It is certainly not too early. It's only a matter of having enough interest
and someone hosting it to pull it off. We should certainly check with
Forio, if there is enough interest in San Francisco.
-viral
On Tuesday, April 29, 2014 9:24:38 AM UTC+5:30, Ted Fujimoto wrote:
Hi all,
I've
On Tue, Apr 29, 2014 at 11:30 AM, Viral Shah vi...@mayin.org wrote:
It is certainly not too early. It's only a matter of having enough interest
and someone hosting it to pull it off. We should certainly check with Forio,
if there is enough interest in San Francisco.
Hey Viral, if you are still
Another point about coding style. You use the `@inbounds` macro without
explicitly checking bounds first. That might be acceptable for benchmarking
and testing, but when you share your code online I think it is important to
be aware of the dangers if this kind of pattern is used in production
W dniu 2014-04-28 22:34, Tim Holy pisze:
Read as CSV, and write as HDF5?
--Tim
On Monday, April 28, 2014 11:24:06 AM paul analyst wrote:
How to convert csv big file (utf8) to bin format ?
csv file:
12356.5,12455.5,12545.4,124784.2
12564.2,25488.01,25544.6,125847.2
...
How to read new file
I'm using text/julia at the moment. That's following CodeMirror's
standard of using e.g. text/x-python, but with the x dropped because it's
been deprecated.
I'm not sure that packages should export main() functions – that's going to
complicated things when a user wants to require CRC and define their own
main().
How about leaving it unexported and using julia -e using PKG;
PKG.main(ARGS)?
On Sunday, 27 April 2014 16:12:41 UTC+1, andrew cooke
I just saw another part of your message, I am wondering also why memory
consumption is so high.
El martes, 29 de abril de 2014 11:31:09 UTC+2, Carlos Becker escribió:
This is likely to be because Julia is creating temporaries. This is
probably why you get increasing memory usage when
Besides Julia internals, I suppose there is memory overhead in terms of the
structure holding the array itself (when temporaries are created).
I suppose an array isn't just the size in bytes of the data it holds, but
also information about its size/type/etc. Though I doubt that would add up
to
That overhead seems constant, beyond a single temporary. So I dont suppose
there is that much to be worried about, unless you are using many small
arrays.
julia 800-sizeof(rand(2))
784
julia 944-sizeof(rand(20))
784
On Tuesday, 29 April 2014 10:40:10 UTC+1, Carlos Becker wrote:
Besides
By processes you mean other programs that can't read HDF5? Then you have to
pick some binary format that all of your programs can handle---there is no
such thing as a binary CSV file, CSV is by definition an ascii format.
--Tim
On Tuesday, April 29, 2014 10:08:23 AM Paul Analyst wrote:
W dniu
Avik: this is actually the situation I'm in. My tight inner loops
involve elementwise operations on many small arrays, so the runtime cost
of using vectorized code is enormous. Using the macros provided by
Devectorize.jl only somewhat alleviates this problem, so I ended up
hand-writing
A habitual MATLAB user, I've been trying out Julia over the last two weeks
to see if it might be a suitable replacement. I want something that is as
fast to develop using, but has much faster runtime. Perhaps I'll write
about my general thoughts in another post. However, in this thread I want
On Wednesday, 4 September 2013 16:29:28 UTC+2, Isaiah wrote:
Maybe this is less useful, but the basic/demo version (by the author
himself) is public domain:
https://www.lri.fr/~hansen/barecmaes2.py
And the Apache commons Java version claims to be Apache licensed, though
it is explicitly
Sorry for nitpicking, but point 3 is wrong, and it might cause trouble in
the following discussion.
f{T:Real}(a::Array{T})
Matches any array with a element type that is a subtype of Real (eg.
Integer[1,2,BigInt(44)] and Real[1, 3.4])
I have had trouble with this too, but now that I somewhat
Do you find yourself dealing with heterogeneous arrays often? It might be
useful to post some examples where this comes up to the list.
Julia compiles specialized versions of functions for the concrete types they
are called with at run time, so you should usually think of the types in
function
On Tuesday, April 29, 2014 3:48:52 PM UTC+1, Ivar Nesje wrote:
Sorry for nitpicking, but point 3 is wrong, and it might cause trouble in
the following discussion.
f{T:Real}(a::Array{T})
Matches any array with a element type that is a subtype of Real (eg.
Integer[1,2,BigInt(44)] and
On Apr 29, 2014, at 8:28 AM, Oliver Woodford oliver.woodf...@gmail.com wrote:
Are you saying that f{T:Real}(a::Array{T}) covers both homogeneous and
heterogeneous arrays, whereas f(a::Array{Real}) only covers heterogeneous
arrays? If that's the case it strikes me as just as confusing.
It might be easier to understand if we start by stripping away the
constraints and the function syntax and look just at the array type.
Array{Real} is a concrete type. It's an array whose elements are all
subtypes of the abstract type Real.
Array{T} is a family of types. It describes a whole
On Tue, Apr 29, 2014 at 11:38 AM, John Myles White johnmyleswh...@gmail.com
wrote:
Array{Any} is also a single type.
Not to nit-pick, but there's a second type parameter, so it's actually
still abstract. But Array{Any,1} is a single type with no subtypes, which I
think is what you meant.
On Tuesday, April 29, 2014 4:38:59 PM UTC+1, John Myles White wrote:
On Apr 29, 2014, at 8:28 AM, Oliver Woodford
oliver@gmail.comjavascript:
wrote:
Are you saying that f{T:Real}(a::Array{T}) covers both homogeneous and
heterogeneous arrays, whereas f(a::Array{Real}) only covers
The real root issue here is parametric
variancehttps://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science).
Julia has opted for parametric invariance – i.e. that P{A} : P{B} only if
A = B – which is what James mentions in his StackOverflow answer. The
wikipedia page does a
On Tuesday, April 29, 2014 4:41:52 PM UTC+1, Patrick O'Leary wrote:
It might be easier to understand if we start by stripping away the
constraints and the function syntax and look just at the array type.
Array{Real} is a concrete type. It's an array whose elements are all
subtypes of the
On Tuesday, April 29, 2014 4:53:05 PM UTC+1, Matt Bauman wrote:
I use cell arrays very often in Matlab, too, but I've found that I often
don't really need to even worry about the distinction in julia. Square
brackets will constrain the types as much as possible, and if it's not
Quick question, folks:
Does f(x::Array{Union(Int8,Int16)}) mean that x must be all Int8 or all
Int16 (homogenous), or each element can be either Int8 or Int16
(heterogeneous)?
If the latter, then would I need to
use f(x::Union(Array{Int8},Array{Int16})) to achieve the former?
If so, then
In my experience, I can think of a single time when having an array of a
specific abstract type was useful (how multiple Period arithmetic is
handled:
https://github.com/karbarcca/Dates.jl/blob/master/src/periods.jl#L88).
Almost always, I'm concentrating on making sure Arrays I work with are of a
Suppose the types that you want existed. Let's call them ConcreteArray, and
Cell.
ConcreteArray gives the guarantee that all of it's elements are stored directly
with a fixed stride.
Can you give some examples of functions that would use these in their type
signature?
Thinking about it some more, the big problem with covariance is that it
forces the confusion of two distinct meanings of P{B} for abstract B:
1. The concrete instance of type P with actual parameter type B.
2. The abstract type including all instances P{A} where A : B.
If P{B} meant the
On Tuesday, April 29, 2014 5:13:08 PM UTC+1, Jacob Quinn wrote:
In my experience, I can think of a single time when having an array of a
specific abstract type was useful (how multiple Period arithmetic is
handled:
https://github.com/karbarcca/Dates.jl/blob/master/src/periods.jl#L88).
On Tuesday, April 29, 2014 5:14:01 PM UTC+1, Jason Merrill wrote:
Suppose the types that you want existed. Let's call them ConcreteArray,
and Cell.
ConcreteArray gives the guarantee that all of it's elements are stored
directly with a fixed stride.
Can you give some examples of functions
On Tue, Apr 29, 2014 at 12:13 PM, Oliver Woodford oliver.woodf...@gmail.com
wrote:
Quick question, folks:
Does f(x::Array{Union(Int8,Int16)}) mean that x must be all Int8 or all
Int16 (homogenous), or each element can be either Int8 or Int16
(heterogeneous)?
If the latter, then would I
Perhaps the Julian curly-brace array syntax makes Any[] arrays seem special
(especially to Matlab converts), when they're really not all that
different. Yes, users need to learn that Array{Real} is not a supertype of
Array{Int}. But that's a common theme throughout Julia's type system, and
Any rough estimate on what soon is?
...not trying to push, of course. We're trying to lock in on a version of
Julia and if soon is like 2 days, this may affect what we decide to do.
On Monday, April 28, 2014 2:33:26 PM UTC-4, Isaiah wrote:
There is no official schedule yet. It has been
In R there are implementations of both the minimal CMA-ES code (also called
bareCMAES or pureCMAES, the Wikipedia version) and an adaption of the
Matlab code in parts. We have done lots of tests with these
implementations. It turned out in too many cases that the implementations
are unstable
On Tuesday, April 29, 2014 9:29:56 AM UTC-7, Oliver Woodford wrote:
On Tuesday, April 29, 2014 5:14:01 PM UTC+1, Jason Merrill wrote:
Suppose the types that you want existed. Let's call them ConcreteArray,
and Cell.
ConcreteArray gives the guarantee that all of it's elements are stored
Hi all,
suppose i have a custom type
julia type mytype
x :: Float64;
# constructor
function mytype()
new(1.1)
end
end
julia my=mytype()
mytype(1.1)
and I want to modify x many times, always keeping track of the most recent
state. suppose x is a
Is there an built-in way to convert a vector to a column matrix without
transposing twice?
I can make a matrix into a vector with vec or squeeze, but I can't see a
simple way to convert from a 1d array to a 2d without initialising it,
calling reshape and having to measure the size.
I've put
Nothing has really been happening in Cambridge more often than those. What
exactly is a hack night?
a =rand(5,5)
b=slicedim(a,2,1,3,5)
ERROR: no method slicedim(Array{Float64,2}, Int64, Int64, Int64, Int64)
how to choose from matrix a column 1,3,5 wihout while etc.?
Paul
Hi. When you cross-post the same question to both the mailing list and as a
new Github issue, it would help people keep track of things if you could
post links from one to the other
- https://github.com/JuliaLang/julia/issues/6687
As I wrote on the Github issue, this is due to the LibCURL.jl
b = a[:,[1; 3; 5]]
or if they are always going to be evenly spaced indexes like that, you can
use a range:
b = a[:, 1:2:5]
On Tuesday, April 29, 2014 1:23:36 PM UTC-5, paul analyst wrote:
a =rand(5,5)
b=slicedim(a,2,1,3,5)
ERROR: no method slicedim(Array{Float64,2}, Int64, Int64, Int64,
Yet another point of view - incidentally the one that convinced me that
Julia has got this right, while most others don't - is the fact that in the
grand scheme of things, JIT is *cheap *while working with types that might
have subtypes is *really painful* if you don't want to compromise with
Function values are passed by
referencehttp://docs.julialang.org/en/latest/manual/functions/#argument-passing-behavior,
so you can just add to my.x inside your function:
julia myadd = function(z,my::mytype)
my.x += z
end
julia my = mytype()
mytype(1.1)
julia myadd(3.0,my); my
It'd be nice to allow up to one missing dimension in the dimension tuple,
and calculate it automatically. Something like this works nicely, where
the missing dimension is specified by ():
function Base.reshape{N}(a::AbstractArray, dims::NTuple{N,Union(Int,())})
missing_mask = [isa(x,Tuple)
Oops: prod, not sum:
function Base.reshape{N}(a::AbstractArray, dims::NTuple{N,Union(Int,())})
missing_mask = [isa(x,Tuple) for x in dims]
sum(missing_mask) == 1 || throw(DimensionMismatch(new dimensions
$(dims) may only have up to one omitted dimension))
sz = length(a) /
On Tuesday, April 29, 2014 11:43:03 AM Tomas Lycken wrote:
Say I have a variable x, and I want to make sure that it's an array
of real numbers that are all of the same type, but I don't care which one.
Can I say x::Array{T:Real} as a type assertion?
function f{T:Real}(x::Array{T})
...
end
Yes, when declaring function arguments, which I believe fall under case 2.
in this
listhttp://docs.julialang.org/en/latest/manual/types/#type-declarations.
Is it possible for a usage of `::` that falls under category 1?
// T
On Tuesday, April 29, 2014 9:07:08 PM UTC+2, Tim Holy wrote:
On
Excellent points Tomas. I think this would be particularly helpful for
those coming from Java. Perhaps some of your comments could be worked into
the manual or FAQ somewhere.
-Jacob
On Tue, Apr 29, 2014 at 2:43 PM, Tomas Lycken tomas.lyc...@gmail.comwrote:
Yet another point of view -
(BTW, the Cambridge meetup is great, everyone in the area should come!)
On Tuesday, April 29, 2014 2:13:31 PM UTC-4, Iain Dunning wrote:
Nothing has really been happening in Cambridge more often than those. What
exactly is a hack night?
On Tue, Apr 29, 2014 at 2:13 PM, Iain Dunning iaindunn...@gmail.com wrote:
Nothing has really been happening in Cambridge more often than those. What
exactly is a hack night?
All I had in mind was an informal meeting where there is work on something
julia for the evening (an hour or two or
I've been busy, so the cajun meetups have slipped somewhat from the
original monthly plan. I can certainly advertise on julia-cajun if
someone wants to put together such a hack night. I believe Cameron
mentioned to me May 9 as a possibility.
Thanks,
Jiahao Chen
Staff Research Scientist
MIT
Ah, this was tried once before to get included in Base, and it was turned
down. Colon makes much more sense here (and works better, too).
https://github.com/JuliaLang/julia/pull/4263
One final iteration (I'll see if we can get this version into Base):
function
Le mardi 29 avril 2014 à 11:51 -0400, Stefan Karpinski a écrit :
[...]
1.
The explicit distinction between A – the actual parameter type of x –
and B, which is simply an upper bound on A, becomes clearer in
situations like this:
frob{A:B}(x::P{A}, y::A)
Hi all. Just curious for this:
a1 = Array(Int, 1)
a1[1] is 0
a2 = Array(Int,1)
and a2[1] is always 0.
...
once, and only once, i get
julia a = Array(Int,1)
1-element Array{Int64,1}:
4294967296
and a[1] was 4294967296
why that value? I was using Julia 0.2.0
Regards
You're just getting dirty memory, which has random values in it.
-- John
On Apr 29, 2014, at 3:10 PM, Renoir rex...@gmail.com wrote:
Hi all. Just curious for this:
a1 = Array(Int, 1)
a1[1] is 0
a2 = Array(Int,1)
and a2[1] is always 0.
...
once, and only once, i get
julia a =
Renoir,
Array(Int, 1) is a constructor for an uninitialized array. The contents of
an uninitialized array are just what is in memory at those addresses.
On Tuesday, April 29, 2014 6:10:47 PM UTC-4, Renoir wrote:
Hi all. Just curious for this:
a1 = Array(Int, 1)
a1[1] is 0
a2 =
I've now merged this fix, and released it as part of v0.4.2 (and thanks to
Miles for merging my PR on METADATA.jl!). If you run Pkg.update() you
should find the bug is now fixed.
(Other) Miles
On Saturday, 26 April 2014 18:22:38 UTC+1, Miles Lubin wrote:
Hi Ohad,
There was indeed a bug in
Uninitialized, i forgot this. Thx.
Il giorno mercoledì 30 aprile 2014 00:17:14 UTC+2, Jake Bolewski ha scritto:
Renoir,
Array(Int, 1) is a constructor for an uninitialized array. The contents
of an uninitialized array are just what is in memory at those addresses.
On Tuesday, April 29,
Creating sparse arrays seems exceptionally slow.
I can set up the non-zero data of the array relatively quickly. For
example, the following code takes about 80 seconds on one machine.
vec_len = 70
row_ind = Uint64[]
col_ind = Uint64[]
value = Float64[]
for j = 1:70
for k =
58 matches
Mail list logo
