Out of curiosity, what happens if you take the compute! function out of main
and pass ratios (and any other needed variables) as another argument?
--Tim
On Monday, April 06, 2015 09:14:24 PM Adam Labadorf wrote:
Thanks for the replies. I took your suggestions (and reread the scope
section of
What OS is this on? Your best bet here, if you can, is to reproduce this in
the terminal REPL (open a terminal repl command) and file an issue on
Images.jl.
On 3 April 2015 at 00:49, will ship willshipdes...@gmail.com wrote:
So have discovered weird behaviour in Juno LightTable (which I have
In Julia v0.4 its possible to do the following
*immutable Foo{a} end*
*Foo{0.1}()*
*Foo{0.2}()*
Is it bad performance-wise if the parameter a takes many different values?
I.e. what's the growth in complexity of Julia as the number of types
increases? (Ignoring the cost of recompiling
Can you post your csv file so we can actually run the program?
On Tuesday, April 7, 2015 at 6:21:18 AM UTC+2, Adam Labadorf wrote:
Thanks for the replies. I took your suggestions (and reread the scope
section of the docs) and am still experiencing the gc creep. Below is the
complete
I don't think there's an easy way to do it, unfortunately: if someone
really wants to tackle it, the way forward would probably be through
Mathematica's LibraryLink:
http://mathematica.stackexchange.com/q/8438
s
On Tuesday, 7 April 2015 11:31:16 UTC+1, Sheehan Olver wrote:
I would be very
On Tue, 2015-04-07 at 06:14, Adam Labadorf alabad...@gmail.com wrote:
Thanks for the replies. I took your suggestions (and reread the scope
section of the docs) and am still experiencing the gc creep. Below is the
complete program, with the notable changes that I wrapped the main
I've used LibraryLink to call Ipopt from Mathematica but haven't succeeded
in calling
Julia from C under Windows, which would be required to use LibraryLink.
On Thursday, April 2, 2015 at 9:25:04 AM UTC-4, Frank Kampas wrote:
Has anyone been able to call Julia from Mathematica?
Greetings all,
I've quite taken to the short-circuit evaluation idiom. I just have a quick
question about its behavior. Why does
boolexpr boolvar = false
throw an error (syntax: invalid assignment location), but
boolexpr (boolvar = false)
work just fine? The documentation
Le mardi 07 avril 2015 à 06:05 -0700, David Gold a écrit :
Greetings all,
I've quite taken to the short-circuit evaluation idiom. I just have a
quick question about its behavior. Why does
boolexpr boolvar = false
throw an error (syntax: invalid assignment location), but
boolexpr
spawn() and readandwrite() are documented as being variants of run() which
do not block the command line. yet in an @async, run() seems to yield to
other tasks. to wit:
# bar prints first because it's the first task
julia @sync begin
@async println(bar)
@async (run(`sleep
I moved compute! out of the main function and pass the ratios as you
suggested and the performance is a bit better but I still notice the gc
time increasing albeit more slowly, new code below. The csv I'm using is
available at
It's simply an operator precedence[1] issue. The assignment operator is
one of the lowest precedence operations in Julia[2], so your expression is
getting parsed as (boolexpr boolvar) = false. That's why the
parentheses are required.
1. https://en.wikipedia.org/wiki/Order_of_operations
2.
Hi Kristoffer,
I’ll certainly will keep your 2 files around if you don’t mind, at least until
I have some time to try the 2 existing packages. WriteVTK.jl seems closer to
your bootstrap files.
Regards,
Rob J. Goedman
goed...@mac.com
On Apr 6, 2015, at 1:24 PM, Kristoffer Carlsson
You should make sure that you really need the specialization based on that
float parameter value.
Make Result an immutable:
immutable Result
pvalue::Float64
i::Int64
j::Int64
end
that way the numbers are stored in the S array directly and all its
memory is preallocated. Otherwise S just holds pointers to the Results
objects. gc time is only 2% for me then (but I didn't run it for
I would say that recompiling code for each new type (each new combination of
types that a function is called with) is the main performance cost, but that
could be quite substantial if you use many different parameter values or
functions with many arguments whose types can vary independently.
Yes, that gives a massive improvement and I see the same gc behavior you
got. I could notice the gc increasing slowly after just watching for a
minute or two, and that seems to have stopped now. I'll know for sure when
I run the whole thing and will report back.
Thanks so much to all of you
Thank you, Milan Matt. That makes a lot of sense. Probably this will only
be an issue with folks such as myself who are new to the notion of operator
precedence. So I don't know if it warrants an addition to the docs.
D
In 0.3 it's not possible in 0.4 this works:
julia type A{T,P}
a::T
end
julia typealias B{T} A{T, 1}
A{T,1}
julia call{T}(::Type{B}, a::T) = B{T}(a)
call (generic function with 936 methods)
julia B(1.0)
A{Float64,1}(1.0)
See https://github.com/JuliaLang/julia/pull/8712 for
Hello All,
I find the following behavior a bit non-intuitive. IMHO, if addition of
finally block changes the default behavior provided by the omitted catch
block, we should force the user to declare a catch block.
# Version 0.4.0-dev+4160 (2015-04-06 03:40 UTC) Commit 8fc5b4e* (1 day old
Unicode only supports some (fairly arbitrary) subscripts and superscripts. I
doubt that pi is one of them.
On Apr 7, 2015, at 1:13 PM, Vitor Aguiar vitor@gmail.com wrote:
Can also do
\Theta\_\pi
?
On Wednesday, August 20, 2014 at 12:10:15 PM UTC-3, John Myles White wrote:
There is currently no way to do what you want, but I'd like to add this
feature. I'm just unsure what the best/simplest API would be.
Cold you open an issue about it in ArgParse.jl
https://github.com/carlobaldassi/ArgParse.jl in the meanwhile?
On Saturday, April 4, 2015 at 11:50:03 PM UTC+2,
Unfortunately the documentation is not really great yet, but
https://github.com/rened/FunctionalData.jl#computing-map-and-friends-details
is a collection of functions that could be used for this, with optional
in-place operations and parallel processing. It is basically a generalization
of
Can also do
\Theta\_\pi
?
On Wednesday, August 20, 2014 at 12:10:15 PM UTC-3, John Myles White wrote:
Try typing the sequence \_1TAB
— John
On Aug 20, 2014, at 8:08 AM, Douglas Bates dmb...@gmail.com javascript:
wrote:
I find it convenient to use identifiers like
julia a₁ = 2
Comprehensions may be what you are looking for:
http://docs.julialang.org/en/latest/manual/arrays/#comprehensions.
For your example,
julia v = [1, 2, 3, 4] # Set the vector v
4-element Array{Int64,1}:
1
2
3
4
julia A = [ j.*v[i] for j in 1:4, i in 1:length(v) ] # Create a 2d array A
where
Glad that helped! (Also not all immutable are inlined that way, only
when isbits==true)
Maybe the gc time increased because it had to look at more and more
objects as more and more Result instances were created?
On Tue, 2015-04-07 at 18:24, Adam Labadorf alabad...@gmail.com wrote:
Yes, that
Let's say I have a type parameterized with two other types and I do the
following:
type A{T,P}
a::T
end
typealias B{T} A{T, 1}
B(1.0) # Error
B{Float64}(1.0) # Works
Is there anyway you could write the code so that the T type is inferred
from the argument to the call to B.
Best
Opened issue 12 https://github.com/carlobaldassi/ArgParse.jl/issues/12.
Thanks,
--Peter
On Tuesday, April 7, 2015 at 10:51:38 AM UTC-7, Carlo Baldassi wrote:
There is currently no way to do what you want, but I'd like to add this
feature. I'm just unsure what the best/simplest API would be.
I agree, seems only consistent that try without a catch should catch nothing.
Thanks for the note. If I figure out a good way to get it to run (but
that's far from assured), I'd be happy to put in a pull request.
Chris
On Monday, April 6, 2015 at 12:29:14 PM UTC-5, Patrick O'Leary wrote:
This hasn't been updated in a while, so it's probably just broken (I don't
think
I think for the moment you either need to include it in the REQUIRE file,
or not and make the user to install gpu-related bits themselves.
IMO This is not ideal...
Another example is Markdown: you have to include that in the REQUIRE, even
though Base.Markdown is included in 0.4. This means you
The code ran to completion at least 17x times faster than the equivalent
python implementation. Out of curiosity, I collected the elapsed time and %
spent in gc statistics from @time and plotted them from across the whole
run:
This was run on a shared cluster so the spikes in time are
Hello,
as far as I understand the Arrays that we often use when working with julia
are dynamic arrays since they support the operations of adding or removing
elements (through push!/unshift! and pop!/shift! methods).
In view of this, I am wondering about what is the most primitive Array type
in
Very good to know. Thank you for the clarification!
On Tuesday, April 7, 2015 at 5:10:43 PM UTC-4, Milan Bouchet-Valat wrote:
Le mardi 07 avril 2015 à 10:56 -0700, David Gold a écrit :
Comprehensions may be what you are looking for:
The code ran to completion at least 17x times faster than the equivalent
python implementation. Out of curiosity, I collected the elapsed time and %
spent in gc statistics from @time and plotted them from across the whole
run. This was run on a shared cluster so the spikes in time are
Does anyone know if there's a Holt-Winters Double-Exponential Smoothing
module for Julia?
It's available in
R: http://astrostatistics.psu.edu/su07/R/html/stats/html/HoltWinters.html
Le mardi 07 avril 2015 à 10:56 -0700, David Gold a écrit :
Comprehensions may be what you are looking for:
http://docs.julialang.org/en/latest/manual/arrays/#comprehensions.
For your example,
julia v = [1, 2, 3, 4] # Set the vector v
4-element Array{Int64,1}:
1
2
3
4
julia A =
The current problem is
f=Fun(x-x^2,Chebyshev(Interval(a,b)))
represents a function on [a,b] as type Fun{Float64,Chebyshev}. But sometimes
one needs to convert numbers to functions a la
convert(typeof(f),5)
e.g., as part of creating the vector [f,5]. Since the
Hi all,
Couldn't find any decent password hashing algorithms so I decided to port a
Python implementation of PBKDF2 as an exercise.
Any ideas on how to improve the code are most welcome; me and Julia are
still getting to know each other...
run() blocks *its task* until the separate process it invokes completes.
If there are other tasks which can proceed it will yield to them as you
have shown below.
But if you just do run() in the REPL its the same task as the command line,
so it blocks the command line.
Note that running a
On Wednesday, April 8, 2015 at 6:10:07 AM UTC+10, Toivo Henningsson wrote:
I agree, seems only consistent that try without a catch should catch
nothing.
There are four combinations of the current syntax
1. try end
2. try catch end
3. try finally end
4. try catch finally end
but there are
When overwriting Base.show for an Array of custom_type REPL eval() uses the
old version of Base.show with only partial delegation/dispatch; which is
cumbersome when working with large arrays of records in REPL.
Is this the expected behaviour, and there is a different approach to use
REPL +
I think you are right that this is deliberate, but I also think that
making catch and finally orthogonal to each other should trump such case by
case optimizations. It would allow a simpler mental model of the language.
If you want the current behavior of
try end
you can use
try catch end
and
43 matches
Mail list logo
