First, my environment is:
Ubuntu latest,
IPython, IJulia from github, plus all the dependencies at latest.
IPython is working just great. I get an error when I try to start it with
profile julia:
ipython notebook --profile julia
/usr/local/lib/python2.7/dist-packages/IPython/frontend.py:30: User
Yes, this is great. It does make me wonder if we should have a Subset type
that wraps a vector and an integer indicating the values to include in the
subset. Something like this:
immutable Subset{T} <: AbstractVector{T}
values::Vector{T}
subset::Uint64
end
With this type, you could make combi
This is indeed great. It made me consider if we should have a Subset type that
contains an array and an integer that encodes the subset with its one bits.
That would seems to alleviate the mutation issues that these combinatorics
iterators have – iterating all the subsets of something would lite
This is really great, Doug. Would you be willing to share the raw Rmd source?
Fernando Perez wanted to show what your Rpubs document would look like in the
new native R implementation of IPython.
-- John
On Apr 4, 2014, at 2:17 PM, Douglas Bates wrote:
> In describing to statisticians some o
Unsexy, comprehensive modules are the best kind.
> On Apr 4, 2014, at 7:23 PM, andrew cooke wrote:
>
> An unsexy (but comprehensive!) module for calculating CRCs.
>
> https://github.com/andrewcooke/CRC.jl
>
> Andrew
An unsexy (but comprehensive!) module for calculating CRCs.
https://github.com/andrewcooke/CRC.jl
Andrew
thanks; for the record i found an open issue -
https://github.com/JuliaLang/julia/issues/5222
On Saturday, 29 March 2014 11:46:50 UTC-3, Avik Sengupta wrote:
>
> I think the Pkg.clone(pwd()) is correct, it copies the current directory
> (where travis has cloned your git repo) to the julia packa
Great read. Some great example code with great explanations.
-Jacob
On Fri, Apr 4, 2014 at 5:17 PM, Douglas Bates wrote:
> In describing to statisticians some of the differences in approach between
> R and Julia programming I have used as examples the evaluation of the
> reference distribution
In describing to statisticians some of the differences in approach between
R and Julia programming I have used as examples the evaluation of the
reference distribution for randomization tests comparing means for paired
designs and for unpaired designs. The documents are
http://rpubs.com/dmbate
I think that this is great news for Julia, especially if Dropbox puts
serious engineering effort into this project. Julia is dynamically typed
just like Python, so all the high level optimizations PySton needs to make
a Python LLVM JIT fast will be aplicable to Julia. Both will sit ontop of
L
Once again pythonistas feel the need for
a single high-level-high-performance language:
https://tech.dropbox.com/2014/04/introducing-pyston-an-upcoming-jit-based-python-implementation/
Ok, I'll do that tomorrow.
If you just want a lexically scoped different behavior for / you can do
something like this:
julia> baremodule IntegerDivision
export /
import Base
/(x::Number, y::Number) = Base./(x,y)
/(x::Integer, y::Integer) = Base.div(x,y)
end
julia> baremodule Foo
I don't see that as a viable option either.
I am trying to find out which other operations would do such promotion, but
so far the relevant one seems to be only division, I can handle that.
Now, in terms of hypothetical workarounds, what about having a macro to
override type promotion? Would that
The change you want would be a one-line change:
https://github.com/JuliaLang/julia/blob/master/base/int.jl#L50
However, that change would affect all code using division of integers,
which seems likely to wreak havoc. As others have pointed out, the operator
for truncated integer division is div;
Use set_mode! to change to raw (not-line-buffered) mode first and call
start reading. You may need to invoke process_events too
Or perhaps structure your algorithm to handle ^C and recover gracefully
Or run the code in a separate worker and send progress updates to the
controller
On Friday, Apri
I'm trying to find a way to see if a user has typed anything into the REPL
while a long-running computation takes place so that users can hit a special
key to pause their computation and inspect its intermediate state.
To get started, I wrote this snippet and tried to see if it would count input
I brought this up before and it was mentioned that it would be added
eventually (I think there are some keyword argument machinery updates
forthcoming).
https://github.com/JuliaLang/julia/issues/5230
-Jacob
On Fri, Apr 4, 2014 at 6:35 AM, andrew cooke wrote:
> code_native takes a tuple of typ
On Friday, April 4, 2014 7:19:11 AM UTC-5, Jacques Rioux wrote:
>
> I did Pkg.update(), Pkg.checkout("ZipFile"), Pkg.build("TestImages") in
> various combinations and got the same results, no download.
>
You also need the latest Julia nightly build; part of the fix is in Base.
Yes, it's possible to create multiple OpenGL contexts within the same
application. For example, this is how Qt renders an opengl widget to
an image (see
http://qt-project.org/doc/qt-5.0/qtopengl/qglwidget.html#renderPixmap)
However, I'm pretty sure the opengl function pointers don't depend on
th
So what is the state of things? Still no luck on Windows for me this
morning.
I did Pkg.update(), Pkg.checkout("ZipFile"), Pkg.build("TestImages") in
various combinations and got the same results, no download.
I looked in the presumably updated build.jl file, I still see the same call
to down
code_native takes a tuple of types that are used to find the method to be
compiled / displayed.
But how does those types work for keyword arguments? I am getting "ERROR:
no method found for the specified argument types".
I have tried omitting the types altogether, or specifying them in the ord
It seems like div might do exactly what you want, although I'm not sure
what it does behind the scenes.
julia> A = rand(Uint8, (100, 100));
julia> b = div(A, uint8(2))
100x100 Array{Uint8,2}:
...
Also, it seems like it keeps the type of the numerator, no matter the
(integer) type of the de
Thanks Tim, that makes total sense, though I was thinking of a way of
expressing this in a matlab-ish kind of way.
How about defining a macro to override type promotion, similar to @inbounds?
@nopromote b = A / uint8(2)
I would like something shorter, but we could decide on the exact name later.
This doesn't address your bigger question, but for truncating division by n I
usually use b[i] = div(A[i], convert(eltype(A), n)). For the particular case
of dividing by 2, an even better choice is b[i] = A[i] >> 1.
--Tim
On Friday, April 04, 2014 02:09:24 AM Carlos Becker wrote:
> I've seen pr
Thanks, Isaiah!
--Tim
On Friday, April 04, 2014 02:23:13 AM Isaiah Norton wrote:
> Windows fix committed to base, and new nightlies are up.
>
> Until a new version of ZipFile is tagged, you will need to do
> `Pkg.checkout("ZipFile")` because there appears to be a Julia depwarn
> issue (#6409) tr
EDIT: this is similar
to
https://groups.google.com/forum/#!searchin/julia-users/promotion/julia-users/UivFNQUaIHI/kw5K-6dOsWEJ
in spirit,
though mine is a very typical use case when dealing with images, beyond the
32/64-bit discussion.
Note that I can also do
b = uint8( A / 2 )
but that
I've seen previous posts in this list about this, but either I missed some
of them or this particular issue is not addressed. I apologize if it is the
former.
I have a Uint8 array and I want to divide (still in Uint8) by 2. This is
very handy when dealing with large images: no need to use more
On 04/04/14 06:40, Elliot Saba wrote:
The ones that are the most important, (OpenBLAS, etc...) already use the
max safe levels. Julia herself shouldn't matter that much, if you're
looking for speed.
Thank you for the info.
Sam
On Thu, Apr 3, 2014 at 1:58 AM, Samuele Carcagno mailto:sam.ca
29 matches
Mail list logo
