Replace scoped_ptr with C++11's unique_ptr

Change-Id: Ib5a504c491e3a79af52a95accf009df473470c6b

cmake/config.h.in

@@ -69,9 +69,6 @@
 // If defined Ceres was compiled with C++11 thread support.
 @CERES_USE_CXX11_THREADS@
 
-// If defined, the memory header is in <tr1/memory>, otherwise <memory>.
-@CERES_TR1_MEMORY_HEADER@
-
 // If defined, Ceres was built as a shared library.
 @CERES_USING_SHARED_LIBRARY@
 

docs/source/numerical_derivatives.rst

@@ -125,7 +125,7 @@ like the following:
        }
 
      private:
-       scoped_ptr<Rat43Functor> functor_;
+       std::unique_ptr<Rat43Functor> functor_;
    };
 
 

include/ceres/autodiff_cost_function.h

@@ -129,8 +129,8 @@
 #ifndef CERES_PUBLIC_AUTODIFF_COST_FUNCTION_H_
 #define CERES_PUBLIC_AUTODIFF_COST_FUNCTION_H_
 
+#include <memory>
 #include "ceres/internal/autodiff.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/sized_cost_function.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
@@ -219,7 +219,7 @@ class AutoDiffCostFunction : public SizedCostFunction<kNumResiduals,
   }
 
  private:
-  internal::scoped_ptr<CostFunctor> functor_;
+  std::unique_ptr<CostFunctor> functor_;
 };
 
 }  // namespace ceres

include/ceres/autodiff_local_parameterization.h

@@ -33,9 +33,9 @@
 #ifndef CERES_PUBLIC_AUTODIFF_LOCAL_PARAMETERIZATION_H_
 #define CERES_PUBLIC_AUTODIFF_LOCAL_PARAMETERIZATION_H_
 
+#include <memory>
 #include "ceres/local_parameterization.h"
 #include "ceres/internal/autodiff.h"
-#include "ceres/internal/scoped_ptr.h"
 
 namespace ceres {
 
@@ -146,7 +146,7 @@ class AutoDiffLocalParameterization : public LocalParameterization {
   virtual int LocalSize() const { return kLocalSize; }
 
  private:
-  internal::scoped_ptr<Functor> functor_;
+  std::unique_ptr<Functor> functor_;
 };
 
 }  // namespace ceres

include/ceres/conditioned_cost_function.h

@@ -36,8 +36,8 @@
 
 #include <vector>
 
+#include <memory>
 #include "ceres/cost_function.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/types.h"
 #include "ceres/internal/disable_warnings.h"
 
@@ -87,7 +87,7 @@ class CERES_EXPORT ConditionedCostFunction : public CostFunction {
                         double** jacobians) const;
 
  private:
-  internal::scoped_ptr<CostFunction> wrapped_cost_function_;
+  std::unique_ptr<CostFunction> wrapped_cost_function_;
   std::vector<CostFunction*> conditioners_;
   Ownership ownership_;
 };

include/ceres/cost_function_to_functor.h

@@ -94,7 +94,6 @@
 #include "ceres/dynamic_cost_function_to_functor.h"
 #include "ceres/internal/fixed_array.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 
 namespace ceres {
 

include/ceres/covariance.h

@@ -31,11 +31,11 @@
 #ifndef CERES_PUBLIC_COVARIANCE_H_
 #define CERES_PUBLIC_COVARIANCE_H_
 
+#include <memory>
 #include <utility>
 #include <vector>
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/types.h"
 
 namespace ceres {
@@ -457,7 +457,7 @@ class CERES_EXPORT Covariance {
       double* covariance_matrix);
 
  private:
-  internal::scoped_ptr<internal::CovarianceImpl> impl_;
+  std::unique_ptr<internal::CovarianceImpl> impl_;
 };
 
 }  // namespace ceres

include/ceres/dynamic_autodiff_cost_function.h

@@ -36,8 +36,8 @@
 #include <numeric>
 #include <vector>
 
+#include <memory>
 #include "ceres/dynamic_cost_function.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/jet.h"
 #include "glog/logging.h"
 
@@ -244,7 +244,7 @@ class DynamicAutoDiffCostFunction : public DynamicCostFunction {
   }
 
  private:
-  internal::scoped_ptr<CostFunctor> functor_;
+  std::unique_ptr<CostFunctor> functor_;
 };
 
 }  // namespace ceres

include/ceres/dynamic_cost_function_to_functor.h

@@ -32,13 +32,13 @@
 #ifndef CERES_PUBLIC_DYNAMIC_COST_FUNCTION_TO_FUNCTOR_H_
 #define CERES_PUBLIC_DYNAMIC_COST_FUNCTION_TO_FUNCTOR_H_
 
+#include <memory>
 #include <numeric>
 #include <vector>
 
 #include "ceres/dynamic_cost_function.h"
 #include "ceres/internal/fixed_array.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 
 namespace ceres {
 
@@ -182,7 +182,7 @@ class DynamicCostFunctionToFunctor {
   }
 
  private:
-  internal::scoped_ptr<CostFunction> cost_function_;
+  std::unique_ptr<CostFunction> cost_function_;
 };
 
 }  // namespace ceres

include/ceres/dynamic_numeric_diff_cost_function.h

@@ -35,11 +35,11 @@
 #define CERES_PUBLIC_DYNAMIC_NUMERIC_DIFF_COST_FUNCTION_H_
 
 #include <cmath>
+#include <memory>
 #include <numeric>
 #include <vector>
 
 #include "ceres/dynamic_cost_function.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/numeric_diff.h"
 #include "ceres/numeric_diff_options.h"
@@ -170,7 +170,7 @@ class DynamicNumericDiffCostFunction : public DynamicCostFunction {
     return functor->Evaluate(parameters, residuals, NULL);
   }
 
-  internal::scoped_ptr<const CostFunctor> functor_;
+  std::unique_ptr<const CostFunctor> functor_;
   Ownership ownership_;
   NumericDiffOptions options_;
 };

include/ceres/gradient_checker.h

@@ -34,15 +34,15 @@
 #ifndef CERES_PUBLIC_GRADIENT_CHECKER_H_
 #define CERES_PUBLIC_GRADIENT_CHECKER_H_
 
-#include <vector>
+#include <memory>
 #include <string>
+#include <vector>
 
 #include "ceres/cost_function.h"
 #include "ceres/dynamic_numeric_diff_cost_function.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/fixed_array.h"
 #include "ceres/internal/macros.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/local_parameterization.h"
 #include "glog/logging.h"
 
@@ -141,7 +141,7 @@ class CERES_EXPORT GradientChecker {
 
   std::vector<const LocalParameterization*> local_parameterizations_;
   const CostFunction* function_;
-  internal::scoped_ptr<CostFunction> finite_diff_cost_function_;
+  std::unique_ptr<CostFunction> finite_diff_cost_function_;
 };
 
 }  // namespace ceres

include/ceres/gradient_problem.h

@@ -31,9 +31,9 @@
 #ifndef CERES_PUBLIC_GRADIENT_PROBLEM_H_
 #define CERES_PUBLIC_GRADIENT_PROBLEM_H_
 
+#include <memory>
 #include "ceres/internal/macros.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/local_parameterization.h"
 
 namespace ceres {
@@ -105,9 +105,9 @@ class CERES_EXPORT GradientProblem {
   bool Plus(const double* x, const double* delta, double* x_plus_delta) const;
 
  private:
-  internal::scoped_ptr<FirstOrderFunction> function_;
-  internal::scoped_ptr<LocalParameterization> parameterization_;
-  internal::scoped_array<double> scratch_;
+  std::unique_ptr<FirstOrderFunction> function_;
+  std::unique_ptr<LocalParameterization> parameterization_;
+  std::unique_ptr<double[]> scratch_;
 };
 
 // A FirstOrderFunction object implements the evaluation of a function

include/ceres/internal/numeric_diff.h

@@ -41,7 +41,6 @@
 #include "Eigen/StdVector"
 #include "ceres/cost_function.h"
 #include "ceres/internal/fixed_array.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/internal/variadic_evaluate.h"
 #include "ceres/numeric_diff_options.h"
 #include "ceres/types.h"

include/ceres/internal/port.h

@@ -56,12 +56,6 @@
 #  error One of CERES_USE_OPENMP, CERES_USE_TBB,CERES_USE_CXX11_THREADS or CERES_NO_THREADS must be defined.
 #endif
 
-#if defined(CERES_TR1_MEMORY_HEADER)
-#include <tr1/memory>
-#else
-#include <memory>
-#endif
-
 namespace ceres {
 
 // We allocate some Eigen objects on the stack and other places they

include/ceres/internal/scoped_ptr.h

@@ -1,310 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2015 Google Inc. All rights reserved.
-// http://ceres-solver.org/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// * Redistributions of source code must retain the above copyright notice,
-//   this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above copyright notice,
-//   this list of conditions and the following disclaimer in the documentation
-//   and/or other materials provided with the distribution.
-// * Neither the name of Google Inc. nor the names of its contributors may be
-//   used to endorse or promote products derived from this software without
-//   specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: jorg@google.com (Jorg Brown)
-//
-// This is an implementation designed to match the anticipated future TR2
-// implementation of the scoped_ptr class, and its closely-related brethren,
-// scoped_array, scoped_ptr_malloc, and make_scoped_ptr.
-
-#ifndef CERES_PUBLIC_INTERNAL_SCOPED_PTR_H_
-#define CERES_PUBLIC_INTERNAL_SCOPED_PTR_H_
-
-#include <assert.h>
-#include <stdlib.h>
-#include <cstddef>
-#include <algorithm>
-
-namespace ceres {
-namespace internal {
-
-template <class C> class scoped_ptr;
-template <class C, class Free> class scoped_ptr_malloc;
-template <class C> class scoped_array;
-
-template <class C>
-scoped_ptr<C> make_scoped_ptr(C *);
-
-// A scoped_ptr<T> is like a T*, except that the destructor of
-// scoped_ptr<T> automatically deletes the pointer it holds (if
-// any). That is, scoped_ptr<T> owns the T object that it points
-// to. Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to
-// a T object. Also like T*, scoped_ptr<T> is thread-compatible, and
-// once you dereference it, you get the threadsafety guarantees of T.
-//
-// The size of a scoped_ptr is small: sizeof(scoped_ptr<C>) == sizeof(C*)
-template <class C>
-class scoped_ptr {
- public:
-  // The element type
-  typedef C element_type;
-
-  // Constructor.  Defaults to intializing with NULL.
-  // There is no way to create an uninitialized scoped_ptr.
-  // The input parameter must be allocated with new.
-  explicit scoped_ptr(C* p = NULL) : ptr_(p) { }
-
-  // Destructor.  If there is a C object, delete it.
-  // We don't need to test ptr_ == NULL because C++ does that for us.
-  ~scoped_ptr() {
-    enum { type_must_be_complete = sizeof(C) };
-    delete ptr_;
-  }
-
-  // Reset.  Deletes the current owned object, if any.
-  // Then takes ownership of a new object, if given.
-  // this->reset(this->get()) works.
-  void reset(C* p = NULL) {
-    if (p != ptr_) {
-      enum { type_must_be_complete = sizeof(C) };
-      delete ptr_;
-      ptr_ = p;
-    }
-  }
-
-  // Accessors to get the owned object.
-  // operator* and operator-> will assert() if there is no current object.
-  C& operator*() const {
-    assert(ptr_ != NULL);
-    return *ptr_;
-  }
-  C* operator->() const  {
-    assert(ptr_ != NULL);
-    return ptr_;
-  }
-  C* get() const { return ptr_; }
-
-  // Comparison operators.
-  // These return whether a scoped_ptr and a raw pointer refer to
-  // the same object, not just to two different but equal objects.
-  bool operator==(const C* p) const { return ptr_ == p; }
-  bool operator!=(const C* p) const { return ptr_ != p; }
-
-  // Swap two scoped pointers.
-  void swap(scoped_ptr& p2) {
-    C* tmp = ptr_;
-    ptr_ = p2.ptr_;
-    p2.ptr_ = tmp;
-  }
-
-  // Release a pointer.
-  // The return value is the current pointer held by this object.
-  // If this object holds a NULL pointer, the return value is NULL.
-  // After this operation, this object will hold a NULL pointer,
-  // and will not own the object any more.
-  C* release() {
-    C* retVal = ptr_;
-    ptr_ = NULL;
-    return retVal;
-  }
-
- private:
-  C* ptr_;
-
-  // google3 friend class that can access copy ctor (although if it actually
-  // calls a copy ctor, there will be a problem) see below
-  friend scoped_ptr<C> make_scoped_ptr<C>(C *p);
-
-  // Forbid comparison of scoped_ptr types.  If C2 != C, it totally doesn't
-  // make sense, and if C2 == C, it still doesn't make sense because you should
-  // never have the same object owned by two different scoped_ptrs.
-  template <class C2> bool operator==(scoped_ptr<C2> const& p2) const;
-  template <class C2> bool operator!=(scoped_ptr<C2> const& p2) const;
-
-  // Disallow evil constructors
-  scoped_ptr(const scoped_ptr&);
-  void operator=(const scoped_ptr&);
-};
-
-// Free functions
-template <class C>
-inline void swap(scoped_ptr<C>& p1, scoped_ptr<C>& p2) {
-  p1.swap(p2);
-}
-
-template <class C>
-inline bool operator==(const C* p1, const scoped_ptr<C>& p2) {
-  return p1 == p2.get();
-}
-
-template <class C>
-inline bool operator==(const C* p1, const scoped_ptr<const C>& p2) {
-  return p1 == p2.get();
-}
-
-template <class C>
-inline bool operator!=(const C* p1, const scoped_ptr<C>& p2) {
-  return p1 != p2.get();
-}
-
-template <class C>
-inline bool operator!=(const C* p1, const scoped_ptr<const C>& p2) {
-  return p1 != p2.get();
-}
-
-template <class C>
-scoped_ptr<C> make_scoped_ptr(C *p) {
-  // This does nothing but to return a scoped_ptr of the type that the passed
-  // pointer is of.  (This eliminates the need to specify the name of T when
-  // making a scoped_ptr that is used anonymously/temporarily.)  From an
-  // access control point of view, we construct an unnamed scoped_ptr here
-  // which we return and thus copy-construct.  Hence, we need to have access
-  // to scoped_ptr::scoped_ptr(scoped_ptr const &).  However, it is guaranteed
-  // that we never actually call the copy constructor, which is a good thing
-  // as we would call the temporary's object destructor (and thus delete p)
-  // if we actually did copy some object, here.
-  return scoped_ptr<C>(p);
-}
-
-// scoped_array<C> is like scoped_ptr<C>, except that the caller must allocate
-// with new [] and the destructor deletes objects with delete [].
-//
-// As with scoped_ptr<C>, a scoped_array<C> either points to an object
-// or is NULL.  A scoped_array<C> owns the object that it points to.
-// scoped_array<T> is thread-compatible, and once you index into it,
-// the returned objects have only the threadsafety guarantees of T.
-//
-// Size: sizeof(scoped_array<C>) == sizeof(C*)
-template <class C>
-class scoped_array {
- public:
-  // The element type
-  typedef C element_type;
-
-  // Constructor.  Defaults to intializing with NULL.
-  // There is no way to create an uninitialized scoped_array.
-  // The input parameter must be allocated with new [].
-  explicit scoped_array(C* p = NULL) : array_(p) { }
-
-  // Destructor.  If there is a C object, delete it.
-  // We don't need to test ptr_ == NULL because C++ does that for us.
-  ~scoped_array() {
-    enum { type_must_be_complete = sizeof(C) };
-    delete[] array_;
-  }
-
-  // Reset. Deletes the current owned object, if any.
-  // Then takes ownership of a new object, if given.
-  // this->reset(this->get()) works.
-  void reset(C* p = NULL) {
-    if (p != array_) {
-      enum { type_must_be_complete = sizeof(C) };
-      delete[] array_;
-      array_ = p;
-    }
-  }
-
-  // Get one element of the current object.
-  // Will assert() if there is no current object, or index i is negative.
-  C& operator[](std::ptrdiff_t i) const {
-    assert(i >= 0);
-    assert(array_ != NULL);
-    return array_[i];
-  }
-
-  // Get a pointer to the zeroth element of the current object.
-  // If there is no current object, return NULL.
-  C* get() const {
-    return array_;
-  }
-
-  // Comparison operators.
-  // These return whether a scoped_array and a raw pointer refer to
-  // the same array, not just to two different but equal arrays.
-  bool operator==(const C* p) const { return array_ == p; }
-  bool operator!=(const C* p) const { return array_ != p; }
-
-  // Swap two scoped arrays.
-  void swap(scoped_array& p2) {
-    C* tmp = array_;
-    array_ = p2.array_;
-    p2.array_ = tmp;
-  }
-
-  // Release an array.
-  // The return value is the current pointer held by this object.
-  // If this object holds a NULL pointer, the return value is NULL.
-  // After this operation, this object will hold a NULL pointer,
-  // and will not own the object any more.
-  C* release() {
-    C* retVal = array_;
-    array_ = NULL;
-    return retVal;
-  }
-
- private:
-  C* array_;
-
-  // Forbid comparison of different scoped_array types.
-  template <class C2> bool operator==(scoped_array<C2> const& p2) const;
-  template <class C2> bool operator!=(scoped_array<C2> const& p2) const;
-
-  // Disallow evil constructors
-  scoped_array(const scoped_array&);
-  void operator=(const scoped_array&);
-};
-
-// Free functions
-template <class C>
-inline void swap(scoped_array<C>& p1, scoped_array<C>& p2) {
-  p1.swap(p2);
-}
-
-template <class C>
-inline bool operator==(const C* p1, const scoped_array<C>& p2) {
-  return p1 == p2.get();
-}
-
-template <class C>
-inline bool operator==(const C* p1, const scoped_array<const C>& p2) {
-  return p1 == p2.get();
-}
-
-template <class C>
-inline bool operator!=(const C* p1, const scoped_array<C>& p2) {
-  return p1 != p2.get();
-}
-
-template <class C>
-inline bool operator!=(const C* p1, const scoped_array<const C>& p2) {
-  return p1 != p2.get();
-}
-
-// This class wraps the c library function free() in a class that can be
-// passed as a template argument to scoped_ptr_malloc below.
-class ScopedPtrMallocFree {
- public:
-  inline void operator()(void* x) const {
-    free(x);
-  }
-};
-
-}  // namespace internal
-}  // namespace ceres
-
-#endif  // CERES_PUBLIC_INTERNAL_SCOPED_PTR_H_

include/ceres/local_parameterization.h

@@ -34,7 +34,6 @@
 
 #include <vector>
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/internal/disable_warnings.h"
 
 namespace ceres {

include/ceres/loss_function.h

@@ -75,9 +75,9 @@
 #ifndef CERES_PUBLIC_LOSS_FUNCTION_H_
 #define CERES_PUBLIC_LOSS_FUNCTION_H_
 
+#include <memory>
 #include "glog/logging.h"
 #include "ceres/internal/macros.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/types.h"
 #include "ceres/internal/disable_warnings.h"
 
@@ -303,7 +303,7 @@ class CERES_EXPORT ComposedLoss : public LossFunction {
   virtual void Evaluate(double, double*) const;
 
  private:
-  internal::scoped_ptr<const LossFunction> f_, g_;
+  std::unique_ptr<const LossFunction> f_, g_;
   const Ownership ownership_f_, ownership_g_;
 };
 
@@ -340,7 +340,7 @@ class CERES_EXPORT ScaledLoss : public LossFunction {
   virtual void Evaluate(double, double*) const;
 
  private:
-  internal::scoped_ptr<const LossFunction> rho_;
+  std::unique_ptr<const LossFunction> rho_;
   const double a_;
   const Ownership ownership_;
   CERES_DISALLOW_COPY_AND_ASSIGN(ScaledLoss);
@@ -416,7 +416,7 @@ class CERES_EXPORT LossFunctionWrapper : public LossFunction {
   }
 
  private:
-  internal::scoped_ptr<const LossFunction> rho_;
+  std::unique_ptr<const LossFunction> rho_;
   Ownership ownership_;
   CERES_DISALLOW_COPY_AND_ASSIGN(LossFunctionWrapper);
 };

include/ceres/numeric_diff_cost_function.h

@@ -161,10 +161,10 @@
 #ifndef CERES_PUBLIC_NUMERIC_DIFF_COST_FUNCTION_H_
 #define CERES_PUBLIC_NUMERIC_DIFF_COST_FUNCTION_H_
 
+#include <memory>
 #include "Eigen/Dense"
 #include "ceres/cost_function.h"
 #include "ceres/internal/numeric_diff.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/numeric_diff_options.h"
 #include "ceres/sized_cost_function.h"
 #include "ceres/types.h"
@@ -309,7 +309,7 @@ class NumericDiffCostFunction
   }
 
  private:
-  internal::scoped_ptr<CostFunctor> functor_;
+  std::unique_ptr<CostFunctor> functor_;
   Ownership ownership_;
   NumericDiffOptions options_;
 };

include/ceres/problem.h

@@ -36,6 +36,7 @@
 
 #include <cstddef>
 #include <map>
+#include <memory>
 #include <set>
 #include <vector>
 
@@ -43,7 +44,6 @@
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/macros.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
 
@@ -485,7 +485,7 @@ class CERES_EXPORT Problem {
  private:
   friend class Solver;
   friend class Covariance;
-  internal::scoped_ptr<internal::ProblemImpl> problem_impl_;
+  std::unique_ptr<internal::ProblemImpl> problem_impl_;
   CERES_DISALLOW_COPY_AND_ASSIGN(Problem);
 };
 

internal/ceres/autodiff_cost_function_test.cc

@@ -31,6 +31,7 @@
 #include "ceres/autodiff_cost_function.h"
 
 #include <cstddef>
+#include <memory>
 
 #include "gtest/gtest.h"
 #include "ceres/cost_function.h"
@@ -158,7 +159,7 @@ TEST(AutoDiffCostFunction, PartiallyFilledResidualShouldFailEvaluation) {
   double* parameters[] = {&parameter};
   double* jacobians[] = {jacobian};
 
-  scoped_ptr<CostFunction> cost_function(
+  std::unique_ptr<CostFunction> cost_function(
       new AutoDiffCostFunction<OnlyFillsOneOutputFunctor, 2, 1>(
           new OnlyFillsOneOutputFunctor));
   InvalidateArray(2, jacobian);

internal/ceres/block_jacobi_preconditioner.h

@@ -31,8 +31,8 @@
 #ifndef CERES_INTERNAL_BLOCK_JACOBI_PRECONDITIONER_H_
 #define CERES_INTERNAL_BLOCK_JACOBI_PRECONDITIONER_H_
 
+#include <memory>
 #include "ceres/block_random_access_diagonal_matrix.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/preconditioner.h"
 
 namespace ceres {
@@ -66,7 +66,7 @@ class BlockJacobiPreconditioner : public BlockSparseMatrixPreconditioner {
  private:
   virtual bool UpdateImpl(const BlockSparseMatrix& A, const double* D);
 
-  scoped_ptr<BlockRandomAccessDiagonalMatrix> m_;
+  std::unique_ptr<BlockRandomAccessDiagonalMatrix> m_;
 };
 
 }  // namespace internal

internal/ceres/block_jacobi_preconditioner_test.cc

@@ -30,11 +30,11 @@
 
 #include "ceres/block_jacobi_preconditioner.h"
 
+#include <memory>
 #include <vector>
 #include "ceres/block_random_access_diagonal_matrix.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/block_sparse_matrix.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "gtest/gtest.h"
 #include "Eigen/Dense"
 
@@ -45,7 +45,7 @@ namespace internal {
 class BlockJacobiPreconditionerTest : public ::testing::Test {
  protected:
   void SetUpFromProblemId(int problem_id) {
-    scoped_ptr<LinearLeastSquaresProblem> problem(
+    std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(problem_id));
 
     CHECK_NOTNULL(problem.get());
@@ -88,8 +88,8 @@ class BlockJacobiPreconditionerTest : public ::testing::Test {
     }
   }
 
-  scoped_ptr<BlockSparseMatrix> A;
-  scoped_array<double> D;
+  std::unique_ptr<BlockSparseMatrix> A;
+  std::unique_ptr<double[]> D;
   Matrix dense_ata;
 };
 

internal/ceres/block_jacobian_writer.cc

@@ -37,7 +37,6 @@
 #include "ceres/residual_block.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 
 namespace ceres {
 namespace internal {

internal/ceres/block_random_access_dense_matrix.cc

@@ -32,7 +32,6 @@
 
 #include <vector>
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "glog/logging.h"
 
 namespace ceres {

internal/ceres/block_random_access_dense_matrix.h

@@ -33,11 +33,11 @@
 
 #include "ceres/block_random_access_matrix.h"
 
+#include <memory>
 #include <vector>
 
 #include "ceres/internal/macros.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 
 namespace ceres {
 namespace internal {
@@ -86,8 +86,8 @@ class BlockRandomAccessDenseMatrix : public BlockRandomAccessMatrix {
  private:
   int num_rows_;
   std::vector<int> block_layout_;
-  scoped_array<double> values_;
-  scoped_array<CellInfo> cell_infos_;
+  std::unique_ptr<double[]> values_;
+  std::unique_ptr<CellInfo[]> cell_infos_;
 
   CERES_DISALLOW_COPY_AND_ASSIGN(BlockRandomAccessDenseMatrix);
 };

internal/ceres/block_random_access_diagonal_matrix.cc

@@ -34,9 +34,9 @@
 #include <set>
 #include <utility>
 #include <vector>
+
 #include "Eigen/Dense"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/stl_util.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"

internal/ceres/block_random_access_diagonal_matrix.h

@@ -31,15 +31,16 @@
 #ifndef CERES_INTERNAL_BLOCK_RANDOM_ACCESS_DIAGONAL_MATRIX_H_
 #define CERES_INTERNAL_BLOCK_RANDOM_ACCESS_DIAGONAL_MATRIX_H_
 
+#include <memory>
 #include <set>
-#include <vector>
 #include <utility>
+#include <vector>
+
 #include "ceres/block_random_access_matrix.h"
-#include "ceres/triplet_sparse_matrix.h"
 #include "ceres/integral_types.h"
 #include "ceres/internal/macros.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
+#include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
 
 namespace ceres {
@@ -87,7 +88,7 @@ class BlockRandomAccessDiagonalMatrix : public BlockRandomAccessMatrix {
   std::vector<CellInfo*> layout_;
 
   // The underlying matrix object which actually stores the cells.
-  scoped_ptr<TripletSparseMatrix> tsm_;
+  std::unique_ptr<TripletSparseMatrix> tsm_;
 
   friend class BlockRandomAccessDiagonalMatrixTest;
   CERES_DISALLOW_COPY_AND_ASSIGN(BlockRandomAccessDiagonalMatrix);

internal/ceres/block_random_access_diagonal_matrix_test.cc

@@ -29,6 +29,7 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include <limits>
+#include <memory>
 #include <vector>
 
 #include "ceres/block_random_access_diagonal_matrix.h"
@@ -92,7 +93,7 @@ class BlockRandomAccessDiagonalMatrixTest : public ::testing::Test {
 
  protected:
   int num_nonzeros_;
-  scoped_ptr<BlockRandomAccessDiagonalMatrix> m_;
+  std::unique_ptr<BlockRandomAccessDiagonalMatrix> m_;
 };
 
 TEST_F(BlockRandomAccessDiagonalMatrixTest, MatrixContents) {

internal/ceres/block_random_access_sparse_matrix.cc

@@ -31,11 +31,12 @@
 #include "ceres/block_random_access_sparse_matrix.h"
 
 #include <algorithm>
+#include <memory>
 #include <set>
 #include <utility>
 #include <vector>
+
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
 #include "glog/logging.h"

internal/ceres/block_random_access_sparse_matrix.h

@@ -31,16 +31,17 @@
 #ifndef CERES_INTERNAL_BLOCK_RANDOM_ACCESS_SPARSE_MATRIX_H_
 #define CERES_INTERNAL_BLOCK_RANDOM_ACCESS_SPARSE_MATRIX_H_
 
+#include <memory>
 #include <set>
 #include <unordered_map>
-#include <vector>
 #include <utility>
+#include <vector>
+
 #include "ceres/block_random_access_matrix.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/integral_types.h"
 #include "ceres/internal/macros.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/types.h"
 #include "ceres/small_blas.h"
 
@@ -116,7 +117,7 @@ class BlockRandomAccessSparseMatrix : public BlockRandomAccessMatrix {
   // iterator in the Layout object instead.
   std::vector<std::pair<std::pair<int, int>, double*> > cell_values_;
   // The underlying matrix object which actually stores the cells.
-  scoped_ptr<TripletSparseMatrix> tsm_;
+  std::unique_ptr<TripletSparseMatrix> tsm_;
 
   friend class BlockRandomAccessSparseMatrixTest;
   CERES_DISALLOW_COPY_AND_ASSIGN(BlockRandomAccessSparseMatrix);

internal/ceres/block_random_access_sparse_matrix_test.cc

@@ -29,7 +29,9 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include <limits>
+#include <memory>
 #include <vector>
+
 #include "ceres/block_random_access_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
 #include "glog/logging.h"
@@ -168,7 +170,7 @@ class BlockRandomAccessSparseMatrixTest : public ::testing::Test {
   }
 
  private:
-  scoped_ptr<BlockRandomAccessSparseMatrix> m_;
+  std::unique_ptr<BlockRandomAccessSparseMatrix> m_;
 };
 
 TEST_F(BlockRandomAccessSparseMatrixTest, IntPairToLongOverflow) {

internal/ceres/block_sparse_matrix.h

@@ -34,11 +34,11 @@
 #ifndef CERES_INTERNAL_BLOCK_SPARSE_MATRIX_H_
 #define CERES_INTERNAL_BLOCK_SPARSE_MATRIX_H_
 
+#include <memory>
 #include "ceres/block_structure.h"
 #include "ceres/sparse_matrix.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/macros.h"
-#include "ceres/internal/scoped_ptr.h"
 
 namespace ceres {
 namespace internal {
@@ -137,8 +137,8 @@ class BlockSparseMatrix : public SparseMatrix {
   int num_cols_;
   int num_nonzeros_;
   int max_num_nonzeros_;
-  scoped_array<double> values_;
-  scoped_ptr<CompressedRowBlockStructure> block_structure_;
+  std::unique_ptr<double[]> values_;
+  std::unique_ptr<CompressedRowBlockStructure> block_structure_;
   CERES_DISALLOW_COPY_AND_ASSIGN(BlockSparseMatrix);
 };
 

internal/ceres/block_sparse_matrix_test.cc

@@ -30,10 +30,10 @@
 
 #include "ceres/block_sparse_matrix.h"
 
+#include <memory>
 #include <string>
 #include "ceres/casts.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "glog/logging.h"
@@ -45,7 +45,7 @@ namespace internal {
 class BlockSparseMatrixTest : public ::testing::Test {
  protected :
   virtual void SetUp() {
-    scoped_ptr<LinearLeastSquaresProblem> problem(
+    std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(2));
     CHECK_NOTNULL(problem.get());
     A_.reset(down_cast<BlockSparseMatrix*>(problem->A.release()));
@@ -59,8 +59,8 @@ class BlockSparseMatrixTest : public ::testing::Test {
     CHECK_EQ(A_->num_nonzeros(), B_->num_nonzeros());
   }
 
-  scoped_ptr<BlockSparseMatrix> A_;
-  scoped_ptr<TripletSparseMatrix> B_;
+  std::unique_ptr<BlockSparseMatrix> A_;
+  std::unique_ptr<TripletSparseMatrix> B_;
 };
 
 TEST_F(BlockSparseMatrixTest, SetZeroTest) {
@@ -109,16 +109,16 @@ TEST_F(BlockSparseMatrixTest, ToDenseMatrixTest) {
 }
 
 TEST_F(BlockSparseMatrixTest, AppendRows) {
-  scoped_ptr<LinearLeastSquaresProblem> problem(
+  std::unique_ptr<LinearLeastSquaresProblem> problem(
       CreateLinearLeastSquaresProblemFromId(2));
-  scoped_ptr<BlockSparseMatrix> m(
+  std::unique_ptr<BlockSparseMatrix> m(
       down_cast<BlockSparseMatrix*>(problem->A.release()));
   A_->AppendRows(*m);
   EXPECT_EQ(A_->num_rows(), 2 * m->num_rows());
   EXPECT_EQ(A_->num_cols(), m->num_cols());
 
   problem.reset(CreateLinearLeastSquaresProblemFromId(1));
-  scoped_ptr<TripletSparseMatrix> m2(
+  std::unique_ptr<TripletSparseMatrix> m2(
       down_cast<TripletSparseMatrix*>(problem->A.release()));
   B_->AppendRows(*m2);
 
@@ -144,7 +144,7 @@ TEST_F(BlockSparseMatrixTest, AppendAndDeleteBlockDiagonalMatrix) {
   for (int i = 0; i < num_cols; ++i) {
     diagonal(i) = 2 * i * i + 1;
   }
-  scoped_ptr<BlockSparseMatrix> appendage(
+  std::unique_ptr<BlockSparseMatrix> appendage(
       BlockSparseMatrix::CreateDiagonalMatrix(diagonal.data(), column_blocks));
 
   A_->AppendRows(*appendage);
@@ -196,7 +196,7 @@ TEST(BlockSparseMatrix, CreateDiagonalMatrix) {
     diagonal(i) = 2 * i * i + 1;
   }
 
-  scoped_ptr<BlockSparseMatrix> m(
+  std::unique_ptr<BlockSparseMatrix> m(
       BlockSparseMatrix::CreateDiagonalMatrix(diagonal.data(), column_blocks));
   const CompressedRowBlockStructure* bs = m->block_structure();
   EXPECT_EQ(bs->cols.size(), column_blocks.size());

internal/ceres/cgnr_linear_operator.h

@@ -32,8 +32,8 @@
 #define CERES_INTERNAL_CGNR_LINEAR_OPERATOR_H_
 
 #include <algorithm>
+#include <memory>
 #include "ceres/linear_operator.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/internal/eigen.h"
 
 namespace ceres {
@@ -111,7 +111,7 @@ class CgnrLinearOperator : public LinearOperator {
  private:
   const LinearOperator& A_;
   const double* D_;
-  scoped_array<double> z_;
+  std::unique_ptr<double[]> z_;
 };
 
 }  // namespace internal

internal/ceres/cgnr_solver.cc

@@ -42,8 +42,7 @@ namespace ceres {
 namespace internal {
 
 CgnrSolver::CgnrSolver(const LinearSolver::Options& options)
-  : options_(options),
-    preconditioner_(NULL) {
+  : options_(options) {
   if (options_.preconditioner_type != JACOBI &&
       options_.preconditioner_type != IDENTITY) {
     LOG(FATAL) << "CGNR only supports IDENTITY and JACOBI preconditioners.";

internal/ceres/cgnr_solver.h

@@ -31,7 +31,7 @@
 #ifndef CERES_INTERNAL_CGNR_SOLVER_H_
 #define CERES_INTERNAL_CGNR_SOLVER_H_
 
-#include "ceres/internal/scoped_ptr.h"
+#include <memory>
 #include "ceres/linear_solver.h"
 
 namespace ceres {
@@ -59,7 +59,7 @@ class CgnrSolver : public BlockSparseMatrixSolver {
 
  private:
   const LinearSolver::Options options_;
-  scoped_ptr<Preconditioner> preconditioner_;
+  std::unique_ptr<Preconditioner> preconditioner_;
   CERES_DISALLOW_COPY_AND_ASSIGN(CgnrSolver);
 };
 

internal/ceres/compressed_row_sparse_matrix_test.cc

@@ -30,11 +30,11 @@
 
 #include "ceres/compressed_row_sparse_matrix.h"
 
+#include <memory>
 #include <numeric>
 #include "ceres/casts.h"
 #include "ceres/crs_matrix.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/random.h"
 #include "ceres/triplet_sparse_matrix.h"
@@ -72,7 +72,7 @@ void CompareMatrices(const SparseMatrix* a, const SparseMatrix* b) {
 class CompressedRowSparseMatrixTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
-    scoped_ptr<LinearLeastSquaresProblem> problem(
+    std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(1));
 
     CHECK_NOTNULL(problem.get());
@@ -95,8 +95,8 @@ class CompressedRowSparseMatrixTest : public ::testing::Test {
   int num_rows;
   int num_cols;
 
-  scoped_ptr<TripletSparseMatrix> tsm;
-  scoped_ptr<CompressedRowSparseMatrix> crsm;
+  std::unique_ptr<TripletSparseMatrix> tsm;
+  std::unique_ptr<CompressedRowSparseMatrix> crsm;
 };
 
 TEST_F(CompressedRowSparseMatrixTest, Scale) {
@@ -132,7 +132,7 @@ TEST_F(CompressedRowSparseMatrixTest, AppendRows) {
     tsm_appendage.Resize(i, num_cols);
 
     tsm->AppendRows(tsm_appendage);
-    scoped_ptr<CompressedRowSparseMatrix> crsm_appendage(
+    std::unique_ptr<CompressedRowSparseMatrix> crsm_appendage(
         CompressedRowSparseMatrix::FromTripletSparseMatrix(tsm_appendage));
 
     crsm->AppendRows(*crsm_appendage);
@@ -143,7 +143,7 @@ TEST_F(CompressedRowSparseMatrixTest, AppendRows) {
 TEST_F(CompressedRowSparseMatrixTest, AppendAndDeleteBlockDiagonalMatrix) {
   int num_diagonal_rows = crsm->num_cols();
 
-  scoped_array<double> diagonal(new double[num_diagonal_rows]);
+  std::unique_ptr<double[]> diagonal(new double[num_diagonal_rows]);
   for (int i = 0; i < num_diagonal_rows; ++i) {
     diagonal[i] = i;
   }
@@ -156,7 +156,7 @@ TEST_F(CompressedRowSparseMatrixTest, AppendAndDeleteBlockDiagonalMatrix) {
   const vector<int> pre_row_blocks = crsm->row_blocks();
   const vector<int> pre_col_blocks = crsm->col_blocks();
 
-  scoped_ptr<CompressedRowSparseMatrix> appendage(
+  std::unique_ptr<CompressedRowSparseMatrix> appendage(
       CompressedRowSparseMatrix::CreateBlockDiagonalMatrix(
           diagonal.get(), row_and_column_blocks));
 
@@ -220,7 +220,7 @@ TEST(CompressedRowSparseMatrix, CreateBlockDiagonalMatrix) {
     diagonal(i) = i + 1;
   }
 
-  scoped_ptr<CompressedRowSparseMatrix> matrix(
+  std::unique_ptr<CompressedRowSparseMatrix> matrix(
       CompressedRowSparseMatrix::CreateBlockDiagonalMatrix(diagonal.data(),
                                                            blocks));
 
@@ -305,7 +305,7 @@ TEST(CompressedRowSparseMatrix, Transpose) {
 
   std::copy(values, values + 17, cols);
 
-  scoped_ptr<CompressedRowSparseMatrix> transpose(matrix.Transpose());
+  std::unique_ptr<CompressedRowSparseMatrix> transpose(matrix.Transpose());
 
   ASSERT_EQ(transpose->row_blocks().size(), matrix.col_blocks().size());
   for (int i = 0; i < transpose->row_blocks().size(); ++i) {
@@ -333,9 +333,9 @@ TEST(CompressedRowSparseMatrix, FromTripletSparseMatrix) {
 
   const int kNumTrials = 10;
   for (int i = 0; i < kNumTrials; ++i) {
-    scoped_ptr<TripletSparseMatrix> tsm(
+    std::unique_ptr<TripletSparseMatrix> tsm(
         TripletSparseMatrix::CreateRandomMatrix(options));
-    scoped_ptr<CompressedRowSparseMatrix> crsm(
+    std::unique_ptr<CompressedRowSparseMatrix> crsm(
         CompressedRowSparseMatrix::FromTripletSparseMatrix(*tsm));
 
     Matrix expected;
@@ -359,9 +359,9 @@ TEST(CompressedRowSparseMatrix, FromTripletSparseMatrixTransposed) {
 
   const int kNumTrials = 10;
   for (int i = 0; i < kNumTrials; ++i) {
-    scoped_ptr<TripletSparseMatrix> tsm(
+    std::unique_ptr<TripletSparseMatrix> tsm(
         TripletSparseMatrix::CreateRandomMatrix(options));
-    scoped_ptr<CompressedRowSparseMatrix> crsm(
+    std::unique_ptr<CompressedRowSparseMatrix> crsm(
         CompressedRowSparseMatrix::FromTripletSparseMatrixTransposed(*tsm));
 
     Matrix tmp;
@@ -416,7 +416,7 @@ TEST_P(RightMultiplyTest, _) {
       options.max_row_block_size = kMaxBlockSize;
       options.block_density = std::max(0.5, RandDouble());
       options.storage_type = ::testing::get<0>(param);
-      scoped_ptr<CompressedRowSparseMatrix> matrix(
+      std::unique_ptr<CompressedRowSparseMatrix> matrix(
           CompressedRowSparseMatrix::CreateRandomMatrix(options));
       const int num_rows = matrix->num_rows();
       const int num_cols = matrix->num_cols();
@@ -484,7 +484,7 @@ TEST_P(LeftMultiplyTest, _) {
       options.max_row_block_size = kMaxBlockSize;
       options.block_density = std::max(0.5, RandDouble());
       options.storage_type = ::testing::get<0>(param);
-      scoped_ptr<CompressedRowSparseMatrix> matrix(
+      std::unique_ptr<CompressedRowSparseMatrix> matrix(
           CompressedRowSparseMatrix::CreateRandomMatrix(options));
       const int num_rows = matrix->num_rows();
       const int num_cols = matrix->num_cols();
@@ -552,7 +552,7 @@ TEST_P(SquaredColumnNormTest, _) {
       options.max_row_block_size = kMaxBlockSize;
       options.block_density = std::max(0.5, RandDouble());
       options.storage_type = ::testing::get<0>(param);
-      scoped_ptr<CompressedRowSparseMatrix> matrix(
+      std::unique_ptr<CompressedRowSparseMatrix> matrix(
           CompressedRowSparseMatrix::CreateRandomMatrix(options));
       const int num_cols = matrix->num_cols();
 

internal/ceres/conjugate_gradients_solver_test.cc

@@ -31,12 +31,12 @@
 // TODO(sameeragarwal): More comprehensive testing with larger and
 // more badly conditioned problem.
 
+#include <memory>
 #include "gtest/gtest.h"
 #include "ceres/conjugate_gradients_solver.h"
 #include "ceres/linear_solver.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/types.h"
 
 namespace ceres {
@@ -44,7 +44,7 @@ namespace internal {
 
 TEST(ConjugateGradientTest, Solves3x3IdentitySystem) {
   double diagonal[] = { 1.0, 1.0, 1.0 };
-  scoped_ptr<TripletSparseMatrix>
+  std::unique_ptr<TripletSparseMatrix>
       A(TripletSparseMatrix::CreateSparseDiagonalMatrix(diagonal, 3));
   Vector b(3);
   Vector x(3);
@@ -77,7 +77,7 @@ TEST(ConjugateGradientTest, Solves3x3IdentitySystem) {
 
 
 TEST(ConjuateGradientTest, Solves3x3SymmetricSystem) {
-  scoped_ptr<TripletSparseMatrix> A(new TripletSparseMatrix(3, 3, 9));
+  std::unique_ptr<TripletSparseMatrix> A(new TripletSparseMatrix(3, 3, 9));
   Vector b(3);
   Vector x(3);
 

internal/ceres/coordinate_descent_minimizer.cc

@@ -35,8 +35,10 @@
 #endif
 
 #include <iterator>
+#include <memory>
 #include <numeric>
 #include <vector>
+
 #include "ceres/evaluator.h"
 #include "ceres/linear_solver.h"
 #include "ceres/minimizer.h"
@@ -137,7 +139,7 @@ void CoordinateDescentMinimizer::Minimize(
     parameter_block->SetConstant();
   }
 
-  scoped_array<LinearSolver*> linear_solvers(
+  std::unique_ptr<LinearSolver*[]> linear_solvers(
       new LinearSolver*[options.num_threads]);
 
   LinearSolver::Options linear_solver_options;
@@ -281,7 +283,7 @@ bool CoordinateDescentMinimizer::IsOrderingValid(
 // points.
 ParameterBlockOrdering* CoordinateDescentMinimizer::CreateOrdering(
     const Program& program) {
-  scoped_ptr<ParameterBlockOrdering> ordering(new ParameterBlockOrdering);
+  std::unique_ptr<ParameterBlockOrdering> ordering(new ParameterBlockOrdering);
   ComputeRecursiveIndependentSetOrdering(program, ordering.get());
   ordering->Reverse();
   return ordering.release();

internal/ceres/cost_function_to_functor_test.cc

@@ -29,6 +29,8 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include "ceres/cost_function_to_functor.h"
+
+#include <memory>
 #include "ceres/dynamic_autodiff_cost_function.h"
 #include "ceres/dynamic_cost_function_to_functor.h"
 #include "ceres/autodiff_cost_function.h"
@@ -58,23 +60,23 @@ void ExpectCostFunctionsAreEqual(const CostFunction& cost_function,
     num_parameters += parameter_block_sizes[i];
   }
 
-  scoped_array<double> parameters(new double[num_parameters]);
+  std::unique_ptr<double[]> parameters(new double[num_parameters]);
   for (int i = 0; i < num_parameters; ++i) {
     parameters[i] = static_cast<double>(i) + 1.0;
   }
 
-  scoped_array<double> residuals(new double[num_residuals]);
-  scoped_array<double> jacobians(new double[num_parameters * num_residuals]);
+  std::unique_ptr<double[]> residuals(new double[num_residuals]);
+  std::unique_ptr<double[]> jacobians(new double[num_parameters * num_residuals]);
 
-  scoped_array<double> actual_residuals(new double[num_residuals]);
-  scoped_array<double> actual_jacobians
+  std::unique_ptr<double[]> actual_residuals(new double[num_residuals]);
+  std::unique_ptr<double[]> actual_jacobians
       (new double[num_parameters * num_residuals]);
 
-  scoped_array<double*> parameter_blocks(
+  std::unique_ptr<double*[]> parameter_blocks(
       new double*[parameter_block_sizes.size()]);
-  scoped_array<double*> jacobian_blocks(
+  std::unique_ptr<double*[]> jacobian_blocks(
       new double*[parameter_block_sizes.size()]);
-  scoped_array<double*> actual_jacobian_blocks(
+  std::unique_ptr<double*[]> actual_jacobian_blocks(
       new double*[parameter_block_sizes.size()]);
 
   num_parameters = 0;
@@ -258,7 +260,7 @@ class DynamicTwoParameterBlockFunctor {
 
 #define TEST_BODY(NAME)                                                 \
   TEST(CostFunctionToFunctor, NAME) {                                   \
-    scoped_ptr<CostFunction> cost_function(                             \
+    std::unique_ptr<CostFunction> cost_function(                             \
         new AutoDiffCostFunction<                                       \
             CostFunctionToFunctor<2, PARAMETER_BLOCK_SIZES >,           \
                 2, PARAMETER_BLOCK_SIZES>(new CostFunctionToFunctor<    \
@@ -267,7 +269,7 @@ class DynamicTwoParameterBlockFunctor {
                             NAME##Functor, 2, PARAMETER_BLOCK_SIZES >(  \
                   new NAME##Functor))));                                \
                                                                         \
-scoped_ptr<CostFunction> actual_cost_function(                          \
+std::unique_ptr<CostFunction> actual_cost_function(                          \
     new AutoDiffCostFunction<NAME##Functor, 2, PARAMETER_BLOCK_SIZES >( \
         new NAME##Functor));                                            \
 ExpectCostFunctionsAreEqual(*cost_function, *actual_cost_function);     \
@@ -316,14 +318,14 @@ TEST_BODY(TenParameterBlock)
 #undef TEST_BODY
 
 TEST(CostFunctionToFunctor, DynamicNumberOfResiduals) {
-  scoped_ptr<CostFunction> cost_function(
+  std::unique_ptr<CostFunction> cost_function(
       new AutoDiffCostFunction<
       CostFunctionToFunctor<ceres::DYNAMIC, 2, 2 >, ceres::DYNAMIC, 2, 2>(
           new CostFunctionToFunctor<ceres::DYNAMIC, 2, 2 >(
               new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2 >(
                   new TwoParameterBlockFunctor)), 2));
 
-  scoped_ptr<CostFunction> actual_cost_function(
+  std::unique_ptr<CostFunction> actual_cost_function(
       new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2 >(
           new TwoParameterBlockFunctor));
   ExpectCostFunctionsAreEqual(*cost_function, *actual_cost_function);

internal/ceres/covariance_impl.cc

@@ -36,6 +36,7 @@
 
 #include <algorithm>
 #include <cstdlib>
+#include <memory>
 #include <numeric>
 #include <sstream>
 #include <unordered_set>
@@ -337,7 +338,7 @@ bool CovarianceImpl::GetCovarianceMatrixInTangentOrAmbientSpace(
   // Assemble the blocks in the covariance matrix.
   MatrixRef covariance(covariance_matrix, covariance_size, covariance_size);
   const int num_threads = options_.num_threads;
-  scoped_array<double> workspace(
+  std::unique_ptr<double[]> workspace(
       new double[num_threads * max_covariance_block_size *
                  max_covariance_block_size]);
 
@@ -706,7 +707,7 @@ bool CovarianceImpl::ComputeCovarianceValuesUsingSuiteSparseQR() {
   // Since the covariance matrix is symmetric, the i^th row and column
   // are equal.
   const int num_threads = options_.num_threads;
-  scoped_array<double> workspace(new double[num_threads * num_cols]);
+  std::unique_ptr<double[]> workspace(new double[num_threads * num_cols]);
 
 #if !(defined(CERES_USE_TBB) || defined(CERES_USE_CXX11_THREADS))
   ThreadTokenProvider thread_token_provider(num_threads);
@@ -915,7 +916,7 @@ bool CovarianceImpl::ComputeCovarianceValuesUsingEigenSparseQR() {
   // are equal.
   const int num_cols = jacobian.num_cols;
   const int num_threads = options_.num_threads;
-  scoped_array<double> workspace(new double[num_threads * num_cols]);
+  std::unique_ptr<double[]> workspace(new double[num_threads * num_cols]);
 
 #if !(defined(CERES_USE_TBB) || defined(CERES_USE_CXX11_THREADS))
   ThreadTokenProvider thread_token_provider(num_threads);

internal/ceres/covariance_impl.h

@@ -32,11 +32,11 @@
 #define CERES_INTERNAL_COVARIANCE_IMPL_H_
 
 #include <map>
+#include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 #include "ceres/covariance.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/problem_impl.h"
 #include "ceres/suitesparse.h"
 
@@ -92,7 +92,7 @@ class CovarianceImpl {
   bool is_valid_;
   std::map<const double*, int> parameter_block_to_row_index_;
   std::set<const double*> constant_parameter_blocks_;
-  scoped_ptr<CompressedRowSparseMatrix> covariance_matrix_;
+  std::unique_ptr<CompressedRowSparseMatrix> covariance_matrix_;
 };
 
 }  // namespace internal

internal/ceres/covariance_test.cc

@@ -33,7 +33,9 @@
 #include <algorithm>
 #include <cmath>
 #include <map>
+#include <memory>
 #include <utility>
+
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/cost_function.h"
 #include "ceres/covariance_impl.h"
@@ -1256,7 +1258,7 @@ class LargeScaleCovarianceTest : public ::testing::Test {
     }
   }
 
-  scoped_array<double> parameters_;
+  std::unique_ptr<double[]> parameters_;
   int parameter_block_size_;
   int num_parameter_blocks_;
 

internal/ceres/cubic_interpolation_test.cc

@@ -30,8 +30,8 @@
 
 #include "ceres/cubic_interpolation.h"
 
+#include <memory>
 #include "ceres/jet.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
@@ -257,7 +257,7 @@ class CubicInterpolatorTest : public ::testing::Test {
  private:
   static const int kNumSamples = 10;
   static const int kNumTestSamples = 100;
-  scoped_array<double> values_;
+  std::unique_ptr<double[]> values_;
 };
 
 TEST_F(CubicInterpolatorTest, ConstantFunction) {
@@ -375,7 +375,7 @@ class BiCubicInterpolatorTest : public ::testing::Test {
   static const int kNumCols = 10;
   static const int kNumRowSamples = 100;
   static const int kNumColSamples = 100;
-  scoped_array<double> values_;
+  std::unique_ptr<double[]> values_;
 };
 
 TEST_F(BiCubicInterpolatorTest, ZeroFunction) {

internal/ceres/dense_linear_solver_test.cc

@@ -28,9 +28,9 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include <memory>
 #include "ceres/casts.h"
 #include "ceres/context_impl.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/linear_solver.h"
 #include "ceres/triplet_sparse_matrix.h"
@@ -61,7 +61,7 @@ TEST_P(DenseLinearSolverTest, _) {
   Param param = GetParam();
   const bool regularized = testing::get<2>(param);
 
-  scoped_ptr<LinearLeastSquaresProblem> problem(
+  std::unique_ptr<LinearLeastSquaresProblem> problem(
       CreateLinearLeastSquaresProblemFromId(testing::get<3>(param)));
   DenseSparseMatrix lhs(*down_cast<TripletSparseMatrix*>(problem->A.get()));
 
@@ -76,7 +76,7 @@ TEST_P(DenseLinearSolverTest, _) {
   options.dense_linear_algebra_library_type = ::testing::get<1>(param);
   ContextImpl context;
   options.context = &context;
-  scoped_ptr<LinearSolver> solver(LinearSolver::Create(options));
+  std::unique_ptr<LinearSolver> solver(LinearSolver::Create(options));
 
   LinearSolver::PerSolveOptions per_solve_options;
   if (regularized) {

internal/ceres/dense_normal_cholesky_solver.cc

@@ -36,7 +36,6 @@
 #include "ceres/blas.h"
 #include "ceres/dense_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/lapack.h"
 #include "ceres/linear_solver.h"
 #include "ceres/types.h"

internal/ceres/dense_qr_solver.cc

@@ -30,12 +30,10 @@
 
 #include "ceres/dense_qr_solver.h"
 
-
 #include <cstddef>
 #include "Eigen/Dense"
 #include "ceres/dense_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/lapack.h"
 #include "ceres/linear_solver.h"
 #include "ceres/types.h"

internal/ceres/dense_sparse_matrix.h

@@ -33,10 +33,9 @@
 #ifndef CERES_INTERNAL_DENSE_SPARSE_MATRIX_H_
 #define CERES_INTERNAL_DENSE_SPARSE_MATRIX_H_
 
-#include "ceres/sparse_matrix.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/macros.h"
-#include "ceres/internal/scoped_ptr.h"
+#include "ceres/sparse_matrix.h"
 #include "ceres/types.h"
 
 namespace ceres {

internal/ceres/dense_sparse_matrix_test.cc

@@ -34,11 +34,11 @@
 
 #include "ceres/dense_sparse_matrix.h"
 
+#include <memory>
 #include "ceres/casts.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
@@ -69,7 +69,7 @@ void CompareMatrices(const SparseMatrix* a, const SparseMatrix* b) {
 class DenseSparseMatrixTest : public ::testing::Test {
  protected :
   virtual void SetUp() {
-    scoped_ptr<LinearLeastSquaresProblem> problem(
+    std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(1));
 
     CHECK_NOTNULL(problem.get());
@@ -84,8 +84,8 @@ class DenseSparseMatrixTest : public ::testing::Test {
   int num_rows;
   int num_cols;
 
-  scoped_ptr<TripletSparseMatrix> tsm;
-  scoped_ptr<DenseSparseMatrix> dsm;
+  std::unique_ptr<TripletSparseMatrix> tsm;
+  std::unique_ptr<DenseSparseMatrix> dsm;
 };
 
 TEST_F(DenseSparseMatrixTest, RightMultiply) {

internal/ceres/dogleg_strategy_test.cc

@@ -29,8 +29,8 @@
 // Author: moll.markus@arcor.de (Markus Moll)
 
 #include <limits>
+#include <memory>
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/dense_qr_solver.h"
 #include "ceres/dogleg_strategy.h"
 #include "ceres/linear_solver.h"
@@ -44,7 +44,7 @@ namespace {
 
 class Fixture : public testing::Test {
  protected:
-  scoped_ptr<DenseSparseMatrix> jacobian_;
+  std::unique_ptr<DenseSparseMatrix> jacobian_;
   Vector residual_;
   Vector x_;
   TrustRegionStrategy::Options options_;
@@ -126,7 +126,7 @@ const double kEpsilon = std::numeric_limits<double>::epsilon();
 // The DoglegStrategy must never return a step that is longer than the current
 // trust region radius.
 TEST_F(DoglegStrategyFixtureEllipse, TrustRegionObeyedTraditional) {
-  scoped_ptr<LinearSolver> linear_solver(
+  std::unique_ptr<LinearSolver> linear_solver(
       new DenseQRSolver(LinearSolver::Options()));
   options_.linear_solver = linear_solver.get();
   // The global minimum is at (1, 1, ..., 1), so the distance to it is
@@ -149,7 +149,7 @@ TEST_F(DoglegStrategyFixtureEllipse, TrustRegionObeyedTraditional) {
 }
 
 TEST_F(DoglegStrategyFixtureEllipse, TrustRegionObeyedSubspace) {
-  scoped_ptr<LinearSolver> linear_solver(
+  std::unique_ptr<LinearSolver> linear_solver(
       new DenseQRSolver(LinearSolver::Options()));
   options_.linear_solver = linear_solver.get();
   options_.dogleg_type = SUBSPACE_DOGLEG;
@@ -169,7 +169,7 @@ TEST_F(DoglegStrategyFixtureEllipse, TrustRegionObeyedSubspace) {
 }
 
 TEST_F(DoglegStrategyFixtureEllipse, CorrectGaussNewtonStep) {
-  scoped_ptr<LinearSolver> linear_solver(
+  std::unique_ptr<LinearSolver> linear_solver(
       new DenseQRSolver(LinearSolver::Options()));
   options_.linear_solver = linear_solver.get();
   options_.dogleg_type = SUBSPACE_DOGLEG;
@@ -196,7 +196,7 @@ TEST_F(DoglegStrategyFixtureEllipse, CorrectGaussNewtonStep) {
 // Test if the subspace basis is a valid orthonormal basis of the space spanned
 // by the gradient and the Gauss-Newton point.
 TEST_F(DoglegStrategyFixtureEllipse, ValidSubspaceBasis) {
-  scoped_ptr<LinearSolver> linear_solver(
+  std::unique_ptr<LinearSolver> linear_solver(
       new DenseQRSolver(LinearSolver::Options()));
   options_.linear_solver = linear_solver.get();
   options_.dogleg_type = SUBSPACE_DOGLEG;
@@ -231,7 +231,7 @@ TEST_F(DoglegStrategyFixtureEllipse, ValidSubspaceBasis) {
 // in the same direction and the Gauss-Newton step is outside the trust region,
 // i.e. the trust region is active.
 TEST_F(DoglegStrategyFixtureValley, CorrectStepLocalOptimumAlongGradient) {
-  scoped_ptr<LinearSolver> linear_solver(
+  std::unique_ptr<LinearSolver> linear_solver(
       new DenseQRSolver(LinearSolver::Options()));
   options_.linear_solver = linear_solver.get();
   options_.dogleg_type = SUBSPACE_DOGLEG;
@@ -259,7 +259,7 @@ TEST_F(DoglegStrategyFixtureValley, CorrectStepLocalOptimumAlongGradient) {
 // in the same direction and the Gauss-Newton step is inside the trust region,
 // i.e. the trust region is inactive.
 TEST_F(DoglegStrategyFixtureValley, CorrectStepGlobalOptimumAlongGradient) {
-  scoped_ptr<LinearSolver> linear_solver(
+  std::unique_ptr<LinearSolver> linear_solver(
       new DenseQRSolver(LinearSolver::Options()));
   options_.linear_solver = linear_solver.get();
   options_.dogleg_type = SUBSPACE_DOGLEG;

internal/ceres/dynamic_autodiff_cost_function_test.cc

@@ -32,8 +32,8 @@
 
 #include <cstddef>
 
+#include <memory>
 #include "ceres/dynamic_autodiff_cost_function.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -418,7 +418,7 @@ class ThreeParameterCostFunctorTest : public ::testing::Test {
 
   vector<double*> parameter_blocks_;
 
-  scoped_ptr<CostFunction> cost_function_;
+  std::unique_ptr<CostFunction> cost_function_;
 
   vector<vector<double> > jacobian_vect_;
 
@@ -665,7 +665,7 @@ class SixParameterCostFunctorTest : public ::testing::Test {
 
   vector<double*> parameter_blocks_;
 
-  scoped_ptr<CostFunction> cost_function_;
+  std::unique_ptr<CostFunction> cost_function_;
 
   vector<vector<double> > jacobian_vect_;
 

internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc

@@ -30,10 +30,10 @@
 
 #include "ceres/dynamic_compressed_row_sparse_matrix.h"
 
+#include <memory>
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "gtest/gtest.h"
@@ -167,10 +167,10 @@ class DynamicCompressedRowSparseMatrixTest : public ::testing::Test {
   int expected_num_nonzeros;
 
   Matrix dense;
-  scoped_ptr<TripletSparseMatrix> tsm;
-  scoped_ptr<CompressedRowSparseMatrix> crsm;
+  std::unique_ptr<TripletSparseMatrix> tsm;
+  std::unique_ptr<CompressedRowSparseMatrix> crsm;
 
-  scoped_ptr<DynamicCompressedRowSparseMatrix> dcrsm;
+  std::unique_ptr<DynamicCompressedRowSparseMatrix> dcrsm;
 };
 
 TEST_F(DynamicCompressedRowSparseMatrixTest, Initialization) {

internal/ceres/dynamic_numeric_diff_cost_function_test.cc

@@ -31,8 +31,8 @@
 
 #include <cstddef>
 
+#include <memory>
 #include "ceres/dynamic_numeric_diff_cost_function.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -419,7 +419,7 @@ class ThreeParameterCostFunctorTest : public ::testing::Test {
 
   vector<double*> parameter_blocks_;
 
-  scoped_ptr<CostFunction> cost_function_;
+  std::unique_ptr<CostFunction> cost_function_;
 
   vector<vector<double> > jacobian_vect_;
 

internal/ceres/dynamic_sparse_normal_cholesky_solver.cc

@@ -33,13 +33,13 @@
 #include <algorithm>
 #include <cstring>
 #include <ctime>
+#include <memory>
 #include <sstream>
 
 #include "Eigen/SparseCore"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/cxsparse.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_solver.h"
 #include "ceres/suitesparse.h"
 #include "ceres/triplet_sparse_matrix.h"
@@ -69,7 +69,7 @@ LinearSolver::Summary DynamicSparseNormalCholeskySolver::SolveImpl(
   if (per_solve_options.D != NULL) {
     // Temporarily append a diagonal block to the A matrix, but undo
     // it before returning the matrix to the user.
-    scoped_ptr<CompressedRowSparseMatrix> regularizer;
+    std::unique_ptr<CompressedRowSparseMatrix> regularizer;
     if (!A->col_blocks().empty()) {
       regularizer.reset(CompressedRowSparseMatrix::CreateBlockDiagonalMatrix(
           per_solve_options.D, A->col_blocks()));

internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc

@@ -28,10 +28,10 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include <memory>
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/context_impl.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/linear_solver.h"
 #include "ceres/triplet_sparse_matrix.h"
@@ -50,7 +50,7 @@ namespace internal {
 class DynamicSparseNormalCholeskySolverTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
-    scoped_ptr<LinearLeastSquaresProblem> problem(
+    std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(1));
     A_.reset(CompressedRowSparseMatrix::FromTripletSparseMatrix(
         *down_cast<TripletSparseMatrix*>(problem->A.get())));
@@ -74,7 +74,7 @@ class DynamicSparseNormalCholeskySolverTest : public ::testing::Test {
     A_->LeftMultiply(b_.get(), rhs.data());
     Vector expected_solution = lhs.llt().solve(rhs);
 
-    scoped_ptr<LinearSolver> solver(LinearSolver::Create(options));
+    std::unique_ptr<LinearSolver> solver(LinearSolver::Create(options));
     LinearSolver::PerSolveOptions per_solve_options;
     per_solve_options.D = D;
     Vector actual_solution(A_->num_cols());
@@ -104,9 +104,9 @@ class DynamicSparseNormalCholeskySolverTest : public ::testing::Test {
     TestSolver(options, D_.get());
   }
 
-  scoped_ptr<CompressedRowSparseMatrix> A_;
-  scoped_array<double> b_;
-  scoped_array<double> D_;
+  std::unique_ptr<CompressedRowSparseMatrix> A_;
+  std::unique_ptr<double[]> b_;
+  std::unique_ptr<double[]> D_;
 };
 
 #ifndef CERES_NO_SUITESPARSE

internal/ceres/evaluation_callback_test.cc

@@ -30,11 +30,11 @@
 
 #include "ceres/solver.h"
 
-#include <limits>
 #include <cmath>
+#include <limits>
 #include <vector>
+
 #include "gtest/gtest.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/sized_cost_function.h"
 #include "ceres/problem.h"
 #include "ceres/problem_impl.h"

internal/ceres/evaluator_test.cc

@@ -33,12 +33,12 @@
 
 #include "ceres/evaluator.h"
 
+#include <memory>
 #include "ceres/casts.h"
 #include "ceres/cost_function.h"
 #include "ceres/crs_matrix.h"
 #include "ceres/evaluator_test_utils.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/local_parameterization.h"
 #include "ceres/problem_impl.h"
 #include "ceres/program.h"
@@ -143,7 +143,7 @@ struct EvaluatorTest
                           const double* expected_residuals,
                           const double* expected_gradient,
                           const double* expected_jacobian) {
-    scoped_ptr<Evaluator> evaluator(
+    std::unique_ptr<Evaluator> evaluator(
         CreateEvaluator(problem->mutable_program()));
     int num_residuals = expected_num_rows;
     int num_parameters = expected_num_cols;
@@ -156,7 +156,7 @@ struct EvaluatorTest
     Vector gradient(num_parameters);
     gradient.setConstant(-3000);
 
-    scoped_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
+    std::unique_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
 
     ASSERT_EQ(expected_num_rows, evaluator->NumResiduals());
     ASSERT_EQ(expected_num_cols, evaluator->NumEffectiveParameters());
@@ -531,8 +531,8 @@ TEST_P(EvaluatorTest, EvaluatorAbortsForResidualsThatFailToEvaluate) {
   // The values are ignored.
   double state[9];
 
-  scoped_ptr<Evaluator> evaluator(CreateEvaluator(problem.mutable_program()));
-  scoped_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
+  std::unique_ptr<Evaluator> evaluator(CreateEvaluator(problem.mutable_program()));
+  std::unique_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
   double cost;
   EXPECT_FALSE(evaluator->Evaluate(state, &cost, NULL, NULL, NULL));
 }
@@ -607,8 +607,8 @@ TEST(Evaluator, EvaluatorRespectsParameterChanges) {
   options.num_eliminate_blocks = 0;
   options.context = problem.context();
   string error;
-  scoped_ptr<Evaluator> evaluator(Evaluator::Create(options, program, &error));
-  scoped_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
+  std::unique_ptr<Evaluator> evaluator(Evaluator::Create(options, program, &error));
+  std::unique_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
 
   ASSERT_EQ(2, jacobian->num_rows());
   ASSERT_EQ(2, jacobian->num_cols());

internal/ceres/gradient_checking_cost_function.cc

@@ -39,7 +39,6 @@
 
 #include "ceres/gradient_checker.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/parameter_block.h"
 #include "ceres/problem.h"
 #include "ceres/problem_impl.h"

internal/ceres/gradient_checking_cost_function_test.cc

@@ -31,9 +31,10 @@
 #include "ceres/gradient_checking_cost_function.h"
 
 #include <cmath>
+#include <memory>
 #include <vector>
+
 #include "ceres/cost_function.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/local_parameterization.h"
 #include "ceres/loss_function.h"
 #include "ceres/parameter_block.h"
@@ -161,7 +162,7 @@ TEST(GradientCheckingCostFunction, ResidualsAndJacobiansArePreservedTest) {
 
   TestTerm<-1, -1> term(arity, dim);
   GradientCheckingIterationCallback callback;
-  scoped_ptr<CostFunction> gradient_checking_cost_function(
+  std::unique_ptr<CostFunction> gradient_checking_cost_function(
       CreateGradientCheckingCostFunction(&term, NULL,
                                          kRelativeStepSize,
                                          kRelativePrecision,
@@ -218,7 +219,7 @@ TEST(GradientCheckingCostFunction, SmokeTest) {
   {
     TestTerm<1, 2> term(arity, dim);
     GradientCheckingIterationCallback callback;
-    scoped_ptr<CostFunction> gradient_checking_cost_function(
+    std::unique_ptr<CostFunction> gradient_checking_cost_function(
         CreateGradientCheckingCostFunction(&term, NULL,
                                            kRelativeStepSize,
                                            kRelativePrecision,
@@ -237,7 +238,7 @@ TEST(GradientCheckingCostFunction, SmokeTest) {
   {
     TestTerm<-1, -1> term(arity, dim);
     GradientCheckingIterationCallback callback;
-    scoped_ptr<CostFunction> gradient_checking_cost_function(
+    std::unique_ptr<CostFunction> gradient_checking_cost_function(
         CreateGradientCheckingCostFunction(&term, NULL,
                                            kRelativeStepSize,
                                            kRelativePrecision,
@@ -358,7 +359,7 @@ TEST(GradientCheckingProblemImpl, ProblemDimensionsMatch) {
                                 NULL, z, x, y);
 
   GradientCheckingIterationCallback callback;
-  scoped_ptr<ProblemImpl> gradient_checking_problem_impl(
+  std::unique_ptr<ProblemImpl> gradient_checking_problem_impl(
       CreateGradientCheckingProblemImpl(&problem_impl, 1.0, 1.0, &callback));
 
   // The dimensions of the two problems match.

internal/ceres/gradient_problem_solver.cc

@@ -30,6 +30,7 @@
 
 #include "ceres/gradient_problem_solver.h"
 
+#include <memory>
 #include "ceres/callbacks.h"
 #include "ceres/gradient_problem.h"
 #include "ceres/gradient_problem_evaluator.h"
@@ -103,7 +104,6 @@ void GradientProblemSolver::Solve(const GradientProblemSolver::Options& options,
   using internal::GradientProblemSolverStateUpdatingCallback;
   using internal::LoggingCallback;
   using internal::Minimizer;
-  using internal::scoped_ptr;
   using internal::SetSummaryFinalCost;
   using internal::WallTimeInSeconds;
 
@@ -135,7 +135,7 @@ void GradientProblemSolver::Solve(const GradientProblemSolver::Options& options,
       Minimizer::Options(GradientProblemSolverOptionsToSolverOptions(options));
   minimizer_options.evaluator.reset(new GradientProblemEvaluator(problem));
 
-  scoped_ptr<IterationCallback> logging_callback;
+  std::unique_ptr<IterationCallback> logging_callback;
   if (options.logging_type != SILENT) {
     logging_callback.reset(
         new LoggingCallback(LINE_SEARCH, options.minimizer_progress_to_stdout));
@@ -143,7 +143,7 @@ void GradientProblemSolver::Solve(const GradientProblemSolver::Options& options,
                                        logging_callback.get());
   }
 
-  scoped_ptr<IterationCallback> state_updating_callback;
+  std::unique_ptr<IterationCallback> state_updating_callback;
   if (options.update_state_every_iteration) {
     state_updating_callback.reset(
         new GradientProblemSolverStateUpdatingCallback(
@@ -152,7 +152,7 @@ void GradientProblemSolver::Solve(const GradientProblemSolver::Options& options,
                                        state_updating_callback.get());
   }
 
-  scoped_ptr<Minimizer> minimizer(Minimizer::Create(LINE_SEARCH));
+  std::unique_ptr<Minimizer> minimizer(Minimizer::Create(LINE_SEARCH));
 
   Solver::Summary solver_summary;
   solver_summary.fixed_cost = 0.0;

internal/ceres/graph_algorithms_test.cc

@@ -31,11 +31,12 @@
 #include "ceres/graph_algorithms.h"
 
 #include <algorithm>
+#include <memory>
 #include <unordered_set>
-#include "gtest/gtest.h"
+
 #include "ceres/graph.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -110,7 +111,7 @@ TEST(Degree2MaximumSpanningForest, PreserveWeights) {
   graph.AddEdge(0, 1, 0.5);
   graph.AddEdge(1, 0, 0.5);
 
-  scoped_ptr<WeightedGraph<int> > forest(Degree2MaximumSpanningForest(graph));
+  std::unique_ptr<WeightedGraph<int> > forest(Degree2MaximumSpanningForest(graph));
 
   const std::unordered_set<int>& vertices = forest->vertices();
   EXPECT_EQ(vertices.size(), 2);
@@ -133,7 +134,7 @@ TEST(Degree2MaximumSpanningForest, StarGraph) {
   graph.AddEdge(0, 3, 3.0);
   graph.AddEdge(0, 4, 4.0);
 
-  scoped_ptr<WeightedGraph<int> > forest(Degree2MaximumSpanningForest(graph));
+  std::unique_ptr<WeightedGraph<int> > forest(Degree2MaximumSpanningForest(graph));
   const std::unordered_set<int>& vertices = forest->vertices();
   EXPECT_EQ(vertices.size(), 5);
 

internal/ceres/graph_test.cc

@@ -32,7 +32,6 @@
 
 #include <unordered_set>
 #include "gtest/gtest.h"
-#include "ceres/internal/scoped_ptr.h"
 
 namespace ceres {
 namespace internal {

internal/ceres/implicit_schur_complement.cc

@@ -34,7 +34,6 @@
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_solver.h"
 #include "ceres/types.h"
 #include "glog/logging.h"

internal/ceres/implicit_schur_complement.h

@@ -34,11 +34,11 @@
 #ifndef CERES_INTERNAL_IMPLICIT_SCHUR_COMPLEMENT_H_
 #define CERES_INTERNAL_IMPLICIT_SCHUR_COMPLEMENT_H_
 
+#include <memory>
 #include "ceres/linear_operator.h"
 #include "ceres/linear_solver.h"
 #include "ceres/partitioned_matrix_view.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/types.h"
 
 namespace ceres {
@@ -145,12 +145,12 @@ class ImplicitSchurComplement : public LinearOperator {
 
   const LinearSolver::Options& options_;
 
-  scoped_ptr<PartitionedMatrixViewBase> A_;
+  std::unique_ptr<PartitionedMatrixViewBase> A_;
   const double* D_;
   const double* b_;
 
-  scoped_ptr<BlockSparseMatrix> block_diagonal_EtE_inverse_;
-  scoped_ptr<BlockSparseMatrix> block_diagonal_FtF_inverse_;
+  std::unique_ptr<BlockSparseMatrix> block_diagonal_EtE_inverse_;
+  std::unique_ptr<BlockSparseMatrix> block_diagonal_FtF_inverse_;
 
   Vector rhs_;
 

internal/ceres/implicit_schur_complement_test.cc

@@ -31,13 +31,13 @@
 #include "ceres/implicit_schur_complement.h"
 
 #include <cstddef>
+#include <memory>
 #include "Eigen/Dense"
 #include "ceres/block_random_access_dense_matrix.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/casts.h"
 #include "ceres/context_impl.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/linear_solver.h"
 #include "ceres/schur_eliminator.h"
@@ -56,7 +56,7 @@ const double kEpsilon = 1e-14;
 class ImplicitSchurComplementTest : public ::testing::Test {
  protected :
   virtual void SetUp() {
-    scoped_ptr<LinearLeastSquaresProblem> problem(
+    std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(2));
 
     CHECK_NOTNULL(problem.get());
@@ -89,7 +89,7 @@ class ImplicitSchurComplementTest : public ::testing::Test {
     ContextImpl context;
     options.context = &context;
 
-    scoped_ptr<SchurEliminatorBase> eliminator(
+    std::unique_ptr<SchurEliminatorBase> eliminator(
         SchurEliminatorBase::Create(options));
     CHECK_NOTNULL(eliminator.get());
     const bool kFullRankETE = true;
@@ -185,9 +185,9 @@ class ImplicitSchurComplementTest : public ::testing::Test {
   int num_cols_;
   int num_eliminate_blocks_;
 
-  scoped_ptr<BlockSparseMatrix> A_;
-  scoped_array<double> b_;
-  scoped_array<double> D_;
+  std::unique_ptr<BlockSparseMatrix> A_;
+  std::unique_ptr<double[]> b_;
+  std::unique_ptr<double[]> D_;
 };
 
 // Verify that the Schur Complement matrix implied by the

internal/ceres/inner_product_computer.h

@@ -31,11 +31,11 @@
 #ifndef CERES_INTERNAL_INNER_PRODUCT_COMPUTER_H_
 #define CERES_INTERNAL_INNER_PRODUCT_COMPUTER_H_
 
+#include <memory>
 #include <vector>
 
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/compressed_row_sparse_matrix.h"
-#include "ceres/internal/scoped_ptr.h"
 
 namespace ceres {
 namespace internal {
@@ -140,7 +140,7 @@ class InnerProductComputer {
   const BlockSparseMatrix& m_;
   const int start_row_block_;
   const int end_row_block_;
-  scoped_ptr<CompressedRowSparseMatrix> result_;
+  std::unique_ptr<CompressedRowSparseMatrix> result_;
 
   // For each term in the inner product, result_offsets_ contains the
   // location in the values array of the result_ matrix where it

internal/ceres/inner_product_computer_test.cc

@@ -30,10 +30,10 @@
 
 #include "ceres/inner_product_computer.h"
 
+#include <memory>
 #include <numeric>
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/random.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "glog/logging.h"
@@ -108,7 +108,7 @@ TEST(InnerProductComputer, NormalOperation) {
         VLOG(2) << "max col block size: " << options.max_col_block_size;
         VLOG(2) << "block density: " << options.block_density;
 
-        scoped_ptr<BlockSparseMatrix> random_matrix(
+        std::unique_ptr<BlockSparseMatrix> random_matrix(
             BlockSparseMatrix::CreateRandomMatrix(options));
 
         TripletSparseMatrix tsm(random_matrix->num_rows(),
@@ -126,7 +126,7 @@ TEST(InnerProductComputer, NormalOperation) {
         Matrix expected_inner_product =
             eigen_random_matrix.transpose() * eigen_random_matrix;
 
-        scoped_ptr<InnerProductComputer> inner_product_computer;
+        std::unique_ptr<InnerProductComputer> inner_product_computer;
 
         inner_product_computer.reset(InnerProductComputer::Create(
             *random_matrix, CompressedRowSparseMatrix::LOWER_TRIANGULAR));
@@ -168,7 +168,7 @@ TEST(InnerProductComputer, SubMatrix) {
     VLOG(2) << "max col block size: " << options.max_col_block_size;
     VLOG(2) << "block density: " << options.block_density;
 
-    scoped_ptr<BlockSparseMatrix> random_matrix(
+    std::unique_ptr<BlockSparseMatrix> random_matrix(
         BlockSparseMatrix::CreateRandomMatrix(options));
 
     const std::vector<CompressedRow>& row_blocks =
@@ -202,7 +202,7 @@ TEST(InnerProductComputer, SubMatrix) {
         Matrix expected_inner_product =
             eigen_random_matrix.transpose() * eigen_random_matrix;
 
-        scoped_ptr<InnerProductComputer> inner_product_computer;
+        std::unique_ptr<InnerProductComputer> inner_product_computer;
         inner_product_computer.reset(InnerProductComputer::Create(
             *random_matrix,
             start_row_block,

internal/ceres/iterative_schur_complement_solver.cc

@@ -41,7 +41,6 @@
 #include "ceres/detect_structure.h"
 #include "ceres/implicit_schur_complement.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_solver.h"
 #include "ceres/preconditioner.h"
 #include "ceres/schur_jacobi_preconditioner.h"

internal/ceres/iterative_schur_complement_solver.h

@@ -31,9 +31,9 @@
 #ifndef CERES_INTERNAL_ITERATIVE_SCHUR_COMPLEMENT_SOLVER_H_
 #define CERES_INTERNAL_ITERATIVE_SCHUR_COMPLEMENT_SOLVER_H_
 
+#include <memory>
 #include "ceres/linear_solver.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/types.h"
 
 namespace ceres {
@@ -82,8 +82,8 @@ class IterativeSchurComplementSolver : public BlockSparseMatrixSolver {
   void CreatePreconditioner(BlockSparseMatrix* A);
 
   LinearSolver::Options options_;
-  scoped_ptr<internal::ImplicitSchurComplement> schur_complement_;
-  scoped_ptr<Preconditioner> preconditioner_;
+  std::unique_ptr<internal::ImplicitSchurComplement> schur_complement_;
+  std::unique_ptr<Preconditioner> preconditioner_;
   Vector reduced_linear_system_solution_;
   CERES_DISALLOW_COPY_AND_ASSIGN(IterativeSchurComplementSolver);
 };

internal/ceres/iterative_schur_complement_solver_test.cc

@@ -35,13 +35,13 @@
 #include "ceres/iterative_schur_complement_solver.h"
 
 #include <cstddef>
+#include <memory>
 #include "Eigen/Dense"
 #include "ceres/block_random_access_dense_matrix.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/casts.h"
 #include "ceres/context_impl.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/linear_solver.h"
 #include "ceres/schur_eliminator.h"
@@ -60,7 +60,7 @@ const double kEpsilon = 1e-14;
 class IterativeSchurComplementSolverTest : public ::testing::Test {
  protected :
   void SetUpProblem(int problem_id) {
-    scoped_ptr<LinearLeastSquaresProblem> problem(
+    std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(problem_id));
 
     CHECK_NOTNULL(problem.get());
@@ -85,7 +85,7 @@ class IterativeSchurComplementSolverTest : public ::testing::Test {
     options.type = DENSE_QR;
     ContextImpl context;
     options.context = &context;
-    scoped_ptr<LinearSolver> qr(LinearSolver::Create(options));
+    std::unique_ptr<LinearSolver> qr(LinearSolver::Create(options));
 
     LinearSolver::PerSolveOptions per_solve_options;
     per_solve_options.D = D;
@@ -114,9 +114,9 @@ class IterativeSchurComplementSolverTest : public ::testing::Test {
   int num_rows_;
   int num_cols_;
   int num_eliminate_blocks_;
-  scoped_ptr<BlockSparseMatrix> A_;
-  scoped_array<double> b_;
-  scoped_array<double> D_;
+  std::unique_ptr<BlockSparseMatrix> A_;
+  std::unique_ptr<double[]> b_;
+  std::unique_ptr<double[]> D_;
 };
 
 TEST_F(IterativeSchurComplementSolverTest, NormalProblem) {

internal/ceres/levenberg_marquardt_strategy_test.cc

@@ -28,8 +28,8 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include <memory>
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/levenberg_marquardt_strategy.h"
 #include "ceres/linear_solver.h"
 #include "ceres/trust_region_strategy.h"
@@ -86,7 +86,7 @@ TEST(LevenbergMarquardtStrategy, AcceptRejectStepRadiusScaling) {
   options.max_lm_diagonal = 1e8;
 
   // We need a non-null pointer here, so anything should do.
-  scoped_ptr<LinearSolver> linear_solver(
+  std::unique_ptr<LinearSolver> linear_solver(
       new RegularizationCheckingLinearSolver(0, NULL));
   options.linear_solver = linear_solver.get();
 

internal/ceres/line_search_minimizer.cc

@@ -43,6 +43,7 @@
 #include <algorithm>
 #include <cstdlib>
 #include <cmath>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -51,7 +52,6 @@
 #include "ceres/evaluator.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/line_search.h"
 #include "ceres/line_search_direction.h"
 #include "ceres/stringprintf.h"
@@ -164,7 +164,7 @@ void LineSearchMinimizer::Minimize(const Minimizer::Options& options,
   line_search_direction_options.max_lbfgs_rank = options.max_lbfgs_rank;
   line_search_direction_options.use_approximate_eigenvalue_bfgs_scaling =
       options.use_approximate_eigenvalue_bfgs_scaling;
-  scoped_ptr<LineSearchDirection> line_search_direction(
+  std::unique_ptr<LineSearchDirection> line_search_direction(
       LineSearchDirection::Create(line_search_direction_options));
 
   LineSearchFunction line_search_function(evaluator);
@@ -188,7 +188,7 @@ void LineSearchMinimizer::Minimize(const Minimizer::Options& options,
   line_search_options.is_silent = options.is_silent;
   line_search_options.function = &line_search_function;
 
-  scoped_ptr<LineSearch>
+  std::unique_ptr<LineSearch>
       line_search(LineSearch::Create(options.line_search_type,
                                      line_search_options,
                                      &summary->message));

internal/ceres/linear_least_squares_problems.cc

@@ -31,13 +31,14 @@
 #include "ceres/linear_least_squares_problems.h"
 
 #include <cstdio>
+#include <memory>
 #include <string>
 #include <vector>
+
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/casts.h"
 #include "ceres/file.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/stringprintf.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
@@ -297,7 +298,7 @@ LinearLeastSquaresProblem* LinearLeastSquaresProblem2() {
   problem->num_eliminate_blocks = 2;
 
   CompressedRowBlockStructure* bs = new CompressedRowBlockStructure;
-  scoped_array<double> values(new double[num_rows * num_cols]);
+  std::unique_ptr<double[]> values(new double[num_rows * num_cols]);
 
   for (int c = 0; c < num_cols; ++c) {
     bs->cols.push_back(Block());
@@ -431,7 +432,7 @@ LinearLeastSquaresProblem* LinearLeastSquaresProblem3() {
   problem->num_eliminate_blocks = 2;
 
   CompressedRowBlockStructure* bs = new CompressedRowBlockStructure;
-  scoped_array<double> values(new double[num_rows * num_cols]);
+  std::unique_ptr<double[]> values(new double[num_rows * num_cols]);
 
   for (int c = 0; c < num_cols; ++c) {
     bs->cols.push_back(Block());
@@ -538,7 +539,7 @@ LinearLeastSquaresProblem* LinearLeastSquaresProblem4() {
   problem->num_eliminate_blocks = 1;
 
   CompressedRowBlockStructure* bs = new CompressedRowBlockStructure;
-  scoped_array<double> values(new double[num_rows * num_cols]);
+  std::unique_ptr<double[]> values(new double[num_rows * num_cols]);
 
   // Column block structure
   bs->cols.push_back(Block());

internal/ceres/linear_least_squares_problems.h

@@ -31,11 +31,11 @@
 #ifndef CERES_INTERNAL_LINEAR_LEAST_SQUARES_PROBLEMS_H_
 #define CERES_INTERNAL_LINEAR_LEAST_SQUARES_PROBLEMS_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 #include "ceres/sparse_matrix.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 
 namespace ceres {
 namespace internal {
@@ -44,21 +44,20 @@ namespace internal {
 // ground truth solutions. To be used by various LinearSolver tests.
 struct LinearLeastSquaresProblem {
   LinearLeastSquaresProblem()
-      : A(NULL), b(NULL), D(NULL), num_eliminate_blocks(0),
-        x(NULL), x_D(NULL) {
+      : num_eliminate_blocks(0) {
   }
 
-  scoped_ptr<SparseMatrix> A;
-  scoped_array<double> b;
-  scoped_array<double> D;
+  std::unique_ptr<SparseMatrix> A;
+  std::unique_ptr<double[]> b;
+  std::unique_ptr<double[]> D;
   // If using the schur eliminator then how many of the variable
   // blocks are e_type blocks.
   int num_eliminate_blocks;
 
   // Solution to min_x |Ax - b|^2
-  scoped_array<double> x;
+  std::unique_ptr<double[]> x;
   // Solution to min_x |Ax - b|^2 + |Dx|^2
-  scoped_array<double> x_D;
+  std::unique_ptr<double[]> x_D;
 };
 
 // Factories for linear least squares problem.

internal/ceres/local_parameterization_test.cc

@@ -30,6 +30,8 @@
 
 #include <cmath>
 #include <limits>
+#include <memory>
+
 #include "Eigen/Geometry"
 #include "ceres/autodiff_local_parameterization.h"
 #include "ceres/fpclassify.h"
@@ -611,10 +613,10 @@ class ProductParameterizationTest : public ::testing::Test {
                                              constant_parameters4));
   }
 
-  scoped_ptr<LocalParameterization> param1_;
-  scoped_ptr<LocalParameterization> param2_;
-  scoped_ptr<LocalParameterization> param3_;
-  scoped_ptr<LocalParameterization> param4_;
+  std::unique_ptr<LocalParameterization> param1_;
+  std::unique_ptr<LocalParameterization> param2_;
+  std::unique_ptr<LocalParameterization> param3_;
+  std::unique_ptr<LocalParameterization> param4_;
 };
 
 TEST_F(ProductParameterizationTest, LocalAndGlobalSize2) {

internal/ceres/normal_prior.cc

@@ -33,7 +33,6 @@
 #include <cstddef>
 #include <vector>
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
 

internal/ceres/numeric_diff_cost_function_test.cc

@@ -33,10 +33,11 @@
 
 #include <algorithm>
 #include <cmath>
+#include <memory>
 #include <string>
 #include <vector>
+
 #include "ceres/internal/macros.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/array_utils.h"
 #include "ceres/numeric_diff_test_utils.h"
 #include "ceres/test_util.h"
@@ -48,7 +49,7 @@ namespace ceres {
 namespace internal {
 
 TEST(NumericDiffCostFunction, EasyCaseFunctorCentralDifferences) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<EasyFunctor,
                                   CENTRAL,
@@ -61,7 +62,7 @@ TEST(NumericDiffCostFunction, EasyCaseFunctorCentralDifferences) {
 }
 
 TEST(NumericDiffCostFunction, EasyCaseFunctorForwardDifferences) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<EasyFunctor,
                                   FORWARD,
@@ -74,7 +75,7 @@ TEST(NumericDiffCostFunction, EasyCaseFunctorForwardDifferences) {
 }
 
 TEST(NumericDiffCostFunction, EasyCaseFunctorRidders) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<EasyFunctor,
                                   RIDDERS,
@@ -87,7 +88,7 @@ TEST(NumericDiffCostFunction, EasyCaseFunctorRidders) {
 }
 
 TEST(NumericDiffCostFunction, EasyCaseCostFunctionCentralDifferences) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<EasyCostFunction,
                                   CENTRAL,
@@ -100,7 +101,7 @@ TEST(NumericDiffCostFunction, EasyCaseCostFunctionCentralDifferences) {
 }
 
 TEST(NumericDiffCostFunction, EasyCaseCostFunctionForwardDifferences) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<EasyCostFunction,
                                   FORWARD,
@@ -113,7 +114,7 @@ TEST(NumericDiffCostFunction, EasyCaseCostFunctionForwardDifferences) {
 }
 
 TEST(NumericDiffCostFunction, EasyCaseCostFunctionRidders) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<EasyCostFunction,
                                   RIDDERS,
@@ -127,7 +128,7 @@ TEST(NumericDiffCostFunction, EasyCaseCostFunctionRidders) {
 
 TEST(NumericDiffCostFunction,
      TranscendentalCaseFunctorCentralDifferences) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<TranscendentalFunctor,
                                   CENTRAL,
@@ -141,7 +142,7 @@ TEST(NumericDiffCostFunction,
 
 TEST(NumericDiffCostFunction,
      TranscendentalCaseFunctorForwardDifferences) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<TranscendentalFunctor,
                                   FORWARD,
@@ -161,7 +162,7 @@ TEST(NumericDiffCostFunction,
   // behavior.
   options.ridders_relative_initial_step_size = 1e-3;
 
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<TranscendentalFunctor,
                                   RIDDERS,
@@ -175,7 +176,7 @@ TEST(NumericDiffCostFunction,
 
 TEST(NumericDiffCostFunction,
      TranscendentalCaseCostFunctionCentralDifferences) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<TranscendentalCostFunction,
                                   CENTRAL,
@@ -189,7 +190,7 @@ TEST(NumericDiffCostFunction,
 
 TEST(NumericDiffCostFunction,
      TranscendentalCaseCostFunctionForwardDifferences) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<TranscendentalCostFunction,
                                   FORWARD,
@@ -209,7 +210,7 @@ TEST(NumericDiffCostFunction,
   // behavior.
   options.ridders_relative_initial_step_size = 1e-3;
 
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<TranscendentalCostFunction,
                                   RIDDERS,
@@ -238,7 +239,7 @@ class SizeTestingCostFunction : public SizedCostFunction<num_rows, num_cols> {
 // templates are instantiated for various shapes of the Jacobian
 // matrix.
 TEST(NumericDiffCostFunction, EigenRowMajorColMajorTest) {
-  scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<SizeTestingCostFunction<1,1>,  CENTRAL, 1, 1>(
           new SizeTestingCostFunction<1,1>, ceres::TAKE_OWNERSHIP));
@@ -282,7 +283,7 @@ TEST(NumericDiffCostFunction, EigenRowMajorColMajorTest) {
 
 TEST(NumericDiffCostFunction,
      EasyCaseFunctorCentralDifferencesAndDynamicNumResiduals) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<EasyFunctor,
                                   CENTRAL,
@@ -295,7 +296,7 @@ TEST(NumericDiffCostFunction,
 }
 
 TEST(NumericDiffCostFunction, ExponentialFunctorRidders) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<ExponentialFunctor,
                                   RIDDERS,
@@ -307,7 +308,7 @@ TEST(NumericDiffCostFunction, ExponentialFunctorRidders) {
 }
 
 TEST(NumericDiffCostFunction, ExponentialCostFunctionRidders) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
       new NumericDiffCostFunction<ExponentialCostFunction,
                                   RIDDERS,
@@ -319,7 +320,7 @@ TEST(NumericDiffCostFunction, ExponentialCostFunctionRidders) {
 }
 
 TEST(NumericDiffCostFunction, RandomizedFunctorRidders) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   NumericDiffOptions options;
   // Larger initial step size is chosen to produce robust results in the
   // presence of random noise.
@@ -337,7 +338,7 @@ TEST(NumericDiffCostFunction, RandomizedFunctorRidders) {
 }
 
 TEST(NumericDiffCostFunction, RandomizedCostFunctionRidders) {
-  internal::scoped_ptr<CostFunction> cost_function;
+  std::unique_ptr<CostFunction> cost_function;
   NumericDiffOptions options;
   // Larger initial step size is chosen to produce robust results in the
   // presence of random noise.
@@ -368,7 +369,7 @@ TEST(NumericDiffCostFunction, PartiallyFilledResidualShouldFailEvaluation) {
   double* parameters[] = {&parameter};
   double* jacobians[] = {jacobian};
 
-  scoped_ptr<CostFunction> cost_function(
+  std::unique_ptr<CostFunction> cost_function(
       new NumericDiffCostFunction<OnlyFillsOneOutputFunctor, CENTRAL, 2, 1>(
           new OnlyFillsOneOutputFunctor));
   InvalidateArray(2, jacobian);

internal/ceres/parameter_block.h

@@ -33,6 +33,7 @@
 
 #include <algorithm>
 #include <cstdlib>
+#include <memory>
 #include <limits>
 #include <string>
 #include <unordered_set>
@@ -40,7 +41,6 @@
 #include "ceres/integral_types.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/local_parameterization.h"
 #include "ceres/stringprintf.h"
 #include "glog/logging.h"
@@ -368,7 +368,7 @@ class ParameterBlock {
   // ends up simplifying the internals of Ceres enough to justify the potential
   // pitfalls of using "mutable."
   mutable const double* state_;
-  mutable scoped_array<double> local_parameterization_jacobian_;
+  mutable std::unique_ptr<double[]> local_parameterization_jacobian_;
 
   // The index of the parameter. This is used by various other parts of Ceres to
   // permit switching from a ParameterBlock* to an index in another array.
@@ -381,7 +381,7 @@ class ParameterBlock {
   int32 delta_offset_;
 
   // If non-null, contains the residual blocks this parameter block is in.
-  scoped_ptr<ResidualBlockSet> residual_blocks_;
+  std::unique_ptr<ResidualBlockSet> residual_blocks_;
 
   // Upper and lower bounds for the parameter block.  SetUpperBound
   // and SetLowerBound lazily initialize the upper_bounds_ and
@@ -394,8 +394,8 @@ class ParameterBlock {
   // std::numeric_limits<double>::max() and
   // -std::numeric_limits<double>::max() respectively which correspond
   // to the parameter block being unconstrained.
-  scoped_array<double> upper_bounds_;
-  scoped_array<double> lower_bounds_;
+  std::unique_ptr<double[]> upper_bounds_;
+  std::unique_ptr<double[]> lower_bounds_;
 
   // Necessary so ProblemImpl can clean up the parameterizations.
   friend class ProblemImpl;

internal/ceres/parameter_block_ordering.cc

@@ -30,10 +30,11 @@
 
 #include "ceres/parameter_block_ordering.h"
 
+#include <memory>
 #include <unordered_set>
+
 #include "ceres/graph.h"
 #include "ceres/graph_algorithms.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/map_util.h"
 #include "ceres/parameter_block.h"
 #include "ceres/program.h"
@@ -52,7 +53,7 @@ int ComputeStableSchurOrdering(const Program& program,
                          vector<ParameterBlock*>* ordering) {
   CHECK_NOTNULL(ordering)->clear();
   EventLogger event_logger("ComputeStableSchurOrdering");
-  scoped_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
+  std::unique_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
   event_logger.AddEvent("CreateHessianGraph");
 
   const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
@@ -83,7 +84,7 @@ int ComputeSchurOrdering(const Program& program,
                          vector<ParameterBlock*>* ordering) {
   CHECK_NOTNULL(ordering)->clear();
 
-  scoped_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
+  std::unique_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
   int independent_set_size = IndependentSetOrdering(*graph, ordering);
   const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
 
@@ -102,7 +103,7 @@ void ComputeRecursiveIndependentSetOrdering(const Program& program,
                                             ParameterBlockOrdering* ordering) {
   CHECK_NOTNULL(ordering)->Clear();
   const vector<ParameterBlock*> parameter_blocks = program.parameter_blocks();
-  scoped_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
+  std::unique_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
 
   int num_covered = 0;
   int round = 0;

internal/ceres/parameter_block_ordering_test.cc

@@ -31,16 +31,17 @@
 #include "ceres/parameter_block_ordering.h"
 
 #include <cstddef>
+#include <memory>
 #include <unordered_set>
 #include <vector>
-#include "gtest/gtest.h"
+
+#include "ceres/cost_function.h"
 #include "ceres/graph.h"
 #include "ceres/problem_impl.h"
 #include "ceres/program.h"
-#include "ceres/stl_util.h"
-#include "ceres/cost_function.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/sized_cost_function.h"
+#include "ceres/stl_util.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -85,7 +86,7 @@ class SchurOrderingTest : public ::testing::Test {
 TEST_F(SchurOrderingTest, NoFixed) {
   const Program& program = problem_.program();
   const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
-  scoped_ptr<HessianGraph> graph(CreateHessianGraph(program));
+  std::unique_ptr<HessianGraph> graph(CreateHessianGraph(program));
 
   const VertexSet& vertices = graph->vertices();
   EXPECT_EQ(vertices.size(), 4);
@@ -130,7 +131,7 @@ TEST_F(SchurOrderingTest, AllFixed) {
   problem_.SetParameterBlockConstant(w_);
 
   const Program& program = problem_.program();
-  scoped_ptr<HessianGraph> graph(CreateHessianGraph(program));
+  std::unique_ptr<HessianGraph> graph(CreateHessianGraph(program));
   EXPECT_EQ(graph->vertices().size(), 0);
 }
 
@@ -139,7 +140,7 @@ TEST_F(SchurOrderingTest, OneFixed) {
 
   const Program& program = problem_.program();
   const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
-  scoped_ptr<HessianGraph> graph(CreateHessianGraph(program));
+  std::unique_ptr<HessianGraph> graph(CreateHessianGraph(program));
 
   const VertexSet& vertices = graph->vertices();
 

internal/ceres/partitioned_matrix_view_test.cc

@@ -30,11 +30,11 @@
 
 #include "ceres/partitioned_matrix_view.h"
 
+#include <memory>
 #include <vector>
 #include "ceres/block_structure.h"
 #include "ceres/casts.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/random.h"
 #include "ceres/sparse_matrix.h"
@@ -50,7 +50,7 @@ class PartitionedMatrixViewTest : public ::testing::Test {
  protected :
   virtual void SetUp() {
     srand(5);
-    scoped_ptr<LinearLeastSquaresProblem> problem(
+    std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(2));
     CHECK_NOTNULL(problem.get());
     A_.reset(problem->A.release());
@@ -68,8 +68,8 @@ class PartitionedMatrixViewTest : public ::testing::Test {
   int num_rows_;
   int num_cols_;
   int num_eliminate_blocks_;
-  scoped_ptr<SparseMatrix> A_;
-  scoped_ptr<PartitionedMatrixViewBase> pmv_;
+  std::unique_ptr<SparseMatrix> A_;
+  std::unique_ptr<PartitionedMatrixViewBase> pmv_;
 };
 
 TEST_F(PartitionedMatrixViewTest, DimensionsTest) {
@@ -143,7 +143,7 @@ TEST_F(PartitionedMatrixViewTest, LeftMultiply) {
 }
 
 TEST_F(PartitionedMatrixViewTest, BlockDiagonalEtE) {
-  scoped_ptr<BlockSparseMatrix>
+  std::unique_ptr<BlockSparseMatrix>
       block_diagonal_ee(pmv_->CreateBlockDiagonalEtE());
   const CompressedRowBlockStructure* bs  = block_diagonal_ee->block_structure();
 
@@ -157,7 +157,7 @@ TEST_F(PartitionedMatrixViewTest, BlockDiagonalEtE) {
 }
 
 TEST_F(PartitionedMatrixViewTest, BlockDiagonalFtF) {
-  scoped_ptr<BlockSparseMatrix>
+  std::unique_ptr<BlockSparseMatrix>
       block_diagonal_ff(pmv_->CreateBlockDiagonalFtF());
   const CompressedRowBlockStructure* bs  = block_diagonal_ff->block_structure();
 

internal/ceres/preprocessor.h

@@ -39,7 +39,6 @@
 #include "ceres/evaluator.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/iteration_callback.h"
 #include "ceres/linear_solver.h"
 #include "ceres/minimizer.h"
@@ -92,11 +91,11 @@ struct PreprocessedProblem {
   Minimizer::Options minimizer_options;
 
   ProblemImpl* problem;
-  scoped_ptr<ProblemImpl> gradient_checking_problem;
-  scoped_ptr<Program> reduced_program;
-  scoped_ptr<LinearSolver> linear_solver;
-  scoped_ptr<IterationCallback> logging_callback;
-  scoped_ptr<IterationCallback> state_updating_callback;
+  std::unique_ptr<ProblemImpl> gradient_checking_problem;
+  std::unique_ptr<Program> reduced_program;
+  std::unique_ptr<LinearSolver> linear_solver;
+  std::unique_ptr<IterationCallback> logging_callback;
+  std::unique_ptr<IterationCallback> state_updating_callback;
 
   std::shared_ptr<Evaluator> evaluator;
   std::shared_ptr<CoordinateDescentMinimizer> inner_iteration_minimizer;

internal/ceres/problem_impl.cc

@@ -34,10 +34,12 @@
 #include <algorithm>
 #include <cstddef>
 #include <iterator>
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
+
 #include "ceres/casts.h"
 #include "ceres/compressed_row_jacobian_writer.h"
 #include "ceres/compressed_row_sparse_matrix.h"
@@ -822,7 +824,7 @@ bool ProblemImpl::Evaluate(const Problem::EvaluateOptions& evaluate_options,
   context_impl_->EnsureMinimumThreads(evaluator_options.num_threads - 1);
   evaluator_options.context = context_impl_;
 
-  scoped_ptr<Evaluator> evaluator(
+  std::unique_ptr<Evaluator> evaluator(
       new ProgramEvaluator<ScratchEvaluatePreparer,
                            CompressedRowJacobianWriter>(evaluator_options,
                                                         &program));
@@ -835,7 +837,7 @@ bool ProblemImpl::Evaluate(const Problem::EvaluateOptions& evaluate_options,
     gradient->resize(evaluator->NumEffectiveParameters());
   }
 
-  scoped_ptr<CompressedRowSparseMatrix> tmp_jacobian;
+  std::unique_ptr<CompressedRowSparseMatrix> tmp_jacobian;
   if (jacobian != NULL) {
     tmp_jacobian.reset(
         down_cast<CompressedRowSparseMatrix*>(evaluator->CreateJacobian()));

internal/ceres/problem_impl.h

@@ -40,13 +40,13 @@
 #define CERES_PUBLIC_PROBLEM_IMPL_H_
 
 #include <map>
+#include <memory>
 #include <unordered_set>
 #include <vector>
 
 #include "ceres/context_impl.h"
 #include "ceres/internal/macros.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/problem.h"
 #include "ceres/types.h"
 
@@ -209,7 +209,7 @@ class ProblemImpl {
   ResidualBlockSet residual_block_set_;
 
   // The actual parameter and residual blocks.
-  internal::scoped_ptr<internal::Program> program_;
+  std::unique_ptr<internal::Program> program_;
 
   // When removing parameter blocks, parameterizations have ambiguous
   // ownership. Instead of scanning the entire problem to see if the

internal/ceres/problem_test.cc

@@ -32,12 +32,12 @@
 #include "ceres/problem.h"
 #include "ceres/problem_impl.h"
 
+#include <memory>
 #include "ceres/casts.h"
 #include "ceres/cost_function.h"
 #include "ceres/crs_matrix.h"
 #include "ceres/evaluator_test_utils.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/local_parameterization.h"
 #include "ceres/loss_function.h"
 #include "ceres/map_util.h"
@@ -496,7 +496,7 @@ struct DynamicProblem : public ::testing::TestWithParam<bool> {
     ExpectParameterBlockContainsResidualBlock(values, r4);
   }
 
-  scoped_ptr<ProblemImpl> problem;
+  std::unique_ptr<ProblemImpl> problem;
   double y[4], z[5], w[3];
 };
 

internal/ceres/program.cc

@@ -31,7 +31,9 @@
 #include "ceres/program.h"
 
 #include <map>
+#include <memory>
 #include <vector>
+
 #include "ceres/array_utils.h"
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
@@ -274,7 +276,7 @@ Program* Program::CreateReducedProgram(
   CHECK_NOTNULL(fixed_cost);
   CHECK_NOTNULL(error);
 
-  scoped_ptr<Program> reduced_program(new Program(*this));
+  std::unique_ptr<Program> reduced_program(new Program(*this));
   if (!reduced_program->RemoveFixedBlocks(removed_parameter_blocks,
                                           fixed_cost,
                                           error)) {
@@ -292,7 +294,7 @@ bool Program::RemoveFixedBlocks(vector<double*>* removed_parameter_blocks,
   CHECK_NOTNULL(fixed_cost);
   CHECK_NOTNULL(error);
 
-  scoped_array<double> residual_block_evaluate_scratch;
+  std::unique_ptr<double[]> residual_block_evaluate_scratch;
   residual_block_evaluate_scratch.reset(
       new double[MaxScratchDoublesNeededForEvaluate()]);
   *fixed_cost = 0.0;

internal/ceres/program_evaluator.h

@@ -83,12 +83,12 @@
 #include "ceres/internal/port.h"
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 #include "ceres/evaluation_callback.h"
 #include "ceres/execution_summary.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/parameter_block.h"
 #include "ceres/program.h"
 #include "ceres/residual_block.h"
@@ -373,12 +373,12 @@ class ProgramEvaluator : public Evaluator {
     }
 
     double cost;
-    scoped_array<double> residual_block_evaluate_scratch;
+    std::unique_ptr<double[]> residual_block_evaluate_scratch;
     // The gradient in the local parameterization.
-    scoped_array<double> gradient;
+    std::unique_ptr<double[]> gradient;
     // Enough space to store the residual for the largest residual block.
-    scoped_array<double> residual_block_residuals;
-    scoped_array<double*> jacobian_block_ptrs;
+    std::unique_ptr<double[]> residual_block_residuals;
+    std::unique_ptr<double*[]> jacobian_block_ptrs;
   };
 
   static void BuildResidualLayout(const Program& program,
@@ -418,8 +418,8 @@ class ProgramEvaluator : public Evaluator {
   Evaluator::Options options_;
   Program* program_;
   JacobianWriter jacobian_writer_;
-  scoped_array<EvaluatePreparer> evaluate_preparers_;
-  scoped_array<EvaluateScratch> evaluate_scratch_;
+  std::unique_ptr<EvaluatePreparer[]> evaluate_preparers_;
+  std::unique_ptr<EvaluateScratch[]> evaluate_scratch_;
   std::vector<int> residual_layout_;
   ::ceres::internal::ExecutionSummary execution_summary_;
 };

internal/ceres/program_test.cc

@@ -30,9 +30,11 @@
 
 #include "ceres/program.h"
 
-#include <limits>
 #include <cmath>
+#include <limits>
+#include <memory>
 #include <vector>
+
 #include "ceres/sized_cost_function.h"
 #include "ceres/problem_impl.h"
 #include "ceres/residual_block.h"
@@ -94,7 +96,7 @@ TEST(Program, RemoveFixedBlocksNothingConstant) {
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
   string message;
-  scoped_ptr<Program> reduced_program(
+  std::unique_ptr<Program> reduced_program(
       CHECK_NOTNULL(problem
                     .program()
                     .CreateReducedProgram(&removed_parameter_blocks,
@@ -118,7 +120,7 @@ TEST(Program, RemoveFixedBlocksAllParameterBlocksConstant) {
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
   string message;
-  scoped_ptr<Program> reduced_program(
+  std::unique_ptr<Program> reduced_program(
       CHECK_NOTNULL(problem
                     .program()
                     .CreateReducedProgram(&removed_parameter_blocks,
@@ -145,7 +147,7 @@ TEST(Program, RemoveFixedBlocksNoResidualBlocks) {
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
   string message;
-  scoped_ptr<Program> reduced_program(
+  std::unique_ptr<Program> reduced_program(
       CHECK_NOTNULL(problem
                     .program()
                     .CreateReducedProgram(&removed_parameter_blocks,
@@ -174,7 +176,7 @@ TEST(Program, RemoveFixedBlocksOneParameterBlockConstant) {
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
   string message;
-  scoped_ptr<Program> reduced_program(
+  std::unique_ptr<Program> reduced_program(
       CHECK_NOTNULL(problem
                     .program()
                     .CreateReducedProgram(&removed_parameter_blocks,
@@ -201,7 +203,7 @@ TEST(Program, RemoveFixedBlocksNumEliminateBlocks) {
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
   string message;
-  scoped_ptr<Program> reduced_program(
+  std::unique_ptr<Program> reduced_program(
       CHECK_NOTNULL(problem
                     .program()
                     .CreateReducedProgram(&removed_parameter_blocks,
@@ -227,7 +229,7 @@ TEST(Program, RemoveFixedBlocksFixedCost) {
 
   ResidualBlock *expected_removed_block =
       problem.program().residual_blocks()[0];
-  scoped_array<double> scratch(
+  std::unique_ptr<double[]> scratch(
       new double[expected_removed_block->NumScratchDoublesForEvaluate()]);
   double expected_fixed_cost;
   expected_removed_block->Evaluate(true,
@@ -240,7 +242,7 @@ TEST(Program, RemoveFixedBlocksFixedCost) {
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
   string message;
-  scoped_ptr<Program> reduced_program(
+  std::unique_ptr<Program> reduced_program(
       CHECK_NOTNULL(problem
                     .program()
                     .CreateReducedProgram(&removed_parameter_blocks,
@@ -318,7 +320,7 @@ TEST(Program, CreateJacobianBlockSparsityTranspose) {
   Program* program = problem.mutable_program();
   program->SetParameterOffsetsAndIndex();
 
-  scoped_ptr<TripletSparseMatrix> actual_block_sparse_jacobian(
+  std::unique_ptr<TripletSparseMatrix> actual_block_sparse_jacobian(
       program->CreateJacobianBlockSparsityTranspose());
 
   Matrix expected_dense_jacobian;
@@ -385,7 +387,7 @@ TEST(Program, ReallocationInCreateJacobianBlockSparsityTranspose) {
   Program* program = problem.mutable_program();
   program->SetParameterOffsetsAndIndex();
 
-  scoped_ptr<TripletSparseMatrix> actual_block_sparse_jacobian(
+  std::unique_ptr<TripletSparseMatrix> actual_block_sparse_jacobian(
       program->CreateJacobianBlockSparsityTranspose());
 
   Matrix expected_dense_jacobian;

internal/ceres/reorder_program.cc

@@ -31,6 +31,7 @@
 #include "ceres/reorder_program.h"
 
 #include <algorithm>
+#include <memory>
 #include <numeric>
 #include <vector>
 
@@ -359,7 +360,7 @@ void MaybeReorderSchurComplementColumnsUsingSuiteSparse(
   MapValuesToContiguousRange(constraints.size(), &constraints[0]);
 
   // Compute a block sparse presentation of J'.
-  scoped_ptr<TripletSparseMatrix> tsm_block_jacobian_transpose(
+  std::unique_ptr<TripletSparseMatrix> tsm_block_jacobian_transpose(
       program->CreateJacobianBlockSparsityTranspose());
 
   cholmod_sparse* block_jacobian_transpose =
@@ -388,7 +389,7 @@ void MaybeReorderSchurComplementColumnsUsingEigen(
   return;
 #else
 
-  scoped_ptr<TripletSparseMatrix> tsm_block_jacobian_transpose(
+  std::unique_ptr<TripletSparseMatrix> tsm_block_jacobian_transpose(
       program->CreateJacobianBlockSparsityTranspose());
 
   typedef Eigen::SparseMatrix<int> SparseMatrix;
@@ -550,7 +551,7 @@ bool ReorderProgramForSparseNormalCholesky(
   }
 
   // Compute a block sparse presentation of J'.
-  scoped_ptr<TripletSparseMatrix> tsm_block_jacobian_transpose(
+  std::unique_ptr<TripletSparseMatrix> tsm_block_jacobian_transpose(
       program->CreateJacobianBlockSparsityTranspose());
 
   vector<int> ordering(program->NumParameterBlocks(), 0);

internal/ceres/residual_block.h

@@ -34,12 +34,12 @@
 #ifndef CERES_INTERNAL_RESIDUAL_BLOCK_H_
 #define CERES_INTERNAL_RESIDUAL_BLOCK_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "ceres/cost_function.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
 
@@ -134,7 +134,7 @@ class ResidualBlock {
  private:
   const CostFunction* cost_function_;
   const LossFunction* loss_function_;
-  scoped_array<ParameterBlock*> parameter_blocks_;
+  std::unique_ptr<ParameterBlock*[]> parameter_blocks_;
 
   // The index of the residual, typically in a Program. This is only to permit
   // switching from a ResidualBlock* to an index in the Program's array, needed

internal/ceres/residual_block_utils_test.cc

@@ -30,12 +30,12 @@
 
 #include <cmath>
 #include <limits>
+#include <memory>
 #include "gtest/gtest.h"
 #include "ceres/parameter_block.h"
 #include "ceres/residual_block.h"
 #include "ceres/residual_block_utils.h"
 #include "ceres/cost_function.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/sized_cost_function.h"
 
 namespace ceres {
@@ -54,7 +54,7 @@ void CheckEvaluation(const CostFunction& cost_function, bool is_good) {
                                parameter_blocks,
                                -1);
 
-  scoped_array<double> scratch(
+  std::unique_ptr<double[]> scratch(
       new double[residual_block.NumScratchDoublesForEvaluate()]);
 
   double cost;

internal/ceres/schur_complement_solver.cc

@@ -32,6 +32,7 @@
 
 #include <algorithm>
 #include <ctime>
+#include <memory>
 #include <set>
 #include <vector>
 
@@ -45,7 +46,6 @@
 #include "ceres/conjugate_gradients_solver.h"
 #include "ceres/detect_structure.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/lapack.h"
 #include "ceres/linear_solver.h"
 #include "ceres/sparse_cholesky.h"
@@ -325,7 +325,7 @@ LinearSolver::Summary SparseSchurComplementSolver::SolveReducedLinearSystem(
     return summary;
   }
 
-  scoped_ptr<CompressedRowSparseMatrix> lhs;
+  std::unique_ptr<CompressedRowSparseMatrix> lhs;
   const CompressedRowSparseMatrix::StorageType storage_type =
       sparse_cholesky_->StorageType();
   if (storage_type == CompressedRowSparseMatrix::UPPER_TRIANGULAR) {
@@ -399,9 +399,9 @@ SparseSchurComplementSolver::SolveReducedLinearSystemUsingConjugateGradients(
 
   VectorRef(solution, num_rows).setZero();
 
-  scoped_ptr<LinearOperator> lhs_adapter(
+  std::unique_ptr<LinearOperator> lhs_adapter(
       new BlockRandomAccessSparseMatrixAdapter(*sc));
-  scoped_ptr<LinearOperator> preconditioner_adapter(
+  std::unique_ptr<LinearOperator> preconditioner_adapter(
       new BlockRandomAccessDiagonalMatrixAdapter(*preconditioner_));
 
 

internal/ceres/schur_complement_solver.h

@@ -31,6 +31,7 @@
 #ifndef CERES_INTERNAL_SCHUR_COMPLEMENT_SOLVER_H_
 #define CERES_INTERNAL_SCHUR_COMPLEMENT_SOLVER_H_
 
+#include <memory>
 #include <set>
 #include <utility>
 #include <vector>
@@ -40,7 +41,6 @@
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/internal/port.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_solver.h"
 #include "ceres/schur_eliminator.h"
 #include "ceres/types.h"
@@ -140,9 +140,9 @@ class SchurComplementSolver : public BlockSparseMatrixSolver {
 
   LinearSolver::Options options_;
 
-  scoped_ptr<SchurEliminatorBase> eliminator_;
-  scoped_ptr<BlockRandomAccessMatrix> lhs_;
-  scoped_array<double> rhs_;
+  std::unique_ptr<SchurEliminatorBase> eliminator_;
+  std::unique_ptr<BlockRandomAccessMatrix> lhs_;
+  std::unique_ptr<double[]> rhs_;
 
   CERES_DISALLOW_COPY_AND_ASSIGN(SchurComplementSolver);
 };
@@ -180,8 +180,8 @@ class SparseSchurComplementSolver : public SchurComplementSolver {
 
   // Size of the blocks in the Schur complement.
   std::vector<int> blocks_;
-  scoped_ptr<SparseCholesky> sparse_cholesky_;
-  scoped_ptr<BlockRandomAccessDiagonalMatrix> preconditioner_;
+  std::unique_ptr<SparseCholesky> sparse_cholesky_;
+  std::unique_ptr<BlockRandomAccessDiagonalMatrix> preconditioner_;
   CERES_DISALLOW_COPY_AND_ASSIGN(SparseSchurComplementSolver);
 };
 

internal/ceres/schur_complement_solver_test.cc

@@ -31,13 +31,13 @@
 #include "ceres/schur_complement_solver.h"
 
 #include <cstddef>
+#include <memory>
 
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/casts.h"
 #include "ceres/context_impl.h"
 #include "ceres/detect_structure.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/linear_solver.h"
 #include "ceres/triplet_sparse_matrix.h"
@@ -51,7 +51,7 @@ namespace internal {
 class SchurComplementSolverTest : public ::testing::Test {
  protected:
   void SetUpFromProblemId(int problem_id) {
-    scoped_ptr<LinearLeastSquaresProblem> problem(
+    std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(problem_id));
 
     CHECK_NOTNULL(problem.get());
@@ -72,7 +72,7 @@ class SchurComplementSolverTest : public ::testing::Test {
     ContextImpl context;
     options.context = &context;
 
-    scoped_ptr<LinearSolver> qr(LinearSolver::Create(options));
+    std::unique_ptr<LinearSolver> qr(LinearSolver::Create(options));
 
     TripletSparseMatrix triplet_A(A->num_rows(),
                                   A->num_cols(),
@@ -115,7 +115,7 @@ class SchurComplementSolverTest : public ::testing::Test {
                     &options.e_block_size,
                     &options.f_block_size);
 
-    scoped_ptr<LinearSolver> solver(LinearSolver::Create(options));
+    std::unique_ptr<LinearSolver> solver(LinearSolver::Create(options));
 
     LinearSolver::PerSolveOptions per_solve_options;
     LinearSolver::Summary summary;
@@ -142,9 +142,9 @@ class SchurComplementSolverTest : public ::testing::Test {
   int num_cols;
   int num_eliminate_blocks;
 
-  scoped_ptr<BlockSparseMatrix> A;
-  scoped_array<double> b;
-  scoped_array<double> D;
+  std::unique_ptr<BlockSparseMatrix> A;
+  std::unique_ptr<double[]> b;
+  std::unique_ptr<double[]> D;
   Vector x;
   Vector sol;
   Vector sol_d;

internal/ceres/schur_eliminator.h

@@ -32,13 +32,14 @@
 #define CERES_INTERNAL_SCHUR_ELIMINATOR_H_
 
 #include <map>
+#include <memory>
 #include <mutex>
 #include <vector>
+
 #include "ceres/block_random_access_matrix.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_solver.h"
 
 namespace ceres {
@@ -343,7 +344,7 @@ class SchurEliminator : public SchurEliminatorBase {
   //
   //   [thread_id * buffer_size_ , (thread_id + 1) * buffer_size_]
   //
-  scoped_array<double> buffer_;
+  std::unique_ptr<double[]> buffer_;
 
   // Buffer to store per thread matrix matrix products used by
   // ChunkOuterProduct. Like buffer_ it is of size num_threads *
@@ -351,7 +352,7 @@ class SchurEliminator : public SchurEliminatorBase {
   //
   //   [thread_id * buffer_size_ , (thread_id + 1) * buffer_size_ -1]
   //
-  scoped_array<double> chunk_outer_product_buffer_;
+  std::unique_ptr<double[]> chunk_outer_product_buffer_;
 
   int buffer_size_;
   int uneliminated_row_begins_;

internal/ceres/schur_eliminator_impl.h

@@ -50,12 +50,12 @@
 
 #include <algorithm>
 #include <map>
+
 #include "ceres/block_random_access_matrix.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/fixed_array.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/invert_psd_matrix.h"
 #include "ceres/map_util.h"
 #include "ceres/schur_eliminator.h"

internal/ceres/schur_eliminator_test.cc

@@ -30,6 +30,7 @@
 
 #include "ceres/schur_eliminator.h"
 
+#include <memory>
 #include "Eigen/Dense"
 #include "ceres/block_random_access_dense_matrix.h"
 #include "ceres/block_sparse_matrix.h"
@@ -37,7 +38,6 @@
 #include "ceres/context_impl.h"
 #include "ceres/detect_structure.h"
 #include "ceres/internal/eigen.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/test_util.h"
 #include "ceres/triplet_sparse_matrix.h"
@@ -54,7 +54,7 @@ namespace internal {
 class SchurEliminatorTest : public ::testing::Test {
  protected:
   void SetUpFromId(int id) {
-    scoped_ptr<LinearLeastSquaresProblem>
+    std::unique_ptr<LinearLeastSquaresProblem>
         problem(CreateLinearLeastSquaresProblemFromId(id));
     CHECK_NOTNULL(problem.get());
     SetupHelper(problem.get());
@@ -154,7 +154,7 @@ class SchurEliminatorTest : public ::testing::Test {
                       &options.f_block_size);
     }
 
-    scoped_ptr<SchurEliminatorBase> eliminator;
+    std::unique_ptr<SchurEliminatorBase> eliminator;
     eliminator.reset(SchurEliminatorBase::Create(options));
     const bool kFullRankETE = true;
     eliminator->Init(num_eliminate_blocks, kFullRankETE, A->block_structure());
@@ -186,9 +186,9 @@ class SchurEliminatorTest : public ::testing::Test {
                 relative_tolerance);
   }
 
-  scoped_ptr<BlockSparseMatrix> A;
-  scoped_array<double> b;
-  scoped_array<double> D;
+  std::unique_ptr<BlockSparseMatrix> A;
+  std::unique_ptr<double[]> b;
+  std::unique_ptr<double[]> D;
   int num_eliminate_blocks;
   int num_eliminate_cols;
 

internal/ceres/schur_jacobi_preconditioner.cc

@@ -32,9 +32,9 @@
 
 #include <utility>
 #include <vector>
+
 #include "ceres/block_random_access_diagonal_matrix.h"
 #include "ceres/block_sparse_matrix.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/linear_solver.h"
 #include "ceres/schur_eliminator.h"
 #include "glog/logging.h"

internal/ceres/schur_jacobi_preconditioner.h

@@ -38,11 +38,12 @@
 #ifndef CERES_INTERNAL_SCHUR_JACOBI_PRECONDITIONER_H_
 #define CERES_INTERNAL_SCHUR_JACOBI_PRECONDITIONER_H_
 
+#include <memory>
 #include <set>
-#include <vector>
 #include <utility>
+#include <vector>
+
 #include "ceres/internal/macros.h"
-#include "ceres/internal/scoped_ptr.h"
 #include "ceres/preconditioner.h"
 
 namespace ceres {
@@ -93,9 +94,9 @@ class SchurJacobiPreconditioner : public BlockSparseMatrixPreconditioner {
   virtual bool UpdateImpl(const BlockSparseMatrix& A, const double* D);
 
   Preconditioner::Options options_;
-  scoped_ptr<SchurEliminatorBase> eliminator_;
+  std::unique_ptr<SchurEliminatorBase> eliminator_;
   // Preconditioner matrix.
-  scoped_ptr<BlockRandomAccessDiagonalMatrix> m_;
+  std::unique_ptr<BlockRandomAccessDiagonalMatrix> m_;
   CERES_DISALLOW_COPY_AND_ASSIGN(SchurJacobiPreconditioner);
 };
 

internal/ceres/scratch_evaluate_preparer.h

@@ -35,7 +35,7 @@
 #ifndef CERES_INTERNAL_SCRATCH_EVALUATE_PREPARER_H_
 #define CERES_INTERNAL_SCRATCH_EVALUATE_PREPARER_H_
 
-#include "ceres/internal/scoped_ptr.h"
+#include <memory>
 
 namespace ceres {
 namespace internal {
@@ -60,7 +60,7 @@ class ScratchEvaluatePreparer {
  private:
   // Scratch space for the jacobians; each jacobian is packed one after another.
   // There is enough scratch to hold all the jacobians for the largest residual.
-  scoped_array<double> jacobian_scratch_;
+  std::unique_ptr<double[]> jacobian_scratch_;
 };
 
 }  // namespace internal