Copying things by default isn’t a very good strategy for a language used to do
linear algebra on large arrays.
Requiring that people use Ref to get reasonable performance for linear algebra
operations would make Julia feel like a much more low-level language than it is
currenty.
— John
On Au
the step size should reset to a default value.
>
> By the way, is it possible to enable display of the internal values of "c" in
> the line search routines? It looks like there is some debugging code in
> there but I'm not sure how to turn it on.
>
> -thom
>
>
ne itself, so the overhead of a full inverse Hessian is relatively small.
>
> In Optim.jl, L-BFGS seems to use the same line search routine as BFGS. Is
> there a reason to think it should take substantively different search path?
>
>
> -thom
>
> On Wednesday, August 20
y more
> computational work than what goes in inside the optimizer.
>
> I will see if L-BFGS does a better job later today. Thanks for your help.
>
> -thom
>
> On Wednesday, August 20, 2014 9:33:21 AM UTC-5, John Myles White wrote:
> It seems odd that your objective fun
Try typing the sequence \_1
— John
On Aug 20, 2014, at 8:08 AM, Douglas Bates wrote:
> I find it convenient to use identifiers like
>
> julia> a₁ = 2
> 2
>
> In the iESS emacs mode for a Julia session I can set the input-mode to TeX
> and type "a_1" to create this identifier. Is there a k
Unfortunately, the rule is simple: "dispatch never looks at keyword arguments."
-- John
On Aug 21, 2014, at 8:59 AM, Spencer Lyon wrote:
> Consider the following code:
>
> function periodogram(x::Array)
> n = length(x)
> I_w = abs(fft(x)).^2 ./ n
> w = 2pi * [0:n-1] ./ n # Fourie
Please read http://julialang.org/blog/2013/09/fast-numeric/
— John
On Aug 21, 2014, at 8:02 PM, K Leo wrote:
> A is a 1-dimensional array. I used to compute sum(abs(A)). But when I
> changed to the following, the speed increased nearly 10 fold. Why is that?
>
>sumA=0
>for i=1:leng
Abstractly, I’d love to be able to print using Color.jl. It seems like a much
cleaner interface.
But it’s not clear to me that Color.jl buys you a lot if your terminal doesn’t
support a widerange of colors.
— John
On Aug 22, 2014, at 3:33 PM, Spencer Russell
wrote:
> I just filed an issue
I don’t see this behavior at all on my system.
After discarding an intial compilation step, here’s what I get:
0.3 — elapsed time: 3.013803287 seconds (400120776 bytes allocated, 1.77% gc
time)
0.4 — elapsed time: 2.920384195 seconds (400120776 bytes allocated, 1.89% gc
time)
Also to clarify:
ia> @time begin a = rand(5000,5000); b = rand(5000); x =a\b end;
> elapsed time: 30.509950844 seconds (400100776 bytes allocated, 0.11% gc time)
>
> It's mystery to me. If I learn anything more, will let you know.
> Thanks again.
>
> Don
>
>
>
> On Friday
Can you clarify a bit what you mean by “same result”?
It would also be great to see a simpler example that doesn’t involve the
Bayesian updating steps, which hopefully aren’t essential to hitting an error.
— John
On Aug 23, 2014, at 4:33 PM, asim wrote:
>
>
> I am trying to use the multiva
der in Julia 0.3. The code only runs 3x faster and
> the type stable code looks a bit more complex.
>
> On Monday, December 16, 2013 8:48:40 PM UTC+2, John Myles White wrote:
> I think Michael is suggesting that it would help to have an automated tool to
> do this. This stuff comes
; the type stable code looks a bit more complex.
>
> On Monday, December 16, 2013 8:48:40 PM UTC+2, John Myles White wrote:
> I think Michael is suggesting that it would help to have an automated tool to
> do this. This stuff comes up in subtle ways in complex code. While editing
The NEWS.md file does cover this:
• Ranges and arrays with the same elements are now unequal. This allows hashing
and comparing ranges to be faster. (#5778)
On Aug 25, 2014, at 8:45 AM, Ed Scheinerman
wrote:
> Thanks again for the pointer to the release notes.
>
> The issue I raised was not
Yes, this is possible. A common Julian pattern is:
function foo!(dest::Array, src::Array)
mutate!(dest, src)
end
function foo(src::Array)
dest = copy(src)
foo!(dest, src)
return dest
end
Some other points to note:
Array{FloatingPoint} isn't related to Array{Float
d Library
> v0.3. Do you mean my own function that mutates the source array?
>
> On Monday, 25 August 2014 14:54:14 UTC-4, Patrick O'Leary wrote:
> On Monday, August 25, 2014 12:28:00 PM UTC-5, John Myles White wrote:
> Array{FloatingPoint} isn't related to Array{Float64}. J
The issue is that you want to have all code documentation show up in REPL. In
the GoDoc approach, this might require an explicit "build" step -- which is a
non-trivial cost in usability.
-- John
On Aug 25, 2014, at 3:01 PM, Job van der Zwan wrote:
> On Monday, 25 August 2014 01:23:26 UTC+2,
This looks like a failure to find functions from NumericFuns.
What versions of Julia and stats packages are you using?
-- John
On Aug 25, 2014, at 9:03 AM, asim wrote:
>
Dahua, did you keep the original package around?
— John
On Aug 25, 2014, at 10:07 PM, Dahua Lin wrote:
> Following Julia package naming convention, the package Distance was renamed
> to Distances.
>
> New package page: https://github.com/JuliaStats/Distances.jl
>
> All materials in Distanc
s/25
>
> Dahua
>
> On Tuesday, August 26, 2014 1:08:48 PM UTC+8, John Myles White wrote:
> Dahua, did you keep the original package around?
>
> — John
>
> On Aug 25, 2014, at 10:07 PM, Dahua Lin wrote:
>
> > Following Julia package naming convention,
day, 26 August 2014 00:04:41 UTC+2, John Myles White wrote:
> The issue is that you want to have all code documentation show up in REPL. In
> the GoDoc approach, this might require an explicit "build" step -- which is a
> non-trivial cost in usability.
>
> -- John
>
>
> julia> A=DataArray([1 2; 3 4])
> 2x2 DataArray{Int64,2}:
> 1 2
> 3 4
> julia> A*.5
> 2x2 DataArray{Float64,2}:
> 0.5 1.0
> 1.5 2.0
> julia> A/2.
> 2x2 DataArray{Float64,2}:
> 0.5 1.0
> 1.5 2.0
> julia> A/2
> InexactError()
>
> So
Hi Phillip,
Could you provide a more complete example of what you're doing? In particular,
I'm very confused by the idea of "pushing" items to a dict, which is an
unordered data structure.
Here is how dictionaries work in Julia:
d = Dict()
d["foo"] = "bar"
sizehint(d, 100)
d["bar"] = "foo"
-
sum(A, 1) works, as does sum(A, (1, )).
More generally, sum(A, dims::Integer...) works, as does as sum(A,
(dims::Integer...), ).
-- John
On Aug 27, 2014, at 2:44 PM, Andrew Dabrowski wrote:
> In the doc for the Standard library I see:
>
> sum(A, dims)
> Sum elements of an array over the giv
014 17:34:24 UTC+2, Stefan Karpinski wrote:
> To clarify – I meant that I like the style of GoDoc, not the fact that you
> run the tool as a separate pass. That doesn't strike me as completely out of
> the question, but wouldn't be optimal.
>
>
> On Tue, Aug 26, 2014 at 1
e "over the given dimensions" ambiguous - isn't
> it actually summing over the dimensions _not_ given?
>
>
> On Wednesday, August 27, 2014 5:46:33 PM UTC-4, John Myles White wrote:
> sum(A, 1) works, as does sum(A, (1, )).
>
> More generally, sum
ts.
>
> On Wednesday, August 27, 2014, John Myles White
> wrote:
> Ok, thanks for clarifying. I also like the idea of strategically placed
> comments as automatic documentation.
>
> -- John
>
> On Aug 27, 2014, at 2:54 PM, Job van der Zwan
> wrote:
>
>> Righ
o use some badd! function when generating multiple draws from the
> distribution, and this function is not found. I am not sure where this
> function is, either.
>
> Thanks
>
> Asim
>
>
>
> On Monday, August 25, 2014 6:14:40 PM UTC-4, John Myles White wrote:
&g
You can't pull the changes to bring you up to 0.3.0 and do make clean/make?
Unless you're wiping all other dependencies, the compile step should take less
than ten minutes.
-- John
On Aug 28, 2014, at 9:35 AM, Ian Stokes-Rees wrote:
> Is there any way to get jl_uv_dlopen into an existing (pr
As we're starting to get better ideas for a documentation system, two questions
I have are how we do two things:
(1) Handle documentation of generic functions and their specialized methods
without requiring documentation of all specialized methods.
(2) Handle documentation of functions that bei
In theory, the compiler could potentially pull the bounds check out of the loop
since the loop parameters are run-time constants, which means that the bounds
check doesn't actually need to happen on each access.
-- John
On Aug 29, 2014, at 1:21 PM, Ed Scheinerman
wrote:
> The compiler can't
DataArrays has a cut function.
-- John
On Aug 29, 2014, at 11:17 AM, Florian Oswald wrote:
> hi
>
> what's the julia equivalent of this R call? i don't need the levels and
> labels, just some kind of grouping index.
>
> > cut(sample(1:10,10,TRUE),c(0,3,6,10))
>
> [1] (3,6] (6,10] (0,3] (
ons in mind. Also there may be situations where several
> packages/functions do the same thing. But it's hard for the user to find find
> simple things like that I think. let me know what you think.
>
>
>
>
> On 29 August 2014 22:29, John Myles White wrote:
> Da
Hi Asim,
It’s a little hard to work with PDF’s. Would you consider using Gists?
(https://gist.github.com)
— John
On Aug 30, 2014, at 1:47 PM, asim wrote:
>
> Hi
>
> The Blas trsv function is described as needing 7 arguments in the
> documentation. However, it only appears to work with 5 a
I can’t speak for others, but I’m very hesitant to download any kind of files
from mailing lists.
— John
On Aug 30, 2014, at 2:00 PM, asim wrote:
> Would this help?
>
> Asim
>
> On Saturday, August 30, 2014 4:49:23 PM UTC-4, John Myles White wrote:
> Hi Asim,
>
&g
This might need to be part of the Zen of Julia.
— John
On Aug 30, 2014, at 2:11 PM, Jameson Nash wrote:
> calling eval in a macro doesn't do what you think it does, so it doesn't do
> what you want
>
>
> On Sat, Aug 30, 2014 at 5:05 PM, Don MacMillen
> wrote:
> Perfect Steve, many thanks
I don’t think this example had any views. Both bindings had an equal right to
be considered the true binding.
I think we’re better off doing more education to teach people to distinguish
bindings and values.
— John
On Aug 31, 2014, at 11:27 AM, Ethan Anderes wrote:
> I've come to wish that
Bradley, it’s especially easy to edit documentation because you can make a Pull
Request right from the website.
— John
On Aug 31, 2014, at 11:30 AM, Bradley Setzler wrote:
> Thank you Adam, this works.
>
> Let me suggest that this information be included in the GLM documentation:
>
> To fit
Merged. Thanks, Bradley.
— John
On Aug 31, 2014, at 12:29 PM, Bradley Setzler wrote:
> Thank you for suggesting this, John.
>
> https://github.com/JuliaStats/GLM.jl/pull/90
>
> Bradley
>
>
> On Sunday, August 31, 2014 1:33:04 PM UTC-5, John Myles White wrote:
&g
h list, I would like to see something like a series option
> for non-parametric regression,
> glm(Y,X,data,family,link,seriesRank=2)
> where seriesRank=2 means all of the terms X1.^2, X1.*X2, X1.*X3,...,X5.^2 are
> included as regressors.
>
> Bradley
>
>
>
>
>
I think there’s a broad issue that need resolution: how do you know when a
function’s output takes control of the memory used by its arguments?
— John
On Aug 31, 2014, at 11:45 AM, Ethan Anderes wrote:
> Yeah, I can see your point John. It's probably not reasonable to make a new
> AliasedArr
X1.^2
> X2.^2
> X3.^2
> X1.*X2
> X1.*X3
> X2.*X3
> X1.*X2.*X3
>
> Bradley
>
> On Sunday, August 31, 2014 2:55:22 PM UTC-5, John Myles White wrote:
> Bradley, you’re forgetting about interactions terms.
>
> — John
>
> On Aug 31, 2014, at 12:53 PM,
do it separately, like a function
> seriesData = createSeries(data, rank=2)
> which returns a DataFrame that contains all of those series terms. Then
> seriesData would simply be used as the data argument in glm().
>
> Bradley
>
> On Sunday, August 31, 2014 3:05:12 PM UTC-5
Have you tried macroexpand?
— John
On Aug 31, 2014, at 10:28 PM, Mykel Kochenderfer
wrote:
> I want to do a calculation like this $\max_{a \in A} \sum_{s \in S} g(s, a)$.
>
> Of course, I can do something like this:
> maximum([sum([g(s, a) for s in S]) for a in A])
>
> But it seems like it
to be able to explain how to identify the different
> behavior to a beginner.
>
> -Ethan
>
> On Sunday, August 31, 2014 12:58:43 PM UTC-7, John Myles White wrote:
>
>
>
> I think there’s a broad issue that need resolution: how do you know when a
> function’s output takes control of the memory used by its arguments?
>
> — John
>
>
>
>
>
Use vec
On Sep 3, 2014, at 11:35 AM, David Smith wrote:
> Ok, so you can continue using the old squeeze. Us reckless types can use the
> aggressive one. ;-)
>
> I don't see why it shouldn't be available. Is there a fear that new users
> will run into subtle errors and hate Julia because of
In general, type inference doesn’t always converge in the global scope.
In this case, you’re seeing that type inference is missing information because
of the reference to cols, which isn’t a compile-time constant.
I personally recommend using typed comprehensions everywhere for explicitness
and
It is definitely possible. You just need to use toplevel, which is a magic that
Jeff doesn't want people to know about.
-- John
On Sep 5, 2014, at 12:52 PM, Ben Arthur wrote:
> sorry to resurrect this old post, but what is the definitive answer to
> whether it's possible to "@eval export ...
How do you feel about using Set( [(1, 2)] )?
— John
On Sep 5, 2014, at 5:01 PM, Sam L wrote:
> I can't figure out how to make a set of tuples in a very clean way.
>
> This works:
>
> julia> push!(Set{(Int, Int)}(), (1,2))
> Set{(Int64,Int64)}({(1,2)})
>
> but this doesn't:
>
> julia> Set(
I am hoping that the 0.4 release of Julia will coincide with a major cleanup of
the Data* world. I wrote up a very high level overview of my goals here:
https://gist.github.com/johnmyleswhite/ad5305ecaa9de01e317e
There’s still more work to do to flesh out these ideas, but the basic
principles a
some time into the future.
— John
On Sep 6, 2014, at 11:15 PM, Iain Dunning wrote:
> I saw on some list/issue you were thinking of working on a more fresh
> approach to the whole data storage situation - is that post 0.4?
>
> On Saturday, September 6, 2014 10:30:04 PM UTC-4, John
No, DataFrames are not indexed. For now, you’d need to build a wrapper that
indexes a DataFrame to get that kind of functionality.
— John
On Sep 7, 2014, at 9:53 AM, Steven Sagaert wrote:
> Hi,
> I was wondering if searching in a dataframe is indexed (in the DB sense, not
> array sense. e.g.
It gets expanded in chunks.
— John
On Sep 7, 2014, at 10:15 AM, Steven Sagaert wrote:
> When you start with an empty array and grow it one element at a time with
> push!, does the underlying array memory block get copied & expanded by one or
> in larger chunks (like ArrayList in Java)?
t of John's just-announced goals:
> https://gist.github.com/johnmyleswhite/ad5305ecaa9de01e317e
>
>
>
> On Sun, Sep 7, 2014 at 12:54 PM, John Myles White
> wrote:
> No, DataFrames are not indexed. For now, you’d need to build a wrapper that
> indexes a DataFrame to
I think we’re still not really interested in promoting the use of NaN as a
surrogate for NULL, especially given that Nullable is going to be added to Base
in 0.4.
Your functions would perform substantially better if you iterated over the
values of A. For example,
function nanmean(A::Array)
es have at least some interesting
> advantages over row oriented systems.
>
> On Sunday, September 7, 2014 10:32:53 AM UTC-7, John Myles White wrote:
> FWIW, I think it’s much easier to index structures if every row has an atomic
> existence that is independent of the table it is
grows beyond it's underlying size. (This might change
> when the array gets large, but I haven't looked at that code recently, so I
> forget the details.)
>
> Cheers,
>Kevin
>
> On Sunday, September 7, 2014, John Myles White
> wrote:
> It gets expanded in c
Hi Alex,
You can’t use things like x_$i as variable names. The $i interpolation trick
applies only to strings — no other construct in the entire language will
perform this kind of interpolation.
You could use a macro to generate variables like this, but it’s not clear to me
why you’d want to.
f things I want this action to be done on, which is apparently not the
> right way of thinking.
>
> n=5
> x_foo=zeros(n,n)
> x_bar=zeros(n,n)
>
> for i in ["foo","bar"]
>
> x_$i = x_$i + n
> println("x_$i")
>
> end
>
>
;s data.table is nice but unfortunately only supports just one index.
>
> Also worth thinking about this in the context of John's just-announced goals:
> https://gist.github.com/johnmyleswhite/ad5305ecaa9de01e317e
>
>
>
> On Sun, Sep 7, 2014 at 12:54 PM, John Myles Wh
One problem with your consistency point, Wilfred: you can iterate over an array
of arbitrary order with a single for loop.
-- John
On Sep 7, 2014, at 4:19 PM, m...@wilfred.me.uk wrote:
> Sorry, 'cripes' was just me saying that it surprised me. Let me attempt to
> make the case for change.
>
I kind of suspect my team (which is the team that invented Hive) isn't likely
to stop using Hive anytime soon.
-- John
On Sep 7, 2014, at 4:50 PM, Steven Sagaert wrote:
>
>
> On Monday, September 8, 2014 1:37:50 AM UTC+2, John Myles White wrote:
> Well, you can write an in
I'm pretty sure you shouldn't have to write an explicit tuple. If
rand(Normal(0, 1), 10, 10) doesn't work, I believe that's a bug.
-- John
On Sep 7, 2014, at 4:54 PM, curiousle...@gmail.com wrote:
> Have you tried:
>
> using Distributions
> x = rand(Normal(0,1),(10,10))
>
> That should work.
I think the types of your inputs might be wrong. In particular, I think the
type of the inner containers isn't right: you're getting Array{Array{T,N},1}
when you wanted Array{Array{E,1},1} for some specific E.
-- John
On Sep 7, 2014, at 5:50 PM, Zenna Tavares wrote:
> What am I doing wrong w
Done: https://github.com/JuliaLang/julia/issues/8269
— John
On Sep 7, 2014, at 1:38 PM, Kevin Squire wrote:
> Interesting read! How about opening an issue?
>
> On Sunday, September 7, 2014, John Myles White
> wrote:
> Since we’re on this topic, I recently discovered this
I suspect the only way to do this is to change Interact so that it exposes a
minimum time threshold before it registers a state change.
— John
On Sep 8, 2014, at 4:16 AM, Andrei Berceanu wrote:
> I have some code along the lines of
>
> f = figure()
> @manipulate for α=1:0.1:3, β=1:0.1:3, γ=1
I don't believe this exists, but it should be easy to write by combining ideas
from Julia's cumsum and foldl. You'd end up with cumfoldl and cumfoldr.
-- John
On Sep 9, 2014, at 7:29 AM, John Drummond wrote:
> What's the idiomatic way of writing Mathematica's Foldlist in Julia?
> i.e. a fold
Try vcat/hcat.
-- John
On Sep 9, 2014, at 3:31 PM, Diego Tapias wrote:
> Thanks for answering!, but what if I want to form a matrix of dimension 2 and
> not an array of dimension 1.
>
> 2014-09-09 17:27 GMT-05:00 Stefan Karpinski :
> append!(v,w) – it modifies and returns v.
>
>
> On Wed,
You want show, not print.
-- John
On Sep 9, 2014, at 3:32 PM, muraveill wrote:
> This is really confusing. In the REPL one can evaluate a stream to get useful
> info on what the object is:
>
> julia> f
> IOStream()
>
> But in a script, just "f" would not work, so for debugging I try to prin
Gray,
You can make parametric types that depend on symbols. Read the code in
Calculus.jl for examples:
https://github.com/johnmyleswhite/Calculus.jl/blob/master/src/symbolic.jl
-- John
On Sep 10, 2014, at 9:20 AM, Gray Calhoun wrote:
> Hi everyone, I'm writing code using expressions fairly
Sweet!
-- John
On Sep 10, 2014, at 9:46 AM, Randy Zwitch wrote:
> Jacob and I are now collaborating on wrapping the liboauth library, if anyone
> else is interested:
>
> https://github.com/randyzwitch/OAuth.jl
>
> On Tuesday, September 9, 2014 8:41:49 AM UTC-4, Randy Zwitch wrote:
> Yes I d
Perhaps these help support the use of Bool as a mechanism for defining im?
-- John
On Sep 10, 2014, at 8:20 PM, Dan Luu wrote:
> In bool.jl, there are things like
>
> signbit(x::Bool) = false
> sign(x::Bool) = x
> abs(x::Bool) = x
> abs2(x::Bool) = x
>
> Are these because Bool is a subtype o
This sure looks like you're not making any copies when you seem to want copies.
In particular, this line:
> cellList[i] = Cell(i, oVector)
probably needs to be
> cellList[i] = Cell(i, copy(oVector))
-- John
On Sep 10, 2014, at 6:41 PM, Andre Bieler wrote:
> can anyone tell me why the f
up some easily parallelizable operations.
>
> -viral
>
> On Sunday, September 7, 2014 11:47:44 AM UTC+5:30, John Myles White wrote:
> Yeah, that’s a way more ambitious project. That’ll take at least a year to
> make any progress at all. Before I could even begin, I need t
For future reference, I'd really appreciate you not referring to my writing as
"quite erroneous" when the claims made are in fact correct.
-- John
On Sep 11, 2014, at 2:38 PM, Mohammed El-Beltagy
wrote:
> In a recent blog by John Myles White
> http://www.johnmyleswhite
This article is really good. Thanks for pointing it out.
-- John
On Sep 11, 2014, at 4:10 PM, asim Ansari wrote:
> Hi
>
> This article by Duncan Temple Lang on Compiling R could be of interest.
> Mentions Juila a few times.
>
> Asim
>
> http://arxiv.org/pdf/1409.3144.pdf
I'd love it if Duncan were to start working on Julia. His ideas would be
invaluable.
-- John
On Sep 11, 2014, at 6:49 PM, Ethan Anderes wrote:
> For the past year I've been trying to get Duncan to jump to our side of the
> tracks and join in on Julia development. I haven't landed the sale, a
One point worth making: it's often much harder to estimate the tails of a
distribution than the mean.
The most natural example of this is estimating the mean of a normal
distribution. From theory we know that the population median and the population
mean are the same quantity, so we could use e
As Lint keeps improving, I feel like we should probably highlight it more
aggressively in the manual.
-- John
On Sep 12, 2014, at 10:56 AM, Tony Fong wrote:
> Lint v0.1.2 starts to track variables' type locally within a function
> declaration. So your case will correctly trigger a lint warni
We really need to standardize on a single type that reflects a single row of a
tabular data structure that gets used both by DBI and by DataFrames.
DataFrameRow is really nice because it's a zero-copy operation for DataFrames,
but we can't provide zero-copy semantics when pulling rows out of a d
It's also easier to enforce in future packages: much simpler to add convert
> methods than to re-represent rows as OrderedDicts (or whatever datatype).
>
> On Friday, September 12, 2014 12:19:47 PM UTC-5, John Myles White wrote:
> We really need to standardize on a single type
more appropriate
> format, skipping the OrderedDict intermediate step).
>
> On Friday, September 12, 2014 3:26:47 PM UTC-5, John Myles White wrote:
> I'm not sure that losing zero copy semantics is actually a big performance
> hit in most pipelines.
>
> I think muc
What does that mean? A DataFrameRow can't be easily created without reference
to an existing DataFrame, so this seems like it's either a mechanism for
transferring rows from one DataFrame to another very slowly or a mechanism for
inserting duplicate rows.
-- John
On Sep 12, 2014, at 3:37 PM,
now it's slow. yes in my case it's a way of transferring a row
> from one df to another. what's a better way of doing this?
>
> On 12 September 2014 22:39, John Myles White wrote:
> What does that mean? A DataFrameRow can't be easily created without reference
&
taframes) and
> allocate the full object beforehand, but it's very convenient to push onto
> master_df in this way, without having to lookup the right index where to put
> it.
>
> On 12 September 2014 22:45, John Myles White wrote:
> Well, slow might be a little unfair. Ar
No worries. I'm glad you enjoy my blog posts.
-- John
On Sep 13, 2014, at 11:32 AM, Mohammed El-Beltagy
wrote:
> On Friday, September 12, 2014 8:33:03 AM UTC+3, John Myles White wrote:
> For future reference, I'd really appreciate you not referring to my writing
> as &qu
This kind of subset operation is no longer possible. It doesn't make sense in a
language without ubiquitous delayed evaluation.
Can I ask what docs you found this operation described in? We should take them
down, because they're clearly out-of-date.
-- John
On Sep 14, 2014, at 4:12 PM, Arshak
I’m not so sure that we should follow the lead of Octave and R here. Neither of
those languages reify distributions as types, so changes to their RNG’s don’t
affect other operations on those same distributions.
In contrast, the proposed change here would break a lot of other code in
Distributio
ll accept lambda = 0, so the
> textbook definition isn't necessarily the popular one! On the other hand,
> Scipy returns an error).
>
> Regards,
> Jamie
>
> On Monday, 15 September 2014 16:03:32 UTC+1, John Myles White wrote:
> I’m not so sure that we should follow
;t necessarily the popular one! On the other hand,
> Scipy returns an error).
>
> Regards,
> Jamie
>
> On Monday, 15 September 2014 16:03:32 UTC+1, John Myles White wrote:
> I’m not so sure that we should follow the lead of Octave and R here. Neither
> of those languages r
Hi Josimar,
Julia arrays are not indexed using parentheses: they are indexed using brackets.
Assuming you have an array like x = zeros(10), you can do
for i in 1:10
x[i] = i*i
end
You also don’t need semicolons in Julia.
— John
On Sep 15, 2014, at 5:15 PM, Josimar Silva wrote:
> Hi
You are a genuine Julia community hero, Tony.
-- John
On Sep 16, 2014, at 9:17 AM, Tony Fong wrote:
> Thanks to this discussion, I have added some performance related lint
> messages related to type declaration. It would catch dimension-less array
> field type going forward.
>
>
> On Tues
Hi Nils,
Try something like:
A = Array(Any, 10)
for i in 1:10
A[i] = randn(1, 10)
end
On Sep 18, 2014, at 6:47 AM, nils.gu...@gmail.com wrote:
> I'm sure this is an extremely trivial question, but I can't seem to find an
> answer anywhere. I'm trying to store a couple of matrices of di
1 has type Int. If you add it to something with a different type, you might be
causing type instability. What happens if you replace the literal 1 with one(T)
for the type you're working with?
-- John
On Sep 18, 2014, at 9:56 AM, G. Patrick Mauroy wrote:
> Profiling shows incrementing integ
I think that was a typo for not surprised.
-- John
On Sep 18, 2014, at 9:59 AM, Steven G. Johnson wrote:
>
>
> On Thursday, September 18, 2014 12:00:32 PM UTC-4, Florian Oswald wrote:
> well, I guess most computer scientists would be surprised. writing on a piece
> of paper
>
> -10^2
>
>
Try findnz.
This seems to not be documented in the sparse section of the manual, but I
would think it should be.
— John
On Sep 18, 2014, at 6:58 PM, DumpsterDoofus wrote:
> Given column vectors I, J, and V, one can construct a sparse matrix using the
> following syntax:
>
> sparse(I, J, V)
Submit a pull request?
One point: I think you may have flipped column indices and row indices in your
description.
— John
On Sep 18, 2014, at 7:45 PM, DumpsterDoofus wrote:
> Thanks, that's what I was looking for! I forked a copy of the documentation
> on my GitHub account and added in the
Depth-first search and replace?
— John
On Sep 19, 2014, at 7:32 AM, David P. Sanders wrote:
>
>
> El viernes, 19 de septiembre de 2014 09:26:09 UTC-5, David P. Sanders
> escribió:
>
>
> El viernes, 19 de septiembre de 2014 08:58:56 UTC-5, Isaiah escribió:
> To do what you want, very brief
Here’s a 20% sample:
{
julia> using DataFrames
julia> using StatsBase
julia> df = DataFrame(A = 1:10, B = 2:2:20)
10x2 DataFrame
|-|||
| Row | A | B |
| 1 | 1 | 2 |
| 2 | 2 | 4 |
| 3 | 3 | 6 |
| 4 | 4 | 8 |
| 5 | 5 | 10 |
| 6 | 6 | 12 |
| 7 | 7 | 14 |
| 8
If you change Base, you do need to regenerate the system image. I always do
this by running make clean and make, but it might be possible to do things
faster than that process.
— John
On Sep 20, 2014, at 2:57 PM, Erik Schnetter wrote:
> I am trying to add "info" calls to Base functions to de
201 - 300 of 919 matches
Mail list logo
