General cleanup of linear algebra routines

- Better error messages
  - [x] Use meaningful `Exception` in `Base.cov`
  - [x] Change generic `error()` calls to `throw(DimensionMismatch(""))`
    where appropriate
  - [x] Interpolate invalid values into error messages
- Generic error handlers for consistent error handling
  - [x] Generic LAPACK error handlers
    - [x] `@assertargsok` throws `ArgumentError`s on negative `info` statuses
    - [x] `@lapackerror` adds throwing `LAPACKExceptions` on positive
      `info` statuses
    - [x] `assertnonsingular`, `assertposdef` throw `SingularError`s and
      `PosDefException`s on positive `info` codes
  - [x] Eliminate generic `error`s for exceptions, esp `KeyError`s in
    `getindex` methods
  - [x] Generic `umferror()` error handler for UMFPACK
    - maps UMFPACK errors to native Julian `Exception`s where
      appropriate
    - maps UMPPACK warnings to throwing `IllConditionedMatrixException`s
  - [x] Remove `info`s as returned quantities from LAPACK wrappers
    (except for `getrf!`, `potrf!`, `pstrf!`, where this is useful for
    higher level routines in `LinAlg`)
- throw `MatrixIllConditionedException` on UMFPACK warnings
- Better error detection
  - [x] Inserts more checks for singular elements in `Diagonal` matrix
    algebra where necessary.
- Genericizing input and output validation
  - [x] Replace square matrix checks with `chksquare`
  - [x] Add macros to simplify testing for bad matrices
    - `@assertrank`, `@assertrank2`: rank deficiency
    - `@assertnonsingular`: singular matrices
    - `@assertposdef`: positive definiteness
  - [x] Add mode validation for `uplo` with `@chkuplo`
  - [x] Add `@isok()` macros to simplify status variable interpretation in
    UMFPACK and CHOLMOD
- Simplify code
  - [x] Consolidate `*` for special matrices
  - [x] Convert simple functions to one-liners
  - [x] Collapse simple `if/else` branches to ternary `?:`s
  - [x] Collapse nested loops using `for i=..., j=...` multiple loop syntax
  - [x] Remove trailing semicolons
  - [x] Consolidate method definitions using type `Union`s and default
    keywords
  - [x] use `apply` to choose appropriate arguments to identical function
    calls
  - [x] use ternary `?:` to collapse appropriate function calls on identical
    arguments
  - [x] Replace appropriate `Union`s with `BlasReal`, `BlasComplex`, `BlasFloat`
- [x] Standardize use of explicit/implicit `return`s
- [x] Simplify code by explicitly writing out zero-padding steps
- [x] Change bitwise & to logical &&

TODO
- [ ] `thin` should probably be a keyword argument.
- [ ] remaining `error`s need a new `DomainError` constructor
- [ ] consistent error messages with `DimensionMismatch`es
Fix doc typo
fix #4884, isqrt for Int64 and Int128
Fix typo in README.md
Merge branch 'master' of github.com:JuliaLang/julia
readcsv fix col count when no newline. fixes #4890

added tests for single line csv without newline

used iobuffer for tests
add 1-argument dict constructor, from anything that generates pairs
try to fix build failure due to 11def4933cb20a504a76168f286497dba8dad459
start adding '.. doctest::' directives to manual
some doc/manual fixes found by doctest
Merge pull request #4894 from tanmaykm/master

readcsv fix col count when no newline. fixes #4890
Fix a memory error in Stat. Thanks ASAN
parseint: code cleanup.
Base.checked_{add,sub,mul}: checked versions of +, - and *.

We've had the intrinsics for checked arithmetic for a rather long time,
we just haven't used it anywhere. This defines checked +, - and * the
same way that we define +, - and *. I had a previous version in which
these worked like +, - and * with promotion and all, but realized that
wasn't actually desirable. When you're doing checked arithmetic, you
want strictly same-type arguments and you want to make sure that they
don't result in an overflowed result for that exact integer type.

Note that there may be an LLVM bug for checked 8-bit multiply: the
overflow flag ends up set no matter what two values you multiply. I
worked around this by defining 8-bit checked multiply without LLVM's
intrinsic, but it would be good to look into this further.
parseint: basic implementation of overflow-detection [fixes #4874]
parseint: allow automatic base detection via 0[box] prefixes.
parseint: speed up parsing by avoiding checks in main paring loop.

The trick here is that we know that we can't possibly overflow until
we reach a fairly large value for each type. In particular, we can't
possibly overflow while n <= div(typemax(T)-base+1,base). After that
we can have one or two decoding cycles left, which actually have to
be checked for overflow. The "naïve" version was 2x+ slower than the
unchecked version, while this version is only around 15% slower.
parseint: tests of overflow detection.
parseint: tests for automatic base detection.
Merge pull request #4875 from JuliaLang/sk/checked

Base.checked_{add,sub,mul} and overflow-safe parseint