On Thursday, July 3, 2014 9:20:55 PM UTC-4, Laszlo Hars wrote:
Looking into Steve's code we see it cheats. Our problem has been that the
Julia console output does not appear on STDOUT, only the results of print()
do. Steve's code evaluates the input expression and then prints it.
The
I really like this new feature.
I was thinking of adding a contour functionality to PGFplots
(https://github.com/sisl/PGFPlots.jl). I think this could be done by
writing the arrays of contour lines as coordinates in a pgfplot
environment. How would you convert the lines
Is it possible to cache the already compiled functions (or code in general)
into files? For instance using a precompile function and a file as output,
or something automatic that keeps in binary files the functions that were
already compiled for the types already used, while the code remains
Just a quick followup: What if identifier wasn't defined in a.jl – what do
I do then? That is, I'd like an abstract, un-implemented template method,
sort of. There'd be no way to import it into b.jl, and therefore no way to
inject its definition into a namespace available to identify. Should I
dropna() is only defined for DataArrays. The individual columns in a
DataFrame are DataArrays, but the DataFrame itself is not. There is a issue
for it https://github.com/JuliaStats/DataFrames.jl/issues/602.
To get a Array out of a DataFrame you are best of building it yourself I
think:
I guess you mean something like this:
julia using Base.Order
julia import Base.lt
julia type MyNewOrdering:Ordering
end
julia f(x::Float64)=x
f (generic function with 1 method)
julia lt(o::MyNewOrdering,x::Float64,y::Float64)=f(x)f(y)
lt (generic function with 9 methods)
julia
I don't think you can create a Function without any methods (yet), but I
think it seems like a useful thing to do.
kl. 10:50:21 UTC+2 fredag 4. juli 2014 skrev Magnus Lie Hetland følgende:
Just a quick followup: What if identifier wasn't defined in a.jl – what
do I do then? That is, I'd
I've also encountered this problem and did indeed solve it by implementing
a method that throws an error. But it would be nice to hear if a better,
more julian, approach exists or could be made available.
Op vrijdag 4 juli 2014 10:50:21 UTC+2 schreef Magnus Lie Hetland:
Just a quick followup:
Hello everyone,
I'm trying to write a function that takes an unknown number of variables
and insert those into another function
function foo(args...)
bar(args)
end
Is there any obvious way of converting the tuple of args into something
callable by bar?
In my example, I'm trying to
Received this from Andrei on my mail but it wasn't posted here:
*Tomas,I realise that your package provides an abstraction for finding the
contours, my question was, once I have them, how can I visualize them.
Matplotlib friends use their own algos for finding the contours in the
first
function foo(args...)
bar(args...)
end
kl. 13:42:29 UTC+2 fredag 4. juli 2014 skrev Oliver Lylloff følgende:
Hello everyone,
I'm trying to write a function that takes an unknown number of variables
and insert those into another function
function foo(args...)
bar(args)
end
Is
Thanks Ivar,
That's indeed the obvious choice for the general case.
However for my example, the function PyPlot.contourf can't take a tuple as
input, so they must be converted from e.g. (:cmap,hot) to cmap=hot.
Hope it makes sense.
Oliver
Den fredag den 4. juli 2014 13.47.10 UTC+2 skrev Ivar
Not sure I understand. Do you want something like
function foo(args...; kwargs...)
bar(args...; kwargs...)
end
kl. 14:04:10 UTC+2 fredag 4. juli 2014 skrev Oliver Lylloff følgende:
Thanks Ivar,
That's indeed the obvious choice for the general case.
However for my example, the function
Sorry Ivar,
It works fine, just needed to sort out which arguments came before and
after the ;
And yes both of your answers are want I'm looking for.
Thanks
Den fredag den 4. juli 2014 14.14.40 UTC+2 skrev Ivar Nesje:
Not sure I understand. Do you want something like
function
Apologies if this is a basic one, but I'm wondering if there's any clean
way to stop output from a worker process being prefixed with from worker
x - and it's a requirement for my project that this can be done whilst
still using standard print/ln syntax in the context of the worker process
Yes, exactly. Sorry I was not especially helpful yesterday – was on my
phone. But you seem to have figured it out. Sorry also that this is not the
most elegant interface. Obviously the longer term is to make passing
functions as arguments more efficient.
On Fri, Jul 4, 2014 at 5:36 AM,
Unfortunately, my happiness was a bit premature. With a simple function
like f(x)=x or f(x)=sin(x), it works, that's inlined, as it seems. If the
function is more complicated, it isn't, and we're back at many seconds, and
memory allocation of gigabytes for sorting an array of 100 elements.
Hi Julia-Users,
I'm trying to parallelize a likelihood calculation in which each step
requires read-only access to several large matrices (10,000 by 3000 in one
case, 3,000 square in another case, etc).
1) If I do a @parallel for, is Julia going to create copies of each of
these matrices?
If I define a parametric type:
type MyType{T}
firstval::T
secondval::T
end
Can specific methods then be written for specific forms of MyType? For
example a method that only worked for MyType containing Int64 as T? I
haven’t tried this yet - I've run into my first real world application of
Le vendredi 04 juillet 2014 à 08:24 -0700, Ben Ward a écrit :
If I define a parametric type:
type MyType{T}
firstval::T
secondval::T
end
Can specific methods then be written for specific forms of MyType? For
example a method that only worked for MyType containing Int64 as T? I
There may be a more efficient way, but this simple sketch for drawing
contour plots with Winston is one way:
using Winston
using Contour
function contour_plot(x, y, z, N)
cs = contours(x,y,z,N)
p = FramedPlot()
for c in cs
level, lines = c.level, c.lines
for line in
shouldn't be using the REPL (console) at all for this sort of thing
Fair point, even though using REPL has advantages: we can always go to the
Julia console to see what has been executed, look at the history, use help,
try out variations of the code directly there... Nevertheless, the thread
Is there any package (or functionality in Base) for solving cubic equations
of the form ax^3+bx^2+cx+d=0 ?
*Pkg.add(Polynomial)*
https://github.com/vtjnash/Polynomial.jl has some documentation.
Nevertheless, the thread was started saying that evaluation of computer
generated code was just one of the potential applications of capturing the
console output. Logging Julia output to a file was another, and there are
several more.
Here we are after 40 posts in this thread and we
Thanks, Steve. I'd never imagined that the solution is that complicated.
Now I have something to digest for a couple of weeks :)
On Friday, July 4, 2014 11:32:13 AM UTC-6, Steven G. Johnson wrote:
Nevertheless, the thread was started saying that evaluation of computer
generated code was
I got sidetracked by a couple of other things, but the parser is now
updated with a bunch of bug fixes. I have a preliminary CSV and graphdot
parser (very reduced from the full grammar). I'm starting to put together
some more comprehensive tests together.
As for speed comparison to DataFrames
I'm not convinced I've understood this thread 100%, but the issue caught my
interest so I went away and had a play. I've put together a gist of a
.juliarc.jl file that ended up being a retake on things already mentioned
here, so it's possible that it's still not the solution you're looking for.
Oh and I forgot, link to the
repository: https://github.com/IainNZ/GraphLayout.jl
On Friday, July 4, 2014 2:39:32 PM UTC-4, Iain Dunning wrote:
I wanted to plot some graphs in pure Julia, but AFAIK there wasn't a graph
layout package in pure Julia yet. So I made one, with an optional
I wanted to plot some graphs in pure Julia, but AFAIK there wasn't a graph
layout package in pure Julia yet. So I made one, with an optional
dependency on Compose.jl for plotting.
Its in METADATA, so Pkg.add(GraphLayout) to get it, and
Pkg.add(Compose) if you want the plotting features.
Heres
This is really cool. I’ve wanted to do this for a while, but never had time.
— John
On Jul 4, 2014, at 11:39 AM, Iain Dunning iaindunn...@gmail.com wrote:
Oh and I forgot, link to the repository:
https://github.com/IainNZ/GraphLayout.jl
On Friday, July 4, 2014 2:39:32 PM UTC-4, Iain
The idea of reading and writing to a REPL by reading and writing unframed
inputs and output over a UNIX-style stream pair is fundamentally broken.
The biggest issue is that the REPL interaction is fundamentally
message-oriented while streams are, by definition, not. There's also the
issue that you
Here is my take for what it is worth as an observer of the Julia language:
I think your second method foo(x::Number) is unreachable because your first
method foo{T:Number}(x::T) is more specific and there are no arguments to
which only the second method is applicable. Having both methods would
Hm. I concur. Perhaps it's a documentation thing, but if Julia wants to be
a general purpose language it needs to have clearly defined and consistent
rules.
On Jul 4, 2014 3:10 PM, David Moon dave_m...@alum.mit.edu wrote:
Here is my take for what it is worth as an observer of the Julia language:
On Fri, Jul 4, 2014 at 3:09 PM, David Moon dave_m...@alum.mit.edu wrote:
Maybe someone should do a PhD thesis on it.
This is essentially what Jeff's PhD thesis is on. You're absolutely right
that it's currently pretty much up to what the implementation does right
now. The trouble with making
You're right, that's very concise, and Julia inlined it, graciously. So it
works, sort of:
julia @time e461(1)
WARNING: the `order` keyword is deprecated, use `lt`, `by` and `rev` instead
.
elapsed time: 66.65448558 seconds (1736533296 bytes allocated)
But then, the warning is not pretty,
Maybe we need to undeprecate the order keyword until we can make function
arguments faster. When I deprecated that, I figured we'd have that soon,
but it hasn't happened yet. In this case, I wonder if the comparison
function is getting inlined in C++ but not in Julia. The function call
overhead
How is it compared to the Graphviz.jl?
http://www.graphviz.org
https://github.com/Keno/GraphViz.jl
On Saturday, July 5, 2014 1:39:32 AM UTC+7, Iain Dunning wrote:
I wanted to plot some graphs in pure Julia, but AFAIK there wasn't a graph
layout package in pure Julia yet. So I made one, with
Hi,
say I want to use the GLM package to run a regression that contains several
categorical variables. My understanding is that I need the equivalent of an
R factor, which is a PooledDataArray. Suppose I take this dataset
using RDatasets
*data = dataset(Ecdat,Benefits)*
and I want columns
Like I said, pure Julia, but otherwise pretty basic. It is the fdp
filter from GraphViz.
On Friday, July 4, 2014 3:42:50 PM UTC-4, Tony Fong wrote:
How is it compared to the Graphviz.jl?
http://www.graphviz.org
https://github.com/Keno/GraphViz.jl
On Saturday, July 5, 2014 1:39:32 AM
If you're just sending unframed data across a pipe, when does the receiving
side evaluate the code?
On Fri, Jul 4, 2014 at 3:38 PM, Laszlo Hars laszloh...@gmail.com wrote:
(Terry) Typing commands in the REPL, I can see output on the screen and
it's also logged in the julia-stdout.txt file.
HI,
in this example, why do I get an InexactError() when showing the fit
summary? (I even converted :age to a Float)
*data = dataset(Ecdat,Benefits)**d2 = DataFrame(age =
convert(DataArray{Float64},data[:Age]), StateUR = data[:StateUR], sex =
convert(PooledDataArray,data[:Sex]))*
*julia
ok - got it. the pool!() function worked after a restart. not sure what
happened.
On Friday, 4 July 2014 20:46:17 UTC+1, Florian Oswald wrote:
Hi,
say I want to use the GLM package to run a regression that contains
several categorical variables. My understanding is that I need the
If you do dump(data) then you see that for that specific dataset :Sex is
already pooled. They way to pool it if it wasn't areadly pooled would be
pool!(data,
:Sex).
On Friday, July 4, 2014 10:46:17 PM UTC+3, Florian Oswald wrote:
Hi,
say I want to use the GLM package to run a regression
This seems like a temporary bug. My most recent build doesn’t behave like this.
Hopefully that means it’s been fixed already.
— John
On Jul 4, 2014, at 1:29 PM, james.dillon.dela...@gmail.com wrote:
Hi All,
Is there a reason why the irrational constant e seems to be rounded to three
That seems good for packages since they already have stable code. Although
for programs in development it would be good something like saving into
files the compilations made by Julia in memory.
Once a function is compiled save the compilation automatically into a file
for the types used, if
Great!! Thanks.
On Friday, July 4, 2014 4:38:08 PM UTC-4, John Myles White wrote:
This seems like a temporary bug. My most recent build doesn’t behave like
this. Hopefully that means it’s been fixed already.
— John
On Jul 4, 2014, at 1:29 PM, james.dill...@gmail.com javascript: wrote:
It doesn't behave that way for me
julia e
e = 2.7182818284590...
julia e == 2.718
false
Did you by accident do something like this by accident?
julia e = 2.718
Warning: imported binding for e overwritten in module Main
2.718
Ivar
kl. 22:29:20 UTC+2 fredag 4. juli 2014 skrev
Oops.
That's exactly what happened.
I was running through
http://www.scolvin.com/juliabyexample/#Strings-Basics
yesterday and forgot I ran these lines.
Sorry about that,
Jim
On Friday, July 4, 2014 4:58:43 PM UTC-4, Stefan Karpinski wrote:
I suspect that Ivar may be right about that
I wrote a script https://gist.github.com/JayKickliter/4c5c70f47be75a20e43e
to change the ID's and dependency paths for all the IPP dylibs. With the
little testing I've done so far, it doesn't appear to break anything. But
if anyone wants to give it a try, please make a copy of the lib folder
Hello,
Built Julia from source on Ubuntu, and was able to 'Pkg.add(ZMQ)' without
any problems.
Julia built (same day) fine on OS X, but when I try to add ZMQ I get:
$ julia
_
_ _ _(_)_ | A fresh approach to technical computing
(_) | (_) (_)|
when does the receiving side evaluate the code?
There are different solutions. E.g. I can send its length information with
the data, and call parse-evaluate when that many bytes arrived. (I coded
this up, and it is working, too). However, the function I posted for
evaluating computer generated
I'm trying to find my way developing Julia code interactively. In other
languages (e.g. Python, R, Octave, etc.) when working on some piece of code
I open a file with it and a console. Each time I change something in the
file, I send that part to console and thus get new state. When I change a
Ah, that fixed it. Thanks!
On Friday, July 4, 2014 8:19:52 PM UTC-4, Iain Dunning wrote:
I broke this, somehow: https://github.com/JuliaLang/julia/pull/7493
Sorry!
On Friday, July 4, 2014 5:58:10 PM UTC-4, Chris Sterritt wrote:
Hello,
Built Julia from source on Ubuntu, and was able to
_ _ _(_)_ | A fresh approach to technical computing
(_) | (_) (_)| Documentation: http://docs.julialang.org
_ _ _| |_ __ _ | Type help() to list help topics
| | | | | | |/ _` | |
| | |_| | | | (_| | | Version 0.3.0-prerelease+2690 (2014-04-20 12:15
UTC)
Lint now checks for redefining mathematical constant.
On Saturday, July 5, 2014 4:29:41 AM UTC+7, Stefan Karpinski wrote:
No problem. Glad we weren't using the wrong value of e! :-)
On Jul 4, 2014, at 5:08 PM, james.dill...@gmail.com javascript: wrote:
Oops.
That's exactly what happened.
I think everybody fully agree with your statement, but apparently this is hard,
and nobody has implemented it yet.
57 matches
Mail list logo
