[julia-users] Performance of Kernel Inlining

[Jared Crean]

I'm working on an high dimensional finite difference code, and I got a 
strange performance result. I have a kernel function that
computes the stencil at a given point, and an outer function, outer_func, 
that loops over the dimensions and calls the kernel function at every grid 
point.
I created a second function, outer_func2, with the same loops as 
outer_func, but rather than call the kernel function it has the contents of
the kernel function copied into it.  The source code is here: 
https://github.com/JaredCrean2/wave6d/blob/master/src/test_inline.jl

The performance results (with bounds checking disabled and 
--math-mode=fast) are:

testing outer_func
  0.398586 seconds
  0.398821 seconds
testing outer_func2
  2.522230 seconds
  2.522479 seconds



I ran this on in Intel Ivy Bridge (i7-3820) processor, using Julia 0.4.4

I looked at the llvm code (attached), and noticed outer_func2 has a bunch 
of extra statements that look like

  %lsr.iv570 = phi i8* [ %scevgep571, %L21 ], [ %scevgep569, %L.preheader ]



that are not present for outer_func.  I don't know llvm code very well 
(hardly at all), so I'm not sure what these mean.  Any help
understanding either the llvm code or the performance difference would be 
appreciated.



  Thanks,
 Jared Crean
outer_func code_llvm = 

define void @julia_outer_func_21149(%jl_value_t*, %jl_value_t*) {
top:
  %2 = getelementptr inbounds %jl_value_t* %0, i64 3, i32 0
  %3 = bitcast %jl_value_t** %2 to i64*
  %4 = load i64* %3, align 8
  %5 = add i64 %4, -2
  %6 = icmp sgt i64 %5, 2
  %7 = select i1 %6, i64 %5, i64 2
  %8 = icmp eq i64 %7, 2
  br i1 %8, label %L23, label %L.preheader

L.preheader:  ; preds = %top
  %9 = bitcast %jl_value_t* %0 to i8**
  %10 = load i8** %9, align 8
  %11 = getelementptr inbounds %jl_value_t* %0, i64 7, i32 0
  %12 = bitcast %jl_value_t** %11 to i64*
  %13 = load i64* %12, align 8
  %14 = bitcast %jl_value_t* %1 to i8**
  %15 = load i8** %14, align 8
  %16 = getelementptr inbounds %jl_value_t* %1, i64 3, i32 0
  %17 = bitcast %jl_value_t** %16 to i64*
  %18 = load i64* %17, align 8
  %19 = getelementptr inbounds %jl_value_t* %1, i64 7, i32 0
  %20 = bitcast %jl_value_t** %19 to i64*
  %21 = load i64* %20, align 8
  %22 = getelementptr inbounds %jl_value_t* %1, i64 6, i32 0
  %23 = getelementptr inbounds %jl_value_t* %1, i64 5, i32 0
  %24 = getelementptr inbounds %jl_value_t* %1, i64 4, i32 0
  %25 = getelementptr inbounds %jl_value_t* %0, i64 6, i32 0
  %26 = getelementptr inbounds %jl_value_t* %0, i64 5, i32 0
  %27 = getelementptr inbounds %jl_value_t* %0, i64 4, i32 0
  %28 = bitcast %jl_value_t** %22 to i64*
  %29 = bitcast %jl_value_t** %23 to i64*
  %30 = bitcast %jl_value_t** %24 to i64*
  %31 = bitcast %jl_value_t** %25 to i64*
  %32 = bitcast %jl_value_t** %26 to i64*
  %33 = bitcast %jl_value_t** %27 to i64*
  %34 = load i64* %28, align 8
  %35 = load i64* %29, align 8
  %36 = load i64* %30, align 8
  %37 = load i64* %31, align 8
  %38 = load i64* %32, align 8
  %39 = load i64* %33, align 8
  %40 = mul i64 %39, %4
  %41 = mul i64 %40, %38
  %42 = mul i64 %41, %37
  %43 = mul i64 %36, %18
  %44 = mul i64 %43, %35
  %45 = mul i64 %44, %34
  %46 = add i64 %4, -2
  %47 = icmp sgt i64 %46, 2
  %smax = select i1 %47, i64 %46, i64 2
  %48 = add i64 %smax, -2
  br label %L2.preheader

L2.preheader: ; preds = %L21, %L.preheader
  %"#s1.0" = phi i64 [ %49, %L21 ], [ 3, %L.preheader ]
  %49 = add i64 %"#s1.0", 1
  %50 = add i64 %"#s1.0", -3
  %51 = add i64 %"#s1.0", -2
  %52 = add i64 %"#s1.0", -1
  br label %L4.preheader

L4.preheader: ; preds = %L19, %L2.preheader
  %"#s2.0" = phi i64 [ %53, %L19 ], [ 3, %L2.preheader ]
  %53 = add i64 %"#s2.0", 1
  %54 = add i64 %"#s2.0", -1
  %55 = mul i64 %54, %4
  %56 = add i64 %50, %55
  %57 = add i64 %51, %55
  %58 = add i64 %52, %55
  %59 = add i64 %55, %"#s1.0"
  %60 = add i64 %49, %55
  %61 = add i64 %"#s2.0", -3
  %62 = mul i64 %61, %4
  %63 = add i64 %52, %62
  %64 = add i64 %"#s2.0", -2
  %65 = mul i64 %64, %4
  %66 = add i64 %52, %65
  %67 = mul i64 %"#s2.0", %4
  %68 = add i64 %52, %67
  %69 = mul i64 %53, %4
  %70 = add i64 %52, %69
  %71 = mul i64 %54, %18
  %72 = add i64 %52, %71
  br label %L6.preheader

L6.preheader: ; preds = %L17, %L4.preheader
  %"#s3.0" = phi i64 [ %73, %L17 ], [ 3, %L4.preheader ]
  %73 = add i64 %"#s3.0", 1
  %74 = add i64 %"#s3.0", -1
  %75 = mul i64 %74, %40
  %76 = add i64 %56, %75
  %77 = add i64 %57, %75
  %78 = add i64 %58, %75
  %79 = add i64 %59, %75
  %80 = add i64 %60, %75
  %81 = add i64 %63, %75
  %82 = add i64 %66, %75
  %83 = add i64 %68, %75
  %84 = add i64 %70, %75
  %85 = add i64 %"#s3.0", -3
  %86 = mul i64 %85, %40
  %87 = add i64 %58, %86
  %88 = add i64 %"#s3.0", -2
  %89 = mul i64 %88, %40
  %90 = add i64 %58, %89
  %91 = mul i64 %"#s3.0", %40
  %92 = add i64 %58, %91
  %93 = mul i64 %73, 

Re: [julia-users] Re: so many plotting packages

[Isaiah Norton]

>
> the julia community would benefit by collecting all these packages in one
> place.
>

There are only 3 or 4 of those packages that should be recommended for
general use. If someone wants to help users decide what package to use,
write up a comparison page with examples. It could be linked from the
existing blurbs on the download page.

i'd suggest moving the rest to juliagraphics.  make sense?


Trying to herd together a group of people who have already rejected the
aesthetic or engineering choices of existing, competing projects seems
totally futile. Winston and Gadfly existed before many of the newer
packages, but people chose to start/use/contribute to newer things anyway.
Putting packages in an org doesn't make people want to start cooperating.
Some of those listed are unmaintained or hobby experiments, and as your
link demonstrates, sometimes people just want to do their own thing -- and
that's fine!

On Fri, Oct 28, 2016 at 9:47 PM, Ben Arthur  wrote:

> i wasn't looking for recommendations.  am happily using gadfly.  started
> out with pyplot three years ago.
>
> rather, i just think the julia community would benefit by collecting all
> these packages in one place.  since tbreloff appears to want to keep an iron
> grip
> 
> on juliaplots, i'd suggest moving the rest to juliagraphics.  make sense?
>>
>>

[julia-users] Re: so many plotting packages

[Ben Arthur]

i wasn't looking for recommendations.  am happily using gadfly.  started 
out with pyplot three years ago.

rather, i just think the julia community would benefit by collecting all 
these packages in one place.  since tbreloff appears to want to keep an iron 
grip 
 on 
juliaplots, i'd suggest moving the rest to juliagraphics.  make sense?
>
>

[julia-users] Re: so many plotting packages

[Chris Rackauckas]

Just use Plots.jl. JuliaPlots and Plots.jl is essentially a metapackage/org 
which puts this all together into one convenient package. It works very 
well and should be recommended as the standard plotting package to almost 
everyone.

On Friday, October 28, 2016 at 12:17:56 PM UTC-7, Ben Arthur wrote:
>
> would be nice to have an organization to contain all of these. as 
> @StefanKarpinski  pointed out (i 
> forget where exactly), it would help to encourage developers to work 
> together. it would also help new users of julia figure out which package 
> they want to use.
>
> https://github.com/johnmyleswhite/ASCIIPlots.jl
> http://github.com/baggepinnen/ExperimentalAnalysis.jl 
> 
> http://github.com/jheinen/GR.jl 
> http://github.com/GiovineItalia/Gadfly.jl 
> 
> http://github.com/mbaz/Gaston.jl 
> http://github.com/ma-laforge/GracePlot.jl 
> 
> http://github.com/ma-laforge/InspectDR.jl 
> 
> http://github.com/sisl/PGFPlots.jl 
> http://github.com/plotly/Plotly.jl 
> http://github.com/tbreloff/Plots.jl 
> http://github.com/JuliaPy/PyPlot.jl 
> http://github.com/ig-or/QWTwPlot.jl 
> http://github.com/tbreloff/Qwt.jl 
> http://github.com/rennis250/Sparrow.jl 
> 
> http://github.com/sunetos/TextPlots.jl 
> 
> http://github.com/Evizero/UnicodePlots.jl 
> 
> http://github.com/nolta/Winston.jl 
>

[julia-users] Re: ANN: ParallelAccelerator v0.2 for Julia 0.5 released.

[Chris Rackauckas]

1) Won't that have bad interactions with pre-compilation? Since macros 
apply at parse time, the package will stay in the "state" the it 
precompiles in: so if one precompiles the package and then adds 
ParallelAccelerator, wouldn't that not be used? And the other way around, 
if one removes ParallelAccelerator, won't the package be unusable without 
manually deleting the precompile cache? I think that to use this you'd have 
to link the precompilation of the package to whether you have changes in 
ParallelAccelerator.

2) Shouldn't/Won't Base auto-parallelize broadcasted calls? That seems like 
the clear next step after loop fusing is finished and threading is no 
longer experimental. Where else is the implicit parallelism hiding?

On Thursday, October 27, 2016 at 2:02:38 PM UTC-7, Todd Anderson wrote:
>
> To answer your question #1, would the following be suitable?  There may be 
> a couple details to work out but what about the general approach?
>
> if haskey(Pkg.installed(), "ParallelAccelerator")
> println("ParallelAccelerator present")
>
> using ParallelAccelerator
>
> macro PkgCheck(ast)
> quote
> @acc $(esc(ast))
> end
> end
> else
> println("ParallelAccelerator not present")
>
> macro PkgCheck(ast)
> return ast
> end
> end
>
> @PkgCheck function f1(x)
> x * 5
> end
>
> a = f1(10)
> println("a = ", a)
>
>
> 2) The point of ParallelAccelerator is to extract the implicit parallelism 
> automatically.  The purpose of @threads is to allow you to express 
> parallelism explicitly.  So, they both enable parallelism but the former 
> has the potential to be a lot easier to use particularly for scientific 
> programmers who are more scientist than programmer.  In general, I feel 
> there is room for all approaches to be supported across a range of 
> programming ability.  
>
> On Thursday, October 27, 2016 at 10:47:57 AM UTC-7, Chris Rackauckas wrote:
>>
>> Thank you for all of your amazing work. I will be giving v0.2 a try soon. 
>> But I have two questions:
>>
>> 1) How do you see ParallelAccelerator integrating with packages? I asked 
>> this in the chatroom, but I think having it here might be helpful for 
>> others to chime in. If I want to use ParallelAccelerator in a package, then 
>> it seems like I would have to require it (and make sure that every user I 
>> have can compile it!) and sprinkle the macros around. Is there some 
>> sensible way to be able to use ParallelAccelerator if it's available on the 
>> user's machine, but not otherwise? This might be something that requires 
>> Pkg3, but even with Pkg3 I don't see how to do this without having one 
>> version of the function with a macro, and another without it.
>>
>> 2) What do you see as the future of ParallelAccelerator going forward? It 
>> seems like Base Julia is stepping all over your domain: automated loop 
>> fusing, multithreading, etc. What exactly does ParallelAccelerator give 
>> that Base Julia does not or, in the near future, will not / can not? I am 
>> curious because with Base Julia getting so many optimizations itself, it's 
>> hard to tell whether supporting ParallelAccelerator will be a worthwhile 
>> investment in a year or two, and wanted to know what you guys think of 
>> that. I don't mean you haven't done great work: you clearly have, but it 
>> seems Julia is also doing a lot of great work!
>>
>> On Tuesday, October 25, 2016 at 9:42:44 AM UTC-7, Todd Anderson wrote:
>>>
>>> The High Performance Scripting team at Intel Labs is pleased to announce 
>>> the release of version 0.2 of ParallelAccelerator.jl, a package for 
>>> high-performance parallel computing in Julia, primarily oriented around 
>>> arrays and stencils.  In this release, we provide support for Julia 0.5 and 
>>> introduce experimental support for the Julia native threading backend.  
>>> While we still currently support Julia 0.4, such support should be 
>>> considered deprecated and we recommend everyone move to Julia 0.5 as Julia 
>>> 0.4 support may be removed in the future.
>>>
>>> The goal of ParallelAccelerator is to accelerate the computational 
>>> kernel of an application by the programmer simply annotating the kernel 
>>> function with the @acc (short for "accelerate") macro, provided by the 
>>> ParallelAccelerator package.  In version 0.2, ParallelAccelerator still 
>>> defaults to transforming the kernel to OpenMP C code that is then compiled 
>>> with a system C compiler (ICC or GCC) and transparently handles the 
>>> invocation of the C code from Julia as if the program were running normally.
>>>
>>> However, ParallelAccelerator v0.2 also introduces experimental backend 
>>> support for Julia's native threading (which is also experimental).  To 
>>> enable native threading mode, set the environment variable 
>>> PROSPECT_MODE=threads.  In this mode, ParallelAccelerator identifies pieces 
>>> of code that can be run in parallel and then runs that code as if it had 
>>> 

Re: [julia-users] Parsing complex numbers

[Jérémy Béjanin]

How easy would it be to make one assuming the standard julia notation 3+4im?

On Friday, October 28, 2016 at 3:58:08 PM UTC-4, Yichao Yu wrote:
>
> On Fri, Oct 28, 2016 at 3:53 PM, Jérémy Béjanin 
>  wrote: 
> > I've noticed that parsing a string representing a real number yields a 
> real 
> > number, but parsing a string representing a complex number yields an 
> > expression that must subsequently be evaluated. Is there a reason for 
> that 
> > behaviour? I'd like to avoid that behaviour considering I am reading 
> > user-inputted data. 
> > 
> > ```julia 
> > julia> typeof(parse("1.60254+3im")) 
> > Expr 
> > 
> > julia> typeof(parse("1.60254")) 
> > Float64 
> > ``` 
>
> Do no use `parse(::String)` to parse numbers. It is for parsing 
> generic julia code. Use `parse(Float64, str)` to parse a floating 
> point number. 
>
> I don't think we have a parsing function for complex number likely 
> because there isn't a universal standard. 
>

[julia-users] Re: ANN: ParallelAccelerator v0.2 for Julia 0.5 released.

[Todd Anderson]

Looks like version 0.2.1 has been merged now.

On Wednesday, October 26, 2016 at 5:13:38 PM UTC-7, Todd Anderson wrote:
>
> Okay, METADATA with ParallelAccelerator verison 0.2 has been merged so if 
> you do a standard Pkg.add() or update() you should get the latest version.
>
> For native threads, please note that we've identified some issues with 
> reductions and stencils that have been fixed and we will shortly be 
> released in version 0.2.1.  I will post here again when that release takes 
> place.
>
> Again, please give it a try and report back with experiences or file bugs.
>
> thanks!
>
> Todd
>

[julia-users] Re: package reproducibility

[Robin Deits]

For my own work, I'm using a simple tool that I 
wrote: https://github.com/rdeits/juliet which allows you to specify git 
URLs and commit SHAs inside your REQUIRE file. Internally, it just uses 
Julia's built-in Pkg module to do most of the work, but automates checking 
out the specified revision of any unpublished packages. 

-Robin

On Friday, October 28, 2016 at 7:42:17 AM UTC-4, Steven G. Johnson wrote:
>
> Since all Julia packages are managed via git, it would be easy to write a 
> tool that collects all of the commits of the current packages into a list 
> so that you can install the same commits on another system.  I don't think 
> there is an existing tool that automates this, though?
>

Re: [julia-users] Parsing complex numbers

[Yichao Yu]

On Fri, Oct 28, 2016 at 3:53 PM, Jérémy Béjanin
 wrote:
> I've noticed that parsing a string representing a real number yields a real
> number, but parsing a string representing a complex number yields an
> expression that must subsequently be evaluated. Is there a reason for that
> behaviour? I'd like to avoid that behaviour considering I am reading
> user-inputted data.
>
> ```julia
> julia> typeof(parse("1.60254+3im"))
> Expr
>
> julia> typeof(parse("1.60254"))
> Float64
> ```

Do no use `parse(::String)` to parse numbers. It is for parsing
generic julia code. Use `parse(Float64, str)` to parse a floating
point number.

I don't think we have a parsing function for complex number likely
because there isn't a universal standard.

[julia-users] Parsing complex numbers

[Jérémy Béjanin]

I've noticed that parsing a string representing a real number yields a real 
number, but parsing a string representing a complex number yields an 
expression that must subsequently be evaluated. Is there a reason for that 
behaviour? I'd like to avoid that behaviour considering I am reading 
user-inputted data.

```julia
julia> typeof(parse("1.60254+3im"))
Expr

julia> typeof(parse("1.60254"))
Float64
```

Re: [julia-users] so many plotting packages

[Cameron McBride]

There is some work on this. On your list is Plots.jl, which is a unifying
package that is backend agnostic. Specifically,
http://github.com/tbreloff/Plots.jl

Also, see:
https://github.com/JuliaPlots

Some seriously great stuff in there (and I say that as a user that has been
plotting in Julia for a couple years now).

Cameron

On Fri, Oct 28, 2016 at 3:17 PM, Ben Arthur  wrote:

> would be nice to have an organization to contain all of these. as
> @StefanKarpinski  pointed out (i
> forget where exactly), it would help to encourage developers to work
> together. it would also help new users of julia figure out which package
> they want to use.
>
> https://github.com/johnmyleswhite/ASCIIPlots.jl
> http://github.com/baggepinnen/ExperimentalAnalysis.jl
> 
> http://github.com/jheinen/GR.jl 
> http://github.com/GiovineItalia/Gadfly.jl
> 
> http://github.com/mbaz/Gaston.jl 
> http://github.com/ma-laforge/GracePlot.jl
> 
> http://github.com/ma-laforge/InspectDR.jl
> 
> http://github.com/sisl/PGFPlots.jl 
> http://github.com/plotly/Plotly.jl 
> http://github.com/tbreloff/Plots.jl 
> http://github.com/JuliaPy/PyPlot.jl 
> http://github.com/ig-or/QWTwPlot.jl 
> http://github.com/tbreloff/Qwt.jl 
> http://github.com/rennis250/Sparrow.jl
> 
> http://github.com/sunetos/TextPlots.jl
> 
> http://github.com/Evizero/UnicodePlots.jl
> 
> http://github.com/nolta/Winston.jl 
>

[julia-users] so many plotting packages

[Ben Arthur]

would be nice to have an organization to contain all of these. as 
@StefanKarpinski  pointed out (i forget 
where exactly), it would help to encourage developers to work together. it 
would also help new users of julia figure out which package they want to 
use.

https://github.com/johnmyleswhite/ASCIIPlots.jl
http://github.com/baggepinnen/ExperimentalAnalysis.jl 

http://github.com/jheinen/GR.jl 
http://github.com/GiovineItalia/Gadfly.jl 

http://github.com/mbaz/Gaston.jl 
http://github.com/ma-laforge/GracePlot.jl 

http://github.com/ma-laforge/InspectDR.jl 

http://github.com/sisl/PGFPlots.jl 
http://github.com/plotly/Plotly.jl 
http://github.com/tbreloff/Plots.jl 
http://github.com/JuliaPy/PyPlot.jl 
http://github.com/ig-or/QWTwPlot.jl 
http://github.com/tbreloff/Qwt.jl 
http://github.com/rennis250/Sparrow.jl 

http://github.com/sunetos/TextPlots.jl 

http://github.com/Evizero/UnicodePlots.jl 

http://github.com/nolta/Winston.jl 

Re: [julia-users] anonymous function

[Stefan Karpinski]

You can write

function (x)
# body
# goes
# here
end


On Fri, Oct 28, 2016 at 3:00 PM, Yichao Yu  wrote:

> On Fri, Oct 28, 2016 at 2:59 PM, digxx  wrote:
> > I didnt see it
>
>
>
> > f = function ()
> > end
> >
> > defines an anonymous function and assigns it to a variable f.
>

Re: [julia-users] anonymous function

[Yichao Yu]

On Fri, Oct 28, 2016 at 2:59 PM, digxx  wrote:
> I didnt see it



> f = function ()
> end
>
> defines an anonymous function and assigns it to a variable f.

Re: [julia-users] anonymous function

[digxx]

I didnt see it

Re: [julia-users] anonymous function

[digxx]

sry u must have written when I was writing...

Re: [julia-users] Parameteric Function of Types

[Isaiah Norton]

On Fri, Oct 28, 2016 at 12:07 PM, Derek Gaston  wrote:

> I can't quite seem to get the right syntax for creating methods that are
> keyed off of subtypes (as a parameter).
>
> Say I have:
>
> abstract foo
> abstract bar <: foo
>
> I want to create a function that is like so:
>
> function doStuff(::Type{foo})
> end
>
> in such a way that I can call it with "Type{bar}".  i.e.:
>  doStuff(Type{bar})
>
> I understand that:
>
> # Returns true:
> issubtype(bar, foo)
>
> # Returns false:
> issubtype(Type{bar}, Type{foo})
>
> And I understand why.
>
> So... I tried to define:
>
> function doStuff{T}(::Type{T<:foo})
> end
>
> But it tells me that: "WARNING: static parameter T does not occur in
> signature" (it looks like it does to me! :-)... so that's not the right
> answer.
>

function doStuff{T <: foo}(::Type{T})
end


>
> Obviously I'm just thinking about the problem incorrectly... so can
> someone shed some light on what's up here?
>
> Before you ask: I really do need to operate on the _types_ and not on
> instances of the objects themselves (which would obviously be
> straightforward to do).
>
>
>
>
> Also: a (related) follow-on question.  What is the correct/preferred way
> to do the following:
>
> function createSomething{T}()
>   return T()
> end
>
>
If you want to implement the "factory pattern", that can be simulated, but
I'm not sure it's necessary (or useful) in Julia.

See also:
  http://stackoverflow.com/a/35524338/508431
  http://docs.julialang.org/en/latest/manual/constructors/#out
er-constructor-methods




(obviously, this is a toy example, my real application of this is not
> trivial)
>
> Is it to do:
>
> function createSomething{T}(::Type{T})
>   return T()
> end
>
> ?
>
>
>
>
> Thanks for any help!
>
> Derek
>

Re: [julia-users] Re: MersenneTwister, srand

[Isaiah Norton]

>
> So what is the difference between srand and merseentwister?


Per doc link, srand uses MT by default.

and also how do I get my random numbers


rand() for floats less than 1 by default, or specify a set to choose from:

help?> rand
search: rand randn rand! randn! randexp randperm randjump randexp!
randcycle randsubseq randstring randsubseq! RandomDevice srand sprand
sprandn sprandbool bitrand transcode

  rand([rng=GLOBAL_RNG], [S], [dims...])

  Pick a random element or array of random elements from the set of values
specified by S; S can be

•an indexable collection (for example 1:n or ['x','y','z']), or

•a type: the set of values to pick from is then equivalent to
typemin(S):typemax(S) for integers (this is not applicable to BigInt), and
to [0, 1) for floating point numbers;

what do the different fields mean?


The fields aren't intended to be accessed, but you can see each element
name with:

julia> fieldnames(MersenneTwister)
4-element Array{Symbol,1}:
 :seed
 :state
 :vals
 :idx


How do I acutally set the seed
>

srand


> srand(0) and rand() would actually be a mersennetwister I'd expect zeros
> everywhere...
>

Why?


On Fri, Oct 28, 2016 at 2:11 PM, digxx  wrote:

> Sorry but that doesn't answer my question. That's where I have the calling
> from but it does not explain the output and what it means...
>

Re: [julia-users] anonymous function

[Yichao Yu]

On Fri, Oct 28, 2016 at 2:30 PM, digxx  wrote:
> ok:
>
> f(x)=x^2 is not an anonymous function
> however
> f=x->x^2 is an anonymous function
>
> unfortunately my function is not just one line so I cant use f=x->x^2 and I
> have to use something like
>
> function f(x)
>
>
> end
>
> this however is not anonymous...
> Is there something like that with
>
> function ...
>
>
> end
>
> which is anonymous?

Yes, read my last post again.

Re: [julia-users] anonymous function

[digxx]

ok:

f(x)=x^2 is not an anonymous function
however
f=x->x^2 is an anonymous function

unfortunately my function is not just one line so I cant use f=x->x^2 and I 
have to use something like

function f(x)


end

this however is not anonymous...
Is there something like that with

function ...


end

which is anonymous?

Re: [julia-users] anonymous function

[Michele Zaffalon]

Thank you for the clarification.

On Fri, Oct 28, 2016 at 8:23 PM, Yichao Yu  wrote:

> On Fri, Oct 28, 2016 at 2:19 PM, Michele Zaffalon
>  wrote:
> > I have read somewhere that your second approach is doing two things at
> the
> > same time: defining an anonymous function and assigning the name f to it.
>
> No it's not. It defines a function named `f`
>
> f = function ()
> end
>
> defines an anonymous function and assigns it to a variable f.
>
> >
> >
> > On Fri, Oct 28, 2016 at 8:12 PM, digxx  wrote:
> >>
> >> So an anonymous function I can write like this
> >>
> >> f=x->x^2
> >>
> >> is it also possible to make an anonymous function out of this:
> >>
> >> function f(x)
> >>
> >> x^2
> >>
> >> end
> >
> >
>

Re: [julia-users] anonymous function

[Yichao Yu]

On Fri, Oct 28, 2016 at 2:19 PM, Michele Zaffalon
 wrote:
> I have read somewhere that your second approach is doing two things at the
> same time: defining an anonymous function and assigning the name f to it.

No it's not. It defines a function named `f`

f = function ()
end

defines an anonymous function and assigns it to a variable f.

>
>
> On Fri, Oct 28, 2016 at 8:12 PM, digxx  wrote:
>>
>> So an anonymous function I can write like this
>>
>> f=x->x^2
>>
>> is it also possible to make an anonymous function out of this:
>>
>> function f(x)
>>
>> x^2
>>
>> end
>
>

Re: [julia-users] anonymous function

[Michele Zaffalon]

I have read somewhere that your second approach is doing two things at the
same time: defining an anonymous function and assigning the name f to it.


On Fri, Oct 28, 2016 at 8:12 PM, digxx  wrote:

> So an anonymous function I can write like this
>
> f=x->x^2
>
> is it also possible to make an anonymous function out of this:
>
> function f(x)
>
> x^2
>
> end
>

Re: [julia-users] anonymous function

[Yichao Yu]

On Fri, Oct 28, 2016 at 2:12 PM, digxx  wrote:
> So an anonymous function I can write like this
>
> f=x->x^2
>
> is it also possible to make an anonymous function out of this:
>
> function f(x)
>
> x^2
>
> end

No. What are you trying to do?

[julia-users] anonymous function

[digxx]

So an anonymous function I can write like this

f=x->x^2

is it also possible to make an anonymous function out of this:

function f(x)

x^2

end

Re: [julia-users] Re: MersenneTwister, srand

[digxx]

Sorry but that doesn't answer my question. That's where I have the calling 
from but it does not explain the output and what it means...

Re: [julia-users] Re: VS code extension

[Zac]

Will do.


On Friday, October 28, 2016 at 5:17:38 PM UTC, David Anthoff wrote:
>
> Yes, PRs to the main repo are welcome. It would be great if you could 
> write up a short issue describing how this code goes about things. There 
> are quite a number of strategies on how to achieve things in VS code 
> (language server protocol vs everything in typescript vs mixed language 
> solutions) and it would be good to sort out what is the right strategy for 
> the extension, and how this new code fits in there.
>
>  
>
> *From:* julia...@googlegroups.com  [mailto:
> julia...@googlegroups.com ] *On Behalf Of *Zac
> *Sent:* Friday, October 28, 2016 8:40 AM
> *To:* julia-users 
> *Subject:* [julia-users] Re: VS code extension
>
>  
>
> Ok then, https://github.com/ZacLN/julia-vscode . I'll look into trying to 
> make a pull request on the main repo. 
>
>  
>
>  
>
>  
>
>  
>
> On Friday, October 28, 2016 at 3:29:17 PM UTC, Tony Kelman wrote:
>
> The repo's MIT licensed, so unless this person changed the license of 
> their additions, yes. Best to preserve git authorship attribution if you 
> can. Pull requests to the JuliaEditorSupport repository are encouraged, I 
> imagine.
>
>
> On Friday, October 28, 2016 at 3:31:56 AM UTC-7, Zac wrote:
>
> Hi, I'm using a fork of this that implements completions, function 
> parameter hints, documentation hovers, linting and definitions. I pulled it 
> from another fork that has subsequently disappeared (github.com/novatena). 
> This 
>
>  
>
> Given that someone else did most of the work is it ok to share it here? 
>
>
> On Tuesday, July 5, 2016 at 4:33:06 PM UTC, FANG Colin wrote:
>
> Thank you.
>
>  
>
> I used to use https://github.com/Mike43110/julia.vscode which 
> unfortunately doesn't provide the command for mark selection as comments. 
>
>

Re: [julia-users] Re: Comprehension (generator) with statement IF and the number of true

[Gregory Salvan]

Yes I'm using 0.4. Thank you for these infos.

2016-10-27 21:29 GMT+02:00 Steven G. Johnson :

>
>
> On Thursday, October 27, 2016 at 1:23:47 PM UTC-4, DNF wrote:
>>
>> All higher-order functions? I thought it was mainly anonymous functions.
>> Either way, that's a seriously big slowdown.
>>
>
> All higher-order functions can benefit in Julia 0.5, not just anonymous
> functions.  Because each function now has its own type, calling a
> higher-order function like reduce(...) can now compile a specialized
> version for each function you pass it, which allows it to do things like
> inlining.
>

[julia-users] Reducing complexity of OffsetArrays

[Bob Portmann]

TL;DR I think the type system should take care of converting between
different types of arrays and thus free the user to code against the type
of array they want (OneTo, ZeroTo, Offset, etc).

Maybe I have a deep mis-understanding of how the new generalized offset
arrays are suppose to work in Julia. If so I'd be happy to be set straight.
If not then I think the present system will lead to unnecessary complexity
and bug-ridden code. In the present system one can define array types that
are not one-based but can have arbitrary offsets. This is a great idea but
to make it work a very general system for indexing relative to the ends of
the array has been devised. If one writes a function that accepts an
`AbstractArray` then one MUST use this more general system or produce bugs
when e.g. a `ZeroToArray` is passed in. This puts a large burden on writers
of library code that works on arrays and I think is an unnecessary
complexity.

Since Fortran arrays are a nice example let look at the situation in
Fortran. If I define an array in a function `real arr(-10:10)` then I would
index it using indices that range from -10 to 10. If I pass this into
another function that declared the array using its total size (usually
passed in separately or in a parameter statement) `real arr(21)` then in
that subroutine one would index the array using "normal" indices that range
from 1 to 21. I.E., you state in the function how you want to treat the
array and are not forced to work with in offset form unless you want to. In
my opinion, this is what makes using offset arrays in Fortran sane and is
the key thing that Julia should try to emulate.

One way to get this behavior in Julia would be to use the type system and
`convert`. Since `AbstractArray` has meant until 0.5 a `OneTo` array I
think it is wise that it remain that way so that all old code will work
unchanged (even with the new array types). Thus, I propose adding a new
top-level type above AbstractArray type to capture all arrays something
like:

```
Array{T,N} <: DenseArray{T,N} <: AbstractArray{T,N} <:
AbstractAllArray{T,N} <: Any
```

And the offset arrays would be subtypes of `AbstractAllArrays` on a
different branch

```
OffsetArray{T,N} <: AbstractOffsetArray{T,N} <: AbstractAllArray{T,N} <: Any
```

And similarly for `ZeroToArray`.

Then, if one declares an Array as

```
function func(arr::AbstractArray)
```

one can safely assume it is a 1-based Array inside `func`. If an offset
array is passed into `func` then it is automatically converted to a `OneTo`
array inside `func`. This is the key point of this proposal and is similar
to the auto-conversion of, e.g., Int to Floats in a function call.
Similarly if one declares an array as a `ZeroToArray` in a function and
passes in an `Array` then it will be converted to a `ZeroToArray` in the
function. Some conversions would need more information and thus would be
disallowed (e.g., `Array` to `OffsetArray`). I think this system would go a
long way towards making `ZeroToArray`s and `OffsetArray`s simple to use in
Julia w/o using the generalized indexing techniques introduced in Julia
0.5. Note that it would still be possible to use the `AbstractAllArray`
type and accept all arrays w/o conversion and use the generalized indexing
techniques.

I'm curious what people think about this.

Bob

ps Paste into github to see in formatted form. I'm not sure how to get that
in an email.

[julia-users] Parameteric Function of Types

[Derek Gaston]

I can't quite seem to get the right syntax for creating methods that are 
keyed off of subtypes (as a parameter).

Say I have:

abstract foo
abstract bar <: foo

I want to create a function that is like so:

function doStuff(::Type{foo})
end

in such a way that I can call it with "Type{bar}".  i.e.: 
 doStuff(Type{bar})

I understand that:

# Returns true:
issubtype(bar, foo)

# Returns false:
issubtype(Type{bar}, Type{foo})

And I understand why.

So... I tried to define:

function doStuff{T}(::Type{T<:foo})
end

But it tells me that: "WARNING: static parameter T does not occur in 
signature" (it looks like it does to me! :-)... so that's not the right 
answer.

Obviously I'm just thinking about the problem incorrectly... so can someone 
shed some light on what's up here?

Before you ask: I really do need to operate on the _types_ and not on 
instances of the objects themselves (which would obviously be 
straightforward to do).




Also: a (related) follow-on question.  What is the correct/preferred way to 
do the following:

function createSomething{T}()
  return T()
end

(obviously, this is a toy example, my real application of this is not 
trivial)

Is it to do:

function createSomething{T}(::Type{T})
  return T()
end

?




Thanks for any help!

Derek

Re: [julia-users] Re: MersenneTwister, srand

[Isaiah Norton]

http://docs.julialang.org/en/latest/stdlib/numbers/?highlight=global_rng#random-numbers

On Fri, Oct 28, 2016 at 1:23 PM, digxx  wrote:

> With number in my head I meant, that I expected to see random number
> arrays of size 624 since as far as I know they are created
> simultaneously,right?
>

RE: [julia-users] [ANN] DataStreams v0.1: Blog post + Package Release Notes

[David Anthoff]

Thanks, this is really super cool work!

 

Let me also point out that Query.jl works great with DataStream sources and 
sinks. For example, let’s say you want to load some code from a SQLite 
database, apply some filtering and transformations and write the result out as 
a CSV file, you can do that like this:

 

using Query, SQLite, CSV

sqlite_db = SQLite.DB(joinpath(Pkg.dir("SQLite"), "test", 
"Chinook_Sqlite.sqlite"))

q = @from i in SQLite.Source(sqlite_db, "SELECT * FROM Employee") begin

@where i.ReportsTo==2

@select {Name=i.LastName, Adr=i.Address}

@collect CSV.Sink("test-output.csv")

end

Data.close!(q)

 

Note that this will actually never materialize the data into a DataFrame or 
anything like that, instead everything is streamed throughout, from the 
DataStreams source to the think, including the whole query part in the middle.

 

Best,

David

 

From: julia-users@googlegroups.com [mailto:julia-users@googlegroups.com] On 
Behalf Of Jacob Quinn
Sent: Thursday, October 27, 2016 11:33 PM
To: julia-users 
Subject: [julia-users] [ANN] DataStreams v0.1: Blog post + Package Release Notes

 

Hey everyone, 

 

Just wanted to put out the announcement of the release of DataStreams v0.1. (it 
was actually tagged a few weeks ago, but I've been letting a few last things 
shake out before announcing).

 

I've written up a blog post on the updates and release here: 
http://quinnj.github.io/datastreams-jl-v0-1/

 

The TL;DR is DataStreams.jl now defines concrete interfaces for Data.Sources 
and Data.Sinks, with each being completely decoupled from the other. This has 
also allowed some cool new features like appending to Data.Sinks and allowing 
simple transform functions to be applied to data "in-transit".

 

I included release notes of existing packages in the blog post, but I'll 
copy-paste here below for easier access:

 

Do note that the DataStreams.jl framework is now Julia 0.5-only.

 

 

·  CSV.jl

o  Docs

oSupports a wide variety of delimited file options such as delim, 
quotechar, escapechar, custom null strings; a header can be provided manually 
or on a specified row or range of rows; types can be provided manually, and 
results can be requested as nullable or not (nullable=true by default); and the 
# of rows can be provided manually (if known) for efficiency.

oCSV.parsefield(io::IO, ::Type{T}) can be called directly on any IOtype to 
tap into the delimited-parsing functionality manually

·  SQLite.jl

o  Docs

oQuery results will now use the declared table column type by default, 
which can help resultset column typing in some cases

oParameterized SQL statements are fully supported, with the ability to bind 
julia values to be sent to the DB

oFull serialization/deserialization of native and custom Julia types is 
supported; so Complex{Int128} can be stored in its own SQLite table column and 
retrieved without any issue

oPure Julia scalar and aggregation functions can be registered with an 
SQLite database and then called from within SQL statements: full docs  
 here

*   Feather.jl 

o  Docs

oFull support for feather release v0.3.0 to ensure compatibility

oFull support for returning "factor" or "category" type columns as native 
CategoricalArray and NullableCategoricalArray types in Julia, thanks to the new 
  CategoricalArrays.jl 
package

onullable::Bool=true keyword argument; if false, columns without null 
values will be returned as Vector{T} instead of NullableVector{T}

oFeather.Sink now supports appending, so multiple DataFrames or CSV.Source 
or any Data.Source can all be streamed to a single feather file

*   ODBC.jl 

o  Docs

oA new ODBC.DSN type that represents a valid, open connection to a 
database; used in all subsequent api calls; it can be constructed using a 
previously configured system/user dsn w/ username and password, or as a full 
custom connection string

oFull support for the DataStreams.jl framework through the ODBC.Sourceand 
ODBC.Sink types, along with their high-level convenience methods ODBC.query and 
ODBC.load

oA new ODBC.prepare(dsn, sql) => ODBC.Statement method which can send an 
sql statement to the database to be compiled and planned before executed 1 or 
more times. SQL statements can include parameters to be prepared that can have 
dynamic values bound before each execution.

[julia-users] Re: MersenneTwister, srand

[digxx]

With number in my head I meant, that I expected to see random number arrays 
of size 624 since as far as I know they are created simultaneously,right?

RE: [julia-users] Re: VS code extension

[David Anthoff]

Yes, PRs to the main repo are welcome. It would be great if you could write up 
a short issue describing how this code goes about things. There are quite a 
number of strategies on how to achieve things in VS code (language server 
protocol vs everything in typescript vs mixed language solutions) and it would 
be good to sort out what is the right strategy for the extension, and how this 
new code fits in there.

 

From: julia-users@googlegroups.com [mailto:julia-users@googlegroups.com] On 
Behalf Of Zac
Sent: Friday, October 28, 2016 8:40 AM
To: julia-users 
Subject: [julia-users] Re: VS code extension

 

Ok then, https://github.com/ZacLN/julia-vscode . I'll look into trying to make 
a pull request on the main repo. 

 

 

 

 

On Friday, October 28, 2016 at 3:29:17 PM UTC, Tony Kelman wrote:

The repo's MIT licensed, so unless this person changed the license of their 
additions, yes. Best to preserve git authorship attribution if you can. Pull 
requests to the JuliaEditorSupport repository are encouraged, I imagine.


On Friday, October 28, 2016 at 3:31:56 AM UTC-7, Zac wrote:

Hi, I'm using a fork of this that implements completions, function parameter 
hints, documentation hovers, linting and definitions. I pulled it from another 
fork that has subsequently disappeared (github.com/novatena 
 ). This 

 

Given that someone else did most of the work is it ok to share it here? 


On Tuesday, July 5, 2016 at 4:33:06 PM UTC, FANG Colin wrote:

Thank you.

 

I used to use https://github.com/Mike43110/julia.vscode which unfortunately 
doesn't provide the command for mark selection as comments. 

[julia-users] MersenneTwister, srand

[digxx]

So what is the difference between srand and merseentwister?

when I do:

r=srand(0)

I get the same as 

r=MersenneTwister(0)

and also how do I get my random numbers

what do the different fields mean?
e.g.
julia> r.(1)
1-element Array{UInt32,1}:
 0x


julia> r.(2)
Base.dSFMT.DSFMT_state(Int32[748398797,1073523691,-1738140313,1073664641,-1492392947,1073490074,-1625281839,1073254801,1875112882,1073717145
 
 … 
 
943540191,1073626624,1091647724,1073372234,-1273625233,-823628301,835224507,991807863,382,0])

julia> r.(2).(1)
770-element Array{Int32,1}:
   748398797
  1073523691
 -1738140313
  1073664641
 -1492392947
  1073490074
 -1625281839
  1073254801
  1875112882
  1073717145
  -147366646
  1073379643
  -822088544
  1073057897
 -172354
  1073036393
 -1801109415
  1073061557
 -1726958192
  1073632729
  -309172420
  1073464042
  -354763249
  1073128395
   135648219
  1073687628
92195370
  1073342927
   -87798830
  1073300027
   446697077
  1073397042
 -1348144529
  1073439833
   -64993866
  1073659055
  -992725433
  1073226916
   348453421
  1072702220
   ⋮
  1073417805
 -1607069797
  1072770558
   118292460
  1073306270
  -572602520
  1073370707
  -445536129
  1073393538
  1989954253
  1073598613
   986054037
  1073137169
  1796020743
  1073612929
   161145485
  1073732406
  -773274735
  1072720842
  1219081491
  1073737258
  1793984938
  1072858519
 -1584606890
  1072715174
 -1892075178
  1073622009
  -183639381
  1072906897
   943540191
  1073626624
  1091647724
  1073372234
 -1273625233
  -823628301
   835224507
   991807863
 382
   0


julia> r.(3)
382-element Array{Float64,1}:
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 ⋮
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0


julia> r.(4)
382


The number I had in my head for MersenneTwister was 624 but I dont find it 
anywhere?
Do I only initialize the pseudo random number generator this way and the 
actual "random" number is then obtain by rand(1) for example?
How do I acutally set the seed coz when I do
srand(0) and rand() would actually be a mersennetwister I'd expect zeros 
everywhere...
Thx

Re: [julia-users] Re: Input a data from the console

[Ismael Venegas Castelló]

IMO the parametric method with multiple dispatch is more Julian.

[julia-users] Re: VS code extension

[Zac]

Ok then, https://github.com/ZacLN/julia-vscode . I'll look into trying to 
make a pull request on the main repo. 




On Friday, October 28, 2016 at 3:29:17 PM UTC, Tony Kelman wrote:
>
> The repo's MIT licensed, so unless this person changed the license of 
> their additions, yes. Best to preserve git authorship attribution if you 
> can. Pull requests to the JuliaEditorSupport repository are encouraged, I 
> imagine.
>
>
> On Friday, October 28, 2016 at 3:31:56 AM UTC-7, Zac wrote:
>>
>> Hi, I'm using a fork of this that implements completions, function 
>> parameter hints, documentation hovers, linting and definitions. I pulled it 
>> from another fork that has subsequently disappeared (github.com/novatena). 
>> This 
>>
>> Given that someone else did most of the work is it ok to share it here? 
>>
>> On Tuesday, July 5, 2016 at 4:33:06 PM UTC, FANG Colin wrote:
>>>
>>> Thank you.
>>>
>>> I used to use https://github.com/Mike43110/julia.vscode which 
>>> unfortunately doesn't provide the command for mark selection as comments. 
>>>
>>

[julia-users] Re: VS code extension

[Tony Kelman]

The repo's MIT licensed, so unless this person changed the license of their 
additions, yes. Best to preserve git authorship attribution if you can. 
Pull requests to the JuliaEditorSupport repository are encouraged, I 
imagine.


On Friday, October 28, 2016 at 3:31:56 AM UTC-7, Zac wrote:
>
> Hi, I'm using a fork of this that implements completions, function 
> parameter hints, documentation hovers, linting and definitions. I pulled it 
> from another fork that has subsequently disappeared (github.com/novatena). 
> This 
>
> Given that someone else did most of the work is it ok to share it here? 
>
> On Tuesday, July 5, 2016 at 4:33:06 PM UTC, FANG Colin wrote:
>>
>> Thank you.
>>
>> I used to use https://github.com/Mike43110/julia.vscode which 
>> unfortunately doesn't provide the command for mark selection as comments. 
>>
>

[julia-users] Re: Pkg.add("IJulia") fails

[bker]

Thanks Joungmin, that worked. For the record, that file was located in 
d:\emacs\.julia\WinRPM\sources.list for some reason.


On Friday, October 28, 2016 at 10:12:54 AM UTC-4, Joungmin Lee wrote:
>
> I had the same problem when installing in Windows 7.
>
> I don't know the exact reason, but the problem solved by changing url in 
> C:\Users\\.julia\v0.5\WinRPM\source.list. 
> Try again after deleting "https://cache.julialang.org 
> /" in two 
> URLs conained in the file.
>
>
> 2016년 10월 27일 목요일 오전 6시 29분 43초 UTC+9, bker 님의 말:
>
>> Complete newb here. Just trying to install IJulia for Jupyter. Installed 
>> Anaconda first, then Julia. When I try to install the IJulia package, I get 
>> the output below. I've tried removing everything and re-installing but I 
>> get the same result. Help!
>>
>>_
>>_   _ _(_)_ |  A fresh approach to technical computing
>>   (_) | (_) (_)|  Documentation: http://docs.julialang.org
>>_ _   _| |_  __ _   |  Type "?help" for help.
>>   | | | | | | |/ _` |  |
>>   | | |_| | | | (_| |  |  Version 0.5.0 (2016-09-19 18:14 UTC)
>>  _/ |\__'_|_|_|\__'_|  |  Official http://julialang.org/ release
>> |__/   |  x86_64-w64-mingw32
>>
>> ERROR: SystemError: opening file D:\emacs\.julia_history: No such file or 
>> direct
>> ory
>>  in #systemerror#51 at .\error.jl:34 [inlined]
>>  in systemerror(::String, ::Bool) at .\error.jl:34
>>  in open(::String, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool) at 
>> .\iostream.jl:89
>>  in #setup_interface#30(::Bool, ::Array{Dict{Any,Any},1}, ::Function, 
>> ::Base.REP
>> L.LineEditREPL) at .\REPL.jl:769
>>  in run_frontend(::Base.REPL.LineEditREPL, ::Base.REPL.REPLBackendRef) at 
>> .\REPL
>> .jl:898
>>  in run_repl(::Base.REPL.LineEditREPL, ::Base.##932#933) at .\REPL.jl:188
>>  in _start() at .\client.jl:360
>>
>> INFO: Disabling history file for this session.
>> julia> Pkg.status()
>> INFO: Initializing package repository D:\emacs\.julia\v0.5
>> INFO: Cloning METADATA from https://github.com/JuliaLang/METADATA.jl
>> No packages installed
>>
>> julia> Pkg.resolve()
>> INFO: No packages to install, update or remove
>>
>> julia> Pkg.add("IJulia")
>> INFO: Cloning cache of BinDeps from 
>> https://github.com/JuliaLang/BinDeps.jl.git
>> ERROR: Cannot clone BinDeps from 
>> https://github.com/JuliaLang/BinDeps.jl.git. Fa
>> iled to receive response: The server returned an invalid or unrecognized 
>> respons
>> e
>>
>>  in prefetch(::String, ::String, ::Array{String,1}) at .\pkg\cache.jl:56
>>  in resolve(::Dict{String,Base.Pkg.Types.VersionSet}, 
>> ::Dict{String,Dict{Version
>> Number,Base.Pkg.Types.Available}}, 
>> ::Dict{String,Tuple{VersionNumber,Bool}}, ::D
>> ict{String,Base.Pkg.Types.Fixed}, ::Dict{String,VersionNumber}, 
>> ::Set{String}) a
>> t .\pkg\entry.jl:512
>>  in resolve(::Dict{String,Base.Pkg.Types.VersionSet}, 
>> ::Dict{String,Dict{Version
>> Number,Base.Pkg.Types.Available}}, 
>> ::Dict{String,Tuple{VersionNumber,Bool}}, ::D
>> ict{String,Base.Pkg.Types.Fixed}) at .\pkg\entry.jl:476
>>  in edit(::Function, ::String, ::Base.Pkg.Types.VersionSet, 
>> ::Vararg{Base.Pkg.Ty
>> pes.VersionSet,N}) at .\pkg\entry.jl:30
>>  in (::Base.Pkg.Entry.##2#5{String,Base.Pkg.Types.VersionSet})() at 
>> .\task.jl:36
>> 0
>>  in sync_end() at .\task.jl:311
>>  in macro expansion at .\task.jl:327 [inlined]
>>  in add(::String, ::Base.Pkg.Types.VersionSet) at .\pkg\entry.jl:51
>>  in 
>> (::Base.Pkg.Dir.##2#3{Array{Any,1},Base.Pkg.Entry.#add,Tuple{String}})() at
>> .\pkg\dir.jl:31
>>  in 
>> cd(::Base.Pkg.Dir.##2#3{Array{Any,1},Base.Pkg.Entry.#add,Tuple{String}}, ::S
>> tring) at .\file.jl:48
>>  in #cd#1(::Array{Any,1}, ::Function, ::Function, ::String, 
>> ::Vararg{Any,N}) at
>> .\pkg\dir.jl:31
>>  in add(::String) at .\pkg\pkg.jl:100
>>
>> julia> Pkg.add("IJulia")
>> INFO: Cloning cache of BinDeps from 
>> https://github.com/JuliaLang/BinDeps.jl.git
>> INFO: Cloning cache of BufferedStreams from 
>> https://github.com/BioJulia/Buffered
>> Streams.jl.git
>> INFO: Cloning cache of Compat from 
>> https://github.com/JuliaLang/Compat.jl.git
>> INFO: Cloning cache of Conda from https://github.com/JuliaPy/Conda.jl.git
>> INFO: Cloning cache of IJulia from 
>> https://github.com/JuliaLang/IJulia.jl.git
>> INFO: Cloning cache of JSON from https://github.com/JuliaIO/JSON.jl.git
>> INFO: Cloning cache of LegacyStrings from 
>> https://github.com/JuliaArchive/Legacy
>> Strings.jl.git
>> INFO: Cloning cache of LibExpat from 
>> https://github.com/amitmurthy/LibExpat.jl.g
>> it
>> INFO: Cloning cache of Libz from https://github.com/BioJulia/Libz.jl.git
>> INFO: Cloning cache of Nettle from 
>> https://github.com/staticfloat/Nettle.jl.git
>> INFO: Cloning cache of SHA from https://github.com/staticfloat/SHA.jl.git
>> INFO: Cloning cache of URIParser from 
>> https://github.com/JuliaWeb/URIParser.jl.g
>> it
>> INFO: Cloning cache of WinRPM from 
>> 

[julia-users] Unit Testing: should I use Base.Test instead of FactCheck?

[Florian Oswald]

I know there are many testing packages out there. I have been using 
FactCheck, but have seen it's been relegated to the JuliaArchive. I take 
that as a sign it's a good moment to use something else.

There is 1 thing I sorely miss from Base.Test coming from FactCheck, and 
that is the ability to say

@fact false --> true "your test failed: false is not true"

i.e. i can print a custom error message to be shown upon failure only.

I also think the display of test results (indentation of lower level 
"contexts" (@testsets in Base.Test)) is nicer in FactCheck, but that's not 
that important.

Thanks for any advice.

[julia-users] IJulia often in trouble

[Joungmin Lee]

After upgrading to v0.5, IJulia don't response during executing codes VERY 
often.
When using Python in Jupyter or using Julia v0.4, such a problem doesn't 
occur.

Trying to reproduce the problem, I found that there's something in 
autocomplete; 
when I tapped quickly several times before autocomple (or before Jupyter 
showed the suggestion list) in Jupyter.

I'm running Julia in Windows 7 and haven't tested in the Linux machine.

Does anybody have the same problem as mine?

Cheers
Joungmin

[julia-users] Re: Pkg.add("IJulia") fails

[Joungmin Lee]

I had the same problem when installing in Windows 7.

I don't know the exact reason, but the problem solved by changing url in 
C:\Users\\.julia\v0.5\WinRPM\source.list. 
Try again after deleting "https://cache.julialang.org 
/" in two 
URLs conained in the file.


2016년 10월 27일 목요일 오전 6시 29분 43초 UTC+9, bker 님의 말:

> Complete newb here. Just trying to install IJulia for Jupyter. Installed 
> Anaconda first, then Julia. When I try to install the IJulia package, I get 
> the output below. I've tried removing everything and re-installing but I 
> get the same result. Help!
>
>_
>_   _ _(_)_ |  A fresh approach to technical computing
>   (_) | (_) (_)|  Documentation: http://docs.julialang.org
>_ _   _| |_  __ _   |  Type "?help" for help.
>   | | | | | | |/ _` |  |
>   | | |_| | | | (_| |  |  Version 0.5.0 (2016-09-19 18:14 UTC)
>  _/ |\__'_|_|_|\__'_|  |  Official http://julialang.org/ release
> |__/   |  x86_64-w64-mingw32
>
> ERROR: SystemError: opening file D:\emacs\.julia_history: No such file or 
> direct
> ory
>  in #systemerror#51 at .\error.jl:34 [inlined]
>  in systemerror(::String, ::Bool) at .\error.jl:34
>  in open(::String, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool) at 
> .\iostream.jl:89
>  in #setup_interface#30(::Bool, ::Array{Dict{Any,Any},1}, ::Function, 
> ::Base.REP
> L.LineEditREPL) at .\REPL.jl:769
>  in run_frontend(::Base.REPL.LineEditREPL, ::Base.REPL.REPLBackendRef) at 
> .\REPL
> .jl:898
>  in run_repl(::Base.REPL.LineEditREPL, ::Base.##932#933) at .\REPL.jl:188
>  in _start() at .\client.jl:360
>
> INFO: Disabling history file for this session.
> julia> Pkg.status()
> INFO: Initializing package repository D:\emacs\.julia\v0.5
> INFO: Cloning METADATA from https://github.com/JuliaLang/METADATA.jl
> No packages installed
>
> julia> Pkg.resolve()
> INFO: No packages to install, update or remove
>
> julia> Pkg.add("IJulia")
> INFO: Cloning cache of BinDeps from 
> https://github.com/JuliaLang/BinDeps.jl.git
> ERROR: Cannot clone BinDeps from 
> https://github.com/JuliaLang/BinDeps.jl.git. Fa
> iled to receive response: The server returned an invalid or unrecognized 
> respons
> e
>
>  in prefetch(::String, ::String, ::Array{String,1}) at .\pkg\cache.jl:56
>  in resolve(::Dict{String,Base.Pkg.Types.VersionSet}, 
> ::Dict{String,Dict{Version
> Number,Base.Pkg.Types.Available}}, 
> ::Dict{String,Tuple{VersionNumber,Bool}}, ::D
> ict{String,Base.Pkg.Types.Fixed}, ::Dict{String,VersionNumber}, 
> ::Set{String}) a
> t .\pkg\entry.jl:512
>  in resolve(::Dict{String,Base.Pkg.Types.VersionSet}, 
> ::Dict{String,Dict{Version
> Number,Base.Pkg.Types.Available}}, 
> ::Dict{String,Tuple{VersionNumber,Bool}}, ::D
> ict{String,Base.Pkg.Types.Fixed}) at .\pkg\entry.jl:476
>  in edit(::Function, ::String, ::Base.Pkg.Types.VersionSet, 
> ::Vararg{Base.Pkg.Ty
> pes.VersionSet,N}) at .\pkg\entry.jl:30
>  in (::Base.Pkg.Entry.##2#5{String,Base.Pkg.Types.VersionSet})() at 
> .\task.jl:36
> 0
>  in sync_end() at .\task.jl:311
>  in macro expansion at .\task.jl:327 [inlined]
>  in add(::String, ::Base.Pkg.Types.VersionSet) at .\pkg\entry.jl:51
>  in 
> (::Base.Pkg.Dir.##2#3{Array{Any,1},Base.Pkg.Entry.#add,Tuple{String}})() at
> .\pkg\dir.jl:31
>  in 
> cd(::Base.Pkg.Dir.##2#3{Array{Any,1},Base.Pkg.Entry.#add,Tuple{String}}, ::S
> tring) at .\file.jl:48
>  in #cd#1(::Array{Any,1}, ::Function, ::Function, ::String, 
> ::Vararg{Any,N}) at
> .\pkg\dir.jl:31
>  in add(::String) at .\pkg\pkg.jl:100
>
> julia> Pkg.add("IJulia")
> INFO: Cloning cache of BinDeps from 
> https://github.com/JuliaLang/BinDeps.jl.git
> INFO: Cloning cache of BufferedStreams from 
> https://github.com/BioJulia/Buffered
> Streams.jl.git
> INFO: Cloning cache of Compat from 
> https://github.com/JuliaLang/Compat.jl.git
> INFO: Cloning cache of Conda from https://github.com/JuliaPy/Conda.jl.git
> INFO: Cloning cache of IJulia from 
> https://github.com/JuliaLang/IJulia.jl.git
> INFO: Cloning cache of JSON from https://github.com/JuliaIO/JSON.jl.git
> INFO: Cloning cache of LegacyStrings from 
> https://github.com/JuliaArchive/Legacy
> Strings.jl.git
> INFO: Cloning cache of LibExpat from 
> https://github.com/amitmurthy/LibExpat.jl.g
> it
> INFO: Cloning cache of Libz from https://github.com/BioJulia/Libz.jl.git
> INFO: Cloning cache of Nettle from 
> https://github.com/staticfloat/Nettle.jl.git
> INFO: Cloning cache of SHA from https://github.com/staticfloat/SHA.jl.git
> INFO: Cloning cache of URIParser from 
> https://github.com/JuliaWeb/URIParser.jl.g
> it
> INFO: Cloning cache of WinRPM from 
> https://github.com/JuliaPackaging/WinRPM.jl.g
> it
> INFO: Cloning cache of ZMQ from https://github.com/JuliaLang/ZMQ.jl.git
> INFO: Installing BinDeps v0.4.5
> INFO: Installing BufferedStreams v0.2.0
> INFO: Installing Compat v0.9.3
> INFO: Installing Conda v0.3.2
> INFO: Installing IJulia v1.3.2
> INFO: Installing JSON v0.8.0
> 

[julia-users] jl_stat_ctime

[Brandon Taylor]

Right now in base jl_stat_ctime looks like this:

JL_DLLEXPORT double jl_stat_ctime(char *statbuf)
{
uv_stat_t *s;
s = (uv_stat_t*)statbuf;
return (double)s->st_ctim.tv_sec + (double)s->st_ctim.tv_nsec * 1e-9;
}

And it's called with

ccall(:jl_stat_ctime,   Float64, (Ptr{UInt8},), buf)

I'd like to simplify this.

I'd like a type

type FineComputerTime
seconds::Int
nanoseconds::Int
end

And a way to fill it in using the stat buffer.

Can anyone offer some tips? The c code keeps confusing me.




I

Re: [julia-users] Re: Sparse arrays in Julia

[Júlio Hoffimann]

Thank you Kristoffer, good to know about the package :)

-Júlio

Re: [julia-users] CPU_CORES is deprecated

[Yichao Yu]

https://github.com/JuliaLang/julia/blob/master/NEWS.md#library-improvements-1

On Fri, Oct 28, 2016 at 8:27 AM, Yichao Yu  wrote:
> Sys.CPU_CORES
>
> On Fri, Oct 28, 2016 at 8:14 AM, Nils Gudat  wrote:
>> As the title says - getting a warning but the constant still exist. There's
>> none of the ususal "use ... instead" in the warning, what's the replacement
>> (if any) for this in 0.5?

Re: [julia-users] CPU_CORES is deprecated

[Yichao Yu]

Sys.CPU_CORES

On Fri, Oct 28, 2016 at 8:14 AM, Nils Gudat  wrote:
> As the title says - getting a warning but the constant still exist. There's
> none of the ususal "use ... instead" in the warning, what's the replacement
> (if any) for this in 0.5?

[julia-users] CPU_CORES is deprecated

[Nils Gudat]

As the title says - getting a warning but the constant still exist. There's 
none of the ususal "use ... instead" in the warning, what's the replacement 
(if any) for this in 0.5?

[julia-users] Re: Sparse arrays in Julia

[Kristoffer Carlsson]

Take a look at https://github.com/JuliaComputing/IndexedTables.jl

"This package provides a table data structure where some of the columns 
form a sorted index. This structure is equivalent to an N-dimensional 
sparse array, and follows the array API to the extent possible."

On Friday, October 28, 2016 at 2:11:00 AM UTC+2, Júlio Hoffimann wrote:
>
> Actually, I don't think it makes very much sense, one could use a 
> dictionary of tuples instead. Sparse 2D exist for a reason: efficient 
> matrix multiplication, etc.
>
> Disregard this email.
>
> -Júlio
>
> Em quinta-feira, 27 de outubro de 2016 17:07:01 UTC-7, Júlio Hoffimann 
> escreveu:
>>
>> Hello,
>>
>> Is it possible to create a multidimensional sparse array in Julia?
>>
>> sparse() works for matrices, I wonder if someone can extend it to 
>> multidimensional arrays. Where should I open a feature request?
>>
>> -Júlio
>>
>

[julia-users] Re: package reproducibility

[Steven G. Johnson]

Since all Julia packages are managed via git, it would be easy to write a 
tool that collects all of the commits of the current packages into a list 
so that you can install the same commits on another system.  I don't think 
there is an existing tool that automates this, though?

Re: [julia-users] Re: Nemo AcbField error

['Bill Hart' via julia-users]

We'll consider changing it. It's mainly supposed to be for us developers so
we can build the binaries, but if people want to actually use it, I guess
we should maintain it a bit more carefully.

Bill.

On 28 October 2016 at 12:34, Jeffrey Sarnoff 
wrote:

> Bill,
> Consider distributing windows_build.txt ready to use with 64-bit machines
> and giving the changes to be made for 32-bit machines in comments.  That
> reverses the current orientation, and fits more of the likely user base.  I
> think that change gives you this:
>
>
> Note that windows_build.txt is preset for 32-bit Windows;
> for 64-bit machines, windows_build.txt should be this:
>
> # This is set for use with 64-bit Windows installations
> #
> #   To use this with  32-bit Windows installations,
> #   replace x86_64 with i686 throughout
> #   replace ABI=64 with ABI=32
>
>
> wget http://mpir.org/mpir-2.7.2.tar.bz2
> tar -xvf mpir-2.7.2.tar.bz2
> cd mpir-2.7.2
> ./configure --enable-shared --disable-static --enable-gmpcompat
> --build=core2-w64-mingw64 LDFLAGS=-static-libgcc ABI=64
> make -j
> cd ..
> wget http://www.mpfr.org/mpfr-current/mpfr-3.1.4.tar.bz2
> tar -xvf mpfr-3.1.4.tar.bz2
> cd mpfr-3.1.4
> ./configure --with-gmp-build=/home/User/mpir-2.7.2 --enable-shared
> --disable-static
> make -j
> cd ..
> git clone https://github.com/wbhart/flint2
> https://github.com/wbhart/antic
> cd flint2
> ./configure --enable-shared --disable-static --with-mpir=/home/user/mpir-2.7.2
> --with-mpfr=/home/user/mpfr-3.1.4 --extensions=/home/user/antic
> # edit Makefile
> # in CLFAGS replace -ansi -pedantic with -std=c99
> # add -mtune=core2 -march=core2 to CFLAGS
> # add -I/home/User/flint2 to INCS
> # ensure EXTRA_SHARED_FLAGS contains -static-libgcc -shared
> -Wl,--export-all-symbols
> make -j
> cd ..
> wget http://pari.math.u-bordeaux.fr/pub/pari/unix/pari-2.7.6.tar.gz
> tar -xvf pari-2.7.6.tar.gz
> cd pari-2.7.6
> export PATH=/home/user/mpir-2.7.2/.libs:$PATH
> LDFLAGS=-static-libgcc CFLAGS="-mtune=core2 -march=core2" ./Configure
> --with-gmp-include=/home/user/mpir-2.7.2 
> --with-gmp-lib=/home/user/mpir-2.7.2/.libs
> --host=x86_64-pc-mingw
> cd Omingw-x86_64-pc
> make gp
> cd ../..
>
>
>
>
> On Friday, October 28, 2016 at 4:54:06 AM UTC-4, Bill Hart wrote:
>>
>> 64 bit Windows will run 32 bit Windows binaries, yes. Of course we
>> recommend the 64 bit ones.
>>
>> On 28 October 2016 at 10:52, digxx  wrote:
>>
>>> Yes but when I do not manually change i686 and ABI=32 to the x64 it is
 running the 32bit version, right?
 You mean windows 64 can still cope with 32bit stuff?

>>>
>>>
>>> I mean changing in the windows_build.txt
>>> By Pkg.build("Nemo") I do not run any executable, right?
>>>
>>
>>

Re: [julia-users] Re: Nemo AcbField error

[Jeffrey Sarnoff]

Bill, 
Consider distributing windows_build.txt ready to use with 64-bit machines 
and giving the changes to be made for 32-bit machines in comments.  That 
reverses the current orientation, and fits more of the likely user base.  I 
think that change gives you this:


Note that windows_build.txt is preset for 32-bit Windows;
for 64-bit machines, windows_build.txt should be this:

# This is set for use with 64-bit Windows installations
#
#   To use this with  32-bit Windows installations,
#   replace x86_64 with i686 throughout
#   replace ABI=64 with ABI=32


wget http://mpir.org/mpir-2.7.2.tar.bz2
tar -xvf mpir-2.7.2.tar.bz2
cd mpir-2.7.2
./configure --enable-shared --disable-static --enable-gmpcompat 
--build=core2-w64-mingw64 LDFLAGS=-static-libgcc ABI=64
make -j
cd ..
wget http://www.mpfr.org/mpfr-current/mpfr-3.1.4.tar.bz2
tar -xvf mpfr-3.1.4.tar.bz2
cd mpfr-3.1.4
./configure --with-gmp-build=/home/User/mpir-2.7.2 --enable-shared 
--disable-static
make -j
cd ..
git clone https://github.com/wbhart/flint2
https://github.com/wbhart/antic
cd flint2
./configure --enable-shared --disable-static 
--with-mpir=/home/user/mpir-2.7.2 --with-mpfr=/home/user/mpfr-3.1.4 
--extensions=/home/user/antic
# edit Makefile
# in CLFAGS replace -ansi -pedantic with -std=c99
# add -mtune=core2 -march=core2 to CFLAGS
# add -I/home/User/flint2 to INCS
# ensure EXTRA_SHARED_FLAGS contains -static-libgcc -shared 
-Wl,--export-all-symbols
make -j
cd ..
wget http://pari.math.u-bordeaux.fr/pub/pari/unix/pari-2.7.6.tar.gz
tar -xvf pari-2.7.6.tar.gz
cd pari-2.7.6
export PATH=/home/user/mpir-2.7.2/.libs:$PATH
LDFLAGS=-static-libgcc CFLAGS="-mtune=core2 -march=core2" ./Configure 
--with-gmp-include=/home/user/mpir-2.7.2 
--with-gmp-lib=/home/user/mpir-2.7.2/.libs --host=x86_64-pc-mingw
cd Omingw-x86_64-pc
make gp
cd ../..




On Friday, October 28, 2016 at 4:54:06 AM UTC-4, Bill Hart wrote:
>
> 64 bit Windows will run 32 bit Windows binaries, yes. Of course we 
> recommend the 64 bit ones.
>
> On 28 October 2016 at 10:52, digxx  
> wrote:
>
>> Yes but when I do not manually change i686 and ABI=32 to the x64 it is 
>>> running the 32bit version, right?
>>> You mean windows 64 can still cope with 32bit stuff? 
>>>
>>
>>
>> I mean changing in the windows_build.txt
>> By Pkg.build("Nemo") I do not run any executable, right? 
>>
>
>

[julia-users] Re: VS code extension

[Zac]

Hi, I'm using a fork of this that implements completions, function 
parameter hints, documentation hovers, linting and definitions. I pulled it 
from another fork that has subsequently disappeared (github.com/novatena). 
This 

Given that someone else did most of the work is it ok to share it here? 

On Tuesday, July 5, 2016 at 4:33:06 PM UTC, FANG Colin wrote:
>
> Thank you.
>
> I used to use https://github.com/Mike43110/julia.vscode which 
> unfortunately doesn't provide the command for mark selection as comments. 
>

Re: [julia-users] Re: Nemo AcbField error

['Bill Hart' via julia-users]

64 bit Windows will run 32 bit Windows binaries, yes. Of course we
recommend the 64 bit ones.

On 28 October 2016 at 10:52, digxx  wrote:

> Yes but when I do not manually change i686 and ABI=32 to the x64 it is
>> running the 32bit version, right?
>> You mean windows 64 can still cope with 32bit stuff?
>>
>
>
> I mean changing in the windows_build.txt
> By Pkg.build("Nemo") I do not run any executable, right?
>

Re: [julia-users] Re: Nemo AcbField error

[digxx]

>
> Yes but when I do not manually change i686 and ABI=32 to the x64 it is 
> running the 32bit version, right?
> You mean windows 64 can still cope with 32bit stuff? 
>


I mean changing in the windows_build.txt
By Pkg.build("Nemo") I do not run any executable, right? 

Re: [julia-users] Re: Nemo AcbField error

[digxx]

>
> Both should work. If you use a 64 bit Julia executable it sould build the 
> 64 bit version. Otherwise it should build the 32 bit version.
>  
> Bill.
>

Yes but when I do not manually change i686 and ABI=32 to the x64 it is 
running the 32bit version, right?
You mean windows 64 can still cope with 32bit stuff? 

[julia-users] Re: package reproducibility

[Tim Wheeler]

Hi Kevin,

You can use Pkg.pin("Stats",v"0.2.5").

-Tim

On Friday, October 28, 2016 at 9:24:14 AM UTC+2, Kevin Kunzmann wrote:
>
> Hey,
>
> I was just wondering whether Julia has a checkpoint-like functionality (R 
> checkpoint-package 
> ) for 
> using a specific checkpoint of the package ecosystem. With quick 
> development happening this would improve reproducibility drastically.
>
> Best,
>
> Kevin 
>

[julia-users] package reproducibility

[Kevin Kunzmann]

Hey,

I was just wondering whether Julia has a checkpoint-like functionality (R 
checkpoint-package 
) for using 
a specific checkpoint of the package ecosystem. With quick development 
happening this would improve reproducibility drastically.

Best,

Kevin 

[julia-users] [ANN] DataStreams v0.1: Blog post + Package Release Notes

[Jacob Quinn]

Hey everyone,

Just wanted to put out the announcement of the release of DataStreams v0.1. 
(it was actually tagged a few weeks ago, but I've been letting a few last 
things shake out before announcing).

I've written up a blog post on the updates and release 
here: http://quinnj.github.io/datastreams-jl-v0-1/

The TL;DR is DataStreams.jl now defines concrete interfaces for 
Data.Sources and Data.Sinks, with each being completely decoupled from the 
other. This has also allowed some cool new features like appending to 
Data.Sinks and allowing simple transform functions to be applied to data 
"in-transit".

I included release notes of existing packages in the blog post, but I'll 
copy-paste here below for easier access:

Do note that the DataStreams.jl framework is now Julia 0.5-only.



   - 
   
   *CSV.jl*
   - *Docs* 
  - Supports a wide variety of delimited file options such as delim, 
  quotechar, escapechar, custom null strings; a header can be provided 
  manually or on a specified row or range of rows; types can be 
  provided manually, and results can be requested as nullable or not (
  nullable=true by default); and the # of rows can be provided manually 
  (if known) for efficiency.
  - CSV.parsefield(io::IO, ::Type{T}) can be called directly on any IOtype 
  to tap into the delimited-parsing functionality manually
   - 
   
   *SQLite.jl*
   - *Docs* 
  - Query results will now use the declared table column type by 
  default, which can help resultset column typing in some cases
  - Parameterized SQL statements are fully supported, with the ability 
  to bind julia values to be sent to the DB
  - Full serialization/deserialization of native and custom Julia types 
  is supported; so Complex{Int128} can be stored in its own SQLite 
  table column and retrieved without any issue
  - Pure Julia scalar and aggregation functions can be registered with 
  an SQLite database and then called from within SQL statements: full docs 
  here 
  
   - *Feather.jl*
  - *Docs* 
  - Full support for feather release v0.3.0 to ensure compatibility
  - Full support for returning "factor" or "category" type columns as 
  native CategoricalArray and NullableCategoricalArray types in Julia, 
  thanks to the new CategoricalArrays.jl 
   package
  - nullable::Bool=true keyword argument; if false, columns without 
  null values will be returned as Vector{T} instead of NullableVector{T}
  - Feather.Sink now supports appending, so multiple DataFrames or 
  CSV.Source or any Data.Source can all be streamed to a single feather 
  file
   - *ODBC.jl*
  - *Docs* 
  - A new ODBC.DSN type that represents a valid, open connection to a 
  database; used in all subsequent api calls; it can be constructed using a 
  previously configured system/user dsn w/ username and password, or as a 
  full custom connection string
  - Full support for the DataStreams.jl framework through the 
  ODBC.Sourceand ODBC.Sink types, along with their high-level 
  convenience methods ODBC.query and ODBC.load
  - A new ODBC.prepare(dsn, sql) => ODBC.Statement method which can 
  send an sql statement to the database to be compiled and planned 
  before executed 1 or more times. SQL statements can include parameters to 
  be prepared that can have dynamic values bound before each execution.