NEWS.md

Julia v0.3.0 Release Notes

New language features

• Greatly enhanced performance for passing and returning Tuples (#4042).

• Tuples (of Integers, Symbols, or Bools) can now be used as type parameters (#5164).

• An additional default "inner" constructor accepting any arguments is now generated. Constructors that look like MyType(a, b) = new(a, b) do not need to be added manually (#4026, #7071).

• Expanded array type hierarchy to include an abstract DenseArray for in-memory arrays with standard strided storage (#987, #2345, #6212).

• When reloading code, types whose definitions have not changed can be ignored in some cases.

• Binary ~ now parses as a vararg macro call to @~. For example x~y~z => @~ x y z (#4882).

• Structure fields can now be accessed by index (#4806).

• If a module contains a function __init__(), it will be called when the module is first loaded, and on process startup if a pre-compiled version of the module is present (#1268).

• Multi-line comments (#69, #6128): #= .... =#

• --bounds-check=yes|no compiler option

• Unicode identifiers are normalized (NFC) so that different encodings of equivalent strings are treated as the same identifier (#5462).

• The set of characters permitted in identifiers has been restricted based on Unicode categories. Generally, punctuation, formatting and control characters, and operator symbols are not allowed in identifiers. Number-like characters cannot begin identifiers (#5936).

• Define a limited number of infix Unicode operators (#552, #6582):

  Precedence class	Operators (with synonyms, if any)
  ==	≥ (>=) ≤ (<=) ≡ (===) ≠ (!=) ≢ (!==) .≥ (.>=) .≤ (.<=) .!= (.≠) ∈ (in) ∉ ((x,y)->!in(x, y)) ∋ ((x,y)->in(y, x)) ∌ ((x,y)->!in(y, x)) ⊆ (issubset) ⊈ ((x,y)->!issubset(x, y)) ⊊ ((x,y)->x⊆y && x!=y)
  +	∪ (union)
  *	÷ (div) ⋅ (dot) × (cross) ∩ (intersect)
  unary	√ ∛

  In addition to these, many of the Unicode operator symbols are parsed as infix operators and are available for user-defined methods (#6929).

• Improved reporting of syntax errors (#6179)

• break inside a for loop with multiple ranges now exits the entire loop nest (#5154)

• Local goto statements using the @goto and @label macros. (#101)

REPL improvements

• New native-Julia REPL implementation, eliminating many problems stemming from the old GNU Readline-based REPL (#6270).

• Tab-substitution of LaTeX math symbols (e.g. \alpha by α) (#6911). This also works in IJulia and in Emacs (#6920).

• workspace() function for obtaining a fresh workspace (#1195).

Library improvements

• isequal now compares all numbers by value, ignoring type (#6624).

• Implement limited shared-memory parallelism with SharedArrays (#5380).

• Well-behaved floating-point ranges (#2333, #5636). Introduced the FloatRange type for floating-point ranges with a step, which will give intuitive/correct results for classically problematic ranges like 0.1:0.1:0.3, 0.0:0.7:2.1 or 1.0:1/49:27.0.

• mod2pi function (#4799, #4862).

• New functions minmax and extrema (#5275).

• New macros @edit, @less, @code_typed, @code_lowered, @code_llvm and @code_native that all function like @which (#5832).

• consume(p) extended to consume(p, args...), allowing it to optionally pass args... back to the producer (#4775).

• .juliarc.jl is now loaded for both script and REPL execution (#5076).

• The Sys module now includes convenient functions for working with dynamic library handles; Sys.dllist will list out all paths currently loaded via dlopen, and Sys.dlpath will lookup a path from a handle

• readdlm treats multiple whitespace characters as a single delimiter by default (when no delimiter is specified). This is useful for reading fixed-width or messy whitespace-delimited data (#5403).

• The Airy, Bessel, Hankel, and related functions (airy*, bessel*, hankel*) now detect errors returned by the underlying AMOS library, throwing an AmosException in that case (#4967).

• methodswith now returns an array of Methods (#5464) rather than just printing its results.

• errno([code]) function to get or set the C library's errno.

• GitHub module for interacting with the GitHub API.

• Package improvements

  • Packages are now installed into .julia/v0.3 by default (or whatever the current Julia version is), so that different versions of Julia can co-exist with incompatible packages. Existing .julia installations are unaffected unless Pkg.init() is run to re-create the package directories (#3344, #5737).

  • Pkg.submit(pkg[,commit]) function to automatically submit a GitHub pull request to the package author.

• Collections improvements

  • Array assignment (e.g. x[:] = y) ignores singleton dimensions and allows the last dimension of one side to match all trailing dimensions of the other (#4048, #4383).

  • Dict(kv) constructor for any iterator on (key,value) pairs.

  • Multi-key Dicts: D[x,y...] is now a synonym for D[(x,y...)] for associations D (#4870).

  • push! and unshift! can push multiple arguments (#4782).

  • writedlm and writecsv now accept any iterable collection of iterable rows, in addition to AbstractArray arguments, and the writedlm delimiter can be any printable object (e.g. a String) instead of just a Char.

  • isempty now works for any iterable collection (#5827).

  • unique now accepts an optional dim argument for finding unique rows or columns of a matrix or regions of a multidimensional array (#5811).

• Number improvements

  • The ImaginaryUnit type no longer exists. Instead, im is of type Complex{Bool}. Making this work required changing the semantics of boolean multiplication to approximately, true * x = x and false * x = zero(x), which can itself be considered useful (#5468).

  • big is now vectorized (#4766)

  • nextpow and prevpow now return the a^n values instead of the exponent n (#4819)

  • Overflow detection in parseint (#4874).

  • rand now supports arbitrary Ranges arguments (#5059).

  • expm1 and log1p now support complex arguments (#3141).

  • Broadcasting .// is now included (#7094).

  • prevfloat and nextfloat now saturate at -Inf and Inf, respectively, and have otherwise been fixed to follow the IEEE-754 standard functions nextDown and nextUp (#5025).

  • New function widen for widening numeric types and values, and widemul for multiplying to a larger type (#6169).

  • polygamma, digamma, and trigamma now accept complex arguments, and zeta(s, z) now provides the Hurwitz zeta (#7125).

  • Narrow integer types (< 32 bits) are promoted to Float64 rather than to Float32 by float(x) (#7390).

• String improvements

  • Triple-quoted regex strings, r"""...""" (#4934).

  • New string type, UTF16String (#4930), constructed by utf16(s) from another string, a Uint16 array or pointer, or a byte array (possibly prefixed by a byte-order marker to indicate endian-ness). Its data is internally NULL-terminated for passing to C (#7016).

  • CharString is renamed to UTF32String (#4943), and its data is now internally NULL-terminated for passing to C (#7016). CharString(c::Char...) is deprecated in favor of utf32(c...), and utf32(s) otherwise has functionality similar to utf16(s).

  • New WString and wstring synonyms for either UTF16String and utf16 or UTF32String and utf32, respectively, depending on the width of Cwchar_t (#7016).

  • normalize_string function to perform Unicode normalization, case-folding, and other transformations (#5576).

  • pointer(s, i=1) for ByteString, UTF16String, UTF32String, and SubStrings thereof (#5703).

  • bytestring is automatically called on String arguments for conversion to Ptr{Uint8} in ccall (#5677).

• Linear algebra improvements

  • Balancing options for eigenvector calculations for general matrices (#5428).

  • Mutating linear algebra functions no longer promote (#5526).

  • condskeel for Skeel condition numbers (#5726).

  • norm(::Matrix) no longer calculates a vector norm when the first dimension is one (#5545); it always uses the operator (induced) matrix norm.

  • New vecnorm(itr, p=2) function that computes the norm of any iterable collection of numbers as if it were a vector of the same length. This generalizes and replaces normfro (#6057), and norm is now type-stable (#6056).

  • New UniformScaling matrix type and identity I constant (#5810).

  • None of the concrete matrix factorization types are exported from Base by default anymore.

  • Sparse linear algebra

    • 1-d sparse getindex has been implemented (#7047)

    • Faster sparse getindex (#7131).

    • Faster sparse kron (#4958).

    • sparse(A) \ B now supports a matrix B of right-hand sides (#5196).

    • eigs(A, sigma) now uses shift-and-invert for nonzero shifts sigma and inverse iteration for which="SM". If sigma==nothing (the new default), computes ordinary (forward) iterations. (#5776)

    • sprand is faster, and whether any entry is nonzero is now determined independently with the specified probability (#6726).

  • Dense linear algebra for special matrix types

    • Interconversions between the special matrix types Diagonal, Bidiagonal, SymTridiagonal, Triangular, and Triangular, and Matrix are now allowed for matrices which are representable in both source and destination types. (5e3f074b)

    • Allow for addition and subtraction over mixed matrix types, automatically promoting the result to the denser matrix type (a448e080, #5927)

    • new algorithms for linear solvers and eigensystems of Bidiagonal matrices of generic element types (#5277)

    • new algorithms for linear solvers, eigensystems and singular systems of Diagonal matrices of generic element types (#5263)

    • new algorithms for linear solvers and eigensystems of Triangular matrices of generic element types (#5255)

    • specialized inv and det methods for Tridiagonal and SymTridiagonal based on recurrence relations between principal minors (#5358)

    • specialized transpose, ctranspose, istril, istriu methods for Triangular (#5255) and Bidiagonal (#5277)

    • new LAPACK wrappers

      • condition number estimate cond(A::Triangular) (#5255)

    • parametrize Triangular on matrix type (#7064)

    • Lyapunov / Sylvester solver (#7435)

    • eigvals for Symmetric, Tridiagonal and Hermitian matrices now support additional method signatures: (#3688, #6652, #6678, #7647)

      • eigvals(M, el, eu) finds all eigenvalues in the interval (el, eu]
      • eigvals(M, il:iu) finds the ilth through the iuth eigenvalues (in ascending order)

  • Dense linear algebra for generic matrix element types

    • LU factorization (#5381 and #5430)

    • QR factorization (#5526)

• New function deleteat! deletes a specified index or indices and returns the updated collection

• The setenv function for external processes now accepts a dir keyword argument for specifying the directory to start the child process in (#4888).

• Constructors for collections (Set, Dict, etc.) now generally accept a single iterable argument giving the elements of the collection (#4996, #4871)

• Ranges and arrays with the same elements are now unequal. This allows hashing and comparing ranges to be faster. (#5778)

• Broadcasting now works on arbitrary AbstractArrays (#5387)

• Reduction functions that accept a pre-allocated output array, including sum!, prod!, maximum!, minimum!, all!, any! (#6197, #5387)

• Faster performance on fill! and copy! for array types not supporting efficient linear indexing (#5671, #5387)

• Changes to range types (#5585)

  • Range is now the abstract range type, instead of Ranges

  • New function range for constructing ranges by length

  • Range is now StepRange, and Range1 is now UnitRange. Their constructors accept end points instead of lengths. Both are subtypes of a new abstract type OrdinalRange.

  • Ranges now support BigInt and general ordinal types.

  • Very large ranges (e.g. 0:typemax(Int)) can now be constructed, but some operations (e.g. length) will raise an OverflowError.

• Extended API for cov and cor, which accept keyword arguments vardim, corrected, and mean (#6273)

• New functions randsubseq and randsubseq! to create a random subsequence of an array (#6726)

• New macro @evalpoly for efficient inline evaluation of polynomials (#7146).

• The signal filtering function filt now accepts an optional initial filter state vector. A new in-place function filt! is also exported. (#7513)

• Significantly faster cumsum and cumprod. (#7359)

Build improvements

• Dependencies are now verified against stored MD5/SHA512 hashes, to ensure that the correct file has been downloaded and was not modified. (#6773)

Deprecated or removed

• convert(Ptr{T1}, x::Array{T2}) is now deprecated unless T1 == T2 or T1 == None (#6073). (You can still explicitly convert one pointer type into another if needed.)

• Sys.shlib_ext has been renamed to Sys.dlext

• dense is deprecated in favor of full (#4759)

• The Stat type is renamed StatStruct (#4670)

• set_rounding, get_rounding and with_rounding now take an additional argument specifying the floating point type to which they apply. The old behaviour and [get/set/with]_bigfloat_rounding functions are deprecated (#5007)

• cholpfact and qrpfact are deprecated in favor of keyword arguments in cholfact(..., pivot=true) and qrfact(..., pivot=true) (#5330)

• symmetrize! is deprecated in favor of Base.LinAlg.copytri! (#5427)

• myindexes has been renamed to localindexes (#5475)

• factorize! is deprecated in favor of factorize. (#5526)

• nnz counts the number of structural nonzeros in a sparse matrix. Use countnz for the actual number of nonzeros. (#6769)

• setfield is renamed setfield! (#5748)

• put and take are renamed put! and take! (#5511)

• put! now returns its first argument, the remote reference (#5819)

• read methods that modify a passed array are now called read! (#5970)

• infs and nans are deprecated in favor of the more general fill.

• * and div are no longer supported for Char.

• Range is renamed StepRange and Range1 is renamed UnitRange. Ranges is renamed Range.

• bitmix is replaced by a 2-argument form of hash.

• readsfrom and writesto are replaced by open (#6948).

• insert! now throws a BoundsError if index > length(collection)+1 (#7373).

Julia v0.2.0 Release Notes

The 0.2 release brings improvements to many areas of Julia. Among the most visible changes are support for 64-bit Windows, keyword arguments to functions, immutable types, a redesigned and polished package manager, a multimedia interface supporting usage of Julia in IPython, a built-in profiler, and major improvements to Julia's linear algebra, I/O, and parallel capabilities. These are accompanied by many other changes adding new features, enhancing the library's consistency, improving performance, increasing test coverage, easing installation, and expanding the documentation. While not part of Julia proper, the package ecosystem has also grown and matured considerably since the 0.1 release. See below for more information about the long list of changes that improve Julia's usability and performance.

New language features

• Keyword & optional function arguments (#485, #1817).

• Immutable types (#13).

• Triple-quoted string literals (#70).

• New infix operator in (e.g. x in S), and corresponding function in(x,S), replacing contains(S,x) function (#2703).

• New variable bindings on each for loop and comprehension iteration (#1571). For example, before this change:

  julia> map(f->f(), { ()->i for i=1:3 })
  3-element Any Array:
   3
   3
   3
  

  and after:

  julia> map(f->f(), { ()->i for i=1:3 })
  3-element Any Array:
   1
   2
   3
  

• Explicit relative importing (#2375).

• Methods can be added to functions in other modules using dot syntax, as in Foo.bar(x) = 0.

• import module: name1, name2, ... (#5214).

• A semicolon is now allowed after an import or using statement (#4130).

• In an interactive session (REPL), you can use ;cmd to run cmd via an interactive shell. For example:

  julia> ;ls
  CONTRIBUTING.md  Makefile           VERSION      deps/      julia@  ui/
  DISTRIBUTING.md  NEWS.md            Windows.inc  doc/       src/    usr/
  LICENSE.md       README.md          base/        etc/       test/
  Make.inc         README.windows.md  contrib/     examples/  tmp/
  

New library functions

• Sampling profiler (#2597).

• Functions for examining stages of the compiler's output: code_lowered, code_typed, code_llvm, and code_native.

• Multimedia I/O API (display, writemime, etcetera) (#3932).

• MPFR-based BigFloat (#2814), and many new BigFloat operations.

• New half-precision IEEE floating-point type, Float16 (#3467).

• Support for setting floating-point rounding modes (#3149).

• methodswith shows all methods with an argument of specific type.

• mapslices provides a general way to perform operations on slices of arrays (#2204).

• repeat function for constructing Arrays with repeated elements (#3605).

• Collections.PriorityQueue type and Collections.heap functions (#2920).

• quadgk 1d-integration routine (#3140).

• erfinv and erfcinv functions (#2987).

• varm, stdm (#2265).

• digamma, invdigamma, trigamma and polygamma for calculating derivatives of gamma function (#3233).

• logdet (#3070).

• Names for C-compatible types: Cchar, Clong, etc. (#2370).

• cglobal to access global variables (#1815).

• unsafe_pointer_to_objref (#2468) and pointer_from_objref (#2515).

• readandwrite for external processes.

• I/O functions readbytes and readbytes! (#3878).

• flush_cstdio function (#3949).

• ClusterManager makes it possible to support different types of compute clusters (#3649, #4014).

• rmprocs for removing processors from a parallel computing session. The system can also tolerate to some extent processors that die unexpectedly (#3050).

• interrupt for interrupting worker processes (#3819).

• timedwait does a polled wait for an event till a specified timeout.

• Condition type with wait and notify functions for Task synchronization.

• versioninfo provides detailed version information, especially useful when reporting and diagnosing bugs.

• detach for running child processes in a separate process group.

• setenv for passing environment variables to child processes.

• ifelse eagerly-evaluated conditional function, especially useful for vectorized conditionals.

Library improvements

• isequal now returns false for numbers of different types. This makes it much easier to define hashing for new numeric types. Uses of Dict with numeric keys might need to change to account for this increased strictness.

• A redesigned and rewritten Pkg system is much more robust in case of problems. The basic interface to adding and removing package requirements remains the same, but great deal of additional functionality for developing packages in-place was added. See the new packages chapter in the manual for further details.

• Sorting API updates (#3665) – see sorting functions.

• The delete!(d::Dict, key) function has been split into separate pop! and delete! functions (#3439). pop!(d,key) removes key from d and returns the value that was associated with it; it throws an exception if d does not contain key. delete!(d,key) removes key from d and succeeds regardless of whether d contained key or not, returning d itself in either case.

• Linear-algebra factorization routines (lu, chol, etc.) now return Factorization objects (and lud, chold, etc. are deprecated; #2212).

• A number of improvements to sparse matrix capabilities and sparse linear algebra.

• More linear algebra fixes and eigensolver hooks for SymTridiagonal, Tridiagonal and Bidiagonal matrix types (#2606, #2608, #2609, #2611, #2678, #2713, #2720, #2725).

• Change integer_valued, real_valued, and so on to isinteger, isreal, and so on, and semantics of the later are now value-based rather than type-based, unlike MATLAB/Octave (#3071). isbool and iscomplex are eliminated in favor of a general iseltype function.

• Transitive comparison of floats with rationals (#3102).

• Fast prime generation with primes and fast primality testing with isprime.

• sum and cumsum now use pairwise summation for better accuracy (#4039).

• Dot operators (.+, .* etc.) now broadcast singleton dimensions of array arguments. This behavior can be applied to any function using broadcast(f, ...).

• combinations, permutations, and partitions now return iterators instead of a task, and integer_partitions has been renamed to partitions (#3989, #4055).

• isreadable/iswritable methods added for more IO types (#3872).

• Much faster and improved readdlm and writedlm (#3350, #3468, #3483).

• Faster matchall (#3719), and various string and regex improvements.

• Documentation of advanced linear algebra features (#2807).

• Support optional RTLD flags in dlopen (#2380).

• pmap now works with any iterable collection.

• Options in pmap for retrying or ignoring failed tasks.

• New sinpi(x) and cospi(x) functions to compute sine and cosine of pi*x more accurately (#4112).

• New implementations of elementary complex functions sqrt, log, asin, acos, atan, tanh, asinh, acosh, atanh with correct branch cuts (#2891).

• Improved behavior of SubArray (#4412, #4284, #4044, #3697, #3790, #3148, #2844, #2644 and various other fixes).

• New convenience functions in graphics API.

• Improved backtraces on Windows and OS X.

• Implementation of reduction functions (including reduce, mapreduce, sum, prod, maximum, minimum, all, and any) are refactored, with improved type stability, efficiency, and consistency. (#6116, #7035, #7061, #7106)

Deprecated or removed

• Methods of min and max that do reductions were renamed to minimum and maximum. min(x) is now minimum(x), and min(x,(),dim) is now minimum(x,dim). (#4235)

• ComplexPair was renamed to Complex and made immutable, and Complex128 and so on are now aliases to the new Complex type.

• ! was added to the name of many mutating functions, e.g., push was renamed push! (#907).

• ref renamed to getindex, and assign to setindex! (#1484).

• writeable renamed to writable (#3874).

• logb and ilogb renamed to exponent (#2516).

• quote_string became a method of repr.

• safe_char, check_ascii, and check_utf8 replaced by is_valid_char, is_valid_ascii, and is_valid_utf8, respectively.

• each_line, each_match, begins_with, ends_with, parse_float, parse_int, and seek_end replaced by: eachline, eachmatch, and so on (_ was removed) (#1539).

• parse_bin(s) replaced by parseint(s,2); parse_oct(s) replaced by parseint(s,8); parse_hex(s) replaced by parseint(s,16).

• findn_nzs replaced by findnz (#1539).

• DivideByZeroError replaced by DivideError.

• addprocs_ssh, addprocs_ssh_tunnel, and addprocs_local replaced by addprocs (with keyword options).

• remote_call, remote_call_fetch, and remote_call_wait replaced by remotecall, remotecall_fetch, and remotecall_wait.

• has replaced by in for sets and by haskey for dictionaries.

• diagmm and diagmm! replaced by scale and scale! (#2916).

• unsafe_ref and unsafe_assign replaced by unsafe_load and unsafe_store!.

• add_each! and del_each! replaced by union! and setdiff!.

• isdenormal renamed to issubnormal (#3105).

• expr replaced by direct call to Expr constructor.

• |, &, $, -, and ~ for sets replaced by union, intersect, symdiff, setdiff, and complement (#3272).

• square function removed.

• pascal function removed.

• add and add! for Set replaced by push!.

• ls function deprecated in favor of readdir or ;ls in the REPL.

• start_timer now expects arguments in units of seconds, not milliseconds.

• Shell redirection operators |, >, and < eliminated in favor of a new operator |> (#3523).

• amap is deprecated in favor of new mapslices functionality.

• The Reverse iterator was removed since it did not work in many cases.

• The gcd function now returns a non-negative value regardless of the argument signs, and various other sign problems with invmod, lcm, gcdx, and powermod were fixed (#4811).

Miscellaneous changes

• julia-release-* executables renamed to julia-*, and libjulia-release renamed to libjulia (#4177).

• Packages will now be installed in .julia/vX.Y, where X.Y is the current Julia version.

Bugfixes and performance updates

Too numerous to mention.