Besides the performance, type system and multiple dispatch the Julia
language also has several nice conveniences.
1. List comprehension which makes it easy to construct vectors and matrices
of various kinds:
julia [ sqrt(exp(i))-j for i = 1:8, j = 1:8]
8x8 Array{Float64,2}:
0.648721
I think it's safe to say that current infrastructure doesn't support this out
of the box. Long-term, Tobias Knopp's experiment in multithreading (check the
issue tracker) might be of interest.
Alternatively, define your own VectorLite type:
immutable VectorLite{T}
offset::Int
I'm not quite sure why multithreading would be necessary if this can be
done as a read-only and process-parallel task. Bob, you might get more help
if you describe the architecture precisely (large memory multi-core node
vs. cluster of small nodes). How do nodes know that they need to read from
@Isaiah Norton
Sorry, when rewriting my post I forgot to include that I know the
bugreport. By now a patch has been committed, but I don't know if I'll have
the time to set up a build environment for testing it before the next
binary pre-release.
@Tony Kelman
Summing it up: For each of the
There are new pre-release binaries up including the patch. Would be great
if you could test and report back (on the issue thread).
On Sat, May 10, 2014 at 8:14 AM, Klaus-Dieter Bauer
bauer.klaus.die...@gmail.com wrote:
@Isaiah Norton
Sorry, when rewriting my post I forgot to include that I
Julia's still pretty new and under very heavy development. We all agree
with your sentiment that distributing a set of commonly-useful packages
along with the binary installation makes a lot of sense. I think there's an
issue for that, it's on the roadmap as it were - it might be entirely
Hello,
I'm trying to do the following:
@defConstraint(m, t == sum{param[i,j]*x[i,j], (i,j)=con_values}
When I test it in the interpreter I get:
*ERROR: no method
addToExpression(GenericAffExpr{Float64,Variable},Float64,Array{Int64,1})*
with con_values defined as [(1,2), (3,4)] and x defined
Hello colleague,
On Friday, May 9, 2014 11:13:06 PM UTC+2, Steve Kelly wrote:
I am going to be developing some software for 3D printing. For path
planning, we will need to use the clipping algorithm.
Graphics.jl mentions a clip function.
While the patch did not resolve the package manager issue, your response
certainly gives reason to hope :)
Are there thoughts on standard GUI components though? For the data-analysis
use-case having a default GUI environment included beyond REPLs would
certainly help in converting MATLAB users.
How I can get maximum element of a sparse matrix?
Function *maximum(m)* not work for sparse matrix *m*.
At the same time as a sort of two arrays? k = 1. Matrix A=10 × k matrixB
=10 x k
I do not want to connect matrix.
Im sorting the rows of the matrix B and I would like to sort matrix A by
thesame key. Is
it possible to link the matrix without concatenate (hcat) them?
Paul
Once 0.3 is released, we’re going to change the docs to note that DataFrames
isn’t supported for any version of Julia below 0.3.
— John
On May 9, 2014, at 2:15 PM, Dustin Lee qhf...@gmail.com wrote:
FWIW, using .3 seems to have done the trick.
On Friday, May 9, 2014 11:29:00 AM UTC-6, K
Normally, if you want to share the sort order between two arrays, you would
use sortperm(). But in your case, sortperm won't give you the row
permutation. However, you can simply do the same thing that sortrows() is
doing (https://github.com/JuliaLang/julia/blob/master/base/sort.jl#L347-L350
)
Hi Andrew,
There are a couple of ways to make this work. The first is to construct x
such that it is indexed by the tuples (1,2) and (3,4):
@defVar(m, x[con_values] = 0)
@addConstraint(m, t == sum{param[i,j]*x[(i,j)], (i,j)=con_values})
The second is to unpack the tuples and construct x indexed
Also note that by placing @defVar in a loop, you are overwriting the Julia
variable x in every pass through the loop. New variables will be added to
the JuMP model with every call to @defVar, but the only one accessible to
the user will be the last one created (in this case, x[3,4]). I can't
`maximum` works on my fairly recent Julia build. So you can upgrade Julia
or just use the function which is now included with Julia:
```
function maximum{T}(A::SparseMatrixCSC{T})
isempty(A) throw(ArgumentError(argument must not be empty))
m = maximum(A.nzval)
nfilled(A)!=length(A)
This is exactly what I was looking for:
@defVar(m, x[con_values] = 0)
@addConstraint(m, t == sum{param[i,j]*x[(i,j)], (i,j)=con_values})
Also good to know about overwriting variables and where to direct future
questions.
Thanks Joey!
and thank you Andrew for using JuMP!
On Saturday, May 10, 2014 1:40:22 PM UTC-4, Andrew B. Martin wrote:
This is exactly what I was looking for:
@defVar(m, x[con_values] = 0)
@addConstraint(m, t == sum{param[i,j]*x[(i,j)], (i,j)=con_values})
Also good to know about overwriting
And now its fixed for real - please give this a go! README has instructions.
On Thursday, May 8, 2014 10:15:17 PM UTC-4, Iain Dunning wrote:
I've now fixed this by truncating the range of characters to ASCII -
ugly, but it works.
On Wednesday, May 7, 2014 2:16:06 PM UTC-4, Elliot Saba
Hello,
Is there a Julia library allowing to solve ordinary differential equations
with boundary values constraints, similarly to the bvpSolve package for
Rhttp://cran.r-project.org/web/packages/bvpSolve/vignettes/bvpSolve.pdf
?
Just a heads up, I see below error since prerelease+3077. Not hard to fix
temporarily by commenting out the 2 lines with the square root symbol.
Regards,
Rob J. Goedman
goed...@icloud.com
_
_ _ _(_)_ | A fresh approach to technical computing
(_) | (_) (_)
If you want, you can write
type AA
aa
bb
function AA()
this = new()
this.aa = 1
this.bb = 2
this
end
end
But that seems like a lot more typing and constructing incomplete objects
gratuitously is a bad idea, so I wouldn't recommend it.
On May 10, 2014, at 12:12 AM,
I kind of like a lot of those keywords. Seems like a pretty good change for
next April.
On May 9, 2014, at 5:37 PM, Steven G. Johnson stevenj@gmail.com wrote:
To maximize terseness, why not eliminate all the vowels in Julia keywords?
For the most part, they serve no useful purpose.
Good be good to open an issue:
https://github.com/JuliaStats/Distributions.jl/issues?state=open
if you have a GitHub account.
Did this just break today? It seemed to load last
night: http://iainnz.github.io/packages.julialang.org/?pkg=Distributionsver=0.3
On Saturday, May 10, 2014 5:41:48 PM
The sqrt symbol now has unitary operator precedence since today.
On Sat, May 10, 2014 at 6:01 PM, Iain Dunning iaindunn...@gmail.com wrote:
Good be good to open an issue:
https://github.com/JuliaStats/Distributions.jl/issues?state=open
if you have a GitHub account.
Did this just break
Done, but it seems Keno is even faster ...
Rob J. Goedman
goed...@icloud.com
On May 10, 2014, at 3:01 PM, Iain Dunning iaindunn...@gmail.com wrote:
Good be good to open an issue:
https://github.com/JuliaStats/Distributions.jl/issues?state=open
if you have a GitHub account.
Did this
Thanks. This is a lot better in my mind because it gets rid of the
trouble associated with matching the orders of the fields, which can be
a big problem with many fields. I wonder what you mean by constructing
incomplete objects gratuitously is a bad idea.
On 05/11/2014 05:43 AM, Stefan
Is there a tool like Doxygen or Epydoc or javadoc for documenting Julia
code?
I tried to use comprehension in loops but found it somehow slower. In
the following example, the loop in first code is slower than in the
second. Would anyone please explain why?
===
function ffcombs()
[Int8[i1,i2] for i1 in II, i2 in II]
end
combs = ffcombs()
ii = zeros(Int8,2)
for
The first one is creating an array of arrays of Int8s while the other two
appear to just be creating one array. Without more code, it's hard to tell.
On May 10, 2014, at 9:09 PM, cnbiz850 cnbiz...@gmail.com wrote:
I tried to use comprehension in loops but found it somehow slower. In the
Andre,
Sounds like a good solution.
As for the new release; the functionality will be possible, meaning you
could *create* a DateTime (or Timestamp) with microsecond precision, but as
of now, there's no other functionality except perhaps equality and
comparison (i.e. no arithmetic, conversions,
Not yet, but it will happen when someone implements a nice solution.
32 matches
Mail list logo
