The main sticking point I've had so far is getting data from the radio in
realtime. What I would like to do is start up a second thread to
constantly read data and store it into a buffer, but since Julia doesn't
have multithreading yet I suppose I'll need to travel down the
multiprocessing road;
Hi All,
I recently had to rebuild julia on a machine without gfortran installed,
and noticed some of the libraries it downloads are compiled with gfortran
by default.
Has anyone looked at building julia with ifort? It would be nice to use
intel's implementation of the blas and lapack in the
There are some options in the makefiles for using MKL blas and lapack along
with gfortran, though I don't know how often that gets tested. There are a
number of open issues on this
(https://github.com/JuliaLang/julia/issues/3902,
https://github.com/JuliaLang/julia/pull/5363,
(1) and (2) do equivalent operations at runtime, they only differ in
how the memoization is implemented (dict vs. global variable). Neither
requires an OpenGL context at compile time, making them roughly
equivalent
(3) caches information derived from the OpenGL context, which may be
I agree that there are just too many different popular definitions of
between vectors/matrices/arrays to just pick one arbitrarily.
Also, another reason not to define A B as elementwise: , when it is
implemented, is expected to correspond to at least a partial order. In
particular, it is
Can't it be done with a pipe? What I mean is, use the radio API to get the
data and store in a pipe. In julia, the main process would read from the
pipe and run your algorithms on it. If necessary, it could hand the data to
another process.
I've done something similar to read data from a sound
I agree that we should focus on getting something that works, and only then
focus on making it good and generic.
-- mb
On Mon, Apr 7, 2014 at 1:55 AM, Elliot Saba staticfl...@gmail.com wrote:
Jay, I'm a signal processing student and can help you out with the
multirate dsp if you want. Feel
How about an input function?
julia function input(prompt::String=)
print(prompt)
chomp(readline())
end
input (generic function with 2 methods)
julia name = input(What's your name? );
What's your name? Ismael
julia println(Hello $(name)!)
Hello Ismael!
I'm not sure what that's in response to, but yes, we should have such a
thing. However, it should automatically use the REPL and provide line
editing when appropriate or fall back on dumb input otherwise.
On Mon, Apr 7, 2014 at 10:39 AM, Ismael VC ismael.vc1...@gmail.com wrote:
How about an
I partly meant to suggest that PowerSeries.jl
https://github.com/jwmerrill/PowerSeries.jl might also meet your needs for
2nd order forward automatic differentiation, and it also already works to
higher orders.
PowerSeries.jl works by computing truncated power series of functions. You
can read
Hi all,
just to let you know that I gave a presentation two weeks ago about Julia,
and the slides are available online
herehttps://sites.google.com/site/carlosbecker/a-few-notes/julia-intro.pdf?attredirects=0d=1
,
together with an ijulia
That is not possible yet.
Please copy and paste the commands and errors from the terminal. It makes
it easier to figure out what is wrong.
2014-04-07 18:03 GMT+02:00 paul analyst paul.anal...@mail.com:
Friends , case back:
R = convert (Matrix {BigFloat}, cor (A))
Ok, I have an array. Now I
I like the side by side presentation between the matlab and julia samples, does
anyone know of an online service or better yet sphinx extension that makes this
easy to do?
Thx, Andreas ,
it is for developers ...,
A=rand(100,100)
R = convert (Matrix {BigFloat}, cor (A))
m,v=eig(R)
ERROR: no method eigfact!(Array{Any,1}, Array{BigFloat,2})
in eigfact at linalg/factorization.jl:669
in eig at linalg/factorization.jl:673
W dniu 2014-04-07 18:10, Andreas
Hi,
I need to (conceptually) add a field to the IntDisjointSets data structure
available in DataStructures.jl, which is basically the size (number of
elements) in each of the disjoint sets.
What is the julian way to do this kind of inheritance?
Should I create a new type which *contains* an
What are done and status here?
On Sat, Feb 1, 2014 at 9:52 AM, Tim Holy tim.h...@gmail.com wrote:
Thanks Jameson, that worked great.
Since this took me into areas of Julia that I hadn't previously explored, I
thought I'd post a complete example below. I suspect that something along
these
El lunes, 7 de abril de 2014 12:59:41 UTC-5, David P. Sanders escribió:
El lunes, 7 de abril de 2014 12:35:05 UTC-5, David P. Sanders escribió:
Hi,
I need to (conceptually) add a field to the IntDisjointSets data
structure available in DataStructures.jl, which is basically the size
data in this example will be notifyasync (i.e., the SingleAsyncWork
object whose handle was sent to uv_async_send); might be nicer to call it
work. No idea what status is.
Would be good to document this in the manual (it only says you'll most
likely just discard the callback parameters). In
On Monday, April 7, 2014 10:58:40 AM UTC-4, Stefan Karpinski wrote:
I'm not sure what that's in response to, but yes, we should have such a
thing. However, it should automatically use the REPL and provide line
editing when appropriate or fall back on dumb input otherwise.
I was thinking
On Monday, April 7, 2014 2:37:14 PM UTC-4, Steven G. Johnson wrote:
However, I'm not sure how to write such a method in Base such that it can
be cleanly extended/overridden if you are running in IJulia.
Oh nevermind, it would be easy. Just write:
readline(io::IO, prompt::String) =
On Monday, April 7, 2014 2:41:28 PM UTC-4, Steven G. Johnson wrote:
readline(io::IO, prompt::String) = default thing in Base
Hmm, now I remember the problem. It seems like this would have to be
readline(read::IO, write::IO, prompt::String) since different streams are
used for
If a signal processing framework is developed for Julia, please keep in mind
that at some point precision time tags (and possibly other tags) will be
desired. GNU Radio developers waited far too long to add tagging.
Hi all,
I have the following matrix (in a copy-pasteable format)
X = [1.753845-.62147147 -1.52345246
-1.48451771;
-.62147147 .999849183356 .38533486
.32021346;
-1.52345246 .38533486 1.81826723
On Monday, April 7, 2014 3:24:32 PM UTC-5, Iain Dunning wrote:
Hi all,
I have the following matrix (in a copy-pasteable format)
X = [1.753845-.62147147 -1.52345246
-1.48451771;
-.62147147 .999849183356 .38533486
Thanks Carlos, This is pretty interesting and I enjoyed reading through
your ensemble code. I also really like the side-by-side comparisons. A site
which could provide many of these with a clear layout could be pretty
useful (and convincing) for those of us coming from R/python/matlab.
(on a
Hey,
Couldn't find the documentation - all I found was
https://github.com/JuliaLang/julia/blob/27c3a5b7ed66bee509fc4a81aa54ba09aec1b2ee/base/linalg/exceptions.jl#L19-L21
and
http://docs.julialang.org/en/latest/stdlib/linalg/?highlight=posdefexception#Base.cholfact
I know rand(4,4) isn't
Hi John, thanks!
On Mon, Apr 7, 2014 at 10:42 PM, John Eric Humphries
johnerichumphr...@gmail.com wrote:
Thanks Carlos, This is pretty interesting and I enjoyed reading through
your ensemble code. I also really like the side-by-side comparisons. A site
which could provide many of these with
I posted a similar question a week or 10 days ago without a reply. I am
giving this a try again.
I was able to get the call to work at home with something like the
following: When I would change the file println's below would display the
information in the console. However, I had no access to
Is there a way to get the least squares residuals for qrfact(X)\y without
having to compute X*beta, as is given by gels? I believe this should be
||Q2'y||; Q2'y appears to be computed but explicitly zeroed in A_ldiv_B!.
Simon
Ok, I figured it out:
julia wf = watch_file((fn, ev, st) - begin
println(File Name : *string(fn))
println(Event : *string(ev))
println(Status: *string(st))
end,
c:\\Bits\\watch.txt)
FileMonitor(Ptr{Void}
Generally, you would define an abstract type that the user would
inherit. Inheriting from an abstract type is essentially a declaration
that the child class will provide definitions for some
functions/behavior
You would also define prototypes for any functions the user code is
expected to
gmail got confused and remove Mason's actual question, to which I was
responding:
I'd like to write a library that includes functions that can operate
on user-defined types and delegate part of their implementation to
user-defined functions. For example:
zero!(x) = (x[1:end] = 0)
where `x`
`status` used to equal 0 (success), now it is just a random number
(whatever happens to be in the register/stack location of this
argument that no longer exists in libuv, but never got remove from
Julia): https://github.com/joyent/libuv/blob/v0.8/include/uv.h#L291
the first argument to every
julia println(aa, , bb)
1.5231071779744345 33.97688693695
Is there a simple way to print
1.52 33.97
perhaps without the C format?
julia @printf(%.2f %.2f\n, aa, bb)
1.52 33.98
Note the rounding of bb.
On Mon, Apr 7, 2014 at 9:35 PM, cnbiz850 cnbiz...@gmail.com wrote:
julia println(aa, , bb)
1.5231071779744345 33.97688693695
Is there a simple way to print
1.52 33.97
perhaps without the C format?
Maybe something about this should be added as documentation for this
function?
On Mon, Apr 7, 2014 at 8:21 PM, Jacques Rioux jacques.ri...@gmail.comwrote:
Ok, I figured it out:
julia wf = watch_file((fn, ev, st) - begin
println(File Name : *string(fn))
Thank you.
I am hoping if we could do something like this:
println(aa[1,5], , bb[1,5])
hopefully one can access part of strings that way.
On 04/08/2014 10:05 AM, Stefan Karpinski wrote:
julia @printf(%.2f %.2f\n, aa, bb)
1.52 33.98
Note the rounding of bb.
On Mon, Apr 7, 2014 at 9:35 PM,
Thanks guys. Just to record it somewhere, I ended up doing this in a
somewhat different but satisfying way – using ZMQ:
https://gist.github.com/StefanKarpinski/10083996. Since the next step after
getting two threads to communicate is inevitably to add a threadsafe
queuing mechanism, you might as
You can slices strings but those values aren't strings – they're floats. If
you want to go this route, you could do this:
julia println(string(aa)[1:5], , string(bb)[1:5])
1.523 33.97
However, that seems harder, is considerably more fragile, and doesn't round
correctly.
On Mon, Apr 7, 2014
The behavior of unpivoted Cholesky is not obviously wrong; it fails to
factorize in finite-precision arithmetic when the smallest eigenvalue
is something on the order of epsilon (you can get the precise constant
and citation from, e.g.
You're absolutely right tagging, but have no intention of turning Radio
into a streaming processing framework. My inspiration is
LiquidDSPhttp://liquidsdr.organd Matlab's communications toolbox. If
liquid wasn't GPL, I would just write an interface to it. It can be
compiled without any
In Julia there is (almost) no distinction between user-defined
functions and library code. In fact, an increasing percentage of the
library code is just pre-packaged Julia functions that happen to
live in the Base module ('increasing', because stuff often moves from
C to Julia because doing so
I strongly recommend you update to Julia 0.2 at least and use the dedicated
GLPK package https://github.com/JuliaOpt/GLPK.jl - I'm sure you'll get much
better support. Version 0.1 of Julia (which had inbuilt GLPK - I had
forgotten!) isn't supported anymore.
How did you get version 0.1?
as stated in question..
I'm a little confused about what you feel is missing. You can do duck
typing just as well as in any dynamic language. While it's true that there
aren't explicit interfaces (or protocols or concepts), those don't exist in
Python either. Julia's abstract types give you everything that
That is correct.
On Mon, Apr 7, 2014 at 11:26 PM, Freddy Chua freddy...@gmail.com wrote:
as stated in question..
Short answer: if a user adds a method to `Base.setindex!`, it *will*
be accessible to library code.
The difference from python here is that python has a single namespace
of method names: if your object has a method `__setitem__`, *all*
python code that says `x[...]=...` might call it. In julia,
... and the ModInt example is fixed again:
julia include(examples/modint.jl)
showcompact (generic function with 8 methods)
julia A = map(ModInt{11}, rand(1:1000,5,5))
5x5 Array{ModInt{11},2}:
10 1 6 5 1
10 9 6 10 8
2 9 2 1 6
10 4 3 2 8
6 5 2 3 10
julia B =
You can write qrfact(X)[:Q]'y and sum the squares of the last n-k terms,
but A_ldiv_B!(QR,y) should return the whole y including the Q2'y part and
then let \ do the slicing.
2014-04-08 0:11 GMT+02:00 Simon Kornblith si...@simonster.com:
(To clarify, I mean the sum of the squared residuals, and
I meant could, not should.
2014-04-08 6:52 GMT+02:00 Andreas Noack Jensen andreasnoackjen...@gmail.com
:
You can write qrfact(X)[:Q]'y and sum the squares of the last n-k terms,
but A_ldiv_B!(QR,y) should return the whole y including the Q2'y part and
then let \ do the slicing.
2014-04-08
Thanks for the report.
I found the bug
in https://github.com/JuliaLang/julia/blob/master/base/statistics.jl#L470,
because it tries to calculate length(edg) - 1, but actually calculates
length(edg - 1), which is kind of useless.
I'll work on a patch (and maybe add a test).
Ivar
kl. 01:26:43
Ah, that's it. Thanks for looking into it.
On another note (but in the same code neighborhood), what's the meaning of
sub(H(H, :, j)
in line 465 of statistics.jl? I'm confused by that first 'H', as I thought
it would imply a function call.
On Tuesday, April 8, 2014 1:39:05 AM UTC-4, Ivar
52 matches
Mail list logo
