diff --git a/.github/workflows/linux-full-tests.yml b/.github/workflows/linux-full-tests.yml
index a99062e8d57..162f6288370 100644
--- a/.github/workflows/linux-full-tests.yml
+++ b/.github/workflows/linux-full-tests.yml
@@ -147,12 +147,6 @@ jobs:
             cxx: g++
             cxxflags: "-Wno-deprecated-declarations"
             configureflags: --disable-std-unique-ptr
-          - name: "Disposable re-enabled"
-            shortname: disposable
-            tag: rolling
-            cc: gcc
-            cxx: g++
-            configureflags: --enable-disposable
           - name: "Thread-safe observer enabled"
             shortname: threadsafe
             tag: rolling
diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
index ae669c7933b..5505dea78bf 100644
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -153,13 +153,6 @@ jobs:
             cxxflags: "-Wno-deprecated-declarations"
             configureflags: --disable-std-unique-ptr
             tests: true
-          - name: "Disposable re-enabled"
-            shortname: disposable
-            tag: rolling
-            cc: gcc
-            cxx: g++
-            configureflags: --enable-disposable
-            tests: true
           - name: "Thread-safe observer enabled"
             shortname: threadsafe
             tag: rolling
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2b93131110b..4d368d27483 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -57,7 +57,6 @@ option(QL_INSTALL_EXAMPLES "Install examples" ON)
 option(QL_INSTALL_TEST_SUITE "Install test suite" ON)
 option(QL_TAGGED_LAYOUT "Library names use layout tags" ${MSVC})
 option(QL_USE_CLANG_TIDY "Use clang-tidy when building" OFF)
-option(QL_USE_DISPOSABLE "Use the Disposable class template. Not needed for C++11" OFF)
 option(QL_USE_INDEXED_COUPON "Use indexed coupons instead of par coupons" OFF)
 option(QL_USE_STD_CLASSES "Enable all QL_USE_STD_ options" OFF)
 option(QL_USE_STD_SHARED_PTR "Use standard smart pointers instead of Boost ones" OFF)
diff --git a/Docs/pages/config.docs b/Docs/pages/config.docs
index aab2fb8b4ae..4fa8a3f4063 100644
--- a/Docs/pages/config.docs
+++ b/Docs/pages/config.docs
@@ -133,14 +133,6 @@
     are used instead of `boost::tuple`. If disabled (the
     default) the Boost facilities are used.
 
-    \code
-    #define QL_USE_DISPOSABLE
-    \endcode
-    If defined, the old `Disposable` class template is used; this
-    should be no longer necessary in C++11 and might interfere with
-    compiler optimizations. If disabled (the default) `Disposable<T>` is
-    still available but is just an alias to `T`.
-
     \code
     #define QL_ENABLE_PARALLEL_UNIT_TEST_RUNNER
     \endcode
diff --git a/Examples/GlobalOptimizer/GlobalOptimizer.cpp b/Examples/GlobalOptimizer/GlobalOptimizer.cpp
index dc973f3adac..daffe148e3a 100644
--- a/Examples/GlobalOptimizer/GlobalOptimizer.cpp
+++ b/Examples/GlobalOptimizer/GlobalOptimizer.cpp
@@ -65,7 +65,7 @@ Real ackley(const Array& x) {
     return M_E + 20.0 - 20.0*std::exp(p1)-std::exp(p2);
 }
 
-Disposable<Array> ackleyValues(const Array& x) {
+Array ackleyValues(const Array& x) {
     Array y(x.size());
     for (Size i = 0; i < x.size(); i++) {
         Real p1 = x[i] * x[i];
@@ -81,7 +81,7 @@ Real sphere(const Array& x) {
     return DotProduct(x, x);
 }
 
-Disposable<Array> sphereValues(const Array& x) {
+Array sphereValues(const Array& x) {
     Array y(x.size());
     for (Size i = 0; i < x.size(); i++) {
         y[i] = x[i]*x[i];
@@ -110,7 +110,7 @@ Real easom(const Array& x) {
     return -p1*std::exp(-p2);
 }
 
-Disposable<Array> easomValues(const Array& x) {
+Array easomValues(const Array& x) {
     Array y(x.size());
     for (Size i = 0; i < x.size(); i++) {
         Real p1 = std::cos(x[i]);
@@ -141,14 +141,14 @@ Real printFunction(Problem& p, const Array& x) {
 class TestFunction : public CostFunction {
 public:
     typedef ext::function<Real(const Array&)> RealFunc;
-    typedef ext::function<Disposable<Array>(const Array&)> ArrayFunc;
+    typedef ext::function<Array(const Array&)> ArrayFunc;
     explicit TestFunction(RealFunc f, ArrayFunc fs = ArrayFunc())
     : f_(std::move(f)), fs_(std::move(fs)) {}
-    explicit TestFunction(Real (*f)(const Array&), Disposable<Array> (*fs)(const Array&) = nullptr)
+    explicit TestFunction(Real (*f)(const Array&), Array (*fs)(const Array&) = nullptr)
     : f_(f), fs_(fs) {}
     ~TestFunction() override = default;
     Real value(const Array& x) const override { return f_(x); }
-    Disposable<Array> values(const Array& x) const override {
+    Array values(const Array& x) const override {
         if(!fs_)
             throw std::runtime_error("Invalid function");
         return fs_(x);
diff --git a/cmake/GenerateHeaders.cmake b/cmake/GenerateHeaders.cmake
index b050eb1db51..b25f7e8ce51 100644
--- a/cmake/GenerateHeaders.cmake
+++ b/cmake/GenerateHeaders.cmake
@@ -37,6 +37,7 @@ function(generate_dir_headers source_dir binary_dir)
     set(children_all "")
     file(GLOB children_hpp RELATIVE ${source_dir} "${source_dir}/*.hpp")
     list(FILTER children_hpp EXCLUDE REGEX "all.hpp")
+    list(FILTER children_hpp EXCLUDE REGEX "disposable.hpp")
     file(GLOB children_dir RELATIVE ${source_dir} "${source_dir}/*")
     list(FILTER children_dir EXCLUDE REGEX "CMakeFiles")
     list(FILTER children_dir EXCLUDE REGEX "^\\..*")
diff --git a/configure.ac b/configure.ac
index 5168c4ed463..bd1c3884b43 100644
--- a/configure.ac
+++ b/configure.ac
@@ -444,23 +444,6 @@ fi
 AC_MSG_RESULT([$ql_use_std_classes])
 
 
-AC_MSG_CHECKING([whether to enable the Disposable class template])
-AC_ARG_ENABLE([disposable],
-              AS_HELP_STRING([--enable-disposable],
-                             [If enabled, the Disposable class template will be used;
-                              this should be no longer necessary in C++11
-                              and might interfere with compiler optimizations.
-                              If disabled (the default) the class will only
-                              be an alias for the underlying type.]),
-              [ql_use_disposable=$enableval],
-              [ql_use_disposable=no])
-if test "$ql_use_disposable" = "yes" ; then
-   AC_DEFINE([QL_USE_DISPOSABLE],[1],
-             [Define this if you want to use the Disposable class template.])
-fi
-AC_MSG_RESULT([$ql_use_disposable])
-
-
 # manual configurations for specific hosts
 case $host in
   powerpc-apple-darwin*)
diff --git a/ql/config.hpp.cfg b/ql/config.hpp.cfg
index 53de8c0e95d..1a61f1fa98b 100644
--- a/ql/config.hpp.cfg
+++ b/ql/config.hpp.cfg
@@ -36,7 +36,6 @@
 #cmakedefine QL_ERROR_LINES
 #cmakedefine QL_EXTRA_SAFETY_CHECKS
 #cmakedefine QL_HIGH_RESOLUTION_DATE
-#cmakedefine QL_USE_DISPOSABLE
 #cmakedefine QL_USE_INDEXED_COUPON
 #cmakedefine QL_USE_STD_SHARED_PTR
 #cmakedefine QL_USE_STD_UNIQUE_PTR
diff --git a/ql/experimental/credit/basket.cpp b/ql/experimental/credit/basket.cpp
index 5e6f268dfdb..7c06aa3daf6 100644
--- a/ql/experimental/credit/basket.cpp
+++ b/ql/experimental/credit/basket.cpp
@@ -106,7 +106,7 @@ namespace QuantLib {
         return std::accumulate(notionals_.begin(), notionals_.end(), 0.0);
     }
 
-    Disposable<vector<Real> > Basket::probabilities(const Date& d) const {
+    vector<Real> Basket::probabilities(const Date& d) const {
         vector<Real> prob(size());
         vector<DefaultProbKey> defKeys = defaultKeys();
         for (Size j = 0; j < size(); j++)
@@ -168,8 +168,7 @@ namespace QuantLib {
         return evalDateRemainingNot_;
     }
 
-    Disposable<std::vector<Size> > 
-        Basket::liveList(const Date& endDate) const {
+    std::vector<Size> Basket::liveList(const Date& endDate) const {
         std::vector<Size> calcBufferLiveList;
         for (Size i = 0; i < size(); i++)
             if (!pool_->get(pool_->names()[i]).defaultedBetween(
@@ -193,8 +192,7 @@ namespace QuantLib {
         return notional;
     }
 
-    Disposable<vector<Real> > 
-        Basket::remainingNotionals(const Date& endDate) const 
+    vector<Real> Basket::remainingNotionals(const Date& endDate) const 
     {
         QL_REQUIRE(endDate >= refDate_, 
             "Target date lies before basket inception");
@@ -208,8 +206,7 @@ namespace QuantLib {
         return calcBufferNotionals;
     }
 
-    Disposable<std::vector<Probability> > 
-        Basket::remainingProbabilities(const Date& d) const 
+    std::vector<Probability> Basket::remainingProbabilities(const Date& d) const 
     {
         QL_REQUIRE(d >= refDate_, "Target date lies before basket inception");
         vector<Real> prob;
@@ -245,8 +242,7 @@ namespace QuantLib {
         //return positions_[position]->expectedExposure(d);
     }
 
-    Disposable<std::vector<std::string> >
-        Basket::remainingNames(const Date& endDate) const 
+    std::vector<std::string> Basket::remainingNames(const Date& endDate) const 
     {
         // maybe return zero directly instead?:
         QL_REQUIRE(endDate >= refDate_, 
@@ -260,8 +256,7 @@ namespace QuantLib {
         return calcBufferNames;
     }
 
-    Disposable<vector<DefaultProbKey> >
-        Basket::remainingDefaultKeys(const Date& endDate) const 
+    vector<DefaultProbKey> Basket::remainingDefaultKeys(const Date& endDate) const 
     {
         QL_REQUIRE(endDate >= refDate_,
             "Target date lies before basket inception");
@@ -329,8 +324,7 @@ namespace QuantLib {
         return cumulatedLoss() + lossModel_->expectedTrancheLoss(d);
     }
 
-    Disposable<std::vector<Real> > 
-        Basket::splitVaRLevel(const Date& date, Real loss) const {
+    std::vector<Real> Basket::splitVaRLevel(const Date& date, Real loss) const {
         calculate();
         return lossModel_->splitVaRLevel(date, loss);
     }
@@ -340,8 +334,7 @@ namespace QuantLib {
         return lossModel_->expectedShortfall(d, prob);
     }
 
-    Disposable<std::map<Real, Probability> > 
-        Basket::lossDistribution(const Date& d) const {
+    std::map<Real, Probability> Basket::lossDistribution(const Date& d) const {
         calculate();
         return lossModel_->lossDistribution(d);
     }
diff --git a/ql/experimental/credit/basket.hpp b/ql/experimental/credit/basket.hpp
index 973176f0d8d..3b768553b46 100644
--- a/ql/experimental/credit/basket.hpp
+++ b/ql/experimental/credit/basket.hpp
@@ -33,7 +33,6 @@
 #include <ql/experimental/credit/recoveryratemodel.hpp>
 #include <ql/experimental/credit/pool.hpp>
 #include <ql/experimental/credit/loss.hpp>
-#include <ql/utilities/disposable.hpp>
 
 namespace QuantLib {
 
@@ -103,7 +102,7 @@ namespace QuantLib {
         //! Underlying pool
         const ext::shared_ptr<Pool>& pool() const;
         //! The keys each counterparty enters the basket with (sensitive to)
-        Disposable<std::vector<DefaultProbKey> > defaultKeys() const;
+        std::vector<DefaultProbKey> defaultKeys() const;
         /*! Loss Given Default for all issuers/notionals based on
             expected recovery rates for the respective issuers.
         */
@@ -128,8 +127,7 @@ namespace QuantLib {
         /*! Vector of cumulative default probability to date d for all
             issuers in the basket.
         */
-        Disposable<std::vector<Probability> > 
-            probabilities(const Date& d) const;
+        std::vector<Probability> probabilities(const Date& d) const;
         /*! Realized basket losses between the reference date and the 
             calculation date, taking the actual recovery rates of loss events 
             into account. 
@@ -165,26 +163,23 @@ namespace QuantLib {
           reference date and the given date, recovery ignored.
         */
         const std::vector<Real>& remainingNotionals() const;
-        Disposable<std::vector<Real> > remainingNotionals(const Date&) const;
+        std::vector<Real> remainingNotionals(const Date&) const;
         /*! Vector of surviving issuers after defaults between the reference 
           basket date and the given (or evaluation) date.
         */
         const std::vector<std::string>& remainingNames() const;
-        Disposable<std::vector<std::string> > 
-            remainingNames(const Date&) const;
+        std::vector<std::string> remainingNames(const Date&) const;
         /*! Default keys of non defaulted counterparties
         */
         const std::vector<DefaultProbKey>& remainingDefaultKeys() const;
-        Disposable<std::vector<DefaultProbKey> > remainingDefaultKeys(
-            const Date&) const;
+        std::vector<DefaultProbKey> remainingDefaultKeys(const Date&) const;
         //! Number of counterparties alive on the requested date.
         Size remainingSize() const;
         Size remainingSize(const Date&) const;
         /*! Vector of cumulative default probability to date d for all
             issuers still (at the evaluation date) alive in the basket.
         */
-        Disposable<std::vector<Probability> > 
-            remainingProbabilities(const Date& d) const;
+        std::vector<Probability> remainingProbabilities(const Date& d) const;
         /*!
           Attachment amount of the equivalent (after defaults) remaining basket
           The remaining attachment amount is
@@ -222,7 +217,7 @@ namespace QuantLib {
         }
         //!Indexes of remaining names. Notice these are names and not positions.
         const std::vector<Size>& liveList() const;
-        Disposable<std::vector<Size> > liveList(const Date&) const;//?? keep?
+        std::vector<Size> liveList(const Date&) const;//?? keep?
         //! Assigns the default loss model to this basket. Resets calculations.
         void setLossModel(
             const ext::shared_ptr<DefaultLossModel>& lossModel);
@@ -246,12 +241,10 @@ namespace QuantLib {
         Real expectedShortfall(const Date& d, Probability prob) const;
         /* Split a portfolio loss along counterparties. Typically loss 
         corresponds to some percentile.*/
-        Disposable<std::vector<Real> > 
-            splitVaRLevel(const Date& date, Real loss) const;
+        std::vector<Real> splitVaRLevel(const Date& date, Real loss) const;
         /*! Full loss distribution
         */
-        Disposable<std::map<Real, Probability> > lossDistribution(
-            const Date&) const;
+        std::map<Real, Probability> lossDistribution(const Date&) const;
         Real densityTrancheLoss(const Date& d, Real lossFraction) const;
         Real defaultCorrelation(const Date& d, Size iName, Size jName) const;
         /*! Probability vector that each of the remaining live names (at eval
@@ -329,8 +322,7 @@ namespace QuantLib {
         return notionals_;
     }
 
-    inline Disposable<std::vector<DefaultProbKey> > 
-        Basket::defaultKeys() const {
+    inline std::vector<DefaultProbKey> Basket::defaultKeys() const {
         return pool_->defaultKeys();
     }
 
diff --git a/ql/experimental/credit/binomiallossmodel.hpp b/ql/experimental/credit/binomiallossmodel.hpp
index aac4e1ed625..902237a7450 100644
--- a/ql/experimental/credit/binomiallossmodel.hpp
+++ b/ql/experimental/credit/binomiallossmodel.hpp
@@ -78,8 +78,7 @@ namespace QuantLib {
         /*! Returns the probability of the default loss values given by the 
             method lossPoints.
         */
-        Disposable<std::vector<Real> > 
-            expectedDistribution(const Date& date) const {
+        std::vector<Real> expectedDistribution(const Date& date) const {
             // precal date conditional magnitudes:
             std::vector<Real> notionals = basket_->remainingNotionals(date);
             std::vector<Probability> invProbs = 
@@ -94,9 +93,9 @@ namespace QuantLib {
                 });
         }
         //! attainable loss points this model provides
-        Disposable<std::vector<Real> > lossPoints(const Date&) const;
+        std::vector<Real> lossPoints(const Date&) const;
         //! Returns the cumulative full loss distribution
-        Disposable<std::map<Real, Probability> > lossDistribution(const Date& d) const override;
+        std::map<Real, Probability> lossDistribution(const Date& d) const override;
         //! Loss level for this percentile
         Real percentile(const Date& d, Real percentile) const override;
         Real expectedShortfall(const Date& d, Real percentile) const override;
@@ -111,9 +110,8 @@ namespace QuantLib {
             const std::vector<Probability>& uncondDefProbs, 
             const std::vector<Real>&) const;
         // expected as in time-value, not average, see literature
-        Disposable<std::vector<Real> >
-            expConditionalLgd(const Date& d,
-                               const std::vector<Real>& mktFactors) const
+        std::vector<Real> expConditionalLgd(const Date& d,
+                                            const std::vector<Real>& mktFactors) const
         {
             std::vector<Real> condLgds;
             const std::vector<Size>& evalDateLives = basket_->liveList();
@@ -125,8 +123,7 @@ namespace QuantLib {
 
         //! Loss probability density conditional on the market factor value.
         // Heres where the burden of the algorithm setup lies.
-        Disposable<std::vector<Real> > 
-            lossProbability(      
+        std::vector<Real> lossProbability(      
                 const Date& date,
                 // expected exposures at the passed date, no wrong way means
                 //  no dependence of the exposure with the mkt factor 
@@ -148,7 +145,7 @@ namespace QuantLib {
         distribution of a given number of defaults.
     */
     template< class LLM>
-    Disposable<std::vector<Real> > BinomialLossModel<LLM>::lossProbability(
+    std::vector<Real> BinomialLossModel<LLM>::lossProbability(
         const Date& date, 
         const std::vector<Real>& bsktNots,
         const std::vector<Real>& uncondDefProbInv, 
@@ -273,8 +270,7 @@ namespace QuantLib {
     }
 
     template< class LLM>
-    Disposable<std::vector<Real> >
-        BinomialLossModel<LLM>::lossPoints(const Date& d) const 
+    std::vector<Real> BinomialLossModel<LLM>::lossPoints(const Date& d) const 
     {
         std::vector<Real> notionals = basket_->remainingNotionals(d);
 
@@ -331,8 +327,7 @@ namespace QuantLib {
 
 
     template< class LLM>
-    Disposable<std::map<Real, Probability> > 
-        BinomialLossModel<LLM>::lossDistribution(const Date& d) const 
+    std::map<Real, Probability> BinomialLossModel<LLM>::lossDistribution(const Date& d) const 
     {
         std::map<Real, Probability> distrib;
         std::vector<Real> lossPts = lossPoints(d);
diff --git a/ql/experimental/credit/constantlosslatentmodel.hpp b/ql/experimental/credit/constantlosslatentmodel.hpp
index 1b93e335479..c289d2ba041 100644
--- a/ql/experimental/credit/constantlosslatentmodel.hpp
+++ b/ql/experimental/credit/constantlosslatentmodel.hpp
@@ -140,7 +140,7 @@ namespace QuantLib {
             integralType, nVariables,ini) {}
 
     protected:
-        //Disposable<std::vector<Probability> > probsBeingNthEvent(
+        //std::vector<Probability> probsBeingNthEvent(
         //    Size n, const Date& d) const {
         //    return 
         //      ConstantLossLatentmodel<copulaPolicy>::probsBeingNthEvent(n, d);
diff --git a/ql/experimental/credit/defaultlossmodel.hpp b/ql/experimental/credit/defaultlossmodel.hpp
index c545e3f31ce..4cb44b5ba70 100644
--- a/ql/experimental/credit/defaultlossmodel.hpp
+++ b/ql/experimental/credit/defaultlossmodel.hpp
@@ -23,7 +23,6 @@
 
 #include <ql/instruments/claim.hpp>
 #include <ql/experimental/credit/defaultprobabilitykey.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <ql/experimental/credit/basket.hpp>
 
 #include <ql/utilities/null_deleter.hpp>
@@ -87,21 +86,18 @@ namespace QuantLib {
             QL_FAIL("eSF Not implemented for this model.");   
         }
         //! Associated VaR fraction to each counterparty.
-        virtual Disposable<std::vector<Real> >
-            splitVaRLevel(const Date& d, Real loss) const {
+        virtual std::vector<Real> splitVaRLevel(const Date& d, Real loss) const {
             QL_FAIL("splitVaRLevel Not implemented for this model.");   
         }
         //! Associated ESF fraction to each counterparty.
-        virtual Disposable<std::vector<Real> >
-            splitESFLevel(const Date& d, Real loss) const {
+        virtual std::vector<Real> splitESFLevel(const Date& d, Real loss) const {
             QL_FAIL("splitESFLevel Not implemented for this model.");   
         }
 
         // \todo Add splits by instrument position.
 
         //! Full loss distribution.
-        virtual Disposable<std::map<Real, Probability> > 
-            lossDistribution(const Date&) const {
+        virtual std::map<Real, Probability> lossDistribution(const Date&) const {
             QL_FAIL("lossDistribution Not implemented for this model.");   
         }
         //! Probability density of a given loss fraction of the basket notional.
@@ -116,8 +112,7 @@ namespace QuantLib {
             The the probabilities ordering in the vector coincides with the 
             pool order.
         */
-        virtual Disposable<std::vector<Probability> > probsBeingNthEvent(
-            Size n, const Date& d) const {
+        virtual std::vector<Probability> probsBeingNthEvent(Size n, const Date& d) const {
             QL_FAIL("probsBeingNthEvent Not implemented for this model.");
         }
         //! Pearsons' default probability correlation. 
diff --git a/ql/experimental/credit/pool.cpp b/ql/experimental/credit/pool.cpp
index 9ec546627c0..7f6dd363f7b 100644
--- a/ql/experimental/credit/pool.cpp
+++ b/ql/experimental/credit/pool.cpp
@@ -74,7 +74,7 @@ namespace QuantLib {
         return names_;
     }
 
-    Disposable<std::vector<DefaultProbKey> > Pool::defaultKeys() const {
+    std::vector<DefaultProbKey> Pool::defaultKeys() const {
         std::vector<DefaultProbKey> defaultKeys;
         defaultKeys.reserve(defaultKeys_.size());
         for (const auto & i : defaultKeys_)
diff --git a/ql/experimental/credit/pool.hpp b/ql/experimental/credit/pool.hpp
index 157fdc9b875..e9f3c0f5b10 100644
--- a/ql/experimental/credit/pool.hpp
+++ b/ql/experimental/credit/pool.hpp
@@ -24,7 +24,6 @@
 #ifndef quantlib_pool_hpp
 #define quantlib_pool_hpp
 
-#include <ql/utilities/disposable.hpp>
 #include <ql/experimental/credit/issuer.hpp>
 #include <map>
 
@@ -44,7 +43,7 @@ namespace QuantLib {
         void setTime(const std::string& name, Real time);
         Real getTime (const std::string& name) const;
         const std::vector<std::string>& names() const;
-        Disposable<std::vector<DefaultProbKey> > defaultKeys() const;
+        std::vector<DefaultProbKey> defaultKeys() const;
     private:
         // \todo: needs to cehck all defaul TS have the same ref date? here or
         //   where used? e.g. simulations.
diff --git a/ql/experimental/credit/randomdefaultlatentmodel.hpp b/ql/experimental/credit/randomdefaultlatentmodel.hpp
index 63ca1a654d3..ff3eac7f5f7 100644
--- a/ql/experimental/credit/randomdefaultlatentmodel.hpp
+++ b/ql/experimental/credit/randomdefaultlatentmodel.hpp
@@ -170,14 +170,13 @@ namespace QuantLib {
         Chen, Z., Glasserman, P. 'Fast pricing of basket default swaps' in
         Operations Research Vol. 56, No. 2, March/April 2008, pp. 286-303
         */
-        Disposable<std::vector<Probability> > probsBeingNthEvent(Size n,
-                                                                 const Date& d) const override;
+        std::vector<Probability> probsBeingNthEvent(Size n, const Date& d) const override;
         //! Pearsons' default probability correlation.
         Real defaultCorrelation(const Date& d, Size iName, Size jName) const override;
         Real expectedTrancheLoss(const Date& d) const override;
         virtual std::pair<Real, Real> expectedTrancheLossInterval(const Date& d,
             Probability confidencePerc) const;
-        Disposable<std::map<Real, Probability> > lossDistribution(const Date& d) const override;
+        std::map<Real, Probability> lossDistribution(const Date& d) const override;
         virtual Histogram computeHistogram(const Date& d) const;
         Real expectedShortfall(const Date& d, Real percent) const override;
         Real percentile(const Date& d, Real percentile) const override;
@@ -188,7 +187,7 @@ namespace QuantLib {
         /*! Distributes the total VaR amount along the portfolio counterparties.
             The passed loss amount is in loss units.
         */
-        Disposable<std::vector<Real> > splitVaRLevel(const Date& date, Real loss) const override;
+        std::vector<Real> splitVaRLevel(const Date& date, Real loss) const override;
         /*! Distributes the total VaR amount along the portfolio
             counterparties.
 
@@ -197,7 +196,7 @@ namespace QuantLib {
 
             The passed loss amount is in loss units.
         */
-        virtual Disposable<std::vector<std::vector<Real> > > splitVaRAndError(
+        virtual std::vector<std::vector<Real> > splitVaRAndError(
             const Date& date, Real loss, Probability confInterval) const;
         //@}
     public:
@@ -253,9 +252,8 @@ namespace QuantLib {
     }
 
     template<template <class, class> class D, class C, class URNG>
-    Disposable<std::vector<Probability> >
-        RandomLM<D, C, URNG>::probsBeingNthEvent(Size n,
-            const Date& d) const
+    std::vector<Probability> RandomLM<D, C, URNG>::probsBeingNthEvent(Size n,
+                                                                      const Date& d) const
     {
         calculate();
         Size basketSize = basket_->size();
@@ -384,8 +382,7 @@ namespace QuantLib {
 
 
     template<template <class, class> class D, class C, class URNG>
-    Disposable<std::map<Real, Probability> >
-        RandomLM<D, C, URNG>::lossDistribution(const Date& d) const {
+    std::map<Real, Probability> RandomLM<D, C, URNG>::lossDistribution(const Date& d) const {
 
         Histogram hist = computeHistogram(d);
         std::map<Real, Probability> distrib;
@@ -539,9 +536,8 @@ namespace QuantLib {
     of the stimator just computed. See the reference for a discussion.
     */
     template<template <class, class> class D, class C, class URNG>
-    ext::tuple<Real, Real, Real> // disposable?
-        RandomLM<D, C, URNG>::percentileAndInterval(const Date& d,
-            Real percentile) const {
+    ext::tuple<Real, Real, Real> RandomLM<D, C, URNG>::percentileAndInterval(const Date& d,
+                                                                             Real percentile) const {
 
         QL_REQUIRE(percentile >= 0. && percentile <= 1.,
             "Incorrect percentile");
@@ -623,7 +619,7 @@ namespace QuantLib {
 
 
     template<template <class, class> class D, class C, class URNG>
-    Disposable<std::vector<Real> > RandomLM<D, C, URNG>::splitVaRLevel(
+    std::vector<Real> RandomLM<D, C, URNG>::splitVaRLevel(
         const Date& date, Real loss) const
     {
         std::vector<Real> varLevels = splitVaRAndError(date, loss, 0.95)[0];
@@ -638,9 +634,8 @@ namespace QuantLib {
     template<template <class, class> class D, class C, class URNG>
     /* FIX ME: some trouble on limit cases, like zero loss or no losses over the
     requested level.*/
-    Disposable<std::vector<std::vector<Real> > >
-        RandomLM<D, C, URNG>::splitVaRAndError(const Date& date, Real loss,
-            Probability confInterval) const
+    std::vector<std::vector<Real> > RandomLM<D, C, URNG>::splitVaRAndError(const Date& date, Real loss,
+                                                                           Probability confInterval) const
     {
         /* Check 'loss' value integrity: i.e. is within tranche limits? (should
             have been done basket...)*/
diff --git a/ql/experimental/credit/recursivelossmodel.hpp b/ql/experimental/credit/recursivelossmodel.hpp
index a6786cb869b..0ba05ca4112 100644
--- a/ql/experimental/credit/recursivelossmodel.hpp
+++ b/ql/experimental/credit/recursivelossmodel.hpp
@@ -59,19 +59,17 @@ namespace QuantLib {
       the date for performance reasons (if in the future other magnitudes
       -e.g. lgd- are contingent on the date they shouldd be passed too).
       */
-      Disposable<std::map<Real, Probability> >
-      conditionalLossDistrib(const std::vector<Probability>& pDefDate,
-                             const std::vector<Real>& mktFactor) const;
+      std::map<Real, Probability> conditionalLossDistrib(const std::vector<Probability>& pDefDate,
+                                                         const std::vector<Real>& mktFactor) const;
       Real expectedConditionalLoss(const std::vector<Probability>& pDefDate, //<< never used!!
                                    const std::vector<Real>& mktFactor) const;
-      Disposable<std::vector<Real> > conditionalLossProb(const std::vector<Probability>& pDefDate,
-                                                         // const Date& date,
-                                                         const std::vector<Real>& mktFactor) const;
+      std::vector<Real> conditionalLossProb(const std::vector<Probability>& pDefDate,
+                                            // const Date& date,
+                                            const std::vector<Real>& mktFactor) const;
       // versions using the P-inverse, deprecate the former
-      Disposable<std::map<Real, Probability> >
-      conditionalLossDistribInvP(const std::vector<Real>& pDefDate,
-                                 // const Date& date,
-                                 const std::vector<Real>& mktFactor) const;
+      std::map<Real, Probability> conditionalLossDistribInvP(const std::vector<Real>& pDefDate,
+                                                             // const Date& date,
+                                                             const std::vector<Real>& mktFactor) const;
       Real expectedConditionalLossInvP(const std::vector<Real>& pDefDate,
                                        // const Date& date,
                                        const std::vector<Real>& mktFactor) const;
@@ -95,9 +93,9 @@ namespace QuantLib {
             makes it easier this way.
         */
       Real expectedTrancheLoss(const Date& date) const override;
-      Disposable<std::vector<Real> > lossProbability(const Date& date) const;
+      std::vector<Real> lossProbability(const Date& date) const;
       // REMEBER THIS HAS TO BE MOVED TO A DISTRIBUTION OBJECT.............
-      Disposable<std::map<Real, Probability> > lossDistribution(const Date& d) const override;
+      std::map<Real, Probability> lossDistribution(const Date& d) const override;
       // INTEGRATE THEN SEARCH RATHER THAN SEARCH AND THEN INTEGRATE:
       // Here I am not using a search because the point might not be attainable
       //  (loss distrib is not continuous)
@@ -177,8 +175,7 @@ namespace QuantLib {
     }
 
     template<class CP>
-    inline Disposable<std::vector<Real> > 
-    RecursiveLossModel<CP>::lossProbability(const Date& date) const {
+    inline std::vector<Real> RecursiveLossModel<CP>::lossProbability(const Date& date) const {
 
         std::vector<Probability> uncDefProb = 
             basket_->remainingProbabilities(date);
@@ -216,8 +213,7 @@ namespace QuantLib {
 
     // make it return a distribution object?
     template<class CP>
-    Disposable<std::map<Real, Probability> > 
-        RecursiveLossModel<CP>::lossDistribution(const Date& d) const 
+    std::map<Real, Probability> RecursiveLossModel<CP>::lossDistribution(const Date& d) const 
     {
         std::map<Real, Probability> distrib;
         std::vector<Real> values  = lossProbability(d);
@@ -303,8 +299,7 @@ namespace QuantLib {
     }
 
     template<class CP>
-    Disposable<std::map<Real, Probability> >
-        RecursiveLossModel<CP>::conditionalLossDistrib(
+    std::map<Real, Probability> RecursiveLossModel<CP>::conditionalLossDistrib(
             const std::vector<Probability>& pDefDate, 
             //const Date& date,
             const std::vector<Real>& mktFactor) const 
@@ -350,10 +345,9 @@ namespace QuantLib {
         return pIndepDistrib;
     }
 
+    // twice?! rewrite one in terms of the other, this is a duplicate!
     template<class CP>
-    Disposable<std::map<Real, Probability> >
-        // twice?! rewrite one in terms of the other, this is a duplicate!
-        RecursiveLossModel<CP>::conditionalLossDistribInvP(
+    std::map<Real, Probability> RecursiveLossModel<CP>::conditionalLossDistribInvP(
             const std::vector<Real>& invpDefDate, 
             //const Date& date,
             const std::vector<Real>& mktFactor) const 
@@ -472,7 +466,7 @@ namespace QuantLib {
     }
 
     template<class CP>
-    Disposable<std::vector<Real> > RecursiveLossModel<CP>::conditionalLossProb(
+    std::vector<Real> RecursiveLossModel<CP>::conditionalLossProb(
         const std::vector<Probability>& pDefDate, 
         //const Date& date,
         const std::vector<Real>& mktFactor) const 
diff --git a/ql/experimental/credit/saddlepointlossmodel.hpp b/ql/experimental/credit/saddlepointlossmodel.hpp
index e5475d79f29..9ed2d96df93 100644
--- a/ql/experimental/credit/saddlepointlossmodel.hpp
+++ b/ql/experimental/credit/saddlepointlossmodel.hpp
@@ -263,7 +263,7 @@ namespace QuantLib {
     public:
       Probability probOverLoss(const Date& d, Real trancheLossFract) const override;
 
-      Disposable<std::map<Real, Probability> > lossDistribution(const Date& d) const override;
+      std::map<Real, Probability> lossDistribution(const Date& d) const override;
 
     protected:
         /*! 
@@ -297,7 +297,7 @@ namespace QuantLib {
     public:
         Probability probDensity(const Date& d, Real loss) const;
     protected:
-        Disposable<std::vector<Real> > splitLossCond(
+        std::vector<Real> splitLossCond(
             const std::vector<Real>& invUncondProbs,
             Real loss, std::vector<Real> mktFactor) const;
         Real expectedShortfallFullPortfolioCond(
@@ -307,7 +307,7 @@ namespace QuantLib {
             const std::vector<Real>& invUncondProbs,
             Real lossPerc, Probability percentile, 
             const std::vector<Real>& mktFactor) const;
-        Disposable<std::vector<Real> > expectedShortfallSplitCond(
+        std::vector<Real> expectedShortfallSplitCond(
             const std::vector<Real>& invUncondProbs,
             Real lossPerc, const std::vector<Real>& mktFactor) const;
     public:
@@ -324,7 +324,7 @@ namespace QuantLib {
             The passed loss is the loss amount level at which we want
             to request the sensitivity. Equivalent to a percentile.
         */
-      Disposable<std::vector<Real> > splitVaRLevel(const Date& date, Real loss) const override;
+      std::vector<Real> splitVaRLevel(const Date& date, Real loss) const override;
       Real expectedShortfall(const Date& d, Probability percentile) const override;
 
     protected:
@@ -533,8 +533,7 @@ namespace QuantLib {
     }
 
     template<class CP>
-    inline Disposable<std::vector<Real> > 
-    SaddlePointLossModel<CP>::splitVaRLevel(const Date& date, Real s) const 
+    inline std::vector<Real> SaddlePointLossModel<CP>::splitVaRLevel(const Date& date, Real s) const 
     {
         std::vector<Real> invUncondProbs = 
             basket_->remainingProbabilities(date);
@@ -697,8 +696,7 @@ namespace QuantLib {
     }
 
     template<class CP>
-    ext::tuple<Real, Real, Real, Real> /// DISPOSABLE????
-        SaddlePointLossModel<CP>::CumGen0234DerivCond(
+    ext::tuple<Real, Real, Real, Real> SaddlePointLossModel<CP>::CumGen0234DerivCond(
         const std::vector<Real>& invUncondProbs,
         Real saddle, 
         const std::vector<Real>&  mktFactor) const 
@@ -740,8 +738,7 @@ namespace QuantLib {
     }
 
     template<class CP>
-    ext::tuple<Real, Real> /// DISPOSABLE???? 
-        SaddlePointLossModel<CP>::CumGen02DerivCond(
+    ext::tuple<Real, Real> SaddlePointLossModel<CP>::CumGen02DerivCond(
         const std::vector<Real>& invUncondProbs,
         Real saddle, 
         const std::vector<Real>&  mktFactor) const 
@@ -896,8 +893,7 @@ namespace QuantLib {
     }
 
     template<class CP>
-    Disposable<std::map<Real, Probability> > 
-        SaddlePointLossModel<CP>::lossDistribution(const Date& d) const {
+    std::map<Real, Probability> SaddlePointLossModel<CP>::lossDistribution(const Date& d) const {
         std::map<Real, Probability> distrib;
         static const Real numPts = 500.;
         for(Real lossFraction=1./numPts; lossFraction<0.45; 
@@ -1128,7 +1124,7 @@ namespace QuantLib {
     request the sensitivity.  Equivalent to a percentile.
     */
     template<class CP>
-    Disposable<std::vector<Real> > SaddlePointLossModel<CP>::splitLossCond(
+    std::vector<Real> SaddlePointLossModel<CP>::splitLossCond(
         const std::vector<Real>& invUncondProbs,
         Real loss, 
         std::vector<Real> mktFactor) const 
@@ -1196,8 +1192,7 @@ namespace QuantLib {
     }
 
     template<class CP>
-    Disposable<std::vector<Real> > 
-        SaddlePointLossModel<CP>::expectedShortfallSplitCond(
+    std::vector<Real> SaddlePointLossModel<CP>::expectedShortfallSplitCond(
             const std::vector<Real>& invUncondProbs,
             Real lossPerc, const std::vector<Real>& mktFactor) const 
     {
diff --git a/ql/experimental/credit/syntheticcdo.cpp b/ql/experimental/credit/syntheticcdo.cpp
index 55163fc9c58..20cfd62dd63 100644
--- a/ql/experimental/credit/syntheticcdo.cpp
+++ b/ql/experimental/credit/syntheticcdo.cpp
@@ -117,7 +117,7 @@ namespace QuantLib {
         return (protectionValue_ - premiumValue_) / remainingNotional_;
     }
 
-    Disposable<vector<Real> > SyntheticCDO::expectedTrancheLoss() const {
+    std::vector<Real> SyntheticCDO::expectedTrancheLoss() const {
         calculate();
         return expectedTrancheLoss_;
     }
diff --git a/ql/experimental/credit/syntheticcdo.hpp b/ql/experimental/credit/syntheticcdo.hpp
index 7c7f48bce90..378785645ba 100644
--- a/ql/experimental/credit/syntheticcdo.hpp
+++ b/ql/experimental/credit/syntheticcdo.hpp
@@ -161,7 +161,7 @@ namespace QuantLib {
         /*!
           Expected tranche loss for all payment dates
          */
-        Disposable<std::vector<Real> > expectedTrancheLoss() const;
+        std::vector<Real> expectedTrancheLoss() const;
         Size error () const;
 
         void setupArguments(PricingEngine::arguments*) const override;
diff --git a/ql/experimental/finitedifferences/fdmblackscholesfwdop.cpp b/ql/experimental/finitedifferences/fdmblackscholesfwdop.cpp
index 932f5c35652..b65aad39c99 100644
--- a/ql/experimental/finitedifferences/fdmblackscholesfwdop.cpp
+++ b/ql/experimental/finitedifferences/fdmblackscholesfwdop.cpp
@@ -87,44 +87,39 @@ namespace QuantLib {
 
     Size FdmBlackScholesFwdOp::size() const { return 1U; }
 
-    Disposable<Array> FdmBlackScholesFwdOp::apply(const Array& u) const {
+    Array FdmBlackScholesFwdOp::apply(const Array& u) const {
         return mapT_.apply(u);
     }
 
-    Disposable<Array> FdmBlackScholesFwdOp::apply_direction(
+    Array FdmBlackScholesFwdOp::apply_direction(
         Size direction, const Array& r) const {
         if (direction == direction_)
             return mapT_.apply(r);
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array> FdmBlackScholesFwdOp::apply_mixed(const Array& r) const {
-        Array retVal(r.size(), 0.0);
-        return retVal;
+    Array FdmBlackScholesFwdOp::apply_mixed(const Array& r) const {
+        return Array(r.size(), 0.0);
     }
 
-    Disposable<Array> FdmBlackScholesFwdOp::solve_splitting(
+    Array FdmBlackScholesFwdOp::solve_splitting(
         Size direction, const Array& r, Real dt) const {
         if (direction == direction_)
             return mapT_.solve_splitting(r, dt, 1.0);
         else {
-            Array retVal(r);
-            return retVal;
+            return r;
         }
     }
 
-    Disposable<Array> FdmBlackScholesFwdOp::preconditioner(
+    Array FdmBlackScholesFwdOp::preconditioner(
         const Array& r, Real dt) const {
         return solve_splitting(direction_, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmBlackScholesFwdOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(1, mapT_.toMatrix());
-        return retVal;
+    std::vector<SparseMatrix> FdmBlackScholesFwdOp::toMatrixDecomp() const {
+        return std::vector<SparseMatrix>(1, mapT_.toMatrix());
     }
 
 }
diff --git a/ql/experimental/finitedifferences/fdmblackscholesfwdop.hpp b/ql/experimental/finitedifferences/fdmblackscholesfwdop.hpp
index 072a35a1dfc..5d76b78b9fd 100644
--- a/ql/experimental/finitedifferences/fdmblackscholesfwdop.hpp
+++ b/ql/experimental/finitedifferences/fdmblackscholesfwdop.hpp
@@ -46,13 +46,13 @@ class FdmBlackScholesFwdOp : public FdmLinearOpComposite {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
       private:
         const ext::shared_ptr<FdmMesher> mesher_;
         const ext::shared_ptr<YieldTermStructure> rTS_, qTS_;
diff --git a/ql/experimental/finitedifferences/fdmdupire1dop.cpp b/ql/experimental/finitedifferences/fdmdupire1dop.cpp
index e270c005829..f57a0e816e8 100644
--- a/ql/experimental/finitedifferences/fdmdupire1dop.cpp
+++ b/ql/experimental/finitedifferences/fdmdupire1dop.cpp
@@ -33,40 +33,34 @@ void FdmDupire1dOp::setTime(Time t1, Time t2) {}
 
 Size FdmDupire1dOp::size() const { return 1; }
 
-Disposable<Array> FdmDupire1dOp::apply(const Array &u) const {
+Array FdmDupire1dOp::apply(const Array &u) const {
     return mapT_.apply(u);
 }
 
-Disposable<Array> FdmDupire1dOp::apply_direction(Size direction,
-                                                 const Array &r) const {
+Array FdmDupire1dOp::apply_direction(Size direction, const Array &r) const {
     if (direction == 0)
         return mapT_.apply(r);
     QL_FAIL("direction too large");
 }
 
-Disposable<Array> FdmDupire1dOp::apply_mixed(const Array &r) const {
-    Array s(r);
-    return s;
+Array FdmDupire1dOp::apply_mixed(const Array &r) const {
+    return r;
 }
 
-Disposable<Array> FdmDupire1dOp::solve_splitting(Size direction, const Array &r,
-                                                 Real a) const {
-
+Array FdmDupire1dOp::solve_splitting(Size direction, const Array &r, Real a) const {
     if (direction == 0) {
         return mapT_.solve_splitting(r, a, 1.0);
     }
     QL_FAIL("direction too large");
 }
 
-Disposable<Array> FdmDupire1dOp::preconditioner(const Array &r, Real dt) const {
+Array FdmDupire1dOp::preconditioner(const Array &r, Real dt) const {
 
     return solve_splitting(0, r, dt);
 }
 
-Disposable<std::vector<SparseMatrix> > FdmDupire1dOp::toMatrixDecomp() const {
-    std::vector<SparseMatrix> retVal(1);
-    retVal[0] = mapT_.toMatrix();
-    return retVal;
+std::vector<SparseMatrix> FdmDupire1dOp::toMatrixDecomp() const {
+    return std::vector<SparseMatrix>(1, mapT_.toMatrix());
 }
 
 }
diff --git a/ql/experimental/finitedifferences/fdmdupire1dop.hpp b/ql/experimental/finitedifferences/fdmdupire1dop.hpp
index a2f4afbd9e0..715f63d5ef2 100644
--- a/ql/experimental/finitedifferences/fdmdupire1dop.hpp
+++ b/ql/experimental/finitedifferences/fdmdupire1dop.hpp
@@ -40,14 +40,14 @@ class FdmDupire1dOp : public FdmLinearOpComposite {
     Size size() const override;
     void setTime(Time t1, Time t2) override;
 
-    Disposable<Array> apply(const Array& r) const override;
-    Disposable<Array> apply_mixed(const Array& r) const override;
+    Array apply(const Array& r) const override;
+    Array apply_mixed(const Array& r) const override;
 
-    Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-    Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-    Disposable<Array> preconditioner(const Array& r, Real s) const override;
+    Array apply_direction(Size direction, const Array& r) const override;
+    Array solve_splitting(Size direction, const Array& r, Real s) const override;
+    Array preconditioner(const Array& r, Real s) const override;
 
-    Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+    std::vector<SparseMatrix> toMatrixDecomp() const override;
 
   private:
     const ext::shared_ptr<FdmMesher> mesher_;
diff --git a/ql/experimental/finitedifferences/fdmextendedornsteinuhlenbeckop.cpp b/ql/experimental/finitedifferences/fdmextendedornsteinuhlenbeckop.cpp
index cbfb6ed88bc..bd8d5a3f812 100644
--- a/ql/experimental/finitedifferences/fdmextendedornsteinuhlenbeckop.cpp
+++ b/ql/experimental/finitedifferences/fdmextendedornsteinuhlenbeckop.cpp
@@ -64,48 +64,41 @@ namespace QuantLib {
         mapX_.axpyb(drift, dxMap_, dxxMap_, Array(1, -r));
     }
 
-    Disposable<Array> FdmExtendedOrnsteinUhlenbeckOp::apply(
-                                                    const Array& r) const {
+    Array FdmExtendedOrnsteinUhlenbeckOp::apply(const Array& r) const {
         return mapX_.apply(r);
     }
 
-    Disposable<Array> FdmExtendedOrnsteinUhlenbeckOp::apply_mixed(
-                                                    const Array& r) const {
-        Array retVal(r.size(), 0.0);
-        return retVal;
+    Array FdmExtendedOrnsteinUhlenbeckOp::apply_mixed(const Array& r) const {
+        return Array(r.size(), 0.0);
     }
 
-    Disposable<Array> FdmExtendedOrnsteinUhlenbeckOp::apply_direction(
+    Array FdmExtendedOrnsteinUhlenbeckOp::apply_direction(
                                     Size direction, const Array& r) const {
         if (direction == direction_) {
             return mapX_.apply(r);
         }
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array> FdmExtendedOrnsteinUhlenbeckOp::solve_splitting(
+    Array FdmExtendedOrnsteinUhlenbeckOp::solve_splitting(
                             Size direction, const Array& r, Real a) const {
         if (direction == direction_) {
             return mapX_.solve_splitting(r, a, 1.0);
         }
         else {
-            Array retVal(r);
-            return retVal;
+            return r;
         }
     }
 
-    Disposable<Array> FdmExtendedOrnsteinUhlenbeckOp::preconditioner(
+    Array FdmExtendedOrnsteinUhlenbeckOp::preconditioner(
                                             const Array& r, Real dt) const {
         return solve_splitting(direction_, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmExtendedOrnsteinUhlenbeckOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(1, mapX_.toMatrix());
-        return retVal;
+    std::vector<SparseMatrix> FdmExtendedOrnsteinUhlenbeckOp::toMatrixDecomp() const {
+        return std::vector<SparseMatrix>(1, mapX_.toMatrix());
     }
 
 }
diff --git a/ql/experimental/finitedifferences/fdmextendedornsteinuhlenbeckop.hpp b/ql/experimental/finitedifferences/fdmextendedornsteinuhlenbeckop.hpp
index 9013f870469..114c31f00ee 100644
--- a/ql/experimental/finitedifferences/fdmextendedornsteinuhlenbeckop.hpp
+++ b/ql/experimental/finitedifferences/fdmextendedornsteinuhlenbeckop.hpp
@@ -47,14 +47,14 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const ext::shared_ptr<FdmMesher> mesher_;
diff --git a/ql/experimental/finitedifferences/fdmextoujumpop.cpp b/ql/experimental/finitedifferences/fdmextoujumpop.cpp
index b332a75e6e2..1baf7a14129 100644
--- a/ql/experimental/finitedifferences/fdmextoujumpop.cpp
+++ b/ql/experimental/finitedifferences/fdmextoujumpop.cpp
@@ -125,29 +125,27 @@ namespace QuantLib {
         ouOp_->setTime(t1, t2);
     }
 
-    Disposable<Array> FdmExtOUJumpOp::apply(const Array& r) const {
+    Array FdmExtOUJumpOp::apply(const Array& r) const {
         return ouOp_->apply(r) + dyMap_.apply(r) + integro(r);
     }
 
-    Disposable<Array> FdmExtOUJumpOp::apply_mixed(const Array& r) const {
-        return  integro(r);
+    Array FdmExtOUJumpOp::apply_mixed(const Array& r) const {
+        return integro(r);
     }
 
-    Disposable<Array> FdmExtOUJumpOp::apply_direction(Size direction,
-                                                      const Array& r) const {
+    Array FdmExtOUJumpOp::apply_direction(Size direction,
+                                          const Array& r) const {
         if (direction == 0)
             return ouOp_->apply_direction(direction, r);
         else if (direction == 1)
             return dyMap_.apply(r);
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array>
-        FdmExtOUJumpOp::solve_splitting(Size direction,
-                                        const Array& r, Real a) const {
+    Array FdmExtOUJumpOp::solve_splitting(Size direction,
+                                          const Array& r, Real a) const {
         if (direction == 0) {
             return ouOp_->solve_splitting(direction, r, a);
         }
@@ -155,22 +153,19 @@ namespace QuantLib {
             return dyMap_.solve_splitting(r, a, 1.0);
         }
         else {
-            Array retVal(r);
-            return retVal;
+            return r;
         }
     }
 
-    Disposable<Array>
-    FdmExtOUJumpOp::preconditioner(const Array& r, Real dt) const {
+    Array FdmExtOUJumpOp::preconditioner(const Array& r, Real dt) const {
         return ouOp_->solve_splitting(0, r, dt);
     }
 
-    Disposable<Array> FdmExtOUJumpOp::integro(const Array& r) const {
+    Array FdmExtOUJumpOp::integro(const Array& r) const {
         return prod(integroPart_, r);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmExtOUJumpOp::toMatrixDecomp() const {
+    std::vector<SparseMatrix> FdmExtOUJumpOp::toMatrixDecomp() const {
         QL_REQUIRE(bcSet_.empty(), "boundary conditions are not supported");
 
         std::vector<SparseMatrix> retVal(1, ouOp_->toMatrixDecomp().front());
diff --git a/ql/experimental/finitedifferences/fdmextoujumpop.hpp b/ql/experimental/finitedifferences/fdmextoujumpop.hpp
index 6d82413f5dd..883366b7fa3 100644
--- a/ql/experimental/finitedifferences/fdmextoujumpop.hpp
+++ b/ql/experimental/finitedifferences/fdmextoujumpop.hpp
@@ -54,16 +54,16 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
       private:
-        Disposable<Array> integro(const Array& r) const;
+        Array integro(const Array& r) const;
 
         const ext::shared_ptr<FdmMesher> mesher_;
         const ext::shared_ptr<ExtOUWithJumpsProcess> process_;
diff --git a/ql/experimental/finitedifferences/fdmhestonfwdop.cpp b/ql/experimental/finitedifferences/fdmhestonfwdop.cpp
index 6196a10a2eb..d9bee3a093e 100644
--- a/ql/experimental/finitedifferences/fdmhestonfwdop.cpp
+++ b/ql/experimental/finitedifferences/fdmhestonfwdop.cpp
@@ -145,7 +145,7 @@ namespace QuantLib {
         }
     }
 
-    Disposable<Array> FdmHestonFwdOp::apply(const Array& u) const {
+    Array FdmHestonFwdOp::apply(const Array& u) const {
         if (leverageFct_ != nullptr) {
             return mapX_->apply(u)
                     + mapY_->apply(u)
@@ -157,7 +157,7 @@ namespace QuantLib {
         }
     }
 
-    Disposable<Array> FdmHestonFwdOp::apply_mixed(const Array& u) const{
+    Array FdmHestonFwdOp::apply_mixed(const Array& u) const{
         if (leverageFct_ != nullptr) {
             return correlation_->apply(L_*u);
         } else {
@@ -165,7 +165,7 @@ namespace QuantLib {
         }
     }
 
-    Disposable<Array> FdmHestonFwdOp::apply_direction(
+    Array FdmHestonFwdOp::apply_direction(
         Size direction, const Array& u) const {
 
         if (direction == 0)
@@ -176,7 +176,7 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
 
-    Disposable<Array> FdmHestonFwdOp::solve_splitting(
+    Array FdmHestonFwdOp::solve_splitting(
         Size direction, const Array& u, Real s) const{
         if (direction == 0) {
             return mapX_->solve_splitting(u, s, 1.0);
@@ -188,13 +188,12 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
 
-    Disposable<Array> FdmHestonFwdOp::preconditioner(
+    Array FdmHestonFwdOp::preconditioner(
         const Array& u, Real dt) const{
         return solve_splitting(1, u, dt);
     }
 
-    Disposable<Array> FdmHestonFwdOp::getLeverageFctSlice(Time t1, Time t2)
-    const {
+    Array FdmHestonFwdOp::getLeverageFctSlice(Time t1, Time t2) const {
         const ext::shared_ptr<FdmLinearOpLayout> layout=mesher_->layout();
         Array v(layout->size(), 1.0);
 
@@ -223,8 +222,7 @@ namespace QuantLib {
         return v;
     }
 
-    Disposable<std::vector<SparseMatrix> > FdmHestonFwdOp::toMatrixDecomp()
-        const {
+    std::vector<SparseMatrix> FdmHestonFwdOp::toMatrixDecomp() const {
 
         std::vector<SparseMatrix> retVal(3);
 
diff --git a/ql/experimental/finitedifferences/fdmhestonfwdop.hpp b/ql/experimental/finitedifferences/fdmhestonfwdop.hpp
index d8f65a8d019..38cd722e208 100644
--- a/ql/experimental/finitedifferences/fdmhestonfwdop.hpp
+++ b/ql/experimental/finitedifferences/fdmhestonfwdop.hpp
@@ -51,16 +51,16 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
       private:
-        Disposable<Array> getLeverageFctSlice(Time t1, Time t2) const;
+        Array getLeverageFctSlice(Time t1, Time t2) const;
         const FdmSquareRootFwdOp::TransformationType type_;
         const Real kappa_, theta_, sigma_, rho_, v0_, mixedSigma_;
 
diff --git a/ql/experimental/finitedifferences/fdmhestongreensfct.cpp b/ql/experimental/finitedifferences/fdmhestongreensfct.cpp
index 789e27c15ba..0e4bb176fcd 100644
--- a/ql/experimental/finitedifferences/fdmhestongreensfct.cpp
+++ b/ql/experimental/finitedifferences/fdmhestongreensfct.cpp
@@ -38,8 +38,8 @@ namespace QuantLib {
                                            const Real l0)
     : l0_(l0), mesher_(std::move(mesher)), process_(std::move(process)), trafoType_(trafoType_) {}
 
-    Disposable<Array> FdmHestonGreensFct::get(Time t, Algorithm algorithm)
-    const {
+    Array FdmHestonGreensFct::get(Time t, Algorithm algorithm) const {
+
         const Rate r = process_->riskFreeRate()->forwardRate(0, t, Continuous);
         const Rate q = process_->dividendYield()->forwardRate(0,t, Continuous);
 
diff --git a/ql/experimental/finitedifferences/fdmhestongreensfct.hpp b/ql/experimental/finitedifferences/fdmhestongreensfct.hpp
index 6131ec5d324..0e58f881508 100644
--- a/ql/experimental/finitedifferences/fdmhestongreensfct.hpp
+++ b/ql/experimental/finitedifferences/fdmhestongreensfct.hpp
@@ -38,7 +38,7 @@ namespace QuantLib {
                            FdmSquareRootFwdOp::TransformationType trafoType_,
                            Real l0 = 1.0);
 
-        Disposable<Array> get(Time t, Algorithm algorithm) const;
+        Array get(Time t, Algorithm algorithm) const;
 
       private:
         const Real l0_;
diff --git a/ql/experimental/finitedifferences/fdmklugeextouop.cpp b/ql/experimental/finitedifferences/fdmklugeextouop.cpp
index 7cf7a1e0f12..a0451b66bc7 100644
--- a/ql/experimental/finitedifferences/fdmklugeextouop.cpp
+++ b/ql/experimental/finitedifferences/fdmklugeextouop.cpp
@@ -74,23 +74,22 @@ namespace QuantLib {
         klugeOp_->setTime(t1, t2);
     }
 
-    Disposable<Array> FdmKlugeExtOUOp::apply(const Array& r) const {
+    Array FdmKlugeExtOUOp::apply(const Array& r) const {
         return ouOp_->apply(r) + klugeOp_->apply(r) + corrMap_.apply(r);
     }
 
-    Disposable<Array> FdmKlugeExtOUOp::apply_mixed(const Array& r) const {
-        return  corrMap_.apply(r) + klugeOp_->apply_mixed(r);
+    Array FdmKlugeExtOUOp::apply_mixed(const Array& r) const {
+        return corrMap_.apply(r) + klugeOp_->apply_mixed(r);
     }
 
-    Disposable<Array> FdmKlugeExtOUOp::apply_direction(Size direction,
-                                                       const Array& r) const {
+    Array FdmKlugeExtOUOp::apply_direction(Size direction,
+                                           const Array& r) const {
         return klugeOp_->apply_direction(direction, r)
                 + ouOp_->apply_direction(direction, r);
     }
 
-    Disposable<Array>
-        FdmKlugeExtOUOp::solve_splitting(Size direction,
-                                        const Array& r, Real a) const {
+    Array FdmKlugeExtOUOp::solve_splitting(Size direction,
+                                           const Array& r, Real a) const {
         if (direction == 0 || direction == 1) {
             return klugeOp_->solve_splitting(direction, r, a);
         }
@@ -103,23 +102,19 @@ namespace QuantLib {
         }
     }
 
-    Disposable<Array>
-        FdmKlugeExtOUOp::preconditioner(const Array& r, Real dt) const {
+    Array FdmKlugeExtOUOp::preconditioner(const Array& r, Real dt) const {
         return klugeOp_->solve_splitting(0, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmKlugeExtOUOp::toMatrixDecomp() const {
-        const std::vector<SparseMatrix> klugeDecomp
-            = klugeOp_->toMatrixDecomp();
+    std::vector<SparseMatrix> FdmKlugeExtOUOp::toMatrixDecomp() const {
+        const std::vector<SparseMatrix> klugeDecomp = klugeOp_->toMatrixDecomp();
 
-        std::vector<SparseMatrix> retVal(4);
-        retVal[0] = klugeDecomp[0];
-        retVal[1] = klugeDecomp[1];
-        retVal[2] = ouOp_->toMatrixDecomp().front();
-        retVal[3] = corrMap_.toMatrix() + klugeDecomp[2];
-
-        return retVal;
+        return {
+            klugeDecomp[0],
+            klugeDecomp[1],
+            ouOp_->toMatrixDecomp().front(),
+            corrMap_.toMatrix() + klugeDecomp[2]
+        };
     }
 
 }
diff --git a/ql/experimental/finitedifferences/fdmklugeextouop.hpp b/ql/experimental/finitedifferences/fdmklugeextouop.hpp
index df9e35449b2..c8f0e461604 100644
--- a/ql/experimental/finitedifferences/fdmklugeextouop.hpp
+++ b/ql/experimental/finitedifferences/fdmklugeextouop.hpp
@@ -73,14 +73,14 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
 
diff --git a/ql/experimental/finitedifferences/fdmsquarerootfwdop.cpp b/ql/experimental/finitedifferences/fdmsquarerootfwdop.cpp
index e514473fb59..ba4a7087697 100644
--- a/ql/experimental/finitedifferences/fdmsquarerootfwdop.cpp
+++ b/ql/experimental/finitedifferences/fdmsquarerootfwdop.cpp
@@ -298,44 +298,41 @@ namespace QuantLib {
         gamma=  (sigma_*sigma_*v(n) + mu*h(n-1))/zetap(n);
     }
 
-    Disposable<Array> FdmSquareRootFwdOp::apply(const Array& p) const {
+    Array FdmSquareRootFwdOp::apply(const Array& p) const {
         return mapX_->apply(p);
     }
 
-    Disposable<Array> FdmSquareRootFwdOp::apply_mixed(const Array& r) const {
-        Array retVal(r.size(), 0.0);
-        return retVal;
+    Array FdmSquareRootFwdOp::apply_mixed(const Array& r) const {
+        return Array(r.size(), 0.0);
     }
-    Disposable<Array> FdmSquareRootFwdOp::apply_direction(
+
+    Array FdmSquareRootFwdOp::apply_direction(
         Size direction, const Array& r) const {
         if (direction == direction_) {
             return mapX_->apply(r);
         }
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
-    Disposable<Array> FdmSquareRootFwdOp::solve_splitting(
+
+    Array FdmSquareRootFwdOp::solve_splitting(
         Size direction, const Array& r, Real dt) const {
         if (direction == direction_) {
             return mapX_->solve_splitting(r, dt, 1.0);
         }
         else {
-            Array retVal(r);
-            return retVal;
+            return r;
         }
     }
 
-    Disposable<Array> FdmSquareRootFwdOp::preconditioner(
+    Array FdmSquareRootFwdOp::preconditioner(
         const Array& r, Real dt) const {
         return solve_splitting(direction_, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmSquareRootFwdOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(1, mapX_->toMatrix());
-        return retVal;
+    std::vector<SparseMatrix> FdmSquareRootFwdOp::toMatrixDecomp() const {
+        return std::vector<SparseMatrix>(1, mapX_->toMatrix());
     }
 
 }
diff --git a/ql/experimental/finitedifferences/fdmsquarerootfwdop.hpp b/ql/experimental/finitedifferences/fdmsquarerootfwdop.hpp
index ecf2291ae88..db0fadfbc1b 100644
--- a/ql/experimental/finitedifferences/fdmsquarerootfwdop.hpp
+++ b/ql/experimental/finitedifferences/fdmsquarerootfwdop.hpp
@@ -46,13 +46,13 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
         Real lowerBoundaryFactor(TransformationType type = Plain) const;
         Real upperBoundaryFactor(TransformationType type = Plain) const;
diff --git a/ql/experimental/finitedifferences/fdmvppstartlimitstepcondition.cpp b/ql/experimental/finitedifferences/fdmvppstartlimitstepcondition.cpp
index c4546109d0b..80d4e4dce33 100644
--- a/ql/experimental/finitedifferences/fdmvppstartlimitstepcondition.cpp
+++ b/ql/experimental/finitedifferences/fdmvppstartlimitstepcondition.cpp
@@ -45,8 +45,9 @@ namespace QuantLib {
         QL_REQUIRE(tMinDown_ > 0, "minimum down time must be greater than one");
     }
 
-    Disposable<Array> FdmVPPStartLimitStepCondition::changeState(
+    Array FdmVPPStartLimitStepCondition::changeState(
         const Real gasPrice, const Array& state, Time) const {
+
         const Real startUpCost
                 = startUpFixCost_ + (gasPrice + fuelCostAddon_)*startUpFuel_;
 
diff --git a/ql/experimental/finitedifferences/fdmvppstartlimitstepcondition.hpp b/ql/experimental/finitedifferences/fdmvppstartlimitstepcondition.hpp
index 066c2b7cd7b..8e3ef8e6247 100644
--- a/ql/experimental/finitedifferences/fdmvppstartlimitstepcondition.hpp
+++ b/ql/experimental/finitedifferences/fdmvppstartlimitstepcondition.hpp
@@ -43,7 +43,7 @@ namespace QuantLib {
         Real maxValue(const Array& states) const override;
 
       private:
-        Disposable<Array> changeState(Real gasPrice, const Array& state, Time t) const override;
+        Array changeState(Real gasPrice, const Array& state, Time t) const override;
 
         const Size nStarts_;
     };
diff --git a/ql/experimental/finitedifferences/fdmvppstepcondition.hpp b/ql/experimental/finitedifferences/fdmvppstepcondition.hpp
index 7c36965c540..a3c6b5eeae0 100644
--- a/ql/experimental/finitedifferences/fdmvppstepcondition.hpp
+++ b/ql/experimental/finitedifferences/fdmvppstepcondition.hpp
@@ -66,8 +66,7 @@ namespace QuantLib {
 
         Real evolve(const FdmLinearOpIterator& iter, Time t) const;
 
-        virtual Disposable<Array> changeState(
-            Real gasPrice, const Array& state, Time t) const = 0;
+        virtual Array changeState(Real gasPrice, const Array& state, Time t) const = 0;
 
         const Real heatRate_;
         const Real pMin_, pMax_;
diff --git a/ql/experimental/finitedifferences/fdmzabrop.cpp b/ql/experimental/finitedifferences/fdmzabrop.cpp
index 0c22dee292c..73ba2e198c9 100644
--- a/ql/experimental/finitedifferences/fdmzabrop.cpp
+++ b/ql/experimental/finitedifferences/fdmzabrop.cpp
@@ -72,13 +72,13 @@ void FdmZabrOp::setTime(Time t1, Time t2) {
 
 Size FdmZabrOp::size() const { return 2; }
 
-Disposable<Array> FdmZabrOp::apply(const Array &u) const {
+Array FdmZabrOp::apply(const Array &u) const {
     return dyMap_.getMap().apply(u) + dxMap_.getMap().apply(u) +
            dxyMap_.apply(u);
 }
 
-Disposable<Array> FdmZabrOp::apply_direction(Size direction,
-                                             const Array &r) const {
+Array FdmZabrOp::apply_direction(Size direction,
+                                 const Array &r) const {
     if (direction == 0)
         return dxMap_.getMap().apply(r);
     else if (direction == 1)
@@ -87,12 +87,12 @@ Disposable<Array> FdmZabrOp::apply_direction(Size direction,
         QL_FAIL("direction too large");
 }
 
-Disposable<Array> FdmZabrOp::apply_mixed(const Array &r) const {
+Array FdmZabrOp::apply_mixed(const Array &r) const {
     return dxyMap_.apply(r);
 }
 
-Disposable<Array> FdmZabrOp::solve_splitting(Size direction, const Array &r,
-                                             Real a) const {
+Array FdmZabrOp::solve_splitting(Size direction, const Array &r,
+                                 Real a) const {
 
     if (direction == 0) {
         return dxMap_.getMap().solve_splitting(r, a, 1.0);
@@ -102,17 +102,16 @@ Disposable<Array> FdmZabrOp::solve_splitting(Size direction, const Array &r,
         QL_FAIL("direction too large");
 }
 
-Disposable<Array> FdmZabrOp::preconditioner(const Array &r, Real dt) const {
-
+Array FdmZabrOp::preconditioner(const Array &r, Real dt) const {
     return solve_splitting(0, r, dt);
 }
 
-Disposable<std::vector<SparseMatrix> > FdmZabrOp::toMatrixDecomp() const {
-    std::vector<SparseMatrix> retVal(3);
-    retVal[0] = dxMap_.getMap().toMatrix();
-    retVal[1] = dyMap_.getMap().toMatrix();
-    retVal[2] = dxyMap_.toMatrix();
-    return retVal;
+std::vector<SparseMatrix> FdmZabrOp::toMatrixDecomp() const {
+    return {
+        dxMap_.getMap().toMatrix(),
+        dyMap_.getMap().toMatrix(),
+        dxyMap_.toMatrix()
+    };
 }
 
 }
diff --git a/ql/experimental/finitedifferences/fdmzabrop.hpp b/ql/experimental/finitedifferences/fdmzabrop.hpp
index a77789a7276..94fbac2dd79 100644
--- a/ql/experimental/finitedifferences/fdmzabrop.hpp
+++ b/ql/experimental/finitedifferences/fdmzabrop.hpp
@@ -75,14 +75,14 @@ class FdmZabrOp : public FdmLinearOpComposite {
     Size size() const override;
     void setTime(Time t1, Time t2) override;
 
-    Disposable<Array> apply(const Array& r) const override;
-    Disposable<Array> apply_mixed(const Array& r) const override;
+    Array apply(const Array& r) const override;
+    Array apply_mixed(const Array& r) const override;
 
-    Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-    Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-    Disposable<Array> preconditioner(const Array& r, Real s) const override;
+    Array apply_direction(Size direction, const Array& r) const override;
+    Array solve_splitting(Size direction, const Array& r, Real s) const override;
+    Array preconditioner(const Array& r, Real s) const override;
 
-    Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+    std::vector<SparseMatrix> toMatrixDecomp() const override;
 
   private:
     const Array volatilityValues_;
diff --git a/ql/experimental/math/convolvedstudentt.cpp b/ql/experimental/math/convolvedstudentt.cpp
index 19807d82e32..240801f7d22 100644
--- a/ql/experimental/math/convolvedstudentt.cpp
+++ b/ql/experimental/math/convolvedstudentt.cpp
@@ -77,8 +77,7 @@ namespace QuantLib {
           a2_ = a_ * a_;
     }
 
-    Disposable<std::vector<Real> >
-    CumulativeBehrensFisher::polynCharactT(Natural n) const {
+    std::vector<Real> CumulativeBehrensFisher::polynCharactT(Natural n) const {
         Natural nu = 2 * n +1;
         std::vector<Real> low(1,1.), high(1,1.);
         high.push_back(std::sqrt(static_cast<Real>(nu)));
@@ -100,8 +99,7 @@ namespace QuantLib {
         return high;
     }
 
-    Disposable<std::vector<Real> >
-    CumulativeBehrensFisher::convolveVectorPolynomials(
+    std::vector<Real> CumulativeBehrensFisher::convolveVectorPolynomials(
         const std::vector<Real>& v1,
         const std::vector<Real>& v2) const {
     #if defined(QL_EXTRA_SAFETY_CHECKS)
diff --git a/ql/experimental/math/convolvedstudentt.hpp b/ql/experimental/math/convolvedstudentt.hpp
index 3c15c0f9777..07f60226935 100644
--- a/ql/experimental/math/convolvedstudentt.hpp
+++ b/ql/experimental/math/convolvedstudentt.hpp
@@ -21,7 +21,6 @@
 #define convolved_student_t_hpp
 
 #include <ql/types.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <vector>
 #include <numeric>
 #include <functional>
@@ -99,9 +98,9 @@ namespace QuantLib {
              T is then \f$ \nu=2n+1 \f$
         */
         // move outside of the class, as a separate problem?
-        Disposable<std::vector<Real> > polynCharactT(Natural n) const;
+        std::vector<Real> polynCharactT(Natural n) const;
 
-        Disposable<std::vector<Real> > convolveVectorPolynomials(
+        std::vector<Real> convolveVectorPolynomials(
             const std::vector<Real>& v1,
             const std::vector<Real>& v2) const ;
     public:
diff --git a/ql/experimental/math/expm.cpp b/ql/experimental/math/expm.cpp
index 3f094c7674b..2015d1057d0 100644
--- a/ql/experimental/math/expm.cpp
+++ b/ql/experimental/math/expm.cpp
@@ -36,8 +36,7 @@ namespace QuantLib {
             explicit MatrixVectorProductFct(Matrix m) : m_(std::move(m)) {}
 
             // implements x = M*y
-            Disposable<std::vector<Real> > operator()(
-                Real t, const std::vector<Real>& y) {
+            std::vector<Real> operator()(Real t, const std::vector<Real>& y) {
 
                 std::vector<Real> result(m_.rows());
                 for (Size i=0; i < result.size(); i++) {
@@ -51,7 +50,7 @@ namespace QuantLib {
         };
     }
 
-    Disposable<Matrix> Expm(const Matrix& M, Real t, Real tol) {
+    Matrix Expm(const Matrix& M, Real t, Real tol) {
         const Size n = M.rows();
         QL_REQUIRE(n == M.columns(), "Expm expects a square matrix");
 
diff --git a/ql/experimental/math/expm.hpp b/ql/experimental/math/expm.hpp
index b3262d99ce3..ec7e566d0b4 100644
--- a/ql/experimental/math/expm.hpp
+++ b/ql/experimental/math/expm.hpp
@@ -38,7 +38,7 @@ namespace QuantLib {
     */
 
     //! returns the matrix exponential exp(t*M)
-    Disposable<Matrix> Expm(const Matrix& M, Real t=1.0, Real tol=QL_EPSILON);
+    Matrix Expm(const Matrix& M, Real t=1.0, Real tol=QL_EPSILON);
 }
 
 #endif
diff --git a/ql/experimental/math/gaussiancopulapolicy.hpp b/ql/experimental/math/gaussiancopulapolicy.hpp
index 50cd7c865f3..f1d598c68be 100644
--- a/ql/experimental/math/gaussiancopulapolicy.hpp
+++ b/ql/experimental/math/gaussiancopulapolicy.hpp
@@ -20,7 +20,6 @@
 #ifndef quantlib_gaussian_copula_policy_hpp
 #define quantlib_gaussian_copula_policy_hpp
 
-#include <ql/utilities/disposable.hpp>
 #include <ql/math/distributions/normaldistribution.hpp>
 #include <vector>
 #include <numeric>
@@ -108,8 +107,7 @@ namespace QuantLib {
         }
         //! 
         //to use this (by default) version, the generator must be a uniform one.
-        Disposable<std::vector<Real> > 
-            allFactorCumulInverter(const std::vector<Real>& probs) const {
+        std::vector<Real> allFactorCumulInverter(const std::vector<Real>& probs) const {
             std::vector<Real> result;
             result.resize(probs.size());
             std::transform(probs.begin(), probs.end(), result.begin(),
diff --git a/ql/experimental/math/laplaceinterpolation.hpp b/ql/experimental/math/laplaceinterpolation.hpp
index d0a29ccf71b..831488de5c2 100644
--- a/ql/experimental/math/laplaceinterpolation.hpp
+++ b/ql/experimental/math/laplaceinterpolation.hpp
@@ -39,7 +39,7 @@ template <class M> void laplaceInterpolation(M &A, Real relTol = 1E-6) {
     struct f_A {
         const SparseMatrix &g;
         explicit f_A(const SparseMatrix &g) : g(g) {}
-        Disposable<Array> operator()(const Array &x) const {
+        Array operator()(const Array &x) const {
             return prod(g, x);
         }
     };
diff --git a/ql/experimental/math/latentmodel.hpp b/ql/experimental/math/latentmodel.hpp
index 5837bfdc323..d29f1bf4952 100644
--- a/ql/experimental/math/latentmodel.hpp
+++ b/ql/experimental/math/latentmodel.hpp
@@ -43,9 +43,8 @@ namespace QuantLib {
     namespace detail {
         // havent figured out how to do this in-place
         struct multiplyV {
-            typedef Disposable<std::vector<Real> > result_type;
-            Disposable<std::vector<Real> > 
-                operator()(Real d,  Disposable<std::vector<Real> > v) 
+            typedef std::vector<Real> result_type;
+            std::vector<Real> operator()(Real d, std::vector<Real> v) 
             {
                 std::transform(v.begin(), v.end(), v.begin(), 
                                multiply_by<Real>(d));
@@ -79,8 +78,8 @@ namespace QuantLib {
         why the overload fails....
                     FIX ME
         */
-        virtual Disposable<std::vector<Real> > integrateV(
-            const ext::function<Disposable<std::vector<Real> >  (
+        virtual std::vector<Real> integrateV(
+            const ext::function<std::vector<Real>  (
             const std::vector<Real>& arg)>& f) const {
             QL_FAIL("No vector integration provided");
         }
@@ -123,10 +122,10 @@ namespace QuantLib {
         Real integrate(const ext::function<Real(const std::vector<Real>& arg)>& f) const override {
             return GaussianQuadMultidimIntegrator::integrate<Real>(f);
         }
-        Disposable<std::vector<Real> > integrateV(
-            const ext::function<Disposable<std::vector<Real> >(const std::vector<Real>& arg)>& f)
+        std::vector<Real> integrateV(
+            const ext::function<std::vector<Real>(const std::vector<Real>& arg)>& f)
             const override {
-            return GaussianQuadMultidimIntegrator::integrate<Disposable<std::vector<Real> > >(f);
+            return GaussianQuadMultidimIntegrator::integrate<std::vector<Real>>(f);
         }
         ~IntegrationBase() override = default;
     };
@@ -144,7 +143,7 @@ namespace QuantLib {
         Real integrate(const ext::function<Real(const std::vector<Real>& arg)>& f) const override {
             return MultidimIntegral::operator()(f, a_, b_);
         }
-        // disposable vector version here....
+        // vector version here....
         ~IntegrationBase() override = default;
         const std::vector<Real> a_, b_;
     };
@@ -324,8 +323,7 @@ namespace QuantLib {
             model. These are all the systemic factors plus all the idiosyncratic
             ones, so the size of the inversion is the number of systemic factors
             plus the number of latent modelled variables*/
-        Disposable<std::vector<Real> > 
-            allFactorCumulInverter(const std::vector<Real>& probs) const {
+        std::vector<Real> allFactorCumulInverter(const std::vector<Real>& probs) const {
             return copula_.allFactorCumulInverter(probs);
         }
         //@}
@@ -430,8 +428,6 @@ namespace QuantLib {
             const sample_type& nextSequence() const {
                 typename USNG::sample_type sample =
                     sequenceGen_.nextSequence();
-                //Not possible to overload operator member access in Disposable
-                //return copula_.allFactorCumulInverter(sample.value).value;
                 x_.value = copula_.allFactorCumulInverter(sample.value);
                 return x_;
             }
@@ -594,9 +590,9 @@ namespace QuantLib {
         /*! Integrates an arbitrary vector function over the density domain(i.e.
          computes its expected value).
         */
-        Disposable<std::vector<Real> > integratedExpectedValueV(
+        std::vector<Real> integratedExpectedValueV(
             // const ext::function<std::vector<Real>(
-            const ext::function<Disposable<std::vector<Real> >(
+            const ext::function<std::vector<Real>(
                 const std::vector<Real>& v1)>& f ) const {
             detail::multiplyV M;
             return integration()->integrateV(//see note in LMIntegrators base class
diff --git a/ql/experimental/math/moorepenroseinverse.hpp b/ql/experimental/math/moorepenroseinverse.hpp
index 5809997f120..bd666419a23 100644
--- a/ql/experimental/math/moorepenroseinverse.hpp
+++ b/ql/experimental/math/moorepenroseinverse.hpp
@@ -32,8 +32,8 @@ namespace QuantLib {
     http://de.mathworks.com/help/matlab/ref/pinv.html
     https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_pseudoinverse */
 
-inline Disposable<Matrix> moorePenroseInverse(const Matrix &A,
-                                              const Real tol = Null<Real>()) {
+inline Matrix moorePenroseInverse(const Matrix &A,
+                                  const Real tol = Null<Real>()) {
 
     Size m = A.rows();
     Size n = A.columns();
diff --git a/ql/experimental/math/multidimquadrature.hpp b/ql/experimental/math/multidimquadrature.hpp
index 141bad5e3f9..82ac33e87f4 100644
--- a/ql/experimental/math/multidimquadrature.hpp
+++ b/ql/experimental/math/multidimquadrature.hpp
@@ -35,10 +35,6 @@
 
 namespace QuantLib {
 
-    namespace detail {
-        typedef Disposable<std::vector<Real> > DispArray;
-    }
-
     /*! \brief Integrates a vector or scalar function of vector domain. 
         
         A template recursion along dimensions avoids calling depth 
@@ -60,7 +56,7 @@ namespace QuantLib {
             : GaussHermiteIntegration(n, mu) {}
 
             template <class F> // todo: fix copies.
-            detail::DispArray operator()(const F& f) const {
+            std::vector<Real> operator()(const F& f) const {
                 //first one, we do not know the size of the vector returned by f
                 Integer i = order()-1;
                 std::vector<Real> term = f(x_[i]);// potential copy! @#$%^!!!
@@ -98,9 +94,7 @@ namespace QuantLib {
         cost... up to the compiler. It can not be templated all the way since
         the integration entries functions can not be templates.
         Most times integrands will return a scalar or vector but could be a 
-        matrix too. Also vectors might be returned as vector or Disposable 
-        wrapped (which is preferred and I have removed the plain vector
-        version).
+        matrix too.
          */
         template<class RetType_T>
         RetType_T operator()(const ext::function<RetType_T (
@@ -139,7 +133,7 @@ namespace QuantLib {
                     return scalarIntegrator<levelSpawn>(f, x);
                 };
             integrationEntriesVR_[levelSpawn-1] =
-                [&](const ext::function<detail::DispArray(const std::vector<Real>&)>& f, Real x){
+                [&](const ext::function<std::vector<Real>(const std::vector<Real>&)>& f, Real x){
                     return vectorIntegratorVR<levelSpawn>(f, x);
                 };
             spawnFcts<levelSpawn-1>();
@@ -158,8 +152,8 @@ namespace QuantLib {
         }
 
         template <int intgDepth>
-        detail::DispArray vectorIntegratorVR(
-            const ext::function<detail::DispArray(const std::vector<Real>& arg1)>& f,
+        std::vector<Real> vectorIntegratorVR(
+            const ext::function<std::vector<Real>(const std::vector<Real>& arg1)>& f,
             const Real mFctr) const 
         {
             varBuffer_[intgDepth-1] = mFctr;
@@ -180,7 +174,7 @@ namespace QuantLib {
             const std::vector<Real>& varg2)> f1, 
             const Real r3)> > integrationEntries_;
         mutable std::vector<
-        ext::function<detail::DispArray (const ext::function<detail::DispArray(
+        ext::function<std::vector<Real> (const ext::function<std::vector<Real>(
             const std::vector<Real>& vvarg2)>& vf1, 
             const Real vr3)> > integrationEntriesVR_;
 
@@ -214,8 +208,8 @@ namespace QuantLib {
 
     // Vector integrand version
     template<>
-    inline detail::DispArray GaussianQuadMultidimIntegrator::integrate<detail::DispArray>(
-        const ext::function<detail::DispArray (const std::vector<Real>& v1)>& f) const
+    inline std::vector<Real> GaussianQuadMultidimIntegrator::integrate<std::vector<Real>>(
+        const ext::function<std::vector<Real> (const std::vector<Real>& v1)>& f) const
     {
         return integralV_([&](Real x){ return integrationEntriesVR_[dimension_-1](ext::cref(f), x); });
     } 
@@ -230,11 +224,11 @@ namespace QuantLib {
         return f(varBuffer_);
     }
 
-    //! Terminal integrand; disposable vector function version
+    //! Terminal integrand; vector function version
     template<>
-    inline detail::DispArray
+    inline std::vector<Real>
         GaussianQuadMultidimIntegrator::vectorIntegratorVR<1>(
-        const ext::function<detail::DispArray (const std::vector<Real>& arg1)>& f,
+        const ext::function<std::vector<Real> (const std::vector<Real>& arg1)>& f,
         const Real mFctr) const 
     {
         varBuffer_[0] = mFctr;
@@ -247,7 +241,7 @@ namespace QuantLib {
         integrationEntries_[0] = [&](const ext::function<Real(const std::vector<Real>&)>& f,
                                      Real x) { return scalarIntegrator<1>(f, x); };
         integrationEntriesVR_[0] =
-            [&](const ext::function<detail::DispArray(const std::vector<Real>&)>& f, Real x) {
+            [&](const ext::function<std::vector<Real>(const std::vector<Real>&)>& f, Real x) {
                 return vectorIntegratorVR<1>(f, x);
             };
     }
diff --git a/ql/experimental/math/tcopulapolicy.cpp b/ql/experimental/math/tcopulapolicy.cpp
index a2b8761ca98..ce42ed1106d 100644
--- a/ql/experimental/math/tcopulapolicy.cpp
+++ b/ql/experimental/math/tcopulapolicy.cpp
@@ -62,8 +62,7 @@ namespace QuantLib {
         }
     }
 
-    Disposable<std::vector<Real> > 
-    TCopulaPolicy::allFactorCumulInverter(
+    std::vector<Real> TCopulaPolicy::allFactorCumulInverter(
         const std::vector<Real>& probs) const 
     {
     #if defined(QL_EXTRA_SAFETY_CHECKS)
diff --git a/ql/experimental/math/tcopulapolicy.hpp b/ql/experimental/math/tcopulapolicy.hpp
index 0fd90faaf69..186e9c74de0 100644
--- a/ql/experimental/math/tcopulapolicy.hpp
+++ b/ql/experimental/math/tcopulapolicy.hpp
@@ -21,7 +21,6 @@
 #define quantlib_tcopula_policy_hpp
 
 #include <ql/errors.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <ql/experimental/math/convolvedstudentt.hpp>
 #include <ql/functional.hpp>
 #include <boost/math/distributions/students_t.hpp>
@@ -145,15 +144,12 @@ namespace QuantLib {
                 * varianceFactors_[iFactor];
         }
         //to use this (by default) version, the generator must be a uniform one.
-        Disposable<std::vector<Real> > 
-            allFactorCumulInverter(const std::vector<Real>& probs) const;
+        std::vector<Real> allFactorCumulInverter(const std::vector<Real>& probs) const;
     private:
-        mutable std::vector<boost::math::students_t_distribution<> > 
-            distributions_;
+        mutable std::vector<boost::math::students_t_distribution<> > distributions_;
         mutable std::vector<Real> varianceFactors_;
         mutable std::vector<CumulativeBehrensFisher> latentVarsCumul_;
-        mutable std::vector<InverseCumulativeBehrensFisher> 
-            latentVarsInverters_;
+        mutable std::vector<InverseCumulativeBehrensFisher> latentVarsInverters_;
     };
 
 }
diff --git a/ql/experimental/models/hestonslvfdmmodel.cpp b/ql/experimental/models/hestonslvfdmmodel.cpp
index dfd3bce9b29..6063cf7bd18 100644
--- a/ql/experimental/models/hestonslvfdmmodel.cpp
+++ b/ql/experimental/models/hestonslvfdmmodel.cpp
@@ -149,19 +149,17 @@ namespace QuantLib {
         }
 
 
-        Disposable<Array> rescalePDF(
+        Array rescalePDF(
             const Array& p,
             const ext::shared_ptr<FdmMesherComposite>& mesher,
             FdmSquareRootFwdOp::TransformationType trafoType, Real alpha) {
 
-            Array retVal = p/integratePDF(p, mesher, trafoType, alpha);
-
-            return retVal;
+            return p/integratePDF(p, mesher, trafoType, alpha);
         }
 
 
         template <class Interpolator>
-        Disposable<Array> reshapePDF(
+        Array reshapePDF(
             const Array& p,
             const ext::shared_ptr<FdmMesherComposite>& oldMesher,
             const ext::shared_ptr<FdmMesherComposite>& newMesher,
diff --git a/ql/experimental/models/normalclvmodel.cpp b/ql/experimental/models/normalclvmodel.cpp
index 7f25ac12de4..170e5537671 100644
--- a/ql/experimental/models/normalclvmodel.cpp
+++ b/ql/experimental/models/normalclvmodel.cpp
@@ -70,7 +70,7 @@ namespace QuantLib {
         return rndCalculator_->invcdf(q, bsProcess_->time(d));
     }
 
-    Disposable<Array> NormalCLVModel::collocationPointsX(const Date& d) const {
+    Array NormalCLVModel::collocationPointsX(const Date& d) const {
         const Time t = bsProcess_->time(d);
 
         const Real expectation
@@ -81,7 +81,7 @@ namespace QuantLib {
         return expectation + stdDeviation*x_;
     }
 
-    Disposable<Array> NormalCLVModel::collocationPointsY(const Date& d) const {
+    Array NormalCLVModel::collocationPointsY(const Date& d) const {
         Array s(x_.size());
 
         CumulativeNormalDistribution N;
diff --git a/ql/experimental/models/normalclvmodel.hpp b/ql/experimental/models/normalclvmodel.hpp
index e4fceb2d0c3..3d4f21ec5bc 100644
--- a/ql/experimental/models/normalclvmodel.hpp
+++ b/ql/experimental/models/normalclvmodel.hpp
@@ -61,10 +61,10 @@ namespace QuantLib {
         Real invCDF(const Date& d, Real q) const;
 
         // collocation points of the Ornstein-Uhlenbeck process
-        Disposable<Array> collocationPointsX(const Date& d) const;
+        Array collocationPointsX(const Date& d) const;
 
         // collocation points for the underlying Y
-        Disposable<Array> collocationPointsY(const Date& d) const;
+        Array collocationPointsY(const Date& d) const;
 
         // CLV mapping function
         ext::function<Real(Time, Real)> g() const;
diff --git a/ql/experimental/models/squarerootclvmodel.cpp b/ql/experimental/models/squarerootclvmodel.cpp
index 67749242d7f..cd139a6272c 100644
--- a/ql/experimental/models/squarerootclvmodel.cpp
+++ b/ql/experimental/models/squarerootclvmodel.cpp
@@ -70,8 +70,8 @@ namespace QuantLib {
     }
 
 
-    Disposable<Array> SquareRootCLVModel::collocationPointsX(const Date& d)
-    const {
+    Array SquareRootCLVModel::collocationPointsX(const Date& d) const {
+
         const std::pair<Real, Real> p = nonCentralChiSquaredParams(d);
 
         Array x = GaussianQuadrature(lagrangeOrder_,
@@ -101,8 +101,7 @@ namespace QuantLib {
         return x;
     }
 
-    Disposable<Array> SquareRootCLVModel::collocationPointsY(const Date& d)
-    const {
+    Array SquareRootCLVModel::collocationPointsY(const Date& d) const {
 
         const Array x = collocationPointsX(d);
         const std::pair<Real, Real> params = nonCentralChiSquaredParams(d);
diff --git a/ql/experimental/models/squarerootclvmodel.hpp b/ql/experimental/models/squarerootclvmodel.hpp
index b8a95b4f23e..a981cdd5fd5 100644
--- a/ql/experimental/models/squarerootclvmodel.hpp
+++ b/ql/experimental/models/squarerootclvmodel.hpp
@@ -54,10 +54,10 @@ namespace QuantLib {
         Real invCDF(const Date& d, Real q) const;
 
         // collocation points of the square root process
-        Disposable<Array> collocationPointsX(const Date& d) const;
+        Array collocationPointsX(const Date& d) const;
 
         // collocation points for the underlying Y
-        Disposable<Array> collocationPointsY(const Date& d) const;
+        Array collocationPointsY(const Date& d) const;
 
         // CLV mapping function
         ext::function<Real(Time, Real)> g() const;
diff --git a/ql/experimental/processes/extouwithjumpsprocess.cpp b/ql/experimental/processes/extouwithjumpsprocess.cpp
index 810457a5dbc..9e5aea72a65 100644
--- a/ql/experimental/processes/extouwithjumpsprocess.cpp
+++ b/ql/experimental/processes/extouwithjumpsprocess.cpp
@@ -58,31 +58,28 @@ namespace QuantLib {
         return eta_;
     }
 
-    Disposable<Array> ExtOUWithJumpsProcess::initialValues() const {
-        Array retVal(2);
-        retVal[0] = ouProcess_->x0();
-        retVal[1] = Y0_;
-        
-        return retVal;
+    Array ExtOUWithJumpsProcess::initialValues() const {
+        return  {
+            ouProcess_->x0(),
+            Y0_
+        };
     }
     
-    Disposable<Array> ExtOUWithJumpsProcess::drift(Time t, const Array& x) const {
-        Array retVal(2);
-        retVal[0] = ouProcess_->drift(t, x[0]);
-        retVal[1] = -beta_*x[1];
-        
-        return retVal;
+    Array ExtOUWithJumpsProcess::drift(Time t, const Array& x) const {
+        return {
+            ouProcess_->drift(t, x[0]),
+            -beta_*x[1]
+        };
     }
 
-    Disposable<Matrix> 
-    ExtOUWithJumpsProcess::diffusion(Time t, const Array& x) const {
+    Matrix ExtOUWithJumpsProcess::diffusion(Time t, const Array& x) const {
         Matrix retVal(2, 2, 0.0);    
         retVal[0][0] = ouProcess_->diffusion(t, x[0]);
         
         return retVal;
     }
 
-    Disposable<Array> ExtOUWithJumpsProcess::evolve(
+    Array ExtOUWithJumpsProcess::evolve(
         Time t0, const Array& x0, Time dt, const Array& dw) const {
         
         Array retVal(2);
diff --git a/ql/experimental/processes/extouwithjumpsprocess.hpp b/ql/experimental/processes/extouwithjumpsprocess.hpp
index fc4d6457fd2..821e2765061 100644
--- a/ql/experimental/processes/extouwithjumpsprocess.hpp
+++ b/ql/experimental/processes/extouwithjumpsprocess.hpp
@@ -67,13 +67,12 @@ namespace QuantLib {
         Size size() const override;
         Size factors() const override;
 
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
-        ext::shared_ptr<ExtendedOrnsteinUhlenbeckProcess>
-                                 getExtendedOrnsteinUhlenbeckProcess() const;
+        ext::shared_ptr<ExtendedOrnsteinUhlenbeckProcess> getExtendedOrnsteinUhlenbeckProcess() const;
 
         Real beta()          const;
         Real eta()           const;
diff --git a/ql/experimental/processes/hestonslvprocess.cpp b/ql/experimental/processes/hestonslvprocess.cpp
index b34900e2fcb..2e4324bd7b3 100644
--- a/ql/experimental/processes/hestonslvprocess.cpp
+++ b/ql/experimental/processes/hestonslvprocess.cpp
@@ -48,7 +48,7 @@ namespace QuantLib {
         mixedSigma_ = mixingFactor_ * sigma_;
     }
 
-    Disposable<Array> HestonSLVProcess::drift(Time t, const Array& x) const {
+    Array HestonSLVProcess::drift(Time t, const Array& x) const {
         Array tmp(2);
 
         const Volatility vol =
@@ -63,8 +63,7 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Matrix> HestonSLVProcess::diffusion(Time t, const Array& x)
-    const {
+    Matrix HestonSLVProcess::diffusion(Time t, const Array& x) const {
 
         const Real vol =
             std::max(1e-8, std::sqrt(x[1])*leverageFct_->localVol(t, x[0], true));
@@ -79,7 +78,7 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Array> HestonSLVProcess::evolve(
+    Array HestonSLVProcess::evolve(
         Time t0, const Array& x0, Time dt, const Array& dw) const {
         Array retVal(2);
 
diff --git a/ql/experimental/processes/hestonslvprocess.hpp b/ql/experimental/processes/hestonslvprocess.hpp
index 995f6b19a76..a5c48e0254f 100644
--- a/ql/experimental/processes/hestonslvprocess.hpp
+++ b/ql/experimental/processes/hestonslvprocess.hpp
@@ -41,14 +41,16 @@ namespace QuantLib {
 
         void update() override;
 
-        Disposable<Array> initialValues() const override { return hestonProcess_->initialValues(); }
-        Disposable<Array> apply(const Array& x0, const Array& dx) const override {
+        Array initialValues() const override {
+            return hestonProcess_->initialValues();
+        }
+        Array apply(const Array& x0, const Array& dx) const override {
             return hestonProcess_->apply(x0, dx);
         }
 
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
         Real v0()    const { return v0_; }
         Real rho()   const { return rho_; }
diff --git a/ql/experimental/processes/klugeextouprocess.cpp b/ql/experimental/processes/klugeextouprocess.cpp
index b9eaa1f59a3..77a6e61d5bd 100644
--- a/ql/experimental/processes/klugeextouprocess.cpp
+++ b/ql/experimental/processes/klugeextouprocess.cpp
@@ -43,7 +43,7 @@ namespace QuantLib {
         return klugeProcess_->factors() + 1;
     }
 
-    Disposable<Array> KlugeExtOUProcess::initialValues() const {
+    Array KlugeExtOUProcess::initialValues() const {
         Array retVal(size());
         const Array x0 = klugeProcess_->initialValues();
         std::copy(x0.begin(), x0.end(), retVal.begin());
@@ -52,7 +52,7 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<Array> KlugeExtOUProcess::drift(Time t, const Array& x) const {
+    Array KlugeExtOUProcess::drift(Time t, const Array& x) const {
         Array retVal(size());
         Array mu = klugeProcess_->drift(t, x);
         std::copy(mu.begin(), mu.end(), retVal.begin());
@@ -61,8 +61,7 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<Matrix> KlugeExtOUProcess::diffusion(Time t, const Array& x)
-        const{
+    Matrix KlugeExtOUProcess::diffusion(Time t, const Array& x) const{
         Matrix retVal(size(), factors(), 0.0);
 
         Volatility vol = ouProcess_->diffusion(t, x.back());
@@ -74,7 +73,7 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<Array> KlugeExtOUProcess::evolve(Time t0, const Array& x0,
+    Array KlugeExtOUProcess::evolve(Time t0, const Array& x0,
                                                 Time dt, const Array& dw) const{
         Array retVal(size());
 
diff --git a/ql/experimental/processes/klugeextouprocess.hpp b/ql/experimental/processes/klugeextouprocess.hpp
index 10562a1b1af..7edae5677a6 100644
--- a/ql/experimental/processes/klugeextouprocess.hpp
+++ b/ql/experimental/processes/klugeextouprocess.hpp
@@ -62,14 +62,13 @@ namespace QuantLib {
         Size size() const override;
         Size factors() const override;
 
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
         ext::shared_ptr<ExtOUWithJumpsProcess> getKlugeProcess() const;
-        ext::shared_ptr<ExtendedOrnsteinUhlenbeckProcess>
-                                                 getExtOUProcess() const;
+        ext::shared_ptr<ExtendedOrnsteinUhlenbeckProcess> getExtOUProcess() const;
 
         Real rho() const;
 
diff --git a/ql/experimental/swaptions/haganirregularswaptionengine.cpp b/ql/experimental/swaptions/haganirregularswaptionengine.cpp
index 9e77e43284c..0766b997512 100644
--- a/ql/experimental/swaptions/haganirregularswaptionengine.cpp
+++ b/ql/experimental/swaptions/haganirregularswaptionengine.cpp
@@ -107,7 +107,7 @@ namespace QuantLib {
 
     //computes a replication of the swap in terms of a basket of vanilla swaps 
     //by solving a linear system of equation 
-    Disposable<Array> HaganIrregularSwaptionEngine::Basket::compute(Rate lambda) const {
+    Array HaganIrregularSwaptionEngine::Basket::compute(Rate lambda) const {
 
         //update members
         lambda_ = lambda;
@@ -164,17 +164,14 @@ namespace QuantLib {
 
         SVD svd(arr);
 
-        Disposable<Array> weights = svd.solveFor(rhs);
-
-        return weights;
-
+        return svd.solveFor(rhs);
     }
 
 
 
     Real HaganIrregularSwaptionEngine::Basket::operator()(Rate lambda) const {
 
-        Disposable<Array> weights = compute(lambda);
+        Array weights = compute(lambda);
 
         Real defect = -targetNPV_;
 
@@ -362,7 +359,7 @@ namespace QuantLib {
              ext::shared_ptr<PricingEngine>(new BlackSwaptionEngine(termStructure_,volatilityStructure_));
 
         //retrieve weights of underlying swaps
-        Disposable<Array> weights = basket.weights();
+        Array weights = basket.weights();
 
         Real npv = 0.0;
 
diff --git a/ql/experimental/swaptions/haganirregularswaptionengine.hpp b/ql/experimental/swaptions/haganirregularswaptionengine.hpp
index 6fed0723da1..3bc249432b9 100644
--- a/ql/experimental/swaptions/haganirregularswaptionengine.hpp
+++ b/ql/experimental/swaptions/haganirregularswaptionengine.hpp
@@ -62,10 +62,10 @@ namespace QuantLib {
           Basket(ext::shared_ptr<IrregularSwap> swap,
                  Handle<YieldTermStructure> termStructure,
                  Handle<SwaptionVolatilityStructure> volatilityStructure);
-          Disposable<Array> compute(Rate lambda = 0.0) const;
+          Array compute(Rate lambda = 0.0) const;
           Real operator()(Rate x) const;
           ext::shared_ptr<VanillaSwap> component(Size i) const;
-          Disposable<Array> weights() const { return compute(lambda_); };
+          Array weights() const { return compute(lambda_); };
           Real& lambda() const { return lambda_; };
           ext::shared_ptr<IrregularSwap> swap() const { return swap_; };
         private:
diff --git a/ql/experimental/volatility/zabr.cpp b/ql/experimental/volatility/zabr.cpp
index 73a2d58760d..e3c3016f7ee 100644
--- a/ql/experimental/volatility/zabr.cpp
+++ b/ql/experimental/volatility/zabr.cpp
@@ -66,8 +66,7 @@ Real ZabrModel::lognormalVolatility(const Real strike) const {
     return lognormalVolatility(std::vector<Real>(1, strike))[0];
 }
 
-Disposable<std::vector<Real> >
-ZabrModel::lognormalVolatility(const std::vector<Real> &strikes) const {
+std::vector<Real> ZabrModel::lognormalVolatility(const std::vector<Real> &strikes) const {
     std::vector<Real> x_ = x(strikes);
     std::vector<Real> result(strikes.size());
     std::transform(strikes.begin(), strikes.end(), x_.begin(), result.begin(),
@@ -86,8 +85,7 @@ Real ZabrModel::normalVolatility(const Real strike) const {
     return normalVolatility(std::vector<Real>(1, strike))[0];
 }
 
-Disposable<std::vector<Real> >
-ZabrModel::normalVolatility(const std::vector<Real> &strikes) const {
+std::vector<Real> ZabrModel::normalVolatility(const std::vector<Real> &strikes) const {
     std::vector<Real> x_ = x(strikes);
     std::vector<Real> result(strikes.size());
     std::transform(strikes.begin(), strikes.end(), x_.begin(), result.begin(),
@@ -106,8 +104,7 @@ Real ZabrModel::localVolatility(const Real f) const {
     return localVolatility(std::vector<Real>(1, f))[0];
 }
 
-Disposable<std::vector<Real> >
-ZabrModel::localVolatility(const std::vector<Real> &f) const {
+std::vector<Real> ZabrModel::localVolatility(const std::vector<Real> &f) const {
     std::vector<Real> x_ = x(f);
     std::vector<Real> result(f.size());
     std::transform(f.begin(), f.end(), x_.begin(), result.begin(),
@@ -119,8 +116,7 @@ Real ZabrModel::fdPrice(const Real strike) const {
     return fdPrice(std::vector<Real>(1, strike))[0];
 }
 
-Disposable<std::vector<Real> >
-ZabrModel::fdPrice(const std::vector<Real> &strikes) const {
+std::vector<Real> ZabrModel::fdPrice(const std::vector<Real> &strikes) const {
 
     // TODO check strikes to be increasing
     // TODO put these parameters somewhere
@@ -309,8 +305,7 @@ Real ZabrModel::x(const Real strike) const {
     return x(std::vector<Real>(1, strike))[0];
 }
 
-Disposable<std::vector<Real> >
-ZabrModel::x(const std::vector<Real> &strikes) const {
+std::vector<Real> ZabrModel::x(const std::vector<Real> &strikes) const {
 
     QL_REQUIRE(strikes[0] > 0.0 || beta_ < 1.0,
                "strikes must be positive (" << strikes[0] << ") if beta = 1");
diff --git a/ql/experimental/volatility/zabr.hpp b/ql/experimental/volatility/zabr.hpp
index cbbbe897b5e..3d5066822bb 100644
--- a/ql/experimental/volatility/zabr.hpp
+++ b/ql/experimental/volatility/zabr.hpp
@@ -27,7 +27,6 @@
 #define quantlib_zabr_hpp
 
 #include <ql/types.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <ql/math/statistics/incrementalstatistics.hpp>
 #include <ql/math/interpolations/linearinterpolation.hpp>
 #include <ql/math/interpolations/cubicinterpolation.hpp>
@@ -42,22 +41,18 @@ class ZabrModel {
     ZabrModel(Real expiryTime, Real forward, Real alpha, Real beta, Real nu, Real rho, Real gamma);
 
     Real localVolatility(Real f) const;
-    Disposable<std::vector<Real> >
-    localVolatility(const std::vector<Real> &f) const;
+    std::vector<Real> localVolatility(const std::vector<Real> &f) const;
 
     Real fdPrice(Real strike) const;
-    Disposable<std::vector<Real> >
-    fdPrice(const std::vector<Real> &strikes) const;
+    std::vector<Real> fdPrice(const std::vector<Real> &strikes) const;
 
     Real fullFdPrice(Real strike) const;
 
     Real lognormalVolatility(Real strike) const;
-    Disposable<std::vector<Real> >
-    lognormalVolatility(const std::vector<Real> &strikes) const;
+    std::vector<Real> lognormalVolatility(const std::vector<Real> &strikes) const;
 
     Real normalVolatility(Real strike) const;
-    Disposable<std::vector<Real> >
-    normalVolatility(const std::vector<Real> &strikes) const;
+    std::vector<Real> normalVolatility(const std::vector<Real> &strikes) const;
 
     Real forward() const { return forward_; }
     Real expiryTime() const { return expiryTime_; }
@@ -73,7 +68,7 @@ class ZabrModel {
         gamma_; // nu_ here is a tranformed version of the input nu !
 
     Real x(Real strike) const;
-    Disposable<std::vector<Real> > x(const std::vector<Real> &strikes) const;
+    std::vector<Real> x(const std::vector<Real> &strikes) const;
 
     Real y(Real strike) const;
 
diff --git a/ql/grid.hpp b/ql/grid.hpp
index 260c927d119..077c541717e 100644
--- a/ql/grid.hpp
+++ b/ql/grid.hpp
@@ -28,22 +28,20 @@
 
 namespace QuantLib {
 
-    Disposable<Array> CenteredGrid(Real center, Real dx, Size steps);
-    Disposable<Array> BoundedGrid(Real xMin, Real xMax, Size steps);
-    Disposable<Array> BoundedLogGrid(Real xMin, Real xMax, Size steps);
+    Array CenteredGrid(Real center, Real dx, Size steps);
+    Array BoundedGrid(Real xMin, Real xMax, Size steps);
+    Array BoundedLogGrid(Real xMin, Real xMax, Size steps);
 
     // inline definitions
 
-    inline Disposable<Array> CenteredGrid(Real center, Real dx,
-                                          Size steps) {
+    inline Array CenteredGrid(Real center, Real dx, Size steps) {
         Array result(steps+1);
         for (Size i=0; i<steps+1; i++)
             result[i] = center + (i - steps/2.0)*dx;
         return result;
     }
 
-    inline Disposable<Array> BoundedGrid(Real xMin, Real xMax,
-                                         Size steps) {
+    inline Array BoundedGrid(Real xMin, Real xMax, Size steps) {
         Array result(steps+1);
         Real x=xMin, dx=(xMax-xMin)/steps;
         for (Size i=0; i<steps+1; i++, x+=dx)
@@ -51,8 +49,7 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<Array> BoundedLogGrid(Real xMin, Real xMax,
-                                            Size steps) {
+    inline Array BoundedLogGrid(Real xMin, Real xMax, Size steps) {
         Array result(steps+1);
         Real gridLogSpacing = (std::log(xMax) - std::log(xMin)) / 
             (steps);
diff --git a/ql/instruments/floatfloatswaption.cpp b/ql/instruments/floatfloatswaption.cpp
index 13e946e272e..902f1ebbb88 100644
--- a/ql/instruments/floatfloatswaption.cpp
+++ b/ql/instruments/floatfloatswaption.cpp
@@ -60,7 +60,7 @@ namespace QuantLib {
                                                   settlementMethod);
     }
 
-    Disposable<std::vector<ext::shared_ptr<BlackCalibrationHelper> > >
+    std::vector<ext::shared_ptr<BlackCalibrationHelper>>
     FloatFloatSwaption::calibrationBasket(
         const ext::shared_ptr<SwapIndex>& standardSwapBase,
         const ext::shared_ptr<SwaptionVolatilityStructure>& swaptionVolatility,
diff --git a/ql/instruments/floatfloatswaption.hpp b/ql/instruments/floatfloatswaption.hpp
index 1afbc9e385d..4f0dbd5bf5a 100644
--- a/ql/instruments/floatfloatswaption.hpp
+++ b/ql/instruments/floatfloatswaption.hpp
@@ -30,7 +30,6 @@
 #include <ql/termstructures/yieldtermstructure.hpp>
 #include <ql/termstructures/volatility/swaption/swaptionvolstructure.hpp>
 #include <ql/models/calibrationhelper.hpp>
-#include <ql/utilities/disposable.hpp>
 
 namespace QuantLib {
 
@@ -62,7 +61,7 @@ namespace QuantLib {
             return swap_;
         }
         //@}
-        Disposable<std::vector<ext::shared_ptr<BlackCalibrationHelper> > >
+        std::vector<ext::shared_ptr<BlackCalibrationHelper>>
         calibrationBasket(const ext::shared_ptr<SwapIndex>& standardSwapBase,
                           const ext::shared_ptr<SwaptionVolatilityStructure>& swaptionVolatility,
                           BasketGeneratingEngine::CalibrationBasketType basketType =
diff --git a/ql/instruments/nonstandardswaption.cpp b/ql/instruments/nonstandardswaption.cpp
index c4afefbdd63..b9ca5ec0202 100644
--- a/ql/instruments/nonstandardswaption.cpp
+++ b/ql/instruments/nonstandardswaption.cpp
@@ -73,7 +73,7 @@ namespace QuantLib {
                                                   settlementMethod);
     }
 
-    Disposable<std::vector<ext::shared_ptr<BlackCalibrationHelper> > >
+    std::vector<ext::shared_ptr<BlackCalibrationHelper>>
     NonstandardSwaption::calibrationBasket(
         const ext::shared_ptr<SwapIndex>& standardSwapBase,
         const ext::shared_ptr<SwaptionVolatilityStructure>& swaptionVolatility,
diff --git a/ql/instruments/nonstandardswaption.hpp b/ql/instruments/nonstandardswaption.hpp
index 99f390e54cc..caae8ff9fb0 100644
--- a/ql/instruments/nonstandardswaption.hpp
+++ b/ql/instruments/nonstandardswaption.hpp
@@ -31,7 +31,6 @@
 #include <ql/termstructures/yieldtermstructure.hpp>
 #include <ql/termstructures/volatility/swaption/swaptionvolstructure.hpp>
 #include <ql/models/calibrationhelper.hpp>
-#include <ql/utilities/disposable.hpp>
 
 namespace QuantLib {
 
@@ -66,7 +65,7 @@ namespace QuantLib {
             return swap_;
         }
         //@}
-        Disposable<std::vector<ext::shared_ptr<BlackCalibrationHelper> > >
+        std::vector<ext::shared_ptr<BlackCalibrationHelper>>
         calibrationBasket(const ext::shared_ptr<SwapIndex>& standardSwapBase,
                           const ext::shared_ptr<SwaptionVolatilityStructure>& swaptionVolatility,
                           BasketGeneratingEngine::CalibrationBasketType basketType =
diff --git a/ql/legacy/libormarketmodels/lfmcovarparam.cpp b/ql/legacy/libormarketmodels/lfmcovarparam.cpp
index 524cbf05e08..5d834051569 100644
--- a/ql/legacy/libormarketmodels/lfmcovarparam.cpp
+++ b/ql/legacy/libormarketmodels/lfmcovarparam.cpp
@@ -44,15 +44,13 @@ namespace QuantLib {
                                   m.row_begin(j_), 0.0);
     }
 
-    Disposable<Matrix> LfmCovarianceParameterization::covariance(
-                                               Time t, const Array& x) const {
+    Matrix LfmCovarianceParameterization::covariance(Time t, const Array& x) const {
         Matrix sigma = this->diffusion(t, x);
         Matrix result = sigma*transpose(sigma);
         return result;
     }
 
-    Disposable<Matrix> LfmCovarianceParameterization::integratedCovariance(
-                                               Time t, const Array& x) const {
+    Matrix LfmCovarianceParameterization::integratedCovariance(Time t, const Array& x) const {
         // this implementation is not intended for production.
         // because it is too slow and too inefficient.
         // This method is useful for testing and R&D.
diff --git a/ql/legacy/libormarketmodels/lfmcovarparam.hpp b/ql/legacy/libormarketmodels/lfmcovarparam.hpp
index 40fec85fbd7..2367d26ccfd 100644
--- a/ql/legacy/libormarketmodels/lfmcovarparam.hpp
+++ b/ql/legacy/libormarketmodels/lfmcovarparam.hpp
@@ -45,12 +45,9 @@ namespace QuantLib {
         Size size() const { return size_; }
         Size factors() const { return factors_; }
 
-        virtual Disposable<Matrix> diffusion(
-                            Time t, const Array& x = Null<Array>()) const = 0;
-        virtual Disposable<Matrix> covariance(
-                            Time t, const Array& x = Null<Array>()) const;
-        virtual Disposable<Matrix> integratedCovariance(
-                            Time t, const Array& x = Null<Array>()) const;
+        virtual Matrix diffusion(Time t, const Array& x = Null<Array>()) const = 0;
+        virtual Matrix covariance(Time t, const Array& x = Null<Array>()) const;
+        virtual Matrix integratedCovariance(Time t, const Array& x = Null<Array>()) const;
 
       protected:
         const Size size_;
diff --git a/ql/legacy/libormarketmodels/lfmcovarproxy.cpp b/ql/legacy/libormarketmodels/lfmcovarproxy.cpp
index 20138977d78..454eb15cf17 100644
--- a/ql/legacy/libormarketmodels/lfmcovarproxy.cpp
+++ b/ql/legacy/libormarketmodels/lfmcovarproxy.cpp
@@ -45,8 +45,7 @@ namespace QuantLib {
         return corrModel_;
     }
 
-    Disposable<Matrix> LfmCovarianceProxy::diffusion(Time t,
-                                                     const Array& x) const {
+    Matrix LfmCovarianceProxy::diffusion(Time t, const Array& x) const {
 
         Matrix pca = corrModel_->pseudoSqrt(t, x);
         Array  vol = volaModel_->volatility(t, x);
@@ -59,8 +58,7 @@ namespace QuantLib {
         return pca;
     }
 
-    Disposable<Matrix> LfmCovarianceProxy::covariance(Time t,
-                                                      const Array& x) const {
+    Matrix LfmCovarianceProxy::covariance(Time t, const Array& x) const {
 
         Array  volatility  = volaModel_->volatility(t, x);
         Matrix correlation = corrModel_->correlation(t, x);
diff --git a/ql/legacy/libormarketmodels/lfmcovarproxy.hpp b/ql/legacy/libormarketmodels/lfmcovarproxy.hpp
index 5f84677bad3..abdefcc0a17 100644
--- a/ql/legacy/libormarketmodels/lfmcovarproxy.hpp
+++ b/ql/legacy/libormarketmodels/lfmcovarproxy.hpp
@@ -40,8 +40,8 @@ namespace QuantLib {
         ext::shared_ptr<LmVolatilityModel>  volatilityModel() const;
         ext::shared_ptr<LmCorrelationModel> correlationModel() const;
 
-        Disposable<Matrix> diffusion(Time t, const Array& x = Null<Array>()) const override;
-        Disposable<Matrix> covariance(Time t, const Array& x = Null<Array>()) const override;
+        Matrix diffusion(Time t, const Array& x = Null<Array>()) const override;
+        Matrix covariance(Time t, const Array& x = Null<Array>()) const override;
 
         using LfmCovarianceParameterization::integratedCovariance;
         virtual Real integratedCovariance(
diff --git a/ql/legacy/libormarketmodels/lfmhullwhiteparam.cpp b/ql/legacy/libormarketmodels/lfmhullwhiteparam.cpp
index 147fc0e1568..b28eb9c962f 100644
--- a/ql/legacy/libormarketmodels/lfmhullwhiteparam.cpp
+++ b/ql/legacy/libormarketmodels/lfmhullwhiteparam.cpp
@@ -93,8 +93,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<Matrix> LfmHullWhiteParameterization::diffusion(
-                                                 Time t, const Array&) const {
+    Matrix LfmHullWhiteParameterization::diffusion(Time t, const Array&) const {
         Matrix tmp(size_, factors_, 0.0);
         const Size m = nextIndexReset(t);
 
@@ -106,8 +105,7 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Matrix> LfmHullWhiteParameterization::covariance(
-                                                 Time t, const Array&) const {
+    Matrix LfmHullWhiteParameterization::covariance(Time t, const Array&) const {
         Matrix tmp(size_, size_, 0.0);
         const Size m = nextIndexReset(t);
 
@@ -120,8 +118,7 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Matrix> LfmHullWhiteParameterization::integratedCovariance(
-                                                 Time t, const Array&) const {
+    Matrix LfmHullWhiteParameterization::integratedCovariance(Time t, const Array&) const {
 
         Matrix tmp(size_, size_, 0.0);
 
diff --git a/ql/legacy/libormarketmodels/lfmhullwhiteparam.hpp b/ql/legacy/libormarketmodels/lfmhullwhiteparam.hpp
index 1078e2cc4ad..d874ad55483 100644
--- a/ql/legacy/libormarketmodels/lfmhullwhiteparam.hpp
+++ b/ql/legacy/libormarketmodels/lfmhullwhiteparam.hpp
@@ -45,10 +45,9 @@ namespace QuantLib {
             const ext::shared_ptr<OptionletVolatilityStructure> & capletVol,
             const Matrix& correlation = Matrix(), Size factors = 1);
 
-        Disposable<Matrix> diffusion(Time t, const Array& x = Null<Array>()) const override;
-        Disposable<Matrix> covariance(Time t, const Array& x = Null<Array>()) const override;
-        Disposable<Matrix> integratedCovariance(Time t,
-                                                const Array& x = Null<Array>()) const override;
+        Matrix diffusion(Time t, const Array& x = Null<Array>()) const override;
+        Matrix covariance(Time t, const Array& x = Null<Array>()) const override;
+        Matrix integratedCovariance(Time t, const Array& x = Null<Array>()) const override;
 
       protected:
         Size nextIndexReset(Time t) const;
diff --git a/ql/legacy/libormarketmodels/lfmprocess.cpp b/ql/legacy/libormarketmodels/lfmprocess.cpp
index 8ea3002e7c9..b03aea81282 100644
--- a/ql/legacy/libormarketmodels/lfmprocess.cpp
+++ b/ql/legacy/libormarketmodels/lfmprocess.cpp
@@ -66,8 +66,8 @@ namespace QuantLib {
         }
     }
 
-    Disposable<Array> LiborForwardModelProcess::drift(Time t,
-                                                      const Array& x) const {
+    Array LiborForwardModelProcess::drift(Time t,
+                                          const Array& x) const {
         Array f(size_, 0.0);
         Matrix covariance(lfmParam_->covariance(t, x));
 
@@ -83,18 +83,15 @@ namespace QuantLib {
         return f;
     }
 
-    Disposable<Matrix>
-    LiborForwardModelProcess::diffusion(Time t, const Array& x) const {
+    Matrix LiborForwardModelProcess::diffusion(Time t, const Array& x) const {
         return lfmParam_->diffusion(t, x);
     }
 
-    Disposable<Matrix> LiborForwardModelProcess::covariance(
-        Time t, const Array& x, Time dt) const {
+    Matrix LiborForwardModelProcess::covariance(Time t, const Array& x, Time dt) const {
         return lfmParam_->covariance(t, x)*dt;
     }
 
-    Disposable<Array> LiborForwardModelProcess::apply(
-        const Array& x0, const Array& dx) const {
+    Array LiborForwardModelProcess::apply(const Array& x0, const Array& dx) const {
         Array tmp(size_);
 
         for (Size k=0; k<size_; ++k) {
@@ -104,9 +101,8 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Array> LiborForwardModelProcess::evolve(
-                                             Time t0, const Array& x0,
-                                             Time dt, const Array& dw) const {
+    Array LiborForwardModelProcess::evolve(Time t0, const Array& x0,
+                                           Time dt, const Array& dw) const {
         /* predictor-corrector step to reduce discretization errors.
 
            Short - but slow - solution would be
@@ -149,9 +145,8 @@ namespace QuantLib {
         return f;
     }
 
-    Disposable<Array> LiborForwardModelProcess::initialValues() const {
-        Array tmp = initialValues_;
-        return tmp;
+    Array LiborForwardModelProcess::initialValues() const {
+        return initialValues_;
     }
 
     void LiborForwardModelProcess::setCovarParam(
diff --git a/ql/legacy/libormarketmodels/lfmprocess.hpp b/ql/legacy/libormarketmodels/lfmprocess.hpp
index f6fe40a7192..89a7e4f321d 100644
--- a/ql/legacy/libormarketmodels/lfmprocess.hpp
+++ b/ql/legacy/libormarketmodels/lfmprocess.hpp
@@ -59,14 +59,14 @@ namespace QuantLib {
       public:
         LiborForwardModelProcess(Size size, ext::shared_ptr<IborIndex> index);
 
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Matrix> covariance(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Array> apply(const Array& x0, const Array& dx) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Matrix covariance(Time t0, const Array& x0, Time dt) const override;
+        Array apply(const Array& x0, const Array& dx) const override;
 
         // implements the predictor-corrector schema
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
         Size size() const override;
         Size factors() const override;
diff --git a/ql/legacy/libormarketmodels/liborforwardmodel.cpp b/ql/legacy/libormarketmodels/liborforwardmodel.cpp
index df09a7fc022..1dcfd49c2d8 100644
--- a/ql/legacy/libormarketmodels/liborforwardmodel.cpp
+++ b/ql/legacy/libormarketmodels/liborforwardmodel.cpp
@@ -102,7 +102,7 @@ namespace QuantLib {
         return npv / (1.0 + capRate*tenor);
     }
 
-    Disposable<Array> LiborForwardModel::w_0(Size alpha, Size beta) const {
+    Array LiborForwardModel::w_0(Size alpha, Size beta) const {
         Array omega(beta+1,0.0);
         QL_REQUIRE(alpha<beta, "alpha needs to be smaller than beta");
 
diff --git a/ql/legacy/libormarketmodels/liborforwardmodel.hpp b/ql/legacy/libormarketmodels/liborforwardmodel.hpp
index bff89f1141e..f5cbbc7225a 100644
--- a/ql/legacy/libormarketmodels/liborforwardmodel.hpp
+++ b/ql/legacy/libormarketmodels/liborforwardmodel.hpp
@@ -71,7 +71,7 @@ namespace QuantLib {
         void setParams(const Array& params) override;
 
       protected:
-        Disposable<Array> w_0(Size alpha, Size beta) const;
+        Array w_0(Size alpha, Size beta) const;
 
         std::vector<Real> f_;
         std::vector<Time> accrualPeriod_;
diff --git a/ql/legacy/libormarketmodels/lmconstwrappercorrmodel.hpp b/ql/legacy/libormarketmodels/lmconstwrappercorrmodel.hpp
index e155690c0f2..44a10999bc9 100644
--- a/ql/legacy/libormarketmodels/lmconstwrappercorrmodel.hpp
+++ b/ql/legacy/libormarketmodels/lmconstwrappercorrmodel.hpp
@@ -38,10 +38,10 @@ namespace QuantLib {
 
         Size factors() const override { return corrModel_->factors(); }
 
-        Disposable<Matrix> correlation(Time t, const Array& x = Null<Array>()) const override {
+        Matrix correlation(Time t, const Array& x = Null<Array>()) const override {
             return corrModel_->correlation(t, x);
         }
-        Disposable<Matrix> pseudoSqrt(Time t, const Array& x = Null<Array>()) const override {
+        Matrix pseudoSqrt(Time t, const Array& x = Null<Array>()) const override {
             return corrModel_->pseudoSqrt(t, x);
         }
         Real correlation(Size i, Size j, Time t, const Array& x = Null<Array>()) const override {
diff --git a/ql/legacy/libormarketmodels/lmconstwrappervolmodel.hpp b/ql/legacy/libormarketmodels/lmconstwrappervolmodel.hpp
index 17cddda79b0..11c747d01e6 100644
--- a/ql/legacy/libormarketmodels/lmconstwrappervolmodel.hpp
+++ b/ql/legacy/libormarketmodels/lmconstwrappervolmodel.hpp
@@ -37,7 +37,7 @@ namespace QuantLib {
           volaModel_(volaModel) {
         }
 
-        Disposable<Array> volatility(Time t, const Array& x = Null<Array>()) const override {
+        Array volatility(Time t, const Array& x = Null<Array>()) const override {
             return volaModel_->volatility(t, x);
         }
         Volatility volatility(
diff --git a/ql/legacy/libormarketmodels/lmcorrmodel.cpp b/ql/legacy/libormarketmodels/lmcorrmodel.cpp
index 22ba1e76420..9866ecafb20 100644
--- a/ql/legacy/libormarketmodels/lmcorrmodel.cpp
+++ b/ql/legacy/libormarketmodels/lmcorrmodel.cpp
@@ -37,7 +37,7 @@ namespace QuantLib {
         return false;
     }
 
-    Disposable<Matrix> LmCorrelationModel::pseudoSqrt(
+    Matrix LmCorrelationModel::pseudoSqrt(
         Time t, const Array& x) const {
         return QuantLib::pseudoSqrt(this->correlation(t, x),
                                     SalvagingAlgorithm::Spectral);
diff --git a/ql/legacy/libormarketmodels/lmcorrmodel.hpp b/ql/legacy/libormarketmodels/lmcorrmodel.hpp
index bdb914a855b..209ddc0840c 100644
--- a/ql/legacy/libormarketmodels/lmcorrmodel.hpp
+++ b/ql/legacy/libormarketmodels/lmcorrmodel.hpp
@@ -43,15 +43,11 @@ namespace QuantLib {
         std::vector<Parameter>& params();
         void setParams(const std::vector<Parameter> & arguments);
 
-        virtual Disposable<Matrix> correlation(
-            Time t, const Array& x = Null<Array>()) const = 0;
-        virtual Disposable<Matrix> pseudoSqrt(
-            Time t, const Array& x = Null<Array>()) const;
-        virtual Real correlation(
-            Size i, Size j, Time t, const Array& x = Null<Array>()) const;
+        virtual Matrix correlation(Time t, const Array& x = Null<Array>()) const = 0;
+        virtual Matrix pseudoSqrt(Time t, const Array& x = Null<Array>()) const;
+        virtual Real correlation(Size i, Size j, Time t, const Array& x = Null<Array>()) const;
         virtual bool isTimeIndependent() const;
 
-
     protected:
         virtual void generateArguments() = 0;
 
diff --git a/ql/legacy/libormarketmodels/lmexpcorrmodel.cpp b/ql/legacy/libormarketmodels/lmexpcorrmodel.cpp
index 9171dc947aa..9a7c10b76f4 100644
--- a/ql/legacy/libormarketmodels/lmexpcorrmodel.cpp
+++ b/ql/legacy/libormarketmodels/lmexpcorrmodel.cpp
@@ -31,8 +31,7 @@ namespace QuantLib {
         generateArguments();
     }
 
-    Disposable<Matrix> LmExponentialCorrelationModel::correlation(
-                                                   Time, const Array&) const {
+    Matrix LmExponentialCorrelationModel::correlation(Time, const Array&) const {
 
         Matrix tmp(corrMatrix_);
         return tmp;
@@ -47,8 +46,7 @@ namespace QuantLib {
         return true;
     }
 
-    Disposable<Matrix> LmExponentialCorrelationModel::pseudoSqrt(
-                                                   Time, const Array&) const {
+    Matrix LmExponentialCorrelationModel::pseudoSqrt(Time, const Array&) const {
         Matrix tmp(pseudoSqrt_);
         return tmp;
     }
diff --git a/ql/legacy/libormarketmodels/lmexpcorrmodel.hpp b/ql/legacy/libormarketmodels/lmexpcorrmodel.hpp
index dd556fdad26..bfd259c1fa1 100644
--- a/ql/legacy/libormarketmodels/lmexpcorrmodel.hpp
+++ b/ql/legacy/libormarketmodels/lmexpcorrmodel.hpp
@@ -46,8 +46,8 @@ namespace QuantLib {
       public:
         LmExponentialCorrelationModel(Size size, Real rho);
 
-        Disposable<Matrix> correlation(Time t, const Array& x = Null<Array>()) const override;
-        Disposable<Matrix> pseudoSqrt(Time t, const Array& x = Null<Array>()) const override;
+        Matrix correlation(Time t, const Array& x = Null<Array>()) const override;
+        Matrix pseudoSqrt(Time t, const Array& x = Null<Array>()) const override;
         Real correlation(Size i, Size j, Time t, const Array& x) const override;
         bool isTimeIndependent() const override;
 
diff --git a/ql/legacy/libormarketmodels/lmextlinexpvolmodel.cpp b/ql/legacy/libormarketmodels/lmextlinexpvolmodel.cpp
index 4ff8ffe2739..4830194bbfa 100644
--- a/ql/legacy/libormarketmodels/lmextlinexpvolmodel.cpp
+++ b/ql/legacy/libormarketmodels/lmextlinexpvolmodel.cpp
@@ -33,7 +33,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<Array> LmExtLinearExponentialVolModel::volatility(
+    Array LmExtLinearExponentialVolModel::volatility(
                                                Time t, const Array& x) const {
         Array tmp = LmLinearExponentialVolatilityModel::volatility(t, x);
         for (Size i=0; i<size_; ++i) {
diff --git a/ql/legacy/libormarketmodels/lmextlinexpvolmodel.hpp b/ql/legacy/libormarketmodels/lmextlinexpvolmodel.hpp
index 7763f1b13bf..61f653afd43 100644
--- a/ql/legacy/libormarketmodels/lmextlinexpvolmodel.hpp
+++ b/ql/legacy/libormarketmodels/lmextlinexpvolmodel.hpp
@@ -49,7 +49,7 @@ namespace QuantLib {
         LmExtLinearExponentialVolModel(const std::vector<Time>& fixingTimes,
                                        Real a, Real b, Real c, Real d);
 
-        Disposable<Array> volatility(Time t, const Array& x = Null<Array>()) const override;
+        Array volatility(Time t, const Array& x = Null<Array>()) const override;
         Volatility volatility(Size i, Time t, const Array& x = Null<Array>()) const override;
 
         Real
diff --git a/ql/legacy/libormarketmodels/lmfixedvolmodel.cpp b/ql/legacy/libormarketmodels/lmfixedvolmodel.cpp
index ef0d65675ca..40af5884542 100644
--- a/ql/legacy/libormarketmodels/lmfixedvolmodel.cpp
+++ b/ql/legacy/libormarketmodels/lmfixedvolmodel.cpp
@@ -37,8 +37,7 @@ namespace QuantLib {
         }
     }
 
-    Disposable<Array> LmFixedVolatilityModel::volatility(
-                                                 Time t, const Array&) const {
+    Array LmFixedVolatilityModel::volatility(Time t, const Array&) const {
         QL_REQUIRE(t >= startTimes_.front() && t <= startTimes_.back(),
                    "invalid time given for volatility model");
 
diff --git a/ql/legacy/libormarketmodels/lmfixedvolmodel.hpp b/ql/legacy/libormarketmodels/lmfixedvolmodel.hpp
index 140172694f4..043cabb8d69 100644
--- a/ql/legacy/libormarketmodels/lmfixedvolmodel.hpp
+++ b/ql/legacy/libormarketmodels/lmfixedvolmodel.hpp
@@ -32,7 +32,7 @@ namespace QuantLib {
       public:
         LmFixedVolatilityModel(Array volatilities, const std::vector<Time>& startTimes);
 
-        Disposable<Array> volatility(Time t, const Array& x = Null<Array>()) const override;
+        Array volatility(Time t, const Array& x = Null<Array>()) const override;
         Volatility volatility(Size i, Time t, const Array& x) const override;
 
       private:
diff --git a/ql/legacy/libormarketmodels/lmlinexpcorrmodel.cpp b/ql/legacy/libormarketmodels/lmlinexpcorrmodel.cpp
index 5da87368390..313b29b69f2 100644
--- a/ql/legacy/libormarketmodels/lmlinexpcorrmodel.cpp
+++ b/ql/legacy/libormarketmodels/lmlinexpcorrmodel.cpp
@@ -32,8 +32,7 @@ namespace QuantLib {
         generateArguments();
     }
 
-    Disposable<Matrix> LmLinearExponentialCorrelationModel::correlation(
-                                                   Time, const Array&) const {
+    Matrix LmLinearExponentialCorrelationModel::correlation(Time, const Array&) const {
         Matrix tmp(corrMatrix_);
         return tmp;
     }
@@ -52,8 +51,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<Matrix> LmLinearExponentialCorrelationModel::pseudoSqrt(
-                                                   Time, const Array&) const {
+    Matrix LmLinearExponentialCorrelationModel::pseudoSqrt(Time, const Array&) const {
         Matrix tmp(pseudoSqrt_);
         return tmp;
     }
diff --git a/ql/legacy/libormarketmodels/lmlinexpcorrmodel.hpp b/ql/legacy/libormarketmodels/lmlinexpcorrmodel.hpp
index c49303e6347..6019462fcc1 100644
--- a/ql/legacy/libormarketmodels/lmlinexpcorrmodel.hpp
+++ b/ql/legacy/libormarketmodels/lmlinexpcorrmodel.hpp
@@ -47,8 +47,8 @@ namespace QuantLib {
         LmLinearExponentialCorrelationModel(Size size, Real rho, Real beta,
                                             Size factors = Null<Size>());
 
-        Disposable<Matrix> correlation(Time t, const Array& x = Null<Array>()) const override;
-        Disposable<Matrix> pseudoSqrt(Time t, const Array& x = Null<Array>()) const override;
+        Matrix correlation(Time t, const Array& x = Null<Array>()) const override;
+        Matrix pseudoSqrt(Time t, const Array& x = Null<Array>()) const override;
         Real correlation(Size i, Size j, Time t, const Array& x) const override;
 
         Size factors() const override;
diff --git a/ql/legacy/libormarketmodels/lmlinexpvolmodel.cpp b/ql/legacy/libormarketmodels/lmlinexpvolmodel.cpp
index 3a340d539ee..eb373043da4 100644
--- a/ql/legacy/libormarketmodels/lmlinexpvolmodel.cpp
+++ b/ql/legacy/libormarketmodels/lmlinexpvolmodel.cpp
@@ -33,7 +33,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<Array> LmLinearExponentialVolatilityModel::volatility(
+    Array LmLinearExponentialVolatilityModel::volatility(
                                                  Time t, const Array&) const {
         const Real a = arguments_[0](0.0);
         const Real b = arguments_[1](0.0);
diff --git a/ql/legacy/libormarketmodels/lmlinexpvolmodel.hpp b/ql/legacy/libormarketmodels/lmlinexpvolmodel.hpp
index 5461c82c9b2..7fcf0b618ce 100644
--- a/ql/legacy/libormarketmodels/lmlinexpvolmodel.hpp
+++ b/ql/legacy/libormarketmodels/lmlinexpvolmodel.hpp
@@ -49,7 +49,7 @@ namespace QuantLib {
                                          const std::vector<Time>& fixingTimes,
                                          Real a, Real b, Real c, Real d);
 
-        Disposable<Array> volatility(Time t, const Array& x = Null<Array>()) const override;
+        Array volatility(Time t, const Array& x = Null<Array>()) const override;
         Volatility volatility(Size i, Time t, const Array& x = Null<Array>()) const override;
 
         Real
diff --git a/ql/legacy/libormarketmodels/lmvolmodel.hpp b/ql/legacy/libormarketmodels/lmvolmodel.hpp
index e03b47fcfd4..d6108cd7bc6 100644
--- a/ql/legacy/libormarketmodels/lmvolmodel.hpp
+++ b/ql/legacy/libormarketmodels/lmvolmodel.hpp
@@ -40,10 +40,8 @@ namespace QuantLib {
         std::vector<Parameter> & params();
         void setParams(const std::vector<Parameter> & arguments);
 
-        virtual Disposable<Array> volatility(
-             Time t, const Array& x = Null<Array>()) const = 0;
-        virtual Volatility volatility(
-             Size i, Time t, const Array& x = Null<Array>()) const;
+        virtual Array volatility(Time t, const Array& x = Null<Array>()) const = 0;
+        virtual Volatility volatility(Size i, Time t, const Array& x = Null<Array>()) const;
         virtual Real integratedVariance(Size i, Size j, Time u,
                                         const Array& x = Null<Array>()) const;
 
diff --git a/ql/math/array.hpp b/ql/math/array.hpp
index 9f16bf2ec21..b42a9bc17f1 100644
--- a/ql/math/array.hpp
+++ b/ql/math/array.hpp
@@ -29,7 +29,6 @@
 #include <ql/types.hpp>
 #include <ql/errors.hpp>
 #include <ql/math/functional.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <ql/utilities/null.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
 #include <boost/type_traits.hpp>
@@ -65,9 +64,6 @@ namespace QuantLib {
         Array(Size size, Real value, Real increment);
         Array(const Array&);
         Array(Array&&) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        Array(const Disposable<Array>&);
-        #endif
         Array(std::initializer_list<Real>);
         //! creates the array from an iterable sequence
         template <class ForwardIterator>
@@ -75,9 +71,6 @@ namespace QuantLib {
 
         Array& operator=(const Array&);
         Array& operator=(Array&&) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        Array& operator=(const Disposable<Array>&);
-        #endif
 
         bool operator==(const Array&) const;
         bool operator!=(const Array&) const;
@@ -169,47 +162,47 @@ namespace QuantLib {
 
     // unary operators
     /*! \relates Array */
-    Disposable<Array> operator+(const Array& v);
+    Array operator+(const Array& v);
     /*! \relates Array */
-    Disposable<Array> operator-(const Array& v);
+    Array operator-(const Array& v);
 
     // binary operators
     /*! \relates Array */
-    Disposable<Array> operator+(const Array&, const Array&);
+    Array operator+(const Array&, const Array&);
     /*! \relates Array */
-    Disposable<Array> operator+(const Array&, Real);
+    Array operator+(const Array&, Real);
     /*! \relates Array */
-    Disposable<Array> operator+(Real, const Array&);
+    Array operator+(Real, const Array&);
     /*! \relates Array */
-    Disposable<Array> operator-(const Array&, const Array&);
+    Array operator-(const Array&, const Array&);
     /*! \relates Array */
-    Disposable<Array> operator-(const Array&, Real);
+    Array operator-(const Array&, Real);
     /*! \relates Array */
-    Disposable<Array> operator-(Real, const Array&);
+    Array operator-(Real, const Array&);
     /*! \relates Array */
-    Disposable<Array> operator*(const Array&, const Array&);
+    Array operator*(const Array&, const Array&);
     /*! \relates Array */
-    Disposable<Array> operator*(const Array&, Real);
+    Array operator*(const Array&, Real);
     /*! \relates Array */
-    Disposable<Array> operator*(Real, const Array&);
+    Array operator*(Real, const Array&);
     /*! \relates Array */
-    Disposable<Array> operator/(const Array&, const Array&);
+    Array operator/(const Array&, const Array&);
     /*! \relates Array */
-    Disposable<Array> operator/(const Array&, Real);
+    Array operator/(const Array&, Real);
     /*! \relates Array */
-    Disposable<Array> operator/(Real, const Array&);
+    Array operator/(Real, const Array&);
 
     // math functions
     /*! \relates Array */
-    Disposable<Array> Abs(const Array&);
+    Array Abs(const Array&);
     /*! \relates Array */
-    Disposable<Array> Sqrt(const Array&);
+    Array Sqrt(const Array&);
     /*! \relates Array */
-    Disposable<Array> Log(const Array&);
+    Array Log(const Array&);
     /*! \relates Array */
-    Disposable<Array> Exp(const Array&);
+    Array Exp(const Array&);
     /*! \relates Array */
-    Disposable<Array> Pow(const Array&, Real);
+    Array Pow(const Array&, Real);
 
     // utilities
     /*! \relates Array */
@@ -249,13 +242,6 @@ namespace QuantLib {
         swap(from);
     }
 
-    #ifdef QL_USE_DISPOSABLE
-    inline Array::Array(const Disposable<Array>& from)
-    : data_((Real*)(0)), n_(0) {
-        swap(const_cast<Disposable<Array>&>(from));
-    }
-    #endif
-
     namespace detail {
 
         template <class I>
@@ -318,13 +304,6 @@ namespace QuantLib {
         return *this;
     }
 
-    #ifdef QL_USE_DISPOSABLE
-    inline Array& Array::operator=(const Disposable<Array>& from) {
-        swap(const_cast<Disposable<Array>&>(from));
-        return *this;
-    }
-    #endif
-
     inline bool Array::operator==(const Array& to) const {
         return (n_ == to.n_) && std::equal(begin(), end(), to.begin());
     }
@@ -528,12 +507,12 @@ namespace QuantLib {
 
     // unary
 
-    inline Disposable<Array> operator+(const Array& v) {
+    inline Array operator+(const Array& v) {
         Array result = v;
         return result;
     }
 
-    inline Disposable<Array> operator-(const Array& v) {
+    inline Array operator-(const Array& v) {
         Array result(v.size());
         std::transform(v.begin(),v.end(),result.begin(),
                        std::negate<Real>());
@@ -543,7 +522,7 @@ namespace QuantLib {
 
     // binary operators
 
-    inline Disposable<Array> operator+(const Array& v1, const Array& v2) {
+    inline Array operator+(const Array& v1, const Array& v2) {
         QL_REQUIRE(v1.size() == v2.size(),
                    "arrays with different sizes (" << v1.size() << ", "
                    << v2.size() << ") cannot be added");
@@ -553,21 +532,21 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<Array> operator+(const Array& v1, Real a) {
+    inline Array operator+(const Array& v1, Real a) {
         Array result(v1.size());
         std::transform(v1.begin(),v1.end(),result.begin(),
                        add<Real>(a));
         return result;
     }
 
-    inline Disposable<Array> operator+(Real a, const Array& v2) {
+    inline Array operator+(Real a, const Array& v2) {
         Array result(v2.size());
         std::transform(v2.begin(),v2.end(),result.begin(),
                        add<Real>(a));
         return result;
     }
 
-    inline Disposable<Array> operator-(const Array& v1, const Array& v2) {
+    inline Array operator-(const Array& v1, const Array& v2) {
         QL_REQUIRE(v1.size() == v2.size(),
                    "arrays with different sizes (" << v1.size() << ", "
                    << v2.size() << ") cannot be subtracted");
@@ -577,21 +556,21 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<Array> operator-(const Array& v1, Real a) {
+    inline Array operator-(const Array& v1, Real a) {
         Array result(v1.size());
         std::transform(v1.begin(),v1.end(),result.begin(),
                        subtract<Real>(a));
         return result;
     }
 
-    inline Disposable<Array> operator-(Real a, const Array& v2) {
+    inline Array operator-(Real a, const Array& v2) {
         Array result(v2.size());
         std::transform(v2.begin(),v2.end(),result.begin(),
                        subtract_from<Real>(a));
         return result;
     }
 
-    inline Disposable<Array> operator*(const Array& v1, const Array& v2) {
+    inline Array operator*(const Array& v1, const Array& v2) {
         QL_REQUIRE(v1.size() == v2.size(),
                    "arrays with different sizes (" << v1.size() << ", "
                    << v2.size() << ") cannot be multiplied");
@@ -601,21 +580,21 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<Array> operator*(const Array& v1, Real a) {
+    inline Array operator*(const Array& v1, Real a) {
         Array result(v1.size());
         std::transform(v1.begin(),v1.end(),result.begin(),
                        multiply_by<Real>(a));
         return result;
     }
 
-    inline Disposable<Array> operator*(Real a, const Array& v2) {
+    inline Array operator*(Real a, const Array& v2) {
         Array result(v2.size());
         std::transform(v2.begin(),v2.end(),result.begin(),
                        multiply_by<Real>(a));
         return result;
     }
 
-    inline Disposable<Array> operator/(const Array& v1, const Array& v2) {
+    inline Array operator/(const Array& v1, const Array& v2) {
         QL_REQUIRE(v1.size() == v2.size(),
                    "arrays with different sizes (" << v1.size() << ", "
                    << v2.size() << ") cannot be divided");
@@ -625,14 +604,14 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<Array> operator/(const Array& v1, Real a) {
+    inline Array operator/(const Array& v1, Real a) {
         Array result(v1.size());
         std::transform(v1.begin(),v1.end(),result.begin(),
                        divide_by<Real>(a));
         return result;
     }
 
-    inline Disposable<Array> operator/(Real a, const Array& v2) {
+    inline Array operator/(Real a, const Array& v2) {
         Array result(v2.size());
         std::transform(v2.begin(),v2.end(),result.begin(),
                        divide<Real>(a));
@@ -641,35 +620,35 @@ namespace QuantLib {
 
     // functions
 
-    inline Disposable<Array> Abs(const Array& v) {
+    inline Array Abs(const Array& v) {
         Array result(v.size());
         std::transform(v.begin(),v.end(),result.begin(),
                        static_cast<Real(*)(Real)>(std::fabs));
         return result;
     }
 
-    inline Disposable<Array> Sqrt(const Array& v) {
+    inline Array Sqrt(const Array& v) {
         Array result(v.size());
         std::transform(v.begin(),v.end(),result.begin(),
                        static_cast<Real(*)(Real)>(std::sqrt));
         return result;
     }
 
-    inline Disposable<Array> Log(const Array& v) {
+    inline Array Log(const Array& v) {
         Array result(v.size());
         std::transform(v.begin(),v.end(),result.begin(),
                        static_cast<Real(*)(Real)>(std::log));
         return result;
     }
 
-    inline Disposable<Array> Exp(const Array& v) {
+    inline Array Exp(const Array& v) {
         Array result(v.size());
         std::transform(v.begin(),v.end(),result.begin(),
                        static_cast<Real(*)(Real)>(std::exp));
         return result;
     }
 
-    inline Disposable<Array> Pow(const Array& v, Real alpha) {
+    inline Array Pow(const Array& v, Real alpha) {
         Array result(v.size());
         for (Size i=0; i<v.size(); ++i)
             result[i] = std::pow(v[i], alpha);
diff --git a/ql/math/interpolations/xabrinterpolation.hpp b/ql/math/interpolations/xabrinterpolation.hpp
index 3123067381d..4e957c769e4 100644
--- a/ql/math/interpolations/xabrinterpolation.hpp
+++ b/ql/math/interpolations/xabrinterpolation.hpp
@@ -259,7 +259,7 @@ class XABRInterpolationImpl : public Interpolation::templateImpl<I1, I2>,
     }
 
     // calculate weighted differences
-    Disposable<Array> interpolationErrors() const {
+    Array interpolationErrors() const {
         Array results(this->xEnd_ - this->xBegin_);
         I1 x = this->xBegin_;
         Array::iterator r = results.begin();
@@ -302,7 +302,7 @@ class XABRInterpolationImpl : public Interpolation::templateImpl<I1, I2>,
             return xabr_->interpolationSquaredError();
         }
 
-        Disposable<Array> values(const Array& x) const override {
+        Array values(const Array& x) const override {
             const Array y = Model().direct(x, xabr_->paramIsFixed_,
                                            xabr_->params_, xabr_->forward_);
             for (Size i = 0; i < xabr_->params_.size(); ++i)
diff --git a/ql/math/matrix.cpp b/ql/math/matrix.cpp
index 414dcdc9cff..2c80d6656ad 100644
--- a/ql/math/matrix.cpp
+++ b/ql/math/matrix.cpp
@@ -60,7 +60,7 @@
 
 namespace QuantLib {
 
-    Disposable<Matrix> inverse(const Matrix& m) {
+    Matrix inverse(const Matrix& m) {
         QL_REQUIRE(m.rows() == m.columns(), "matrix is not square");
 
         boost::numeric::ublas::matrix<Real> a(m.rows(), m.columns());
diff --git a/ql/math/matrix.hpp b/ql/math/matrix.hpp
index 40832be8628..ed1fa60b82b 100644
--- a/ql/math/matrix.hpp
+++ b/ql/math/matrix.hpp
@@ -56,16 +56,10 @@ namespace QuantLib {
         Matrix(Size rows, Size columns, Iterator begin, Iterator end);
         Matrix(const Matrix&);
         Matrix(Matrix&&) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        Matrix(const Disposable<Matrix>&);
-        #endif
         Matrix(std::initializer_list<std::initializer_list<Real>>);
 
         Matrix& operator=(const Matrix&);
         Matrix& operator=(Matrix&&) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        Matrix& operator=(const Disposable<Matrix>&);
-        #endif
         //@}
 
         //! \name Algebraic operators
@@ -128,7 +122,7 @@ namespace QuantLib {
         const_row_iterator at(Size) const;
         row_iterator operator[](Size);
         row_iterator at(Size);
-        Disposable<Array> diagonal() const;
+        Array diagonal() const;
         Real& operator()(Size i, Size j) const;
         //@}
 
@@ -153,38 +147,37 @@ namespace QuantLib {
     // algebraic operators
 
     /*! \relates Matrix */
-    Disposable<Matrix> operator+(const Matrix&, const Matrix&);
+    Matrix operator+(const Matrix&, const Matrix&);
     /*! \relates Matrix */
-    Disposable<Matrix> operator-(const Matrix&, const Matrix&);
+    Matrix operator-(const Matrix&, const Matrix&);
     /*! \relates Matrix */
-    Disposable<Matrix> operator*(const Matrix&, Real);
+    Matrix operator*(const Matrix&, Real);
     /*! \relates Matrix */
-    Disposable<Matrix> operator*(Real, const Matrix&);
+    Matrix operator*(Real, const Matrix&);
     /*! \relates Matrix */
-    Disposable<Matrix> operator/(const Matrix&, Real);
+    Matrix operator/(const Matrix&, Real);
 
 
     // vectorial products
 
     /*! \relates Matrix */
-    Disposable<Array> operator*(const Array&, const Matrix&);
+    Array operator*(const Array&, const Matrix&);
     /*! \relates Matrix */
-    Disposable<Array> operator*(const Matrix&, const Array&);
+    Array operator*(const Matrix&, const Array&);
     /*! \relates Matrix */
-    Disposable<Matrix> operator*(const Matrix&, const Matrix&);
+    Matrix operator*(const Matrix&, const Matrix&);
 
     // misc. operations
 
     /*! \relates Matrix */
-    Disposable<Matrix> transpose(const Matrix&);
+    Matrix transpose(const Matrix&);
 
     /*! \relates Matrix */
-    Disposable<Matrix> outerProduct(const Array& v1, const Array& v2);
+    Matrix outerProduct(const Array& v1, const Array& v2);
 
     /*! \relates Matrix */
     template <class Iterator1, class Iterator2>
-    Disposable<Matrix>
-    outerProduct(Iterator1 v1begin, Iterator1 v1end, Iterator2 v2begin, Iterator2 v2end);
+    Matrix outerProduct(Iterator1 v1begin, Iterator1 v1end, Iterator2 v2begin, Iterator2 v2end);
 
     /*! \relates Matrix */
     void swap(Matrix&, Matrix&);
@@ -193,7 +186,7 @@ namespace QuantLib {
     std::ostream& operator<<(std::ostream&, const Matrix&);
 
     /*! \relates Matrix */
-    Disposable<Matrix> inverse(const Matrix& m);
+    Matrix inverse(const Matrix& m);
 
     /*! \relates Matrix */
     Real determinant(const Matrix& m);
@@ -233,13 +226,6 @@ namespace QuantLib {
         swap(from);
     }
 
-    #ifdef QL_USE_DISPOSABLE
-    inline Matrix::Matrix(const Disposable<Matrix>& from)
-    : data_((Real*)(0)), rows_(0), columns_(0) {
-        swap(const_cast<Disposable<Matrix>&>(from));
-    }
-    #endif
-
     inline Matrix::Matrix(std::initializer_list<std::initializer_list<Real>> data)
     : data_(data.size() == 0 || data.begin()->size() == 0 ?
             (Real*)nullptr : new Real[data.size() * data.begin()->size()]),
@@ -267,13 +253,6 @@ namespace QuantLib {
         return *this;
     }
 
-    #ifdef QL_USE_DISPOSABLE
-    inline Matrix& Matrix::operator=(const Disposable<Matrix>& from) {
-        swap(const_cast<Disposable<Matrix>&>(from));
-        return *this;
-    }
-    #endif
-
     inline void Matrix::swap(Matrix& from) {
         using std::swap;
         data_.swap(from.data_);
@@ -480,7 +459,7 @@ namespace QuantLib {
         return row_begin(i);
     }
 
-    inline Disposable<Array> Matrix::diagonal() const {
+    inline Array Matrix::diagonal() const {
         Size arraySize = std::min<Size>(rows(), columns());
         Array tmp(arraySize);
         for(Size i = 0; i < arraySize; i++)
@@ -512,7 +491,7 @@ namespace QuantLib {
         return rows_ == 0 || columns_ == 0;
     }
 
-    inline Disposable<Matrix> operator+(const Matrix& m1, const Matrix& m2) {
+    inline Matrix operator+(const Matrix& m1, const Matrix& m2) {
         QL_REQUIRE(m1.rows() == m2.rows() &&
                    m1.columns() == m2.columns(),
                    "matrices with different sizes (" <<
@@ -525,7 +504,7 @@ namespace QuantLib {
         return temp;
     }
 
-    inline Disposable<Matrix> operator-(const Matrix& m1, const Matrix& m2) {
+    inline Matrix operator-(const Matrix& m1, const Matrix& m2) {
         QL_REQUIRE(m1.rows() == m2.rows() &&
                    m1.columns() == m2.columns(),
                    "matrices with different sizes (" <<
@@ -538,28 +517,28 @@ namespace QuantLib {
         return temp;
     }
 
-    inline Disposable<Matrix> operator*(const Matrix& m, Real x) {
+    inline Matrix operator*(const Matrix& m, Real x) {
         Matrix temp(m.rows(),m.columns());
         std::transform(m.begin(),m.end(),temp.begin(),
                        multiply_by<Real>(x));
         return temp;
     }
 
-    inline Disposable<Matrix> operator*(Real x, const Matrix& m) {
+    inline Matrix operator*(Real x, const Matrix& m) {
         Matrix temp(m.rows(),m.columns());
         std::transform(m.begin(),m.end(),temp.begin(),
                        multiply_by<Real>(x));
         return temp;
     }
 
-    inline Disposable<Matrix> operator/(const Matrix& m, Real x) {
+    inline Matrix operator/(const Matrix& m, Real x) {
         Matrix temp(m.rows(),m.columns());
         std::transform(m.begin(),m.end(),temp.begin(),
                        divide_by<Real>(x));
         return temp;
     }
 
-    inline Disposable<Array> operator*(const Array& v, const Matrix& m) {
+    inline Array operator*(const Array& v, const Matrix& m) {
         QL_REQUIRE(v.size() == m.rows(),
                    "vectors and matrices with different sizes ("
                    << v.size() << ", " << m.rows() << "x" << m.columns() <<
@@ -572,7 +551,7 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<Array> operator*(const Matrix& m, const Array& v) {
+    inline Array operator*(const Matrix& m, const Array& v) {
         QL_REQUIRE(v.size() == m.columns(),
                    "vectors and matrices with different sizes ("
                    << v.size() << ", " << m.rows() << "x" << m.columns() <<
@@ -584,7 +563,7 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<Matrix> operator*(const Matrix& m1, const Matrix& m2) {
+    inline Matrix operator*(const Matrix& m1, const Matrix& m2) {
         QL_REQUIRE(m1.columns() == m2.rows(),
                    "matrices with different sizes (" <<
                    m1.rows() << "x" << m1.columns() << ", " <<
@@ -601,7 +580,7 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<Matrix> transpose(const Matrix& m) {
+    inline Matrix transpose(const Matrix& m) {
         Matrix result(m.columns(),m.rows());
         #if defined(QL_PATCH_MSVC) && defined(QL_DEBUG)
         if (!m.empty())
@@ -611,13 +590,12 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<Matrix> outerProduct(const Array& v1, const Array& v2) {
+    inline Matrix outerProduct(const Array& v1, const Array& v2) {
         return outerProduct(v1.begin(), v1.end(), v2.begin(), v2.end());
     }
 
     template <class Iterator1, class Iterator2>
-    inline Disposable<Matrix>
-    outerProduct(Iterator1 v1begin, Iterator1 v1end, Iterator2 v2begin, Iterator2 v2end) {
+    inline Matrix outerProduct(Iterator1 v1begin, Iterator1 v1end, Iterator2 v2begin, Iterator2 v2end) {
 
         Size size1 = std::distance(v1begin, v1end);
         QL_REQUIRE(size1>0, "null first vector");
diff --git a/ql/math/matrixutilities/bicgstab.hpp b/ql/math/matrixutilities/bicgstab.hpp
index e74e1e014d6..d905b43aef7 100644
--- a/ql/math/matrixutilities/bicgstab.hpp
+++ b/ql/math/matrixutilities/bicgstab.hpp
@@ -38,7 +38,7 @@ namespace QuantLib {
 
     class BiCGstab  {
       public:
-        typedef ext::function<Disposable<Array>(const Array&)> MatrixMult;
+        typedef ext::function<Array(const Array&)> MatrixMult;
 
         BiCGstab(MatrixMult A, Size maxIter, Real relTol, MatrixMult preConditioner = MatrixMult());
 
diff --git a/ql/math/matrixutilities/choleskydecomposition.cpp b/ql/math/matrixutilities/choleskydecomposition.cpp
index b073c8b4426..db405546614 100644
--- a/ql/math/matrixutilities/choleskydecomposition.cpp
+++ b/ql/math/matrixutilities/choleskydecomposition.cpp
@@ -23,7 +23,7 @@
 
 namespace QuantLib {
 
-    Disposable<Matrix> CholeskyDecomposition(const Matrix& S, bool flexible) {
+    Matrix CholeskyDecomposition(const Matrix& S, bool flexible) {
         Size i, j, size = S.rows();
 
         QL_REQUIRE(size == S.columns(),
diff --git a/ql/math/matrixutilities/choleskydecomposition.hpp b/ql/math/matrixutilities/choleskydecomposition.hpp
index e31f66cb4a0..893cb4dd0c7 100644
--- a/ql/math/matrixutilities/choleskydecomposition.hpp
+++ b/ql/math/matrixutilities/choleskydecomposition.hpp
@@ -29,7 +29,7 @@
 namespace QuantLib {
 
     /*! \relates Matrix */
-    Disposable<Matrix> CholeskyDecomposition(const Matrix& m, bool flexible = false);
+    Matrix CholeskyDecomposition(const Matrix& m, bool flexible = false);
 }
 
 
diff --git a/ql/math/matrixutilities/factorreduction.cpp b/ql/math/matrixutilities/factorreduction.cpp
index 149135da86a..cc95b856918 100644
--- a/ql/math/matrixutilities/factorreduction.cpp
+++ b/ql/math/matrixutilities/factorreduction.cpp
@@ -23,9 +23,8 @@
 
 namespace QuantLib {
 
-    Disposable<std::vector<Real> >
-    factorReduction(Matrix mtrx,
-                    Size maxIters) {
+    std::vector<Real> factorReduction(Matrix mtrx,
+                                      Size maxIters) {
         static Real tolerance = 1.e-6;
 
         QL_REQUIRE(mtrx.rows() == mtrx.columns(),
diff --git a/ql/math/matrixutilities/factorreduction.hpp b/ql/math/matrixutilities/factorreduction.hpp
index e5e18220be1..d8a88a63af6 100644
--- a/ql/math/matrixutilities/factorreduction.hpp
+++ b/ql/math/matrixutilities/factorreduction.hpp
@@ -41,8 +41,7 @@ namespace QuantLib {
           University Of Chicago Press, 1976. Chapter 9 is relevant to
           this context.
     */
-    Disposable<std::vector<Real> > factorReduction(Matrix mtrx,
-                                                   Size maxIters = 25);
+    std::vector<Real> factorReduction(Matrix mtrx, Size maxIters = 25);
 
 }
 
diff --git a/ql/math/matrixutilities/getcovariance.hpp b/ql/math/matrixutilities/getcovariance.hpp
index 53b89ade13b..7cc7ba5da4c 100644
--- a/ql/math/matrixutilities/getcovariance.hpp
+++ b/ql/math/matrixutilities/getcovariance.hpp
@@ -46,10 +46,10 @@ namespace QuantLib {
               CovarianceDecomposition
     */
     template<class DataIterator>
-    Disposable<Matrix> getCovariance(DataIterator stdDevBegin,
-                                     DataIterator stdDevEnd,
-                                     const Matrix& corr,
-                                     Real tolerance = 1.0e-12){
+    Matrix getCovariance(DataIterator stdDevBegin,
+                         DataIterator stdDevEnd,
+                         const Matrix& corr,
+                         Real tolerance = 1.0e-12){
         Size size = std::distance(stdDevBegin, stdDevEnd);
         QL_REQUIRE(corr.rows() == size,
                    "dimension mismatch between volatilities (" << size <<
diff --git a/ql/math/matrixutilities/gmres.hpp b/ql/math/matrixutilities/gmres.hpp
index b93eaea955f..d04897eeb9e 100644
--- a/ql/math/matrixutilities/gmres.hpp
+++ b/ql/math/matrixutilities/gmres.hpp
@@ -53,7 +53,7 @@ namespace QuantLib {
 
     class GMRES  {
       public:
-        typedef ext::function<Disposable<Array>(const Array&)> MatrixMult;
+        typedef ext::function<Array(const Array&)> MatrixMult;
 
         GMRES(MatrixMult A, Size maxIter, Real relTol, MatrixMult preConditioner = MatrixMult());
 
diff --git a/ql/math/matrixutilities/pseudosqrt.cpp b/ql/math/matrixutilities/pseudosqrt.cpp
index 881b2602bd3..0cf0986996b 100644
--- a/ql/math/matrixutilities/pseudosqrt.cpp
+++ b/ql/math/matrixutilities/pseudosqrt.cpp
@@ -85,7 +85,7 @@ namespace QuantLib {
             : size_(targetMatrix.rows()), lowerDiagonal_(lowerDiagonal),
               targetMatrix_(targetMatrix), targetVariance_(std::move(targetVariance)),
               currentRoot_(size_, size_), tempMatrix_(size_, size_), currentMatrix_(size_, size_) {}
-            Disposable<Array> values(const Array&) const override {
+            Array values(const Array&) const override {
                 QL_FAIL("values method not implemented");
             }
             Real value(const Array& x) const override {
@@ -137,9 +137,9 @@ namespace QuantLib {
         };
 
         // Optimization function for hypersphere and lower-diagonal algorithm
-        Disposable<Matrix> hypersphereOptimize(const Matrix& targetMatrix,
-                                               const Matrix& currentRoot,
-                                               const bool lowerDiagonal) {
+        Matrix hypersphereOptimize(const Matrix& targetMatrix,
+                                   const Matrix& currentRoot,
+                                   const bool lowerDiagonal) {
             Size i,j,k,size = targetMatrix.rows();
             Matrix result(currentRoot);
             Array variance(size, 0);
@@ -278,7 +278,7 @@ namespace QuantLib {
         }
 
         // Take a matrix and make all the diagonal entries 1.
-        Disposable<Matrix> projectToUnitDiagonalMatrix(const Matrix& M) {
+        Matrix projectToUnitDiagonalMatrix(const Matrix& M) {
             Size size = M.rows();
             QL_REQUIRE(size == M.columns(),
                        "matrix not square");
@@ -291,7 +291,7 @@ namespace QuantLib {
         }
 
         // Take a matrix and make all the eigenvalues non-negative
-        Disposable<Matrix> projectToPositiveSemidefiniteMatrix(Matrix& M) {
+        Matrix projectToPositiveSemidefiniteMatrix(Matrix& M) {
             Size size = M.rows();
             QL_REQUIRE(size == M.columns(),
                        "matrix not square");
@@ -308,8 +308,7 @@ namespace QuantLib {
 
         // implementation of the Higham algorithm to find the nearest
         // correlation matrix.
-        Disposable<Matrix>
-        highamImplementation(const Matrix& A, const Size maxIterations, const Real& tolerance) {
+        Matrix highamImplementation(const Matrix& A, const Size maxIterations, const Real& tolerance) {
 
             Size size = A.rows();
             Matrix R, Y(A), X(A), deltaS(size, size, 0.0);
@@ -345,7 +344,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<Matrix> pseudoSqrt(const Matrix& matrix, SalvagingAlgorithm::Type sa) {
+    Matrix pseudoSqrt(const Matrix& matrix, SalvagingAlgorithm::Type sa) {
         Size size = matrix.rows();
 
         #if defined(QL_EXTRA_SAFETY_CHECKS)
@@ -425,10 +424,10 @@ namespace QuantLib {
     }
 
 
-    Disposable<Matrix> rankReducedSqrt(const Matrix& matrix,
-                                       Size maxRank,
-                                       Real componentRetainedPercentage,
-                                       SalvagingAlgorithm::Type sa) {
+    Matrix rankReducedSqrt(const Matrix& matrix,
+                           Size maxRank,
+                           Real componentRetainedPercentage,
+                           SalvagingAlgorithm::Type sa) {
         Size size = matrix.rows();
 
         #if defined(QL_EXTRA_SAFETY_CHECKS)
diff --git a/ql/math/matrixutilities/pseudosqrt.hpp b/ql/math/matrixutilities/pseudosqrt.hpp
index ebeaba2630f..f5a1537df21 100644
--- a/ql/math/matrixutilities/pseudosqrt.hpp
+++ b/ql/math/matrixutilities/pseudosqrt.hpp
@@ -61,8 +61,8 @@ namespace QuantLib {
         - the correctness of the results is tested by checking
           returned values against numerical calculations.
     */
-    Disposable<Matrix> pseudoSqrt(const Matrix&,
-                                  SalvagingAlgorithm::Type = SalvagingAlgorithm::None);
+    Matrix pseudoSqrt(const Matrix&,
+                      SalvagingAlgorithm::Type = SalvagingAlgorithm::None);
 
     //! Returns the rank-reduced pseudo square root of a real symmetric matrix
     /*! The result matrix has rank<=maxRank. If maxRank>=size, then the
@@ -77,10 +77,10 @@ namespace QuantLib {
 
         \relates Matrix
     */
-    Disposable<Matrix> rankReducedSqrt(const Matrix&,
-                                       Size maxRank,
-                                       Real componentRetainedPercentage,
-                                       SalvagingAlgorithm::Type);
+    Matrix rankReducedSqrt(const Matrix&,
+                           Size maxRank,
+                           Real componentRetainedPercentage,
+                           SalvagingAlgorithm::Type);
 }
 
 
diff --git a/ql/math/matrixutilities/qrdecomposition.cpp b/ql/math/matrixutilities/qrdecomposition.cpp
index 0b80d5e8bee..a7b7a893789 100644
--- a/ql/math/matrixutilities/qrdecomposition.cpp
+++ b/ql/math/matrixutilities/qrdecomposition.cpp
@@ -27,9 +27,10 @@
 
 namespace QuantLib {
 
-    Disposable<std::vector<Size> > qrDecomposition(const Matrix& M,
-                                                   Matrix& q, Matrix& r,
-                                                   bool pivot) {
+    std::vector<Size> qrDecomposition(const Matrix& M,
+                                      Matrix& q,
+                                      Matrix& r,
+                                      bool pivot) {
         Matrix mT = transpose(M);
         const Size m = M.rows();
         const Size n = M.columns();
@@ -121,8 +122,8 @@ namespace QuantLib {
         return ipvt;
     }
 
-    Disposable<Array> qrSolve(const Matrix& a, const Array& b,
-                              bool pivot, const Array& d) {
+    Array qrSolve(const Matrix& a, const Array& b,
+                  bool pivot, const Array& d) {
         const Size m = a.rows();
         const Size n = a.columns();
 
diff --git a/ql/math/matrixutilities/qrdecomposition.hpp b/ql/math/matrixutilities/qrdecomposition.hpp
index da4eb6f858d..e40ebb5415d 100644
--- a/ql/math/matrixutilities/qrdecomposition.hpp
+++ b/ql/math/matrixutilities/qrdecomposition.hpp
@@ -46,10 +46,10 @@ namespace QuantLib {
 
         See lmdiff.cpp for further details.
     */
-    Disposable<std::vector<Size> > qrDecomposition(const Matrix& A,
-                                                   Matrix& q,
-                                                   Matrix& r,
-                                                   bool pivot = true);
+    std::vector<Size> qrDecomposition(const Matrix& A,
+                                      Matrix& q,
+                                      Matrix& r,
+                                      bool pivot = true);
 
     //! QR Solve
     /*! This implementation is based on MINPACK
@@ -69,10 +69,10 @@ namespace QuantLib {
 
         See lmdiff.cpp for further details.
     */
-    Disposable<Array> qrSolve(const Matrix& a,
-                              const Array& b,
-                              bool pivot = true,
-                              const Array& d = Array());
+    Array qrSolve(const Matrix& a,
+                  const Array& b,
+                  bool pivot = true,
+                  const Array& d = Array());
 }
 
 #endif
diff --git a/ql/math/matrixutilities/sparseilupreconditioner.cpp b/ql/math/matrixutilities/sparseilupreconditioner.cpp
index a849d332018..5f9a45e4905 100644
--- a/ql/math/matrixutilities/sparseilupreconditioner.cpp
+++ b/ql/math/matrixutilities/sparseilupreconditioner.cpp
@@ -153,12 +153,11 @@ namespace QuantLib {
         return U_;
     }
 
-    Disposable<Array> SparseILUPreconditioner::apply(const Array& b) const {
+    Array SparseILUPreconditioner::apply(const Array& b) const {
         return backwardSolve(forwardSolve(b));
     }
 
-    Disposable<Array> SparseILUPreconditioner::forwardSolve(
-                                                       const Array& b) const {
+    Array SparseILUPreconditioner::forwardSolve(const Array& b) const {
         Integer n = b.size();
         Array y(n, 0.0);
         y[0]=b[0]/L_(0,0);
@@ -174,8 +173,7 @@ namespace QuantLib {
         return y;
     }
 
-    Disposable<Array> SparseILUPreconditioner::backwardSolve(
-                                                       const Array& y) const {
+    Array SparseILUPreconditioner::backwardSolve(const Array& y) const {
         Size n = y.size();
         Array x(n, 0.0);
         x[n-1] = y[n-1]/U_(n-1,n-1);
diff --git a/ql/math/matrixutilities/sparseilupreconditioner.hpp b/ql/math/matrixutilities/sparseilupreconditioner.hpp
index c93e7bc052c..c280d801f8b 100644
--- a/ql/math/matrixutilities/sparseilupreconditioner.hpp
+++ b/ql/math/matrixutilities/sparseilupreconditioner.hpp
@@ -40,14 +40,14 @@ namespace QuantLib {
         const SparseMatrix& L() const;
         const SparseMatrix& U() const;
 
-        Disposable<Array> apply(const Array& b) const;
+        Array apply(const Array& b) const;
 
       private:
         SparseMatrix L_, U_;
         std::vector<Size> lBands_, uBands_;
 
-        Disposable<Array> forwardSolve(const Array& b) const;
-        Disposable<Array> backwardSolve(const Array& y) const;
+        Array forwardSolve(const Array& b) const;
+        Array backwardSolve(const Array& y) const;
     };
 
 }
diff --git a/ql/math/matrixutilities/sparsematrix.hpp b/ql/math/matrixutilities/sparsematrix.hpp
index 0840e68e426..905dafda01b 100644
--- a/ql/math/matrixutilities/sparsematrix.hpp
+++ b/ql/math/matrixutilities/sparsematrix.hpp
@@ -62,11 +62,11 @@ FOR A PARTICULAR PURPOSE.  See the license for more details.
 #endif
 
 namespace QuantLib {
+
     typedef boost::numeric::ublas::compressed_matrix<Real> SparseMatrix;
-    typedef boost::numeric::ublas::matrix_reference<SparseMatrix>
-        SparseMatrixReference;
+    typedef boost::numeric::ublas::matrix_reference<SparseMatrix> SparseMatrixReference;
 
-    inline Disposable<Array> prod(const SparseMatrix& A, const Array& x) {
+    inline Array prod(const SparseMatrix& A, const Array& x) {
         QL_REQUIRE(x.size() == A.size2(),
                    "vectors and sparse matrices with different sizes ("
                    << x.size() << ", " << A.size1() << "x" << A.size2() <<
diff --git a/ql/math/matrixutilities/svd.cpp b/ql/math/matrixutilities/svd.cpp
index ed1e57a3848..adfef140fc3 100644
--- a/ql/math/matrixutilities/svd.cpp
+++ b/ql/math/matrixutilities/svd.cpp
@@ -494,7 +494,7 @@ namespace QuantLib {
         return s_;
     }
 
-    Disposable<Matrix> SVD::S() const {
+    Matrix SVD::S() const {
         Matrix S(n_,n_);
         for (Size i = 0; i < Size(n_); i++) {
             for (Size j = 0; j < Size(n_); j++) {
@@ -525,15 +525,14 @@ namespace QuantLib {
         return r;
     }
 
-    Disposable<Array> SVD::solveFor(const Array& b) const{
+    Array SVD::solveFor(const Array& b) const{
         Matrix W(n_, n_, 0.0);
         const Size numericalRank = this->rank();
         for (Size i=0; i<numericalRank; i++)
             W[i][i] = 1./s_[i];
 
         Matrix inverse = V()* W * transpose(U());
-        Array result = inverse * b;
-        return result;
+        return inverse * b;
     }
 
 }
diff --git a/ql/math/matrixutilities/svd.hpp b/ql/math/matrixutilities/svd.hpp
index 936f7950907..d2af1d3a5e7 100644
--- a/ql/math/matrixutilities/svd.hpp
+++ b/ql/math/matrixutilities/svd.hpp
@@ -59,12 +59,12 @@ namespace QuantLib {
         const Matrix& U() const;
         const Matrix& V() const;
         const Array& singularValues() const;
-        Disposable<Matrix> S() const;
+        Matrix S() const;
         Real norm2() const;
         Real cond()  const;
         Size rank()  const;
         // utilities
-        Disposable<Array> solveFor(const Array&) const;
+        Array solveFor(const Array&) const;
       private:
         Matrix U_, V_;
         Array s_;
diff --git a/ql/math/matrixutilities/tapcorrelations.cpp b/ql/math/matrixutilities/tapcorrelations.cpp
index 3275b19de57..24221f317c6 100644
--- a/ql/math/matrixutilities/tapcorrelations.cpp
+++ b/ql/math/matrixutilities/tapcorrelations.cpp
@@ -22,9 +22,9 @@
 
 namespace QuantLib {
 
-    Disposable<Matrix> triangularAnglesParametrization(const Array& angles,
-                                                       Size matrixSize,
-                                                       Size rank) {
+    Matrix triangularAnglesParametrization(const Array& angles,
+                                           Size matrixSize,
+                                           Size rank) {
 
         // what if rank == 1?
         QL_REQUIRE((rank-1) * (2*matrixSize - rank) == 2*angles.size(),
@@ -54,9 +54,9 @@ namespace QuantLib {
         return m;
     }
 
-    Disposable<Matrix> lmmTriangularAnglesParametrization(const Array& angles,
-                                                          Size matrixSize,
-                                                          Size) {
+    Matrix lmmTriangularAnglesParametrization(const Array& angles,
+                                              Size matrixSize,
+                                              Size) {
         Matrix m(matrixSize, matrixSize);
         for (Size i=0; i<m.rows(); ++i) {
             Real cosPhi, sinPhi;
@@ -79,10 +79,9 @@ namespace QuantLib {
         return m;
     }
 
-    Disposable<Matrix> triangularAnglesParametrizationUnconstrained(
-                                                            const Array& x,
-                                                            Size matrixSize,
-                                                            Size rank) {
+    Matrix triangularAnglesParametrizationUnconstrained(const Array& x,
+                                                        Size matrixSize,
+                                                        Size rank) {
         Array angles(x.size());
         //we convert the unconstrained parameters in angles
         for (Size i = 0; i < x.size(); ++i)
@@ -90,10 +89,9 @@ namespace QuantLib {
         return triangularAnglesParametrization(angles, matrixSize, rank);
     }
 
-    Disposable<Matrix> lmmTriangularAnglesParametrizationUnconstrained(
-                                                            const Array& x,
-                                                            Size matrixSize,
-                                                            Size rank) {
+    Matrix lmmTriangularAnglesParametrizationUnconstrained(const Array& x,
+                                                           Size matrixSize,
+                                                           Size rank) {
         Array angles(x.size());
         //we convert the unconstrained parameters in angles
         for (Size i = 0; i < x.size(); ++i)
@@ -101,9 +99,8 @@ namespace QuantLib {
         return lmmTriangularAnglesParametrization(angles, matrixSize, rank);
     }
 
-    Disposable<Matrix> triangularAnglesParametrizationRankThree(
-                                            Real alpha, Real t0,
-                                            Real epsilon, Size matrixSize) {
+    Matrix triangularAnglesParametrizationRankThree(Real alpha, Real t0,
+                                                    Real epsilon, Size matrixSize) {
         Matrix m(matrixSize, 3);
         for (Size i=0; i<m.rows(); ++i) {
             Real t = t0 * (1 - std::exp(epsilon*Real(i)));
@@ -115,9 +112,8 @@ namespace QuantLib {
         return m;
     }
 
-    Disposable<Matrix> triangularAnglesParametrizationRankThreeVectorial(
-                                                    const Array& parameters,
-                                                    Size nbRows) {
+    Matrix triangularAnglesParametrizationRankThreeVectorial(const Array& parameters,
+                                                             Size nbRows) {
         QL_REQUIRE(parameters.size() == 3,
                    "the parameter array must contain exactly 3 values" );
         return triangularAnglesParametrizationRankThree(parameters[0],
@@ -132,7 +128,7 @@ namespace QuantLib {
         return DotProduct(temp, temp);
     }
 
-    Disposable<Array> FrobeniusCostFunction::values(const Array& x) const {
+    Array FrobeniusCostFunction::values(const Array& x) const {
         Array result((target_.rows()*(target_.columns()-1))/2);
         Matrix pseudoRoot = f_(x, matrixSize_, rank_);
         Matrix differences = pseudoRoot * transpose(pseudoRoot) - target_;
diff --git a/ql/math/matrixutilities/tapcorrelations.hpp b/ql/math/matrixutilities/tapcorrelations.hpp
index d52160d0ecf..1f88b4cfb9c 100644
--- a/ql/math/matrixutilities/tapcorrelations.hpp
+++ b/ql/math/matrixutilities/tapcorrelations.hpp
@@ -25,7 +25,6 @@
 #include <ql/math/matrix.hpp>
 #include <ql/math/optimization/costfunction.hpp>
 #include <ql/types.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <utility>
 #include <vector>
 
@@ -43,27 +42,23 @@ namespace QuantLib {
         - the correctness of the results is tested by checking
           returned values against numerical calculations.
     */
-    Disposable<Matrix>
-    triangularAnglesParametrization(const Array& angles,
-                                    Size matrixSize,
-                                    Size rank);
+    Matrix triangularAnglesParametrization(const Array& angles,
+                                           Size matrixSize,
+                                           Size rank);
 
-    Disposable<Matrix>
-    lmmTriangularAnglesParametrization(const Array& angles,
-                                       Size matrixSize,
-                                       Size rank);
+    Matrix lmmTriangularAnglesParametrization(const Array& angles,
+                                              Size matrixSize,
+                                              Size rank);
 
     // the same function using the angles parameterized by the following
     // transformation \f[ \teta_i = \frac{\Pi}{2} - arctan(x_i)\f]
-    Disposable<Matrix>
-    triangularAnglesParametrizationUnconstrained(const Array& x,
-                                                 Size matrixSize,
-                                                 Size rank);
+    Matrix triangularAnglesParametrizationUnconstrained(const Array& x,
+                                                        Size matrixSize,
+                                                        Size rank);
 
-    Disposable<Matrix>
-    lmmTriangularAnglesParametrizationUnconstrained(const Array& x,
-                                                    Size matrixSize,
-                                                    Size rank);
+    Matrix lmmTriangularAnglesParametrizationUnconstrained(const Array& x,
+                                                           Size matrixSize,
+                                                           Size rank);
 
 
     //! Returns the rank reduced Triangular Angles Parametrized correlation matrix
@@ -79,32 +74,30 @@ namespace QuantLib {
         - the correctness of the results is tested by checking
           returned values against numerical calculations.
     */
-    Disposable<Matrix>
-    triangularAnglesParametrizationRankThree(Real alpha,
-                                             Real t0,
-                                             Real epsilon,
-                                             Size nbRows);
+    Matrix triangularAnglesParametrizationRankThree(Real alpha,
+                                                    Real t0,
+                                                    Real epsilon,
+                                                    Size nbRows);
 
     // the same function with parameters packed in an Array
-    Disposable<Matrix>
-    triangularAnglesParametrizationRankThreeVectorial(const Array& parameters,
-                                                      Size nbRows);
+    Matrix triangularAnglesParametrizationRankThreeVectorial(const Array& parameters,
+                                                             Size nbRows);
 
     // Cost function associated with Frobenius norm.
     // <http://en.wikipedia.org/wiki/Matrix_norm>
     class FrobeniusCostFunction : public CostFunction{
       public:
         FrobeniusCostFunction(Matrix target,
-                              ext::function<Disposable<Matrix>(const Array&, Size, Size)> f,
+                              ext::function<Matrix(const Array&, Size, Size)> f,
                               Size matrixSize,
                               Size rank)
         : target_(std::move(target)), f_(std::move(f)), matrixSize_(matrixSize), rank_(rank) {}
         Real value(const Array& x) const override;
-        Disposable<Array> values(const Array& x) const override;
+        Array values(const Array& x) const override;
 
       private:
         Matrix target_;
-        ext::function<Disposable<Matrix>(const Array&, Size, Size)> f_;
+        ext::function<Matrix(const Array&, Size, Size)> f_;
         Size matrixSize_;
         Size rank_;
     };
diff --git a/ql/math/ode/adaptiverungekutta.hpp b/ql/math/ode/adaptiverungekutta.hpp
index 5e5e8bde7b3..a2a175db2b0 100644
--- a/ql/math/ode/adaptiverungekutta.hpp
+++ b/ql/math/ode/adaptiverungekutta.hpp
@@ -29,7 +29,6 @@
 
 #include <ql/types.hpp>
 #include <ql/errors.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <ql/functional.hpp>
 #include <vector>
 #include <cmath>
@@ -39,9 +38,7 @@ namespace QuantLib {
     template <class T = Real>
     class AdaptiveRungeKutta {
       public:
-        typedef ext::function<
-          Disposable<std::vector<T> >(const Real,
-                                      const std::vector<T>&)> OdeFct;
+        typedef ext::function<std::vector<T>(const Real, const std::vector<T>&)> OdeFct;
         typedef ext::function<T(const Real, const T)> OdeFct1d;
 
         /*! The class is constructed with the following inputs:
@@ -64,8 +61,7 @@ namespace QuantLib {
             The ode is given by a function \f$ F: R \times K^n
             \rightarrow K^n \f$ as \f$ f'(x) = F(x,f(x)) \f$, $K=R,
             C$ */
-        Disposable<std::vector<T> >
-        operator()(const OdeFct& ode, const std::vector<T>& y1, Real x1, Real x2);
+        std::vector<T> operator()(const OdeFct& ode, const std::vector<T>& y1, Real x1, Real x2);
         T operator()(const OdeFct1d& ode, T y1, Real x1, Real x2);
 
       private:
@@ -99,8 +95,7 @@ namespace QuantLib {
 
 
     template<class T>
-    Disposable<std::vector<T> > AdaptiveRungeKutta<T>::operator()(
-                                                     const OdeFct& ode,
+    std::vector<T> AdaptiveRungeKutta<T>::operator()(const OdeFct& ode,
                                                      const std::vector<T>& y1,
                                                      const Real x1,
                                                      const Real x2) {
@@ -138,8 +133,7 @@ namespace QuantLib {
             typedef typename AdaptiveRungeKutta<T>::OdeFct1d OdeFct1d;
             explicit OdeFctWrapper(const OdeFct1d& ode1d)
             : ode1d_(ode1d) {}
-            Disposable<std::vector<T> > operator()(const Real x,
-                                                   const std::vector<T>& y) {
+            std::vector<T> operator()(const Real x, const std::vector<T>& y) {
                 std::vector<T> res(1,ode1d_(x,y[0]));
                 return res;
             }
diff --git a/ql/math/optimization/bfgs.cpp b/ql/math/optimization/bfgs.cpp
index dd8e9237d16..4408fbf37f0 100644
--- a/ql/math/optimization/bfgs.cpp
+++ b/ql/math/optimization/bfgs.cpp
@@ -23,9 +23,9 @@
 
 namespace QuantLib {
 
-    Disposable<Array> BFGS::getUpdatedDirection(const Problem& P,
-                                                Real,
-                                                const Array& oldGradient) {
+    Array BFGS::getUpdatedDirection(const Problem& P,
+                                    Real,
+                                    const Array& oldGradient) {
         if (inverseHessian_.rows() == 0)
         {
             // first time in this update, we create needed structures
diff --git a/ql/math/optimization/bfgs.hpp b/ql/math/optimization/bfgs.hpp
index c069696b886..81f35bdb8d2 100644
--- a/ql/math/optimization/bfgs.hpp
+++ b/ql/math/optimization/bfgs.hpp
@@ -44,8 +44,7 @@ namespace QuantLib {
       private:
         //! \name LineSearchBasedMethod interface
         //@{
-        Disposable<Array>
-        getUpdatedDirection(const Problem& P, Real gold2, const Array& oldGradient) override;
+        Array getUpdatedDirection(const Problem& P, Real gold2, const Array& oldGradient) override;
         //@}
         //! inverse of hessian matrix
         Matrix inverseHessian_;
diff --git a/ql/math/optimization/conjugategradient.cpp b/ql/math/optimization/conjugategradient.cpp
index b772f78cb82..56e453695db 100644
--- a/ql/math/optimization/conjugategradient.cpp
+++ b/ql/math/optimization/conjugategradient.cpp
@@ -27,9 +27,9 @@
 
 namespace QuantLib {
 
-    Disposable<Array> ConjugateGradient::getUpdatedDirection(const Problem& P,
-                                                             Real gold2,
-                                                             const Array&) {
+    Array ConjugateGradient::getUpdatedDirection(const Problem& P,
+                                                 Real gold2,
+                                                 const Array&) {
         return -lineSearch_->lastGradient() +
             (P.gradientNormValue() / gold2) * lineSearch_->searchDirection();
     }
diff --git a/ql/math/optimization/conjugategradient.hpp b/ql/math/optimization/conjugategradient.hpp
index 9cb72ed2639..1c15aefb8f5 100644
--- a/ql/math/optimization/conjugategradient.hpp
+++ b/ql/math/optimization/conjugategradient.hpp
@@ -52,8 +52,7 @@ namespace QuantLib {
       private:
         //! \name LineSearchBasedMethod interface
         //@{
-        Disposable<Array>
-        getUpdatedDirection(const Problem& P, Real gold2, const Array& oldGradient) override;
+        Array getUpdatedDirection(const Problem& P, Real gold2, const Array& oldGradient) override;
         //@}
     };
 
diff --git a/ql/math/optimization/costfunction.hpp b/ql/math/optimization/costfunction.hpp
index 4f667063484..ee3007a0014 100644
--- a/ql/math/optimization/costfunction.hpp
+++ b/ql/math/optimization/costfunction.hpp
@@ -43,7 +43,7 @@ namespace QuantLib {
                              static_cast<Real>(v.size()));
         }
         //! method to overload to compute the cost function values in x
-        virtual Disposable<Array> values(const Array& x) const =0;
+        virtual Array values(const Array& x) const =0;
 
         //! method to overload to compute grad_f, the first derivative of
         //  the cost function with respect to x
@@ -87,8 +87,8 @@ namespace QuantLib {
 
         //! method to overload to compute J_f, the jacobian of
         // the cost function with respect to x and also the cost function
-        virtual Disposable<Array> valuesAndJacobian(Matrix &jac,
-                                                    const Array &x) const {
+        virtual Array valuesAndJacobian(Matrix &jac,
+                                        const Array &x) const {
             jacobian(jac,x);
             return values(x);
         }
diff --git a/ql/math/optimization/leastsquare.cpp b/ql/math/optimization/leastsquare.cpp
index 3569174ec51..824c60d3a2c 100644
--- a/ql/math/optimization/leastsquare.cpp
+++ b/ql/math/optimization/leastsquare.cpp
@@ -36,7 +36,7 @@ namespace QuantLib {
         return DotProduct(diff, diff);
     }
 
-    Disposable<Array> LeastSquareFunction::values(const Array& x) const {
+    Array LeastSquareFunction::values(const Array& x) const {
         // size of target and function to fit vectors
         Array target(lsp_.size()), fct2fit(lsp_.size());
         // compute its values
diff --git a/ql/math/optimization/leastsquare.hpp b/ql/math/optimization/leastsquare.hpp
index 49e7fa08236..e02aeede12d 100644
--- a/ql/math/optimization/leastsquare.hpp
+++ b/ql/math/optimization/leastsquare.hpp
@@ -66,7 +66,7 @@ namespace QuantLib {
 
         //! compute value of the least square function
         Real value(const Array& x) const override;
-        Disposable<Array> values(const Array&) const override;
+        Array values(const Array&) const override;
         //! compute vector of derivatives of the least square function
         void gradient(Array& grad_f, const Array& x) const override;
         //! compute value and gradient of the least square function
diff --git a/ql/math/optimization/linesearchbasedmethod.hpp b/ql/math/optimization/linesearchbasedmethod.hpp
index e7213f354ca..53cb92a2297 100644
--- a/ql/math/optimization/linesearchbasedmethod.hpp
+++ b/ql/math/optimization/linesearchbasedmethod.hpp
@@ -44,10 +44,9 @@ namespace QuantLib {
 
       protected:
         //! computes the new search direction
-        virtual Disposable<Array>
-        getUpdatedDirection(const Problem &P,
-                            Real gold2,
-                            const Array& gradient) = 0;
+        virtual Array getUpdatedDirection(const Problem &P,
+                                          Real gold2,
+                                          const Array& gradient) = 0;
         //! line search
         ext::shared_ptr<LineSearch> lineSearch_;
     };
diff --git a/ql/math/optimization/problem.hpp b/ql/math/optimization/problem.hpp
index a8ddc49ecb1..ea13f461b42 100644
--- a/ql/math/optimization/problem.hpp
+++ b/ql/math/optimization/problem.hpp
@@ -56,7 +56,7 @@ namespace QuantLib {
         Real value(const Array& x);
 
         //! call cost values computation and increment evaluation counter
-        Disposable<Array> values(const Array& x);
+        Array values(const Array& x);
 
         //! call cost function gradient computation and increment
         //  evaluation counter
@@ -118,7 +118,7 @@ namespace QuantLib {
         return costFunction_.value(x);
     }
 
-    inline Disposable<Array> Problem::values(const Array& x) {
+    inline Array Problem::values(const Array& x) {
         ++functionEvaluation_;
         return costFunction_.values(x);
     }
diff --git a/ql/math/optimization/projectedcostfunction.cpp b/ql/math/optimization/projectedcostfunction.cpp
index deba65a2111..6d7dd1d32b7 100644
--- a/ql/math/optimization/projectedcostfunction.cpp
+++ b/ql/math/optimization/projectedcostfunction.cpp
@@ -39,8 +39,7 @@ namespace QuantLib {
         return costFunction_.value(actualParameters_);
     }
 
-    Disposable<Array> ProjectedCostFunction::values(
-                                        const Array& freeParameters) const{
+    Array ProjectedCostFunction::values(const Array& freeParameters) const{
         mapFreeParameters(freeParameters);
         return costFunction_.values(actualParameters_);
     }
diff --git a/ql/math/optimization/projectedcostfunction.hpp b/ql/math/optimization/projectedcostfunction.hpp
index f174dd857c1..79e7b189837 100644
--- a/ql/math/optimization/projectedcostfunction.hpp
+++ b/ql/math/optimization/projectedcostfunction.hpp
@@ -48,7 +48,7 @@ namespace QuantLib {
             //! \name CostFunction interface
             //@{
             Real value(const Array& freeParameters) const override;
-            Disposable<Array> values(const Array& freeParameters) const override;
+            Array values(const Array& freeParameters) const override;
             //@}
 
         private:
diff --git a/ql/math/optimization/projection.cpp b/ql/math/optimization/projection.cpp
index d1bbb823d06..cdf992b1c56 100644
--- a/ql/math/optimization/projection.cpp
+++ b/ql/math/optimization/projection.cpp
@@ -51,7 +51,7 @@ namespace QuantLib {
 
     }
 
-    Disposable<Array> Projection::project(const Array &parameters) const {
+    Array Projection::project(const Array &parameters) const {
 
         QL_REQUIRE(parameters.size() == fixParameters_.size(),
                    "parameters.size()!=parametersFreedoms_.size()");
@@ -64,8 +64,7 @@ namespace QuantLib {
 
     }
 
-    Disposable<Array>
-    Projection::include(const Array &projectedParameters) const {
+    Array Projection::include(const Array &projectedParameters) const {
 
         QL_REQUIRE(projectedParameters.size() == numberOfFreeParameters_,
                    "projectedParameters.size()!=numberOfFreeParameters");
diff --git a/ql/math/optimization/projection.hpp b/ql/math/optimization/projection.hpp
index 875fcc824e6..6357edba280 100644
--- a/ql/math/optimization/projection.hpp
+++ b/ql/math/optimization/projection.hpp
@@ -37,12 +37,11 @@ namespace QuantLib {
 
         //! returns the subset of free parameters corresponding
         // to set of parameters
-        virtual Disposable<Array> project(const Array &parameters) const;
+        virtual Array project(const Array &parameters) const;
 
         //! returns whole set of parameters corresponding to the set
         // of projected parameters
-        virtual Disposable<Array>
-        include(const Array &projectedParameters) const;
+        virtual Array include(const Array &projectedParameters) const;
         virtual ~Projection() = default;
 
       protected:
diff --git a/ql/math/optimization/steepestdescent.cpp b/ql/math/optimization/steepestdescent.cpp
index 53115bd78c9..08f05138f08 100644
--- a/ql/math/optimization/steepestdescent.cpp
+++ b/ql/math/optimization/steepestdescent.cpp
@@ -24,9 +24,9 @@
 
 namespace QuantLib {
 
-    Disposable<Array> SteepestDescent::getUpdatedDirection(const Problem&,
-                                                           Real,
-                                                           const Array&) {
+    Array SteepestDescent::getUpdatedDirection(const Problem&,
+                                               Real,
+                                               const Array&) {
         return -lineSearch_->lastGradient();
     }
 
diff --git a/ql/math/optimization/steepestdescent.hpp b/ql/math/optimization/steepestdescent.hpp
index d7ad8772c16..bf0e9940c0d 100644
--- a/ql/math/optimization/steepestdescent.hpp
+++ b/ql/math/optimization/steepestdescent.hpp
@@ -42,8 +42,7 @@ namespace QuantLib {
       private:
         //! \name LineSearchBasedMethod interface
         //@{
-        Disposable<Array>
-        getUpdatedDirection(const Problem& P, Real gold2, const Array& oldGradient) override;
+        Array getUpdatedDirection(const Problem& P, Real gold2, const Array& oldGradient) override;
         //@}
     };
 
diff --git a/ql/math/randomnumbers/stochasticcollocationinvcdf.cpp b/ql/math/randomnumbers/stochasticcollocationinvcdf.cpp
index 86661ead95d..9ad6c0758c9 100644
--- a/ql/math/randomnumbers/stochasticcollocationinvcdf.cpp
+++ b/ql/math/randomnumbers/stochasticcollocationinvcdf.cpp
@@ -28,8 +28,8 @@
 namespace QuantLib {
 
     namespace {
-        Disposable<Array> g(Real sigma, const Array& x,
-                            const ext::function<Real(Real)>& invCDF) {
+        Array g(Real sigma, const Array& x,
+                const ext::function<Real(Real)>& invCDF) {
 
             Array y(x.size());
             const CumulativeNormalDistribution normalCDF;
diff --git a/ql/math/statistics/sequencestatistics.hpp b/ql/math/statistics/sequencestatistics.hpp
index 46560026067..2278c14c40e 100644
--- a/ql/math/statistics/sequencestatistics.hpp
+++ b/ql/math/statistics/sequencestatistics.hpp
@@ -61,9 +61,9 @@ namespace QuantLib {
         //! \name covariance and correlation
         //@{
         //! returns the covariance Matrix
-        Disposable<Matrix> covariance() const;
+        Matrix covariance() const;
         //! returns the correlation Matrix
-        Disposable<Matrix> correlation() const;
+        Matrix correlation() const;
         //@}
         //! \name 1-D inspectors lifted from underlying statistics class
         //@{
@@ -244,7 +244,7 @@ namespace QuantLib {
     }
 
     template <class Stat>
-    Disposable<Matrix> GenericSequenceStatistics<Stat>::covariance() const {
+    Matrix GenericSequenceStatistics<Stat>::covariance() const {
         Real sampleWeight = weightSum();
         QL_REQUIRE(sampleWeight > 0.0,
                    "sampleWeight=0, unsufficient");
@@ -266,7 +266,7 @@ namespace QuantLib {
 
 
     template <class Stat>
-    Disposable<Matrix> GenericSequenceStatistics<Stat>::correlation() const {
+    Matrix GenericSequenceStatistics<Stat>::correlation() const {
         Matrix correlation = covariance();
         Array variances = correlation.diagonal();
         for (Size i=0; i<dimension_; i++){
diff --git a/ql/methods/finitedifferences/meshers/fdmmesher.hpp b/ql/methods/finitedifferences/meshers/fdmmesher.hpp
index 19ac8ea5263..0fb53709ce6 100644
--- a/ql/methods/finitedifferences/meshers/fdmmesher.hpp
+++ b/ql/methods/finitedifferences/meshers/fdmmesher.hpp
@@ -46,7 +46,7 @@ namespace QuantLib {
                             Size direction) const = 0;
         virtual Real location(const FdmLinearOpIterator& iter ,
                               Size direction) const = 0;
-        virtual Disposable<Array> locations(Size direction) const = 0;
+        virtual Array locations(Size direction) const = 0;
 
         const ext::shared_ptr<FdmLinearOpLayout>& layout() const {
             return layout_;
diff --git a/ql/methods/finitedifferences/meshers/fdmmeshercomposite.cpp b/ql/methods/finitedifferences/meshers/fdmmeshercomposite.cpp
index 1c3ec110613..96dc0582e4d 100644
--- a/ql/methods/finitedifferences/meshers/fdmmeshercomposite.cpp
+++ b/ql/methods/finitedifferences/meshers/fdmmeshercomposite.cpp
@@ -98,7 +98,7 @@ namespace QuantLib {
         return mesher_[direction]->location(iter.coordinates()[direction]);
     }
 
-    Disposable<Array> FdmMesherComposite::locations(Size direction) const {
+    Array FdmMesherComposite::locations(Size direction) const {
         Array retVal(layout_->size());
 
         const FdmLinearOpIterator endIter = layout_->end();
diff --git a/ql/methods/finitedifferences/meshers/fdmmeshercomposite.hpp b/ql/methods/finitedifferences/meshers/fdmmeshercomposite.hpp
index fd7d31bc962..28f7996cabe 100644
--- a/ql/methods/finitedifferences/meshers/fdmmeshercomposite.hpp
+++ b/ql/methods/finitedifferences/meshers/fdmmeshercomposite.hpp
@@ -57,7 +57,7 @@ namespace QuantLib {
         Real dplus(const FdmLinearOpIterator& iter, Size direction) const override;
         Real dminus(const FdmLinearOpIterator& iter, Size direction) const override;
         Real location(const FdmLinearOpIterator& iter, Size direction) const override;
-        Disposable<Array> locations(Size direction) const override;
+        Array locations(Size direction) const override;
 
         const std::vector<ext::shared_ptr<Fdm1dMesher> >&
             getFdm1dMeshers() const;
diff --git a/ql/methods/finitedifferences/meshers/uniformgridmesher.cpp b/ql/methods/finitedifferences/meshers/uniformgridmesher.cpp
index 9f86cb55d4c..e8bb40cb0de 100644
--- a/ql/methods/finitedifferences/meshers/uniformgridmesher.cpp
+++ b/ql/methods/finitedifferences/meshers/uniformgridmesher.cpp
@@ -45,7 +45,7 @@ namespace QuantLib {
         }
     }
 
-    Disposable<Array> UniformGridMesher::locations(Size d) const {
+    Array UniformGridMesher::locations(Size d) const {
         Array retVal(layout_->size());
 
         const FdmLinearOpIterator endIter = layout_->end();
diff --git a/ql/methods/finitedifferences/meshers/uniformgridmesher.hpp b/ql/methods/finitedifferences/meshers/uniformgridmesher.hpp
index 98b435b05ae..bf33815bba5 100644
--- a/ql/methods/finitedifferences/meshers/uniformgridmesher.hpp
+++ b/ql/methods/finitedifferences/meshers/uniformgridmesher.hpp
@@ -49,7 +49,7 @@ namespace QuantLib {
             return locations_[direction][iter.coordinates()[direction]];
         }
 
-        Disposable<Array> locations(Size direction) const override;
+        Array locations(Size direction) const override;
 
       private:
         std::unique_ptr<Real[]> dx_;
diff --git a/ql/methods/finitedifferences/operators/fdm2dblackscholesop.cpp b/ql/methods/finitedifferences/operators/fdm2dblackscholesop.cpp
index 08dc22f7a21..ce3808ed370 100644
--- a/ql/methods/finitedifferences/operators/fdm2dblackscholesop.cpp
+++ b/ql/methods/finitedifferences/operators/fdm2dblackscholesop.cpp
@@ -111,15 +111,15 @@ namespace QuantLib {
                                  ->forwardRate(t1, t2, Continuous).rate();
     }
 
-    Disposable<Array> Fdm2dBlackScholesOp::apply(const Array& x) const {
+    Array Fdm2dBlackScholesOp::apply(const Array& x) const {
         return opX_.apply(x) + opY_.apply(x) + apply_mixed(x);
     }
     
-    Disposable<Array> Fdm2dBlackScholesOp::apply_mixed(const Array& x) const {
+    Array Fdm2dBlackScholesOp::apply_mixed(const Array& x) const {
         return corrMapT_.apply(x) + currentForwardRate_*x;
     }
     
-    Disposable<Array> Fdm2dBlackScholesOp::apply_direction(
+    Array Fdm2dBlackScholesOp::apply_direction(
                                        Size direction, const Array& x) const {
         if (direction == 0) {
             return opX_.apply(x);
@@ -132,7 +132,7 @@ namespace QuantLib {
         }
     }
     
-    Disposable<Array> Fdm2dBlackScholesOp::solve_splitting(Size direction,
+    Array Fdm2dBlackScholesOp::solve_splitting(Size direction,
                                                const Array& x, Real s) const {
         if (direction == 0) {
             return opX_.solve_splitting(direction, x, s);
@@ -144,21 +144,19 @@ namespace QuantLib {
             QL_FAIL("direction is too large");
     }
     
-    Disposable<Array> Fdm2dBlackScholesOp::preconditioner(const Array& r, 
-                                                          Real dt) const {
+    Array Fdm2dBlackScholesOp::preconditioner(const Array& r, 
+                                              Real dt) const {
         return solve_splitting(0, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    Fdm2dBlackScholesOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(3);
-        retVal[0] = opX_.toMatrix();
-        retVal[1] = opY_.toMatrix();
-        retVal[2] = corrMapT_.toMatrix() +
+    std::vector<SparseMatrix> Fdm2dBlackScholesOp::toMatrixDecomp() const {
+        return {
+            opX_.toMatrix(),
+            opY_.toMatrix(),
+            corrMapT_.toMatrix() +
             currentForwardRate_*boost::numeric::ublas::identity_matrix<Real>(
-                    mesher_->layout()->size());
-
-        return retVal;
+                    mesher_->layout()->size())
+        };
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdm2dblackscholesop.hpp b/ql/methods/finitedifferences/operators/fdm2dblackscholesop.hpp
index 202126ab063..7d893a2792b 100644
--- a/ql/methods/finitedifferences/operators/fdm2dblackscholesop.hpp
+++ b/ql/methods/finitedifferences/operators/fdm2dblackscholesop.hpp
@@ -46,15 +46,15 @@ namespace QuantLib {
 
         Size size() const override;
         void setTime(Time t1, Time t2) override;
-        Disposable<Array> apply(const Array& x) const override;
-        Disposable<Array> apply_mixed(const Array& x) const override;
+        Array apply(const Array& x) const override;
+        Array apply_mixed(const Array& x) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& x) const override;
+        Array apply_direction(Size direction, const Array& x) const override;
 
-        Disposable<Array> solve_splitting(Size direction, const Array& x, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array solve_splitting(Size direction, const Array& x, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const ext::shared_ptr<FdmMesher> mesher_;
diff --git a/ql/methods/finitedifferences/operators/fdmbatesop.cpp b/ql/methods/finitedifferences/operators/fdmbatesop.cpp
index 748bb9290f4..ca0653ffdef 100644
--- a/ql/methods/finitedifferences/operators/fdmbatesop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmbatesop.cpp
@@ -86,7 +86,7 @@ namespace QuantLib {
         return std::exp(-y*y)*valueOfDerivative;
     }
     
-    Disposable<Array> FdmBatesOp::integro(const Array& r) const {
+    Array FdmBatesOp::integro(const Array& r) const {
         const ext::shared_ptr<FdmLinearOpLayout> layout = mesher_->layout();
         
         QL_REQUIRE(layout->dim().size() == 2, "invalid layout dimension");
@@ -123,7 +123,7 @@ namespace QuantLib {
         return lambda_*(integral-r);
     }
 
-    Disposable<std::vector<SparseMatrix> > FdmBatesOp::toMatrixDecomp() const {
+    std::vector<SparseMatrix> FdmBatesOp::toMatrixDecomp() const {
         QL_FAIL("not implemented");
     }
 
diff --git a/ql/methods/finitedifferences/operators/fdmbatesop.hpp b/ql/methods/finitedifferences/operators/fdmbatesop.hpp
index 60862fe5815..874bda86b0f 100644
--- a/ql/methods/finitedifferences/operators/fdmbatesop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmbatesop.hpp
@@ -45,14 +45,14 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         class IntegroIntegrand {
@@ -68,7 +68,7 @@ namespace QuantLib {
             const ext::shared_ptr<LinearInterpolation>& interpl_;
         };
           
-        Disposable<Array> integro(const Array& r) const;  
+        Array integro(const Array& r) const;  
         
         Array x_, weights_;
         
@@ -89,28 +89,27 @@ namespace QuantLib {
         hestonOp_->setTime(t1, t2);
     }
     
-    inline Disposable<Array> FdmBatesOp::apply(const Array& r) const {
+    inline Array FdmBatesOp::apply(const Array& r) const {
         return hestonOp_->apply(r) + integro(r);
     }
     
-    inline Disposable<Array> FdmBatesOp::apply_mixed(const Array& r) const {
+    inline Array FdmBatesOp::apply_mixed(const Array& r) const {
         return hestonOp_->apply_mixed(r) + integro(r);
     }
 
-    inline
-    Disposable<Array> FdmBatesOp::apply_direction(Size direction,
-                                                  const Array& r) const {
+    inline Array FdmBatesOp::apply_direction(Size direction,
+                                             const Array& r) const {
         return hestonOp_->apply_direction(direction, r);
     }
 
-    inline Disposable<Array> FdmBatesOp::solve_splitting(Size direction,
-                                                         const Array& r,
-                                                         Real s) const{
+    inline Array FdmBatesOp::solve_splitting(Size direction,
+                                             const Array& r,
+                                             Real s) const{
         return hestonOp_->solve_splitting(direction, r, s);
     }
  
-    inline Disposable<Array> FdmBatesOp::preconditioner(const Array& r,
-                                                 Real s) const {
+    inline Array FdmBatesOp::preconditioner(const Array& r,
+                                            Real s) const {
         return hestonOp_->preconditioner(r, s);
     }
     
diff --git a/ql/methods/finitedifferences/operators/fdmblackscholesop.cpp b/ql/methods/finitedifferences/operators/fdmblackscholesop.cpp
index 3c43d3301e8..3f9a313f746 100644
--- a/ql/methods/finitedifferences/operators/fdmblackscholesop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmblackscholesop.cpp
@@ -106,44 +106,39 @@ namespace QuantLib {
 
     Size FdmBlackScholesOp::size() const { return 1U; }
 
-    Disposable<Array> FdmBlackScholesOp::apply(const Array& u) const {
+    Array FdmBlackScholesOp::apply(const Array& u) const {
         return mapT_.apply(u);
     }
 
-    Disposable<Array> FdmBlackScholesOp::apply_direction(Size direction,
-                                                    const Array& r) const {
+    Array FdmBlackScholesOp::apply_direction(Size direction,
+                                             const Array& r) const {
         if (direction == direction_)
             return mapT_.apply(r);
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array> FdmBlackScholesOp::apply_mixed(const Array& r) const {
-        Array retVal(r.size(), 0.0);
-        return retVal;
+    Array FdmBlackScholesOp::apply_mixed(const Array& r) const {
+        return Array(r.size(), 0.0);
     }
 
-    Disposable<Array> FdmBlackScholesOp::solve_splitting(Size direction,
-                                                const Array& r, Real dt) const {
+    Array FdmBlackScholesOp::solve_splitting(Size direction,
+                                             const Array& r, Real dt) const {
         if (direction == direction_)
             return mapT_.solve_splitting(r, dt, 1.0);
         else {
-            Array retVal(r);
-            return retVal;
+            return r;
         }
     }
 
-    Disposable<Array> FdmBlackScholesOp::preconditioner(const Array& r,
-                                                        Real dt) const {
+    Array FdmBlackScholesOp::preconditioner(const Array& r,
+                                            Real dt) const {
         return solve_splitting(direction_, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmBlackScholesOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(1, mapT_.toMatrix());
-        return retVal;
+    std::vector<SparseMatrix> FdmBlackScholesOp::toMatrixDecomp() const {
+        return std::vector<SparseMatrix>(1, mapT_.toMatrix());
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmblackscholesop.hpp b/ql/methods/finitedifferences/operators/fdmblackscholesop.hpp
index 5efb63de9e1..3f355cf02b3 100644
--- a/ql/methods/finitedifferences/operators/fdmblackscholesop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmblackscholesop.hpp
@@ -49,13 +49,13 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const ext::shared_ptr<FdmMesher> mesher_;
diff --git a/ql/methods/finitedifferences/operators/fdmcevop.cpp b/ql/methods/finitedifferences/operators/fdmcevop.cpp
index 368b9600878..afd0b7b9873 100644
--- a/ql/methods/finitedifferences/operators/fdmcevop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmcevop.cpp
@@ -49,45 +49,38 @@ namespace QuantLib {
         mapT_.axpyb(Array(), dxxMap_, dxxMap_, Array(1, -r));
     }
 
-    Disposable<Array> FdmCEVOp::apply(const Array& r) const {
+    Array FdmCEVOp::apply(const Array& r) const {
         return mapT_.apply(r);
     }
 
-    Disposable<Array> FdmCEVOp::apply_mixed(const Array& r) const {
-        Array retVal(r.size(), 0.0);
-        return retVal;
+    Array FdmCEVOp::apply_mixed(const Array& r) const {
+        return Array(r.size(), 0.0);
     }
 
-    Disposable<Array>
-    FdmCEVOp::apply_direction(Size direction, const Array& r) const {
+    Array FdmCEVOp::apply_direction(Size direction, const Array& r) const {
         if (direction == direction_) {
             return mapT_.apply(r);
         }
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array>
-    FdmCEVOp::solve_splitting(Size direction, const Array& r, Real a) const {
+    Array FdmCEVOp::solve_splitting(Size direction, const Array& r, Real a) const {
         if (direction == direction_) {
             return mapT_.solve_splitting(r, a, 1.0);
         }
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array>
-    FdmCEVOp::preconditioner(const Array& r, Real dt) const {
+    Array FdmCEVOp::preconditioner(const Array& r, Real dt) const {
         return solve_splitting(direction_, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> > FdmCEVOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(1, mapT_.toMatrix());
-        return retVal;
+    std::vector<SparseMatrix> FdmCEVOp::toMatrixDecomp() const {
+        return std::vector<SparseMatrix>(1, mapT_.toMatrix());
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmcevop.hpp b/ql/methods/finitedifferences/operators/fdmcevop.hpp
index 5c446cad18a..37770410683 100644
--- a/ql/methods/finitedifferences/operators/fdmcevop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmcevop.hpp
@@ -51,13 +51,13 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const ext::shared_ptr<YieldTermStructure>& rTS_;
diff --git a/ql/methods/finitedifferences/operators/fdmcirop.cpp b/ql/methods/finitedifferences/operators/fdmcirop.cpp
index e9d02b82816..6161cb37363 100644
--- a/ql/methods/finitedifferences/operators/fdmcirop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmcirop.cpp
@@ -126,7 +126,7 @@ namespace QuantLib {
         return 2;
     }
 
-    Disposable<Array> FdmCIROp::apply(const Array& u) const {
+    Array FdmCIROp::apply(const Array& u) const {
         Array dx = dxMap_.getMap().apply(u);
         Array dy = dyMap_.getMap().apply(u);
         Array dz = dzMap_.getMap().apply(u);
@@ -134,8 +134,8 @@ namespace QuantLib {
         return (dy + dx + dz);
     }
 
-    Disposable<Array> FdmCIROp::apply_direction(Size direction,
-                                                   const Array& r) const {
+    Array FdmCIROp::apply_direction(Size direction,
+                                    const Array& r) const {
         if (direction == 0)
             return dxMap_.getMap().apply(r);
         else if (direction == 1)
@@ -144,14 +144,12 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
 
-    Disposable<Array> FdmCIROp::apply_mixed(const Array& r) const {
+    Array FdmCIROp::apply_mixed(const Array& r) const {
         return dzMap_.getMap().apply(r);
     }
 
-    Disposable<Array>
-        FdmCIROp::solve_splitting(Size direction,
-                                     const Array& r, Real a) const {
-
+    Array FdmCIROp::solve_splitting(Size direction,
+                                    const Array& r, Real a) const {
         if (direction == 0) {
             return dxMap_.getMap().solve_splitting(r, a, 1.0);
         }
@@ -162,21 +160,16 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
 
-    Disposable<Array>
-        FdmCIROp::preconditioner(const Array& r, Real dt) const {
-
+    Array FdmCIROp::preconditioner(const Array& r, Real dt) const {
         return solve_splitting(1, solve_splitting(0, r, dt), dt) ;
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmCIROp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(3);
-
-        retVal[0] = dxMap_.getMap().toMatrix();
-        retVal[1] = dyMap_.getMap().toMatrix();
-        retVal[2] = dzMap_.getMap().toMatrix();
-
-        return retVal;
+    std::vector<SparseMatrix> FdmCIROp::toMatrixDecomp() const {
+        return {
+            dxMap_.getMap().toMatrix(),
+            dyMap_.getMap().toMatrix(),
+            dzMap_.getMap().toMatrix()
+        };
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmcirop.hpp b/ql/methods/finitedifferences/operators/fdmcirop.hpp
index 0800b6e9108..8644a8d1d45 100644
--- a/ql/methods/finitedifferences/operators/fdmcirop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmcirop.hpp
@@ -104,14 +104,14 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         FdmCIREquityPart dxMap_;
diff --git a/ql/methods/finitedifferences/operators/fdmg2op.cpp b/ql/methods/finitedifferences/operators/fdmg2op.cpp
index 45eff364fa0..bb41ba69eef 100644
--- a/ql/methods/finitedifferences/operators/fdmg2op.cpp
+++ b/ql/methods/finitedifferences/operators/fdmg2op.cpp
@@ -70,16 +70,15 @@ namespace QuantLib {
         mapY_.axpyb(Array(), dyMap_, dyMap_, hr);
     }
 
-    Disposable<Array> FdmG2Op::apply(const Array& r) const {
+    Array FdmG2Op::apply(const Array& r) const {
         return mapX_.apply(r) + mapY_.apply(r) + apply_mixed(r);
     }
 
-    Disposable<Array> FdmG2Op::apply_mixed(const Array& r) const {
+    Array FdmG2Op::apply_mixed(const Array& r) const {
         return corrMap_.apply(r);
     }
 
-    Disposable<Array>
-    FdmG2Op::apply_direction(Size direction, const Array& r) const {
+    Array FdmG2Op::apply_direction(Size direction, const Array& r) const {
         if (direction == direction1_) {
             return mapX_.apply(r);
         }
@@ -87,13 +86,11 @@ namespace QuantLib {
             return mapY_.apply(r);
         }
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array>
-    FdmG2Op::solve_splitting(Size direction, const Array& r, Real a) const {
+    Array FdmG2Op::solve_splitting(Size direction, const Array& r, Real a) const {
         if (direction == direction1_) {
             return mapX_.solve_splitting(r, a, 1.0);
         }
@@ -101,23 +98,20 @@ namespace QuantLib {
             return mapY_.solve_splitting(r, a, 1.0);
         }
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array>
-    FdmG2Op::preconditioner(const Array& r, Real dt) const {
+    Array FdmG2Op::preconditioner(const Array& r, Real dt) const {
         return solve_splitting(direction1_, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> > FdmG2Op::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(3);
-        retVal[0] = mapX_.toMatrix();
-        retVal[1] = mapY_.toMatrix();
-        retVal[2] = corrMap_.toMatrix();
-
-        return retVal;
+    std::vector<SparseMatrix> FdmG2Op::toMatrixDecomp() const {
+        return {
+            mapX_.toMatrix(),
+            mapY_.toMatrix(),
+            corrMap_.toMatrix()
+        };
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmg2op.hpp b/ql/methods/finitedifferences/operators/fdmg2op.hpp
index 668bae8df32..684cea45745 100644
--- a/ql/methods/finitedifferences/operators/fdmg2op.hpp
+++ b/ql/methods/finitedifferences/operators/fdmg2op.hpp
@@ -44,13 +44,13 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const Size direction1_, direction2_;
diff --git a/ql/methods/finitedifferences/operators/fdmhestonhullwhiteop.cpp b/ql/methods/finitedifferences/operators/fdmhestonhullwhiteop.cpp
index 3292f84efd2..47e29bac107 100644
--- a/ql/methods/finitedifferences/operators/fdmhestonhullwhiteop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmhestonhullwhiteop.cpp
@@ -102,15 +102,14 @@ namespace QuantLib {
         return 3;
     }
 
-    Disposable<Array> FdmHestonHullWhiteOp::apply(const Array& u) const {
+    Array FdmHestonHullWhiteOp::apply(const Array& u) const {
         return  dyMap_.apply(u) + dxMap_.getMap().apply(u)
               + hullWhiteOp_.apply(u)
               + hestonCorrMap_.apply(u) + equityIrCorrMap_.apply(u);
     }
 
-    Disposable<Array>
-    FdmHestonHullWhiteOp::apply_direction(Size direction,
-                                          const Array& r) const {
+    Array FdmHestonHullWhiteOp::apply_direction(Size direction,
+                                                const Array& r) const {
         if (direction == 0)
             return dxMap_.getMap().apply(r);
         else if (direction == 1)
@@ -121,13 +120,12 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
 
-    Disposable<Array> FdmHestonHullWhiteOp::apply_mixed(const Array& r) const {
+    Array FdmHestonHullWhiteOp::apply_mixed(const Array& r) const {
         return hestonCorrMap_.apply(r) + equityIrCorrMap_.apply(r);
     }
 
-    Disposable<Array>
-    FdmHestonHullWhiteOp::solve_splitting(Size direction, const Array& r,
-                                          Real a) const {
+    Array FdmHestonHullWhiteOp::solve_splitting(Size direction, const Array& r,
+                                                Real a) const {
         if (direction == 0) {
             return dxMap_.getMap().solve_splitting(r, a, 1.0);
         }
@@ -141,20 +139,18 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
     
-    Disposable<Array> FdmHestonHullWhiteOp::preconditioner(const Array& r, 
-                                                           Real dt) const {
+    Array FdmHestonHullWhiteOp::preconditioner(const Array& r, 
+                                               Real dt) const {
         return solve_splitting(0, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmHestonHullWhiteOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(4);
-        retVal[0] = dxMap_.getMap().toMatrix();
-        retVal[1] = dyMap_.toMatrix();
-        retVal[2] = hullWhiteOp_.toMatrixDecomp().front();
-        retVal[3] = hestonCorrMap_.toMatrix() + equityIrCorrMap_.toMatrix();
-
-        return retVal;
+    std::vector<SparseMatrix> FdmHestonHullWhiteOp::toMatrixDecomp() const {
+        return {
+            dxMap_.getMap().toMatrix(),
+            dyMap_.toMatrix(),
+            hullWhiteOp_.toMatrixDecomp().front(),
+            hestonCorrMap_.toMatrix() + equityIrCorrMap_.toMatrix()
+        };
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmhestonhullwhiteop.hpp b/ql/methods/finitedifferences/operators/fdmhestonhullwhiteop.hpp
index 3585029f60c..4143ebf02c0 100644
--- a/ql/methods/finitedifferences/operators/fdmhestonhullwhiteop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmhestonhullwhiteop.hpp
@@ -70,14 +70,14 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const Real v0_, kappa_, theta_, sigma_, rho_;
diff --git a/ql/methods/finitedifferences/operators/fdmhestonop.cpp b/ql/methods/finitedifferences/operators/fdmhestonop.cpp
index 0a278c381c8..2baa32b2896 100644
--- a/ql/methods/finitedifferences/operators/fdmhestonop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmhestonop.cpp
@@ -72,8 +72,8 @@ namespace QuantLib {
         }
     }
 
-    Disposable<Array> FdmHestonEquityPart::getLeverageFctSlice(Time t1, Time t2)
-    const {
+    Array FdmHestonEquityPart::getLeverageFctSlice(Time t1, Time t2) const {
+
         const ext::shared_ptr<FdmLinearOpLayout> layout=mesher_->layout();
         Array v(layout->size(), 1.0);
 
@@ -155,13 +155,13 @@ namespace QuantLib {
         return 2;
     }
 
-    Disposable<Array> FdmHestonOp::apply(const Array& u) const {
+    Array FdmHestonOp::apply(const Array& u) const {
         return dyMap_.getMap().apply(u) + dxMap_.getMap().apply(u)
               + dxMap_.getL()*correlationMap_.apply(u);
     }
 
-    Disposable<Array> FdmHestonOp::apply_direction(Size direction,
-                                                   const Array& r) const {
+    Array FdmHestonOp::apply_direction(Size direction,
+                                       const Array& r) const {
         if (direction == 0)
             return dxMap_.getMap().apply(r);
         else if (direction == 1)
@@ -170,13 +170,12 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
 
-    Disposable<Array> FdmHestonOp::apply_mixed(const Array& r) const {
+    Array FdmHestonOp::apply_mixed(const Array& r) const {
         return dxMap_.getL()*correlationMap_.apply(r);
     }
 
-    Disposable<Array>
-        FdmHestonOp::solve_splitting(Size direction,
-                                     const Array& r, Real a) const {
+    Array FdmHestonOp::solve_splitting(Size direction,
+                                       const Array& r, Real a) const {
 
         if (direction == 0) {
             return dxMap_.getMap().solve_splitting(r, a, 1.0);
@@ -188,21 +187,16 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
 
-    Disposable<Array>
-        FdmHestonOp::preconditioner(const Array& r, Real dt) const {
-
+    Array FdmHestonOp::preconditioner(const Array& r, Real dt) const {
         return solve_splitting(1, solve_splitting(0, r, dt), dt) ;
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmHestonOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(3);
-
-        retVal[0] = dxMap_.getMap().toMatrix();
-        retVal[1] = dyMap_.getMap().toMatrix();
-        retVal[2] = correlationMap_.toMatrix();
-
-        return retVal;
+    std::vector<SparseMatrix> FdmHestonOp::toMatrixDecomp() const {
+        return {
+            dxMap_.getMap().toMatrix(),
+            dyMap_.getMap().toMatrix(),
+            correlationMap_.toMatrix()
+        };
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmhestonop.hpp b/ql/methods/finitedifferences/operators/fdmhestonop.hpp
index 0e2437dc97c..a31bc5e0569 100644
--- a/ql/methods/finitedifferences/operators/fdmhestonop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmhestonop.hpp
@@ -51,7 +51,7 @@ namespace QuantLib {
         const Array& getL() const { return L_; }
 
       protected:
-        Disposable<Array> getLeverageFctSlice(Time t1, Time t2) const;
+        Array getLeverageFctSlice(Time t1, Time t2) const;
 
         Array varianceValues_, volatilityValues_, L_;
         const FirstDerivativeOp  dxMap_;
@@ -96,14 +96,14 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         NinePointLinearOp correlationMap_;
diff --git a/ql/methods/finitedifferences/operators/fdmhullwhiteop.cpp b/ql/methods/finitedifferences/operators/fdmhullwhiteop.cpp
index 9ebd2ef9399..d467320748c 100644
--- a/ql/methods/finitedifferences/operators/fdmhullwhiteop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmhullwhiteop.cpp
@@ -56,46 +56,37 @@ namespace QuantLib {
         mapT_.axpyb(Array(), dzMap_, dzMap_, -(x_+phi));
     }
 
-    Disposable<Array> FdmHullWhiteOp::apply(const Array& r) const {
+    Array FdmHullWhiteOp::apply(const Array& r) const {
         return mapT_.apply(r);
     }
 
-    Disposable<Array> FdmHullWhiteOp::apply_mixed(const Array& r) const {
-        Array retVal(r.size(), 0.0);
-        return retVal;
+    Array FdmHullWhiteOp::apply_mixed(const Array& r) const {
+        return Array(r.size(), 0.0);
     }
 
-    Disposable<Array>
-    FdmHullWhiteOp::apply_direction(Size direction, const Array& r) const {
+    Array FdmHullWhiteOp::apply_direction(Size direction, const Array& r) const {
         if (direction == direction_)
             return mapT_.apply(r);
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array> FdmHullWhiteOp::solve_splitting(
-        Size direction, const Array& r, Real a) const {
-
+    Array FdmHullWhiteOp::solve_splitting(Size direction, const Array& r, Real a) const {
         if (direction == direction_) {
             return mapT_.solve_splitting(r, a, 1.0);
         }
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array>
-    FdmHullWhiteOp::preconditioner(const Array& r, Real dt) const {
+    Array FdmHullWhiteOp::preconditioner(const Array& r, Real dt) const {
         return solve_splitting(direction_, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmHullWhiteOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(1, mapT_.toMatrix());
-        return retVal;
+    std::vector<SparseMatrix> FdmHullWhiteOp::toMatrixDecomp() const {
+        return std::vector<SparseMatrix>(1, mapT_.toMatrix());
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmhullwhiteop.hpp b/ql/methods/finitedifferences/operators/fdmhullwhiteop.hpp
index 2e8e8e6f3e7..735f7a12587 100644
--- a/ql/methods/finitedifferences/operators/fdmhullwhiteop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmhullwhiteop.hpp
@@ -45,13 +45,13 @@ namespace QuantLib {
         //! Time \f$t1 <= t2\f$ is required
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const Size direction_;
diff --git a/ql/methods/finitedifferences/operators/fdmlinearop.hpp b/ql/methods/finitedifferences/operators/fdmlinearop.hpp
index 0c6d6d353e2..0c546a42169 100644
--- a/ql/methods/finitedifferences/operators/fdmlinearop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmlinearop.hpp
@@ -35,9 +35,9 @@ namespace QuantLib {
       public:
         typedef Array array_type;
         virtual ~FdmLinearOp() = default;
-        virtual Disposable<array_type> apply(const array_type& r) const = 0;
+        virtual array_type apply(const array_type& r) const = 0;
 
-        virtual Disposable<SparseMatrix> toMatrix() const = 0;
+        virtual SparseMatrix toMatrix() const = 0;
     };
 }
 
diff --git a/ql/methods/finitedifferences/operators/fdmlinearopcomposite.hpp b/ql/methods/finitedifferences/operators/fdmlinearopcomposite.hpp
index febdff53245..473615f46c1 100644
--- a/ql/methods/finitedifferences/operators/fdmlinearopcomposite.hpp
+++ b/ql/methods/finitedifferences/operators/fdmlinearopcomposite.hpp
@@ -39,24 +39,20 @@ namespace QuantLib {
         //! Time \f$t1 <= t2\f$ is required
         virtual void setTime(Time t1, Time t2) = 0;
 
-        virtual Disposable<Array> apply_mixed(const Array& r) const = 0;
+        virtual Array apply_mixed(const Array& r) const = 0;
         
-        virtual Disposable<Array> 
-            apply_direction(Size direction, const Array& r) const = 0;
-        virtual Disposable<Array> 
-            solve_splitting(Size direction, const Array& r, Real s) const = 0;
-        virtual Disposable<Array> 
-            preconditioner(const Array& r, Real s) const = 0;
+        virtual Array apply_direction(Size direction, const Array& r) const = 0;
+        virtual Array solve_splitting(Size direction, const Array& r, Real s) const = 0;
+        virtual Array preconditioner(const Array& r, Real s) const = 0;
 
-        virtual Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const {
+        virtual std::vector<SparseMatrix> toMatrixDecomp() const {
             QL_FAIL(" ublas representation is not implemented");
         }
 
-        Disposable<SparseMatrix> toMatrix() const override {
+        SparseMatrix toMatrix() const override {
             const std::vector<SparseMatrix> dcmp = toMatrixDecomp();
-            SparseMatrix retVal = std::accumulate(dcmp.begin()+1, dcmp.end(),
-                                                  SparseMatrix(dcmp.front()));
-            return retVal;
+            return std::accumulate(dcmp.begin()+1, dcmp.end(),
+                                   SparseMatrix(dcmp.front()));
         }
 
     };
diff --git a/ql/methods/finitedifferences/operators/fdmlinearopiterator.hpp b/ql/methods/finitedifferences/operators/fdmlinearopiterator.hpp
index c63a425ed10..51e607af09d 100644
--- a/ql/methods/finitedifferences/operators/fdmlinearopiterator.hpp
+++ b/ql/methods/finitedifferences/operators/fdmlinearopiterator.hpp
@@ -27,7 +27,6 @@
 #define quantlib_linear_op_iterator_hpp
 
 #include <ql/types.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <numeric>
 #include <utility>
 #include <vector>
@@ -47,11 +46,6 @@ namespace QuantLib {
         FdmLinearOpIterator(std::vector<Size> dim, std::vector<Size> coordinates, Size index)
         : index_(index), dim_(std::move(dim)), coordinates_(std::move(coordinates)) {}
 
-        FdmLinearOpIterator(
-            const Disposable<FdmLinearOpIterator> & from) {
-            swap(const_cast<Disposable<FdmLinearOpIterator> & >(from));
-        }
-
         void operator++() {
             ++index_;
             for (Size i=0; i < dim_.size(); ++i) {
diff --git a/ql/methods/finitedifferences/operators/fdmlinearoplayout.cpp b/ql/methods/finitedifferences/operators/fdmlinearoplayout.cpp
index 8c2467c5b82..4dd65760d73 100644
--- a/ql/methods/finitedifferences/operators/fdmlinearoplayout.cpp
+++ b/ql/methods/finitedifferences/operators/fdmlinearoplayout.cpp
@@ -66,7 +66,7 @@ namespace QuantLib {
     }
 
     // smart but sometimes too slow
-    Disposable<FdmLinearOpIterator> FdmLinearOpLayout::iter_neighbourhood(
+    FdmLinearOpIterator FdmLinearOpLayout::iter_neighbourhood(
         const FdmLinearOpIterator& iterator, Size i, Integer offset) const {
 
         std::vector<Size> coordinates = iterator.coordinates();
@@ -80,9 +80,8 @@ namespace QuantLib {
         }
         coordinates[i] = Size(coorOffset);
 
-        FdmLinearOpIterator retVal(dim_, coordinates,
+        return FdmLinearOpIterator(dim_, coordinates,
                                    index(coordinates));
-
-        return retVal;
     }
+
 }
diff --git a/ql/methods/finitedifferences/operators/fdmlinearoplayout.hpp b/ql/methods/finitedifferences/operators/fdmlinearoplayout.hpp
index 69535098e4b..115d68cdc01 100644
--- a/ql/methods/finitedifferences/operators/fdmlinearoplayout.hpp
+++ b/ql/methods/finitedifferences/operators/fdmlinearoplayout.hpp
@@ -76,7 +76,7 @@ namespace QuantLib {
                            Size i2, Integer offset2) const;
 
         // smart but sometimes too slow
-        Disposable<FdmLinearOpIterator> iter_neighbourhood(
+        FdmLinearOpIterator iter_neighbourhood(
             const FdmLinearOpIterator& iterator, Size i, Integer offset) const;
 
       private:
diff --git a/ql/methods/finitedifferences/operators/fdmlocalvolfwdop.cpp b/ql/methods/finitedifferences/operators/fdmlocalvolfwdop.cpp
index 7ae9be0e04f..fc66556c067 100644
--- a/ql/methods/finitedifferences/operators/fdmlocalvolfwdop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmlocalvolfwdop.cpp
@@ -59,44 +59,39 @@ namespace QuantLib {
 
     Size FdmLocalVolFwdOp::size() const { return 1U; }
 
-    Disposable<Array> FdmLocalVolFwdOp::apply(const Array& u) const {
+    Array FdmLocalVolFwdOp::apply(const Array& u) const {
         return mapT_.apply(u);
     }
 
-    Disposable<Array> FdmLocalVolFwdOp::apply_direction(
+    Array FdmLocalVolFwdOp::apply_direction(
         Size direction, const Array& r) const {
         if (direction == direction_)
             return mapT_.apply(r);
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array> FdmLocalVolFwdOp::apply_mixed(const Array& r) const {
-        Array retVal(r.size(), 0.0);
-        return retVal;
+    Array FdmLocalVolFwdOp::apply_mixed(const Array& r) const {
+        return Array(r.size(), 0.0);
     }
 
-    Disposable<Array> FdmLocalVolFwdOp::solve_splitting(
+    Array FdmLocalVolFwdOp::solve_splitting(
         Size direction, const Array& r, Real dt) const {
         if (direction == direction_)
             return mapT_.solve_splitting(r, dt, 1.0);
         else {
-            Array retVal(r);
-            return retVal;
+            return r;
         }
     }
 
-    Disposable<Array> FdmLocalVolFwdOp::preconditioner(
+    Array FdmLocalVolFwdOp::preconditioner(
         const Array& r, Real dt) const {
         return solve_splitting(direction_, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmLocalVolFwdOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(1, mapT_.toMatrix());
-        return retVal;
+    std::vector<SparseMatrix> FdmLocalVolFwdOp::toMatrixDecomp() const {
+        return std::vector<SparseMatrix>(1, mapT_.toMatrix());
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmlocalvolfwdop.hpp b/ql/methods/finitedifferences/operators/fdmlocalvolfwdop.hpp
index 27aa00b0fed..7ad5f13552f 100644
--- a/ql/methods/finitedifferences/operators/fdmlocalvolfwdop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmlocalvolfwdop.hpp
@@ -45,13 +45,13 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const ext::shared_ptr<FdmMesher> mesher_;
diff --git a/ql/methods/finitedifferences/operators/fdmornsteinuhlenbeckop.cpp b/ql/methods/finitedifferences/operators/fdmornsteinuhlenbeckop.cpp
index 8f9d15cd880..bda2e259a92 100644
--- a/ql/methods/finitedifferences/operators/fdmornsteinuhlenbeckop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmornsteinuhlenbeckop.cpp
@@ -66,50 +66,38 @@ namespace QuantLib {
         mapX_.axpyb(Array(), m_, m_, Array(1, -r));
     }
 
-    Disposable<Array> FdmOrnsteinUhlenbeckOp::apply(const Array& r) const {
+    Array FdmOrnsteinUhlenbeckOp::apply(const Array& r) const {
         return mapX_.apply(r);
     }
 
-    Disposable<Array> FdmOrnsteinUhlenbeckOp::apply_mixed(
-        const Array& r) const {
-
-        Array retVal(r.size(), 0.0);
-        return retVal;
+    Array FdmOrnsteinUhlenbeckOp::apply_mixed(const Array& r) const {
+        return Array(r.size(), 0.0);
     }
 
-    Disposable<Array> FdmOrnsteinUhlenbeckOp::apply_direction(
-        Size direction, const Array& r) const {
-
+    Array FdmOrnsteinUhlenbeckOp::apply_direction(Size direction, const Array& r) const {
         if (direction == direction_) {
             return mapX_.apply(r);
         }
         else {
-            Array retVal(r.size(), 0.0);
-            return retVal;
+            return Array(r.size(), 0.0);
         }
     }
 
-    Disposable<Array> FdmOrnsteinUhlenbeckOp::solve_splitting(
-        Size direction, const Array& r, Real a) const {
-
+    Array FdmOrnsteinUhlenbeckOp::solve_splitting(Size direction, const Array& r, Real a) const {
         if (direction == direction_) {
             return mapX_.solve_splitting(r, a, 1.0);
         }
         else {
-            Array retVal(r);
-            return retVal;
+            return r;
         }
     }
 
-    Disposable<Array> FdmOrnsteinUhlenbeckOp::preconditioner(
-        const Array& r, Real dt) const {
+    Array FdmOrnsteinUhlenbeckOp::preconditioner(const Array& r, Real dt) const {
         return solve_splitting(direction_, r, dt);
     }
 
-    Disposable<std::vector<SparseMatrix> >
-    FdmOrnsteinUhlenbeckOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(1, mapX_.toMatrix());
-        return retVal;
+    std::vector<SparseMatrix> FdmOrnsteinUhlenbeckOp::toMatrixDecomp() const {
+        return std::vector<SparseMatrix>(1, mapX_.toMatrix());
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmornsteinuhlenbeckop.hpp b/ql/methods/finitedifferences/operators/fdmornsteinuhlenbeckop.hpp
index bc6e5c94665..c5a0b478a93 100644
--- a/ql/methods/finitedifferences/operators/fdmornsteinuhlenbeckop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmornsteinuhlenbeckop.hpp
@@ -46,14 +46,14 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
 
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const ext::shared_ptr<FdmMesher> mesher_;
diff --git a/ql/methods/finitedifferences/operators/fdmsabrop.cpp b/ql/methods/finitedifferences/operators/fdmsabrop.cpp
index 9b6a7189fcb..e665b4656b0 100644
--- a/ql/methods/finitedifferences/operators/fdmsabrop.cpp
+++ b/ql/methods/finitedifferences/operators/fdmsabrop.cpp
@@ -59,15 +59,15 @@ namespace QuantLib {
         return 2;
     }
 
-    Disposable<Array> FdmSabrOp::apply(const Array& u) const {
+    Array FdmSabrOp::apply(const Array& u) const {
         return mapF_.apply(u) + mapA_.apply(u) + correlationMap_.apply(u);
     }
 
-    Disposable<Array> FdmSabrOp::apply_mixed(const Array& r) const {
+    Array FdmSabrOp::apply_mixed(const Array& r) const {
         return correlationMap_.apply(r);
     }
 
-    Disposable<Array> FdmSabrOp::apply_direction(
+    Array FdmSabrOp::apply_direction(
         Size direction, const Array& r) const {
         if (direction == 0)
             return mapF_.apply(r);
@@ -77,7 +77,7 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
 
-    Disposable<Array> FdmSabrOp::solve_splitting(
+    Array FdmSabrOp::solve_splitting(
        Size direction, const Array& r, Real a) const {
 
         if (direction == 0) {
@@ -90,20 +90,18 @@ namespace QuantLib {
             QL_FAIL("direction too large");
     }
 
-    Disposable<Array> FdmSabrOp::preconditioner(
+    Array FdmSabrOp::preconditioner(
         const Array& r, Real dt) const {
 
         return solve_splitting(1, solve_splitting(0, r, dt), dt) ;
     }
 
-    Disposable<std::vector<SparseMatrix> > FdmSabrOp::toMatrixDecomp() const {
-        std::vector<SparseMatrix> retVal(3);
-
-        retVal[0] = mapA_.toMatrix();
-        retVal[1] = mapF_.toMatrix();
-        retVal[2] = correlationMap_.toMatrix();
-
-        return retVal;
+    std::vector<SparseMatrix> FdmSabrOp::toMatrixDecomp() const {
+        return {
+            mapA_.toMatrix(),
+            mapF_.toMatrix(),
+            correlationMap_.toMatrix()
+        };
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/fdmsabrop.hpp b/ql/methods/finitedifferences/operators/fdmsabrop.hpp
index 79f7df2ed5b..5f336f83ba8 100644
--- a/ql/methods/finitedifferences/operators/fdmsabrop.hpp
+++ b/ql/methods/finitedifferences/operators/fdmsabrop.hpp
@@ -55,13 +55,13 @@ namespace QuantLib {
         Size size() const override;
         void setTime(Time t1, Time t2) override;
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> apply_mixed(const Array& r) const override;
-        Disposable<Array> apply_direction(Size direction, const Array& r) const override;
-        Disposable<Array> solve_splitting(Size direction, const Array& r, Real s) const override;
-        Disposable<Array> preconditioner(const Array& r, Real s) const override;
+        Array apply(const Array& r) const override;
+        Array apply_mixed(const Array& r) const override;
+        Array apply_direction(Size direction, const Array& r) const override;
+        Array solve_splitting(Size direction, const Array& r, Real s) const override;
+        Array preconditioner(const Array& r, Real s) const override;
 
-        Disposable<std::vector<SparseMatrix> > toMatrixDecomp() const override;
+        std::vector<SparseMatrix> toMatrixDecomp() const override;
 
       private:
         const ext::shared_ptr<YieldTermStructure> rTS_;
diff --git a/ql/methods/finitedifferences/operators/ninepointlinearop.cpp b/ql/methods/finitedifferences/operators/ninepointlinearop.cpp
index 0f6661ad378..fd0dd1ef822 100644
--- a/ql/methods/finitedifferences/operators/ninepointlinearop.cpp
+++ b/ql/methods/finitedifferences/operators/ninepointlinearop.cpp
@@ -110,21 +110,7 @@ namespace QuantLib {
         std::copy(m.a22_.get(), m.a22_.get()+size, a22_.get());
     }
 
-    #ifdef QL_USE_DISPOSABLE
-    NinePointLinearOp::NinePointLinearOp(
-        const Disposable<NinePointLinearOp>& from) {
-        swap(const_cast<Disposable<NinePointLinearOp>&>(from));
-    }
-
-    NinePointLinearOp& NinePointLinearOp::operator=(
-        const Disposable<NinePointLinearOp>& m) {
-        swap(const_cast<Disposable<NinePointLinearOp>&>(m));
-        return *this;
-    }
-    #endif
-
-    Disposable<Array> NinePointLinearOp::apply(const Array& u)
-        const {
+    Array NinePointLinearOp::apply(const Array& u) const {
 
         const ext::shared_ptr<FdmLinearOpLayout> index=mesher_->layout();
         QL_REQUIRE(u.size() == index->size(),"inconsistent length of r "
@@ -154,7 +140,7 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<SparseMatrix> NinePointLinearOp::toMatrix() const {
+    SparseMatrix NinePointLinearOp::toMatrix() const {
         const ext::shared_ptr<FdmLinearOpLayout> index = mesher_->layout();
         const Size n = index->size();
 
@@ -175,8 +161,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<NinePointLinearOp>
-        NinePointLinearOp::mult(const Array & u) const {
+    NinePointLinearOp NinePointLinearOp::mult(const Array & u) const {
 
         NinePointLinearOp retVal(d0_, d1_, mesher_);
         const Size size = mesher_->layout()->size();
diff --git a/ql/methods/finitedifferences/operators/ninepointlinearop.hpp b/ql/methods/finitedifferences/operators/ninepointlinearop.hpp
index f3402f36289..82335c66770 100644
--- a/ql/methods/finitedifferences/operators/ninepointlinearop.hpp
+++ b/ql/methods/finitedifferences/operators/ninepointlinearop.hpp
@@ -43,21 +43,15 @@ namespace QuantLib {
                 const ext::shared_ptr<FdmMesher>& mesher);
         NinePointLinearOp(const NinePointLinearOp& m);
         NinePointLinearOp(NinePointLinearOp&& m) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        NinePointLinearOp(const Disposable<NinePointLinearOp>& m);
-        #endif
         NinePointLinearOp& operator=(const NinePointLinearOp& m);
         NinePointLinearOp& operator=(NinePointLinearOp&& m) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        NinePointLinearOp& operator=(const Disposable<NinePointLinearOp>& m);
-        #endif
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<NinePointLinearOp> mult(const Array& u) const;
+        Array apply(const Array& r) const override;
+        NinePointLinearOp mult(const Array& u) const;
 
         void swap(NinePointLinearOp& m);
 
-        Disposable<SparseMatrix> toMatrix() const override;
+        SparseMatrix toMatrix() const override;
 
       protected:
         NinePointLinearOp() = default;
diff --git a/ql/methods/finitedifferences/operators/nthorderderivativeop.cpp b/ql/methods/finitedifferences/operators/nthorderderivativeop.cpp
index 2635a6c269d..96d0083f504 100644
--- a/ql/methods/finitedifferences/operators/nthorderderivativeop.cpp
+++ b/ql/methods/finitedifferences/operators/nthorderderivativeop.cpp
@@ -79,15 +79,13 @@ namespace QuantLib {
         }
     }
 
-    Disposable<NthOrderDerivativeOp::array_type>
-    NthOrderDerivativeOp::apply(const array_type& r) const {
+    NthOrderDerivativeOp::array_type NthOrderDerivativeOp::apply(const array_type& r) const {
         return prod(m_, r);
     }
 
 
-    Disposable<SparseMatrix> NthOrderDerivativeOp::toMatrix() const {
-        SparseMatrix tmp(m_);
-        return tmp;
+    SparseMatrix NthOrderDerivativeOp::toMatrix() const {
+        return m_;
     }
 
 }
diff --git a/ql/methods/finitedifferences/operators/nthorderderivativeop.hpp b/ql/methods/finitedifferences/operators/nthorderderivativeop.hpp
index 8fd8f8f4fe7..054e09ed700 100644
--- a/ql/methods/finitedifferences/operators/nthorderderivativeop.hpp
+++ b/ql/methods/finitedifferences/operators/nthorderderivativeop.hpp
@@ -35,8 +35,8 @@ namespace QuantLib {
             Size direction, Size order, Integer nPoints,
             const ext::shared_ptr<FdmMesher>& mesher);
 
-        Disposable<array_type> apply(const array_type& r) const override;
-        Disposable<SparseMatrix> toMatrix() const override;
+        array_type apply(const array_type& r) const override;
+        SparseMatrix toMatrix() const override;
 
       private:
         SparseMatrix m_;
diff --git a/ql/methods/finitedifferences/operators/numericaldifferentiation.cpp b/ql/methods/finitedifferences/operators/numericaldifferentiation.cpp
index 492981a1ab2..c6dfedb2ae5 100644
--- a/ql/methods/finitedifferences/operators/numericaldifferentiation.cpp
+++ b/ql/methods/finitedifferences/operators/numericaldifferentiation.cpp
@@ -37,7 +37,7 @@
 namespace QuantLib {
 
     namespace {
-        Disposable<Array> calcOffsets(
+        Array calcOffsets(
             Real h, Size n, NumericalDifferentiation::Scheme scheme) {
             QL_REQUIRE(n > 1, "number of steps must be greater than one");
 
@@ -68,7 +68,7 @@ namespace QuantLib {
         // B. Fornberg, 1998. Calculation of Weights
         //                    in Finite Difference Formulas
         // https://amath.colorado.edu/faculty/fornberg/Docs/sirev_cl.pdf
-        Disposable<Array> calcWeights(const Array& x, Size M) {
+        Array calcWeights(const Array& x, Size M) {
             const Size N = x.size();
             QL_REQUIRE(N > M, "number of points must be greater "
                                "than the order of the derivative");
diff --git a/ql/methods/finitedifferences/operators/triplebandlinearop.cpp b/ql/methods/finitedifferences/operators/triplebandlinearop.cpp
index fcf103250bb..15879763a2e 100644
--- a/ql/methods/finitedifferences/operators/triplebandlinearop.cpp
+++ b/ql/methods/finitedifferences/operators/triplebandlinearop.cpp
@@ -80,20 +80,6 @@ namespace QuantLib {
         std::copy(m.upper_.get(), m.upper_.get() + len, upper_.get());
     }
 
-
-    #ifdef QL_USE_DISPOSABLE
-    TripleBandLinearOp::TripleBandLinearOp(
-        const Disposable<TripleBandLinearOp>& from) {
-        swap(const_cast<Disposable<TripleBandLinearOp>&>(from));
-    }
-
-    TripleBandLinearOp& TripleBandLinearOp::operator=(
-        const Disposable<TripleBandLinearOp>& m) {
-        swap(const_cast<Disposable<TripleBandLinearOp>&>(m));
-        return *this;
-    }
-    #endif
-
     void TripleBandLinearOp::swap(TripleBandLinearOp& m) {
         std::swap(mesher_, m.mesher_);
         std::swap(direction_, m.direction_);
@@ -174,8 +160,7 @@ namespace QuantLib {
         }
     }
 
-    Disposable<TripleBandLinearOp>
-    TripleBandLinearOp::add(const TripleBandLinearOp& m) const {
+    TripleBandLinearOp TripleBandLinearOp::add(const TripleBandLinearOp& m) const {
 
         TripleBandLinearOp retVal(direction_, mesher_);
         const Size size = mesher_->layout()->size();
@@ -190,7 +175,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<TripleBandLinearOp> TripleBandLinearOp::mult(const Array& u) const {
+    TripleBandLinearOp TripleBandLinearOp::mult(const Array& u) const {
 
         TripleBandLinearOp retVal(direction_, mesher_);
 
@@ -206,7 +191,7 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<TripleBandLinearOp> TripleBandLinearOp::multR(const Array& u) const {
+    TripleBandLinearOp TripleBandLinearOp::multR(const Array& u) const {
         const ext::shared_ptr<FdmLinearOpLayout> layout = mesher_->layout();
         const Size size = layout->size();
         QL_REQUIRE(u.size() == size, "inconsistent size of rhs");
@@ -225,7 +210,7 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<TripleBandLinearOp> TripleBandLinearOp::add(const Array& u) const {
+    TripleBandLinearOp TripleBandLinearOp::add(const Array& u) const {
 
         TripleBandLinearOp retVal(direction_, mesher_);
 
@@ -240,7 +225,7 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<Array> TripleBandLinearOp::apply(const Array& r) const {
+    Array TripleBandLinearOp::apply(const Array& r) const {
         const ext::shared_ptr<FdmLinearOpLayout> index = mesher_->layout();
 
         QL_REQUIRE(r.size() == index->size(), "inconsistent length of r");
@@ -260,7 +245,7 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<SparseMatrix> TripleBandLinearOp::toMatrix() const {
+    SparseMatrix TripleBandLinearOp::toMatrix() const {
         const ext::shared_ptr<FdmLinearOpLayout> index = mesher_->layout();
         const Size n = index->size();
 
@@ -275,8 +260,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<Array>
-    TripleBandLinearOp::solve_splitting(const Array& r, Real a, Real b) const {
+    Array TripleBandLinearOp::solve_splitting(const Array& r, Real a, Real b) const {
         const ext::shared_ptr<FdmLinearOpLayout> layout = mesher_->layout();
         QL_REQUIRE(r.size() == layout->size(), "inconsistent size of rhs");
 
diff --git a/ql/methods/finitedifferences/operators/triplebandlinearop.hpp b/ql/methods/finitedifferences/operators/triplebandlinearop.hpp
index c1bc97db75e..8812fe693e2 100644
--- a/ql/methods/finitedifferences/operators/triplebandlinearop.hpp
+++ b/ql/methods/finitedifferences/operators/triplebandlinearop.hpp
@@ -44,25 +44,18 @@ namespace QuantLib {
 
         TripleBandLinearOp(const TripleBandLinearOp& m);
         TripleBandLinearOp(TripleBandLinearOp&& m) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        TripleBandLinearOp(const Disposable<TripleBandLinearOp>& m);
-        #endif
         TripleBandLinearOp& operator=(const TripleBandLinearOp& m);
         TripleBandLinearOp& operator=(TripleBandLinearOp&& m) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        TripleBandLinearOp& operator=(const Disposable<TripleBandLinearOp>& m);
-        #endif
 
-        Disposable<Array> apply(const Array& r) const override;
-        Disposable<Array> solve_splitting(const Array& r, Real a,
-                                          Real b = 1.0) const;
+        Array apply(const Array& r) const override;
+        Array solve_splitting(const Array& r, Real a, Real b = 1.0) const;
 
-        Disposable<TripleBandLinearOp> mult(const Array& u) const;
+        TripleBandLinearOp mult(const Array& u) const;
         // interpret u as the diagonal of a diagonal matrix, multiplied on LHS
-        Disposable<TripleBandLinearOp> multR(const Array& u) const;
+        TripleBandLinearOp multR(const Array& u) const;
         // interpret u as the diagonal of a diagonal matrix, multiplied on RHS
-        Disposable<TripleBandLinearOp> add(const TripleBandLinearOp& m) const;
-        Disposable<TripleBandLinearOp> add(const Array& u) const;
+        TripleBandLinearOp add(const TripleBandLinearOp& m) const;
+        TripleBandLinearOp add(const Array& u) const;
 
         // some very basic linear algebra routines
         void axpyb(const Array& a, const TripleBandLinearOp& x,
@@ -70,7 +63,7 @@ namespace QuantLib {
 
         void swap(TripleBandLinearOp& m);
 
-        Disposable<SparseMatrix> toMatrix() const override;
+        SparseMatrix toMatrix() const override;
 
       protected:
         TripleBandLinearOp() = default;
diff --git a/ql/methods/finitedifferences/schemes/impliciteulerscheme.cpp b/ql/methods/finitedifferences/schemes/impliciteulerscheme.cpp
index 4b522a28955..d00405cdb03 100644
--- a/ql/methods/finitedifferences/schemes/impliciteulerscheme.cpp
+++ b/ql/methods/finitedifferences/schemes/impliciteulerscheme.cpp
@@ -34,7 +34,7 @@ namespace QuantLib {
     : dt_(Null<Real>()), iterations_(ext::make_shared<Size>(0U)), relTol_(relTol),
       map_(std::move(map)), bcSet_(bcSet), solverType_(solverType) {}
 
-    Disposable<Array> ImplicitEulerScheme::apply(const Array& r, Real theta) const {
+    Array ImplicitEulerScheme::apply(const Array& r, Real theta) const {
         return r - (theta*dt_)*map_->apply(r);
     }
 
diff --git a/ql/methods/finitedifferences/schemes/impliciteulerscheme.hpp b/ql/methods/finitedifferences/schemes/impliciteulerscheme.hpp
index 76a19d1e77d..f7fed331b2d 100644
--- a/ql/methods/finitedifferences/schemes/impliciteulerscheme.hpp
+++ b/ql/methods/finitedifferences/schemes/impliciteulerscheme.hpp
@@ -57,7 +57,7 @@ namespace QuantLib {
         friend class CrankNicolsonScheme;
         void step(array_type& a, Time t, Real theta);
 
-        Disposable<Array> apply(const Array& r, Real theta) const;
+        Array apply(const Array& r, Real theta) const;
           
         Time dt_;
         ext::shared_ptr<Size> iterations_;
diff --git a/ql/methods/finitedifferences/schemes/methodoflinesscheme.cpp b/ql/methods/finitedifferences/schemes/methodoflinesscheme.cpp
index 6c8e5161c01..137cb7b41db 100644
--- a/ql/methods/finitedifferences/schemes/methodoflinesscheme.cpp
+++ b/ql/methods/finitedifferences/schemes/methodoflinesscheme.cpp
@@ -31,15 +31,13 @@ namespace QuantLib {
       bcSet_(bcSet) {}
 
 
-    Disposable<std::vector<Real> >
-    MethodOfLinesScheme::apply(Time t, const std::vector<Real>& u) const {
+    std::vector<Real> MethodOfLinesScheme::apply(Time t, const std::vector<Real>& u) const {
         map_->setTime(t, t + 0.0001);
         bcSet_.applyBeforeApplying(*map_);
 
         const Array dxdt = -map_->apply(Array(u.begin(), u.end()));
 
-        std::vector<Real> retVal(dxdt.begin(), dxdt.end());
-        return retVal;
+        return std::vector<Real>(dxdt.begin(), dxdt.end());
     }
 
     void MethodOfLinesScheme::step(array_type& a, Time t) {
diff --git a/ql/methods/finitedifferences/schemes/methodoflinesscheme.hpp b/ql/methods/finitedifferences/schemes/methodoflinesscheme.hpp
index d39252e1c46..63ebc9a4531 100644
--- a/ql/methods/finitedifferences/schemes/methodoflinesscheme.hpp
+++ b/ql/methods/finitedifferences/schemes/methodoflinesscheme.hpp
@@ -50,8 +50,7 @@ namespace QuantLib {
 
       protected:
         //apply for QuantLib's Runge-Kutta implementation
-        Disposable<std::vector<Real> >
-            apply(Time, const std::vector<Real>&) const;
+        std::vector<Real> apply(Time, const std::vector<Real>&) const;
 
         Time dt_;
         const Real eps_, relInitStepSize_;
diff --git a/ql/methods/finitedifferences/schemes/trbdf2scheme.hpp b/ql/methods/finitedifferences/schemes/trbdf2scheme.hpp
index db6e22b8eea..61aa43eb071 100644
--- a/ql/methods/finitedifferences/schemes/trbdf2scheme.hpp
+++ b/ql/methods/finitedifferences/schemes/trbdf2scheme.hpp
@@ -60,7 +60,7 @@ namespace QuantLib {
 
         Size numberOfIterations() const;
       protected:
-        Disposable<Array> apply(const Array& r) const;
+        Array apply(const Array& r) const;
 
         Time dt_;
         Real beta_;
@@ -98,8 +98,7 @@ namespace QuantLib {
     }
 
     template <class TrapezoidalScheme>
-    inline Disposable<Array> TrBDF2Scheme<TrapezoidalScheme>::apply(
-        const Array& r) const {
+    inline Array TrBDF2Scheme<TrapezoidalScheme>::apply(const Array& r) const {
         return r - beta_*map_->apply(r);
     }
 
diff --git a/ql/methods/finitedifferences/tridiagonaloperator.cpp b/ql/methods/finitedifferences/tridiagonaloperator.cpp
index 4f48413ad52..0d94f5caf59 100644
--- a/ql/methods/finitedifferences/tridiagonaloperator.cpp
+++ b/ql/methods/finitedifferences/tridiagonaloperator.cpp
@@ -54,7 +54,7 @@ namespace QuantLib {
                    " instead of " << n_-1);
     }
 
-    Disposable<Array> TridiagonalOperator::applyTo(const Array& v) const {
+    Array TridiagonalOperator::applyTo(const Array& v) const {
         QL_REQUIRE(n_!=0,
                    "uninitialized TridiagonalOperator");
         QL_REQUIRE(v.size()==n_,
@@ -76,8 +76,7 @@ namespace QuantLib {
         return result;
     }
 
-    Disposable<Array> TridiagonalOperator::solveFor(const Array& rhs) const  {
-
+    Array TridiagonalOperator::solveFor(const Array& rhs) const  {
         Array result(rhs.size());
         solveFor(rhs, result);
         return result;
@@ -109,8 +108,8 @@ namespace QuantLib {
         result[0] -= temp_[1]*result[1];
     }
 
-    Disposable<Array> TridiagonalOperator::SOR(const Array& rhs,
-                                               Real tol) const {
+    Array TridiagonalOperator::SOR(const Array& rhs,
+                                   Real tol) const {
         QL_REQUIRE(n_!=0,
                    "uninitialized TridiagonalOperator");
         QL_REQUIRE(rhs.size()==n_,
@@ -154,12 +153,10 @@ namespace QuantLib {
         return result;
     }
 
-    Disposable<TridiagonalOperator>
-    TridiagonalOperator::identity(Size size) {
-        TridiagonalOperator I(Array(size-1, 0.0),     // lower diagonal
-                              Array(size,   1.0),     // diagonal
-                              Array(size-1, 0.0));    // upper diagonal
-        return I;
+    TridiagonalOperator TridiagonalOperator::identity(Size size) {
+        return TridiagonalOperator(Array(size-1, 0.0),     // lower diagonal
+                                   Array(size,   1.0),     // diagonal
+                                   Array(size-1, 0.0));    // upper diagonal
     }
 
 }
diff --git a/ql/methods/finitedifferences/tridiagonaloperator.hpp b/ql/methods/finitedifferences/tridiagonaloperator.hpp
index 393dc2a0e72..2ee157860e6 100644
--- a/ql/methods/finitedifferences/tridiagonaloperator.hpp
+++ b/ql/methods/finitedifferences/tridiagonaloperator.hpp
@@ -41,26 +41,19 @@ namespace QuantLib {
     */
     class TridiagonalOperator {
         // unary operators
-        friend Disposable<TridiagonalOperator>
-        operator+(const TridiagonalOperator&);
-        friend Disposable<TridiagonalOperator>
-        operator-(const TridiagonalOperator&);
+        friend TridiagonalOperator operator+(const TridiagonalOperator&);
+        friend TridiagonalOperator operator-(const TridiagonalOperator&);
         // binary operators
-        friend Disposable<TridiagonalOperator>
-        operator+(const TridiagonalOperator&,
-                  const TridiagonalOperator&);
-        friend Disposable<TridiagonalOperator>
-        operator-(const TridiagonalOperator&,
-                  const TridiagonalOperator&);
-        friend Disposable<TridiagonalOperator>
-        operator*(Real,
-                  const TridiagonalOperator&);
-        friend Disposable<TridiagonalOperator>
-        operator*(const TridiagonalOperator&,
-                  Real);
-        friend Disposable<TridiagonalOperator>
-        operator/(const TridiagonalOperator&,
-                  Real);
+        friend TridiagonalOperator operator+(const TridiagonalOperator&,
+                                             const TridiagonalOperator&);
+        friend TridiagonalOperator operator-(const TridiagonalOperator&,
+                                             const TridiagonalOperator&);
+        friend TridiagonalOperator operator*(Real,
+                                             const TridiagonalOperator&);
+        friend TridiagonalOperator operator*(const TridiagonalOperator&,
+                                             Real);
+        friend TridiagonalOperator operator/(const TridiagonalOperator&,
+                                             Real);
       public:
         typedef Array array_type;
         // constructors
@@ -70,20 +63,14 @@ namespace QuantLib {
                             const Array& high);
         TridiagonalOperator(const TridiagonalOperator&) = default;
         TridiagonalOperator(TridiagonalOperator&&) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        TridiagonalOperator(const Disposable<TridiagonalOperator>&);
-        #endif
         TridiagonalOperator& operator=(const TridiagonalOperator&);
         TridiagonalOperator& operator=(TridiagonalOperator&&) QL_NOEXCEPT;
-        #ifdef QL_USE_DISPOSABLE
-        TridiagonalOperator& operator=(const Disposable<TridiagonalOperator>&);
-        #endif
         //! \name Operator interface
         //@{
         //! apply operator to a given array
-        Disposable<Array> applyTo(const Array& v) const;
+        Array applyTo(const Array& v) const;
         //! solve linear system for a given right-hand side
-        Disposable<Array> solveFor(const Array& rhs) const;
+        Array solveFor(const Array& rhs) const;
         /*! solve linear system for a given right-hand side
             without result Array allocation. The rhs and result parameters
             can be the same Array, in which case rhs will be changed
@@ -91,10 +78,10 @@ namespace QuantLib {
         void solveFor(const Array& rhs,
                       Array& result) const;
         //! solve linear system with SOR approach
-        Disposable<Array> SOR(const Array& rhs,
-                              Real tol) const;
+        Array SOR(const Array& rhs,
+                  Real tol) const;
         //! identity instance
-        static Disposable<TridiagonalOperator> identity(Size size);
+        static TridiagonalOperator identity(Size size);
         //@}
         //! \name Inspectors
         //@{
@@ -140,13 +127,6 @@ namespace QuantLib {
         swap(from);
     }
 
-    #ifdef QL_USE_DISPOSABLE
-    inline TridiagonalOperator::TridiagonalOperator(
-                                const Disposable<TridiagonalOperator>& from) {
-        swap(const_cast<Disposable<TridiagonalOperator>&>(from));
-    }
-    #endif
-
     inline TridiagonalOperator& TridiagonalOperator::operator=(
                                 const TridiagonalOperator& from) {
         TridiagonalOperator temp(from);
@@ -160,14 +140,6 @@ namespace QuantLib {
         return *this;
     }
 
-    #ifdef QL_USE_DISPOSABLE
-    inline TridiagonalOperator& TridiagonalOperator::operator=(
-                                const Disposable<TridiagonalOperator>& from) {
-        swap(const_cast<Disposable<TridiagonalOperator>&>(from));
-        return *this;
-    }
-    #endif
-
     inline void TridiagonalOperator::setFirstRow(Real valB,
                                                  Real valC) {
         diagonal_[0]      = valB;
@@ -219,14 +191,12 @@ namespace QuantLib {
 
     // Time constant algebra
 
-    inline Disposable<TridiagonalOperator>
-    operator+(const TridiagonalOperator& D) {
+    inline TridiagonalOperator operator+(const TridiagonalOperator& D) {
         TridiagonalOperator D1 = D;
         return D1;
     }
 
-    inline Disposable<TridiagonalOperator>
-    operator-(const TridiagonalOperator& D) {
+    inline TridiagonalOperator operator-(const TridiagonalOperator& D) {
         Array low = -D.lowerDiagonal_,
             mid = -D.diagonal_,
             high = -D.upperDiagonal_;
@@ -234,9 +204,8 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<TridiagonalOperator>
-    operator+(const TridiagonalOperator& D1,
-              const TridiagonalOperator& D2) {
+    inline TridiagonalOperator operator+(const TridiagonalOperator& D1,
+                                         const TridiagonalOperator& D2) {
         Array low = D1.lowerDiagonal_ + D2.lowerDiagonal_,
             mid = D1.diagonal_ + D2.diagonal_,
             high = D1.upperDiagonal_ + D2.upperDiagonal_;
@@ -244,9 +213,8 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<TridiagonalOperator>
-    operator-(const TridiagonalOperator& D1,
-              const TridiagonalOperator& D2) {
+    inline TridiagonalOperator operator-(const TridiagonalOperator& D1,
+                                         const TridiagonalOperator& D2) {
         Array low = D1.lowerDiagonal_ - D2.lowerDiagonal_,
             mid = D1.diagonal_ - D2.diagonal_,
             high = D1.upperDiagonal_ - D2.upperDiagonal_;
@@ -254,9 +222,8 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<TridiagonalOperator>
-    operator*(Real a,
-              const TridiagonalOperator& D) {
+    inline TridiagonalOperator operator*(Real a,
+                                         const TridiagonalOperator& D) {
         Array low = D.lowerDiagonal_ * a,
             mid = D.diagonal_ * a,
             high = D.upperDiagonal_ * a;
@@ -264,9 +231,8 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<TridiagonalOperator>
-    operator*(const TridiagonalOperator& D,
-              Real a) {
+    inline TridiagonalOperator operator*(const TridiagonalOperator& D,
+                                         Real a) {
         Array low = D.lowerDiagonal_ * a,
             mid = D.diagonal_ * a,
             high = D.upperDiagonal_ * a;
@@ -274,9 +240,8 @@ namespace QuantLib {
         return result;
     }
 
-    inline Disposable<TridiagonalOperator>
-    operator/(const TridiagonalOperator& D,
-              Real a) {
+    inline TridiagonalOperator operator/(const TridiagonalOperator& D,
+                                         Real a) {
         Array low = D.lowerDiagonal_ / a,
             mid = D.diagonal_ / a,
             high = D.upperDiagonal_ / a;
diff --git a/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.cpp b/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.cpp
index 4c99b829b07..28a2b5640ad 100644
--- a/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.cpp
+++ b/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.cpp
@@ -27,25 +27,22 @@
 namespace QuantLib {
 
     template <>
-    Disposable<Array> FdmAffineModelSwapInnerValue<HullWhite>::getState(
+    Array FdmAffineModelSwapInnerValue<HullWhite>::getState(
         const ext::shared_ptr<HullWhite>& model, Time t,
         const FdmLinearOpIterator& iter) const {
 
-        Array retVal(1, model->dynamics()->shortRate(t,
-                                    mesher_->location(iter, direction_)));
-        return retVal;
+        return { model->dynamics()->shortRate(t, mesher_->location(iter, direction_)) };
     }
 
     template <>
-    Disposable<Array> FdmAffineModelSwapInnerValue<G2>::getState(
+    Array FdmAffineModelSwapInnerValue<G2>::getState(
         const ext::shared_ptr<G2>&, Time,
         const FdmLinearOpIterator& iter) const {
 
-        Array retVal(2);
-        retVal[0] = mesher_->location(iter, direction_);
-        retVal[1] = mesher_->location(iter, direction_+1);
-
-        return retVal;
+        return {
+            mesher_->location(iter, direction_),
+            mesher_->location(iter, direction_+1)
+        };
     }
 
 }
diff --git a/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp b/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
index f410bccaf6e..5c721a933d5 100644
--- a/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
+++ b/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
@@ -50,10 +50,9 @@ namespace QuantLib {
         Real avgInnerValue(const FdmLinearOpIterator& iter, Time t) override;
 
       private:
-        Disposable<Array> getState(
-            const ext::shared_ptr<ModelType>& model,
-            Time t,
-            const FdmLinearOpIterator& iter) const;
+        Array getState(const ext::shared_ptr<ModelType>& model,
+                       Time t,
+                       const FdmLinearOpIterator& iter) const;
 
         RelinkableHandle<YieldTermStructure> disTs_, fwdTs_;
         const ext::shared_ptr<ModelType> disModel_, fwdModel_;
diff --git a/ql/methods/finitedifferences/utilities/fdmquantohelper.cpp b/ql/methods/finitedifferences/utilities/fdmquantohelper.cpp
index d0edd77db88..a36fd130720 100644
--- a/ql/methods/finitedifferences/utilities/fdmquantohelper.cpp
+++ b/ql/methods/finitedifferences/utilities/fdmquantohelper.cpp
@@ -47,7 +47,7 @@ namespace QuantLib {
         return rDomestic - rForeign + equityVol*fxVol*equityFxCorrelation_;
     }
 
-    Disposable<Array> FdmQuantoHelper::quantoAdjustment(
+    Array FdmQuantoHelper::quantoAdjustment(
         const Array& equityVol, Time t1, Time t2) const {
 
         const Rate rDomestic = rTS_->forwardRate(t1, t2, Continuous).rate();
diff --git a/ql/methods/finitedifferences/utilities/fdmquantohelper.hpp b/ql/methods/finitedifferences/utilities/fdmquantohelper.hpp
index d416539b7a6..db5bfa426c7 100644
--- a/ql/methods/finitedifferences/utilities/fdmquantohelper.hpp
+++ b/ql/methods/finitedifferences/utilities/fdmquantohelper.hpp
@@ -42,7 +42,7 @@ namespace QuantLib {
                       Real exchRateATMlevel);
 
       Rate quantoAdjustment(Volatility equityVol, Time t1, Time t2) const;
-      Disposable<Array> quantoAdjustment(const Array& equityVol, Time t1, Time t2) const;
+      Array quantoAdjustment(const Array& equityVol, Time t1, Time t2) const;
 
       const ext::shared_ptr<YieldTermStructure> rTS_, fTS_;
       const ext::shared_ptr<BlackVolTermStructure> fxVolTS_;
diff --git a/ql/methods/finitedifferences/utilities/fdmtimedepdirichletboundary.cpp b/ql/methods/finitedifferences/utilities/fdmtimedepdirichletboundary.cpp
index eed80df0714..c878e5b750f 100644
--- a/ql/methods/finitedifferences/utilities/fdmtimedepdirichletboundary.cpp
+++ b/ql/methods/finitedifferences/utilities/fdmtimedepdirichletboundary.cpp
@@ -40,7 +40,7 @@ namespace QuantLib {
 
     FdmTimeDepDirichletBoundary::FdmTimeDepDirichletBoundary(
         const ext::shared_ptr<FdmMesher>& mesher,
-        ext::function<Disposable<Array>(Real)> valuesOnBoundary,
+        ext::function<Array(Real)> valuesOnBoundary,
         Size direction,
         Side side)
     : indices_(FdmIndicesOnBoundary(mesher->layout(), direction, side).getIndices()),
diff --git a/ql/methods/finitedifferences/utilities/fdmtimedepdirichletboundary.hpp b/ql/methods/finitedifferences/utilities/fdmtimedepdirichletboundary.hpp
index aadf2883411..b72b4b8a244 100644
--- a/ql/methods/finitedifferences/utilities/fdmtimedepdirichletboundary.hpp
+++ b/ql/methods/finitedifferences/utilities/fdmtimedepdirichletboundary.hpp
@@ -47,7 +47,7 @@ namespace QuantLib {
                                     Side side);
 
         FdmTimeDepDirichletBoundary(const ext::shared_ptr<FdmMesher>& mesher,
-                                    ext::function<Disposable<Array>(Real)> valueOnBoundary,
+                                    ext::function<Array(Real)> valueOnBoundary,
                                     Size direction,
                                     Side side);
 
@@ -60,7 +60,7 @@ namespace QuantLib {
       private:
         const std::vector<Size> indices_;
         const ext::function<Real (Real)> valueOnBoundary_;
-        const ext::function<Disposable<Array>(Real)> valuesOnBoundary_;
+        const ext::function<Array(Real)> valuesOnBoundary_;
 
         Array values_;
     };
diff --git a/ql/methods/finitedifferences/utilities/localvolrndcalculator.cpp b/ql/methods/finitedifferences/utilities/localvolrndcalculator.cpp
index 911a8434070..938072d0787 100644
--- a/ql/methods/finitedifferences/utilities/localvolrndcalculator.cpp
+++ b/ql/methods/finitedifferences/utilities/localvolrndcalculator.cpp
@@ -322,8 +322,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<std::vector<Size> > LocalVolRNDCalculator::rescaleTimeSteps()
-    const {
+    std::vector<Size> LocalVolRNDCalculator::rescaleTimeSteps() const {
         calculate();
 
         return rescaleTimeSteps_;
@@ -340,11 +339,9 @@ namespace QuantLib {
             return (*pFct_[idx])(x);
     }
 
-    Disposable<Array> LocalVolRNDCalculator::rescalePDF(
-        const Array& x, const Array& p) const {
-
-        Array retVal = p/DiscreteSimpsonIntegral()(x, p);
-        return retVal;
+    Array LocalVolRNDCalculator::rescalePDF(const Array& x, const Array& p) const {
+        return p/DiscreteSimpsonIntegral()(x, p);
     }
+
 }
 
diff --git a/ql/methods/finitedifferences/utilities/localvolrndcalculator.hpp b/ql/methods/finitedifferences/utilities/localvolrndcalculator.hpp
index fb3cdaaa9dc..c18a1ac900c 100644
--- a/ql/methods/finitedifferences/utilities/localvolrndcalculator.hpp
+++ b/ql/methods/finitedifferences/utilities/localvolrndcalculator.hpp
@@ -71,14 +71,14 @@ namespace QuantLib {
 
             ext::shared_ptr<TimeGrid> timeGrid() const;
             ext::shared_ptr<Fdm1dMesher> mesher(Time t) const;
-            Disposable<std::vector<Size> > rescaleTimeSteps() const;
+            std::vector<Size> rescaleTimeSteps() const;
 
 	  protected:
             void performCalculations() const override;
 
           private:
 		Real probabilityInterpolation(Size idx, Real x) const;
-		Disposable<Array> rescalePDF(const Array& x, const Array& p) const;
+		Array rescalePDF(const Array& x, const Array& p) const;
 
 
 		const Size xGrid_, tGrid_;
diff --git a/ql/methods/lattices/lattice1d.hpp b/ql/methods/lattices/lattice1d.hpp
index d8f13fb9518..0b2764aac32 100644
--- a/ql/methods/lattices/lattice1d.hpp
+++ b/ql/methods/lattices/lattice1d.hpp
@@ -40,7 +40,7 @@ namespace QuantLib {
       public:
         TreeLattice1D(const TimeGrid& timeGrid, Size n)
         : TreeLattice<Impl>(timeGrid,n) {}
-        Disposable<Array> grid(Time t) const override {
+        Array grid(Time t) const override {
             Size i = this->timeGrid().index(t);
             Array grid(this->impl().size(i));
             for (Size j=0; j<grid.size(); j++)
diff --git a/ql/methods/lattices/lattice2d.hpp b/ql/methods/lattices/lattice2d.hpp
index 97146c5ab03..d406c2201a5 100644
--- a/ql/methods/lattices/lattice2d.hpp
+++ b/ql/methods/lattices/lattice2d.hpp
@@ -49,7 +49,7 @@ namespace QuantLib {
       protected:
         ext::shared_ptr<T> tree1_, tree2_;
         // smelly
-        Disposable<Array> grid(Time) const override { QL_FAIL("not implemented"); }
+        Array grid(Time) const override { QL_FAIL("not implemented"); }
 
       private:
         Matrix m_;
diff --git a/ql/methods/montecarlo/parametricexercise.cpp b/ql/methods/montecarlo/parametricexercise.cpp
index a960998fabd..4cde6beb619 100644
--- a/ql/methods/montecarlo/parametricexercise.cpp
+++ b/ql/methods/montecarlo/parametricexercise.cpp
@@ -31,7 +31,7 @@ namespace QuantLib {
                           const ParametricExercise& exercise,
                           Size exerciseIndex);
             Real value(const Array& parameters) const override;
-            Disposable<Array> values(const Array&) const override {
+            Array values(const Array&) const override {
                 QL_FAIL("values method not implemented");
             }
 
diff --git a/ql/models/marketmodels/correlations/expcorrelations.cpp b/ql/models/marketmodels/correlations/expcorrelations.cpp
index 71a9e92b6cc..6e251bc0976 100644
--- a/ql/models/marketmodels/correlations/expcorrelations.cpp
+++ b/ql/models/marketmodels/correlations/expcorrelations.cpp
@@ -29,12 +29,11 @@
 
 namespace QuantLib {
 
-    Disposable<Matrix> exponentialCorrelations(
-                                        const std::vector<Time>& rateTimes,
-                                        Real longTermCorr,
-                                        Real beta,
-                                        Real gamma,
-                                        Time time) {
+    Matrix exponentialCorrelations(const std::vector<Time>& rateTimes,
+                                   Real longTermCorr,
+                                   Real beta,
+                                   Real gamma,
+                                   Time time) {
         // preliminary checks
         checkIncreasingTimes(rateTimes);
         QL_REQUIRE(longTermCorr<=1.0 && longTermCorr>=0.0,
diff --git a/ql/models/marketmodels/correlations/expcorrelations.hpp b/ql/models/marketmodels/correlations/expcorrelations.hpp
index 599a1fa498d..4d50b6058a9 100644
--- a/ql/models/marketmodels/correlations/expcorrelations.hpp
+++ b/ql/models/marketmodels/correlations/expcorrelations.hpp
@@ -28,7 +28,6 @@
 #define quantlib_exp_correlations_hpp
 
 #include <ql/math/matrix.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <ql/models/marketmodels/piecewiseconstantcorrelation.hpp>
 
 namespace QuantLib {
@@ -39,12 +38,11 @@ namespace QuantLib {
         gamma = exponent for time to go
         t = time dependence
     */
-    Disposable<Matrix> exponentialCorrelations(
-                                    const std::vector<Time>& rateTimes,
-                                    Real longTermCorr = 0.5,
-                                    Real beta = 0.2,
-                                    Real gamma = 1.0,
-                                    Time t = 0.0);
+    Matrix exponentialCorrelations(const std::vector<Time>& rateTimes,
+                                   Real longTermCorr = 0.5,
+                                   Real beta = 0.2,
+                                   Real gamma = 1.0,
+                                   Time t = 0.0);
 
     class ExponentialForwardCorrelation :
         public PiecewiseConstantCorrelation {
diff --git a/ql/models/marketmodels/driftcomputation/cmsmmdriftcalculator.cpp b/ql/models/marketmodels/driftcomputation/cmsmmdriftcalculator.cpp
index 8750ebf6ddd..1d907f6c13a 100644
--- a/ql/models/marketmodels/driftcomputation/cmsmmdriftcalculator.cpp
+++ b/ql/models/marketmodels/driftcomputation/cmsmmdriftcalculator.cpp
@@ -61,7 +61,7 @@ namespace QuantLib {
             oneOverTaus_[i] = 1.0/taus[i];
 
         // Compute covariance matrix from pseudoroot
-        const Disposable<Matrix> pT = transpose(pseudo_);
+        Matrix pT = transpose(pseudo_);
         C_ = pseudo_*pT;
 
         // Compute lower and upper extrema for (non reduced) drift calculation
diff --git a/ql/models/marketmodels/driftcomputation/lmmdriftcalculator.cpp b/ql/models/marketmodels/driftcomputation/lmmdriftcalculator.cpp
index 3dfb7b362ce..f7eff4515f0 100644
--- a/ql/models/marketmodels/driftcomputation/lmmdriftcalculator.cpp
+++ b/ql/models/marketmodels/driftcomputation/lmmdriftcalculator.cpp
@@ -54,7 +54,7 @@ namespace QuantLib {
             oneOverTaus_[i] = 1.0/taus[i];
 
         // Compute covariance matrix from pseudoroot
-        const Disposable<Matrix> pT = transpose(pseudo_);
+        Matrix pT = transpose(pseudo_);
         C_ = pseudo_*pT;
 
         // Compute lower and upper extrema for (non reduced) drift calculation
diff --git a/ql/models/marketmodels/driftcomputation/lmmnormaldriftcalculator.cpp b/ql/models/marketmodels/driftcomputation/lmmnormaldriftcalculator.cpp
index f97c28b5c37..1f5e87656a2 100644
--- a/ql/models/marketmodels/driftcomputation/lmmnormaldriftcalculator.cpp
+++ b/ql/models/marketmodels/driftcomputation/lmmnormaldriftcalculator.cpp
@@ -46,7 +46,7 @@ namespace QuantLib {
             oneOverTaus_[i] = 1.0/taus[i];
 
         // Compute covariance matrix from pseudoroot
-        const Disposable<Matrix> pT = transpose(pseudo_);
+        Matrix pT = transpose(pseudo_);
         C_ = pseudo_*pT;
 
         // Compute lower and upper extrema for (non reduced) drift calculation
diff --git a/ql/models/marketmodels/driftcomputation/smmdriftcalculator.cpp b/ql/models/marketmodels/driftcomputation/smmdriftcalculator.cpp
index 3bbd6bac9d9..753567c4068 100644
--- a/ql/models/marketmodels/driftcomputation/smmdriftcalculator.cpp
+++ b/ql/models/marketmodels/driftcomputation/smmdriftcalculator.cpp
@@ -58,7 +58,7 @@ namespace QuantLib {
             oneOverTaus_[i] = 1.0/taus[i];
 
         // Compute covariance matrix from pseudoroot
-        const Disposable<Matrix> pT = transpose(pseudo_);
+        Matrix pT = transpose(pseudo_);
         C_ = pseudo_*pT;
 
         // Compute lower and upper extrema for (non reduced) drift calculation
diff --git a/ql/models/marketmodels/forwardforwardmappings.cpp b/ql/models/marketmodels/forwardforwardmappings.cpp
index 182d727c8c3..9669b6e5eab 100644
--- a/ql/models/marketmodels/forwardforwardmappings.cpp
+++ b/ql/models/marketmodels/forwardforwardmappings.cpp
@@ -25,11 +25,9 @@ FOR A PARTICULAR PURPOSE.  See the license for more details.
 
 namespace QuantLib {
 
-    Disposable<Matrix>
-        ForwardForwardMappings::ForwardForwardJacobian(const CurveState& cs,
-        Size multiplier,
-        Size offset)
-        {
+    Matrix ForwardForwardMappings::ForwardForwardJacobian(const CurveState& cs,
+                                                          Size multiplier,
+                                                          Size offset) {
 
         Size n = cs.numberOfRates();
 
@@ -58,16 +56,13 @@ namespace QuantLib {
             }
 
         return jacobian;
-        }
-
-    Disposable<Matrix>
-        ForwardForwardMappings::YMatrix(const CurveState& cs,
-        const std::vector<Spread>& shortDisplacements,
-        const std::vector<Spread>& longDisplacements,
-        Size multiplier,
-        Size offset
-        )
-        {
+    }
+
+    Matrix ForwardForwardMappings::YMatrix(const CurveState& cs,
+                                           const std::vector<Spread>& shortDisplacements,
+                                           const std::vector<Spread>& longDisplacements,
+                                           Size multiplier,
+                                           Size offset) {
         Size n = cs.numberOfRates();
 
         QL_REQUIRE(offset < multiplier, "offset  must be less than period in"
@@ -101,15 +96,11 @@ namespace QuantLib {
             }
 
         return jacobian;
+    }
 
-        }
-
-    LMMCurveState
-        ForwardForwardMappings::RestrictCurveState(const CurveState& cs,
-                                 Size multiplier,
-                                 Size offset
-                                )
-        {
+    LMMCurveState ForwardForwardMappings::RestrictCurveState(const CurveState& cs,
+                                                             Size multiplier,
+                                                             Size offset) {
            Size n = cs.numberOfRates();
 
            QL_REQUIRE(offset < multiplier, "offset  must be less than period in"
@@ -130,5 +121,5 @@ namespace QuantLib {
            newState.setOnDiscountRatios(discRatios);
            return newState;
 
-        }
+    }
 }
diff --git a/ql/models/marketmodels/forwardforwardmappings.hpp b/ql/models/marketmodels/forwardforwardmappings.hpp
index d6bcb9da16c..70f9301bf75 100644
--- a/ql/models/marketmodels/forwardforwardmappings.hpp
+++ b/ql/models/marketmodels/forwardforwardmappings.hpp
@@ -35,31 +35,26 @@ namespace QuantLib {
         {
             /*! Returns the dg[i]/df[j] jacobian between
             forward rates with tenor multipler and forward rates with tenor 1*/
-            Disposable<Matrix>
-                ForwardForwardJacobian(const CurveState& cs, 
-                                       Size multiplier,
-                                       Size offset);
+            Matrix ForwardForwardJacobian(const CurveState& cs, 
+                                          Size multiplier,
+                                          Size offset);
 
             /*! Returns the Y matrix to switch base          
             forward rates with tenor multipler and forward rates with tenor 1*/
 
-            Disposable<Matrix>
-                YMatrix(const CurveState& cs,
-                const std::vector<Spread>& shortDisplacements,
-                const std::vector<Spread>& longDisplacements,
-                Size Multiplier,
-                Size offset
-                );
+            Matrix YMatrix(const CurveState& cs,
+                           const std::vector<Spread>& shortDisplacements,
+                           const std::vector<Spread>& longDisplacements,
+                           Size Multiplier,
+                           Size offset);
 
             /*! 
             replaces curve state with curve state based on periodic subset of times
 
             */
-            LMMCurveState
-                RestrictCurveState(const CurveState& cs,
-                                 Size multiplier,
-                                 Size offSet
-                                );
+            LMMCurveState RestrictCurveState(const CurveState& cs,
+                                             Size multiplier,
+                                             Size offSet);
 
         }
 
diff --git a/ql/models/marketmodels/swapforwardmappings.cpp b/ql/models/marketmodels/swapforwardmappings.cpp
index d5fabd9f327..63019732810 100644
--- a/ql/models/marketmodels/swapforwardmappings.cpp
+++ b/ql/models/marketmodels/swapforwardmappings.cpp
@@ -69,8 +69,7 @@ namespace QuantLib {
         return part1-part2;
     }
 
-    Disposable<Matrix>
-    SwapForwardMappings::coterminalSwapForwardJacobian(const CurveState& cs)
+    Matrix SwapForwardMappings::coterminalSwapForwardJacobian(const CurveState& cs)
     {
         Size n = cs.numberOfRates();
         const std::vector<Rate>& f = cs.forwardRates();
@@ -100,9 +99,8 @@ namespace QuantLib {
         return jacobian;
     }
 
-    Disposable<Matrix>
-    SwapForwardMappings::coterminalSwapZedMatrix(const CurveState& cs,
-                                                 const Spread displacement) {
+    Matrix SwapForwardMappings::coterminalSwapZedMatrix(const CurveState& cs,
+                                                        const Spread displacement) {
             Size n = cs.numberOfRates();
             Matrix zMatrix = coterminalSwapForwardJacobian(cs);
             const std::vector<Rate>& f = cs.forwardRates();
@@ -114,8 +112,7 @@ namespace QuantLib {
     }
 
 
-    Disposable<Matrix>
-    SwapForwardMappings::coinitialSwapForwardJacobian(const CurveState& cs)
+    Matrix SwapForwardMappings::coinitialSwapForwardJacobian(const CurveState& cs)
     {
         Size n = cs.numberOfRates();
 
@@ -127,9 +124,8 @@ namespace QuantLib {
         return jacobian;
     }
 
-    Disposable<Matrix>
-    SwapForwardMappings::cmSwapForwardJacobian(const CurveState& cs,
-                                               const Size spanningForwards)
+    Matrix SwapForwardMappings::cmSwapForwardJacobian(const CurveState& cs,
+                                                      const Size spanningForwards)
     {
         Size n = cs.numberOfRates();
 
@@ -141,9 +137,8 @@ namespace QuantLib {
         return jacobian;
     }
 
-    Disposable<Matrix>
-    SwapForwardMappings::coinitialSwapZedMatrix(const CurveState& cs,
-                                                const Spread displacement)
+    Matrix SwapForwardMappings::coinitialSwapZedMatrix(const CurveState& cs,
+                                                       const Spread displacement)
     {
         Size n = cs.numberOfRates();
         Matrix zMatrix = coinitialSwapForwardJacobian(cs);
@@ -159,10 +154,9 @@ namespace QuantLib {
         return zMatrix;
     }
 
-    Disposable<Matrix>
-    SwapForwardMappings::cmSwapZedMatrix(const CurveState& cs,
-                                         const Size spanningForwards,
-                                         const Spread displacement)
+    Matrix SwapForwardMappings::cmSwapZedMatrix(const CurveState& cs,
+                                                const Size spanningForwards,
+                                                const Spread displacement)
     {
         Size n = cs.numberOfRates();
         Matrix zMatrix = cmSwapForwardJacobian(cs,spanningForwards);
@@ -178,11 +172,10 @@ namespace QuantLib {
         return zMatrix;
     }
 
-      Real 
-      SwapForwardMappings::swaptionImpliedVolatility(const MarketModel& volStructure,
-                                  Size startIndex,
-                                  Size endIndex)
-      {
+    Real SwapForwardMappings::swaptionImpliedVolatility(const MarketModel& volStructure,
+                                                        Size startIndex,
+                                                        Size endIndex)
+    {
           QL_REQUIRE(startIndex < endIndex, "start index must be before end index in swaptionImpliedVolatility");
 
           LMMCurveState cs(volStructure.evolution().rateTimes());
@@ -223,6 +216,6 @@ namespace QuantLib {
           Real expiry = evolution.rateTimes()[startIndex];
           return std::sqrt(variance/expiry);
 
-      }
+    }
 
 }
diff --git a/ql/models/marketmodels/swapforwardmappings.hpp b/ql/models/marketmodels/swapforwardmappings.hpp
index 55c298c3067..e201a515900 100644
--- a/ql/models/marketmodels/swapforwardmappings.hpp
+++ b/ql/models/marketmodels/swapforwardmappings.hpp
@@ -49,33 +49,29 @@ namespace QuantLib {
 
         /*! Returns the dsr[i]/df[j] jacobian between
             coterminal swap rates and forward rates */
-        static Disposable<Matrix>
-        coterminalSwapForwardJacobian(const CurveState& cs);
+        static Matrix coterminalSwapForwardJacobian(const CurveState& cs);
 
         /*! Returns the Z matrix to switch base from forward to
             coterminal swap rates */
-        static Disposable<Matrix> coterminalSwapZedMatrix(const CurveState& cs,
-                                                          Spread displacement);
+        static Matrix coterminalSwapZedMatrix(const CurveState& cs, Spread displacement);
 
         /*! Returns the dsr[i]/df[j] jacobian between
             coinitial swap rates and forward rates */
-        static Disposable<Matrix>
-        coinitialSwapForwardJacobian(const CurveState& cs);
+        static Matrix coinitialSwapForwardJacobian(const CurveState& cs);
 
         /*! Returns the Z matrix to switch base from forward to
             coinitial swap rates */
-        static Disposable<Matrix> coinitialSwapZedMatrix(const CurveState& cs, Spread displacement);
+        static Matrix coinitialSwapZedMatrix(const CurveState& cs, Spread displacement);
 
 
         /*! Returns the dsr[i]/df[j] jacobian between
             constant maturity swap rates and forward rates */
-        static Disposable<Matrix> cmSwapForwardJacobian(const CurveState& cs,
-                                                        Size spanningForwards);
+        static Matrix cmSwapForwardJacobian(const CurveState& cs,
+                                            Size spanningForwards);
 
         /*! Returns the Z matrix to switch base from forward to
             constant maturity swap rates */
-        static Disposable<Matrix>
-        cmSwapZedMatrix(const CurveState& cs, Size spanningForwards, Spread displacement);
+        static Matrix cmSwapZedMatrix(const CurveState& cs, Size spanningForwards, Spread displacement);
 
         /*! computes the implied vol of a swaption specified by two indices
         using the freezing coefficients methdodology. This routine is easy to use but not very efficient
diff --git a/ql/models/model.cpp b/ql/models/model.cpp
index 170698f283d..f8e7ab4564f 100644
--- a/ql/models/model.cpp
+++ b/ql/models/model.cpp
@@ -55,7 +55,7 @@ namespace QuantLib {
             return std::sqrt(value);
         }
 
-        Disposable<Array> values(const Array& params) const override {
+        Array values(const Array& params) const override {
             model_->setParams(projection_.include(params));
             Array values(instruments_.size());
             for (Size i=0; i<instruments_.size(); i++) {
@@ -125,7 +125,7 @@ namespace QuantLib {
         return f.value(params);
     }
 
-    Disposable<Array> CalibratedModel::params() const {
+    Array CalibratedModel::params() const {
         Size size=0;
         for (const auto& argument : arguments_)
             size += argument.size();
diff --git a/ql/models/model.hpp b/ql/models/model.hpp
index cce17feb508..34c94326289 100644
--- a/ql/models/model.hpp
+++ b/ql/models/model.hpp
@@ -116,7 +116,7 @@ namespace QuantLib {
         const Array& problemValues() const { return problemValues_; }
 
         //! Returns array of arguments on which calibration is done
-        Disposable<Array> params() const;
+        Array params() const;
 
         virtual void setParams(const Array& params);
         Integer functionEvaluation() const { return functionEvaluation_; }
diff --git a/ql/models/shortrate/onefactormodels/gaussian1dmodel.cpp b/ql/models/shortrate/onefactormodels/gaussian1dmodel.cpp
index d4665a0ee11..1f9bf32ed97 100644
--- a/ql/models/shortrate/onefactormodels/gaussian1dmodel.cpp
+++ b/ql/models/shortrate/onefactormodels/gaussian1dmodel.cpp
@@ -247,7 +247,7 @@ Real Gaussian1dModel::gaussianShiftedPolynomialIntegral(
         a * h * h * h * h - b * h * h * h + c * h * h - d * h + e, x0, x1);
 }
 
-Disposable<Array> Gaussian1dModel::yGrid(
+Array Gaussian1dModel::yGrid(
     const Real stdDevs, const int gridPoints, const Real T, const Real t, const Real y) const {
 
     // we use that the standard deviation is independent of $x$ here !
diff --git a/ql/models/shortrate/onefactormodels/gaussian1dmodel.hpp b/ql/models/shortrate/onefactormodels/gaussian1dmodel.hpp
index 8b5ffb5e0ed..4f04a2d54bc 100644
--- a/ql/models/shortrate/onefactormodels/gaussian1dmodel.hpp
+++ b/ql/models/shortrate/onefactormodels/gaussian1dmodel.hpp
@@ -150,8 +150,7 @@ class Gaussian1dModel : public TermStructureConsistentModel, public LazyObject {
        consisting of
         2*gridPoints+1 points */
 
-    Disposable<Array>
-    yGrid(Real yStdDevs, int gridPoints, Real T = 1.0, Real t = 0, Real y = 0) const;
+    Array yGrid(Real yStdDevs, int gridPoints, Real T = 1.0, Real t = 0, Real y = 0) const;
 
   private:
     // It is of great importance for performance reasons to cache underlying
diff --git a/ql/models/shortrate/onefactormodels/gsr.hpp b/ql/models/shortrate/onefactormodels/gsr.hpp
index 16553ca3d84..c4d7df90709 100644
--- a/ql/models/shortrate/onefactormodels/gsr.hpp
+++ b/ql/models/shortrate/onefactormodels/gsr.hpp
@@ -68,7 +68,7 @@ class Gsr : public Gaussian1dModel, public CalibratedModel {
     // calibration constraints
 
     // fixed reversions, only volatilities are free
-    Disposable<std::vector<bool> > FixedReversions() {
+    std::vector<bool> FixedReversions() {
         std::vector<bool> res(reversions_.size(), true);
         std::vector<bool> vol(volatilities_.size(), false);
         res.insert(res.end(), vol.begin(), vol.end());
@@ -76,14 +76,14 @@ class Gsr : public Gaussian1dModel, public CalibratedModel {
     }
 
     // fixed volatilities, only reversions are free
-    Disposable<std::vector<bool> > FixedVolatilities() {
+    std::vector<bool> FixedVolatilities() {
         std::vector<bool> res(reversions_.size(), false);
         std::vector<bool> vol(volatilities_.size(), true);
         res.insert(res.end(), vol.begin(), vol.end());
         return res;
     }
 
-    Disposable<std::vector<bool> > MoveVolatility(Size i) {
+    std::vector<bool> MoveVolatility(Size i) {
         QL_REQUIRE(i < volatilities_.size(),
                    "volatility with index " << i << " does not exist (0..."
                                             << volatilities_.size() - 1 << ")");
@@ -92,7 +92,7 @@ class Gsr : public Gaussian1dModel, public CalibratedModel {
         return res;
     }
 
-    Disposable<std::vector<bool> > MoveReversion(Size i) {
+    std::vector<bool> MoveReversion(Size i) {
         QL_REQUIRE(i < reversions_.size(),
                    "reversion with index " << i << " does not exist (0..."
                                            << reversions_.size() - 1 << ")");
diff --git a/ql/models/shortrate/onefactormodels/markovfunctional.cpp b/ql/models/shortrate/onefactormodels/markovfunctional.cpp
index 76a1f0feb1f..82c03973046 100644
--- a/ql/models/shortrate/onefactormodels/markovfunctional.cpp
+++ b/ql/models/shortrate/onefactormodels/markovfunctional.cpp
@@ -713,7 +713,7 @@ namespace QuantLib {
         return modelOutputs_;
     }
 
-    Disposable<Array> MarkovFunctional::numeraireArray(const Time t, const Array& y) const {
+    Array MarkovFunctional::numeraireArray(const Time t, const Array& y) const {
 
         calculate();
         Array res(y.size(), termStructure()->discount(numeraireTime_, true));
@@ -752,14 +752,12 @@ namespace QuantLib {
         return res;
     }
 
-    Disposable<Array>
-    MarkovFunctional::zerobondArray(const Time T, const Time t, const Array& y) const {
+    Array MarkovFunctional::zerobondArray(const Time T, const Time t, const Array& y) const {
 
         return deflatedZerobondArray(T, t, y) * numeraireArray(t, y);
     }
 
-    Disposable<Array>
-    MarkovFunctional::deflatedZerobondArray(const Time T, const Time t, const Array& y) const {
+    Array MarkovFunctional::deflatedZerobondArray(const Time T, const Time t, const Array& y) const {
 
         calculate();
 
diff --git a/ql/models/shortrate/onefactormodels/markovfunctional.hpp b/ql/models/shortrate/onefactormodels/markovfunctional.hpp
index 239d974b42e..cfa3d667a31 100644
--- a/ql/models/shortrate/onefactormodels/markovfunctional.hpp
+++ b/ql/models/shortrate/onefactormodels/markovfunctional.hpp
@@ -395,7 +395,7 @@ namespace QuantLib {
             updateNumeraireTabulation();
         }
 
-        Disposable<std::vector<bool> > FixedFirstVolatility() const {
+        std::vector<bool> FixedFirstVolatility() const {
             std::vector<bool> c(volatilities_.size(), false);
             c[0] = true;
             return c;
@@ -425,9 +425,9 @@ namespace QuantLib {
                                 const Option::Type& type,
                                 Real strike) const;
 
-        Disposable<Array> deflatedZerobondArray(Time T, Time t, const Array& y) const;
-        Disposable<Array> numeraireArray(Time t, const Array& y) const;
-        Disposable<Array> zerobondArray(Time T, Time t, const Array& y) const;
+        Array deflatedZerobondArray(Time T, Time t, const Array& y) const;
+        Array numeraireArray(Time t, const Array& y) const;
+        Array zerobondArray(Time T, Time t, const Array& y) const;
 
         Real deflatedZerobond(Time T, Time t = 0.0, Real y = 0.0) const;
 
diff --git a/ql/models/volatility/garch.cpp b/ql/models/volatility/garch.cpp
index 511863013e0..0a5c04606ef 100644
--- a/ql/models/volatility/garch.cpp
+++ b/ql/models/volatility/garch.cpp
@@ -57,7 +57,7 @@ namespace QuantLib {
           public:
             explicit Garch11CostFunction (const std::vector<Volatility> &);
             Real value(const Array& x) const override;
-            Disposable<Array> values(const Array& x) const override;
+            Array values(const Array& x) const override;
             void gradient(Array& grad, const Array& x) const override;
             Real valueAndGradient(Array& grad, const Array& x) const override;
 
@@ -81,7 +81,7 @@ namespace QuantLib {
             return retval / (2.0*r2_.size());
         }
 
-        Disposable<Array> Garch11CostFunction::values(const Array& x) const {
+        Array Garch11CostFunction::values(const Array& x) const {
             Array retval (r2_.size());
             Real sigma2 = 0;
             Real u2 = 0;
diff --git a/ql/numericalmethod.hpp b/ql/numericalmethod.hpp
index fdd5beb99f1..c4c4d61ad9e 100644
--- a/ql/numericalmethod.hpp
+++ b/ql/numericalmethod.hpp
@@ -90,7 +90,7 @@ namespace QuantLib {
         //@}
 
         // this is a smell, but we need it. We'll rethink it later.
-        virtual Disposable<Array> grid(Time) const = 0;
+        virtual Array grid(Time) const = 0;
       protected:
         TimeGrid t_;
     };
diff --git a/ql/pricingengines/bond/discretizedconvertible.cpp b/ql/pricingengines/bond/discretizedconvertible.cpp
index 0661ea52a6c..6643710a80c 100644
--- a/ql/pricingengines/bond/discretizedconvertible.cpp
+++ b/ql/pricingengines/bond/discretizedconvertible.cpp
@@ -227,7 +227,7 @@ namespace QuantLib {
         values_ += couponAmounts_[i];
     }
 
-    Disposable<Array> DiscretizedConvertible::adjustedGrid() const {
+    Array DiscretizedConvertible::adjustedGrid() const {
         Time t = time();
         Array grid = method()->grid(t);
         // add back all dividend amounts in the future
diff --git a/ql/pricingengines/bond/discretizedconvertible.hpp b/ql/pricingengines/bond/discretizedconvertible.hpp
index 0054f905798..abb0cebc8cf 100644
--- a/ql/pricingengines/bond/discretizedconvertible.hpp
+++ b/ql/pricingengines/bond/discretizedconvertible.hpp
@@ -68,7 +68,7 @@ namespace QuantLib {
         Array conversionProbability_, spreadAdjustedRate_, dividendValues_;
 
       private:
-        Disposable<Array> adjustedGrid() const;
+        Array adjustedGrid() const;
         void applyConvertibility();
         void applyCallability(Size, bool convertible);
         void addCoupon(Size);
diff --git a/ql/pricingengines/swaption/basketgeneratingengine.cpp b/ql/pricingengines/swaption/basketgeneratingengine.cpp
index dfc3aaf6d61..25b75f0c857 100644
--- a/ql/pricingengines/swaption/basketgeneratingengine.cpp
+++ b/ql/pricingengines/swaption/basketgeneratingengine.cpp
@@ -31,7 +31,7 @@ using std::fabs;
 
 namespace QuantLib {
 
-    Disposable<std::vector<ext::shared_ptr<BlackCalibrationHelper> > >
+    std::vector<ext::shared_ptr<BlackCalibrationHelper>>
     BasketGeneratingEngine::calibrationBasket(
         const ext::shared_ptr<Exercise>& exercise,
         const ext::shared_ptr<SwapIndex>& standardSwapBase,
diff --git a/ql/pricingengines/swaption/basketgeneratingengine.hpp b/ql/pricingengines/swaption/basketgeneratingengine.hpp
index b334dafdf23..549ef9d6141 100644
--- a/ql/pricingengines/swaption/basketgeneratingengine.hpp
+++ b/ql/pricingengines/swaption/basketgeneratingengine.hpp
@@ -63,7 +63,7 @@ namespace QuantLib {
             MaturityStrikeByDeltaGamma
         } CalibrationBasketType;
 
-        Disposable<std::vector<ext::shared_ptr<BlackCalibrationHelper> > >
+        std::vector<ext::shared_ptr<BlackCalibrationHelper>>
         calibrationBasket(const ext::shared_ptr<Exercise>& exercise,
                           const ext::shared_ptr<SwapIndex>& standardSwapBase,
                           const ext::shared_ptr<SwaptionVolatilityStructure>& swaptionVolatility,
@@ -89,9 +89,8 @@ namespace QuantLib {
 
         virtual const Date underlyingLastDate() const = 0;
 
-        virtual const Disposable<Array>
-        initialGuess(const Date &expiry) const = 0; // return (nominal,
-                                                    // maturity, rate)
+        virtual const Array initialGuess(const Date &expiry) const = 0; // return (nominal,
+                                                                        // maturity, rate)
 
       private:
 
@@ -151,7 +150,7 @@ namespace QuantLib {
                 return std::sqrt(res / vals.size());
             }
 
-            Disposable<Array> values(const Array& v) const override {
+            Array values(const Array& v) const override {
                 // transformations
                 int type = type_; // start with same type as non standard
                                   // underlying (1 means payer, -1 receiver)
diff --git a/ql/pricingengines/swaption/gaussian1dfloatfloatswaptionengine.cpp b/ql/pricingengines/swaption/gaussian1dfloatfloatswaptionengine.cpp
index 98549e83238..5863854f970 100644
--- a/ql/pricingengines/swaption/gaussian1dfloatfloatswaptionengine.cpp
+++ b/ql/pricingengines/swaption/gaussian1dfloatfloatswaptionengine.cpp
@@ -69,7 +69,7 @@ namespace QuantLib {
     }
 
     // NOLINTNEXTLINE(readability-const-return-type)
-    const Disposable<Array> Gaussian1dFloatFloatSwaptionEngine::initialGuess(const Date &expiry) const {
+    const Array Gaussian1dFloatFloatSwaptionEngine::initialGuess(const Date &expiry) const {
 
         Size idx1 =
             std::upper_bound(arguments_.leg1ResetDates.begin(),
@@ -79,7 +79,6 @@ namespace QuantLib {
         // very simple initial guess
         // check guess for nominal and weighted maturity !
 
-        Array initial(3);
         Real nominalSum1 = 0.0;
         for (Size i = idx1; i < arguments_.leg1ResetDates.size(); i++) {
             nominalSum1 += arguments_.nominal1[i];
@@ -93,11 +92,11 @@ namespace QuantLib {
         }
         weightedMaturity1 /= nominalAvg1;
 
-        initial[0] = nominalAvg1;
-        initial[1] = weightedMaturity1;
-        initial[2] = 0.03; // ???
-
-        return initial;
+        return {
+            nominalAvg1,
+            weightedMaturity1,
+            0.03 // ???
+        };
     }
 
     // calculate npv and underlying npv as of expiry date
diff --git a/ql/pricingengines/swaption/gaussian1dfloatfloatswaptionengine.hpp b/ql/pricingengines/swaption/gaussian1dfloatfloatswaptionengine.hpp
index 3a8a1d3e25f..00749a4ba95 100644
--- a/ql/pricingengines/swaption/gaussian1dfloatfloatswaptionengine.hpp
+++ b/ql/pricingengines/swaption/gaussian1dfloatfloatswaptionengine.hpp
@@ -133,7 +133,7 @@ namespace QuantLib {
         Real underlyingNpv(const Date& expiry, Real y) const override;
         Swap::Type underlyingType() const override;
         const Date underlyingLastDate() const override;
-        const Disposable<Array> initialGuess(const Date& expiry) const override;
+        const Array initialGuess(const Date& expiry) const override;
 
       private:
         const int integrationPoints_;
diff --git a/ql/pricingengines/swaption/gaussian1dnonstandardswaptionengine.cpp b/ql/pricingengines/swaption/gaussian1dnonstandardswaptionengine.cpp
index a1e452824bc..e22e825bb28 100644
--- a/ql/pricingengines/swaption/gaussian1dnonstandardswaptionengine.cpp
+++ b/ql/pricingengines/swaption/gaussian1dnonstandardswaptionengine.cpp
@@ -19,7 +19,6 @@
 
 #include <ql/pricingengines/swaption/gaussian1dnonstandardswaptionengine.hpp>
 #include <ql/rebatedexercise.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <ql/time/daycounters/actualactual.hpp>
 #include <ql/quotes/simplequote.hpp>
 #include <ql/math/interpolations/cubicinterpolation.hpp>
@@ -98,7 +97,7 @@ namespace QuantLib {
     }
 
     // NOLINTNEXTLINE(readability-const-return-type)
-    const Disposable<Array> Gaussian1dNonstandardSwaptionEngine::initialGuess(const Date &expiry) const {
+    const Array Gaussian1dNonstandardSwaptionEngine::initialGuess(const Date &expiry) const {
 
         Size fixedIdx =
             std::upper_bound(arguments_.fixedResetDates.begin(),
diff --git a/ql/pricingengines/swaption/gaussian1dnonstandardswaptionengine.hpp b/ql/pricingengines/swaption/gaussian1dnonstandardswaptionengine.hpp
index 22164ad4e5e..31ee2bcdabf 100644
--- a/ql/pricingengines/swaption/gaussian1dnonstandardswaptionengine.hpp
+++ b/ql/pricingengines/swaption/gaussian1dnonstandardswaptionengine.hpp
@@ -124,7 +124,7 @@ namespace QuantLib {
         Real underlyingNpv(const Date& expiry, Real y) const override;
         Swap::Type underlyingType() const override;
         const Date underlyingLastDate() const override;
-        const Disposable<Array> initialGuess(const Date& expiry) const override;
+        const Array initialGuess(const Date& expiry) const override;
 
       private:
         const int integrationPoints_;
diff --git a/ql/processes/batesprocess.cpp b/ql/processes/batesprocess.cpp
index bd8a1a8e1ab..1c3d5fd4463 100644
--- a/ql/processes/batesprocess.cpp
+++ b/ql/processes/batesprocess.cpp
@@ -37,14 +37,14 @@ namespace QuantLib {
       m_(std::exp(nu+0.5*delta*delta)-1) {
     }
 
-    Disposable<Array> BatesProcess::drift(Time t, const Array& x) const {
+    Array BatesProcess::drift(Time t, const Array& x) const {
         Array retVal = HestonProcess::drift(t, x);
         retVal[0] -= lambda_*m_;
         return retVal;
     }
 
-    Disposable<Array> BatesProcess::evolve(Time t0, const Array& x0,
-                                           Time dt, const Array& dw) const {
+    Array BatesProcess::evolve(Time t0, const Array& x0,
+                               Time dt, const Array& dw) const {
 
         const Size hestonFactors = HestonProcess::factors();
 
diff --git a/ql/processes/batesprocess.hpp b/ql/processes/batesprocess.hpp
index e33dae353ee..ed30aacc970 100644
--- a/ql/processes/batesprocess.hpp
+++ b/ql/processes/batesprocess.hpp
@@ -58,8 +58,8 @@ namespace QuantLib {
                          = HestonProcess::FullTruncation);
 
         Size factors() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array drift(Time t, const Array& x) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
         Real lambda() const;
         Real nu()     const;
diff --git a/ql/processes/endeulerdiscretization.cpp b/ql/processes/endeulerdiscretization.cpp
index fc33a65de6e..0193b1e506b 100644
--- a/ql/processes/endeulerdiscretization.cpp
+++ b/ql/processes/endeulerdiscretization.cpp
@@ -21,10 +21,9 @@
 
 namespace QuantLib {
 
-    Disposable<Array> EndEulerDiscretization::drift(
-                                      const StochasticProcess& process,
-                                      Time t0, const Array& x0,
-                                      Time dt) const {
+    Array EndEulerDiscretization::drift(const StochasticProcess& process,
+                                        Time t0, const Array& x0,
+                                        Time dt) const {
         return process.drift(t0+dt, x0)*dt;
     }
 
@@ -33,10 +32,10 @@ namespace QuantLib {
         return process.drift(t0+dt, x0)*dt;
     }
 
-    Disposable<Matrix> EndEulerDiscretization::diffusion(
-                                      const StochasticProcess& process,
-                                      Time t0, const Array& x0,
-                                      Time dt) const {
+    Matrix EndEulerDiscretization::diffusion(const StochasticProcess& process,
+                                             Time t0,
+                                             const Array& x0,
+                                             Time dt) const {
         return process.diffusion(t0+dt, x0) * std::sqrt(dt);
     }
 
@@ -45,10 +44,10 @@ namespace QuantLib {
         return process.diffusion(t0+dt, x0) * std::sqrt(dt);
     }
 
-    Disposable<Matrix> EndEulerDiscretization::covariance(
-                                      const StochasticProcess& process,
-                                      Time t0, const Array& x0,
-                                      Time dt) const {
+    Matrix EndEulerDiscretization::covariance(const StochasticProcess& process,
+                                              Time t0,
+                                              const Array& x0,
+                                              Time dt) const {
         Matrix sigma = process.diffusion(t0+dt, x0);
         Matrix result = sigma*transpose(sigma)*dt;
         return result;
diff --git a/ql/processes/endeulerdiscretization.hpp b/ql/processes/endeulerdiscretization.hpp
index a949112803d..83a12746a6a 100644
--- a/ql/processes/endeulerdiscretization.hpp
+++ b/ql/processes/endeulerdiscretization.hpp
@@ -38,8 +38,7 @@ namespace QuantLib {
         /*! Returns an approximation of the drift defined as
             \f$ \mu(t_0 + \Delta t, \mathbf{x}_0) \Delta t \f$.
         */
-        Disposable<Array>
-        drift(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
+        Array drift(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
         /*! Returns an approximation of the drift defined as
             \f$ \mu(t_0 + \Delta t, x_0) \Delta t \f$.
         */
@@ -48,8 +47,7 @@ namespace QuantLib {
         /*! Returns an approximation of the diffusion defined as
             \f$ \sigma(t_0 + \Delta t, \mathbf{x}_0) \sqrt{\Delta t} \f$.
         */
-        Disposable<Matrix>
-        diffusion(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
+        Matrix diffusion(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
         /*! Returns an approximation of the diffusion defined as
             \f$ \sigma(t_0 + \Delta t, x_0) \sqrt{\Delta t} \f$.
         */
@@ -58,8 +56,7 @@ namespace QuantLib {
         /*! Returns an approximation of the covariance defined as
             \f$ \sigma(t_0 + \Delta t, \mathbf{x}_0)^2 \Delta t \f$.
         */
-        Disposable<Matrix>
-        covariance(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
+        Matrix covariance(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
         /*! Returns an approximation of the variance defined as
             \f$ \sigma(t_0 + \Delta t, x_0)^2 \Delta t \f$.
         */
diff --git a/ql/processes/eulerdiscretization.cpp b/ql/processes/eulerdiscretization.cpp
index af76cfb8f56..e814d638438 100644
--- a/ql/processes/eulerdiscretization.cpp
+++ b/ql/processes/eulerdiscretization.cpp
@@ -21,10 +21,9 @@
 
 namespace QuantLib {
 
-    Disposable<Array> EulerDiscretization::drift(
-                                      const StochasticProcess& process,
-                                      Time t0, const Array& x0,
-                                      Time dt) const {
+    Array EulerDiscretization::drift(const StochasticProcess& process,
+                                     Time t0, const Array& x0,
+                                     Time dt) const {
         return process.drift(t0, x0)*dt;
     }
 
@@ -33,10 +32,10 @@ namespace QuantLib {
         return process.drift(t0, x0)*dt;
     }
 
-    Disposable<Matrix> EulerDiscretization::diffusion(
-                                      const StochasticProcess& process,
-                                      Time t0, const Array& x0,
-                                      Time dt) const {
+    Matrix EulerDiscretization::diffusion(const StochasticProcess& process,
+                                          Time t0,
+                                          const Array& x0,
+                                          Time dt) const {
         return process.diffusion(t0, x0) * std::sqrt(dt);
     }
 
@@ -45,10 +44,10 @@ namespace QuantLib {
         return process.diffusion(t0, x0) * std::sqrt(dt);
     }
 
-    Disposable<Matrix> EulerDiscretization::covariance(
-                                      const StochasticProcess& process,
-                                      Time t0, const Array& x0,
-                                      Time dt) const {
+    Matrix EulerDiscretization::covariance(const StochasticProcess& process,
+                                           Time t0,
+                                           const Array& x0,
+                                           Time dt) const {
         Matrix sigma = process.diffusion(t0, x0);
         Matrix result = sigma*transpose(sigma)*dt;
         return result;
diff --git a/ql/processes/eulerdiscretization.hpp b/ql/processes/eulerdiscretization.hpp
index 92d5bd843be..e78c43c1431 100644
--- a/ql/processes/eulerdiscretization.hpp
+++ b/ql/processes/eulerdiscretization.hpp
@@ -38,8 +38,7 @@ namespace QuantLib {
         /*! Returns an approximation of the drift defined as
             \f$ \mu(t_0, \mathbf{x}_0) \Delta t \f$.
         */
-        Disposable<Array>
-        drift(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
+        Array drift(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
         /*! Returns an approximation of the drift defined as
             \f$ \mu(t_0, x_0) \Delta t \f$.
         */
@@ -48,8 +47,7 @@ namespace QuantLib {
         /*! Returns an approximation of the diffusion defined as
             \f$ \sigma(t_0, \mathbf{x}_0) \sqrt{\Delta t} \f$.
         */
-        Disposable<Matrix>
-        diffusion(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
+        Matrix diffusion(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
         /*! Returns an approximation of the diffusion defined as
             \f$ \sigma(t_0, x_0) \sqrt{\Delta t} \f$.
         */
@@ -58,8 +56,7 @@ namespace QuantLib {
         /*! Returns an approximation of the covariance defined as
             \f$ \sigma(t_0, \mathbf{x}_0)^2 \Delta t \f$.
         */
-        Disposable<Matrix>
-        covariance(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
+        Matrix covariance(const StochasticProcess&, Time t0, const Array& x0, Time dt) const override;
         /*! Returns an approximation of the variance defined as
             \f$ \sigma(t_0, x_0)^2 \Delta t \f$.
         */
diff --git a/ql/processes/g2process.cpp b/ql/processes/g2process.cpp
index 9b65db4c0f8..912ece881bf 100644
--- a/ql/processes/g2process.cpp
+++ b/ql/processes/g2process.cpp
@@ -31,21 +31,18 @@ namespace QuantLib {
         return 2;
     }
 
-    Disposable<Array> G2Process::initialValues() const {
-        Array tmp(2);
-        tmp[0] = x0_;
-        tmp[1] = y0_;
-        return tmp;
+    Array G2Process::initialValues() const {
+        return { x0_, y0_ };
     }
 
-    Disposable<Array> G2Process::drift(Time t, const Array& x) const {
-        Array tmp(2);
-        tmp[0] = xProcess_->drift(t, x[0]);
-        tmp[1] = yProcess_->drift(t, x[1]);
-        return tmp;
+    Array G2Process::drift(Time t, const Array& x) const {
+        return {
+            xProcess_->drift(t, x[0]),
+            yProcess_->drift(t, x[1])
+        };
     }
 
-    Disposable<Matrix> G2Process::diffusion(Time, const Array&) const {
+    Matrix G2Process::diffusion(Time, const Array&) const {
         /* the correlation matrix is
            |  1   rho |
            | rho   1  |
@@ -61,16 +58,15 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Array> G2Process::expectation(Time t0, const Array& x0,
-                                             Time dt) const {
-        Array tmp(2);
-        tmp[0] = xProcess_->expectation(t0, x0[0], dt);
-        tmp[1] = yProcess_->expectation(t0, x0[1], dt);
-        return tmp;
+    Array G2Process::expectation(Time t0, const Array& x0,
+                                 Time dt) const {
+        return {
+            xProcess_->expectation(t0, x0[0], dt),
+            yProcess_->expectation(t0, x0[1], dt)
+        };
     }
 
-    Disposable<Matrix> G2Process::stdDeviation(Time t0, const Array& x0,
-                                               Time dt) const {
+    Matrix G2Process::stdDeviation(Time t0, const Array& x0, Time dt) const {
         /* the correlation matrix is
            |  1   rho |
            | rho   1  |
@@ -93,8 +89,7 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Matrix> G2Process::covariance(Time t0, const Array& x0,
-                                             Time dt) const {
+    Matrix G2Process::covariance(Time t0, const Array& x0, Time dt) const {
         Matrix sigma = stdDeviation(t0, x0, dt);
         Matrix result = sigma*transpose(sigma);
         return result;
@@ -139,21 +134,18 @@ namespace QuantLib {
         return 2;
     }
 
-    Disposable<Array> G2ForwardProcess::initialValues() const {
-        Array tmp(2);
-        tmp[0] = x0_;
-        tmp[1] = y0_;
-        return tmp;
+    Array G2ForwardProcess::initialValues() const {
+        return { x0_, y0_ };
     }
 
-    Disposable<Array> G2ForwardProcess::drift(Time t, const Array& x) const {
-        Array tmp(2);
-        tmp[0] = xProcess_->drift(t, x[0]) + xForwardDrift(t, T_);
-        tmp[1] = yProcess_->drift(t, x[1]) + yForwardDrift(t, T_);
-        return tmp;
+    Array G2ForwardProcess::drift(Time t, const Array& x) const {
+        return {
+            xProcess_->drift(t, x[0]) + xForwardDrift(t, T_),
+            yProcess_->drift(t, x[1]) + yForwardDrift(t, T_)
+        };
     }
 
-    Disposable<Matrix> G2ForwardProcess::diffusion(Time, const Array&) const {
+    Matrix G2ForwardProcess::diffusion(Time, const Array&) const {
         Matrix tmp(2,2);
         Real sigma1 = sigma_;
         Real sigma2 = eta_;
@@ -162,16 +154,15 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Array> G2ForwardProcess::expectation(Time t0, const Array& x0,
-                                                    Time dt) const {
-        Array tmp(2);
-        tmp[0] = xProcess_->expectation(t0, x0[0], dt) - Mx_T(t0, t0+dt, T_);
-        tmp[1] = yProcess_->expectation(t0, x0[1], dt) - My_T(t0, t0+dt, T_);
-        return tmp;
+    Array G2ForwardProcess::expectation(Time t0, const Array& x0,
+                                        Time dt) const {
+        return {
+            xProcess_->expectation(t0, x0[0], dt) - Mx_T(t0, t0+dt, T_),
+            yProcess_->expectation(t0, x0[1], dt) - My_T(t0, t0+dt, T_)
+        };
     }
 
-    Disposable<Matrix> G2ForwardProcess::stdDeviation(Time t0, const Array& x0,
-                                                      Time dt) const {
+    Matrix G2ForwardProcess::stdDeviation(Time t0, const Array& x0, Time dt) const {
         Matrix tmp(2,2);
         Real sigma1 = xProcess_->stdDeviation(t0, x0[0], dt);
         Real sigma2 = yProcess_->stdDeviation(t0, x0[1], dt);
@@ -187,8 +178,7 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Matrix> G2ForwardProcess::covariance(Time t0, const Array& x0,
-                                                    Time dt) const {
+    Matrix G2ForwardProcess::covariance(Time t0, const Array& x0, Time dt) const {
         Matrix sigma = stdDeviation(t0, x0, dt);
         Matrix result = sigma*transpose(sigma);
         return result;
diff --git a/ql/processes/g2process.hpp b/ql/processes/g2process.hpp
index 88cc0f99935..0e05134fb77 100644
--- a/ql/processes/g2process.hpp
+++ b/ql/processes/g2process.hpp
@@ -37,12 +37,12 @@ namespace QuantLib {
         //! \name StochasticProcess interface
         //@{
         Size size() const override;
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Array> expectation(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Matrix> stdDeviation(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Matrix> covariance(Time t0, const Array& x0, Time dt) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Array expectation(Time t0, const Array& x0, Time dt) const override;
+        Matrix stdDeviation(Time t0, const Array& x0, Time dt) const override;
+        Matrix covariance(Time t0, const Array& x0, Time dt) const override;
         //@}
         Real x0() const;
         Real y0() const;
@@ -65,12 +65,12 @@ namespace QuantLib {
         //! \name StochasticProcess interface
         //@{
         Size size() const override;
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Array> expectation(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Matrix> stdDeviation(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Matrix> covariance(Time t0, const Array& x0, Time dt) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Array expectation(Time t0, const Array& x0, Time dt) const override;
+        Matrix stdDeviation(Time t0, const Array& x0, Time dt) const override;
+        Matrix covariance(Time t0, const Array& x0, Time dt) const override;
         //@}
       protected:
         Real x0_, y0_, a_, sigma_, b_, eta_, rho_;
diff --git a/ql/processes/gjrgarchprocess.cpp b/ql/processes/gjrgarchprocess.cpp
index 4e2384abcd2..9b92c266c5a 100644
--- a/ql/processes/gjrgarchprocess.cpp
+++ b/ql/processes/gjrgarchprocess.cpp
@@ -50,15 +50,11 @@ namespace QuantLib {
         return 2;
     }
 
-    Disposable<Array> GJRGARCHProcess::initialValues() const {
-        Array tmp(2);
-        tmp[0] = s0_->value();
-        tmp[1] = daysPerYear_*v0_;
-        return tmp;
+    Array GJRGARCHProcess::initialValues() const {
+        return { s0_->value(), daysPerYear_*v0_ };
     }
 
-    Disposable<Array> GJRGARCHProcess::drift(Time t, const Array& x) const {
-        Array tmp(2);
+    Array GJRGARCHProcess::drift(Time t, const Array& x) const {
         const Real N = CumulativeNormalDistribution()(lambda_);
         const Real n = std::exp(-lambda_*lambda_/2.0)/std::sqrt(2*M_PI);
         const Real q2 = 1.0 + lambda_*lambda_;
@@ -67,17 +63,17 @@ namespace QuantLib {
                          : (discretization_ == Reflection) ? - std::sqrt(-x[1])
                          : 0.0;
 
-        tmp[0] = riskFreeRate_->forwardRate(t, t, Continuous)
+        return {
+            riskFreeRate_->forwardRate(t, t, Continuous)
                - dividendYield_->forwardRate(t, t, Continuous)
-               - 0.5 * vol * vol;
-
-        tmp[1] = daysPerYear_*daysPerYear_*omega_ + daysPerYear_*(beta_ 
+               - 0.5 * vol * vol,
+            daysPerYear_*daysPerYear_*omega_ + daysPerYear_*(beta_ 
                                              + alpha_*q2 + gamma_*q3 - 1.0) *
-           ((discretization_==PartialTruncation) ? x[1] : vol*vol);
-        return tmp;
+               ((discretization_==PartialTruncation) ? x[1] : vol*vol)
+        };
     }
 
-    Disposable<Matrix> GJRGARCHProcess::diffusion(Time, const Array& x) const {
+    Matrix GJRGARCHProcess::diffusion(Time, const Array& x) const {
         /* the correlation matrix is
            |  1   rho |
            | rho   1  |
@@ -115,16 +111,13 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Array> GJRGARCHProcess::apply(const Array& x0,
-                                           const Array& dx) const {
-        Array tmp(2);
-        tmp[0] = x0[0] * std::exp(dx[0]);
-        tmp[1] = x0[1] + dx[1];
-        return tmp;
+    Array GJRGARCHProcess::apply(const Array& x0,
+                                 const Array& dx) const {
+        return { x0[0] * std::exp(dx[0]), x0[1] + dx[1] };
     }
 
-    Disposable<Array> GJRGARCHProcess::evolve(Time t0, const Array& x0,
-                                            Time dt, const Array& dw) const {
+    Array GJRGARCHProcess::evolve(Time t0, const Array& x0,
+                                  Time dt, const Array& dw) const {
         Array retVal(2);
         Real vol, mu, nu;
 
diff --git a/ql/processes/gjrgarchprocess.hpp b/ql/processes/gjrgarchprocess.hpp
index 9bd275b3f55..e16451d6020 100644
--- a/ql/processes/gjrgarchprocess.hpp
+++ b/ql/processes/gjrgarchprocess.hpp
@@ -79,11 +79,11 @@ namespace QuantLib {
                         Discretization d = FullTruncation);
 
         Size size() const override;
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Array> apply(const Array& x0, const Array& dx) const override;
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Array apply(const Array& x0, const Array& dx) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
         Real v0()     const { return v0_; }
         Real lambda() const { return lambda_; }
diff --git a/ql/processes/hestonprocess.cpp b/ql/processes/hestonprocess.cpp
index d6b92eae2fe..d84c1143603 100644
--- a/ql/processes/hestonprocess.cpp
+++ b/ql/processes/hestonprocess.cpp
@@ -63,29 +63,24 @@ namespace QuantLib {
                 || discretization_ == BroadieKayaExactSchemeLaguerre) ? 3 : 2;
     }
 
-    Disposable<Array> HestonProcess::initialValues() const {
-        Array tmp(2);
-        tmp[0] = s0_->value();
-        tmp[1] = v0_;
-        return tmp;
+    Array HestonProcess::initialValues() const {
+        return { s0_->value(), v0_ };
     }
 
-    Disposable<Array> HestonProcess::drift(Time t, const Array& x) const {
-        Array tmp(2);
+    Array HestonProcess::drift(Time t, const Array& x) const {
         const Real vol = (x[1] > 0.0) ? std::sqrt(x[1])
                          : (discretization_ == Reflection) ? - std::sqrt(-x[1])
                          : 0.0;
 
-        tmp[0] = riskFreeRate_->forwardRate(t, t, Continuous)
+        return {
+            riskFreeRate_->forwardRate(t, t, Continuous)
                - dividendYield_->forwardRate(t, t, Continuous)
-               - 0.5 * vol * vol;
-
-        tmp[1] = kappa_*
-           (theta_-((discretization_==PartialTruncation) ? x[1] : vol*vol));
-        return tmp;
+               - 0.5 * vol * vol,
+            kappa_* (theta_-((discretization_==PartialTruncation) ? x[1] : vol*vol))
+        };
     }
 
-    Disposable<Matrix> HestonProcess::diffusion(Time, const Array& x) const {
+    Matrix HestonProcess::diffusion(Time, const Array& x) const {
         /* the correlation matrix is
            |  1   rho |
            | rho   1  |
@@ -106,12 +101,12 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Array> HestonProcess::apply(const Array& x0,
-                                           const Array& dx) const {
-        Array tmp(2);
-        tmp[0] = x0[0] * std::exp(dx[0]);
-        tmp[1] = x0[1] + dx[1];
-        return tmp;
+    Array HestonProcess::apply(const Array& x0,
+                               const Array& dx) const {
+        return {
+            x0[0] * std::exp(dx[0]),
+            x0[1] + dx[1]
+        };
     }
 
     namespace {
@@ -399,8 +394,8 @@ namespace QuantLib {
                      v/k) / k;
      }
 
-    Disposable<Array> HestonProcess::evolve(Time t0, const Array& x0,
-                                            Time dt, const Array& dw) const {
+    Array HestonProcess::evolve(Time t0, const Array& x0,
+                                Time dt, const Array& dw) const {
         Array retVal(2);
         Real vol, vol2, mu, nu, dy;
 
diff --git a/ql/processes/hestonprocess.hpp b/ql/processes/hestonprocess.hpp
index c5adf714c33..6f93d7dfc8b 100644
--- a/ql/processes/hestonprocess.hpp
+++ b/ql/processes/hestonprocess.hpp
@@ -68,11 +68,11 @@ namespace QuantLib {
         Size size() const override;
         Size factors() const override;
 
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Array> apply(const Array& x0, const Array& dx) const override;
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Array apply(const Array& x0, const Array& dx) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
         Real v0()    const { return v0_; }
         Real rho()   const { return rho_; }
diff --git a/ql/processes/hybridhestonhullwhiteprocess.cpp b/ql/processes/hybridhestonhullwhiteprocess.cpp
index 5a354726eaa..220b78c3046 100644
--- a/ql/processes/hybridhestonhullwhiteprocess.cpp
+++ b/ql/processes/hybridhestonhullwhiteprocess.cpp
@@ -57,45 +57,37 @@ namespace QuantLib {
         return 3;
     }
 
-    Disposable<Array> HybridHestonHullWhiteProcess::initialValues() const {
-        Array retVal(3);
-        retVal[0] = hestonProcess_->s0()->value();
-        retVal[1] = hestonProcess_->v0();
-        retVal[2] = hullWhiteProcess_->x0();
-        
-        return retVal;
+    Array HybridHestonHullWhiteProcess::initialValues() const {
+        return {
+            hestonProcess_->s0()->value(),
+            hestonProcess_->v0(),
+            hullWhiteProcess_->x0()
+        };
     }
 
-    Disposable<Array> 
-    HybridHestonHullWhiteProcess::drift(Time t, const Array& x) const {
-        Array retVal(3), x0(2);
-        
-        x0[0] = x[0]; x0[1] = x[1];
+    Array HybridHestonHullWhiteProcess::drift(Time t, const Array& x) const {
+        Array x0 = { x[0], x[1] };
         Array y0 = hestonProcess_->drift(t, x0);
-        
-        retVal[0] = y0[0]; retVal[1] = y0[1];
-        retVal[2] = hullWhiteProcess_->drift(t, x[2]);
-        
-        return retVal;
-    }
 
-    Disposable<Array> 
-    HybridHestonHullWhiteProcess::apply(const Array& x0,const Array& dx) const {
-        Array retVal(3), xt(2), dxt(2);
-        
-        xt[0]  = x0[0]; xt[1]  = x0[1];
-        dxt[0] = dx[0]; dxt[1] = dx[1];
+        return {
+            y0[0],
+            y0[1],
+            hullWhiteProcess_->drift(t, x[2])
+        };
+    }
 
+    Array HybridHestonHullWhiteProcess::apply(const Array& x0, const Array& dx) const {
+        Array xt = { x0[0], x0[1] }, dxt = { dx[0], dx[1] };
         Array yt = hestonProcess_->apply(xt, dxt);
-        
-        retVal[0] = yt[0]; retVal[1] = yt[1];
-        retVal[2] = hullWhiteProcess_->apply(x0[2], dx[2]);
-        
-        return retVal;
+
+        return {
+            yt[0],
+            yt[1],
+            hullWhiteProcess_->apply(x0[2], dx[2])
+        };
     }
     
-    Disposable<Matrix> 
-    HybridHestonHullWhiteProcess::diffusion(Time t, const Array& x) const {
+    Matrix HybridHestonHullWhiteProcess::diffusion(Time t, const Array& x) const {
         Matrix retVal(3,3);
 
         Array xt(2); xt[0] = x[0]; xt[1] = x[1];
@@ -112,9 +104,8 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<Array> 
-    HybridHestonHullWhiteProcess::evolve(Time t0, const Array& x0,
-                                         Time dt, const Array& dw) const {
+    Array HybridHestonHullWhiteProcess::evolve(Time t0, const Array& x0,
+                                               Time dt, const Array& dw) const {
 
         const Rate r         = x0[2];
         const Real a         = hullWhiteProcess_->a();
diff --git a/ql/processes/hybridhestonhullwhiteprocess.hpp b/ql/processes/hybridhestonhullwhiteprocess.hpp
index b8f106e07bb..5e00a8e16e5 100644
--- a/ql/processes/hybridhestonhullwhiteprocess.hpp
+++ b/ql/processes/hybridhestonhullwhiteprocess.hpp
@@ -50,18 +50,17 @@ namespace QuantLib {
           Discretization discretization = BSMHullWhite);
 
         Size size() const override;
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Array> apply(const Array& x0, const Array& dx) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Array apply(const Array& x0, const Array& dx) const override;
 
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
         DiscountFactor numeraire(Time t, const Array& x) const;
 
         const ext::shared_ptr<HestonProcess>& hestonProcess() const;
-        const ext::shared_ptr<HullWhiteForwardProcess>& 
-                                                    hullWhiteProcess() const;
+        const ext::shared_ptr<HullWhiteForwardProcess>& hullWhiteProcess() const;
 
         Real eta() const;
         Time time(const Date& date) const override;
diff --git a/ql/processes/jointstochasticprocess.cpp b/ql/processes/jointstochasticprocess.cpp
index 4d787ec5cbe..3996e9e1fa9 100644
--- a/ql/processes/jointstochasticprocess.cpp
+++ b/ql/processes/jointstochasticprocess.cpp
@@ -66,8 +66,8 @@ namespace QuantLib {
         return factors_;
     }
 
-    Disposable<Array> JointStochasticProcess::slice(const Array& x,
-                                                    Size i) const {
+    Array JointStochasticProcess::slice(const Array& x,
+                                        Size i) const {
         // cut out the ith process' variables
         Size n = vsize_[i+1]-vsize_[i];
         Array y(n);
@@ -75,7 +75,7 @@ namespace QuantLib {
         return y;
     }
 
-    Disposable<Array> JointStochasticProcess::initialValues() const {
+    Array JointStochasticProcess::initialValues() const {
         Array retVal(size());
 
         for (auto iter = l_.begin(); iter != l_.end(); ++iter) {
@@ -89,8 +89,8 @@ namespace QuantLib {
     }
 
 
-    Disposable<Array> JointStochasticProcess::drift(Time t,
-                                                    const Array& x) const {
+    Array JointStochasticProcess::drift(Time t,
+                                        const Array& x) const {
         Array retVal(size());
 
         for (Size i=0; i < l_.size(); ++i) {
@@ -104,9 +104,9 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<Array> JointStochasticProcess::expectation(Time t0,
-                                                          const Array& x0,
-                                                          Time dt) const {
+    Array JointStochasticProcess::expectation(Time t0,
+                                              const Array& x0,
+                                              Time dt) const {
         Array retVal(size());
 
         for (Size i=0; i < l_.size(); ++i) {
@@ -121,17 +121,16 @@ namespace QuantLib {
     }
 
 
-    Disposable<Matrix> JointStochasticProcess::diffusion(
-                                               Time t, const Array& x) const {
+    Matrix JointStochasticProcess::diffusion(Time t, const Array& x) const {
         // might need some improvement in the future
         const Time dt = 0.001;
         return pseudoSqrt(covariance(t, x, dt)/dt);
     }
 
 
-    Disposable<Matrix> JointStochasticProcess::covariance(Time t0,
-                                                          const Array& x0,
-                                                          Time dt) const {
+    Matrix JointStochasticProcess::covariance(Time t0,
+                                              const Array& x0,
+                                              Time dt) const {
 
         // get the model intrinsic covariance matrix
         Matrix retVal(size(), size(), 0.0);
@@ -163,15 +162,15 @@ namespace QuantLib {
     }
 
 
-    Disposable<Matrix> JointStochasticProcess::stdDeviation(Time t0,
-                                                            const Array& x0,
-                                                            Time dt) const {
+    Matrix JointStochasticProcess::stdDeviation(Time t0,
+                                                const Array& x0,
+                                                Time dt) const {
         return pseudoSqrt(covariance(t0, x0, dt));
     }
 
 
-    Disposable<Array> JointStochasticProcess::apply(const Array& x0,
-                                                    const Array& dx) const {
+    Array JointStochasticProcess::apply(const Array& x0,
+                                        const Array& dx) const {
         Array retVal(size());
 
         for (Size i=0; i < l_.size(); ++i) {
@@ -184,7 +183,7 @@ namespace QuantLib {
         return retVal;
     }
 
-    Disposable<Array> JointStochasticProcess::evolve(
+    Array JointStochasticProcess::evolve(
         Time t0, const Array& x0, Time dt, const Array& dw) const {
         Array dv(modelFactors_);
 
diff --git a/ql/processes/jointstochasticprocess.hpp b/ql/processes/jointstochasticprocess.hpp
index deb53763bdc..1fbab6beacd 100644
--- a/ql/processes/jointstochasticprocess.hpp
+++ b/ql/processes/jointstochasticprocess.hpp
@@ -39,27 +39,26 @@ namespace QuantLib {
         Size size() const override;
         Size factors() const override;
 
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Array> expectation(Time t0, const Array& x0, Time dt) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Array expectation(Time t0, const Array& x0, Time dt) const override;
 
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Matrix> covariance(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Matrix> stdDeviation(Time t0, const Array& x0, Time dt) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Matrix covariance(Time t0, const Array& x0, Time dt) const override;
+        Matrix stdDeviation(Time t0, const Array& x0, Time dt) const override;
 
-        Disposable<Array> apply(const Array& x0, const Array& dx) const override;
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array apply(const Array& x0, const Array& dx) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
         virtual void preEvolve(Time t0, const Array& x0,
                                Time dt, const Array& dw) const = 0;
-        virtual Disposable<Array> postEvolve(Time t0, const Array& x0,
-                                             Time dt, const Array& dw,
-                                             const Array& y0) const = 0;
+        virtual Array postEvolve(Time t0, const Array& x0,
+                                 Time dt, const Array& dw,
+                                 const Array& y0) const = 0;
 
         virtual DiscountFactor numeraire(Time t, const Array& x) const = 0;
         virtual bool correlationIsStateDependent() const = 0;
-        virtual Disposable<Matrix> crossModelCorrelation(
-                                Time t0, const Array& x0) const = 0;
+        virtual Matrix crossModelCorrelation(Time t0, const Array& x0) const = 0;
 
         const std::vector<ext::shared_ptr<StochasticProcess> > &
                                                        constituents() const;
@@ -69,7 +68,7 @@ namespace QuantLib {
 
       protected:
         std::vector<ext::shared_ptr<StochasticProcess> > l_;
-        Disposable<Array> slice(const Array& x, Size i) const;
+        Array slice(const Array& x, Size i) const;
 
       private:
         typedef
diff --git a/ql/processes/stochasticprocessarray.cpp b/ql/processes/stochasticprocessarray.cpp
index a46ed3a3409..82e81626491 100644
--- a/ql/processes/stochasticprocessarray.cpp
+++ b/ql/processes/stochasticprocessarray.cpp
@@ -44,23 +44,23 @@ namespace QuantLib {
         return processes_.size();
     }
 
-    Disposable<Array> StochasticProcessArray::initialValues() const {
+    Array StochasticProcessArray::initialValues() const {
         Array tmp(size());
         for (Size i=0; i<size(); ++i)
             tmp[i] = processes_[i]->x0();
         return tmp;
     }
 
-    Disposable<Array> StochasticProcessArray::drift(Time t,
-                                                    const Array& x) const {
+    Array StochasticProcessArray::drift(Time t,
+                                        const Array& x) const {
         Array tmp(size());
         for (Size i=0; i<size(); ++i)
             tmp[i] = processes_[i]->drift(t, x[i]);
         return tmp;
     }
 
-    Disposable<Matrix> StochasticProcessArray::diffusion(
-                                               Time t, const Array& x) const {
+    Matrix StochasticProcessArray::diffusion(Time t,
+                                             const Array& x) const {
         Matrix tmp = sqrtCorrelation_;
         for (Size i=0; i<size(); ++i) {
             Real sigma = processes_[i]->diffusion(t, x[i]);
@@ -71,18 +71,18 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Array> StochasticProcessArray::expectation(Time t0,
-                                                          const Array& x0,
-                                                          Time dt) const {
+    Array StochasticProcessArray::expectation(Time t0,
+                                              const Array& x0,
+                                              Time dt) const {
         Array tmp(size());
         for (Size i=0; i<size(); ++i)
             tmp[i] = processes_[i]->expectation(t0, x0[i], dt);
         return tmp;
     }
 
-    Disposable<Matrix> StochasticProcessArray::stdDeviation(Time t0,
-                                                            const Array& x0,
-                                                            Time dt) const {
+    Matrix StochasticProcessArray::stdDeviation(Time t0,
+                                                const Array& x0,
+                                                Time dt) const {
         Matrix tmp = sqrtCorrelation_;
         for (Size i=0; i<size(); ++i) {
             Real sigma = processes_[i]->stdDeviation(t0, x0[i], dt);
@@ -93,14 +93,14 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Matrix> StochasticProcessArray::covariance(Time t0,
-                                                          const Array& x0,
-                                                          Time dt) const {
+    Matrix StochasticProcessArray::covariance(Time t0,
+                                              const Array& x0,
+                                              Time dt) const {
         Matrix tmp = stdDeviation(t0, x0, dt);
         return tmp*transpose(tmp);
     }
 
-    Disposable<Array> StochasticProcessArray::evolve(
+    Array StochasticProcessArray::evolve(
                   Time t0, const Array& x0, Time dt, const Array& dw) const {
         const Array dz = sqrtCorrelation_ * dw;
 
@@ -110,8 +110,8 @@ namespace QuantLib {
         return tmp;
     }
 
-    Disposable<Array> StochasticProcessArray::apply(const Array& x0,
-                                                    const Array& dx) const {
+    Array StochasticProcessArray::apply(const Array& x0,
+                                        const Array& dx) const {
         Array tmp(size());
         for (Size i=0; i<size(); ++i)
             tmp[i] = processes_[i]->apply(x0[i],dx[i]);
@@ -127,7 +127,7 @@ namespace QuantLib {
         return processes_[i];
     }
 
-    Disposable<Matrix> StochasticProcessArray::correlation() const {
+    Matrix StochasticProcessArray::correlation() const {
         return sqrtCorrelation_ * transpose(sqrtCorrelation_);
     }
 
diff --git a/ql/processes/stochasticprocessarray.hpp b/ql/processes/stochasticprocessarray.hpp
index 6746085f3c3..53e6acf416e 100644
--- a/ql/processes/stochasticprocessarray.hpp
+++ b/ql/processes/stochasticprocessarray.hpp
@@ -39,21 +39,21 @@ namespace QuantLib {
                   const Matrix& correlation);
         // stochastic process interface
         Size size() const override;
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Array> expectation(Time t0, const Array& x0, Time dt) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Array expectation(Time t0, const Array& x0, Time dt) const override;
 
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Matrix> covariance(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Matrix> stdDeviation(Time t0, const Array& x0, Time dt) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Matrix covariance(Time t0, const Array& x0, Time dt) const override;
+        Matrix stdDeviation(Time t0, const Array& x0, Time dt) const override;
 
-        Disposable<Array> apply(const Array& x0, const Array& dx) const override;
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array apply(const Array& x0, const Array& dx) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
 
         Time time(const Date&) const override;
         // inspectors
         const ext::shared_ptr<StochasticProcess1D>& process(Size i) const;
-        Disposable<Matrix> correlation() const;
+        Matrix correlation() const;
       protected:
         std::vector<ext::shared_ptr<StochasticProcess1D> > processes_;
         Matrix sqrtCorrelation_;
diff --git a/ql/stochasticprocess.cpp b/ql/stochasticprocess.cpp
index 3e267c8aeb2..217674ff6f9 100644
--- a/ql/stochasticprocess.cpp
+++ b/ql/stochasticprocess.cpp
@@ -33,32 +33,31 @@ namespace QuantLib {
         return size();
     }
 
-    Disposable<Array> StochasticProcess::expectation(Time t0,
-                                                     const Array& x0,
-                                                     Time dt) const {
+    Array StochasticProcess::expectation(Time t0,
+                                         const Array& x0,
+                                         Time dt) const {
         return apply(x0, discretization_->drift(*this, t0, x0, dt));
     }
 
-    Disposable<Matrix> StochasticProcess::stdDeviation(Time t0,
-                                                       const Array& x0,
-                                                       Time dt) const {
+    Matrix StochasticProcess::stdDeviation(Time t0,
+                                           const Array& x0,
+                                           Time dt) const {
         return discretization_->diffusion(*this, t0, x0, dt);
     }
 
-    Disposable<Matrix> StochasticProcess::covariance(Time t0,
-                                                     const Array& x0,
-                                                     Time dt) const {
+    Matrix StochasticProcess::covariance(Time t0,
+                                         const Array& x0,
+                                         Time dt) const {
         return discretization_->covariance(*this, t0, x0, dt);
     }
 
-    Disposable<Array> StochasticProcess::evolve(
-                                             Time t0, const Array& x0,
-                                             Time dt, const Array& dw) const {
+    Array StochasticProcess::evolve(Time t0, const Array& x0,
+                                    Time dt, const Array& dw) const {
         return apply(expectation(t0,x0,dt), stdDeviation(t0,x0,dt)*dw);
     }
 
-    Disposable<Array> StochasticProcess::apply(const Array& x0,
-                                               const Array& dx) const {
+    Array StochasticProcess::apply(const Array& x0,
+                                   const Array& dx) const {
         return x0 + dx;
     }
 
diff --git a/ql/stochasticprocess.hpp b/ql/stochasticprocess.hpp
index bc91af197f4..2446c05aae9 100644
--- a/ql/stochasticprocess.hpp
+++ b/ql/stochasticprocess.hpp
@@ -45,17 +45,18 @@ namespace QuantLib {
         class discretization {
           public:
             virtual ~discretization() = default;
-            virtual Disposable<Array> drift(const StochasticProcess&,
-                                            Time t0, const Array& x0,
-                                            Time dt) const = 0;
-            virtual Disposable<Matrix> diffusion(
-                                              const StochasticProcess&,
-                                              Time t0, const Array& x0,
-                                              Time dt) const = 0;
-            virtual Disposable<Matrix> covariance(
-                                              const StochasticProcess&,
-                                              Time t0, const Array& x0,
-                                              Time dt) const = 0;
+            virtual Array drift(const StochasticProcess&,
+                                Time t0,
+                                const Array& x0,
+                                Time dt) const = 0;
+            virtual Matrix diffusion(const StochasticProcess&,
+                                     Time t0,
+                                     const Array& x0,
+                                     Time dt) const = 0;
+            virtual Matrix covariance(const StochasticProcess&,
+                                      Time t0,
+                                      const Array& x0,
+                                      Time dt) const = 0;
         };
         ~StochasticProcess() override = default;
         //! \name Stochastic process interface
@@ -65,17 +66,17 @@ namespace QuantLib {
         //! returns the number of independent factors of the process
         virtual Size factors() const;
         //! returns the initial values of the state variables
-        virtual Disposable<Array> initialValues() const = 0;
+        virtual Array initialValues() const = 0;
         /*! \brief returns the drift part of the equation, i.e.,
                    \f$ \mu(t, \mathrm{x}_t) \f$
         */
-        virtual Disposable<Array> drift(Time t,
-                                        const Array& x) const = 0;
+        virtual Array drift(Time t,
+                            const Array& x) const = 0;
         /*! \brief returns the diffusion part of the equation, i.e.
                    \f$ \sigma(t, \mathrm{x}_t) \f$
         */
-        virtual Disposable<Matrix> diffusion(Time t,
-                                             const Array& x) const = 0;
+        virtual Matrix diffusion(Time t,
+                                 const Array& x) const = 0;
         /*! returns the expectation
             \f$ E(\mathrm{x}_{t_0 + \Delta t}
                 | \mathrm{x}_{t_0} = \mathrm{x}_0) \f$
@@ -84,9 +85,9 @@ namespace QuantLib {
             overridden in derived classes which want to hard-code a
             particular discretization.
         */
-        virtual Disposable<Array> expectation(Time t0,
-                                              const Array& x0,
-                                              Time dt) const;
+        virtual Array expectation(Time t0,
+                                  const Array& x0,
+                                  Time dt) const;
         /*! returns the standard deviation
             \f$ S(\mathrm{x}_{t_0 + \Delta t}
                 | \mathrm{x}_{t_0} = \mathrm{x}_0) \f$
@@ -95,9 +96,9 @@ namespace QuantLib {
             overridden in derived classes which want to hard-code a
             particular discretization.
         */
-        virtual Disposable<Matrix> stdDeviation(Time t0,
-                                                const Array& x0,
-                                                Time dt) const;
+        virtual Matrix stdDeviation(Time t0,
+                                    const Array& x0,
+                                    Time dt) const;
         /*! returns the covariance
             \f$ V(\mathrm{x}_{t_0 + \Delta t}
                 | \mathrm{x}_{t_0} = \mathrm{x}_0) \f$
@@ -106,9 +107,9 @@ namespace QuantLib {
             overridden in derived classes which want to hard-code a
             particular discretization.
         */
-        virtual Disposable<Matrix> covariance(Time t0,
-                                              const Array& x0,
-                                              Time dt) const;
+        virtual Matrix covariance(Time t0,
+                                  const Array& x0,
+                                  Time dt) const;
         /*! returns the asset value after a time interval \f$ \Delta t
             \f$ according to the given discretization. By default, it
             returns
@@ -119,15 +120,15 @@ namespace QuantLib {
             where \f$ E \f$ is the expectation and \f$ S \f$ the
             standard deviation.
         */
-        virtual Disposable<Array> evolve(Time t0,
-                                         const Array& x0,
-                                         Time dt,
-                                         const Array& dw) const;
+        virtual Array evolve(Time t0,
+                             const Array& x0,
+                             Time dt,
+                             const Array& dw) const;
         /*! applies a change to the asset value. By default, it
             returns \f$ \mathrm{x} + \Delta \mathrm{x} \f$.
         */
-        virtual Disposable<Array> apply(const Array& x0,
-                                        const Array& dx) const;
+        virtual Array apply(const Array& x0,
+                            const Array& dx) const;
         //@}
 
         //! \name utilities
@@ -228,14 +229,14 @@ namespace QuantLib {
       private:
         // StochasticProcess interface implementation
         Size size() const override;
-        Disposable<Array> initialValues() const override;
-        Disposable<Array> drift(Time t, const Array& x) const override;
-        Disposable<Matrix> diffusion(Time t, const Array& x) const override;
-        Disposable<Array> expectation(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Matrix> stdDeviation(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Matrix> covariance(Time t0, const Array& x0, Time dt) const override;
-        Disposable<Array> evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
-        Disposable<Array> apply(const Array& x0, const Array& dx) const override;
+        Array initialValues() const override;
+        Array drift(Time t, const Array& x) const override;
+        Matrix diffusion(Time t, const Array& x) const override;
+        Array expectation(Time t0, const Array& x0, Time dt) const override;
+        Matrix stdDeviation(Time t0, const Array& x0, Time dt) const override;
+        Matrix covariance(Time t0, const Array& x0, Time dt) const override;
+        Array evolve(Time t0, const Array& x0, Time dt, const Array& dw) const override;
+        Array apply(const Array& x0, const Array& dx) const override;
     };
 
 
@@ -245,13 +246,12 @@ namespace QuantLib {
         return 1;
     }
 
-    inline Disposable<Array> StochasticProcess1D::initialValues() const {
+    inline Array StochasticProcess1D::initialValues() const {
         Array a(1, x0());
         return a;
     }
 
-    inline Disposable<Array> StochasticProcess1D::drift(
-                                               Time t, const Array& x) const {
+    inline Array StochasticProcess1D::drift(Time t, const Array& x) const {
         #if defined(QL_EXTRA_SAFETY_CHECKS)
         QL_REQUIRE(x.size() == 1, "1-D array required");
         #endif
@@ -259,8 +259,7 @@ namespace QuantLib {
         return a;
     }
 
-    inline Disposable<Matrix> StochasticProcess1D::diffusion(
-                                               Time t, const Array& x) const {
+    inline Matrix StochasticProcess1D::diffusion(Time t, const Array& x) const {
         #if defined(QL_EXTRA_SAFETY_CHECKS)
         QL_REQUIRE(x.size() == 1, "1-D array required");
         #endif
@@ -268,7 +267,7 @@ namespace QuantLib {
         return m;
     }
 
-    inline Disposable<Array> StochasticProcess1D::expectation(
+    inline Array StochasticProcess1D::expectation(
                                     Time t0, const Array& x0, Time dt) const {
         #if defined(QL_EXTRA_SAFETY_CHECKS)
         QL_REQUIRE(x0.size() == 1, "1-D array required");
@@ -277,7 +276,7 @@ namespace QuantLib {
         return a;
     }
 
-    inline Disposable<Matrix> StochasticProcess1D::stdDeviation(
+    inline Matrix StochasticProcess1D::stdDeviation(
                                     Time t0, const Array& x0, Time dt) const {
         #if defined(QL_EXTRA_SAFETY_CHECKS)
         QL_REQUIRE(x0.size() == 1, "1-D array required");
@@ -286,7 +285,7 @@ namespace QuantLib {
         return m;
     }
 
-    inline Disposable<Matrix> StochasticProcess1D::covariance(
+    inline Matrix StochasticProcess1D::covariance(
                                     Time t0, const Array& x0, Time dt) const {
         #if defined(QL_EXTRA_SAFETY_CHECKS)
         QL_REQUIRE(x0.size() == 1, "1-D array required");
@@ -295,8 +294,7 @@ namespace QuantLib {
         return m;
     }
 
-    inline Disposable<Array> StochasticProcess1D::evolve(
-                                             Time t0, const Array& x0,
+    inline Array StochasticProcess1D::evolve(Time t0, const Array& x0,
                                              Time dt, const Array& dw) const {
         #if defined(QL_EXTRA_SAFETY_CHECKS)
         QL_REQUIRE(x0.size() == 1, "1-D array required");
@@ -306,9 +304,8 @@ namespace QuantLib {
         return a;
     }
 
-    inline Disposable<Array> StochasticProcess1D::apply(
-                                                      const Array& x0,
-                                                      const Array& dx) const {
+    inline Array StochasticProcess1D::apply(const Array& x0,
+                                            const Array& dx) const {
         #if defined(QL_EXTRA_SAFETY_CHECKS)
         QL_REQUIRE(x0.size() == 1, "1-D array required");
         QL_REQUIRE(dx.size() == 1, "1-D array required");
diff --git a/ql/termstructures/globalbootstrap.hpp b/ql/termstructures/globalbootstrap.hpp
index 822c19b40cd..d5be6bdb12f 100644
--- a/ql/termstructures/globalbootstrap.hpp
+++ b/ql/termstructures/globalbootstrap.hpp
@@ -267,7 +267,7 @@ template <class Curve> void GlobalBootstrap<Curve>::calculate() const {
             return std::sqrt(std::accumulate(v.begin(), v.end(), 0.0) / static_cast<Real>(v.size()));
         }
 
-        Disposable<Array> values(const Array& x) const override {
+        Array values(const Array& x) const override {
             for (Size i = 0; i < x.size(); ++i) {
                 Traits::updateGuess(ts_->data_, transformDirect(x[i], i), i + 1);
             }
@@ -284,8 +284,7 @@ template <class Curve> void GlobalBootstrap<Curve>::calculate() const {
                     result[numberHelpers_ + i] = tmp[i];
                 }
             }
-            Array asArray(result.begin(), result.end());
-            return asArray;
+            return Array(result.begin(), result.end());
         }
 
       private:
diff --git a/ql/termstructures/localbootstrap.hpp b/ql/termstructures/localbootstrap.hpp
index ec6cccc9cfe..ca3c445377a 100644
--- a/ql/termstructures/localbootstrap.hpp
+++ b/ql/termstructures/localbootstrap.hpp
@@ -53,7 +53,7 @@ namespace QuantLib {
           rateHelpersStart_(rateHelpersStart), rateHelpersEnd_(rateHelpersEnd) {}
 
         Real value(const Array& x) const override;
-        Disposable<Array> values(const Array& x) const override;
+        Array values(const Array& x) const override;
 
       private:
         Curve* curve_;
@@ -272,7 +272,7 @@ namespace QuantLib {
     }
 
     template <class Curve>
-    Disposable<Array> PenaltyFunction<Curve>::values(const Array& x) const {
+    Array PenaltyFunction<Curve>::values(const Array& x) const {
         Array::const_iterator guessIt = x.begin();
         Size i = initialIndex_;
         while (guessIt != x.end()) {
diff --git a/ql/termstructures/volatility/abcdcalibration.cpp b/ql/termstructures/volatility/abcdcalibration.cpp
index ab8c8fd2df1..09387004ffe 100644
--- a/ql/termstructures/volatility/abcdcalibration.cpp
+++ b/ql/termstructures/volatility/abcdcalibration.cpp
@@ -197,7 +197,7 @@ namespace QuantLib {
     }
 
     // calculate weighted differences
-    Disposable<Array> AbcdCalibration::errors() const {
+    Array AbcdCalibration::errors() const {
         Array results(times_.size());
         for (Size i=0; i<times_.size() ; i++) {
             results[i] = (value(times_[i]) - blackVols_[i])* std::sqrt(weights_[i]);
diff --git a/ql/termstructures/volatility/abcdcalibration.hpp b/ql/termstructures/volatility/abcdcalibration.hpp
index c9960cdf7b1..54aa534e9e9 100644
--- a/ql/termstructures/volatility/abcdcalibration.hpp
+++ b/ql/termstructures/volatility/abcdcalibration.hpp
@@ -53,7 +53,7 @@ namespace QuantLib {
                 abcd_->d_ = y[3];
                 return abcd_->error();
             }
-            Disposable<Array> values(const Array& x) const override {
+            Array values(const Array& x) const override {
                 const Array y = abcd_->transformation_->direct(x);
                 abcd_->a_ = y[0];
                 abcd_->b_ = y[1];
@@ -103,7 +103,7 @@ namespace QuantLib {
         Real value(Real x) const;
         Real error() const;
         Real maxError() const;
-        Disposable<Array> errors() const;
+        Array errors() const;
         EndCriteria::Type endCriteria() const;
         Real a() const { return a_; }
         Real b() const { return b_; }
diff --git a/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp b/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp
index c5b4a3369b4..d2aebc88d2f 100644
--- a/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp
+++ b/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp
@@ -72,12 +72,11 @@ namespace QuantLib {
           d2CdK2_(dxMap_.mult(Array(mesher->layout()->size(), -1.0)).add(dxxMap_)),
           mapT_(0, mesher_) {}
 
-        Disposable<Array> d2CdK2(const Array& c) const {
+        Array d2CdK2(const Array& c) const {
             return d2CdK2_.apply(c);
         }
 
-        Disposable<Array> solveFor(
-            Time dT, const Array& sig, const Array& b) const {
+        Array solveFor(Time dT, const Array& sig, const Array& b) const {
 
             Array x(lnMarketStrikes_.size());
             Interpolation sigInterpl;
@@ -127,11 +126,11 @@ namespace QuantLib {
 
         }
 
-        Disposable<Array> apply(const Array& c) const {
+        Array apply(const Array& c) const {
             return -mapT_.apply(c);
         }
 
-        Disposable<Array> values(const Array& sig) const override {
+        Array values(const Array& sig) const override {
             Array newNPVs = solveFor(dT_, sig, previousNPVs_);
 
             const std::vector<Real>& gridPoints =
@@ -148,13 +147,12 @@ namespace QuantLib {
             return retVal;
         }
 
-        Disposable<Array> vegaCalibrationError(const Array& sig) const {
+        Array vegaCalibrationError(const Array& sig) const {
             return values(sig)/marketVegas_;
         }
 
-        Disposable<Array> initialValues() const {
-            Array retVal(lnMarketStrikes_.size(), 0.25);
-            return retVal;
+        Array initialValues() const {
+            return Array(lnMarketStrikes_.size(), 0.25);
         }
 
 
@@ -179,7 +177,7 @@ namespace QuantLib {
                              ext::shared_ptr<AndreasenHugeCostFunction> callCostFct)
         : putCostFct_(std::move(putCostFct)), callCostFct_(std::move(callCostFct)) {}
 
-        Disposable<Array> values(const Array& sig) const override {
+        Array values(const Array& sig) const override {
             if ((putCostFct_ != nullptr) && (callCostFct_ != nullptr)) {
                 const Array pv = putCostFct_->values(sig);
                 const Array cv = callCostFct_->values(sig);
@@ -197,7 +195,7 @@ namespace QuantLib {
                 QL_FAIL("internal error: cost function not set");
         }
 
-        Disposable<Array> initialValues() const {
+        Array initialValues() const {
             if ((putCostFct_ != nullptr) && (callCostFct_ != nullptr))
                 return 0.5*(  putCostFct_->initialValues()
                             + callCostFct_->initialValues());
@@ -501,7 +499,7 @@ namespace QuantLib {
         return (*(ext::get<2>(f->second)))(s);
     }
 
-    Disposable<Array> AndreasenHugeVolatilityInterpl::getPriceSlice(
+    Array AndreasenHugeVolatilityInterpl::getPriceSlice(
         Time t, Option::Type optionType) const {
 
         const Size iu = getExerciseTimeIdx(t);
@@ -563,7 +561,7 @@ namespace QuantLib {
         return this->optionPrice(t, strike, optionType);
     }
 
-    Disposable<Array> AndreasenHugeVolatilityInterpl::getLocalVolSlice(
+    Array AndreasenHugeVolatilityInterpl::getLocalVolSlice(
         Time t, Option::Type optionType) const {
 
         const Size iu = getExerciseTimeIdx(t);
diff --git a/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.hpp b/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.hpp
index ab8f8f8e829..7c608fd831e 100644
--- a/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.hpp
+++ b/ql/termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.hpp
@@ -116,11 +116,9 @@ namespace QuantLib {
         Real getCacheValue(
             Real strike, const TimeValueCacheType::const_iterator& f) const;
 
-        Disposable<Array>
-            getPriceSlice(Time t, Option::Type optionType) const;
+        Array getPriceSlice(Time t, Option::Type optionType) const;
 
-        Disposable<Array>
-            getLocalVolSlice(Time t, Option::Type optionType) const;
+        Array getLocalVolSlice(Time t, Option::Type optionType) const;
 
         CalibrationSet calibrationSet_;
         const Handle<Quote> spot_;
diff --git a/ql/termstructures/volatility/smilesectionutils.hpp b/ql/termstructures/volatility/smilesectionutils.hpp
index 6318300d7f8..c121b629471 100644
--- a/ql/termstructures/volatility/smilesectionutils.hpp
+++ b/ql/termstructures/volatility/smilesectionutils.hpp
@@ -25,7 +25,6 @@
 #define quantlib_smile_section_utils_hpp
 
 #include <ql/termstructures/volatility/smilesection.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <vector>
 
 namespace QuantLib {
diff --git a/ql/termstructures/volatility/swaption/cmsmarket.cpp b/ql/termstructures/volatility/swaption/cmsmarket.cpp
index dafc93974bd..eaec5fe9c2f 100644
--- a/ql/termstructures/volatility/swaption/cmsmarket.cpp
+++ b/ql/termstructures/volatility/swaption/cmsmarket.cpp
@@ -188,17 +188,17 @@ namespace QuantLib {
 
     // array of errors to be used by Levenberg-Marquardt optimization
 
-    Disposable<Array> CmsMarket::weightedFwdNpvErrors(const Matrix& w) {
+    Array CmsMarket::weightedFwdNpvErrors(const Matrix& w) {
         performCalculations();
         return weightedMeans(errFwdCmsLegNPV_, w);
     }
 
-    Disposable<Array> CmsMarket::weightedSpotNpvErrors(const Matrix& w) {
+    Array CmsMarket::weightedSpotNpvErrors(const Matrix& w) {
         performCalculations();
         return weightedMeans(errSpotCmsLegNPV_, w);
     }
 
-    Disposable<Array> CmsMarket::weightedSpreadErrors(const Matrix& w) {
+    Array CmsMarket::weightedSpreadErrors(const Matrix& w) {
         performCalculations();
         return weightedMeans(errSpreads_, w);
     }
@@ -214,7 +214,7 @@ namespace QuantLib {
         return mean;
     }
 
-    Disposable<Array> CmsMarket::weightedMeans(const Matrix& var, const Matrix& w) const {
+    Array CmsMarket::weightedMeans(const Matrix& var, const Matrix& w) const {
         Array weightedVars(nExercise_*nSwapIndexes_);
         for (Size i=0; i<nExercise_; ++i) {
             for (Size j=0; j<nSwapIndexes_; ++j) {
diff --git a/ql/termstructures/volatility/swaption/cmsmarket.hpp b/ql/termstructures/volatility/swaption/cmsmarket.hpp
index 259158fc407..875a7b25c7d 100644
--- a/ql/termstructures/volatility/swaption/cmsmarket.hpp
+++ b/ql/termstructures/volatility/swaption/cmsmarket.hpp
@@ -65,14 +65,14 @@ namespace QuantLib {
         Real weightedSpreadError(const Matrix& weights);
         Real weightedSpotNpvError(const Matrix& weights);
         Real weightedFwdNpvError(const Matrix& weights);
-        Disposable<Array> weightedSpreadErrors(const Matrix& weights);
-        Disposable<Array> weightedSpotNpvErrors(const Matrix& weights);
-        Disposable<Array> weightedFwdNpvErrors(const Matrix& weights);
+        Array weightedSpreadErrors(const Matrix& weights);
+        Array weightedSpotNpvErrors(const Matrix& weights);
+        Array weightedFwdNpvErrors(const Matrix& weights);
 
       private:
         void performCalculations() const override;
         Real weightedMean(const Matrix& var, const Matrix& weights) const;
-        Disposable<Array> weightedMeans(const Matrix& var, const Matrix& weights) const;
+        Array weightedMeans(const Matrix& var, const Matrix& weights) const;
 
         std::vector<Period> swapLengths_;
         std::vector<ext::shared_ptr<SwapIndex> > swapIndexes_;
diff --git a/ql/termstructures/volatility/swaption/cmsmarketcalibration.cpp b/ql/termstructures/volatility/swaption/cmsmarketcalibration.cpp
index 62aa55bfb67..0149ac5648f 100644
--- a/ql/termstructures/volatility/swaption/cmsmarketcalibration.cpp
+++ b/ql/termstructures/volatility/swaption/cmsmarketcalibration.cpp
@@ -37,11 +37,11 @@ namespace {
               calibrationType_(smileAndCms->calibrationType_) {};
 
         Real value(const Array& x) const override;
-        Disposable<Array> values(const Array& x) const override;
+        Array values(const Array& x) const override;
 
       protected:
         Real switchErrorFunctionOnCalibrationType() const;
-        Disposable<Array> switchErrorsFunctionOnCalibrationType() const;
+        Array switchErrorsFunctionOnCalibrationType() const;
 
         CmsMarketCalibration *smileAndCms_;
         Handle<SwaptionVolatilityStructure> volCube_;
@@ -116,7 +116,7 @@ namespace {
         return switchErrorFunctionOnCalibrationType();
     }
 
-    Disposable<Array> ObjectiveFunction::values(const Array &x) const {
+    Array ObjectiveFunction::values(const Array &x) const {
         updateVolatilityCubeAndCmsMarket(x);
         return switchErrorsFunctionOnCalibrationType();
     }
@@ -150,8 +150,7 @@ namespace {
         }
     }
 
-    Disposable<Array>
-    ObjectiveFunction::switchErrorsFunctionOnCalibrationType() const {
+    Array ObjectiveFunction::switchErrorsFunctionOnCalibrationType() const {
         switch (calibrationType_) {
         case CmsMarketCalibration::OnSpread:
             return cmsMarket_->weightedSpreadErrors(weights_);
diff --git a/ql/termstructures/volatility/swaption/swaptionvolcube1.hpp b/ql/termstructures/volatility/swaption/swaptionvolcube1.hpp
index 510c7d2e412..387f46c9a07 100644
--- a/ql/termstructures/volatility/swaption/swaptionvolcube1.hpp
+++ b/ql/termstructures/volatility/swaption/swaptionvolcube1.hpp
@@ -102,7 +102,7 @@ namespace QuantLib {
             std::vector<Period> swapTenors_;
             Size nLayers_;
             std::vector<Matrix> points_;
-            mutable std::vector<Disposable<Matrix> > transposedPoints_;
+            mutable std::vector<Matrix> transposedPoints_;
             bool extrapolation_;
             bool backwardFlat_;
             mutable std::vector< ext::shared_ptr<Interpolation2D> > interpolators_;
diff --git a/ql/termstructures/yield/fittedbonddiscountcurve.cpp b/ql/termstructures/yield/fittedbonddiscountcurve.cpp
index 27cb6f451c2..d761b9b0b08 100644
--- a/ql/termstructures/yield/fittedbonddiscountcurve.cpp
+++ b/ql/termstructures/yield/fittedbonddiscountcurve.cpp
@@ -39,7 +39,7 @@ namespace QuantLib {
         explicit FittingCost(
                        FittedBondDiscountCurve::FittingMethod* fittingMethod);
         Real value(const Array& x) const override;
-        Disposable<Array> values(const Array& x) const override;
+        Array values(const Array& x) const override;
 
       private:
         FittedBondDiscountCurve::FittingMethod* fittingMethod_;
@@ -248,9 +248,7 @@ namespace QuantLib {
         return squaredError;
     }
 
-    Disposable<Array>
-    FittedBondDiscountCurve::FittingMethod::FittingCost::values(
-                                                       const Array &x) const {
+    Array FittedBondDiscountCurve::FittingMethod::FittingCost::values(const Array &x) const {
         Size n = fittingMethod_->curve_->bondHelpers_.size();
         Size N = fittingMethod_->l2_.size();
 
diff --git a/ql/userconfig.hpp b/ql/userconfig.hpp
index 6b4a7d3da1b..aa75f87c4dc 100644
--- a/ql/userconfig.hpp
+++ b/ql/userconfig.hpp
@@ -106,13 +106,6 @@
 //#    define QL_USE_STD_TUPLE
 #endif
 
-/* Define this if you want to use the Disposable class template.
-   This should be no longer necessary in C++11
-   and might interfere with compiler optimizations. */
-#ifndef QL_USE_DISPOSABLE
-//#    define QL_USE_DISPOSABLE
-#endif
-
 /* Define this to enable the parallel unit test runner */
 #ifndef QL_ENABLE_PARALLEL_UNIT_TEST_RUNNER
 //#    define QL_ENABLE_PARALLEL_UNIT_TEST_RUNNER
diff --git a/ql/utilities/Makefile.am b/ql/utilities/Makefile.am
index e7e65a7ef41..a1247661143 100644
--- a/ql/utilities/Makefile.am
+++ b/ql/utilities/Makefile.am
@@ -46,7 +46,7 @@ all.hpp: Makefile.am
 	echo "/* This file is automatically generated; do not edit.     */" > ${srcdir}/$@
 	echo "/* Add the files to be included into Makefile.am instead. */" >> ${srcdir}/$@
 	echo >> ${srcdir}/$@
-	for i in $(filter-out all.hpp, $(this_include_HEADERS)); do \
+	for i in $(filter-out all.hpp disposable.hpp, $(this_include_HEADERS)); do \
 		echo "#include <${subdir}/$$i>" >> ${srcdir}/$@; \
 	done
 	echo >> ${srcdir}/$@
diff --git a/ql/utilities/all.hpp b/ql/utilities/all.hpp
index 4c77361ea8e..13bb3116098 100644
--- a/ql/utilities/all.hpp
+++ b/ql/utilities/all.hpp
@@ -4,7 +4,6 @@
 #include <ql/utilities/clone.hpp>
 #include <ql/utilities/dataformatters.hpp>
 #include <ql/utilities/dataparsers.hpp>
-#include <ql/utilities/disposable.hpp>
 #include <ql/utilities/null.hpp>
 #include <ql/utilities/null_deleter.hpp>
 #include <ql/utilities/observablevalue.hpp>
diff --git a/ql/utilities/disposable.hpp b/ql/utilities/disposable.hpp
index ad300476fa5..023e4ae5a9f 100644
--- a/ql/utilities/disposable.hpp
+++ b/ql/utilities/disposable.hpp
@@ -17,10 +17,6 @@
  FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
-/*! \file disposable.hpp
-    \brief generic disposable object with move semantics
-*/
-
 #ifndef quantlib_disposable_hpp
 #define quantlib_disposable_hpp
 
@@ -28,79 +24,13 @@
 
 namespace QuantLib {
 
-    #ifndef QL_USE_DISPOSABLE
+    // Deprecated in version 1.27
+    #pragma message("Warning: the deprecated Disposable<T> class is no longer used. Replace it with T.")
+    #pragma message("    This file will disappear in a future release; do not include it.")
 
     template <class T>
     using Disposable = T;
 
-    #else
-
-    #pragma message("Warning: enabling the old Disposable class template is deprecated.")
-    #pragma message("    If you're using --enable-disposable in your build")
-    #pragma message("    or if you defined QL_USE_DISPOSABLE in ql/userconfig.hpp,")
-    #pragma message("    please restore the default compilation options in the near future.")
-
-    //! generic disposable object with move semantics
-    /*! This class can be used for returning a value by copy. It relies
-        on the returned object exposing a <tt>swap(T\&)</tt> method through
-        which the copy constructor and assignment operator are implemented,
-        thus resulting in actual move semantics. Typical use of this
-        class is along the following lines:
-        \code
-        Disposable<Foo> bar(Integer i) {
-            Foo f(i*2);
-            return f;
-        }
-        \endcode
-
-        \warning In order to avoid copies in code such as shown above,
-                 the conversion from <tt>T</tt> to <tt>Disposable\<T\></tt>
-                 is destructive, i.e., it does <b>not</b> preserve the
-                 state of the original object. Therefore, it is necessary
-                 for the developer to avoid code such as
-        \code
-        Disposable<Foo> bar(Foo& f) {
-            return f;
-        }
-        \endcode
-                 which would likely render the passed object unusable.
-                 The correct way to obtain the desired behavior would be:
-        \code
-        Disposable<Foo> bar(Foo& f) {
-            Foo temp = f;
-            return temp;
-        }
-        \endcode
-    */
-    template <class T>
-    class Disposable : public T {
-      public:
-        Disposable(T& t);
-        Disposable(const Disposable<T>& t);
-        Disposable<T>& operator=(const Disposable<T>& t);
-    };
-
-
-    // inline definitions
-
-    template <class T>
-    inline Disposable<T>::Disposable(T& t) {
-        this->swap(t);
-    }
-
-    template <class T>
-    inline Disposable<T>::Disposable(const Disposable<T>& t) : T() {
-        this->swap(const_cast<Disposable<T>&>(t));
-    }
-
-    template <class T>
-    inline Disposable<T>& Disposable<T>::operator=(const Disposable<T>& t) {
-        this->swap(const_cast<Disposable<T>&>(t));
-        return *this;
-    }
-
-    #endif
-
 }
 
 
diff --git a/test-suite/array.cpp b/test-suite/array.cpp
index 8c789a707df..ab933e083fc 100644
--- a/test-suite/array.cpp
+++ b/test-suite/array.cpp
@@ -101,72 +101,6 @@ void ArrayTest::testConstruction() {
                         << "\n    copy:      " << a6[i]);
     }
 
-    #ifdef QL_USE_DISPOSABLE
-
-    // creation of disposable array
-    Array temp1(size, value);
-    Disposable<Array> temp2(temp1);
-    if (temp2.size() != size || !temp1.empty())
-        BOOST_ERROR("array not correctly moved into disposable array"
-                    << "\n    original size of source: " << size
-                    << "\n    current size of source:  " << temp1.size()
-                    << "\n    current size of target:  " << temp2.size());
-    for (i=0; i<size; i++) {
-        if (temp2[i] != value)
-            BOOST_ERROR(io::ordinal(i+1) << " element of disposable "
-                        "not moved correctly"
-                        << "\n    required:  " << value
-                        << "\n    resulting: " << temp2[i]);
-    }
-
-    // copy constructor from disposable
-    Array a7(temp2);
-    if (a7.size() != size || !temp2.empty())
-        BOOST_ERROR("disposable array not correctly moved into array"
-                    << "\n    original size of source: " << size
-                    << "\n    current size of source:  " << temp2.size()
-                    << "\n    current size of target:  " << a7.size());
-    for (i=0; i<size; i++) {
-        if (a7[i] != value)
-            BOOST_ERROR(io::ordinal(i+1) << " element not moved correctly"
-                        << "\n    required:  " << value
-                        << "\n    resulting: " << a7[i]);
-    }
-
-    // assignment
-    Array a8;
-    a8 = a7;
-    if (a8.size() != a7.size())
-        BOOST_ERROR("copy not of the same size as original"
-                    << "\n    original:  " << a7.size()
-                    << "\n    copy:      " << a8.size());
-    for (i=0; i<a7.size(); i++) {
-        if (a8[i] != a7[i])
-            BOOST_ERROR(io::ordinal(i+1) << " element of copy "
-                        "not with same value as original"
-                        << "\n    original:  " << a7[i]
-                        << "\n    copy:      " << a8[i]);
-    }
-
-    // assignment from disposable
-    Array temp3(size, value);
-    Disposable<Array> temp4(temp3);
-    Array a9;
-    a9 = temp4;
-    if (a9.size() != size || !temp4.empty())
-        BOOST_ERROR("disposable array not correctly moved into array"
-                    << "\n    original size of source: " << size
-                    << "\n    current size of source:  " << temp4.size()
-                    << "\n    current size of target:  " << a9.size());
-    for (i=0; i<size; i++) {
-        if (a9[i] != value)
-            BOOST_ERROR(io::ordinal(i+1) << " element not moved correctly"
-                        << "\n    required:  " << value
-                        << "\n    resulting: " << a9[i]);
-    }
-
-    #endif
-
     // transform
     Array a10(5);
     for (i=0; i < a10.size(); i++) {
diff --git a/test-suite/fdmlinearop.cpp b/test-suite/fdmlinearop.cpp
index 1e216c9d58f..534d5919ba0 100644
--- a/test-suite/fdmlinearop.cpp
+++ b/test-suite/fdmlinearop.cpp
@@ -1202,16 +1202,14 @@ void FdmLinearOpTest::testFdmHestonHullWhiteOp() {
 }
 
 namespace {
-    Disposable<Array> axpy(
-        const boost::numeric::ublas::compressed_matrix<Real>& A,
-        const Array& x) {
+    Array axpy(const boost::numeric::ublas::compressed_matrix<Real>& A,
+               const Array& x) {
         
         boost::numeric::ublas::vector<Real> tmpX(x.size()), y(x.size());
         std::copy(x.begin(), x.end(), tmpX.begin());
         boost::numeric::ublas::axpy_prod(A, tmpX, y);
 
-        Array retVal(y.begin(), y.end());
-        return retVal;
+        return Array(y.begin(), y.end());
     }
 
     boost::numeric::ublas::compressed_matrix<Real> createTestMatrix(
@@ -1252,11 +1250,11 @@ void FdmLinearOpTest::testBiCGstab() {
     const boost::numeric::ublas::compressed_matrix<Real> a
         = createTestMatrix(n, m, theta);
 
-    const ext::function<Disposable<Array>(const Array&)> matmult
+    const ext::function<Array(const Array&)> matmult
         = [&](const Array& _x) { return axpy(a, _x); };
 
     SparseILUPreconditioner ilu(a, 4);
-    ext::function<Disposable<Array>(const Array&)> precond
+    ext::function<Array(const Array&)> precond
         = [&](const Array& _x) { return ilu.apply(_x); };
 
     Array b(n*m);
@@ -1288,11 +1286,11 @@ void FdmLinearOpTest::testGMRES() {
     const boost::numeric::ublas::compressed_matrix<Real> a
         = createTestMatrix(n, m, theta);
 
-    const ext::function<Disposable<Array>(const Array&)> matmult
+    const ext::function<Array(const Array&)> matmult
         = [&](const Array& _x) { return axpy(a, _x); };
     
     SparseILUPreconditioner ilu(a, 4);
-    ext::function<Disposable<Array>(const Array&)> precond
+    ext::function<Array(const Array&)> precond
         = [&](const Array& _x) { return ilu.apply(_x); };
     
     Array b(n*m);
diff --git a/test-suite/markovfunctional.cpp b/test-suite/markovfunctional.cpp
index 96a879961d6..c76a765b55a 100644
--- a/test-suite/markovfunctional.cpp
+++ b/test-suite/markovfunctional.cpp
@@ -549,7 +549,7 @@ namespace {
 
     // Calibration Basket 1: CMS10y Swaptions, 5 yearly fixings
 
-    Disposable<std::vector<Date> > expiriesCalBasket1() {
+    std::vector<Date> expiriesCalBasket1() {
 
         std::vector<Date> res;
         Date referenceDate_ = Settings::instance().evaluationDate();
@@ -560,7 +560,7 @@ namespace {
         return res;
     }
 
-    Disposable<std::vector<Period> > tenorsCalBasket1() {
+    std::vector<Period> tenorsCalBasket1() {
 
         std::vector<Period> res(5, 10 * Years);
 
@@ -569,7 +569,7 @@ namespace {
 
     // Calibration Basket 2: 6m caplets, 5 years
 
-    Disposable<std::vector<Date> > expiriesCalBasket2() {
+    std::vector<Date> expiriesCalBasket2() {
 
         Date referenceDate_ = Settings::instance().evaluationDate();
 
@@ -591,7 +591,7 @@ namespace {
 
     // Calibration Basket 3: Coterminal Swaptions 10y
 
-    Disposable<std::vector<Date> > expiriesCalBasket3() {
+    std::vector<Date> expiriesCalBasket3() {
 
         Date referenceDate_ = Settings::instance().evaluationDate();
 
@@ -610,16 +610,15 @@ namespace {
         return res;
     }
 
-    Disposable<std::vector<Period> > tenorsCalBasket3() {
+    std::vector<Period> tenorsCalBasket3() {
 
         std::vector<Period> res = {9 * Years, 8 * Years, 7 * Years, 6 * Years, 5 * Years,
                                    4 * Years, 3 * Years, 2 * Years, 1 * Years};
         return res;
     }
 
-    Disposable<std::vector<Real> >
-    impliedStdDevs(const Real atm, const std::vector<Real> &strikes,
-                   const std::vector<Real> &prices) {
+    std::vector<Real> impliedStdDevs(const Real atm, const std::vector<Real> &strikes,
+                                     const std::vector<Real> &prices) {
 
         std::vector<Real> result;
 
diff --git a/test-suite/matrices.cpp b/test-suite/matrices.cpp
index 8c3696fc921..1bbda4dbe11 100644
--- a/test-suite/matrices.cpp
+++ b/test-suite/matrices.cpp
@@ -624,9 +624,8 @@ namespace matrices_test {
     class MatrixMult {
       public:
         explicit MatrixMult(Matrix m) : m_(std::move(m)) {}
-        Disposable<Array> operator()(const Array& x) const {
-            Array retVal = m_*x;
-            return retVal;
+        Array operator()(const Array& x) const {
+            return m_ * x;
         }
 
       private:
diff --git a/test-suite/nthorderderivativeop.cpp b/test-suite/nthorderderivativeop.cpp
index bf7ed945af1..39bc7be875b 100644
--- a/test-suite/nthorderderivativeop.cpp
+++ b/test-suite/nthorderderivativeop.cpp
@@ -458,38 +458,35 @@ namespace {
                     theta*identity_matrix<Real>(n) - u, dv);
         }
 
-        Disposable<SparseMatrix> toMatrix() const override {
-            SparseMatrix tmp(map_);
-            return tmp;
+        SparseMatrix toMatrix() const override {
+            return map_;
         }
 
         Size size() const override { return 2; }
         void setTime(Time t1, Time t2) override { }
 
-        Disposable<Array> apply(const Array& r) const override {
+        Array apply(const Array& r) const override {
             return prod(map_, r);
         }
 
-        Disposable<Array> apply_mixed(const Array& r) const override {
+        Array apply_mixed(const Array& r) const override {
             QL_FAIL("operator splitting is not supported");
         }
 
-        Disposable<Array> apply_direction(
-            Size direction, const Array& r) const override {
+        Array apply_direction(Size direction, const Array& r) const override {
             QL_FAIL("operator splitting is not supported");
         }
 
-        Disposable<Array> solve_splitting(
-            Size direction, const Array& r, Real dt) const override {
+        Array solve_splitting(Size direction, const Array& r, Real dt) const override {
             QL_FAIL("operator splitting is not supported");
         }
 
-        Disposable<Array> preconditioner(const Array& r, Real dt) const override {
+        Array preconditioner(const Array& r, Real dt) const override {
             return preconditioner_.solve_splitting(r, dt, 1.0);
         }
 
       private:
-        Disposable<Array> solve_apply(const Array& r, Real dt) const {
+        Array solve_apply(const Array& r, Real dt) const {
             return r - dt*apply(r);
         }
 
@@ -548,7 +545,7 @@ namespace {
         const Size direction_;
     };
 
-    Disposable<Array> priceReport(
+    Array priceReport(
         const GridSetup& setup, const Array& strikes) {
 
         const Date today(2, May, 2018);
@@ -704,7 +701,7 @@ namespace {
             const GridSetup& setup, Array strikes)
         : setup_(setup), strikes_(std::move(strikes)) { }
 
-        Disposable<Array> values(const Array& x) const override {
+        Array values(const Array& x) const override {
             const GridSetup g = {
                 x[0], x[1],
                 setup_.cellAvg, setup_.midPoint,
diff --git a/test-suite/numericaldifferentiation.cpp b/test-suite/numericaldifferentiation.cpp
index 1fd8e8cf166..afbecd7e319 100644
--- a/test-suite/numericaldifferentiation.cpp
+++ b/test-suite/numericaldifferentiation.cpp
@@ -253,7 +253,7 @@ void NumericalDifferentiationTest::testDerivativesOfSineFunction() {
 }
 
 namespace {
-    Disposable<Array> vandermondeCoefficients(
+    Array vandermondeCoefficients(
         Size order, Real x, const Array& gridPoints) {
 
         const Array q = gridPoints - x;
diff --git a/test-suite/ode.cpp b/test-suite/ode.cpp
index 74c41668658..79038de0d2b 100644
--- a/test-suite/ode.cpp
+++ b/test-suite/ode.cpp
@@ -44,8 +44,7 @@ namespace {
     };
 
     struct ode3 {
-        Disposable<std::vector<Real> > operator()(Real x,
-                                                  const std::vector<Real>& y) {
+        std::vector<Real> operator()(Real x, const std::vector<Real>& y) {
             std::vector<Real> r(2);
             r[0] = y[1]; r[1] = -y[0];
             return r;
@@ -53,7 +52,7 @@ namespace {
     };
 
     struct ode4 {
-        Disposable<std::vector<std::complex<Real> > > operator()(
+        std::vector<std::complex<Real> > operator()(
                                   const std::complex<Real>& x,
                                   const std::vector<std::complex<Real> >& y) {
             std::vector<std::complex<Real> > r(2);
diff --git a/test-suite/optimizers.cpp b/test-suite/optimizers.cpp
index 10bdf99b174..f1e53f51875 100644
--- a/test-suite/optimizers.cpp
+++ b/test-suite/optimizers.cpp
@@ -67,11 +67,9 @@ namespace {
             return y;
         }
 
-        Disposable<Array> values(const Array& x) const override {
+        Array values(const Array& x) const override {
             QL_REQUIRE(x.size()==1,"independent variable must be 1 dimensional");
-            Array y(1);
-            y[0] = value(x);
-            return y;
+            return Array(1, value(x));
         }
 
       private:
@@ -86,7 +84,7 @@ namespace {
       public:
         Real value(const Array&) const override { return 1.0; }
 
-        Disposable<Array> values(const Array&) const override {
+        Array values(const Array&) const override {
             // dummy nested optimization
             Array coefficients(3, 1.0);
             OneDimensionalPolynomialDegreeN oneDimensionalPolynomialDegreeN(coefficients);
@@ -101,8 +99,7 @@ namespace {
             EndCriteria endCriteria(1000, 100, 1e-5, 1e-5, 1e-5);
             optimizationMethod.minimize(problem, endCriteria);
             // return dummy result
-            Array dummy(1,0);
-            return dummy;
+            return Array(1, 0);
         }
     };
 
@@ -369,18 +366,16 @@ namespace {
 
     class FirstDeJong : public CostFunction {
       public:
-        Disposable<Array> values(const Array& x) const override {
-            Array retVal(x.size(),value(x));
-            return retVal;
+        Array values(const Array& x) const override {
+            return Array(x.size(),value(x));
         }
         Real value(const Array& x) const override { return DotProduct(x, x); }
     };
 
     class SecondDeJong : public CostFunction {
       public:
-        Disposable<Array> values(const Array& x) const override {
-            Array retVal(x.size(),value(x));
-            return retVal;
+        Array values(const Array& x) const override {
+            return Array(x.size(),value(x));
         }
         Real value(const Array& x) const override {
             return  100.0*(x[0]*x[0]-x[1])*(x[0]*x[0]-x[1])
@@ -390,9 +385,8 @@ namespace {
 
     class ModThirdDeJong : public CostFunction {
       public:
-        Disposable<Array> values(const Array& x) const override {
-            Array retVal(x.size(),value(x));
-            return retVal;
+        Array values(const Array& x) const override {
+            return Array(x.size(),value(x));
         }
         Real value(const Array& x) const override {
             Real fx = 0.0;
@@ -408,9 +402,8 @@ namespace {
         ModFourthDeJong()
         : uniformRng_(MersenneTwisterUniformRng(4711)) {
         }
-        Disposable<Array> values(const Array& x) const override {
-            Array retVal(x.size(),value(x));
-            return retVal;
+        Array values(const Array& x) const override {
+            return Array(x.size(),value(x));
         }
         Real value(const Array& x) const override {
             Real fx = 0.0;
@@ -424,9 +417,8 @@ namespace {
 
     class Griewangk : public CostFunction {
       public:
-        Disposable<Array> values(const Array& x) const override {
-            Array retVal(x.size(),value(x));
-            return retVal;
+        Array values(const Array& x) const override {
+            return Array(x.size(),value(x));
         }
         Real value(const Array& x) const override {
             Real fx = 0.0;
diff --git a/test-suite/riskneutraldensitycalculator.cpp b/test-suite/riskneutraldensitycalculator.cpp
index 05362635838..ed03838331a 100644
--- a/test-suite/riskneutraldensitycalculator.cpp
+++ b/test-suite/riskneutraldensitycalculator.cpp
@@ -266,7 +266,7 @@ namespace {
         const ext::shared_ptr<RiskNeutralDensityCalculator> calc_;
     };
 
-    Disposable<std::vector<Time> > adaptiveTimeGrid(
+    std::vector<Time> adaptiveTimeGrid(
         Size maxStepsPerYear, Size minStepsPerYear, Real decay, Time endTime) {
         const Time maxDt = 1.0/maxStepsPerYear;
         const Time minDt = 1.0/minStepsPerYear;
diff --git a/test-suite/squarerootclvmodel.cpp b/test-suite/squarerootclvmodel.cpp
index 617cdba10b3..053e5636d3b 100644
--- a/test-suite/squarerootclvmodel.cpp
+++ b/test-suite/squarerootclvmodel.cpp
@@ -294,7 +294,7 @@ namespace square_root_clv_model {
             return retVal;
         }
 
-        Disposable<Array> values(const Array& params) const override {
+        Array values(const Array& params) const override {
             const Real theta = params[0];
             const Real kappa = params[1];
             const Real sigma = params[2];