diff --git a/.travis.yml b/.travis.yml
index 291e609ed7af2..2963901d0bf9d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -84,19 +84,18 @@ before_install:
         contrib/travis_fastfail.sh || exit 1;
         brew tap staticfloat/julia > /dev/null;
         brew rm --force $(brew deps --HEAD julia);
-        brew install -v gcc gmp mpfr pcre2 staticfloat/julia/openblas-julia staticfloat/julia/arpack-julia staticfloat/julia/suite-sparse-julia staticfloat/juliadeps/libgfortran;
+        brew install -v gcc gmp mpfr pcre2 staticfloat/julia/openblas-julia staticfloat/julia/suite-sparse-julia staticfloat/juliadeps/libgfortran;
         BUILDOPTS="-j3 USECLANG=1 USECCACHE=1 BINARYBUILDER_TRIPLET=x86_64-apple-darwin14";
         BUILDOPTS="$BUILDOPTS USE_BINARYBUILDER_LLVM=1 LLVM_CONFIG=$TRAVIS_BUILD_DIR/usr/tools/llvm-config LLVM_SIZE=$TRAVIS_BUILD_DIR/usr/tools/llvm-size";
         BUILDOPTS="$BUILDOPTS VERBOSE=1 USE_BLAS64=0 SUITESPARSE_INC=-I$(brew --prefix suite-sparse-julia)/include FORCE_ASSERTIONS=1";
         BUILDOPTS="$BUILDOPTS LIBBLAS=-lopenblas LIBBLASNAME=libopenblas LIBLAPACK=-lopenblas LIBLAPACKNAME=libopenblas";
-        for lib in SUITESPARSE ARPACK BLAS LAPACK GMP MPFR PCRE LIBUNWIND; do
+        for lib in SUITESPARSE BLAS LAPACK GMP MPFR PCRE LIBUNWIND; do
             BUILDOPTS="$BUILDOPTS USE_SYSTEM_$lib=1";
         done;
         export LDFLAGS="-L$(brew --prefix openblas-julia)/lib -L$(brew --prefix suite-sparse-julia)/lib";
         spawn_DYLD_FALLBACK_LIBRARY_PATH="/usr/local/lib:/lib:/usr/lib";
         spawn_DYLD_FALLBACK_LIBRARY_PATH+=":$(brew --prefix openblas-julia)/lib";
         spawn_DYLD_FALLBACK_LIBRARY_PATH+=":$(brew --prefix suite-sparse-julia)/lib";
-        spawn_DYLD_FALLBACK_LIBRARY_PATH+=":$(brew --prefix arpack-julia)/lib";
         export JULIA_MACOS_SPAWN="DYLD_FALLBACK_LIBRARY_PATH=\"$spawn_DYLD_FALLBACK_LIBRARY_PATH\" \$1";
         export BUILDOPTS="$BUILDOPTS spawn=\$(JULIA_MACOS_SPAWN)";
         make $BUILDOPTS -C contrib -f repackage_system_suitesparse4.make;
diff --git a/Make.inc b/Make.inc
index bf77060badb75..e8f2ec5fdfe37 100644
--- a/Make.inc
+++ b/Make.inc
@@ -38,7 +38,6 @@ USE_SYSTEM_BLAS:=0
 USE_SYSTEM_LAPACK:=0
 USE_SYSTEM_GMP:=0
 USE_SYSTEM_MPFR:=0
-USE_SYSTEM_ARPACK:=0
 USE_SYSTEM_SUITESPARSE:=0
 USE_SYSTEM_LIBUV:=0
 USE_SYSTEM_UTF8PROC:=0
@@ -1075,16 +1074,9 @@ MKLLIB := $(MKLROOT)/lib/ia32
 endif
 USE_SYSTEM_BLAS:=1
 USE_SYSTEM_LAPACK:=1
-ifeq ($(OS), WINNT)
-LIBBLASNAME := mkl_rt
-LIBLAPACKNAME := mkl_rt
-# work around libtool issue with arpack
-MKL_LDFLAGS := -L$(MKLLIB) -Wl,-lmkl_rt
-else
 LIBBLASNAME := libmkl_rt
 LIBLAPACKNAME := libmkl_rt
 MKL_LDFLAGS := -L$(MKLLIB) -lmkl_rt
-endif
 ifneq ($(strip $(MKLLIB)),)
   ifeq ($(OS), Linux)
     RPATH_MKL := -Wl,-rpath,$(MKLLIB)
diff --git a/Makefile b/Makefile
index 2841439a69576..33079548ad3a5 100644
--- a/Makefile
+++ b/Makefile
@@ -225,7 +225,6 @@ JL_PRIVATE_LIBS-$(USE_SYSTEM_LIBSSH2) += libssh2
 JL_PRIVATE_LIBS-$(USE_SYSTEM_MBEDTLS) += libmbedtls libmbedcrypto libmbedx509
 JL_PRIVATE_LIBS-$(USE_SYSTEM_CURL) += libcurl
 JL_PRIVATE_LIBS-$(USE_SYSTEM_LIBGIT2) += libgit2
-JL_PRIVATE_LIBS-$(USE_SYSTEM_ARPACK) += libarpack
 ifeq ($(USE_LLVM_SHLIB),1)
 JL_PRIVATE_LIBS-$(USE_SYSTEM_LLVM) += libLLVM
 endif
diff --git a/NEWS.md b/NEWS.md
index 359ad8f0fdd5a..f39553297c7ae 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1130,9 +1130,6 @@ Deprecated or removed
     `normalize`, and moved to the new `Unicode` standard library module.
     `graphemes` has also been moved to that module ([#25021]).
 
-  * The functions `eigs` and `svds` have been moved to the `IterativeEigensolvers` standard
-    library module ([#24714]).
-
   * Sparse array functionality has moved to the `SparseArrays` standard library module ([#25249]).
 
   * Linear algebra functionality, and specifically the `LinAlg` module has moved to the
@@ -1272,6 +1269,8 @@ Deprecated or removed
 
   * `atan2` is now a 2-argument method of `atan` ([#27248]).
 
+  * The functions `eigs` and `svds` have been moved to the `Arpack.jl` package ([#27616]).
+
 Command-line option changes
 ---------------------------
 
diff --git a/README.arm.md b/README.arm.md
index 9de38fdeee94e..577d034c82a89 100644
--- a/README.arm.md
+++ b/README.arm.md
@@ -29,13 +29,12 @@ override USE_SYSTEM_LAPACK=1
 override USE_SYSTEM_LIBM=1
 override USE_SYSTEM_GMP=1
 override USE_SYSTEM_MPFR=1
-override USE_SYSTEM_ARPACK=1
 ````
 
 The following command will install all the necessary libraries on Ubuntu:
 
 ````
-sudo apt-get install libblas3gf liblapack3gf libarpack2 libgmp3-dev \
+sudo apt-get install libblas3gf liblapack3gf libgmp3-dev \
                      libmpfr-dev libblas-dev liblapack-dev cmake gcc-4.8 \
                      g++-4.8 gfortran libgfortran3 m4 libedit-dev
 ````
diff --git a/README.md b/README.md
index 09300bb4524e7..174d5837707e4 100644
--- a/README.md
+++ b/README.md
@@ -309,7 +309,6 @@ Julia uses the following external libraries, which are automatically downloaded
 - **[LAPACK]** (>= 3.5)      — 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.
 - **[SuiteSparse]** (>= 4.1) — library of linear algebra routines for sparse matrices (see [note below](#suitesparse)).
-- **[ARPACK]**               — collection of subroutines designed to solve large, sparse eigenvalue problems.
 - **[PCRE]** (>= 10.00)      — Perl-compatible regular expressions library.
 - **[GMP]** (>= 5.0)         — GNU multiple precision arithmetic library, needed for `BigInt` support.
 - **[MPFR]** (>= 3.0)        — GNU multiple precision floating point library, needed for arbitrary precision floating point (`BigFloat`) support.
@@ -339,7 +338,6 @@ Julia uses the following external libraries, which are automatically downloaded
 [LAPACK]:       http://www.netlib.org/lapack
 [MKL]:          http://software.intel.com/en-us/articles/intel-mkl
 [SuiteSparse]:  http://faculty.cse.tamu.edu/davis/suitesparse.html
-[ARPACK]:       http://forge.scilab.org/index.php/p/arpack-ng
 [PCRE]:         http://www.pcre.org
 [LLVM]:         http://www.llvm.org
 [FemtoLisp]:    https://github.com/JeffBezanson/femtolisp
diff --git a/base/Makefile b/base/Makefile
index 17cce740971bc..21c7ad457a140 100644
--- a/base/Makefile
+++ b/base/Makefile
@@ -180,7 +180,6 @@ $(eval $(call symlink_system_library,$(LIBLAPACKNAME),LAPACK))
 endif
 $(eval $(call symlink_system_library,libgmp,GMP))
 $(eval $(call symlink_system_library,libmpfr,MPFR))
-$(eval $(call symlink_system_library,libarpack,ARPACK))
 $(eval $(call symlink_system_library,libmbedtls,MBEDTLS))
 $(eval $(call symlink_system_library,libssh2,LIBSSH2))
 $(eval $(call symlink_system_library,libcurl,CURL))
diff --git a/base/deprecated.jl b/base/deprecated.jl
index e7cf77c928a78..8c93747d6090d 100644
--- a/base/deprecated.jl
+++ b/base/deprecated.jl
@@ -1720,6 +1720,8 @@ end
 
 @deprecate atan2(y, x) atan(y, x)
 
+@deprecate_moved eigs "Arpack"
+@deprecate_moved svds "Arpack"
 
 # END 0.7 deprecations
 
diff --git a/base/sysimg.jl b/base/sysimg.jl
index b4faa6019f831..3b0d1aefabb07 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -520,7 +520,6 @@ let
             :Future,
             :OldPkg,
             :LinearAlgebra,
-            :IterativeEigensolvers,
             :SparseArrays,
             :SuiteSparse,
             :SharedArrays,
@@ -647,9 +646,6 @@ end
     @eval @deprecate_stdlib $(Symbol("@dateformat_str")) Dates true
     @deprecate_stdlib now Dates true
 
-    @deprecate_stdlib eigs IterativeEigensolvers true
-    @deprecate_stdlib svds IterativeEigensolvers true
-
     @eval @deprecate_stdlib $(Symbol("@printf")) Printf true
     @eval @deprecate_stdlib $(Symbol("@sprintf")) Printf true
 
diff --git a/contrib/fixup-libgfortran.sh b/contrib/fixup-libgfortran.sh
index 131cbc3836571..07e3a33fe25c2 100755
--- a/contrib/fixup-libgfortran.sh
+++ b/contrib/fixup-libgfortran.sh
@@ -29,11 +29,6 @@ fi
 
 private_libdir=$1
 
-if [ ! -f "$private_libdir/libarpack.$SHLIB_EXT" ]; then
-    echo "ERROR: Could not open $private_libdir/libarpack.$SHLIB_EXT" >&2
-    exit 2
-fi
-
 find_shlib()
 {
     lib_path="$1"
@@ -52,7 +47,7 @@ private_libname()
 }
 
 # First, discover all the places where libgfortran/libgcc is, as well as their true SONAMES
-for lib in arpack lapack; do
+for lib in lapack; do
     if [ -f "$private_libdir/lib$lib.$SHLIB_EXT" ]; then
         # Find the paths to the libraries we're interested in.  These are almost
         # always within the same directory, but we like to be general.
@@ -125,11 +120,11 @@ change_linkage()
 }
 
 # For every library that remotely touches libgfortran stuff (the libraries we
-# have copied in ourselves as well as arpack, etc...) we must
+# have copied in ourselves) we must
 # update the linkage to point to @rpath (on OSX) or $ORIGIN (on Linux) so
 # that direct links to the old libgfortran directories are instead directed
 # to the proper location, which is our $private_libdir.
-for lib in libopenblas libarpack libcholmod liblapack $SONAMES; do
+for lib in libopenblas libcholmod liblapack $SONAMES; do
     # Grab every incarnation of that library that exists within $private_libdir
     # (e.g. "libopenblas.so", and "libopenblas.so.0", etc...)
     for lib_path in $private_libdir/$lib*; do
diff --git a/contrib/vagrant/Vagrantfile b/contrib/vagrant/Vagrantfile
index d59ce3ee39a07..a693cd81235e1 100644
--- a/contrib/vagrant/Vagrantfile
+++ b/contrib/vagrant/Vagrantfile
@@ -5,7 +5,7 @@ $script = <<SCRIPT
 cat - > /home/vagrant/.bash_aliases <<"EOF"
 export JULIA_VAGRANT_BUILD=1
 BUILDOPTS="LLVM_CONFIG=llvm-config-3.3 USE_BLAS64=0"
-for lib in LLVM ZLIB SUITESPARSE ARPACK BLAS LAPACK GMP MPFR PCRE LIBUNWIND GRISU OPENLIBM; do
+for lib in LLVM ZLIB SUITESPARSE BLAS LAPACK GMP MPFR PCRE LIBUNWIND GRISU OPENLIBM; do
     export BUILDOPTS="$BUILDOPTS USE_SYSTEM_$lib=1"
 done
 
@@ -16,7 +16,7 @@ apt-get update -qq -y
 apt-get install python-software-properties -y
 add-apt-repository ppa:staticfloat/julia-deps -y
 apt-get update -qq -y
-apt-get install g++ git make patchelf gfortran llvm-3.3 libsuitesparse-dev libopenblas-dev liblapack-dev libarpack2-dev libgmp-dev libpcre3-dev libunwind8-dev libmpfr-dev cmake -y
+apt-get install g++ git make patchelf gfortran llvm-3.3 libsuitesparse-dev libopenblas-dev liblapack-dev libgmp-dev libpcre3-dev libunwind8-dev libmpfr-dev cmake -y
 SCRIPT
 
 Vagrant.configure("2") do |config|
diff --git a/deps/Makefile b/deps/Makefile
index 45e218d67f1a2..a759218f6ca03 100644
--- a/deps/Makefile
+++ b/deps/Makefile
@@ -20,7 +20,7 @@ include $(SRCDIR)/tools/git-external.mk
 # additionally all targets should be listed in the getall target for easier off-line compilation
 # if you are adding a new target, it can help to copy an similar, existing target
 #
-# autoconf configure-driven scripts: llvm pcre arpack unwind gmp mpfr patchelf libuv curl
+# autoconf configure-driven scripts: llvm pcre unwind gmp mpfr patchelf libuv curl
 # custom Makefile rules: openlibm dsfmt suitesparse-wrapper suitesparse lapack openblas utf8proc objconv osxunwind libwhich
 # CMake libs: libgit2 libssh2 mbedtls
 #
@@ -126,10 +126,6 @@ ifeq ($(USE_SYSTEM_MPFR), 0)
 DEP_LIBS += mpfr
 endif
 
-ifeq ($(USE_SYSTEM_ARPACK), 0)
-DEP_LIBS += arpack
-endif
-
 ifeq ($(USE_GPL_LIBS), 1)
 ifeq ($(USE_SYSTEM_SUITESPARSE), 0)
 DEP_LIBS += suitesparse
@@ -172,7 +168,7 @@ uninstall: $(addprefix uninstall-, $(DEP_LIBS_STAGED))
 cleanall: $(addprefix clean-, $(DEP_LIBS))
 distcleanall: $(addprefix distclean-, $(DEP_LIBS))
 	rm -rf $(build_prefix)
-getall: get-llvm get-libuv get-pcre get-openlibm get-dsfmt get-openblas get-lapack get-suitesparse get-arpack get-unwind get-osxunwind get-gmp get-mpfr get-patchelf get-utf8proc get-objconv get-mbedtls get-libssh2 get-curl get-libgit2 get-libwhich
+getall: get-llvm get-libuv get-pcre get-openlibm get-dsfmt get-openblas get-lapack get-suitesparse get-unwind get-osxunwind get-gmp get-mpfr get-patchelf get-utf8proc get-objconv get-mbedtls get-libssh2 get-curl get-libgit2 get-libwhich
 
 include $(SRCDIR)/llvm.mk
 include $(SRCDIR)/libuv.mk
@@ -181,7 +177,6 @@ include $(SRCDIR)/openlibm.mk
 include $(SRCDIR)/dsfmt.mk
 include $(SRCDIR)/objconv.mk
 include $(SRCDIR)/blas.mk
-include $(SRCDIR)/arpack.mk
 include $(SRCDIR)/utf8proc.mk
 include $(SRCDIR)/suitesparse.mk
 include $(SRCDIR)/unwind.mk
diff --git a/deps/arpack.mk b/deps/arpack.mk
deleted file mode 100644
index 9b130af9b5b8d..0000000000000
--- a/deps/arpack.mk
+++ /dev/null
@@ -1,104 +0,0 @@
-## ARPACK ##
-
-ifeq ($(USE_SYSTEM_BLAS), 0)
-$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-configured: | $(build_prefix)/manifest/openblas
-else ifeq ($(USE_SYSTEM_LAPACK), 0)
-$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-configured: | $(build_prefix)/manifest/lapack
-endif
-
-ARPACK_FFLAGS := $(USE_BLAS_FFLAGS)
-ARPACK_CFLAGS :=
-
-ifeq ($(USE_BLAS64), 1)
-ARPACK_CFLAGS += -DBLASINT=int64_t
-ifneq ($(USEIFC),1)
-ifeq ($(USE_SYSTEM_BLAS), 0)
-ifeq ($(OPENBLAS_SYMBOLSUFFIX), 64_)
-ARPACK_FFLAGS += -cpp -ffixed-line-length-none
-ARPACK_OPENBLASFCNS1 := axpy copy gemv geqr2 lacpy lahqr lanhs larnv lartg lascl laset scal trevc trmm trsen gbmv gbtrf gbtrs gttrf gttrs pttrf pttrs
-ARPACK_OPENBLASFCNS2 := dot ger labad laev2 lamch lanst lanv2 lapy2 larf larfg lasr nrm2 orm2r rot steqr swap
-ARPACK_OPENBLASFCNS3 := dotc geru unm2r
-ARPACK_OPENBLASFCNS4 := COPY LABAD LAMCH LANHS LANV2 LARFG ROT GEMV
-ARPACK_FFLAGS += $(foreach fcn, $(ARPACK_OPENBLASFCNS1) $(ARPACK_OPENBLASFCNS2), -Ds$(fcn)=s$(fcn)_64 -Dd$(fcn)=d$(fcn)_64)
-ARPACK_FFLAGS += $(foreach fcn, $(ARPACK_OPENBLASFCNS1) $(ARPACK_OPENBLASFCNS3), -Dc$(fcn)=c$(fcn)_64 -Dz$(fcn)=z$(fcn)_64)
-ARPACK_FFLAGS += $(foreach fcn, $(ARPACK_OPENBLASFCNS4), -DS$(fcn)=S$(fcn)_64 -DD$(fcn)=D$(fcn)_64)
-ARPACK_FFLAGS += -Dscnrm2=scnrm2_64 -Ddznrm2=dznrm2_64 -Dcsscal=csscal_64 -Dzdscal=zdscal_64
-# CFLAGS are for the configure checks
-ARPACK_CFLAGS += -Dsgemm_=sgemm_64_ -Dcheev_=cheev_64_
-endif
-endif
-endif
-endif
-
-ARPACK_MFLAGS := F77="$(FC)" MPIF77="$(FC)"
-ARPACK_FFLAGS += $(FFLAGS) $(JFFLAGS)
-ARPACK_FLAGS := --with-blas="$(LIBBLAS)" --with-lapack="$(LIBLAPACK)" \
-    --disable-mpi --enable-shared FFLAGS="$(ARPACK_FFLAGS)" \
-    CFLAGS="$(CFLAGS) $(ARPACK_CFLAGS)" LDFLAGS="$(LDFLAGS) $(RPATH_ESCAPED_ORIGIN)"
-
-# ARPACK-NG upstream keeps changing their download filenames
-$(SRCCACHE)/arpack-ng-$(ARPACK_VER).tar.gz: | $(SRCCACHE)
-	$(JLDOWNLOAD) $@ https://julialang-s3.julialang.org/src/arpack-ng-$(ARPACK_VER).tar.gz
-	touch -c $@
-$(SRCCACHE)/arpack-ng-$(ARPACK_VER)-testA.mtx: | $(SRCCACHE)
-	$(JLDOWNLOAD) $@ https://raw.githubusercontent.com/opencollab/arpack-ng/$(ARPACK_VER)/TESTS/testA.mtx
-	touch -c $@
-
-$(SRCCACHE)/arpack-ng-$(ARPACK_VER)/source-extracted: $(SRCCACHE)/arpack-ng-$(ARPACK_VER).tar.gz
-	$(JLCHECKSUM) $<
-	cd $(dir $<) && $(TAR) -zxf $<
-	touch -c $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/configure # old target
-	echo 1 > $@
-
-$(SRCCACHE)/arpack-ng-$(ARPACK_VER)/arpack-tests-blasint.patch-applied: $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/source-extracted
-	cd $(dir $@) && patch -p1 < $(SRCDIR)/patches/arpack-tests-blasint.patch
-	echo 1 > $@
-
-$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-configured: $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/source-extracted $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/arpack-tests-blasint.patch-applied
-	mkdir -p $(dir $@)
-	cd $(dir $@) && \
-	$(dir $<)/configure $(CONFIGURE_COMMON) $(ARPACK_FLAGS)
-	echo 1 > $@
-
-$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-compiled: $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-configured
-	$(MAKE) -C $(dir $<) $(ARPACK_MFLAGS)
-	echo 1 > $@
-
-$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-checked: $(SRCCACHE)/arpack-ng-$(ARPACK_VER)-testA.mtx $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-compiled
-	$(JLCHECKSUM) $<
-	cp $< $(dir $@)/TESTS/testA.mtx
-ifeq ($(OS),$(BUILD_OS))
-	$(MAKE) -C $(dir $@) check $(ARPACK_MFLAGS)
-endif
-	echo 1 > $@
-
-define ARPACK_INSTALL
-	$(call MAKE_INSTALL,$1,$2,$3)
-ifeq ($(OS), WINNT)
-	mv $2/$$(build_shlibdir)/libarpack-2.dll $2/$$(build_shlibdir)/libarpack.$$(SHLIB_EXT)
-endif
-endef
-
-$(eval $(call staged-install, \
-	arpack,arpack-ng-$(ARPACK_VER), \
-	ARPACK_INSTALL,$(ARPACK_MFLAGS),, \
-	$$(INSTALL_NAME_CMD)libarpack.$$(SHLIB_EXT) $$(build_shlibdir)/libarpack.$$(SHLIB_EXT)))
-
-clean-arpack:
-	-rm $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-configured $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-compiled
-	-$(MAKE) -C $(BUILDDIR)/arpack-ng-$(ARPACK_VER) clean
-
-distclean-arpack:
-	-rm -rf $(SRCCACHE)/arpack-ng-$(ARPACK_VER).tar.gz \
-		$(SRCCACHE)/arpack-ng-$(ARPACK_VER) \
-		$(SRCCACHE)/arpack-ng-$(ARPACK_VER)-testA.mtx \
-		$(BUILDDIR)/arpack-ng-$(ARPACK_VER)
-
-
-get-arpack: $(SRCCACHE)/arpack-ng-$(ARPACK_VER).tar.gz $(SRCCACHE)/arpack-ng-$(ARPACK_VER)-testA.mtx
-extract-arpack: $(SRCCACHE)/arpack-ng-$(ARPACK_VER)/source-extracted
-configure-arpack: $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-configured
-compile-arpack: $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-compiled
-# XXX: bug_1315 ARPACK tests fail stochastically
-fastcheck-arpack: #check-arpack
-check-arpack: $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/build-checked
diff --git a/deps/patches/arpack-tests-blasint.patch b/deps/patches/arpack-tests-blasint.patch
deleted file mode 100644
index 915b03034798a..0000000000000
--- a/deps/patches/arpack-tests-blasint.patch
+++ /dev/null
@@ -1,158 +0,0 @@
-diff -urN arpack-ng-3.2.0/TESTS/bug_1315_double.c arpack-ng-3.2.0-BLASINT/TESTS/bug_1315_double.c
---- arpack-ng-3.2.0/TESTS/bug_1315_double.c	2014-11-14 09:47:06.000000000 -0500
-+++ arpack-ng-3.2.0-BLASINT/TESTS/bug_1315_double.c	2015-08-10 01:08:29.000000000 -0400
-@@ -9,15 +9,18 @@
-  * This is not efficient since the problem is
-  * symmetric but is done to exhibit the bug.
-  * */
--
--extern void dnaupd_(int *, char *, int *, char *, int *,
--		   double *, double *, int *, double *,
--		   int *, int *, int *, double *,
--		   double *, int *, int *);
--
--extern void dneupd_( int*, char*, int *, double *, double *, double *, int*, double *,
--		double *, double *, char *, int *, char *, int *, double *, double *, int *,
--		double *, int *, int *, int *, double *, double *, int *, int * );
-+#ifndef BLASINT
-+#define BLASINT int
-+#endif
-+
-+extern void dnaupd_(BLASINT *, char *, BLASINT *, char *, BLASINT *,
-+		   double *, double *, BLASINT *, double *,
-+		   BLASINT *, BLASINT *, BLASINT *, double *,
-+		   double *, BLASINT *, BLASINT *);
-+
-+extern void dneupd_( BLASINT*, char*, BLASINT *, double *, double *, double *, BLASINT*, double *,
-+		double *, double *, char *, BLASINT *, char *, BLASINT *, double *, double *, BLASINT *,
-+		double *, BLASINT *, BLASINT *, BLASINT *, double *, double *, BLASINT *, BLASINT * );
- 
- void matVec(double * x, double * y) {
-   int i;
-@@ -26,26 +29,26 @@
- };
- 
- int main() {
--  int ido = 0;
-+  BLASINT ido = 0;
-   char bmat[] = "I";
--  int N = 1000;
-+  BLASINT N = 1000;
-   char which[] = "LM";
--  int nev = 9;
-+  BLASINT nev = 9;
-   double tol = 0;
-   double resid[N];
--  int ncv = 2*nev+1;
-+  BLASINT ncv = 2*nev+1;
-   double V[ncv*N];
--  int ldv = N;
--  int iparam[11];
--  int ipntr[14];
-+  BLASINT ldv = N;
-+  BLASINT iparam[11];
-+  BLASINT ipntr[14];
-   double workd[3*N];
--  int rvec = 1;
-+  BLASINT rvec = 1;
-   char howmny[] = "A";
-   double* dr = (double*) malloc((nev+1)*sizeof(double));
-   double* di = (double*) malloc((nev+1)*sizeof(double));
--  int select[3*ncv];
-+  BLASINT select[3*ncv];
-   double z[(N+1)*(nev+1)];
--  int ldz = N+1;
-+  BLASINT ldz = N+1;
-   double sigmar=0;
-   double sigmai=0;
-   double workev[3*ncv];
-@@ -55,8 +58,8 @@
-   double workl[3*(ncv*ncv) + 6*ncv];
-   for (k=0; k < 3*(ncv*ncv) + 6*ncv; ++k )
-     workl[k] = 0;
--  int lworkl = 3*(ncv*ncv) + 6*ncv;
--  int info = 0;
-+  BLASINT lworkl = 3*(ncv*ncv) + 6*ncv;
-+  BLASINT info = 0;
- 
-   iparam[0] = 1;
-   iparam[2] = 10*N;
-diff -urN arpack-ng-3.2.0/TESTS/bug_1315_single.c arpack-ng-3.2.0-BLASINT/TESTS/bug_1315_single.c
---- arpack-ng-3.2.0/TESTS/bug_1315_single.c	2014-11-14 09:47:06.000000000 -0500
-+++ arpack-ng-3.2.0-BLASINT/TESTS/bug_1315_single.c	2015-08-10 01:29:58.000000000 -0400
-@@ -9,15 +9,18 @@
-  * This is not efficient since the problem is
-  * symmetric but is done to exhibit the bug.
-  */
--
--extern void snaupd_(int *, char *, int *, char *, int *,
--		   float *, float *, int *, float *,
--		   int *, int *, int *, float *,
--		   float *, int *, int *);
--
--extern void sneupd_( int*, char*, int *, float *, float *, float *, int*, float *,
--		float *, float *, char *, int *, char *, int *, float *, float *, int *,
--		float *, int *, int *, int *, float *, float *, int *, int * );
-+#ifndef BLASINT
-+#define BLASINT int
-+#endif
-+
-+extern void snaupd_(BLASINT *, char *, BLASINT *, char *, BLASINT *,
-+		   float *, float *, BLASINT *, float *,
-+		   BLASINT *, BLASINT *, BLASINT *, float *,
-+		   float *, BLASINT *, BLASINT *);
-+
-+extern void sneupd_( BLASINT*, char*, BLASINT *, float *, float *, float *, BLASINT*, float *,
-+		float *, float *, char *, BLASINT *, char *, BLASINT *, float *, float *, BLASINT *,
-+		float *, BLASINT *, BLASINT *, BLASINT *, float *, float *, BLASINT *, BLASINT * );
- 
- 
- void matVec(float * x, float * y) {
-@@ -27,26 +30,26 @@
- };
- 
- int main() {
--  int ido = 0;
-+  BLASINT ido = 0;
-   char bmat[] = "I";
--  int N = 1000;
-+  BLASINT N = 1000;
-   char which[] = "LM";
--  int nev = 9;
-+  BLASINT nev = 9;
-   float tol = 0;
-   float resid[N];
--  int ncv = 2*nev+1;
-+  BLASINT ncv = 2*nev+1;
-   float V[ncv*N];
--  int ldv = N;
--  int iparam[11];
--  int ipntr[14];
-+  BLASINT ldv = N;
-+  BLASINT iparam[11];
-+  BLASINT ipntr[14];
-   float workd[3*N];
--  int rvec = 1;
-+  BLASINT rvec = 1;
-   char howmny[] = "A";
-   float* dr = (float*) malloc((nev+1)*sizeof(float));
-   float* di = (float*) malloc((nev+1)*sizeof(float));
--  int select[3*ncv];
-+  BLASINT select[3*ncv];
-   float z[(N+1)*(nev+1)];
--  int ldz = N+1;
-+  BLASINT ldz = N+1;
-   float sigmar=0;
-   float sigmai=0;
-   float workev[3*ncv];
-@@ -56,8 +59,8 @@
-   float workl[3*(ncv*ncv) + 6*ncv];
-   for (k=0; k < 3*(ncv*ncv) + 6*ncv; ++k )
-     workl[k] = 0;
--  int lworkl = 3*(ncv*ncv) + 6*ncv;
--  int info = 0;
-+  BLASINT lworkl = 3*(ncv*ncv) + 6*ncv;
-+  BLASINT info = 0;
- 
-   iparam[0] = 1;
-   iparam[2] = 10*N;
diff --git a/doc/Manifest.toml b/doc/Manifest.toml
index 015cc5e86566c..116b0af661172 100644
--- a/doc/Manifest.toml
+++ b/doc/Manifest.toml
@@ -2,37 +2,12 @@
 uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 
 [[Compat]]
-git-tree-sha1 = "45abe32cc7bcf2632dda2fb2549c7060811ea0ec"
-repo-rev = "kc/Compat_fix"
+deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Test", "UUIDs", "Unicode"]
+git-tree-sha1 = "f3e87ca1e2df8e1e4f82ea504fddf0b9b0894f61"
+repo-rev = "9b0c3982dcdab1ba35eb5b51a4aa084754e1a0eb"
 repo-url = "https://github.com/JuliaLang/Compat.jl.git"
 uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
-version = "0.65.0+"
-
-    [Compat.deps]
-    Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
-    Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
-    DelimitedFiles = "8bb1440f-4735-579b-a4ab-409b98df4dab"
-    Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
-    InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
-    IterativeEigensolvers = "de555fa4-b82f-55e7-8b71-53f60bbc027d"
-    LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
-    Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
-    LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-    Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
-    Mmap = "a63ad114-7e13-5084-954f-fe012c677804"
-    OldPkg = "fe1c5a76-5840-53d2-82f9-288dd83ce2ce"
-    Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
-    Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
-    REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
-    Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-    Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
-    SharedArrays = "1a1011a3-84de-559e-8e89-a11a2f7dc383"
-    Sockets = "6462fe0b-24de-5631-8697-dd941f90decc"
-    SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
-    SuiteSparse = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
-    Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-    UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
-    Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
+version = "0.69.0"
 
 [[Dates]]
 uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
@@ -58,9 +33,6 @@ version = "0.18.0"
 [[InteractiveUtils]]
 uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 
-[[IterativeEigensolvers]]
-uuid = "de555fa4-b82f-55e7-8b71-53f60bbc027d"
-
 [[LibGit2]]
 uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
 
@@ -79,6 +51,9 @@ uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
 [[Mmap]]
 uuid = "a63ad114-7e13-5084-954f-fe012c677804"
 
+[[Pkg]]
+uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+
 [[Printf]]
 uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 
@@ -100,9 +75,6 @@ uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
 [[SparseArrays]]
 uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
-[[SuiteSparse]]
-uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
-
 [[Test]]
 uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
diff --git a/stdlib/IterativeEigensolvers/Project.toml b/stdlib/IterativeEigensolvers/Project.toml
deleted file mode 100644
index 2f00589c6ab65..0000000000000
--- a/stdlib/IterativeEigensolvers/Project.toml
+++ /dev/null
@@ -1,5 +0,0 @@
-name = "IterativeEigensolvers"
-uuid = "de555fa4-b82f-55e7-8b71-53f60bbc027d"
-
-[deps]
-LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
diff --git a/stdlib/IterativeEigensolvers/docs/src/index.md b/stdlib/IterativeEigensolvers/docs/src/index.md
deleted file mode 100644
index 185d2dcc14a56..0000000000000
--- a/stdlib/IterativeEigensolvers/docs/src/index.md
+++ /dev/null
@@ -1,208 +0,0 @@
-# [Iterative Eigensolvers](@id lib-itereigen)
-
-```@meta
-DocTestSetup = :(using IterativeEigensolvers, LinearAlgebra, SparseArrays)
-```
-
-Julia provides bindings to [ARPACK](http://www.caam.rice.edu/software/ARPACK/), which
-can be used to perform iterative solutions for eigensystems (using [`eigs`](@ref))
-or singular value decompositions (using [`svds`](@ref)).
-
-`eigs` calculates the eigenvalues and, optionally, eigenvectors of its input(s)
-using implicitly restarted Lanczos or Arnoldi iterations for real symmetric or
-general nonsymmetric matrices respectively.
-
-For the single matrix version,
-
-`eigs(A; nev=6, ncv=max(20,2*nev+1), which=:LM, tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)`
-
-the following keyword arguments are supported:
-
-* `nev`: Number of eigenvalues
-* `ncv`: Number of Krylov vectors used in the computation; should satisfy `nev+1 <= ncv <= n`
-  for real symmetric problems and `nev+2 <= ncv <= n` for other problems, where `n` is the
-  size of the input matrix `A`. The default is `ncv = max(20,2*nev+1)`. Note that these
-  restrictions limit the input matrix `A` to be of dimension at least 2.
-* `which`: type of eigenvalues to compute. See the note below.
-
-| `which` | type of eigenvalues                                                                                                       |
-|:--------|:--------------------------------------------------------------------------------------------------------------------------|
-| `:LM`   | eigenvalues of largest magnitude (default)                                                                                |
-| `:SM`   | eigenvalues of smallest magnitude                                                                                         |
-| `:LR`   | eigenvalues of largest real part                                                                                          |
-| `:SR`   | eigenvalues of smallest real part                                                                                         |
-| `:LI`   | eigenvalues of largest imaginary part (nonsymmetric or complex `A` only)                                                  |
-| `:SI`   | eigenvalues of smallest imaginary part (nonsymmetric or complex `A` only)                                                 |
-| `:BE`   | compute half of the eigenvalues from each end of the spectrum, biased in favor of the high end. (real symmetric `A` only) |
-
-* `tol`: parameter defining the relative tolerance for convergence of Ritz values (eigenvalue estimates).
-     A Ritz value ``θ`` is considered converged when its associated residual
-     is less than or equal to the product of `tol` and ``max(ɛ^{2/3}, |θ|)``,
-     where `ɛ = eps(real(eltype(A)))/2` is LAPACK's machine epsilon.
-     The residual associated with ``θ`` and its corresponding Ritz vector ``v``
-     is defined as the norm ``||Av - vθ||``.
-     The specified value of `tol` should be positive; otherwise, it is ignored
-     and ``ɛ`` is used instead.
-     Default: ``ɛ``.
-
-* `maxiter`: Maximum number of iterations (default = 300)
-* `sigma`: Specifies the level shift used in inverse iteration. If `nothing` (default),
-  defaults to ordinary (forward) iterations. Otherwise, find eigenvalues close to `sigma`
-  using shift and invert iterations.
-* `ritzvec`: Returns the Ritz vectors `v` (eigenvectors) if `true`
-* `v0`: starting vector from which to start the iterations
-
-We can see the various keywords in action in the following examples:
-```jldoctest; filter = r"(1|2)-element Array{(Float64|Complex{Float64}),1}:\n (.|\s)*$"
-julia> A = Diagonal(1:4);
-
-julia> λ, ϕ = eigs(A, nev = 2, which=:SM);
-
-julia> λ
-2-element Array{Float64,1}:
- 1.0000000000000002
- 2.0
-
-julia> B = Diagonal([1., 2., -3im, 4im]);
-
-julia> λ, ϕ = eigs(B, nev=1, which=:LI);
-
-julia> λ
-1-element Array{Complex{Float64},1}:
- 1.3322676295501878e-15 + 4.0im
-
-julia> λ, ϕ = eigs(B, nev=1, which=:SI);
-
-julia> λ
-1-element Array{Complex{Float64},1}:
- -2.498001805406602e-16 - 3.0000000000000018im
-
-julia> λ, ϕ = eigs(B, nev=1, which=:LR);
-
-julia> λ
-1-element Array{Complex{Float64},1}:
- 2.0000000000000004 + 4.0615212488780827e-17im
-
-julia> λ, ϕ = eigs(B, nev=1, which=:SR);
-
-julia> λ
-1-element Array{Complex{Float64},1}:
- -8.881784197001252e-16 + 3.999999999999997im
-
-julia> λ, ϕ = eigs(B, nev=1, sigma=1.5);
-
-julia> λ
-1-element Array{Complex{Float64},1}:
- 1.0000000000000004 + 4.0417078924070745e-18im
-```
-
-!!! note
-    The `sigma` and `which` keywords interact: the description of eigenvalues
-    searched for by `which` do *not* necessarily refer to the eigenvalues of
-    `A`, but rather the linear operator constructed by the specification of the
-    iteration mode implied by `sigma`.
-
-    | `sigma`         | iteration mode                   | `which` refers to eigenvalues of |
-    |:----------------|:---------------------------------|:---------------------------------|
-    | `nothing`       | ordinary (forward)               | ``A``                            |
-    | real or complex | inverse with level shift `sigma` | ``(A - \\sigma I )^{-1}``        |
-
-!!! note
-    Although `tol` has a default value, the best choice depends strongly on the
-    matrix `A`. We recommend that users _always_ specify a value for `tol`
-    which suits their specific needs.
-
-    For details of how the errors in the computed eigenvalues are estimated, see:
-
-    * B. N. Parlett, "The Symmetric Eigenvalue Problem", SIAM: Philadelphia, 2/e
-      (1998), Ch. 13.2, "Accessing Accuracy in Lanczos Problems", pp. 290-292 ff.
-    * R. B. Lehoucq and D. C. Sorensen, "Deflation Techniques for an Implicitly
-      Restarted Arnoldi Iteration", SIAM Journal on Matrix Analysis and
-      Applications (1996), 17(4), 789–821.  doi:10.1137/S0895479895281484
-
-For the two-input generalized eigensolution version,
-
-`eigs(A, B; nev=6, ncv=max(20,2*nev+1), which=:LM, tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)`
-
-the following keyword arguments are supported:
-
-* `nev`: Number of eigenvalues
-* `ncv`: Number of Krylov vectors used in the computation; should satisfy `nev+1 <= ncv <= n`
-  for real symmetric problems and `nev+2 <= ncv <= n` for other problems, where `n` is the
-  size of the input matrices `A` and `B`. The default is `ncv = max(20,2*nev+1)`. Note that
-  these restrictions limit the input matrix `A` to be of dimension at least 2.
-* `which`: type of eigenvalues to compute. See the note below.
-
-| `which` | type of eigenvalues                                                                                                       |
-|:--------|:--------------------------------------------------------------------------------------------------------------------------|
-| `:LM`   | eigenvalues of largest magnitude (default)                                                                                |
-| `:SM`   | eigenvalues of smallest magnitude                                                                                         |
-| `:LR`   | eigenvalues of largest real part                                                                                          |
-| `:SR`   | eigenvalues of smallest real part                                                                                         |
-| `:LI`   | eigenvalues of largest imaginary part (nonsymmetric or complex `A` only)                                                  |
-| `:SI`   | eigenvalues of smallest imaginary part (nonsymmetric or complex `A` only)                                                 |
-| `:BE`   | compute half of the eigenvalues from each end of the spectrum, biased in favor of the high end. (real symmetric `A` only) |
-
-* `tol`: relative tolerance used in the convergence criterion for eigenvalues, similar to
-     `tol` in the [`eigs(A)`](@ref) method for the ordinary eigenvalue
-     problem, but effectively for the eigenvalues of ``B^{-1} A`` instead of ``A``.
-     See the documentation for the ordinary eigenvalue problem in
-     [`eigs(A)`](@ref) and the accompanying note about `tol`.
-* `maxiter`: Maximum number of iterations (default = 300)
-* `sigma`: Specifies the level shift used in inverse iteration. If `nothing` (default),
-  defaults to ordinary (forward) iterations. Otherwise, find eigenvalues close to `sigma`
-  using shift and invert iterations.
-* `ritzvec`: Returns the Ritz vectors `v` (eigenvectors) if `true`
-* `v0`: starting vector from which to start the iterations
-
-`eigs` returns the `nev` requested eigenvalues in `d`, the corresponding Ritz vectors `v`
-(only if `ritzvec=true`), the number of converged eigenvalues `nconv`, the number of
-iterations `niter` and the number of matrix vector multiplications `nmult`, as well as the
-final residual vector `resid`.
-
-We can see the various keywords in action in the following examples:
-```jldoctest; filter = r"(1|2)-element Array{(Float64|Complex{Float64}),1}:\n (.|\s)*$"
-julia> A = sparse(1.0I, 4, 4); B = Diagonal(1:4);
-
-julia> λ, ϕ = eigs(A, B, nev = 2);
-
-julia> λ
-2-element Array{Float64,1}:
- 1.0000000000000002
- 0.5
-
-julia> A = Diagonal([1, -2im, 3, 4im]); B = sparse(1.0I, 4, 4);
-
-julia> λ, ϕ = eigs(A, B, nev=1, which=:SI);
-
-julia> λ
-1-element Array{Complex{Float64},1}:
- -1.5720931501039814e-16 - 1.9999999999999984im
-
-julia> λ, ϕ = eigs(A, B, nev=1, which=:LI);
-
-julia> λ
-1-element Array{Complex{Float64},1}:
- 0.0 + 4.000000000000002im
-```
-
-!!! note
-    The `sigma` and `which` keywords interact: the description of eigenvalues searched for by
-    `which` do *not* necessarily refer to the eigenvalue problem ``Av = Bv\\lambda``, but rather
-    the linear operator constructed by the specification of the iteration mode implied by `sigma`.
-
-    | `sigma`         | iteration mode                   | `which` refers to the problem      |
-    |:----------------|:---------------------------------|:-----------------------------------|
-    | `nothing`       | ordinary (forward)               | ``Av = Bv\\lambda``                |
-    | real or complex | inverse with level shift `sigma` | ``(A - \\sigma B )^{-1}B = v\\nu`` |
-
-
-```@docs
-IterativeEigensolvers.eigs(::Any)
-IterativeEigensolvers.eigs(::Any, ::Any)
-IterativeEigensolvers.svds
-```
-
-```@meta
-DocTestSetup = nothing
-```
diff --git a/stdlib/IterativeEigensolvers/src/IterativeEigensolvers.jl b/stdlib/IterativeEigensolvers/src/IterativeEigensolvers.jl
deleted file mode 100644
index ca2f543a8dd8e..0000000000000
--- a/stdlib/IterativeEigensolvers/src/IterativeEigensolvers.jl
+++ /dev/null
@@ -1,339 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-__precompile__(true)
-
-"""
-Arnoldi and Lanczos iteration for computing eigenvalues
-"""
-module IterativeEigensolvers
-
-using LinearAlgebra: BlasFloat, BlasInt, Diagonal, I, SVD, UniformScaling,
-                     checksquare, factorize,ishermitian, issymmetric, mul!,
-                     rmul!, qr
-import LinearAlgebra
-
-export eigs, svds
-
-include("arpack.jl")
-
-using .ARPACK
-
-## eigs
-"""
-    eigs(A; nev=6, ncv=max(20,2*nev+1), which=:LM, tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)
-
-Computes eigenvalues `d` of `A` using implicitly restarted Lanczos or Arnoldi iterations for real symmetric or
-general nonsymmetric matrices respectively. See [the manual](@ref lib-itereigen) for more information.
-
-`eigs` returns the `nev` requested eigenvalues in `d`, the corresponding Ritz vectors `v`
-(only if `ritzvec=true`), the number of converged eigenvalues `nconv`, the number of
-iterations `niter` and the number of matrix vector multiplications `nmult`, as well as the
-final residual vector `resid`.
-
-# Examples
-```jldoctest
-julia> using IterativeEigensolvers
-
-julia> A = Diagonal(1:4);
-
-julia> λ, ϕ = eigs(A, nev = 2);
-
-julia> λ
-2-element Array{Float64,1}:
- 4.0
- 3.0
-```
-"""
-eigs(A; kwargs...) = eigs(A, I; kwargs...)
-eigs(A::AbstractMatrix{<:BlasFloat}, ::UniformScaling; kwargs...) = _eigs(A, I; kwargs...)
-
-eigs(A::AbstractMatrix{T}, B::AbstractMatrix{T}; kwargs...) where {T<:BlasFloat} = _eigs(A, B; kwargs...)
-eigs(A::AbstractMatrix{BigFloat}, B::AbstractMatrix...; kwargs...) = throw(MethodError(eigs, Any[A,B,kwargs...]))
-eigs(A::AbstractMatrix{BigFloat}, B::UniformScaling; kwargs...) = throw(MethodError(eigs, Any[A,B,kwargs...]))
-function eigs(A::AbstractMatrix{T}, ::UniformScaling; kwargs...) where T
-    Tnew = typeof(zero(T)/sqrt(one(T)))
-    eigs(convert(AbstractMatrix{Tnew}, A), I; kwargs...)
-end
-function eigs(A::AbstractMatrix, B::AbstractMatrix; kwargs...)
-    T = promote_type(eltype(A), eltype(B))
-    Tnew = typeof(zero(T)/sqrt(one(T)))
-    eigs(convert(AbstractMatrix{Tnew}, A), convert(AbstractMatrix{Tnew}, B); kwargs...)
-end
-"""
-    eigs(A, B; nev=6, ncv=max(20,2*nev+1), which=:LM, tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)
-
-Computes generalized eigenvalues `d` of `A` and `B` using implicitly restarted Lanczos or Arnoldi iterations for
-real symmetric or general nonsymmetric matrices respectively. See [the manual](@ref lib-itereigen) for more information.
-"""
-eigs(A, B; kwargs...) = _eigs(A, B; kwargs...)
-function _eigs(A, B;
-               nev::Integer=6, ncv::Integer=max(20,2*nev+1), which=:LM,
-               tol=0.0, maxiter::Integer=300, sigma=nothing, v0::Vector=zeros(eltype(A),(0,)),
-               ritzvec::Bool=true)
-    n = checksquare(A)
-
-    T = eltype(A)
-    iscmplx = T <: Complex
-    isgeneral = B !== I
-    sym = !iscmplx && issymmetric(A) && issymmetric(B)
-    nevmax = sym ? n-1 : n-2
-    if nevmax <= 0
-        throw(ArgumentError("input matrix A is too small. Use eigen instead."))
-    end
-    if nev > nevmax
-        @warn "Adjusting nev from $nev to $nevmax"
-        nev = nevmax
-    end
-    if nev <= 0
-        throw(ArgumentError("requested number of eigenvalues (nev) must be ≥ 1, got $nev"))
-    end
-    ncvmin = nev + (sym ? 1 : 2)
-    if ncv < ncvmin
-        @warn "Adjusting ncv from $ncv to $ncvmin"
-        ncv = ncvmin
-    end
-    ncv = BlasInt(min(ncv, n))
-    bmat = isgeneral ? "G" : "I"
-    isshift = sigma !== nothing
-
-    if isa(which,AbstractString)
-        @warn "Use symbols instead of strings for specifying which eigenvalues to compute"
-        which=Symbol(which)
-    end
-    if (which != :LM && which != :SM && which != :LR && which != :SR &&
-        which != :LI && which != :SI && which != :BE)
-        throw(ArgumentError("which must be :LM, :SM, :LR, :SR, :LI, :SI, or :BE, got $(repr(which))"))
-    end
-    if which == :BE && !sym
-        throw(ArgumentError("which=:BE only possible for real symmetric problem"))
-    end
-    isshift && which == :SM && @warn "Use of :SM in shift-and-invert mode is not recommended, use :LM to find eigenvalues closest to sigma"
-
-    if which==:SM && !isshift # transform into shift-and-invert method with sigma = 0
-        isshift=true
-        sigma=zero(T)
-        which=:LM
-    end
-
-    if sigma !== nothing && !iscmplx && isa(sigma,Complex)
-        throw(ArgumentError("complex shifts for real problems are not yet supported"))
-    end
-    sigma = isshift ? convert(T,sigma) : zero(T)
-
-    if !isempty(v0)
-        if length(v0) != n
-            throw(DimensionMismatch())
-        end
-        if eltype(v0) != T
-            throw(ArgumentError("starting vector must have element type $T, got $(eltype(v0))"))
-        end
-    end
-
-    whichstr = "LM"
-    if which == :BE
-        whichstr = "BE"
-    end
-    if which == :LR
-        whichstr = (!sym ? "LR" : "LA")
-    end
-    if which == :SR
-        whichstr = (!sym ? "SR" : "SA")
-    end
-    if which == :LI
-        if !sym
-            whichstr = "LI"
-        else
-            throw(ArgumentError("largest imaginary is meaningless for symmetric eigenvalue problems"))
-        end
-    end
-    if which == :SI
-        if !sym
-            whichstr = "SI"
-        else
-            throw(ArgumentError("smallest imaginary is meaningless for symmetric eigenvalue problems"))
-        end
-    end
-
-    # Refer to ex-*.doc files in ARPACK/DOCUMENTS for calling sequence
-    matvecA!(y, x) = mul!(y, A, x)
-    if !isgeneral           # Standard problem
-        matvecB = x -> x
-        if !isshift         #    Regular mode
-            mode       = 1
-            solveSI = x->x
-        else                #    Shift-invert mode
-            mode       = 3
-            F = factorize(A - UniformScaling(sigma))
-            solveSI = x -> F \ x
-        end
-    else                    # Generalized eigenproblem
-        matvecB = x -> B * x
-        if !isshift         #    Regular inverse mode
-            mode       = 2
-            F = factorize(B)
-            solveSI = x -> F \ x
-        else                #    Shift-invert mode
-            mode       = 3
-            F = factorize(A - sigma*B)
-            solveSI = x -> F \ x
-        end
-    end
-
-    # Compute the Ritz values and Ritz vectors
-    (resid, v, ldv, iparam, ipntr, workd, workl, lworkl, rwork, TOL) =
-       ARPACK.aupd_wrapper(T, matvecA!, matvecB, solveSI, n, sym, iscmplx, bmat, nev, ncv, whichstr, tol, maxiter, mode, v0)
-
-    # Postprocessing to get eigenvalues and eigenvectors
-    output = ARPACK.eupd_wrapper(T, n, sym, iscmplx, bmat, nev, whichstr, ritzvec, TOL,
-                                 resid, ncv, v, ldv, sigma, iparam, ipntr, workd, workl, lworkl, rwork)
-
-    # Issue 10495, 10701: Check that all eigenvalues are converged
-    nev = length(output[1])
-    nconv = output[ritzvec ? 3 : 2]
-    nev ≤ nconv || @warn "Not all wanted Ritz pairs converged. Requested: $nev, converged: $nconv"
-
-    return output
-end
-
-
-## svds
-struct SVDAugmented{T,S} <: AbstractArray{T, 2}
-    X::S
-    SVDAugmented{T,S}(X::AbstractMatrix) where {T,S} = new(X)
-end
-
-function SVDAugmented(A::AbstractMatrix{T}) where T
-    Tnew = typeof(zero(T)/sqrt(one(T)))
-    Anew = convert(AbstractMatrix{Tnew}, A)
-    SVDAugmented{Tnew,typeof(Anew)}(Anew)
-end
-
-function LinearAlgebra.mul!(y::StridedVector{T}, A::SVDAugmented{T}, x::StridedVector{T}) where T
-    m, mn = size(A.X, 1), length(x)
-    mul!( view(y, 1:m), A.X, view(x, m + 1:mn)) # left singular vector
-    mul!(view(y, m + 1:mn), adjoint(A.X), view(x, 1:m)) # right singular vector
-    return y
-end
-Base.size(A::SVDAugmented)  = ((+)(size(A.X)...), (+)(size(A.X)...))
-LinearAlgebra.ishermitian(A::SVDAugmented) = true
-
-struct AtA_or_AAt{T,S} <: AbstractArray{T, 2}
-    A::S
-    buffer::Vector{T}
-end
-
-function AtA_or_AAt(A::AbstractMatrix{T}) where T
-    Tnew = typeof(zero(T)/sqrt(one(T)))
-    Anew = convert(AbstractMatrix{Tnew}, A)
-    AtA_or_AAt{Tnew,typeof(Anew)}(Anew, Vector{Tnew}(undef, max(size(A)...)))
-end
-
-function LinearAlgebra.mul!(y::StridedVector{T}, A::AtA_or_AAt{T}, x::StridedVector{T}) where T
-    if size(A.A, 1) >= size(A.A, 2)
-        mul!(A.buffer, A.A, x)
-        return mul!(y, adjoint(A.A), A.buffer)
-    else
-        mul!(A.buffer, adjoint(A.A), x)
-        return mul!(y, A.A, A.buffer)
-    end
-end
-Base.size(A::AtA_or_AAt) = ntuple(i -> min(size(A.A)...), Val(2))
-LinearAlgebra.ishermitian(s::AtA_or_AAt) = true
-
-
-svds(A::AbstractMatrix{<:BlasFloat}; kwargs...) = _svds(A; kwargs...)
-svds(A::AbstractMatrix{BigFloat}; kwargs...) = throw(MethodError(svds, Any[A, kwargs...]))
-function svds(A::AbstractMatrix{T}; kwargs...) where T
-    Tnew = typeof(zero(T)/sqrt(one(T)))
-    svds(convert(AbstractMatrix{Tnew}, A); kwargs...)
-end
-
-"""
-    svds(A; nsv=6, ritzvec=true, tol=0.0, maxiter=1000, ncv=2*nsv, v0=zeros((0,))) -> (SVD([left_sv,] s, [right_sv,]), nconv, niter, nmult, resid)
-
-Computes the largest singular values `s` of `A` using implicitly restarted Lanczos
-iterations derived from [`eigs`](@ref).
-
-**Inputs**
-
-* `A`: Linear operator whose singular values are desired. `A` may be represented as a
-  subtype of `AbstractArray`, e.g., a sparse matrix, or any other type supporting the four
-  methods `size(A)`, `eltype(A)`, `A * vector`, and `A' * vector`.
-* `nsv`: Number of singular values. Default: 6.
-* `ritzvec`: If `true`, return the left and right singular vectors `left_sv` and `right_sv`.
-   If `false`, omit the singular vectors. Default: `true`.
-* `tol`: tolerance, see [`eigs`](@ref).
-* `maxiter`: Maximum number of iterations, see [`eigs`](@ref). Default: 1000.
-* `ncv`: Maximum size of the Krylov subspace, see [`eigs`](@ref) (there called `nev`). Default: `2*nsv`.
-* `v0`: Initial guess for the first Krylov vector. It may have length `min(size(A)...)`, or 0.
-
-**Outputs**
-
-* `svd`: An `SVD` object containing the left singular vectors, the requested values, and the
-  right singular vectors. If `ritzvec = false`, the left and right singular vectors will be
-  empty.
-* `nconv`: Number of converged singular values.
-* `niter`: Number of iterations.
-* `nmult`: Number of matrix--vector products used.
-* `resid`: Final residual vector.
-
-# Examples
-```jldoctest; filter = r"2-element Array{Float64,1}:\\n.*\\n.*"
-julia> A = Diagonal(1:4);
-
-julia> s = svds(A, nsv = 2)[1];
-
-julia> s.S
-2-element Array{Float64,1}:
- 4.0
- 2.9999999999999996
-```
-
-!!! note "Implementation"
-    `svds(A)` is formally equivalent to calling [`eigs`](@ref) to perform implicitly restarted
-    Lanczos tridiagonalization on the Hermitian matrix ``A^\\prime A`` or ``AA^\\prime`` such
-    that the size is smallest.
-"""
-svds(A; kwargs...) = _svds(A; kwargs...)
-function _svds(X; nsv::Int = 6, ritzvec::Bool = true, tol::Float64 = 0.0, maxiter::Int = 1000, ncv::Int = 2*nsv, v0::Vector=zeros(eltype(X),(0,)))
-    if nsv < 1
-        throw(ArgumentError("number of singular values (nsv) must be ≥ 1, got $nsv"))
-    end
-    if nsv > minimum(size(X))
-        throw(ArgumentError("number of singular values (nsv) must be ≤ $(minimum(size(X))), got $nsv"))
-    end
-    m, n = size(X)
-    otype = eltype(X)
-    if length(v0) ∉ [0,n]
-        throw(DimensionMismatch("length of v0, the guess for the starting right Krylov vector, must be 0, or $n, got $(length(v0))"))
-    end
-    ex    = eigs(AtA_or_AAt(X), I; which = :LM, ritzvec = ritzvec, nev = nsv, tol = tol, maxiter = maxiter, v0=v0)
-    # ind   = [1:2:ncv;]
-    # sval  = abs.(ex[1][ind])
-
-    svals = sqrt.(real.(ex[1]))
-    if ritzvec
-        # calculating singular vectors
-        # left_sv  = sqrt(2) * ex[2][ 1:size(X,1),     ind ] .* sign.(ex[1][ind]')
-        if size(X, 1) >= size(X, 2)
-            V = ex[2]
-            U = Array(qr(rmul!(X*V, Diagonal(inv.(svals)))).Q)
-        else
-            U = ex[2]
-            V = Array(qr(rmul!(X'U, Diagonal(inv.(svals)))).Q)
-        end
-
-        # right_sv = sqrt(2) * ex[2][ size(X,1)+1:end, ind ]
-        return (SVD(U, svals, copy(V')), ex[3], ex[4], ex[5], ex[6])
-    else
-        #The sort is necessary to work around #10329
-        return (SVD(zeros(eltype(svals), n, 0),
-                    svals,
-                    zeros(eltype(svals), 0, m)),
-                    ex[2], ex[3], ex[4], ex[5])
-    end
-end
-
-include("deprecated.jl")
-
-end # module
diff --git a/stdlib/IterativeEigensolvers/src/arpack.jl b/stdlib/IterativeEigensolvers/src/arpack.jl
deleted file mode 100644
index 359d4c730b065..0000000000000
--- a/stdlib/IterativeEigensolvers/src/arpack.jl
+++ /dev/null
@@ -1,290 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-module ARPACK
-
-import LinearAlgebra: BlasInt, ARPACKException
-
-## aupd and eupd wrappers
-
-function aupd_wrapper(T, matvecA!::Function, matvecB::Function, solveSI::Function, n::Integer,
-                      sym::Bool, cmplx::Bool, bmat::String,
-                      nev::Integer, ncv::Integer, which::String,
-                      tol::Real, maxiter::Integer, mode::Integer, v0::Vector)
-    lworkl = cmplx ? ncv * (3*ncv + 5) : (sym ? ncv * (ncv + 8) :  ncv * (3*ncv + 6) )
-    TR = cmplx ? T.types[1] : T
-    TOL = Ref{TR}(tol)
-
-    v     = Matrix{T}(undef, n, ncv)
-    workd = Vector{T}(undef, 3*n)
-    workl = Vector{T}(undef, lworkl)
-    rwork = cmplx ? Vector{TR}(undef, ncv) : Vector{TR}()
-
-    if isempty(v0)
-        resid = Vector{T}(undef, n)
-        info  = Ref{BlasInt}(0)
-    else
-        resid = deepcopy(v0)
-        info  = Ref{BlasInt}(1)
-    end
-    iparam = zeros(BlasInt, 11)
-    ipntr  = zeros(BlasInt, (sym && !cmplx) ? 11 : 14)
-    ido    = Ref{BlasInt}(0)
-
-    iparam[1] = BlasInt(1)       # ishifts
-    iparam[3] = BlasInt(maxiter) # maxiter
-    iparam[7] = BlasInt(mode)    # mode
-
-    zernm1 = 0:(n-1)
-
-    while true
-        if cmplx
-            naupd(ido, bmat, n, which, nev, TOL, resid, ncv, v, n,
-                  iparam, ipntr, workd, workl, lworkl, rwork, info)
-        elseif sym
-            saupd(ido, bmat, n, which, nev, TOL, resid, ncv, v, n,
-                  iparam, ipntr, workd, workl, lworkl, info)
-        else
-            naupd(ido, bmat, n, which, nev, TOL, resid, ncv, v, n,
-                  iparam, ipntr, workd, workl, lworkl, info)
-        end
-        if info[] != 0
-            throw(ARPACKException(info[]))
-        end
-
-        x = view(workd, ipntr[1] .+ zernm1)
-        y = view(workd, ipntr[2] .+ zernm1)
-        if mode == 1  # corresponds to dsdrv1, dndrv1 or zndrv1
-            if ido[] == 1
-                matvecA!(y, x)
-            elseif ido[] == 99
-                break
-            else
-                throw(ARPACKException("unexpected behavior"))
-            end
-        elseif mode == 3 && bmat == "I" # corresponds to dsdrv2, dndrv2 or zndrv2
-            if ido[] == -1 || ido[] == 1
-                y[:] = solveSI(x)
-            elseif ido[] == 99
-                break
-            else
-                throw(ARPACKException("unexpected behavior"))
-            end
-        elseif mode == 2 # corresponds to dsdrv3, dndrv3 or zndrv3
-            if ido[] == -1 || ido[] == 1
-                matvecA!(y, x)
-                if sym
-                    x[:] = y    # overwrite as per Remark 5 in dsaupd.f
-                end
-                y[:] = solveSI(y)
-            elseif ido[] == 2
-                y[:] = matvecB(x)
-            elseif ido[] == 99
-                break
-            else
-                throw(ARPACKException("unexpected behavior"))
-            end
-        elseif mode == 3 && bmat == "G" # corresponds to dsdrv4, dndrv4 or zndrv4
-            if ido[] == -1
-                y[:] = solveSI(matvecB(x))
-            elseif  ido[] == 1
-                y[:] = solveSI(view(workd,ipntr[3] .+ zernm1))
-            elseif ido[] == 2
-                y[:] = matvecB(x)
-            elseif ido[] == 99
-                break
-            else
-                throw(ARPACKException("unexpected behavior"))
-            end
-        else
-            throw(ArgumentError("ARPACK mode ($mode) not yet supported"))
-        end
-    end
-
-    return (resid, v, n, iparam, ipntr, workd, workl, lworkl, rwork, TOL)
-end
-
-function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::String,
-                      nev::Integer, which::String, ritzvec::Bool,
-                      TOL::Ref, resid, ncv::Integer, v, ldv, sigma, iparam, ipntr,
-                      workd, workl, lworkl, rwork)
-    howmny = "A"
-    select = Vector{BlasInt}(undef, ncv)
-    info   = Ref{BlasInt}(0)
-
-    dmap = x -> abs.(x)
-    if iparam[7] == 3 # shift-and-invert
-        dmap = x -> abs.(1 ./ (x .- sigma))
-    elseif which == "LR" || which == "LA" || which == "BE"
-        dmap = real
-    elseif which == "SR" || which == "SA"
-        dmap = x -> -real(x)
-    elseif which == "LI"
-        dmap = imag
-    elseif which == "SI"
-        dmap = x -> -imag(x)
-    end
-
-    if cmplx
-        d = Vector{T}(undef, nev+1)
-        sigmar = Ref{T}(sigma)
-        workev = Vector{T}(undef, 2ncv)
-        neupd(ritzvec, howmny, select, d, v, ldv, sigmar, workev,
-              bmat, n, which, nev, TOL, resid, ncv, v, ldv,
-              iparam, ipntr, workd, workl, lworkl, rwork, info)
-        if info[] != 0
-            throw(ARPACKException(info[]))
-        end
-
-        p = sortperm(dmap(d[1:nev]), rev=true)
-        return ritzvec ? (d[p], v[1:n, p],iparam[5],iparam[3],iparam[9],resid) : (d[p],iparam[5],iparam[3],iparam[9],resid)
-    elseif sym
-        d = Vector{T}(undef, nev)
-        sigmar = Ref{T}(sigma)
-        seupd(ritzvec, howmny, select, d, v, ldv, sigmar,
-              bmat, n, which, nev, TOL, resid, ncv, v, ldv,
-              iparam, ipntr, workd, workl, lworkl, info)
-        if info[] != 0
-            throw(ARPACKException(info[]))
-        end
-
-        p = sortperm(dmap(d), rev=true)
-        return ritzvec ? (d[p], v[1:n, p],iparam[5],iparam[3],iparam[9],resid) : (d[p],iparam[5],iparam[3],iparam[9],resid)
-    else
-        dr = Vector{T}(undef, nev+1)
-        di = Vector{T}(undef, nev+1)
-        fill!(dr,NaN)
-        fill!(di,NaN)
-        sigmar = Ref{T}(real(sigma))
-        sigmai = Ref{T}(imag(sigma))
-        workev = Vector{T}(undef, 3*ncv)
-        neupd(ritzvec, howmny, select, dr, di, v, ldv, sigmar, sigmai,
-              workev, bmat, n, which, nev, TOL, resid, ncv, v, ldv,
-              iparam, ipntr, workd, workl, lworkl, info)
-        if info[] != 0
-            throw(ARPACKException(info[]))
-        end
-        evec = complex.(Matrix{T}(undef, n, nev+1), Matrix{T}(undef, n, nev+1))
-
-        j = 1
-        while j <= nev
-            if di[j] == 0
-                evec[:,j] = v[:,j]
-            else # For complex conjugate pairs
-                evec[:,j]   = v[:,j] + im*v[:,j+1]
-                evec[:,j+1] = v[:,j] - im*v[:,j+1]
-                j += 1
-            end
-            j += 1
-        end
-        if j == nev+1 && !isnan(di[j])
-            if di[j] == 0
-                evec[:,j] = v[:,j]
-                j += 1
-            else
-                throw(ARPACKException("unexpected behavior"))
-            end
-        end
-
-        d = complex.(dr, di)
-
-        if j == nev+1
-            p = sortperm(dmap(d[1:nev]), rev=true)
-        else
-            p = sortperm(dmap(d), rev=true)
-            p = p[1:nev]
-        end
-
-        return ritzvec ? (d[p], evec[1:n, p],iparam[5],iparam[3],iparam[9],resid) : (d[p],iparam[5],iparam[3],iparam[9],resid)
-    end
-end
-
-for (T, saupd_name, seupd_name, naupd_name, neupd_name) in
-    ((:Float64, :dsaupd_, :dseupd_, :dnaupd_, :dneupd_),
-     (:Float32, :ssaupd_, :sseupd_, :snaupd_, :sneupd_))
-    @eval begin
-        function naupd(ido, bmat, n, evtype, nev, TOL::Ref{$T}, resid::Vector{$T}, ncv, v::Matrix{$T}, ldv,
-                       iparam, ipntr, workd::Vector{$T}, workl::Vector{$T}, lworkl, info)
-            ccall(($(string(naupd_name)), :libarpack), Cvoid,
-                  (Ref{BlasInt}, Ptr{UInt8}, Ref{BlasInt}, Ptr{UInt8}, Ref{BlasInt},
-                   Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ptr{$T}, Ref{BlasInt},
-                   Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ref{BlasInt}, Clong, Clong),
-                  ido, bmat, n, evtype, nev,
-                  TOL, resid, ncv, v, ldv,
-                  iparam, ipntr, workd, workl, lworkl, info, sizeof(bmat), sizeof(evtype))
-        end
-
-        function neupd(rvec, howmny, select, dr, di, z, ldz, sigmar, sigmai,
-                  workev::Vector{$T}, bmat, n, evtype, nev, TOL::Ref{$T}, resid::Vector{$T}, ncv, v, ldv,
-                  iparam, ipntr, workd::Vector{$T}, workl::Vector{$T}, lworkl, info)
-            ccall(($(string(neupd_name)), :libarpack), Cvoid,
-                  (Ref{BlasInt}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$T}, Ptr{$T}, Ptr{$T}, Ref{BlasInt},
-                   Ref{$T}, Ref{$T}, Ptr{$T}, Ptr{UInt8}, Ref{BlasInt}, Ptr{UInt8}, Ref{BlasInt},
-                   Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ptr{$T}, Ref{BlasInt},
-                   Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ref{BlasInt}, Clong, Clong, Clong),
-                  rvec, howmny, select, dr, di, z, ldz,
-                  sigmar, sigmai, workev, bmat, n, evtype, nev,
-                  TOL, resid, ncv, v, ldv,
-                  iparam, ipntr, workd, workl, lworkl, info, sizeof(howmny), sizeof(bmat), sizeof(evtype))
-        end
-
-        function saupd(ido, bmat, n, which, nev, TOL::Ref{$T}, resid::Vector{$T}, ncv, v::Matrix{$T}, ldv,
-                       iparam, ipntr, workd::Vector{$T}, workl::Vector{$T}, lworkl, info)
-            ccall(($(string(saupd_name)), :libarpack), Cvoid,
-                  (Ref{BlasInt}, Ptr{UInt8}, Ref{BlasInt}, Ptr{UInt8}, Ref{BlasInt},
-                   Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ptr{$T}, Ref{BlasInt},
-                   Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ref{BlasInt}, Clong, Clong),
-                  ido, bmat, n, which, nev,
-                  TOL, resid, ncv, v, ldv,
-                  iparam, ipntr, workd, workl, lworkl, info, sizeof(bmat), sizeof(which))
-        end
-
-        function seupd(rvec, howmny, select, d, z, ldz, sigma,
-                       bmat, n, evtype, nev, TOL::Ref{$T}, resid::Vector{$T}, ncv, v::Matrix{$T}, ldv,
-                       iparam, ipntr, workd::Vector{$T}, workl::Vector{$T}, lworkl, info)
-            ccall(($(string(seupd_name)), :libarpack), Cvoid,
-                  (Ref{BlasInt}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$T}, Ptr{$T}, Ref{BlasInt},
-                   Ptr{$T}, Ptr{UInt8}, Ref{BlasInt}, Ptr{UInt8}, Ref{BlasInt},
-                   Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ptr{$T}, Ref{BlasInt},
-                   Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ref{BlasInt}, Clong, Clong, Clong),
-                  rvec, howmny, select, d, z, ldz,
-                  sigma, bmat, n, evtype, nev,
-                  TOL, resid, ncv, v, ldv,
-                  iparam, ipntr, workd, workl, lworkl, info, sizeof(howmny), sizeof(bmat), sizeof(evtype))
-        end
-    end
-end
-
-for (T, TR, naupd_name, neupd_name) in
-    ((:ComplexF64, :Float64, :znaupd_, :zneupd_),
-     (:ComplexF32, :Float32, :cnaupd_, :cneupd_))
-    @eval begin
-        function naupd(ido, bmat, n, evtype, nev, TOL::Ref{$TR}, resid::Vector{$T}, ncv, v::Matrix{$T}, ldv,
-                       iparam, ipntr, workd::Vector{$T}, workl::Vector{$T}, lworkl,
-                       rwork::Vector{$TR}, info)
-            ccall(($(string(naupd_name)), :libarpack), Cvoid,
-                  (Ref{BlasInt}, Ptr{UInt8}, Ref{BlasInt}, Ptr{UInt8}, Ref{BlasInt},
-                   Ptr{$TR}, Ptr{$T}, Ref{BlasInt}, Ptr{$T}, Ref{BlasInt},
-                   Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ptr{$TR}, Ref{BlasInt}),
-                  ido, bmat, n, evtype, nev,
-                  TOL, resid, ncv, v, ldv,
-                  iparam, ipntr, workd, workl, lworkl, rwork, info)
-        end
-
-        function neupd(rvec, howmny, select, d, z, ldz, sigma, workev::Vector{$T},
-                       bmat, n, evtype, nev, TOL::Ref{$TR}, resid::Vector{$T}, ncv, v::Matrix{$T}, ldv,
-                       iparam, ipntr, workd::Vector{$T}, workl::Vector{$T}, lworkl,
-                       rwork::Vector{$TR}, info)
-            ccall(($(string(neupd_name)), :libarpack), Cvoid,
-                  (Ref{BlasInt}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$T}, Ptr{$T}, Ref{BlasInt},
-                   Ptr{$T}, Ptr{$T}, Ptr{UInt8}, Ref{BlasInt}, Ptr{UInt8}, Ref{BlasInt},
-                   Ptr{$TR}, Ptr{$T}, Ref{BlasInt}, Ptr{$T}, Ref{BlasInt},
-                   Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$T}, Ptr{$T}, Ref{BlasInt}, Ptr{$TR}, Ref{BlasInt}),
-                  rvec, howmny, select, d, z, ldz,
-                  sigma, workev, bmat, n, evtype, nev,
-                  TOL, resid, ncv, v, ldv,
-                  iparam, ipntr, workd, workl, lworkl, rwork, info)
-        end
-    end
-end
-
-end # module ARPACK
diff --git a/stdlib/IterativeEigensolvers/src/deprecated.jl b/stdlib/IterativeEigensolvers/src/deprecated.jl
deleted file mode 100644
index e48331e7ae75b..0000000000000
--- a/stdlib/IterativeEigensolvers/src/deprecated.jl
+++ /dev/null
@@ -1,4 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-LinearAlgebra.A_mul_B!(y::StridedVector{T}, A::AtA_or_AAt{T}, x::StridedVector{T}) where {T} = LinearAlgebra.mul!(y, A, x)
-LinearAlgebra.A_mul_B!(y::StridedVector{T}, A::SVDAugmented{T}, x::StridedVector{T}) where {T} = LinearAlgebra.mul!(y, A, x)
diff --git a/stdlib/IterativeEigensolvers/test/runtests.jl b/stdlib/IterativeEigensolvers/test/runtests.jl
deleted file mode 100644
index 939a71a16e419..0000000000000
--- a/stdlib/IterativeEigensolvers/test/runtests.jl
+++ /dev/null
@@ -1,283 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-using IterativeEigensolvers
-using Test, LinearAlgebra, SparseArrays, Random
-
-@testset "eigs" begin
-    srand(1234)
-    n = 10
-    areal  = sprandn(n,n,0.4)
-    breal  = sprandn(n,n,0.4)
-    acmplx = complex.(sprandn(n,n,0.4), sprandn(n,n,0.4))
-    bcmplx = complex.(sprandn(n,n,0.4), sprandn(n,n,0.4))
-
-    testtol = 1e-6
-
-    @testset for elty in (Float64, ComplexF64)
-        if elty == ComplexF32 || elty == ComplexF64
-            a = acmplx
-            b = bcmplx
-        else
-            a = areal
-            b = breal
-        end
-        a_evs = eigvals(Array(a))
-        a     = convert(SparseMatrixCSC{elty}, a)
-        asym  = copy(a') + a                  # symmetric indefinite
-        apd   = a'*a                    # symmetric positive-definite
-
-        b     = convert(SparseMatrixCSC{elty}, b)
-        bsym  = copy(b') + b
-        bpd   = b'*b
-
-        (d,v) = eigs(a, nev=3)
-        @test a*v[:,2] ≈ d[2]*v[:,2]
-        @test norm(v) > testtol # eigenvectors cannot be null vectors
-        (d,v) = eigs(a, LinearAlgebra.I, nev=3) # test eigs(A, B; kwargs...)
-        @test a*v[:,2] ≈ d[2]*v[:,2]
-        @test norm(v) > testtol # eigenvectors cannot be null vectors
-        @test_logs (:warn,"Use symbols instead of strings for specifying which eigenvalues to compute") eigs(a, which="LM")
-        @test_logs (:warn,"Adjusting ncv from 1 to 4") eigs(a, ncv=1, nev=2)
-        @test_logs (:warn,"Adjusting nev from $n to $(n-2)") eigs(a, nev=n)
-        # (d,v) = eigs(a, b, nev=3, tol=1e-8) # not handled yet
-        # @test a*v[:,2] ≈ d[2]*b*v[:,2] atol=testtol
-        # @test norm(v) > testtol # eigenvectors cannot be null vectors
-        if elty <: LinearAlgebra.BlasComplex
-            sr_ind = argmin(real.(a_evs))
-            (d, v) = eigs(a, nev=1, which=:SR)
-            @test d[1] ≈ a_evs[sr_ind]
-            si_ind = argmin(imag.(a_evs))
-            (d, v) = eigs(a, nev=1, which=:SI)
-            @test d[1] ≈ a_evs[si_ind]
-            lr_ind = argmax(real.(a_evs))
-            (d, v) = eigs(a, nev=1, which=:LR)
-            @test d[1] ≈ a_evs[lr_ind]
-            li_ind = argmax(imag.(a_evs))
-            (d, v) = eigs(a, nev=1, which=:LI)
-            @test d[1] ≈ a_evs[li_ind]
-        end
-
-        (d,v) = eigs(asym, nev=3)
-        @test asym*v[:,1] ≈ d[1]*v[:,1]
-        @test eigs(asym; nev=1, sigma=d[3])[1][1] ≈ d[3]
-        @test norm(v) > testtol # eigenvectors cannot be null vectors
-
-        (d,v) = eigs(apd, nev=3)
-        @test apd*v[:,3] ≈ d[3]*v[:,3]
-        @test eigs(apd; nev=1, sigma=d[3])[1][1] ≈ d[3]
-
-        (d,v) = eigs(apd, bpd, nev=3, tol=1e-8)
-        @test apd*v[:,2] ≈ d[2]*bpd*v[:,2] atol=testtol
-        @test norm(v) > testtol # eigenvectors cannot be null vectors
-
-        @testset "(shift-and-)invert mode" begin
-            (d,v) = eigs(apd, nev=3, sigma=0)
-            @test apd*v[:,3] ≈ d[3]*v[:,3]
-            @test norm(v) > testtol # eigenvectors cannot be null vectors
-
-            (d,v) = eigs(apd, bpd, nev=3, sigma=0, tol=1e-8)
-            @test apd*v[:,1] ≈ d[1]*bpd*v[:,1] atol=testtol
-            @test norm(v) > testtol # eigenvectors cannot be null vectors
-        end
-
-        @testset "ArgumentErrors" begin
-            @test_throws ArgumentError eigs(rand(elty,2,2))
-            @test_throws ArgumentError eigs(a, nev=-1)
-            @test_throws ArgumentError eigs(a, which=:Z)
-            @test_throws ArgumentError eigs(a, which=:BE)
-            @test_throws DimensionMismatch eigs(a, v0=zeros(elty,n+2))
-            @test_throws ArgumentError eigs(a, v0=zeros(Int,n))
-            if elty == Float64
-                @test_throws ArgumentError eigs(a + copy(transpose(a)), which=:SI)
-                @test_throws ArgumentError eigs(a + copy(transpose(a)), which=:LI)
-                @test_throws ArgumentError eigs(a, sigma = rand(ComplexF32))
-            end
-        end
-    end
-
-    @testset "Symmetric generalized with singular B" begin
-        srand(127)
-        n = 10
-        k = 3
-        A = randn(n,n); A = A'A
-        B = randn(n,k); B = B*B'
-        @test sort(eigs(A, B, nev = k, sigma = 1.0)[1]) ≈ sort(eigvals(A, B)[1:k])
-    end
-end
-
-# Problematic example from #6965A
-let A6965 = [
-    1.0   1.0   1.0   1.0   1.0   1.0   1.0  1.0
-    -1.0   2.0   0.0   0.0   0.0   0.0   0.0  1.0
-    -1.0   0.0   3.0   0.0   0.0   0.0   0.0  1.0
-    -1.0   0.0   0.0   4.0   0.0   0.0   0.0  1.0
-    -1.0   0.0   0.0   0.0   5.0   0.0   0.0  1.0
-    -1.0   0.0   0.0   0.0   0.0   6.0   0.0  1.0
-    -1.0   0.0   0.0   0.0   0.0   0.0   7.0  1.0
-    -1.0  -1.0  -1.0  -1.0  -1.0  -1.0  -1.0  8.0
-]
-    d, = eigs(A6965,which=:SM,nev=2,ncv=4,tol=eps())
-    @test d[1] ≈ 2.5346936860350002
-    @test real(d[2]) ≈ 2.6159972444834976
-    @test abs(imag(d[2])) ≈ 1.2917858749046127
-
-    # Requires ARPACK 3.2 or a patched 3.1.5
-    #T6965 = [ 0.9  0.05  0.05
-    #          0.8  0.1   0.1
-    #          0.7  0.1   0.2 ]
-    #d,v,nconv = eigs(T6965,nev=1,which=:LM)
-    # @test T6965*v ≈ d[1]*v atol=1e-6
-end
-
-# Example from Quantum Information Theory
-import Base: size
-
-mutable struct CPM{T<:LinearAlgebra.BlasFloat} <: AbstractMatrix{T} # completely positive map
-    kraus::Array{T,3} # kraus operator representation
-end
-size(Phi::CPM) = (size(Phi.kraus,1)^2,size(Phi.kraus,3)^2)
-LinearAlgebra.issymmetric(Phi::CPM) = false
-LinearAlgebra.ishermitian(Phi::CPM) = false
-function LinearAlgebra.mul!(rho2::StridedVector{T},Phi::CPM{T},rho::StridedVector{T}) where {T<:LinearAlgebra.BlasFloat}
-    rho = reshape(rho,(size(Phi.kraus,3),size(Phi.kraus,3)))
-    rho1 = zeros(T,(size(Phi.kraus,1),size(Phi.kraus,1)))
-    for s = 1:size(Phi.kraus,2)
-        As = view(Phi.kraus,:,s,:)
-        rho1 += As*rho*As'
-    end
-    return copyto!(rho2,rho1)
-end
-LinearAlgebra.A_mul_B!(rho2::StridedVector{T},Phi::CPM{T},rho::StridedVector{T}) where {T<:LinearAlgebra.BlasFloat} = LinearAlgebra.mul!(rho2, Phi, rho)
-# after the A_mul_B! deprecation, remove this A_mul_B! def
-
-let
-    # Generate random isometry
-    (Q, R) = qr(randn(100, 50))
-    Q = reshape(Array(Q), (50, 2, 50))
-    # Construct trace-preserving completely positive map from this
-    Phi = CPM(copy(Q))
-    (d,v,nconv,numiter,numop,resid) = eigs(Phi,nev=1,which=:LM)
-    # Properties: largest eigenvalue should be 1, largest eigenvector, when reshaped as matrix
-    # should be a Hermitian positive definite matrix (up to an arbitrary phase)
-
-    @test d[1] ≈ 1. # largest eigenvalue should be 1.
-    v = reshape(v,(50,50)) # reshape to matrix
-    v /= tr(v) # factor out arbitrary phase
-    @test vecnorm(imag(v)) ≈ 0. # it should be real
-    v = real(v)
-    # @test vecnorm(v-v')/2 ≈ 0. # it should be Hermitian
-    # Since this fails sometimes (numerical precision error),this test is commented out
-    v = (v + v')/2
-    @test isposdef(v)
-
-    # Repeat with starting vector
-    (d2,v2,nconv2,numiter2,numop2,resid2) = eigs(Phi,nev=1,which=:LM,v0=reshape(v,(2500,)))
-    v2 = reshape(v2,(50,50))
-    v2 /= tr(v2)
-    @test numiter2 < numiter
-    @test v ≈ v2
-
-    # Adjust the tolerance a bit since matrices with repeated eigenvalues
-    # can be very stressful to ARPACK and this may therefore fail with
-    # info = 3 if the tolerance is too small
-    @test eigs(sparse(1.0I, 50, 50), nev=10, tol = 5e-16)[1] ≈ fill(1., 10) #Issue 4246
-end
-
-@testset "real svds" begin
-    A = sparse([1, 1, 2, 3, 4], [2, 1, 1, 3, 1], [2.0, -1.0, 6.1, 7.0, 1.5])
-    S1 = svds(A, nsv = 2)
-    S2 = svd(Array(A))
-
-    ## singular values match:
-    @test S1[1].S ≈ S2.S[1:2]
-    @testset "singular vectors" begin
-        ## 1st left singular vector
-        s1_left = sign(S1[1].U[3,1]) * S1[1].U[:,1]
-        s2_left = sign(S2.U[3,1]) * S2.U[:,1]
-        @test s1_left ≈ s2_left
-
-        ## 1st right singular vector
-        s1_right = sign(S1[1].V[3,1]) * S1[1].V[:,1]
-        s2_right = sign(S2.V[3,1]) * S2.V[:,1]
-        @test s1_right ≈ s2_right
-    end
-    # Issue number 10329
-    # Ensure singular values from svds are in
-    # the correct order
-    @testset "singular values ordered correctly" begin
-        B = sparse(Diagonal([1.0, 2.0, 34.0, 5.0, 6.0]))
-        S3 = svds(B, ritzvec=false, nsv=2)
-        @test S3[1].S ≈ [34.0, 6.0]
-        S4 = svds(B, nsv=2)
-        @test S4[1].S ≈ [34.0, 6.0]
-    end
-    @testset "passing guess for Krylov vectors" begin
-        S1 = svds(A, nsv = 2, v0=rand(eltype(A),size(A,2)))
-        @test S1[1].S ≈ S2.S[1:2]
-    end
-
-    @test_throws ArgumentError svds(A,nsv=0)
-    @test_throws ArgumentError svds(A,nsv=20)
-    @test_throws DimensionMismatch svds(A,nsv=2,v0=rand(size(A,2)+1))
-
-    @testset "Orthogonal vectors with repeated singular values $i times. Issue 16608" for i in 2:3
-        rng = MersenneTwister(126) # Fragile to compute repeated values without blocking so we set the seed
-        v0  = randn(rng, 20)
-        d   = sort(rand(rng, 20), rev = true)
-        for j in 2:i
-            d[j] = d[1]
-        end
-        A = qr(randn(rng, 20, 20)).Q*Diagonal(d)*qr(randn(rng, 20, 20)).Q
-        @testset "Number of singular values: $j" for j in 2:6
-            # Default size of subspace
-            F = svds(A, nsv = j, v0 = v0)
-            @test F[1].U'F[1].U ≈ Matrix(I, j, j)
-            @test F[1].V'F[1].V ≈ Matrix(I, j, j)
-            @test F[1].S        ≈ d[1:j]
-            for k in 3j:2:5j
-                # Custom size of subspace
-                F = svds(A, nsv = j, ncv = k, v0 = v0)
-                @test F[1].U'F[1].U ≈ Matrix(I, j, j)
-                @test F[1].V'F[1].V ≈ Matrix(I, j, j)
-                @test F[1].S        ≈ d[1:j]
-            end
-        end
-    end
-end
-
-@testset "complex svds" begin
-    A = sparse([1, 1, 2, 3, 4], [2, 1, 1, 3, 1], exp.(im*[2.0:2:10;]), 5, 4)
-    S1 = svds(A, nsv = 2)
-    S2 = svd(Array(A))
-
-    ## singular values match:
-    @test S1[1].S ≈ S2.S[1:2]
-    @testset "singular vectors" begin
-        ## left singular vectors
-        s1_left = abs.(S1[1].U[:,1:2])
-        s2_left = abs.(S2.U[:,1:2])
-        @test s1_left ≈ s2_left
-
-        ## right singular vectors
-        s1_right = abs.(S1[1].V[:,1:2])
-        s2_right = abs.(S2.V[:,1:2])
-        @test s1_right ≈ s2_right
-    end
-    @testset "passing guess for Krylov vectors" begin
-        S1 = svds(A, nsv = 2, v0=rand(eltype(A),size(A,2)))
-        @test S1[1].S ≈ S2.S[1:2]
-    end
-
-    @test_throws ArgumentError svds(A,nsv=0)
-    @test_throws ArgumentError svds(A,nsv=20)
-    @test_throws DimensionMismatch svds(A,nsv=2,v0=complex(rand(size(A,2)+1)))
-end
-
-@testset "promotion" begin
-    eigs(rand(1:10, 10, 10))
-    eigs(rand(1:10, 10, 10), rand(1:10, 10, 10) |> t -> t't)
-    svds(rand(1:10, 10, 8))
-    @test_throws MethodError eigs(big.(rand(1:10, 10, 10)))
-    @test_throws MethodError eigs(big.(rand(1:10, 10, 10)), rand(1:10, 10, 10))
-    @test_throws MethodError svds(big.(rand(1:10, 10, 8)))
-end
diff --git a/stdlib/Pkg/test/repl.jl b/stdlib/Pkg/test/repl.jl
index 18a6ba67ce041..4234a16dc8e6f 100644
--- a/stdlib/Pkg/test/repl.jl
+++ b/stdlib/Pkg/test/repl.jl
@@ -277,6 +277,10 @@ temp_pkg_dir() do project_path; cd(project_path) do
         cd(joinpath(tmp, "BigProject")) do
             try
                 pushfirst!(LOAD_PATH, Base.parse_load_path("@"))
+                pkg"dev SubModule"
+                pkg"dev SubModule2"
+                pkg"add Random"
+                pkg"add Example"
                 pkg"build"
                 @eval using BigProject
                 pkg"build BigProject"
@@ -285,21 +289,21 @@ temp_pkg_dir() do project_path; cd(project_path) do
                 pkg"test SubModule2"
                 pkg"test BigProject"
                 pkg"test"
-                current_json = Pkg.API.installed()["JSON"]
+                current_example = Pkg.API.installed()["Example"]
                 old_project = read("Project.toml", String)
                 open("Project.toml"; append=true) do io
                     print(io, """
 
                     [compat]
-                    JSON = "0.16.0"
+                    Example = "0.4.0"
                     """
                     )
                 end
                 pkg"up"
-                @test Pkg.API.installed()["JSON"].minor == 16
+                @test Pkg.API.installed()["Example"].minor == 4
                 write("Project.toml", old_project)
                 pkg"up"
-                @test Pkg.API.installed()["JSON"] == current_json
+                @test Pkg.API.installed()["Example"] ==     current_example
             finally
                 popfirst!(LOAD_PATH)
             end
diff --git a/stdlib/Pkg/test/test_packages/BigProject/.gitignore b/stdlib/Pkg/test/test_packages/BigProject/.gitignore
index 346892a9d027b..a4fd8a5830756 100644
--- a/stdlib/Pkg/test/test_packages/BigProject/.gitignore
+++ b/stdlib/Pkg/test/test_packages/BigProject/.gitignore
@@ -1 +1,2 @@
 deps/buildartifact
+Manifest.toml
\ No newline at end of file
diff --git a/stdlib/Pkg/test/test_packages/BigProject/Manifest.toml b/stdlib/Pkg/test/test_packages/BigProject/Manifest.toml
deleted file mode 100644
index b76939361e5dc..0000000000000
--- a/stdlib/Pkg/test/test_packages/BigProject/Manifest.toml
+++ /dev/null
@@ -1,96 +0,0 @@
-[[Base64]]
-uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
-
-[[Compat]]
-deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "IterativeEigensolvers", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "SuiteSparse", "Test", "UUIDs", "Unicode"]
-git-tree-sha1 = "e891dc2ba653107604985bc5ab7294d9de83630f"
-uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
-version = "0.66.0"
-
-[[Dates]]
-uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
-
-[[DelimitedFiles]]
-uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"
-
-[[Distributed]]
-uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"
-
-[[InteractiveUtils]]
-uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
-
-[[IterativeEigensolvers]]
-uuid = "de555fa4-b82f-55e7-8b71-53f60bbc027d"
-
-[[JSON]]
-deps = ["Compat", "Nullables", "Sockets", "Unicode"]
-git-tree-sha1 = "e2f6776e8bfd310b2ade13fba1faf99d8967d58f"
-uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
-version = "0.17.2"
-
-[[LibGit2]]
-uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
-
-[[Libdl]]
-uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
-
-[[LinearAlgebra]]
-uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-
-[[Markdown]]
-uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
-
-[[Mmap]]
-uuid = "a63ad114-7e13-5084-954f-fe012c677804"
-
-[[Nullables]]
-deps = ["Compat"]
-git-tree-sha1 = "23258f849603ad4fed3ce7dbcb8c0658920fa5ef"
-uuid = "4d1e1d77-625e-5b40-9113-a560ec7a8ecd"
-version = "0.0.5"
-
-[[Pkg]]
-uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
-
-[[Printf]]
-uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
-
-[[REPL]]
-uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
-
-[[Random]]
-uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-
-[[Serialization]]
-uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
-
-[[SharedArrays]]
-uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"
-
-[[Sockets]]
-uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
-
-[[SparseArrays]]
-uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
-
-[[SubModule]]
-path = "SubModule"
-uuid = "0d404dc8-25d6-11e8-300e-11c8e584fb95"
-version = "0.1.0"
-
-[[SubModule2]]
-path = "SubModule2"
-uuid = "2d3cad7e-26b9-11e8-3e8d-a543003d541d"
-version = "0.1.0"
-
-[[SuiteSparse]]
-uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
-
-[[Test]]
-uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-
-[[UUIDs]]
-uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
-
-[[Unicode]]
-uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
diff --git a/stdlib/Pkg/test/test_packages/BigProject/Project.toml b/stdlib/Pkg/test/test_packages/BigProject/Project.toml
index adf739620e6bb..bf694f7b4adbd 100644
--- a/stdlib/Pkg/test/test_packages/BigProject/Project.toml
+++ b/stdlib/Pkg/test/test_packages/BigProject/Project.toml
@@ -4,11 +4,6 @@ uuid = "da7e1942-2519-11e8-2822-f5508ce758f0"
 version = "0.1.0"
 
 [deps]
-JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
-Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-SubModule = "0d404dc8-25d6-11e8-300e-11c8e584fb95"
-SubModule2 = "2d3cad7e-26b9-11e8-3e8d-a543003d541d"
 
 [targets.test.deps]
-Example = "7876af07-990d-54b4-ab0e-23690620f79a"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/test/choosetests.jl b/test/choosetests.jl
index a05088fe7f57b..7614d42d6fffb 100644
--- a/test/choosetests.jl
+++ b/test/choosetests.jl
@@ -157,9 +157,6 @@ function choosetests(choices = [])
         filter!(x -> x != "rounding", tests)
     end
 
-    # The shift and invert solvers need SuiteSparse for sparse input
-    Base.USE_GPL_LIBS || filter!(x->x != "IterativeEigensolvers", STDLIBS)
-
     filter!(!in(skip_tests), tests)
 
     explicit_pkg     =  "OldPkg/pkg"        in tests
diff --git a/test/precompile.jl b/test/precompile.jl
index f11ecfafd4aca..cb3e190dcfa7e 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -224,7 +224,7 @@ try
                      Base.PkgId(m) => Base.module_build_id(m)
                  end for s in
                 [:Base64, :CRC32c, :Dates, :DelimitedFiles, :Distributed, :FileWatching, :Markdown,
-                 :Future, :IterativeEigensolvers, :Libdl, :LinearAlgebra, :Logging, :Mmap, :Printf,
+                 :Future, :Libdl, :LinearAlgebra, :Logging, :Mmap, :Printf,
                  :Profile, :Random, :Serialization, :SharedArrays, :SparseArrays, :SuiteSparse, :Test,
                  :Unicode, :REPL, :InteractiveUtils, :OldPkg, :Pkg, :LibGit2, :SHA, :UUIDs, :Sockets]))
         @test discard_module.(deps) == deps1