There is no need to modify a copy; only the Nullable is immutable and not
its underlying value. Just instead of modifying ec.title, modify
get(ec.title). Like setfield!(get(ec.title), k, v). In short scripts, I
often define getindex(x::Nullable) = get(x) so that I can write ec.title[]
instead o
er 21, 2016 at 4:50:26 PM UTC, Fengyang Wang wrote:
>>
>> but type piracy is bad practice. This method should really be in Base.
>>
>
> As always, if something, should be in Base or Julia, then I think a PR is
> welcome.
>
> [Maybe I do not fully understand this (y
You could even do x[direction] += rand([-1, 1]). The allocation can be
avoided by defining a global constant with [-1, 1] as its contents.
On Saturday, September 24, 2016 at 6:54:47 PM UTC-4, Steven G. Johnson
wrote:
>
>
>
> On Saturday, September 24, 2016 at 6:09:14 PM UTC-4, David P. Sanders
Oh yeah, or x[direction] += rand(-1:2:1) to avoid the need for the
allocation in the first place.
On Sunday, September 25, 2016 at 1:01:47 AM UTC-4, Fengyang Wang wrote:
>
> You could even do x[direction] += rand([-1, 1]). The allocation can be
> avoided by defining a global constant
There should be no copy if you reshape a view.
julia> reshape((@view x[1:6]), (3, 2))
3×2
Base.ReshapedArray{Float64,2,SubArray{Float64,1,Array{Float64,1},Tuple{UnitRange{Int64}},true},Tuple{}}:
1.0 1.0
1.0 1.0
1.0 1.0
On Sunday, October 2, 2016 at 8:43:01 AM UTC-4, Alexey Cherkaev wrote:
It is not in general possible to recover the function itself from a method,
as methods are specific to types and not functions. Multiple functions can
share methods if those functions have the same type.
In the case of generic (or singleton) functions, you can recover the
function from the inst
I would also personally prefer a Discourse-based forum to this Google
Groups mailing list.
On Saturday, September 19, 2015 at 8:16:36 PM UTC-4, Jonathan Malmaud wrote:
>
> Hi all,
> There's been some chatter about maybe switching to a new, more modern
> forum platform for Julia that could potent
I think you have misunderstood Kristoffer. It's possible the Int values
themselves are of distinct types; note for instance
julia> Array{Int, Int32(1)}
Array{Int64,1}
julia> Array{Int, 1}
Array{Int64,1}
julia> Array{Int, Int32(1)} == Array{Int, 1}
false
On Thursday, October 6, 2016 at 10:52
The ^ operator can be used for implication. Due to Curry-Howard,
implication is isomorphic to function abstraction, which combinatorially
can be counted using the exponentiation function.
On Thursday, October 6, 2016 at 12:10:51 PM UTC-4, Kevin Liu wrote:
>
> How is an implication represented in
HackerRank supports Julia in its Algorithms domain and related contests. I
sent a support request to extend this to the Mathematics domain.
On Monday, June 27, 2016 at 10:39:52 PM UTC-4, Андрей Логунов wrote:
>
> Are there any projects/initiatives to apply Julia with online judge
> systems (http
As Jussi Piitulainen noted, the ^ operator is backwards, so you need to
wrap it around a function.
On Friday, October 7, 2016 at 10:05:34 AM UTC-4, Kevin Liu wrote:
>
> *julia> **@code_native(b^a)*
>
>.section__TEXT,__text,regular,pure_instructions
>
> Filename: bool.jl
>
> Source
The `showall` function does this.
On Monday, October 10, 2016 at 3:16:20 PM UTC-4, John Paul Vasquez wrote:
>
> Is there a command/option to display all the elements of a very long
> array? The output gets cut in the middle. For example when calling
> Pkg.available(), I only see the head and tai
It is also possible to use @type and @immutable, although the macros are
slightly harder to define.
macro lit_str(s); Symbol(s); end
macro lit"type"(x)
...
end
macro lit"immutable"(x)
...
end
@type ...
@immutable ...
On Saturday, October 29, 2016 at 6:16:37 PM UTC-4, Jake Rosoman wr
There is no need to do this in Julia; you can simply initialize in the
default argument.
function f(x; y=[x, x, x])
@show x y
end
then
julia> f(1)
x = 1
y = [1,1,1]
because in Julia, unlike Python, the initialization is done at calltime
instead of function definition time.
On Friday, No
Hi,
I learned Julia recently, and I must say it has been incredible for
scientific work. I am in love with the clean, modern syntax. Props to the
developers for their tireless efforts to improve this language even further!
Historically, Lua and Javascript have been the most common choices for
Thank you for your response! This has been very helpful.
Thank you for your response! This has been very helpful.
On Wednesday, August 26, 2015 at 1:17:06 PM UTC-4, Stefan Karpinski wrote:
>
> Is JavaScript actually easy to integrate with Java?
>
Java has always come bundled with a Javascript interpreter (first Rhino,
now Nashorn). It can be used like this:
*package sample1;*
*import javax.script.ScriptEng
Are you using solarized, by any chance? That terminal theme is notorious
for changing around the meaning of colours. I would avoid it if possible.
This can't work because it would not, for instance, make sense to use
module `M` independently. You could use the parent module from `M`, but as
it stands that won't work either because loading the parent module will try
to use `f` from `M`. What are you trying to do?
On Monday, June 20, 2016 a
This would be one form of tech evangelism. I wonder if there are any
communities set up for Julia evangelism?
The typealias is the best solution I know of.
I don't know about performance or correctness, but it *is* possible to do
something like this:
x :: SomeType{X, TypeVar(:T), Z}
but I think the typealias is a better solution.
It is no longer true that
show(io, x)
should be overriden for MIME text/plain. Instead, the MIME version is for
multiline display, and the two-argument form for single-line display. See
https://github.com/JuliaLang/julia/pull/17113.
On Saturday, July 2, 2016 at 8:06:28 AM UTC-4, Steven G. Joh
let is lowered to what is basically a function that's executed immediately.
It should have identical performance on 0.5.
On Friday, July 1, 2016 at 10:31:20 AM UTC-4, David Gold wrote:
>
> Depends which version you're on. On 0.5, where anonymous functions are
> performant, I think the way to go
Hi Ferran,
Just a quick note that any solution (including Mauro's) *must* make a
copy—as the original vectors are not contiguous in memory, they have to be
copied to form an array.
Generally, pointers returned from ccalls should be freed with the free
function from the same library. From the documentation of Libc.free:
Call free from the C standard library. Only use this on memory obtained from
> malloc, not on pointers retrieved from other C libraries. Ptr objects
> obtain
On Monday, August 8, 2016 at 10:26:46 AM UTC-4, Kevin Squire wrote:
>
> Try
>
> import Base.(!)
>
> Cheers,
> Kevin
>
Why do import statements have different syntax? This syntax, I'm pretty
sure, has either meant getfield or broadcast—in neither case does it
actually refer to the ! function
I think the problem is that ConjugatePriors is holding PDMats back, while
Distributions wants to move it forward. Try removing it and see if
Distributions will update.
What is the standard MIME type for Julia code?
My reading of the MIME standard leads to me think
application/x-julia
is the accurate choice. However, I could only find few results on Google,
and Julia doesn't currently recognize this as a text MIME.
Should application/julia perhaps be recognized as a text MIME, then?
julia> istextmime("application/julia")
false
julia> istextmime("application/javascript")
true
A PR making this change: https://github.com/JuliaLang/julia/pull/18441
This is an intuitive explanation, but the mathematics of IEEE floating
points seem to be designed so that 0.0 represents a "really small positive
number" and -0.0 represents "exact zero" or at least "an even smaller
really small negative number"; hence -0.0 + 0.0 = 0.0. I never understood
this
julia> foo(x) = 0
foo (generic function with 1 method)
julia> foo(x::Int) = 0.0
foo (generic function with 2 methods)
julia> foo.(Any[1, 2, 3])
3-element Array{Float64,1}:
0.0
0.0
0.0
julia> foo.(Number[1, 2, 3])
3-element Array{Number,1}:
0.0
0.0
0.0
My understanding was that the actual
In addition to Mauro's answer, programatically, you can do
which(issymmetric, Tuple{typeof(fill(NaN, 1, 1))}), which is almost your
preferred syntax.
I wonder why this is desirable. A type instability in the array type is
unlikely to be of much concern, because the cost of array operations will
wildly overshadow the cost of a dynamic dispatch. Once the array passes a
function barrier, its eltype becomes inferrable. A type instability in a
sc
I was looking for a Julia package to handle rational functions, when I
noticed that the `Polynomials` package implements `gcd`, `div`, and `rem`.
So it would be possible to simply use `Rational{Poly}`... or so I thought.
Unfortunately, the type `Rational` prevents this use, since it requires its
collect(UInt8, "hello world")
should do the trick.
On Saturday, February 6, 2016 at 8:31:19 PM UTC-5, icebl...@gmail.com wrote:
>
> Hello,
>
> I m trying to convert ASCIIString (or ASCII) to Uint8 .
>
> b"string" seems to be the option. However it doesnt seem to handle
> b"$(variable)"
>
> Also
oes.
>
> On Saturday, February 6, 2016, Fengyang Wang > wrote:
>
>> I was looking for a Julia package to handle rational functions, when I
>> noticed that the `Polynomials` package implements `gcd`, `div`, and `rem`.
>> So it would be possible to simply use `Rational
38 matches
Mail list logo