Replace http links with https links to suppress warning during doc li…

…nkcheck

DISTRIBUTING.md

@@ -69,7 +69,7 @@ Linux
 On Linux, `make binary-dist` creates a tarball that contains a fully
 functional Julia installation. If you wish to create a distribution
 package such as a `.deb`, or `.rpm`, some extra effort is needed. See the
-[julia-debian](http:https://github.com/staticfloat/julia-debian) repository
+[julia-debian](https:https://github.com/staticfloat/julia-debian) repository
 for an example of what metadata is needed for creating `.deb` packages
 for Debian and Ubuntu-based systems. See the
 [Fedora package](https://admin.fedoraproject.org/pkgdb/package/julia/)

README.md

@@ -265,7 +265,7 @@ Julia uses the following external libraries, which are automatically downloaded
 - **[OpenLibm]** — portable libm library containing elementary math functions.
 - **[OpenSpecFun]** (>= 0.4) — library containing Bessel and error functions of complex arguments.
 - **[DSFMT]** — fast Mersenne Twister pseudorandom number generator library.
-- **[OpenBLAS]** — fast, open, and maintained [basic linear algebra subprograms (BLAS)](http:https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) library, based on [Kazushige Goto's](http:https://en.wikipedia.org/wiki/Kazushige_Goto) famous [GotoBLAS](https://www.tacc.utexas.edu/research-development/tacc-software/gotoblas2).
+- **[OpenBLAS]** — fast, open, and maintained [basic linear algebra subprograms (BLAS)](https:https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) library, based on [Kazushige Goto's](https:https://en.wikipedia.org/wiki/Kazushige_Goto) famous [GotoBLAS](https://www.tacc.utexas.edu/research-development/tacc-software/gotoblas2).
 - **[LAPACK]** (>= 3.4) — library of linear algebra routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems.
 - **[MKL]** (optional) – OpenBLAS and LAPACK may be replaced by Intel's MKL library.
 - **[AMOS]** — subroutines for computing Bessel and Airy functions.

README.windows.md

@@ -261,7 +261,7 @@ replace `config.vm.provision :shell, privileged: false, :inline => $script_msys2
 
 ### Build process is slow/eats memory/hangs my computer
 
-- Disable the Windows [Superfetch](http:https://en.wikipedia.org/wiki/Windows_Vista_I/O_technologies#SuperFetch) and
+- Disable the Windows [Superfetch](https:https://en.wikipedia.org/wiki/Windows_Vista_I/O_technologies#SuperFetch) and
  [Program Compatibility Assistant](https://blogs.msdn.com/b/cjacks/archive/2011/11/22/managing-the-windows-7-program-compatibility-assistant-pca.aspx) services, as they are known to have
  [spurious interactions]((https://cygwin.com/ml/cygwin/2011-12/msg00058.html)) with MinGW/Cygwin.
 

base/primes.jl

@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Sieve of Atkin for generating primes:
-# http:https://en.wikipedia.org/wiki/Sieve_of_Atkin
+# https:https://en.wikipedia.org/wiki/Sieve_of_Atkin
 # Code very loosely based on this:
 # https://thomasinterestingblog.wordpress.com/2011/11/30/generating-primes-with-the-sieve-of-atkin-in-c/
 # https://dl.dropboxusercontent.com/u/29023244/atkin.cpp
@@ -35,7 +35,7 @@ primes(n::Union{Integer,AbstractVector{Bool}}) = find(primesmask(n))
 const PRIMES = primes(2^16)
 
 # Small precomputed primes + Miller-Rabin for primality testing:
-# http:https://en.wikipedia.org/wiki/Miller–Rabin_primality_test
+# https:https://en.wikipedia.org/wiki/Miller–Rabin_primality_test
 #
 function isprime(n::Integer)
  (n < 3 || iseven(n)) && return n == 2
@@ -77,8 +77,8 @@ isprime(n::Int128) = n < 2 ? false :
 
 # Trial division of small (< 2^16) precomputed primes +
 # Pollard rho's algorithm with Richard P. Brent optimizations
-# http:https://en.wikipedia.org/wiki/Trial_division
-# http:https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm
+# https:https://en.wikipedia.org/wiki/Trial_division
+# https:https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm
 # https://maths-people.anu.edu.au/~brent/pub/pub051.html
 #
 function factor{T<:Integer}(n::T)

doc/devdocs/backtraces.rst

@@ -103,5 +103,5 @@ A few terms have been used as shorthand in this guide:
 
 * ``<julia_root>`` refers to the root directory of the julia source tree; e.g. it should contain folders such as ``base``, ``deps``, ``src``, ``test``, etc.....
 
-.. _gist: http:https://gist.github.com
+.. _gist: https:https://gist.github.com
 .. _issue: https://github.com/JuliaLang/julia/issues?state=open

doc/devdocs/object.rst

@@ -79,16 +79,16 @@ However, the :ref:`man-embedding` section of the manual is also required reading
 for covering other details of boxing and unboxing various types,
 and understanding the gc interactions.
 
-Mirror structs for some of the built-in types are `defined in julia.h <http:https://github.com/JuliaLang/julia/blob/master/src/julia.h>`_.
-The corresponding global :c:type:`jl_datatype_t` objects are created by `jl_init_types in jltypes.c <http:https://github.com/JuliaLang/julia/blob/master/src/jltypes.c>`_.
+Mirror structs for some of the built-in types are `defined in julia.h <https:https://github.com/JuliaLang/julia/blob/master/src/julia.h>`_.
+The corresponding global :c:type:`jl_datatype_t` objects are created by `jl_init_types in jltypes.c <https:https://github.com/JuliaLang/julia/blob/master/src/jltypes.c>`_.
 
 Garbage collector mark bits
 ---------------------------
 
 The garbage collector uses several bits from the metadata portion of the :c:type:`jl_typetag_t`
 to track each object in the system.
 Further details about this algorithm can be found in the comments of the `garbage collector implementation in gc.c
-<http:https://github.com/JuliaLang/julia/blob/master/src/gc.c>`_.
+<https:https://github.com/JuliaLang/julia/blob/master/src/gc.c>`_.
 
 Object allocation
 -----------------
@@ -111,7 +111,7 @@ Types::
  jl_uniontype_t *jl_new_uniontype(jl_tuple_t *types);
 
 While these are the most commonly used options, there are more low-level constructors too,
-which you can find declared in `julia.h <http:https://github.com/JuliaLang/julia/blob/master/src/julia.h>`_.
+which you can find declared in `julia.h <https:https://github.com/JuliaLang/julia/blob/master/src/julia.h>`_.
 These are used in :c:func:`jl_init_types` to create the initial types needed to bootstrap the creation of the Julia system image.
 
 Tuples::
@@ -153,7 +153,7 @@ Arrays::
 
 Note that many of these have alternative allocation functions for various special-purposes.
 The list here reflects the more common usages, but a more complete list can be found by reading the `julia.h header file
-<http:https://github.com/JuliaLang/julia/blob/master/src/julia.h>`_.
+<https:https://github.com/JuliaLang/julia/blob/master/src/julia.h>`_.
 
 Internal to Julia, storage is typically allocated by :c:func:`newstruct` (or :func:`newobj` for the special types)::
 

doc/devdocs/stdio.rst

@@ -96,7 +96,7 @@ is reachable before initialisation is complete.
 Legacy ios.c library
 --------------------
 
-The :code:`julia/src/support/ios.c` library is inherited from `femtolisp <http:https://github.com/JeffBezanson/femtolisp>`_.
+The :code:`julia/src/support/ios.c` library is inherited from `femtolisp <https:https://github.com/JeffBezanson/femtolisp>`_.
 It provides cross-platform buffered file IO and in-memory temporary buffers.
 
 :code:`ios.c` is still used by:
@@ -107,7 +107,7 @@ It provides cross-platform buffered file IO and in-memory temporary buffers.
 
 Use of :code:`ios.c` in these modules is mostly self-contained and
 separated from the ``libuv`` I/O system. However, there is `one place
-<http:https://github.com/JuliaLang/julia/blob/master/src/flisp/print.c#L654>`_
+<https:https://github.com/JuliaLang/julia/blob/master/src/flisp/print.c#L654>`_
 where femtolisp calls through to :c:func:`jl_printf` with a legacy :c:type:`ios_t` stream.
 
 There is a hack in :code:`ios.h` that makes the :c:member:`ios_t.bm`

doc/manual/arrays.rst

@@ -588,7 +588,7 @@ stride parameters.
 Sparse Matrices
 ===============
 
-`Sparse matrices <http:https://en.wikipedia.org/wiki/Sparse_matrix>`_ are
+`Sparse matrices <https:https://en.wikipedia.org/wiki/Sparse_matrix>`_ are
 matrices that contain enough zeros that storing them in a special data
 structure leads to savings in space and execution time. Sparse
 matrices may be used when operations on the sparse representation of a
@@ -600,7 +600,7 @@ Compressed Sparse Column (CSC) Storage
 
 In Julia, sparse matrices are stored in the `Compressed Sparse Column
 (CSC) format
-<http:https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_.28CSC_or_CCS.29>`_.
+<https:https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_.28CSC_or_CCS.29>`_.
 Julia sparse matrices have the type ``SparseMatrixCSC{Tv,Ti}``, where ``Tv``
 is the type of the nonzero values, and ``Ti`` is the integer type for
 storing column pointers and row indices.::

doc/manual/calling-c-and-fortran-code.rst

@@ -39,7 +39,7 @@ functions in the Julia runtime, or functions in an application linked to
 Julia.
 
 By default, Fortran compilers `generate mangled names
-<http:https://en.wikipedia.org/wiki/Name_mangling#Name_mangling_in_Fortran>`_
+<https:https://en.wikipedia.org/wiki/Name_mangling#Name_mangling_in_Fortran>`_
 (for example, converting function names to lowercase or uppercase,
 often appending an underscore), and so to call a Fortran function via
 ``ccall`` you must pass the mangled identifier corresponding to the rule

doc/manual/constructors.rst

@@ -32,7 +32,7 @@ together is all that is ever needed to create instances. There are,
 however, cases where more functionality is required when creating
 composite objects. Sometimes invariants must be enforced, either by
 checking arguments or by transforming them. `Recursive data
-structures <http:https://en.wikipedia.org/wiki/Recursion_%28computer_science%29#Recursive_data_structures_.28structural_recursion.29>`_,
+structures <https:https://en.wikipedia.org/wiki/Recursion_%28computer_science%29#Recursive_data_structures_.28structural_recursion.29>`_,
 especially those that may be self-referential, often cannot be
 constructed cleanly without first being created in an incomplete state
 and then altered programmatically to be made whole, as a separate step

doc/manual/dates.rst

@@ -10,7 +10,7 @@ The :mod:`Dates` module provides two types for working with dates: :class:`Date`
 
 Both :class:`Date` and :class:`DateTime` are basically immutable ``Int64`` wrappers. The single ``instant`` field of either type is actually a ``UTInstant{P}`` type, which represents a continuously increasing machine timeline based on the UT second [1]_. The :class:`DateTime` type is *timezone-unaware* (in Python parlance) or is analogous to a *LocalDateTime* in Java 8. Additional time zone functionality can be added through the `Timezones.jl package <https://github.com/quinnj/Timezones.jl/>`_, which compiles the `Olsen Time Zone Database <https://www.iana.org/time-zones>`_. Both :class:`Date` and :class:`DateTime` are based on the ISO 8601 standard, which follows the proleptic Gregorian calendar. One note is that the ISO 8601 standard is particular about BC/BCE dates. In general, the last day of the BC/BCE era, 1-12-31 BC/BCE, was followed by 1-1-1 AD/CE, thus no year zero exists. The ISO standard, however, states that 1 BC/BCE is year zero, so ``0000-12-31`` is the day before ``0001-01-01``, and year ``-0001`` (yes, negative one for the year) is 2 BC/BCE, year ``-0002`` is 3 BC/BCE, etc.
 
-.. [1] The notion of the UT second is actually quite fundamental. There are basically two different notions of time generally accepted, one based on the physical rotation of the earth (one full rotation = 1 day), the other based on the SI second (a fixed, constant value). These are radically different! Think about it, a "UT second", as defined relative to the rotation of the earth, may have a different absolute length depending on the day! Anyway, the fact that :class:`Date` and :class:`DateTime` are based on UT seconds is a simplifying, yet honest assumption so that things like leap seconds and all their complexity can be avoided. This basis of time is formally called `UT <http:https://en.wikipedia.org/wiki/Universal_Time>`_ or UT1. Basing types on the UT second basically means that every minute has 60 seconds and every day has 24 hours and leads to more natural calculations when working with calendar dates.
+.. [1] The notion of the UT second is actually quite fundamental. There are basically two different notions of time generally accepted, one based on the physical rotation of the earth (one full rotation = 1 day), the other based on the SI second (a fixed, constant value). These are radically different! Think about it, a "UT second", as defined relative to the rotation of the earth, may have a different absolute length depending on the day! Anyway, the fact that :class:`Date` and :class:`DateTime` are based on UT seconds is a simplifying, yet honest assumption so that things like leap seconds and all their complexity can be avoided. This basis of time is formally called `UT <https:https://en.wikipedia.org/wiki/Universal_Time>`_ or UT1. Basing types on the UT second basically means that every minute has 60 seconds and every day has 24 hours and leads to more natural calculations when working with calendar dates.
 
 Constructors
 ------------

doc/manual/documentation.rst

@@ -6,7 +6,7 @@
 
 Julia enables package developers and users to document functions, types and
 other objects easily, either via the built-in documentation system in Julia 0.4
-or the `Docile.jl <http:https://github.com/MichaelHatherly/Docile.jl>`_ package in
+or the `Docile.jl <https:https://github.com/MichaelHatherly/Docile.jl>`_ package in
 Julia 0.3.
 
 In 0.4:
@@ -16,7 +16,7 @@ In 0.4:
  "Tells you if there are too foo items in the array."
  foo(xs::Array) = ...
 
-Documentation is interpreted as `Markdown <http:https://en.wikipedia.org/wiki/Markdown>`_,
+Documentation is interpreted as `Markdown <https:https://en.wikipedia.org/wiki/Markdown>`_,
 so you can use indentation and code fences to delimit code examples from text.
 
 .. doctest::

doc/manual/functions.rst

@@ -195,7 +195,7 @@ Anonymous Functions
 -------------------
 
 Functions in Julia are `first-class objects
-<http:https://en.wikipedia.org/wiki/First-class_citizen>`_: they can be assigned to
+<https:https://en.wikipedia.org/wiki/First-class_citizen>`_: they can be assigned to
 variables, called using the standard function call syntax from the
 variable they have been assigned to. They can be used as arguments, and
 they can be returned as values. They can also be created anonymously,

doc/manual/integers-and-floating-point-numbers.rst

@@ -54,9 +54,9 @@ Type Precision Number of bits
 :class:`Float64` double_ 64
 ================ ========= ==============
 
-.. _half: http:https://en.wikipedia.org/wiki/Half-precision_floating-point_format
-.. _single: http:https://en.wikipedia.org/wiki/Single_precision_floating-point_format
-.. _double: http:https://en.wikipedia.org/wiki/Double_precision_floating-point_format
+.. _half: https:https://en.wikipedia.org/wiki/Half-precision_floating-point_format
+.. _single: https:https://en.wikipedia.org/wiki/Single_precision_floating-point_format
+.. _double: https:https://en.wikipedia.org/wiki/Double_precision_floating-point_format
 
 Additionally, full support for :ref:`man-complex-and-rational-numbers` is built
 on top of these primitive numeric types. All numeric types interoperate
@@ -225,7 +225,7 @@ a wraparound behavior:
  true
 
 Thus, arithmetic with Julia integers is actually a form of `modular arithmetic
-<http:https://en.wikipedia.org/wiki/Modular_arithmetic>`_. This reflects the
+<https:https://en.wikipedia.org/wiki/Modular_arithmetic>`_. This reflects the
 characteristics of the underlying arithmetic of integers as implemented on
 modern computers. In applications where overflow is possible, explicit checking
 for wraparound produced by overflow is essential; otherwise, the ``BigInt`` type
@@ -330,7 +330,7 @@ Floating-point zero
 ~~~~~~~~~~~~~~~~~~~
 
 Floating-point numbers have `two zeros
-<http:https://en.wikipedia.org/wiki/Signed_zero>`_, positive zero and negative zero.
+<https:https://en.wikipedia.org/wiki/Signed_zero>`_, positive zero and negative zero.
 They are equal to each other but have different binary representations, as can
 be seen using the ``bits`` function: :
 
@@ -366,7 +366,7 @@ Special value Name Description
 For further discussion of how these non-finite floating-point values are
 ordered with respect to each other and other floats, see
 :ref:`man-numeric-comparisons`. By the
-`IEEE 754 standard <http:https://en.wikipedia.org/wiki/IEEE_754-2008>`_, these
+`IEEE 754 standard <https:https://en.wikipedia.org/wiki/IEEE_754-2008>`_, these
 floating-point values are the results of certain arithmetic operations:
 
 .. doctest::
@@ -428,7 +428,7 @@ Machine epsilon
 Most real numbers cannot be represented exactly with floating-point numbers,
 and so for many purposes it is important to know the distance between two
 adjacent representable floating-point numbers, which is often known as
-`machine epsilon <http:https://en.wikipedia.org/wiki/Machine_epsilon>`_.
+`machine epsilon <https:https://en.wikipedia.org/wiki/Machine_epsilon>`_.
 
 Julia provides :func:`eps`, which gives the distance between ``1.0``
 and the next larger representable floating-point value:
@@ -506,7 +506,7 @@ Rounding modes
 If a number doesn't have an exact floating-point representation, it must be
 rounded to an appropriate representable value, however, if wanted, the manner
 in which this rounding is done can be changed according to the rounding modes
-presented in the `IEEE 754 standard <http:https://en.wikipedia.org/wiki/IEEE_754-2008>`_::
+presented in the `IEEE 754 standard <https:https://en.wikipedia.org/wiki/IEEE_754-2008>`_::
 
 
  julia> 1.1 + 0.1
@@ -546,7 +546,7 @@ computation, and also in the following references:
  to some of the issues arising from how this representation differs in
  behavior from the idealized abstraction of real numbers.
 - Also recommended is Bruce Dawson's `series of blog posts on floating-point
- numbers <http:https://randomascii.wordpress.com/2012/05/20/thats-not-normalthe-performance-of-odd-floats/>`_.
+ numbers <https:https://randomascii.wordpress.com/2012/05/20/thats-not-normalthe-performance-of-odd-floats/>`_.
 - For an excellent, in-depth discussion of floating-point numbers and issues of
  numerical accuracy encountered when computing with them, see David Goldberg's
  paper `What Every Computer Scientist Should Know About Floating-Point
@@ -556,7 +556,7 @@ computation, and also in the following references:
  and issues with floating-point numbers, as well as discussion of many other
  topics in numerical computing, see the `collected writings
  <https://www.cs.berkeley.edu/~wkahan/>`_ of `William Kahan
- <http:https://en.wikipedia.org/wiki/William_Kahan>`_, commonly known as the "Father
+ <https:https://en.wikipedia.org/wiki/William_Kahan>`_, commonly known as the "Father
  of Floating-Point". Of particular interest may be `An Interview with the Old
  Man of Floating-Point
  <https://www.cs.berkeley.edu/~wkahan/ieee754status/754story.html>`_.