/JuliaEditorSupportLogo.ipynb

## JuliaEditorSupportLogo.ipynb
{
  "cells": [
    {
      "metadata": {
        "trusted": true,
        "collapsed": true
      },
      "cell_type": "code",
      "source": "# By Lyndon White (AKA oxinabox, AKA Frames)",
      "execution_count": 12,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": false,
        "trusted": true
      },
      "cell_type": "code",
      "source": "codetext = \"\"\"const cache_location = joinpath(Pkg.Dir.path(),\"../jltags_cache/\"); kinds = Dict(\"module\"=>\"module\", \"variable\"=>\"variable\", \"function\"=>\"function\", \"datatype\"=>\"datatype\", \"union\"=>\"union\", \"type\" =>\"type\"); immutable Tag; name::AbstractString; file::AbstractString; address::AbstractString; fields::Dict{AbstractString,AbstractString}; const mtime_line_prefix = \"!_TAG_SOURCE_MTIME\"; function write_header(fp::IO, file_mtimes=[]); println(fp,\"!_TAG_FILE_FORMAT  2  /exted format; --format=1 will not app\\\" to lines/\"); println(fp,\"!_TAG_FILE_SORTED  0  /0=unsorted, 1=sorted, 2=foldcase/\"); println(fp,\"!_TAG_PROGRAM_NAME jltags //\"); for (filename, mtime) in file_mtimes; println(fp,mtime_line_prefix,\"\\t\",filename,\"\\t\",string(mtime)); function write_tag(fp::IO, tag::Tag); tag.fields[\"language\"]=\"julia\"; print(fp, \"(tag.name)\\t(tag.file)\\t(tag.address);\\\"\"); for (field,value) in tag.fields; value = escape_string(value); print(fp,\"\\tfield:value\"); println(fp); function module_to_filename(mm::Module); name = mm==Base ? \"sysimg\" : mm==Core ? \"coreimg\": string(mm); path = Base.find_source_file(name*\".jl\"); path!=nothing ? path : \"<module name: unkown path>\" function docs(func::Function, method::Method); try signiture_types = method.sig.types[2:]; doc = Base.Docs.doc(func,signiture_types...); return doc.meta[:results][1].text[1] catch ee; return \"No docs found for \" * string(method); function tags(name_sym::Symbol, mm::Module, value::Function); name=string(name_sym); Task() do; for func in Base.MethodList(methods(value)); if mm!=func.module continue file, linenum = functionloc(func); address = string(linenum); args = map(string, func.sig.parameters[2:]) ; fields = Dict{AbstractString,AbstractString}(; \"module\" => mm|>string, \"kind\" => kinds[\"function\"], \"arity\" => string(length(args)), \"args\" => join(args,\",\"), \"string\" => string(func), \"doc\" => docs(value, func), ); produce(Tag(name,file,address,fields)) ; function tags(name_sym::Symbol, mm::Module, value::Union); name=string(name_sym); Task() do; filename=module_to_filename(mm) fields=Dict(\"kind\" => kinds[\"union\"], \"module\"=> string(mm), \"types\" => join(\",\",map(string,value.types)), \"string\" => string(value); ); produce(Tag(name,filename,\"/name\\\\s*=/\",fields)) ; function tags(name_sym::Symbol,mm::Module, tt::DataType, record_truename=false); name=string(name_sym); Task() do; filename = module_to_filename(mm) fields=Dict(\"kind\" => kinds[\"datatype\"], \"module\"=> string(mm), \"other_type_parameters\"=>join(\",\",map(string, setdiff(tt.parameters,tt.types))), \"abstract\"=> tt.abstract |> string, \"mutable\"=> tt.mutable |> string, \"size\"=> tt.size |> string, \"supertype\"=>supertype(tt) |> string, \"bitstype\"=>isbits(tt) |> string, \"string\" => string(tt); ); if record_truename; fields[\"true_name\"]=tt.name.name |> string; if tt.name.names |> length >= nfields(tt) if name_sym != :Module type_fields = [\"fname::\"*string(fieldtype(tt,fname)) for fname in fieldnames(tt)]; fields[\"fields\"] = join(type_fields,\",\"); produce(Tag(name,filename, \"/^[typealias|type|abstract|immutable]\\\\s+name\\\\s*=/\", fields)); function tags(name_sym::Symbol, mm::Module, value::Type); Task() do; for tag in  tags(name_sym,mm,value.body); tag.fields[\"kind\"] = kinds[\"type\"]; tag.fields[\"inner_string\"]=tag.fields[\"string\"]; tag.fields[\"string\"] = string(value); produce(tag); function tags(name_sym::Symbol,mm::Module, submodule::Module); name=string(name_sym); Task() do; filename = module_to_filename(submodule); fields=Dict(\"kind\" => kinds[\"module\"], \"module\"=> module_parent(submodule) |> string, \"string\"=> string(submodule)); produce(Tag(name,filename, \"/^module name/\",fields)); function tags(name_sym::Symbol,mm::Module, variable::Any); name=string(name_sym); Task() do; filename=module_to_filename(mm) fields=Dict(\"kind\" => kinds[\"variable\"], \"module\"=> string(mm), \"type\" => string(typeof(variable)), \"constant\" => string(isconst(mm,name_sym)), \"string\" => string(variable)); produce(Tag(name,filename, \"/name\\\\s*=/\",fields)) ; function tags_from_module(mm::Module); try; println(STDERR, \"++ Generating Tags from mm ++\"); Task() do for name_sym in names(mm); value = eval(mm,name_sym); map(produce, tags(name_sym, mm, value)); |> collect; catch ee; warn(string(Module)*\" tagging failed. As \"* string(ee)); []; function name2module(name); eval(parse(\"import \"*name)); eval(parse(name)); function create_module_tagsfile(cache_name, module_name); mkpath(cache_location); mod = name2module(module_name); if mod==nothing; warn(\"(module_name) Not Found\"); return nothing; open(cache_name,\"w\") do fp; tags = tags_from_module(mod) |> collect; file_mtimes = Dict(tag.file=>stat(tag.file).mtime|>Dates.unix2datetime for tag in tags); write_header(fp, file_mtimes); for tag in tags; write_tag(fp,tag); function is_cache_current(cache_name); for line in eachline(cache_name); if line[1:length(mtime_line_prefix)] == mtime_line_prefix; prefix, filename, mtime_str = split(line,\"\\t\"); cached_mtime = DateTime(mtime_str); cur_mtime = stat(filename).mtime |> Dates.unix2datetime; if cached_mtime!=cur_mtime return false; return true; function get_module_tag_file(module_name); println(STDERR, \"Sourcing module_name\"); cache_name = joinpath(cache_location,module_name*\".tags\"); if !isfile(cache_name) || !is_cache_current(cache_name); create_module_tagsfile(cache_name, module_name); cache_name; function parseall(str); Task() do pos = start(str); while !done(str, pos); ex, pos = parse(str, pos); produce(ex); function get_modules_names(filename); code = readstring(filename); function inner(::Any); function inner(ee::Expr); if ee.head == :using || ee.head==:importall; module_name = join(map(string,ee.args),\".\"); produce(module_name); else for arg in ee.args; inner(arg); Task() do; produce(\"Core\"); produce(\"Base\"); for ee in code |> parseall; for mod in @task inner(ee); produce(mod); function make_standalone_tagfile(filename); println(STDERR,\"Standalone Tagging filename\"); mod_names = get_modules_names(filename); open(joinpath(dirname(filename), \".\"*basename(filename)*\".tags\"),\"w\") do fp; for mod_name in mod_names; tag_file = get_module_tag_file(mod_name); println(fp, open(readstring, tag_file,\"r\")) function print_refered_tagfile_paths(filename); mod_names = get_modules_names(filename); for mod_name in mod_names; tag_file = get_module_tag_file(mod_name); println(tag_file); if length(ARGS)>0; mode = lowercase(ARGS[1]); if mode == \"standalone\"; make_standalone_tagfile(ARGS[2]); elseif mode == \"refer\"; print_refered_tagfile_paths(ARGS[2]); else println(\"Invalid mode selected.\")const binops_renames =Dict( :(<=) => \"\\\\le\", :(>=) => \"\\\\ge\", :in  => \"\\\\in\") const binops = [Symbol.(split(\"+ - < > ∈ ≈\"))..., keys(binops_renames)...] val_or_expr(x::Expr) = x val_or_expr(x) = Val{x}() function MathSequence(v_vs, binop) dlm = to_math(binop) vs = to_math.(collect(v_vs)) frags = Vector{MathExpressionFragment}() sizehint!(frags, 2*length(vs)-1) for v in vs[1:-1] push!(frags,v) push!(frags,dlm) push!(frags, vs[]) MathSequence(frags) to_math(sym::MathSymbolInner) = MathSymbol(sym) to_math{sym}(::Val{sym})= MathSymbol(sym) function to_math(::Val{:call}, v_binop::Union{(Val{binop} for binop in binops)...}, vs...) MathSequence(vs, v_binop) function to_math(::Val{:call}, ::Val{:^}, v_base, v_expo) MathSuperscript(to_math(v_base), to_math(v_expo)) function to_math(::Val{:call}, ::Val{:/}, v_base, v_expo) MathFrac(to_math(v_base), to_math(v_expo)) function to_math{func}(::Val{:call}, v_func::Val{func}, v_args...) MathFunctionCall(func, MathSequence(v_args, Symbol(\", \"))) function to_math(ast::Expr) to_math(Val{ast.head}(), val_or_expr.(ast.args)... ) to_math(::Val{:vect},vs...) = to_math_vector(vs) function to_math_vector(col) math_col = MathExpressionFragment[to_math(c) for c in col] MathMatrix(math_col[:,:])  to_math(::Val{:hcat},row...) = to_math_matrix(row) function to_math_matrix(rows...) function math_row(row) row_vec = MathExpressionFragment[to_math(r) for r in row.args] permutedims(row_vec[:,:], (2,1))   MathMatrix(vcat(map(math_row, rows)...)) function to_math(::Val{:vcat},vs...) if typeof(vs[1])<:Expr && vs[1].head == :row to_math_matrix(vs...) else to_math_vector(vs)  \"Note: Does not (currently) escape all of latex.\" function escape_latex(s::AbstractString) replace(s,\"_\",\"\\_\") latex_brace(x::AbstractString) = \"{\" * x * \"}\" to_latex(s::MathSymbolInner) = to_latex(\"s\") to_latex(s::AbstractString) = escape_latex(s) to_latex(x::MathSymbol) = to_latex(x.sym) function to_latex(x::MathSuperscript) to_latex(x.base) * \"^\" * latex_brace(to_latex(x.expo)) function to_latex(x::MathFrac) \"\\\\frac\" * latex_brace(to_latex(x.numer)) * latex_brace(to_latex(x.denom)) function to_latex(x::MathFunctionCall) name = x.fname |> string |> escape_latex if length(name) > 1 name = \"\\\\mathrm\"*latex_brace(name)  name*to_latex(x.arg) function to_latex(x::MathMatrix)  desc = \"c\"^size(x.mat,1) rows = mapslices(y->join(y,\" & \"), to_latex.(x.mat),2) |> vec latexmat = join(rows, \"\\\\\\\\\") \"\\\\left[\\\\begin{array}{desc} latexmat \\\\{array}\\\\right]\" to_latex(x::MathSequence) = \"(\" * join(to_latex.(x.fragments),\" \") * \")\" abstract MathExpressionFragment immutable MathSequence <:MathExpressionFragment fragments::Vector{MathExpressionFragment} typealias MathSymbolInner Union{Base.BitInteger.types..., Float16, Float32, Float64, Symbol} immutable MathSymbol{T<:MathSymbolInner} <: MathExpressionFragment sym::T immutable MathFrac <: MathExpressionFragment numer::MathExpressionFragment denom::MathExpressionFragment immutable MathSuperscript <: MathExpressionFragment base::MathExpressionFragment expo::MathExpressionFragment immutable MathFunctionCall <: MathExpressionFragment fname::Symbol arg::MathSequence immutable MathMatrix <: MathExpressionFragment mat::Matrix{MathExpressionFragment} module Expr2LaTeX using LaTeXStrings using DocStringExtensions export to_math, to_latex, rer, rerval, @rer include(\"rer.jl\") include(\"mathast.jl\") include(\"expr2math.jl\") include(\"math2latex.jl\")  function datafile(filename) joinpath(dirname(@__FILE__),\"..\",\"data\", filename) \" Parses as string of the form eg \\\" \" parse_hexcode(h::AbstractString) = reinterpret(RGB24, parse(UInt32,h[2:],16)) \"Parses three strings that are integers between 0-255, and converts to color\" function parse_decimal256(r::AbstractString, g::AbstractString, b::AbstractString) ret = 0x00_00_00_00 ret+=parse(UInt8,r) ret<<=8 ret+=parse(UInt8,g) ret<<=8 ret+=parse(UInt8,b) reinterpret(RGB24, ret) \"Parses strings in CIE l*a*b, eg \\\"2.03/-0.03/9.89\\\"\" function parse_CieLab(vals) l,a,b = (x->parse(Float64, x)).(split(vals,\"/\")) Lab(l,a,b) function load_x11_style(path) lines = eachline(path) data = Dict{String, RGB24}() for line in lines line[1]=='!' && continue fields = split(line) length(fields)==-0 && continue r, g, b = fields[1:3] name = strip(join(fields[4:],\" \")) data[name] = parse_decimal256(r,g,b) data function load_xcms_colordb(filename) ret = Dict{String, RGB24}() lines = eachline(open(filename,\"r\")) for line in lines startswith(line, \"XCMS_COLORDB_START\") && break for line in lines startswith(line, \"XCMS_COLORDB_\") && break name, colorcode = split(line, '\\t'; keep=false) spec, vals = split(colorcode, \":\") @assert spec == \"CIELab\" \"Only CIELab format supported right now\" col = parse_CieLab(vals) ret[name] = convert(RGB24, col) ret function load_resene() lines = eachline(datafile(\"resenecolours.txt\")) for line in lines startswith(line, \"\\\"Colour Name\\\"\") && break data = Dict{String, RGB24}() for line in lines namefield, rr, gg, bb = split(line,\"\\t\") name = namefield[1+length(\"\\\"Resene \") : -1] data[name] = parse_decimal256(rr, gg, bb) data include(\"types.jl\") function float32name(fname::Symbol) name_parts = split(string(fname),\"_\") new_name = name_parts[1]*\"f\" if length(name_parts) > 1 new_name *= \"_\"*join(name_parts[2:]) Symbol(new_name) for fname in (:xsin, :xcos, :xtan, :xasin, :xacos, :xatan, :xexp, :xsinh, :xcosh, :xtanh, :xasinh, :xacosh, :xatanh, :xcbrt, :xexp2, :xexp10, :xexpm1, :xsin_u1, :xcos_u1, :xtan_u1, :xasin_u1, :xacos_u1, :xatan_u1, :xcbrt_u1) @eval begin @inline function fname(a::Float64) ret = ccall(((QuoteNode(fname)), jl_sleef),VDouble,(VDouble,), a) Base.convert(Float64, ret) @inline function fname(a::Float32) ret = ccall(((QuoteNode(float32name(fname))), jl_sleef),VFloat,(VFloat,), a) Base.convert(Float32, ret) for fname in (:xlog, :xlog10, :xlog_u1) @eval begin @inline function fname(a::Float64) isnan(a) || a >= 0.0 || throw(DomainError()) ret = ccall(((QuoteNode(fname)), jl_sleef),VDouble,(VDouble,), a) Base.convert(Float64, ret) @inline function fname(a::Float32) isnan(a) || a >= 0f0 || throw(DomainError()) ret = ccall(((QuoteNode(float32name(fname))), jl_sleef),VFloat,(VFloat,), a) Base.convert(Float32, ret) @inline function xlog1p(a::Float64) isnan(a) || a >= -1.0 || throw(DomainError()) ret = ccall((:xlog1p, jl_sleef),VDouble,(VDouble,), a) Base.convert(Float64, ret) @inline function xlog1p(a::Float32) isnan(a) || a >= -1f0 || throw(DomainError()) ret = ccall((:xlog1pf, jl_sleef),VFloat,(VFloat,), a) Base.convert(Float32, ret) for fname in [:xsincos, :xsincos_u1] @eval begin @inline function fname(a::Float64) ret = ccall(((QuoteNode(fname)), jl_sleef),VDouble2,(VDouble,), a) Base.convert(Tuple{Float64,Float64}, ret) @inline function fname(a::Float32) ret = ccall(((QuoteNode(float32name(fname))), jl_sleef),VFloat2,(VFloat,), a) Base.convert(Tuple{Float32,Float32}, ret) for fname in [:xatan2, :xpow, :xatan2_u1] @eval begin @inline function fname(a::Float64, b::Float64) ret = ccall(((QuoteNode(fname)), jl_sleef),VDouble,(VDouble,VDouble), a, b) Base.convert(Float64, ret) @inline function fname(a::Float32, b::Float32) ret = ccall(((QuoteNode(float32name(fname))), jl_sleef),VFloat,(VFloat,VFloat), a, b) Base.convert(Float32, ret) @inline function xldexp(x::Float64, q::Int32) ret = ccall((:xldexp, jl_sleef),VDouble,(VDouble, VInt), xv, qv) Base.convert(Float64, ret) @inline function xldexp(x::Float32, q::Int32) ret = ccall((:xldexpf, jl_sleef),VDouble,(VFloat, VInt2), x, q) Base.convert(Float64, ret) @inline function xilogb(a::Float64) ret = ccall((:xilogb, jl_sleef),VInt,(VDouble,), a) convert(Int32, ret) using Base.Cartesian.@ntuple @inline vinit8{T}(x::T) = @ntuple 8 k->k==1 ? VecElement{T}(x) : VecElement{T}(zero(T)) @inline vinit4{T}(x::T) = @ntuple 4 k->k==1 ? VecElement{T}(x) : VecElement{T}(zero(T)) @inline vinit2{T}(x::T) = @ntuple 2 k->k==1 ? VecElement{T}(x) : VecElement{T}(zero(T)) typealias __m256d NTuple{4, VecElement{Float64}} @inline Base.convert(::Type{__m256d}, x::Float64) = __m256d(vinit4(x)) @inline Base.convert(::Type{Float64}, x::__m256d) = first(x).value typealias __m128d NTuple{2, VecElement{Float64}} @inline Base.convert(::Type{__m128d}, x::Float64) = __m128d(vinit2(x)) @inline Base.convert(::Type{Float64}, x::__m128d) = first(x).value typealias __m256 NTuple{8, VecElement{Float32}} @inline Base.convert(::Type{__m256}, x::Float32) = __m256(vinit8(x)) @inline Base.convert(::Type{Float32}, x::__m256) = first(x).value typealias __m128 NTuple{4, VecElement{Float32}} @inline Base.convert(::Type{__m128}, x::Float32) = __m128(vinit4(x)) @inline Base.convert(::Type{Float32}, x::__m128) = first(x).value typealias __m256i NTuple{8, VecElement{Int32}} @inline Base.convert(::Type{__m256i}, x::Int32) = __m256i(vinit8(x)) @inline Base.convert(::Type{Int32}, x::__m256i) = first(x).value typealias __m128i NTuple{4, VecElement{Int32}} @inline Base.convert(::Type{__m128i}, x::Int32) = __m128i(vinit4(x)) @inline Base.convert(::Type{Int32}, x::__m128i) = first(x).value if SIMD_ARCH == \"sse2\" typealias VDouble __m128d typealias VInt __m128i typealias VFloat __m128 typealias VInt2 __m128i elseif SIMD_ARCH == \"avx\" || SIMD_ARCH == \"fma4\" typealias VDouble __m256d typealias VInt __m128i typealias VFloat __m256 immutable VInt2 x::VInt y::VInt elseif SIMD_ARCH == \"avx2\" typealias VDouble __m256d typealias VInt __m128i typealias VFloat __m256 typealias VInt2 __m256i elseif SIMD_ARCH == \"purec\" typealias VDouble Float64 typealias VInt Int32 typealias VFloat Float32 typealias VInt2 Int32 else error(\"SIMD instruction set: (SIMD_ARCH). Not Supported. This error should never occur. Please report this bug.\") immutable VDouble2 x::VDouble y::VDouble Base.convert(::Type{Tuple{Float64,Float64}}, d::VDouble2) = (convert(Float64, d.x), convert(Float64, d.y)) immutable VFloat2 x::VFloat y::VFloat Base.convert(::Type{Tuple{Float32,Float32}}, d::VFloat2) = (convert(Float32, d.x), convert(Float32, d.y)) module SLEEF export xsin, xcos, xtan, xasin, xacos, xatan, xlog, xexp, xsinh, xcosh, xtanh, xasinh, xacosh, xatanh, xcbrt, xexp2, xexp10, xexpm1, xlog10, xlog1p, xsin_u1, xcos_u1, xtan_u1, xasin_u1, xacos_u1, xatan_u1, xlog_u1, xcbrt_u1, xsincos, xsincos_u1, xatan2, xatan2_u1, xpow, xldexp, xilogb if isfile(joinpath(dirname(@__FILE__),\"..\",\"deps\",\"deps.jl\")) include(\"../deps/deps.jl\") else error(\"SLEEF not properly installed. Please run Pkg.build(\\\"SLEEF\\\")\") include(\"sleef_inner.jl\") module Pipe using Compat export @pipe function rewrite(ff::Expr,target) function replace(arg::Any) arg function replace(arg::Symbol) if arg==:_ target else arg function replace(arg::Expr) rep = copy(arg) rep.args = map(replace,rep.args) rep if (ff.head==:call) rep_args = map(replace,ff.args) if ff.args != rep_args ff.args=rep_args return ff rewrite_apply(ff,target) function rewrite_apply(ff::@compat(Union{Symbol,Expr}), target) :( ff( target)) function rewrite(ff::Symbol,target) rewrite_apply(ff,target) function funnel(ee::Any) ee function funnel(ee::Expr) if (ee.args[1]==:|>) ff = ee.args[3] target = funnel(ee.args[2]) rewrite(ff,target) else ee macro pipe(ee) esc(funnel(ee)) using Luxor const draw_width = 500 const draw_height = 500 Drawing(draw_width, draw_height, \"code.png\") background(\"black\") sethue(\"red\") fontsize(5) textbuff = IOBuffer(codetext) letters_per_line = Int(draw_width ÷ (0.7*textextents(\"x\")[3])) line_height = 1.5*textextents(\"I\")[4] line_raw = Vector{UInt8}(letters_per_line) for y_pos in 0:line_height:draw_height readbytes!(textbuff, line_raw) text(String(line_raw), 0, y_pos) end finish() preview()\n\"\"\";",
      "execution_count": 1,
      "outputs": []
    },
    {
      "metadata": {
        "collapsed": false,
        "trusted": true
      },
      "cell_type": "code",
      "source": "using Luxor\n\n\n\nfunction jeds_logo(draw_width = 500)\n    Drawing(draw_width, draw_width, \"code-$(draw_width).png\")\n\n    background(\"black\")\n\n    fontface(\"Courier\")\n    fontsize(2/50*draw_width)\n\n    textbuff = IOBuffer(codetext)\n    letters_per_line = Int(draw_width ÷ (0.7*textextents(\"x\")[3]))\n    line_height = 1.5*textextents(\"I\")[4]\n\n\n    line_raw = Vector{UInt8}(letters_per_line)\n    for y_pos in 0:line_height:draw_width\n\n        readbytes!(textbuff, line_raw)\n\n        newsubpath()\n            move(0, y_pos)\n            textpath(String(line_raw))\n            setline(3)\n            setcolor(\"black\")\n        closepath()\n    end\n    clip()\n    closepath()\n    origin()\n    juliacircles(draw_width/5)\n\n    finish()\n    preview()\nend",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": "jeds_logo (generic function with 2 methods)"
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "metadata": {
        "collapsed": false,
        "trusted": true
      },
      "cell_type": "code",
      "source": "jeds_logo(500)",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "collapsed": false
      },
      "cell_type": "code",
      "source": "jeds_logo(200)",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "collapsed": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "julia-0.6",
      "display_name": "Julia 0.6.0-rc2",
      "language": "julia"
    },
    "language_info": {
      "mimetype": "application/julia",
      "file_extension": ".jl",
      "version": "0.6.0",
      "name": "julia"
    },
    "gist": {
      "id": "54024275480da75ee0ffcfe7271e8e75",
      "data": {
        "description": "JuliaEditorSupportLogo.ipynb",
        "public": true
      }
    },
    "_draft": {
      "nbviewer_url": "https://gist.github.com/54024275480da75ee0ffcfe7271e8e75"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}