Hi Kai
Welcome to Julia and thank you for reporting the problem. It is good
practice to include an example that can be copy-pasted into the terminal.
It makes it easier to investigate the problem. Please also provide the
output from versioninfo().
2014-04-14 3:32 GMT+02:00 coolzai
On Mon, Apr 14, 2014 at 1:51 AM, Jeff Waller truth...@gmail.com wrote:
On Monday, April 14, 2014 12:41:05 AM UTC-4, Jameson wrote:
We know that the extremes of verbosity (e.g. C) and conciseness (e.g.
perl) are 'bad'. But why? Because using C generally means writing more
code, which takes
That's pretty cool, but I have a followup.
Does this mean
1) Writing macros is implicitly harder because they don't deal with
(splatted) collections as easy as functions?
2) This is not really important because it hardly is ever done?
3) sprintf should be re-written as a function?
4) sprintf
I would pick (4): sprintf should be modified to deal with it.
My reason: sprintf knows how many arguments it is expecting, so if it
sees a `...` on the last argument, it could easily emit code to
extract the elements that it needs
Also (1) / (2): splatting arguments is something that happens in
I have even heard of a small community naming theirselfs physicists
claiming that mega stands for 1000^2... ;-)
Am Montag, 14. April 2014 01:45:27 UTC+2 schrieb Steven G. Johnson:
Technically, the international standard megabyte (MB) is 1000^2 bytes.
If you want 2^20 bytes, that is a
Thanks! That was very helpful.
Cheers,
Daniel.
On 13 April 2014 07:16, Adrian Cuthbertson adrian.cuthbert...@gmail.comwrote:
Hi Daniel, this worked for me in IJulia...
using PyPlot
using PyCall
img = imread(ada.png);
fig = plt.figure()
ax = plt.Axes(fig,[0,0,1,1])
fig[:add_axes](ax)
People often talk about code concision as if it's a simple case of number
of characters or lines per idea / function / project / whatever. And sure,
SLOC is an indicator of how expressive a language is, but a fundamentally
flawed one because it conflates two distinct issues: (1), the number of
Anybody else get a no method sparse(Int64, Int64, Array{Int64,1}, Int64,
Int64, Function) when you try b = sparse(2,1,-1,10,1), or just me (win64,
bf709c)?
Aside from that, A\full(b) should work in this case.
On Sunday, April 13, 2014 11:40:02 PM UTC-7, Jameson wrote:
IIRC, spare division
This might be the same Haswell Windows OpenBlas threading problem
as https://github.com/JuliaLang/julia/issues/6504
Does inv(rand(3,3)) crash? What about if you run blas_set_num_threads(1)
beforehand?
On Sunday, April 13, 2014 12:55:41 PM UTC-7, Ariel Keselman wrote:
Just installed Julia
yes, inv(rand(3,3)) crushes!
and indeed, using blas_set_num_threads(1) beforehand helps
Thanks!
On Friday, April 11, 2014 03:49:16 PM Ben Racine wrote:
But, when a function really does logically belong to its first argument, I
(sometimes) find myself missing the function namespacing inherent to those
systems. I find myself wanting to do what one can do in R and inject a '.'
into the
This conversation is reminding me of a post from John D Cook a couple years
ago (www.johndcook.com/blog/2012/04/02/why-scipy/) where he said he would
rather do math in a general-purpose language than try to do
general-purpose programming in a math language. He has a point, for
example
Number of tokens might be a more useful quantitative measure of concise
code than number of characters. But there's no simple number that can
substitute for good taste.
On Monday, April 14, 2014 4:19:49 AM UTC-5, Mike Innes wrote:
People often talk about code concision as if it's a simple
Up for grabs issue: https://github.com/JuliaLang/julia/issues/6520. If
anyone is interested in doing a bit of metaprogramming, this is a good
opportunity.
On Mon, Apr 14, 2014 at 2:47 AM, Jameson Nash vtjn...@gmail.com wrote:
I would pick (4): sprintf should be modified to deal with it.
My
The mahalanobis distance?
http://stats.stackexchange.com/questions/62092/bottom-to-top-explanation-of-the-mahalanobis-distance
(habanero cookies answer)
Forgive me, but this is a discussion thread :-).
On Mon, Apr 14, 2014 at 4:33 PM, Jason Merrill jwmerr...@gmail.com wrote:
Number of
On Monday, April 14, 2014 10:58:15 AM UTC-4, Stefan Karpinski wrote:
Up for grabs issue: https://github.com/JuliaLang/julia/issues/6520. If
anyone is interested in doing a bit of metaprogramming, this is a good
opportunity.
Oh! Me, I mean I'm saying all these things, I should also
The macros are defined here:
https://github.com/JuliaLang/julia/blob/master/base/printf.jl#L750-L784
It should be a matter of detecting that there's a splat happening – keep in
mind that splats can be mixed with other arguments – and emitting the
appropriate code in the macro. It may be possible
On Sunday, April 13, 2014 9:30:36 PM UTC-4, Sheehan Olver wrote:
The pyplot gui command didn't work for me (and pyplot doesn't work from
the command line). Maybe I just need to update my matplotlib.
Perhaps you are using a Mac, and don't have Matplotlib with a working Qt
graphics
On Monday, April 14, 2014 11:36:40 AM UTC-4, Stefan Karpinski wrote:
The macros are defined here:
https://github.com/JuliaLang/julia/blob/master/base/printf.jl#L750-L784
Do I need to git the most up-to-date source for Julia as well and make a
language development environment? What's
You can work from a binary installation to test your changes locally, but
you'll need to rebuild the system image for changes to Julia code in base
to take effect. Last I checked this detail is not explicitly documented
anywhere, adding a sentence or two to CONTRIBUTING.md about this would be a
The mahalanobis distance?
http://stats.stackexchange.com/questions/62092/bottom-to-top-explanation-of-the-mahalanobis-distance
(habanero cookies answer)
So here's a conjecture. The mahalanobis distance of all golfed programs
solving the same problem for all equivalently expressive
http://en.wikipedia.org/wiki/Kolmogorov_complexity
On Apr 14, 2014, at 12:08 PM, Jeff Waller truth...@gmail.com wrote:
The mahalanobis distance?
http://stats.stackexchange.com/questions/62092/bottom-to-top-explanation-of-the-mahalanobis-distance
(habanero cookies answer)
So here's
The AST equivalent of code_llvm is code_lowered.
On Mon, Apr 14, 2014 at 3:08 PM, Jeff Waller truth...@gmail.com wrote:
The mahalanobis distance?
http://stats.stackexchange.com/questions/62092/bottom-to-
top-explanation-of-the-mahalanobis-distance
(habanero cookies answer)
So here's a
El lunes, 14 de abril de 2014 04:42:47 UTC-5, Tony Kelman escribió:
Anybody else get a no method sparse(Int64, Int64, Array{Int64,1}, Int64,
Int64, Function) when you try b = sparse(2,1,-1,10,1), or just me (win64,
bf709c)?
I get the same on Mac, Commit aadabde* (2014-04-06 20:48 UTC)
Miles can speak to the design, but JuMP provides quite a bit more than just
AD. It gives a user-friendly modeling environment like Pyomo or Yalmip, or
the .mod layer of AMPL which is neither open-source nor a modern
general-purpose programming language. Miles and Iain have a very
interesting
In Python I either use models written in AMPL, or in pure Python models
with derivatives computed by ADOL-C or CppAD (the latter being limited to
dense derivatives for now because the Python interface hasn't been updated
in a while). At least in Python, trips in and out of ADOL-C almost count
At least in Python, trips in and out of ADOL-C almost count for nothing
as they're just passing pointers around.
This might be the case in Julia as well. But I think you'll agree that
ADOL-C and friends are much more opaque and less hackable than Julia code.
At least on OSX, both can be
On Monday, April 14, 2014 6:15:26 PM UTC-7, Tony Kelman wrote:
At least in Python, trips in and out of ADOL-C almost count for nothing
as they're just passing pointers around.
This might be the case in Julia as well. But I think you'll agree that
ADOL-C and friends are much more opaque
On Monday, April 14, 2014 05:30:02 PM Dominique Orban wrote:
At least in Python, trips in and out of ADOL-C almost count
for nothing as they're just passing pointers around.
That still implies a function call; in Python you might not notice because
most things are triggering function calls
Sure, they're opaque but I'm saying that they're opaque for a reason. AD
is an entire field of research. As is optimization.
I don't entirely understand the details, but there are some features of
Julia as a language that allow you to do some truly new things with respect
to AD (and maybe
It seems like this discussion is heading down the rabbit's hole, but let me
address the original question.
AMPL is certainly the right choice from a maturity perspective, but AMPL
itself being closed source and the AMPL solver library being written in
seemingly intentionally obfuscated C
I need to do some basic interpolation and think Grid.jl should provide all
the functionality I need, but I can’t quite get it to work for me.
I am essentially looking to do something like what is described for this
form of the interp1 matlab function (copied and pasted excerpt from
Jake,
Thank you for your work and the comprehensive answer.
g
On Friday, April 11, 2014 9:01:16 AM UTC-7, Jake Bolewski wrote:
Hi Gexarcha,
I'm the author of the OpenCL package for Julia. Although things have
stalled lately do to other commitments, I think we are slowly building a
33 matches
Mail list logo
