I just want to put some emphasis on what Scott hinted at: if you want to
contribute to Julia, start with figuring out what *you* know a little about.
Sometimes there's code in base that does some of those things, but not all of
them, and/or not as well as you know how to.
Sometimes there's no
I started contributing (and driving the core team to distraction) two weeks
ago, by finding things where I had a small amount of expertise in an area
that hadn't received maybe as much attention as other areas that I know
little about (those guys live in the clouds, IMO, way over my head!).
So t
There is an "up for grabs" label, but it is a weird mix of difficulty
levels -- from pretty easy (though often tedious) stuff all the way to
random codegen and parser things that are probably not great first bugs.
Here is a discussion the last time this came up:
https://groups.google.com/forum/#!t
I got into contributing to Julia because of @timholy's amazing #9493. It
was pretty easy to figure out, based on that issue, what I was supposed to
do and how to contribute. But what if someone just doesn't want to write
tests (maybe they have test anxiety) or doesn't have domain knowledge for
earlier this year, as a volunteer, i spent an hour on six consecutive Friday
afternoons introducing middle school students (aged 12 - 14) to Julia ...
we got familiar with the REPL, the IJulia notebook, JuliaBox, Jupyter
(on tmpnb.org) ...
we extended a Rock Paper Scissors program:
https://en.w
Necrothread after six months. Has the @doc format been finalized and what
is the best way to start using it without breaking 0.3?
(err, "multi-package scale")
On Thu, May 7, 2015 at 9:47 PM, Isaiah Norton
wrote:
> Yes, exactly -- this is what e.g. the StatsBase and GraphicsBase packages
> are doing, on a multi-module scale. But it works well within a single
> module too, in combination with the lazy loading.
>
> On Thu, Ma
Yes, exactly -- this is what e.g. the StatsBase and GraphicsBase packages
are doing, on a multi-module scale. But it works well within a single
module too, in combination with the lazy loading.
On Thu, May 7, 2015 at 2:49 PM, Kristoffer Carlsson
wrote:
> That seemed to do the trick.
>
> I kinda
tl;dr: just cargo cult and do what everyone else does :)
The main difference is where they search:
- `include` searches relative to the path of the source file *in which it
is called*. That is why it is useful and widely used in packages.
- `require` looks in cwd, then package directories (plus
I want to make a parametric type that needs some checking, so I want to
include an inner constructor. But since the type of the arguments can
change, then the method of checking (the validity of the arguments) needs
to depend on the type. I know the following works, but thought it would be
good
To whom it may concern:
I can't seem to figure out how to use the scipy min_cg, being called by
PyCall. The definition of objective functions with an arbitrary number of
arguments doesn't seem to work well. I am trying to reproduce the example
from the scipy website in Julia.
http://docs.scipy
perfect, just want I needed. Thanks Matt
On Thursday, May 7, 2015 at 3:57:44 PM UTC-4, Matt Bauman wrote:
>
> There's the (undocumented) `@timed` macro. It returns a tuple of (result,
> time, bytes allocated, percent GC time).
>
>
> https://github.com/JuliaLang/julia/blob/861f02712eb4b41c08fed3f
Excellent. See also the response to your email.
On Thursday, May 7, 2015 at 4:39:32 PM UTC-4, Alexandros Fakos wrote:
>
> Thanks a lot Spencer,
>
> So when I create a type I should first think which fields are going to be
> initialized in the constructor. It makes sense.
>
> Best,
> Alex
>
>
>
>
When should I use `include` and when should I use `require`?
In all the packages I've read everyone seems to use `include`, but
`require` seems to do everything that it does, plus be smarter about not
loading twice. Is this correct?
Thanks a lot Spencer,
So when I create a type I should first think which fields are going to be
initialized in the constructor. It makes sense.
Best,
Alex
On Thursday, May 7, 2015 at 4:17:20 PM UTC-4, Spencer Lyon wrote:
>
> Uninitialized fields need to be declared last because the way you
Uninitialized fields need to be declared last because the way you construct
an incompletely initialized type is to call `new` with less than the total
number of fields. Then, elsewhere (preferably via a function call later in
the constructor) you will fill in the fields that didn't make it into
There's the (undocumented) `@timed` macro. It returns a tuple of (result,
time, bytes allocated, percent GC time).
https://github.com/JuliaLang/julia/blob/861f02712eb4b41c08fed3f21c5a4206b8d669bc/base/util.jl#L100-L112
On Thursday, May 7, 2015 at 3:05:46 PM UTC-4, Edward Chen wrote:
>
> Cool, t
Is there a way to suppress some of that output? Maybe the default should even
be much less, but with a "verbose" option somewhere?
I love that all that info is available, but I'm not sure I always want to see
it - it kinda hides the actual time in noise...
// T
Not loading on Ubuntu 14.04 & 0.3.7...
Kaj
On Tuesday, April 28, 2015 at 2:11:17 PM UTC+3, Tim Holy wrote:
>
> Also, on 0.3 Gtk loads just fine for me. Not sure why it's not working on
> PkgEvaluator.
>
> --Tim
>
> On Tuesday, April 28, 2015 12:46:52 AM Andreas Lobinger wrote:
> > Hello coll
Cool, thanks -- but I would also like the bytes allocated
On Thursday, May 7, 2015 at 3:02:51 PM UTC-4, Jacob Quinn wrote:
>
> http://docs.julialang.org/en/latest/stdlib/base/#Base.tic
>
> On Thu, May 7, 2015 at 1:00 PM, Edward Chen > wrote:
>
>> To whom it may concern:
>>
>> I am interested in t
http://docs.julialang.org/en/latest/stdlib/base/#Base.tic
On Thu, May 7, 2015 at 1:00 PM, Edward Chen wrote:
> To whom it may concern:
>
> I am interested in testing the performance of my code.
>
> I am familiar with using @elapsed in the following way:
>
> metric = Float64[]
> push!(metric,@ela
To whom it may concern:
I am interested in testing the performance of my code.
I am familiar with using @elapsed in the following way:
metric = Float64[]
push!(metric,@elapsed output = foo(input))
Is there an analogous way for doing this with @time, or @allocated?
Thanks,
Ed
That seemed to do the trick.
I kinda like how this forces you to be explicit in what you will extend
from the main module.
On Thursday, May 7, 2015 at 8:28:47 PM UTC+2, Kristoffer Carlsson wrote:
>
> Question:
>
> Is the solution to define "main functions" in the library module and then
> impor
On Thursday, May 7, 2015 at 8:08:42 PM UTC+2, Douglas Bates wrote:
>
>
>
> On Thursday, May 7, 2015 at 11:55:59 AM UTC-5, Kristoffer Carlsson wrote:
>>
>> Boring but non allocating like list comprehension and anonymous function:
>>
>> m = typemin(Int16)
>> for TUnit in TUnitS
>>m = max(m,TUni
Question:
Is the solution to define "main functions" in the library module and then
import those functions into the book modules?
Sort of like how you import Base.push! if you want to extend the push!
function.
On Thursday, May 7, 2015 at 7:43:26 PM UTC+2, Kristoffer Carlsson wrote:
>
> I rea
On Thursday, May 7, 2015 at 11:55:59 AM UTC-5, Kristoffer Carlsson wrote:
>
> Boring but non allocating like list comprehension and anonymous function:
>
> m = typemin(Int16)
> for TUnit in TUnitS
>m = max(m,TUnit.tau_max)
> end
>
>
Even more compact is to use a function as the first argument
If I don't want to leave fields uninitialized what is the easiest and most
correct way to initialize them? Put them all zero with an inner constructor?
Thanks a lot,
Alex
On Thursday, May 7, 2015 at 12:56:35 PM UTC-4, Alexandros Fakos wrote:
>
> Andrew,
>
> I found your suggestion very helpful.
I realized this doesn't work well for me.
The problem with using @lazymod and splitting my "books" into different
modules is that I have methods with the same name in the "book" modules.
This will cause conflicts and I won't get the methods when I import the
second book module.
Maybe I could us
Excellent. The first idea is exactly what I needed.
I don't think the second one would work because the number of
multiplication calls I need is dynamic (notice we have `@nexprs $N-d+1`).
On Thursday, May 7, 2015 at 1:11:41 PM UTC-4, Tim Holy wrote:
>
> You could do
>
> tmp = one(eltype(z))
>
The next Julia meetup at Mexico City next Saturday May 9, starting at
11:00am (GMT-5), will be the first one to be live streamed in Google
Hangouts and Youtube, we hope everything works well! :D
Meetup:
- http://www.meetup.com/julialang-mx/events/221963847
Youtube:
- https://youtu.b
Usually I think these antivirus databases also have some way of reporting
false positives? May help.
On Wednesday, May 6, 2015 at 8:17:35 AM UTC-7, Pileas wrote:
>
> Haha, I am sorry my bad. I should have mentioned the "broettes" also!
>
> Τη Τετάρτη, 6 Μαΐου 2015 - 11:12:30 π.μ. UTC-4, ο χρήστη
You could do
tmp = one(eltype(z))
@nexprs $N j->(tmp *= z[r, i_j])
out[r,ix] = tmp
Does that do what you want?
Alternatively, build up the expression outside the quote block:
args = [:(z[r, $i]) for i = 1:N]
ex = Expr(:call, :*, args...)
and then use $ex where your former @nexprs is.
--Tim
Andrew,
I found your suggestion very helpful. However, it seems complicated to
place uninitialized fields last. Why is this? The field have names and when
calling *new() *you are using these names.
For example:
*julia> type foo*
* a :: Int64*
* b :: Int64*
* function foo()*
*
Boring but non allocating like list comprehension and anonymous function:
m = typemin(Int16)
for TUnit in TUnitS
m = max(m,TUnit.tau_max)
end
On Thursday, May 7, 2015 at 5:49:49 PM UTC+2, Michela Di Lullo wrote:
>
> Hello everyone,
>
> I have to compute the maximum value of tau_max, attribu
Or:
maximum([t.tau_max for t in TUnitS])
On Thursday, May 7, 2015 at 12:02:09 PM UTC-4, Darwin Darakananda wrote:
>
> How about :
>
> mapreduce(t -> t.tau_max, max, TUnitS)
>
>
> On Thursday, May 7, 2015 at 8:49:49 AM UTC-7, Michela Di Lullo wrote:
>>
>> Hello everyone,
>>
>> I have to compute
Consider the following expression:
julia> macroexpand(:(@nexprs 3 j->(out[r, ix] *= z[r, i_{3-j+1}]) ))
quote
out[r,ix] *= z[r,i_3]
out[r,ix] *= z[r,i_2]
out[r,ix] *= z[r,i_1]
end
What I would really like to be able to do is have a macro generate the
expression
julia> ... some magi
How about :
mapreduce(t -> t.tau_max, max, TUnitS)
On Thursday, May 7, 2015 at 8:49:49 AM UTC-7, Michela Di Lullo wrote:
>
> Hello everyone,
>
> I have to compute the maximum value of tau_max, attribute of TUnit which
> is declared as follows:
>
> immutable TUnit
>
> Node::Int16
>
> a:
Hello everyone,
I have to compute the maximum value of tau_max, attribute of TUnit which is
declared as follows:
immutable TUnit
Node::Int16
a::Float64
b::Float64
c::Float64
inf::Float64
sup::Float64
ton::Int16
toff::Int16
storia0::Int16
pt0::Fl
Personally I always recommend Processing as a starting environment, it
allows to easily do cool stuff.
The bottleneck when starting is often motivation, so having positive
feedback is important.
http://www.openprocessing.org/sketch/192912
Thank you all so much! All your comments were really helpful !
Best,
Alex
On Thursday, May 7, 2015 at 5:52:39 AM UTC-4, Tim Holy wrote:
>
> See also
> http://docs.julialang.org/en/release-0.3/manual/faq/#how-do-abstract-or-ambiguous-fields-in-types-interact-with-the-compiler
>
>
> --Tim
>
> O
Very good points! I'd like to teach them something where I think the base
concepts are good (like Scheme, CLU, or Julia), but also something that
they can keep getting deeper and deeper into, as they grow older... (at
least until they bankrupt me by going to MIT!)
On Thursday, May 7, 2015 at
One of the advantages I do think that Julia has for teaching is that it makes
it unusually easy to see what's happening on many levels. Teaching with
high-level languages like Python or Java – anything but C for that matter –
tends to construct a wall between the safe "walled garden" and the low
Ah, no, I never said that I felt it was the *right* match for children...
however my children have been programming their Legos with Lego MindStorms,
and have taken Scratch classes (and MineCraft circuits... learned boolean
logic at age 7 ;-) ) at Einstein's Workshop already...
(It's in Burlingto
I'm issuing the PR in a few minutes, it looks like this:
(I also fixed a small bug with realloc's counting)
```julia
ASCII convert to UTF-16
elapsed time: 8.441981477 seconds (1000 allocations, 5000 MB allocated,
2.94% gc time in 222 pauses with 0 full sweep)
```
Does that look like acceptable out
Julia is a great language, but I am wondering why you think it is the right
match for children. IMO the comparative advantages of Julia are
1. parametric polymorphism,
2. macros,
3. ability to generate very fast code with very little help.
I don't think that any of these appeal very much to beginn
I'd say so... (I don't know if you saw my message on LinkedIn, but I was
serious about there maybe being a job for a C/C++ programmer where Juila
skills would be a big ++, in India).
Hi Florian,
Good point - ultimately I do want to do the PSID stuff in Julia, as I'm
solving my numerical model in Julia and the estimation I'll do will require
hand-coding an estimator in any case. As I want to start from a correct
reference point though I thought I'd create a panel using your
Ah, good to know! I was a bit confused!
I'd planned on installing IJulia on his laptop, but I'm not sure about the
state of IJulia with 0.4
(I like to live on the bleeding edge), and I was also going to install 0.4
on his laptop (so he gets his daddy's
string/char fixes ;-)
Have any of you seen
Hi Nils (again; why are we talking about R packages when you've seen the
julia light already? :-) ),
agree with tom and kevin above.
absolutely yes I would start with dataframe. it's my reference when it
comes to high-quality packages, and it has all you need for this task I
think. For a norma
As far as I can tell, this should be a pretty simple change… maybe it will be
done this afternoon…
Would it break anything to change @timed to return the extra information as
well? It seems like rather a bit of duplication,
@time does all the work, and then prints stuff out, and @timed returns
I have created a julia-jobs mailing list, but not done much more than that in
making it operational. Should we do so?
-viral
> On 07-May-2015, at 5:50 pm, Scott Jones wrote:
>
> What if the job is a general job, but where Julia knowledge expertise is a
> big ++?
> (that sort of posting migh
On Thursday, May 7, 2015 at 7:53:08 AM UTC-5, Alan Edelman wrote:
>
> My children have been watching me "play" with julia for years now.
> They are now 12 and 14. No question that "manipulate" is the way to start.
> (and by the way that's true for adults too)
>
> You can use "manipulate" with anyt
Yes, that'd be a good place to start.
On Thu, May 7, 2015 at 7:13 AM, Nils Gudat wrote:
> Two problems with this:
>
> (i) I'm a terrible, terrible programmer (just as Mike about the time I
> wanted to "help out" by making his Jewel package 0.4-compatible)
> (ii) The project I'm working on right
My children have been watching me "play" with julia for years now.
They are now 12 and 14. No question that "manipulate" is the way to start.
(and by the way that's true for adults too)
You can use "manipulate" with anything, just a matter of imagination, I'd
think.
On Thursday, May 7, 2015 a
This is more about encouragement than "how to", but encouragement is
probably all he needs anyway!
My son was about 5 or so and had games he played on the computer. One day
he wanted to show me something in a game, and when we went to the computer,
the icon was missing from the desktop. I told
What if the job is a general job, but where Julia knowledge expertise is a
big ++?
(that sort of posting might in the the works for some people I know ;-) )
On Friday, March 6, 2015 at 1:51:16 PM UTC-5, Keno Fischer wrote:
>
> I think if they are julia job postings they're fine. General data scie
Has anybody had any experience teaching Julia to kids?
This is *not* a joke, my almost 9 year old son has a science project due
next week.
He knows some Lua (which he originally learned from the ComputerCraft mod
in MineCraft, and then using the Codea
app for the iPad), but he's seen how I've fal
On Thu, May 07 2015, Mauro wrote:
> Where `Type` is special is with respect to `isa` and thus method
> dispatch where this works:
>
> julia> bar{T}(::Type{T}) = T
> bar (generic function with 1 method)
>
> julia> bar(Int)
> Int64
>
> julia> isa(Int, Type{Int})
> true
>
> I think there is some spe
> b) seems more reliable but indeed it seems to only solve equations with
> real coefficients.
>
Usually reinterpreting the NxN complex coefficient matrix and the N-sized
solution vector as 2N (x 2N) sized real matrices/vectors does the trick.
The ODE procedures don't care if it's real or compl
Unless there is someone on the list who has solved that equation before
it will be hard to say what exactly works. I would first try with
ODE.jl as that should be fast to code. If it does not work then use
Sundials.jl.
Alternatively, first use Sundials.jl, then using ODE.jl should be
trivial.
O
Here is my understanding of Type. Beware though, it might be completely
wrong!!!
`Type` in itself is just an ordinary abstract type:
julia> typeof(Type)
DataType
julia> super(Type)
Any
and DataType is a subtype of it
julia> subtypes(Type)
3-element Array{Any,1}:
DataType
TypeConstru
ok, so the system under discussion is this one:
http://scicomp.stackexchange.com/questions/19585/system-of-coupled-nonlinear-odes-with-complex-coefficients
i think the choice basically comes down to either
a) an explicit RK method in ODE.jl or
b) CVODE(S) in Sundials.jl
What do you guys suggest
Two problems with this:
(i) I'm a terrible, terrible programmer (just as Mike about the time I
wanted to "help out" by making his Jewel package 0.4-compatible)
(ii) The project I'm working on right now has a tight deadline, so I won't
have much time for the "exploratory" stage and will in all li
Thanks. I did also figure out a method based on transposing a hcat,
but in the end went with the simple loop.
s
On 6 May 2015 at 16:44, Stefan Karpinski wrote:
> If the command allows invocation without spaces, you can do this:
>
> `command -e$a`
>
>
> If the command allows invocation with a spa
See also
http://docs.julialang.org/en/release-0.3/manual/faq/#how-do-abstract-or-ambiguous-fields-in-types-interact-with-the-compiler
--Tim
On Wednesday, May 06, 2015 11:20:30 PM Kevin Squire wrote:
> To add a little detail to Mauro's response:
>
> The "overly-specific types" suggestion really
Brilliant, that's exactly what I was looking for. I guess I had assumed
new() would act as return and boot me out of the function, but that is not
the case it seems. I find Julia so interesting!
On Thursday, May 7, 2015 at 4:19:10 AM UTC-4, Alex wrote:
>
>
>> Would it be possible to run the call
>
>
> Would it be possible to run the callback when I init a "mouse" object? I
> feel like it should be possible but I can't seem to figure out how to
> reference or pointer the object being initialized from within it's own
> constructor. Similar to the below, replacing thisObject for something
Ah interesting, that makes sense. Wasn't sure if I could const it while
changing the contents.
Would it be possible to run the callback when I init a "mouse" object? I
feel like it should be possible but I can't seem to figure out how to
reference or pointer the object being initialized from w
You could put the whole code into a function main() if you want. If you
have a fixed set of Foos you can also declare them const (`const foo =
Foo(0.,0.), since you would only change the fields in foo.
- Alex.
On Thursday, 7 May 2015 09:22:00 UTC+2, Elburz Sorkhabi wrote:
>
> Thanks for the ins
Thanks for the insight, very much appreciated.
I had considered doing something similar with a type, but what that be on
par with global variables in terms of performance? I read in the docs that
global variables are frowned up.
On Thursday, May 7, 2015 at 3:15:28 AM UTC-4, Alex wrote:
>
> Hi!
Hi!
Strangely enough (?) it seems one can't pass normal functions
to GLFW.Set...Callback. But if you just want to store the positions in some
object (maybe to change its properties) you can do something like this
# some type which needs positions
type Foo
x::Float64
y::Float64
end
setp
71 matches
Mail list logo
