Update minimum required C++ version for Ceres to C++14
- Removes all workarounds for pre-C++14 versions
- Removes '11' qualifier from C++ threading option and associated
defines.
- Fix missing inclusion of 'Multithreading' in reported Ceres components
when C++ threading model is enabled.
- Update Sphinx documentation to specify C++14 as minimum requirement.
Change-Id: I706c8b367b3221e3c4d1a0aaf669a8f9c911e438
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ea39ad4..948bddb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,19 +32,19 @@
cmake_minimum_required(VERSION 3.5)
cmake_policy(VERSION 3.5)
-# Set the C++ version (must be >= C++11) when compiling Ceres.
+# Set the C++ version (must be >= C++14) when compiling Ceres.
#
# Reflect a user-specified (via -D) CMAKE_CXX_STANDARD if present, otherwise
-# default to C++11.
+# default to C++14.
set(DEFAULT_CXX_STANDARD ${CMAKE_CXX_STANDARD})
if (NOT DEFAULT_CXX_STANDARD)
- set(DEFAULT_CXX_STANDARD 11)
+ set(DEFAULT_CXX_STANDARD 14)
endif()
set(CMAKE_CXX_STANDARD ${DEFAULT_CXX_STANDARD} CACHE STRING
- "C++ standard (minimum 11)" FORCE)
+ "C++ standard (minimum 14)" FORCE)
# Restrict CMAKE_CXX_STANDARD to the valid versions permitted and ensure that
# if one was forced via -D that it is in the valid set.
-set(ALLOWED_CXX_STANDARDS 11 14 17 20)
+set(ALLOWED_CXX_STANDARDS 14 17 20)
set_property(CACHE CMAKE_CXX_STANDARD PROPERTY STRINGS ${ALLOWED_CXX_STANDARDS})
list(FIND ALLOWED_CXX_STANDARDS ${CMAKE_CXX_STANDARD} POSITION)
if (POSITION LESS 0)
@@ -56,11 +56,13 @@
set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE BOOL "")
mark_as_advanced(CMAKE_CXX_STANDARD_REQUIRED)
-# MSVC versions < 2013 did not fully support >= C++11.
+# MSVC versions < 2015 did not fully support >= C++14, and technically even
+# 2015 did not support a couple of smaller features
if (CMAKE_CXX_COMPILER_ID MATCHES MSVC AND
- CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
+ CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14.0)
message(FATAL_ERROR "Invalid CMAKE_CXX_COMPILER_VERSION: "
- "${CMAKE_CXX_COMPILER_VERSION}. Ceres requires at least MSVC 2013 Update 4+")
+ "${CMAKE_CXX_COMPILER_VERSION}. Ceres requires at least MSVC 2015 for "
+ "C++14 support.")
endif()
# On macOS, add the Homebrew prefix (with appropriate suffixes) to the
diff --git a/bazel/ceres.bzl b/bazel/ceres.bzl
index e58f32e..9f12f1b 100644
--- a/bazel/ceres.bzl
+++ b/bazel/ceres.bzl
@@ -196,7 +196,7 @@
"CERES_NO_ACCELERATE_SPARSE",
"CERES_NO_LAPACK",
"CERES_USE_EIGEN_SPARSE",
- "CERES_USE_CXX11_THREADS",
+ "CERES_USE_CXX_THREADS",
],
includes = [
"config",
diff --git a/cmake/CeresCompileOptionsToComponents.cmake b/cmake/CeresCompileOptionsToComponents.cmake
index ccf0fa2..5be0fb2 100644
--- a/cmake/CeresCompileOptionsToComponents.cmake
+++ b/cmake/CeresCompileOptionsToComponents.cmake
@@ -84,6 +84,8 @@
CERES_RESTRICT_SCHUR_SPECIALIZATION "SchurSpecializations")
add_to_output_if_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
CERES_USE_OPENMP "OpenMP;Multithreading")
+ add_to_output_if_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
+ CERES_USE_CXX_THREADS "Multithreading")
# Remove duplicates of SparseLinearAlgebraLibrary if multiple sparse backends
# are present.
list(REMOVE_DUPLICATES ${CERES_COMPONENTS_VAR})
diff --git a/cmake/CeresThreadingModels.cmake b/cmake/CeresThreadingModels.cmake
index 24e8aab..571dd7d 100644
--- a/cmake/CeresThreadingModels.cmake
+++ b/cmake/CeresThreadingModels.cmake
@@ -29,7 +29,7 @@
# Author: alexs.mac@gmail.com (Alex Stewart)
# Ordered by expected preference.
-set(CERES_THREADING_MODELS "CXX11_THREADS;OPENMP;NO_THREADS")
+set(CERES_THREADING_MODELS "CXX_THREADS;OPENMP;NO_THREADS")
function(find_available_ceres_threading_models CERES_THREADING_MODELS_AVAILABLE_VAR)
set(CERES_THREADING_MODELS_AVAILABLE ${CERES_THREADING_MODELS})
@@ -48,7 +48,7 @@
endfunction()
macro(set_ceres_threading_model_to_cxx11_threads)
- list(APPEND CERES_COMPILE_OPTIONS CERES_USE_CXX11_THREADS)
+ list(APPEND CERES_COMPILE_OPTIONS CERES_USE_CXX_THREADS)
endmacro()
macro(set_ceres_threading_model_to_openmp)
@@ -63,7 +63,7 @@
endmacro()
macro(set_ceres_threading_model CERES_THREADING_MODEL_TO_SET)
- if ("${CERES_THREADING_MODEL_TO_SET}" STREQUAL "CXX11_THREADS")
+ if ("${CERES_THREADING_MODEL_TO_SET}" STREQUAL "CXX_THREADS")
set_ceres_threading_model_to_cxx11_threads()
elseif ("${CERES_THREADING_MODEL_TO_SET}" STREQUAL "OPENMP")
set_ceres_threading_model_to_openmp()
diff --git a/cmake/config.h.in b/cmake/config.h.in
index 1caacfe..4a516f6 100644
--- a/cmake/config.h.in
+++ b/cmake/config.h.in
@@ -73,10 +73,10 @@
// If defined, Ceres was compiled without multithreading support.
@CERES_NO_THREADS@
-// If defined Ceres was compiled with OpenMP multithreading support.
+// If defined Ceres was compiled with OpenMP multithreading.
@CERES_USE_OPENMP@
-// If defined Ceres was compiled with C++11 thread support.
-@CERES_USE_CXX11_THREADS@
+// If defined Ceres was compiled with modern C++ multithreading.
+@CERES_USE_CXX_THREADS@
// If defined, Ceres was built as a shared library.
@CERES_USING_SHARED_LIBRARY@
diff --git a/docs/source/features.rst b/docs/source/features.rst
index 348511d..724d6dc 100644
--- a/docs/source/features.rst
+++ b/docs/source/features.rst
@@ -54,8 +54,9 @@
of Non-linear Conjugate Gradients, BFGS and LBFGS.
* **Speed** - Ceres Solver has been extensively optimized, with C++
- templating, hand written linear algebra routines and OpenMP or C++11 threads
- based multithreading of the Jacobian evaluation and the linear solvers.
+ templating, hand written linear algebra routines and OpenMP or
+ modern C++ threads based multithreading of the Jacobian evaluation
+ and the linear solvers.
* **Solution Quality** Ceres is the `best performing`_ solver on the NIST
problem set used by Mondragon and Borchers for benchmarking
diff --git a/docs/source/installation.rst b/docs/source/installation.rst
index d0e458f..2d844cb 100644
--- a/docs/source/installation.rst
+++ b/docs/source/installation.rst
@@ -23,9 +23,8 @@
.. NOTE ::
- All versions of Ceres > 1.14 require a **fully C++11-compliant**
- compiler. In versions <= 1.14, C++11 was an optional requirement
- controlled by the ``CXX11 [Default: OFF]`` build option.
+ Starting with v2.0 Ceres requires a **fully C++14-compliant**
+ compiler. In versions <= 1.14, C++11 was an optional requirement.
Ceres relies on a number of open source libraries, some of which are
optional. For details on customizing the build process, see
@@ -378,7 +377,7 @@
<https://github.com/tbennun/ceres-windows>`_ for Ceres Solver by Tal
Ben-Nun.
-On Windows, we support building with Visual Studio 2013 Release 4 or newer. Note
+On Windows, we support building with Visual Studio 2015.2 of newer. Note
that the Windows port is less featureful and less tested than the
Linux or Mac OS X versions due to the lack of an officially supported
way of building SuiteSparse and CXSparse. There are however a number
@@ -709,7 +708,7 @@
gains in the ``SPARSE_SCHUR`` solver, you can disable some of the
template specializations by turning this ``OFF``.
-#. ``CERES_THREADING_MODEL [Default: CXX11_THREADS > OPENMP > NO_THREADS]``:
+#. ``CERES_THREADING_MODEL [Default: CXX_THREADS > OPENMP > NO_THREADS]``:
Multi-threading backend Ceres should be compiled with. This will
automatically be set to only accept the available subset of threading
options in the CMake GUI.
@@ -904,8 +903,6 @@
#. ``Multithreading``: Ceres built with *a* multithreading library.
This is equivalent to (``CERES_THREAD != NO_THREADS``).
-#. ``C++11``: Ceres built with C++11.
-
To specify one/multiple Ceres components use the ``COMPONENTS`` argument to
`find_package()
<http://www.cmake.org/cmake/help/v3.2/command/find_package.html>`_ like so:
diff --git a/docs/source/nnls_solving.rst b/docs/source/nnls_solving.rst
index afe5546..592ee41 100644
--- a/docs/source/nnls_solving.rst
+++ b/docs/source/nnls_solving.rst
@@ -2226,7 +2226,7 @@
Number of threads actually used by the solver for Jacobian and
residual evaluation. This number is not equal to
:member:`Solver::Summary::num_threads_given` if none of `OpenMP`
- or `CXX11_THREADS` is available.
+ or `CXX_THREADS` is available.
.. member:: LinearSolverType Solver::Summary::linear_solver_type_given
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index a6b3f5d..27e736a 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -52,9 +52,7 @@
add_executable(curve_fitting_c curve_fitting.c)
target_link_libraries(curve_fitting_c Ceres::ceres)
-# Force CMake to link curve_fitting_c using the C linker, this is important
-# when Ceres was compiled using C++11 to ensure that -std=c++11 is not passed
-# through.
+# Force CMake to link curve_fitting_c using the C linker.
set_target_properties(curve_fitting_c PROPERTIES LINKER_LANGUAGE C)
# As this is a C file #including <math.h> we have to explicitly add the math
# library (libm). Although some compilers (dependent upon options) will accept
diff --git a/include/ceres/cost_function_to_functor.h b/include/ceres/cost_function_to_functor.h
index cbd6186..1beeb90 100644
--- a/include/ceres/cost_function_to_functor.h
+++ b/include/ceres/cost_function_to_functor.h
@@ -89,12 +89,12 @@
#include <cstdint>
#include <numeric>
#include <tuple>
+#include <utility>
#include <vector>
#include "ceres/cost_function.h"
#include "ceres/dynamic_cost_function_to_functor.h"
#include "ceres/internal/fixed_array.h"
-#include "ceres/internal/integer_sequence.h"
#include "ceres/internal/parameter_dims.h"
#include "ceres/internal/port.h"
#include "ceres/types.h"
@@ -144,8 +144,8 @@
// Extract parameter block pointers from params.
using Indices =
- internal::make_integer_sequence<int,
- ParameterDims::kNumParameterBlocks>;
+ std::make_integer_sequence<int,
+ ParameterDims::kNumParameterBlocks>;
std::array<const T*, ParameterDims::kNumParameterBlocks> parameter_blocks =
GetParameterPointers<T>(params, Indices());
@@ -158,7 +158,7 @@
template <typename T, typename Tuple, int... Indices>
static std::array<const T*, ParameterDims::kNumParameterBlocks>
GetParameterPointers(const Tuple& paramPointers,
- internal::integer_sequence<int, Indices...>) {
+ std::integer_sequence<int, Indices...>) {
return std::array<const T*, ParameterDims::kNumParameterBlocks>{
{std::get<Indices>(paramPointers)...}};
}
diff --git a/include/ceres/internal/algorithm.h b/include/ceres/internal/algorithm.h
deleted file mode 100644
index 3872055..0000000
--- a/include/ceres/internal/algorithm.h
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: algorithm.h
-// -----------------------------------------------------------------------------
-//
-// This header file contains Google extensions to the standard <algorithm> C++
-// header.
-
-#ifndef CERES_PUBLIC_INTERNAL_ALGORITHM_H_
-#define CERES_PUBLIC_INTERNAL_ALGORITHM_H_
-
-#include <algorithm>
-#include <iterator>
-#include <type_traits>
-
-namespace ceres {
-namespace internal {
-
-// Performs comparisons with operator==, similar to C++14's `std::equal_to<>`.
-struct EqualTo {
- template <typename T, typename U>
- bool operator()(const T& a, const U& b) const {
- return a == b;
- }
-};
-
-template <typename InputIter1, typename InputIter2, typename Pred>
-bool EqualImpl(InputIter1 first1,
- InputIter1 last1,
- InputIter2 first2,
- InputIter2 last2,
- Pred pred,
- std::input_iterator_tag,
- std::input_iterator_tag) {
- while (true) {
- if (first1 == last1) return first2 == last2;
- if (first2 == last2) return false;
- if (!pred(*first1, *first2)) return false;
- ++first1;
- ++first2;
- }
-}
-
-template <typename InputIter1, typename InputIter2, typename Pred>
-bool EqualImpl(InputIter1 first1,
- InputIter1 last1,
- InputIter2 first2,
- InputIter2 last2,
- Pred&& pred,
- std::random_access_iterator_tag,
- std::random_access_iterator_tag) {
- return (last1 - first1 == last2 - first2) &&
- std::equal(first1, last1, first2, std::forward<Pred>(pred));
-}
-
-// When we are using our own internal predicate that just applies operator==, we
-// forward to the non-predicate form of std::equal. This enables an optimization
-// in libstdc++ that can result in std::memcmp being used for integer types.
-template <typename InputIter1, typename InputIter2>
-bool EqualImpl(InputIter1 first1,
- InputIter1 last1,
- InputIter2 first2,
- InputIter2 last2,
- internal::EqualTo /* unused */,
- std::random_access_iterator_tag,
- std::random_access_iterator_tag) {
- return (last1 - first1 == last2 - first2) &&
- std::equal(first1, last1, first2);
-}
-
-// Compares the equality of two ranges specified by pairs of iterators, using
-// the given predicate, returning true iff for each corresponding iterator i1
-// and i2 in the first and second range respectively, pred(*i1, *i2) == true
-//
-// This comparison takes at most min(`last1` - `first1`, `last2` - `first2`)
-// invocations of the predicate. Additionally, if InputIter1 and InputIter2 are
-// both random-access iterators, and `last1` - `first1` != `last2` - `first2`,
-// then the predicate is never invoked and the function returns false.
-//
-// This is a C++11-compatible implementation of C++14 `std::equal`. See
-// https://en.cppreference.com/w/cpp/algorithm/equal for more information.
-template <typename InputIter1, typename InputIter2, typename Pred>
-bool equal(InputIter1 first1,
- InputIter1 last1,
- InputIter2 first2,
- InputIter2 last2,
- Pred&& pred) {
- return internal::EqualImpl(
- first1,
- last1,
- first2,
- last2,
- std::forward<Pred>(pred),
- typename std::iterator_traits<InputIter1>::iterator_category{},
- typename std::iterator_traits<InputIter2>::iterator_category{});
-}
-
-// Performs comparison of two ranges specified by pairs of iterators using
-// operator==.
-template <typename InputIter1, typename InputIter2>
-bool equal(InputIter1 first1,
- InputIter1 last1,
- InputIter2 first2,
- InputIter2 last2) {
- return internal::equal(first1, last1, first2, last2, internal::EqualTo{});
-}
-} // namespace internal
-} // namespace ceres
-#endif // CERES_PUBLIC_INTERNAL_ALGORITHM_H_
\ No newline at end of file
diff --git a/include/ceres/internal/autodiff.h b/include/ceres/internal/autodiff.h
index 0603321..71b7bae 100644
--- a/include/ceres/internal/autodiff.h
+++ b/include/ceres/internal/autodiff.h
@@ -143,6 +143,7 @@
#include <stddef.h>
#include <array>
+#include <utility>
#include "ceres/internal/array_selector.h"
#include "ceres/internal/eigen.h"
@@ -213,14 +214,14 @@
struct Make1stOrderPerturbations;
template <int N, int... Ns, int ParameterIdx, int Offset>
-struct Make1stOrderPerturbations<integer_sequence<int, N, Ns...>,
+struct Make1stOrderPerturbations<std::integer_sequence<int, N, Ns...>,
ParameterIdx,
Offset> {
template <typename T, typename JetT>
inline static void Apply(T const* const* parameters, JetT* x) {
Make1stOrderPerturbation<0, N, Offset, T, JetT>::Apply(
parameters[ParameterIdx], x + Offset);
- Make1stOrderPerturbations<integer_sequence<int, Ns...>,
+ Make1stOrderPerturbations<std::integer_sequence<int, Ns...>,
ParameterIdx + 1,
Offset + N>::Apply(parameters, x);
}
@@ -228,7 +229,7 @@
// End of 'recursion'. Nothing more to do.
template <int ParameterIdx, int Total>
-struct Make1stOrderPerturbations<integer_sequence<int>, ParameterIdx, Total> {
+struct Make1stOrderPerturbations<std::integer_sequence<int>, ParameterIdx, Total> {
template <typename T, typename JetT>
static void Apply(T const* const* /* NOT USED */, JetT* /* NOT USED */) {}
};
@@ -276,7 +277,7 @@
struct Take1stOrderParts;
template <int N, int... Ns, int ParameterIdx, int Offset>
-struct Take1stOrderParts<integer_sequence<int, N, Ns...>,
+struct Take1stOrderParts<std::integer_sequence<int, N, Ns...>,
ParameterIdx,
Offset> {
template <typename JetT, typename T>
@@ -284,7 +285,7 @@
if (jacobians[ParameterIdx]) {
Take1stOrderPart<Offset, N>(num_outputs, output, jacobians[ParameterIdx]);
}
- Take1stOrderParts<integer_sequence<int, Ns...>,
+ Take1stOrderParts<std::integer_sequence<int, Ns...>,
ParameterIdx + 1,
Offset + N>::Apply(num_outputs, output, jacobians);
}
@@ -292,7 +293,7 @@
// End of 'recursion'. Nothing more to do.
template <int ParameterIdx, int Offset>
-struct Take1stOrderParts<integer_sequence<int>, ParameterIdx, Offset> {
+struct Take1stOrderParts<std::integer_sequence<int>, ParameterIdx, Offset> {
template <typename T, typename JetT>
static void Apply(int /* NOT USED*/,
JetT* /* NOT USED*/,
diff --git a/include/ceres/internal/fixed_array.h b/include/ceres/internal/fixed_array.h
index 021851d..f8ef02d 100644
--- a/include/ceres/internal/fixed_array.h
+++ b/include/ceres/internal/fixed_array.h
@@ -39,7 +39,6 @@
#include <Eigen/Core> // For Eigen::aligned_allocator
-#include "ceres/internal/algorithm.h"
#include "ceres/internal/memory.h"
#include "glog/logging.h"
@@ -312,7 +311,7 @@
// Relational operators. Equality operators are elementwise using
// `operator==`, while order operators order FixedArrays lexicographically.
friend bool operator==(const FixedArray& lhs, const FixedArray& rhs) {
- return internal::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+ return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs) {
diff --git a/include/ceres/internal/integer_sequence.h b/include/ceres/internal/integer_sequence.h
deleted file mode 100644
index 3936b92..0000000
--- a/include/ceres/internal/integer_sequence.h
+++ /dev/null
@@ -1,106 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2018 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: jodebo_beck@gmx.de (Johannes Beck)
-//
-// This class mimics std::integer_sequence. That is the reason to follow the
-// naming convention of the stl and not the google one. Once Ceres switches
-// to c++ 14 this class can be removed.
-
-#ifndef CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_H_
-#define CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_H_
-
-#if __cplusplus >= 201402L
-// We have at least c++ 14 support. Use integer_sequence from the standard.
-// Sometimes the STL implementation uses a compiler intrinsic to generate
-// the sequences which will speed up compilation.
-#include <utility>
-
-namespace ceres {
-namespace internal {
-template <typename T, T... Ns>
-using integer_sequence = std::integer_sequence<T, Ns...>;
-
-template <typename T, T N>
-using make_integer_sequence = std::make_integer_sequence<T, N>;
-
-} // namespace internal
-} // namespace ceres
-#else
-
-namespace ceres {
-namespace internal {
-
-template <typename T, T... Ns>
-struct integer_sequence {
- using value_type = T;
-};
-
-// Implementation of make_integer_sequence.
-//
-// Recursively instantiate make_integer_sequence_impl until Ns
-// contains the sequence 0, 1, ..., Total-1.
-//
-// Example for Total = 4:
-// T CurIdx, Total, Ns...
-// make_integer_sequence_impl<int, 0, 4 >
-// make_integer_sequence_impl<int, 1, 4, 0 >
-// make_integer_sequence_impl<int, 2, 4, 0, 1 >
-// make_integer_sequence_impl<int, 3, 4, 0, 1, 2 >
-// make_integer_sequence_impl<int, 4, 4, 0, 1, 2, 3>
-// ^^^^^^^^^^
-// resulting sequence.
-//
-// The implemented algorithm has linear complexity for simplicity. A O(log(N))
-// implementation can be found e.g. here:
-// https://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence
-template <typename T, T CurIdx, T Total, T... Ns>
-struct make_integer_sequence_impl {
- using type = typename make_integer_sequence_impl<T, CurIdx + 1, Total, Ns...,
- CurIdx>::type;
-};
-
-// End of 'recursion' when CurIdx reaches Total. All indices 0, 1, ..., N-1 are
-// contained in Ns. The final integer_sequence is created here.
-template <typename T, T Total, T... Ns>
-struct make_integer_sequence_impl<T, Total, Total, Ns...> {
- using type = integer_sequence<T, Ns...>;
-};
-
-// A helper alias template to simplify creation of integer_sequence with 0, 1,
-// ..., N-1 as Ns:
-template <typename T, T N>
-using make_integer_sequence =
- typename make_integer_sequence_impl<T, 0, N>::type;
-
-} // namespace internal
-} // namespace ceres
-
-#endif
-
-#endif // CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_H_
diff --git a/include/ceres/internal/integer_sequence_algorithm.h b/include/ceres/internal/integer_sequence_algorithm.h
index bdeab93..170acac 100644
--- a/include/ceres/internal/integer_sequence_algorithm.h
+++ b/include/ceres/internal/integer_sequence_algorithm.h
@@ -35,7 +35,7 @@
#ifndef CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_ALGORITHM_H_
#define CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_ALGORITHM_H_
-#include "integer_sequence.h"
+#include <utility>
namespace ceres {
namespace internal {
@@ -61,33 +61,33 @@
// Strip of and sum the first number.
template <typename T, T N, T... Ns>
-struct SumImpl<integer_sequence<T, N, Ns...>> {
- static constexpr T Value = N + SumImpl<integer_sequence<T, Ns...>>::Value;
+struct SumImpl<std::integer_sequence<T, N, Ns...>> {
+ static constexpr T Value = N + SumImpl<std::integer_sequence<T, Ns...>>::Value;
};
// Strip of and sum the first two numbers.
template <typename T, T N1, T N2, T... Ns>
-struct SumImpl<integer_sequence<T, N1, N2, Ns...>> {
+struct SumImpl<std::integer_sequence<T, N1, N2, Ns...>> {
static constexpr T Value =
- N1 + N2 + SumImpl<integer_sequence<T, Ns...>>::Value;
+ N1 + N2 + SumImpl<std::integer_sequence<T, Ns...>>::Value;
};
// Strip of and sum the first four numbers.
template <typename T, T N1, T N2, T N3, T N4, T... Ns>
-struct SumImpl<integer_sequence<T, N1, N2, N3, N4, Ns...>> {
+struct SumImpl<std::integer_sequence<T, N1, N2, N3, N4, Ns...>> {
static constexpr T Value =
- N1 + N2 + N3 + N4 + SumImpl<integer_sequence<T, Ns...>>::Value;
+ N1 + N2 + N3 + N4 + SumImpl<std::integer_sequence<T, Ns...>>::Value;
};
// Only one number is left. 'Value' is just that number ('recursion' ends).
template <typename T, T N>
-struct SumImpl<integer_sequence<T, N>> {
+struct SumImpl<std::integer_sequence<T, N>> {
static constexpr T Value = N;
};
// No number is left. 'Value' is the identity element (for sum this is zero).
template <typename T>
-struct SumImpl<integer_sequence<T>> {
+struct SumImpl<std::integer_sequence<T>> {
static constexpr T Value = T(0);
};
@@ -129,16 +129,16 @@
struct ExclusiveScanImpl;
template <typename T, T Sum, T N, T... Ns, T... Rs>
-struct ExclusiveScanImpl<T, Sum, integer_sequence<T, N, Ns...>,
- integer_sequence<T, Rs...>> {
+struct ExclusiveScanImpl<T, Sum, std::integer_sequence<T, N, Ns...>,
+ std::integer_sequence<T, Rs...>> {
using Type =
- typename ExclusiveScanImpl<T, Sum + N, integer_sequence<T, Ns...>,
- integer_sequence<T, Rs..., Sum>>::Type;
+ typename ExclusiveScanImpl<T, Sum + N, std::integer_sequence<T, Ns...>,
+ std::integer_sequence<T, Rs..., Sum>>::Type;
};
// End of 'recursion'. The resulting type is SeqOut.
template <typename T, T Sum, typename SeqOut>
-struct ExclusiveScanImpl<T, Sum, integer_sequence<T>, SeqOut> {
+struct ExclusiveScanImpl<T, Sum, std::integer_sequence<T>, SeqOut> {
using Type = SeqOut;
};
@@ -152,7 +152,7 @@
public:
using Type =
- typename ExclusiveScanImpl<T, T(0), Seq, integer_sequence<T>>::Type;
+ typename ExclusiveScanImpl<T, T(0), Seq, std::integer_sequence<T>>::Type;
};
// Helper to use exclusive scan without typename.
diff --git a/include/ceres/internal/numeric_diff.h b/include/ceres/internal/numeric_diff.h
index 211fa82..fb2e00b 100644
--- a/include/ceres/internal/numeric_diff.h
+++ b/include/ceres/internal/numeric_diff.h
@@ -36,6 +36,7 @@
#define CERES_PUBLIC_INTERNAL_NUMERIC_DIFF_H_
#include <cstring>
+#include <utility>
#include "Eigen/Dense"
#include "Eigen/StdVector"
@@ -437,7 +438,7 @@
template <typename ParameterDims, int N, int... Ns, int ParameterIdx>
struct EvaluateJacobianForParameterBlocks<ParameterDims,
- integer_sequence<int, N, Ns...>,
+ std::integer_sequence<int, N, Ns...>,
ParameterIdx> {
template <NumericDiffMethodType method,
int kNumResiduals,
@@ -468,7 +469,7 @@
}
return EvaluateJacobianForParameterBlocks<ParameterDims,
- integer_sequence<int, Ns...>,
+ std::integer_sequence<int, Ns...>,
ParameterIdx + 1>::
template Apply<method, kNumResiduals>(functor,
residuals_at_eval_point,
@@ -481,7 +482,7 @@
// End of 'recursion'. Nothing more to do.
template <typename ParameterDims, int ParameterIdx>
-struct EvaluateJacobianForParameterBlocks<ParameterDims, integer_sequence<int>,
+struct EvaluateJacobianForParameterBlocks<ParameterDims, std::integer_sequence<int>,
ParameterIdx> {
template <NumericDiffMethodType method, int kNumResiduals,
typename CostFunctor>
diff --git a/include/ceres/internal/parameter_dims.h b/include/ceres/internal/parameter_dims.h
index 2272e8d..2402106 100644
--- a/include/ceres/internal/parameter_dims.h
+++ b/include/ceres/internal/parameter_dims.h
@@ -32,8 +32,8 @@
#define CERES_PUBLIC_INTERNAL_PARAMETER_DIMS_H_
#include <array>
+#include <utility>
-#include "ceres/internal/integer_sequence.h"
#include "ceres/internal/integer_sequence_algorithm.h"
namespace ceres {
@@ -41,16 +41,16 @@
// Checks, whether the given parameter block sizes are valid. Valid means every
// dimension is bigger than zero.
-constexpr bool IsValidParameterDimensionSequence(integer_sequence<int>) {
+constexpr bool IsValidParameterDimensionSequence(std::integer_sequence<int>) {
return true;
}
template <int N, int... Ts>
constexpr bool IsValidParameterDimensionSequence(
- integer_sequence<int, N, Ts...>) {
+ std::integer_sequence<int, N, Ts...>) {
return (N <= 0) ? false
: IsValidParameterDimensionSequence(
- integer_sequence<int, Ts...>());
+ std::integer_sequence<int, Ts...>());
}
// Helper class that represents the parameter dimensions. The parameter
@@ -66,7 +66,7 @@
template <bool IsDynamic, int... Ns>
class ParameterDims {
public:
- using Parameters = integer_sequence<int, Ns...>;
+ using Parameters = std::integer_sequence<int, Ns...>;
// The parameter dimensions are only valid if all parameter block dimensions
// are greater than zero.
@@ -82,7 +82,7 @@
"At least one parameter block must be specified.");
static constexpr int kNumParameters =
- Sum<integer_sequence<int, Ns...>>::Value;
+ Sum<std::integer_sequence<int, Ns...>>::Value;
static constexpr int GetDim(int dim) { return params_[dim]; }
@@ -98,7 +98,7 @@
private:
template <typename T, int... Indices>
static inline std::array<T*, kNumParameterBlocks> GetUnpackedParameters(
- T* ptr, integer_sequence<int, Indices...>) {
+ T* ptr, std::integer_sequence<int, Indices...>) {
return std::array<T*, kNumParameterBlocks>{{ptr + Indices...}};
}
diff --git a/include/ceres/internal/port.h b/include/ceres/internal/port.h
index 07bb505..958b0d1 100644
--- a/include/ceres/internal/port.h
+++ b/include/ceres/internal/port.h
@@ -35,19 +35,19 @@
#include "ceres/internal/config.h"
#if defined(CERES_USE_OPENMP)
-# if defined(CERES_USE_CXX11_THREADS) || defined(CERES_NO_THREADS)
-# error CERES_USE_OPENMP is mutually exclusive to CERES_USE_CXX11_THREADS and CERES_NO_THREADS
+# if defined(CERES_USE_CXX_THREADS) || defined(CERES_NO_THREADS)
+# error CERES_USE_OPENMP is mutually exclusive to CERES_USE_CXX_THREADS and CERES_NO_THREADS
# endif
-#elif defined(CERES_USE_CXX11_THREADS)
+#elif defined(CERES_USE_CXX_THREADS)
# if defined(CERES_USE_OPENMP) || defined(CERES_NO_THREADS)
-# error CERES_USE_CXX11_THREADS is mutually exclusive to CERES_USE_OPENMP, CERES_USE_CXX11_THREADS and CERES_NO_THREADS
+# error CERES_USE_CXX_THREADS is mutually exclusive to CERES_USE_OPENMP, CERES_USE_CXX_THREADS and CERES_NO_THREADS
# endif
#elif defined(CERES_NO_THREADS)
-# if defined(CERES_USE_OPENMP) || defined(CERES_USE_CXX11_THREADS)
-# error CERES_NO_THREADS is mutually exclusive to CERES_USE_OPENMP and CERES_USE_CXX11_THREADS
+# if defined(CERES_USE_OPENMP) || defined(CERES_USE_CXX_THREADS)
+# error CERES_NO_THREADS is mutually exclusive to CERES_USE_OPENMP and CERES_USE_CXX_THREADS
# endif
#else
-# error One of CERES_USE_OPENMP, CERES_USE_CXX11_THREADS or CERES_NO_THREADS must be defined.
+# error One of CERES_USE_OPENMP, CERES_USE_CXX_THREADS or CERES_NO_THREADS must be defined.
#endif
// CERES_NO_SPARSE should be automatically defined by config.h if Ceres was
diff --git a/include/ceres/internal/variadic_evaluate.h b/include/ceres/internal/variadic_evaluate.h
index 26428d0..046832c 100644
--- a/include/ceres/internal/variadic_evaluate.h
+++ b/include/ceres/internal/variadic_evaluate.h
@@ -36,6 +36,7 @@
#include <stddef.h>
#include <type_traits>
+#include <utility>
#include "ceres/cost_function.h"
#include "ceres/internal/parameter_dims.h"
@@ -47,7 +48,7 @@
template <typename Functor, typename T, int... Indices>
inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input,
T* output, std::false_type /*is_dynamic*/,
- integer_sequence<int, Indices...>) {
+ std::integer_sequence<int, Indices...>) {
static_assert(sizeof...(Indices),
"Invalid number of parameter blocks. At least one parameter "
"block must be specified.");
@@ -58,7 +59,7 @@
template <typename Functor, typename T>
inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input,
T* output, std::true_type /*is_dynamic*/,
- integer_sequence<int>) {
+ std::integer_sequence<int>) {
return functor(input, output);
}
@@ -67,7 +68,7 @@
inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input,
T* output, const void* /* NOT USED */) {
using ParameterBlockIndices =
- make_integer_sequence<int, ParameterDims::kNumParameterBlocks>;
+ std::make_integer_sequence<int, ParameterDims::kNumParameterBlocks>;
using IsDynamic = std::integral_constant<bool, ParameterDims::kIsDynamic>;
return VariadicEvaluateImpl(functor, input, output, IsDynamic(),
ParameterBlockIndices());
diff --git a/internal/ceres/CMakeLists.txt b/internal/ceres/CMakeLists.txt
index 80125c9..1ff9217 100644
--- a/internal/ceres/CMakeLists.txt
+++ b/internal/ceres/CMakeLists.txt
@@ -30,7 +30,7 @@
# Avoid 'xxx.cc has no symbols' warnings from source files which are 'empty'
# when their enclosing #ifdefs are disabled.
-if (CERES_THREADING_MODEL STREQUAL "CXX11_THREADS")
+if (CERES_THREADING_MODEL STREQUAL "CXX_THREADS")
set(CERES_PARALLEL_FOR_SRC parallel_for_cxx.cc thread_pool.cc)
elseif (CERES_THREADING_MODEL STREQUAL "OPENMP")
set(CERES_PARALLEL_FOR_SRC parallel_for_openmp.cc)
@@ -397,7 +397,6 @@
${Ceres_SOURCE_DIR}/data)
endmacro (CERES_TEST)
- ceres_test(algorithm)
ceres_test(array_utils)
ceres_test(array_selector)
ceres_test(autodiff)
@@ -442,7 +441,6 @@
ceres_test(implicit_schur_complement)
ceres_test(inner_product_computer)
ceres_test(invert_psd_matrix)
- ceres_test(integer_sequence)
ceres_test(integer_sequence_algorithm)
ceres_test(is_close)
ceres_test(iterative_refiner)
diff --git a/internal/ceres/algorithm_test.cc b/internal/ceres/algorithm_test.cc
deleted file mode 100644
index c131563..0000000
--- a/internal/ceres/algorithm_test.cc
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "ceres/internal/algorithm.h"
-
-#include <algorithm>
-#include <list>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-TEST(EqualTest, DefaultComparisonRandomAccess) {
- std::vector<int> v1{1, 2, 3};
- std::vector<int> v2 = v1;
- std::vector<int> v3 = {1, 2};
- std::vector<int> v4 = {1, 2, 4};
-
- EXPECT_TRUE(
- ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end()));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), v3.begin(), v3.end()));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), v4.begin(), v4.end()));
-}
-
-TEST(EqualTest, DefaultComparison) {
- std::list<int> lst1{1, 2, 3};
- std::list<int> lst2 = lst1;
- std::list<int> lst3{1, 2};
- std::list<int> lst4{1, 2, 4};
-
- EXPECT_TRUE(ceres::internal::equal(
- lst1.begin(), lst1.end(), lst2.begin(), lst2.end()));
- EXPECT_FALSE(ceres::internal::equal(
- lst1.begin(), lst1.end(), lst3.begin(), lst3.end()));
- EXPECT_FALSE(ceres::internal::equal(
- lst1.begin(), lst1.end(), lst4.begin(), lst4.end()));
-}
-
-TEST(EqualTest, EmptyRange) {
- std::vector<int> v1{1, 2, 3};
- std::vector<int> empty1;
- std::vector<int> empty2;
-
- EXPECT_FALSE(ceres::internal::equal(
- v1.begin(), v1.end(), empty1.begin(), empty1.end()));
- EXPECT_FALSE(ceres::internal::equal(
- empty1.begin(), empty1.end(), v1.begin(), v1.end()));
- EXPECT_TRUE(ceres::internal::equal(
- empty1.begin(), empty1.end(), empty2.begin(), empty2.end()));
-}
-
-TEST(EqualTest, MixedIterTypes) {
- std::vector<int> v1{1, 2, 3};
- std::list<int> lst1{v1.begin(), v1.end()};
- std::list<int> lst2{1, 2, 4};
- std::list<int> lst3{1, 2};
-
- EXPECT_TRUE(
- ceres::internal::equal(v1.begin(), v1.end(), lst1.begin(), lst1.end()));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), lst2.begin(), lst2.end()));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), lst3.begin(), lst3.end()));
-}
-
-TEST(EqualTest, MixedValueTypes) {
- std::vector<int> v1{1, 2, 3};
- std::vector<char> v2{1, 2, 3};
- std::vector<char> v3{1, 2};
- std::vector<char> v4{1, 2, 4};
-
- EXPECT_TRUE(
- ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end()));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), v3.begin(), v3.end()));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), v4.begin(), v4.end()));
-}
-
-TEST(EqualTest, WeirdIterators) {
- std::vector<bool> v1{true, false};
- std::vector<bool> v2 = v1;
- std::vector<bool> v3{true};
- std::vector<bool> v4{true, true, true};
-
- EXPECT_TRUE(
- ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end()));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), v3.begin(), v3.end()));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), v4.begin(), v4.end()));
-}
-
-TEST(EqualTest, CustomComparison) {
- int n[] = {1, 2, 3, 4};
- std::vector<int*> v1{&n[0], &n[1], &n[2]};
- std::vector<int*> v2 = v1;
- std::vector<int*> v3{&n[0], &n[1], &n[3]};
- std::vector<int*> v4{&n[0], &n[1]};
-
- auto eq = [](int* a, int* b) { return *a == *b; };
-
- EXPECT_TRUE(
- ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end(), eq));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), v3.begin(), v3.end(), eq));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), v4.begin(), v4.end(), eq));
-}
-
-TEST(EqualTest, MoveOnlyPredicate) {
- std::vector<int> v1{1, 2, 3};
- std::vector<int> v2{4, 5, 6};
-
- // move-only equality predicate
- struct Eq {
- Eq() = default;
- Eq(Eq&&) = default;
- Eq(const Eq&) = delete;
- Eq& operator=(const Eq&) = delete;
- bool operator()(const int a, const int b) const { return a == b; }
- };
-
- EXPECT_TRUE(
- ceres::internal::equal(v1.begin(), v1.end(), v1.begin(), v1.end(), Eq()));
- EXPECT_FALSE(
- ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end(), Eq()));
-}
-
-struct CountingTrivialPred {
- int* count;
- bool operator()(int, int) const {
- ++*count;
- return true;
- }
-};
-
-TEST(EqualTest, RandomAccessComplexity) {
- std::vector<int> v1{1, 1, 3};
- std::vector<int> v2 = v1;
- std::vector<int> v3{1, 2};
-
- do {
- int count = 0;
- ceres::internal::equal(v1.begin(),
- v1.end(),
- v2.begin(),
- v2.end(),
- CountingTrivialPred{&count});
- EXPECT_LE(count, 3);
- } while (std::next_permutation(v2.begin(), v2.end()));
-
- int count = 0;
- ceres::internal::equal(
- v1.begin(), v1.end(), v3.begin(), v3.end(), CountingTrivialPred{&count});
- EXPECT_EQ(count, 0);
-}
-} // namespace
diff --git a/internal/ceres/concurrent_queue_test.cc b/internal/ceres/concurrent_queue_test.cc
index 698966a..ce6d687 100644
--- a/internal/ceres/concurrent_queue_test.cc
+++ b/internal/ceres/concurrent_queue_test.cc
@@ -31,7 +31,7 @@
// This include must come before any #ifndef check on Ceres compile options.
#include "ceres/internal/port.h"
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
#include <chrono>
#include <thread>
@@ -304,4 +304,4 @@
} // namespace internal
} // namespace ceres
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/context_impl.cc b/internal/ceres/context_impl.cc
index 1b9662f..622f33a 100644
--- a/internal/ceres/context_impl.cc
+++ b/internal/ceres/context_impl.cc
@@ -34,9 +34,9 @@
namespace internal {
void ContextImpl::EnsureMinimumThreads(int num_threads) {
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
thread_pool.Resize(num_threads);
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
}
} // namespace internal
diff --git a/internal/ceres/context_impl.h b/internal/ceres/context_impl.h
index d83b77a..5c03ad7 100644
--- a/internal/ceres/context_impl.h
+++ b/internal/ceres/context_impl.h
@@ -36,9 +36,9 @@
#include "ceres/context.h"
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
#include "ceres/thread_pool.h"
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
namespace ceres {
namespace internal {
@@ -51,14 +51,14 @@
virtual ~ContextImpl() {}
- // When compiled with C++11 threading support, resize the thread pool to have
+ // When compiled with C++ threading support, resize the thread pool to have
// at min(num_thread, num_hardware_threads) where num_hardware_threads is
// defined by the hardware. Otherwise this call is a no-op.
void EnsureMinimumThreads(int num_threads);
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
ThreadPool thread_pool;
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
};
} // namespace internal
diff --git a/internal/ceres/integer_sequence_algorithm_test.cc b/internal/ceres/integer_sequence_algorithm_test.cc
index a6c85d0..af42a91 100644
--- a/internal/ceres/integer_sequence_algorithm_test.cc
+++ b/internal/ceres/integer_sequence_algorithm_test.cc
@@ -31,39 +31,40 @@
#include "ceres/internal/integer_sequence_algorithm.h"
#include <type_traits>
+#include <utility>
namespace ceres {
namespace internal {
// Unit tests for summation of integer sequence.
-static_assert(Sum<integer_sequence<int>>::Value == 0,
+static_assert(Sum<std::integer_sequence<int>>::Value == 0,
"Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2>>::Value == 2,
+static_assert(Sum<std::integer_sequence<int, 2>>::Value == 2,
"Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2, 3>>::Value == 5,
+static_assert(Sum<std::integer_sequence<int, 2, 3>>::Value == 5,
"Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2, 3, 10>>::Value == 15,
+static_assert(Sum<std::integer_sequence<int, 2, 3, 10>>::Value == 15,
"Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2, 3, 10, 4>>::Value == 19,
+static_assert(Sum<std::integer_sequence<int, 2, 3, 10, 4>>::Value == 19,
"Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2, 3, 10, 4, 1>>::Value == 20,
+static_assert(Sum<std::integer_sequence<int, 2, 3, 10, 4, 1>>::Value == 20,
"Unit test of summing up an integer sequence failed.");
// Unit tests for exclusive scan of integer sequence.
-static_assert(std::is_same<ExclusiveScan<integer_sequence<int>>,
- integer_sequence<int>>::value,
+static_assert(std::is_same<ExclusiveScan<std::integer_sequence<int>>,
+ std::integer_sequence<int>>::value,
"Unit test of calculating the exclusive scan of an integer "
"sequence failed.");
-static_assert(std::is_same<ExclusiveScan<integer_sequence<int, 2>>,
- integer_sequence<int, 0>>::value,
+static_assert(std::is_same<ExclusiveScan<std::integer_sequence<int, 2>>,
+ std::integer_sequence<int, 0>>::value,
"Unit test of calculating the exclusive scan of an integer "
"sequence failed.");
-static_assert(std::is_same<ExclusiveScan<integer_sequence<int, 2, 1>>,
- integer_sequence<int, 0, 2>>::value,
+static_assert(std::is_same<ExclusiveScan<std::integer_sequence<int, 2, 1>>,
+ std::integer_sequence<int, 0, 2>>::value,
"Unit test of calculating the exclusive scan of an integer "
"sequence failed.");
-static_assert(std::is_same<ExclusiveScan<integer_sequence<int, 2, 1, 10>>,
- integer_sequence<int, 0, 2, 3>>::value,
+static_assert(std::is_same<ExclusiveScan<std::integer_sequence<int, 2, 1, 10>>,
+ std::integer_sequence<int, 0, 2, 3>>::value,
"Unit test of calculating the exclusive scan of an integer "
"sequence failed.");
diff --git a/internal/ceres/integer_sequence_test.cc b/internal/ceres/integer_sequence_test.cc
deleted file mode 100644
index ab3559a..0000000
--- a/internal/ceres/integer_sequence_test.cc
+++ /dev/null
@@ -1,58 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2018 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: jodebo_beck@gmx.de (Johannes Beck)
-
-#include "ceres/internal/integer_sequence.h"
-
-#include <type_traits>
-
-namespace ceres {
-namespace internal {
-
-// Unit test for integer_sequence<...>::value_type
-static_assert(std::is_same<integer_sequence<unsigned int, 0>::value_type,
- unsigned int>::value,
- "Unit test of integer sequence value type failed.");
-
-// Unit tests for make_integer_sequence
-static_assert(
- std::is_same<make_integer_sequence<int, 0>, integer_sequence<int>>::value,
- "Unit test of make integer sequence failed.");
-static_assert(std::is_same<make_integer_sequence<int, 1>,
- integer_sequence<int, 0>>::value,
- "Unit test of make integer sequence failed.");
-static_assert(std::is_same<make_integer_sequence<int, 2>,
- integer_sequence<int, 0, 1>>::value,
- "Unit test of make integer sequence failed.");
-static_assert(std::is_same<make_integer_sequence<int, 3>,
- integer_sequence<int, 0, 1, 2>>::value,
- "Unit test of make integer sequence failed.");
-
-} // namespace internal
-} // namespace ceres
diff --git a/internal/ceres/parallel_for_cxx.cc b/internal/ceres/parallel_for_cxx.cc
index b6ef709..8e358f5 100644
--- a/internal/ceres/parallel_for_cxx.cc
+++ b/internal/ceres/parallel_for_cxx.cc
@@ -31,7 +31,7 @@
// This include must come before any #ifndef check on Ceres compile options.
#include "ceres/internal/port.h"
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
#include "ceres/parallel_for.h"
@@ -244,4 +244,4 @@
} // namespace internal
} // namespace ceres
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/parameter_dims_test.cc b/internal/ceres/parameter_dims_test.cc
index f33536f..c832260 100644
--- a/internal/ceres/parameter_dims_test.cc
+++ b/internal/ceres/parameter_dims_test.cc
@@ -26,28 +26,29 @@
#include <gtest/gtest.h>
#include <type_traits>
+#include <utility>
namespace ceres {
namespace internal {
// Is valid parameter dims unit test
-static_assert(IsValidParameterDimensionSequence(integer_sequence<int>()) ==
+static_assert(IsValidParameterDimensionSequence(std::integer_sequence<int>()) ==
true,
"Unit test of is valid parameter dimension sequence failed.");
static_assert(
- IsValidParameterDimensionSequence(integer_sequence<int, 2, 1>()) == true,
+ IsValidParameterDimensionSequence(std::integer_sequence<int, 2, 1>()) == true,
"Unit test of is valid parameter dimension sequence failed.");
static_assert(
- IsValidParameterDimensionSequence(integer_sequence<int, 0, 1>()) == false,
+ IsValidParameterDimensionSequence(std::integer_sequence<int, 0, 1>()) == false,
"Unit test of is valid parameter dimension sequence failed.");
static_assert(
- IsValidParameterDimensionSequence(integer_sequence<int, 3, 0>()) == false,
+ IsValidParameterDimensionSequence(std::integer_sequence<int, 3, 0>()) == false,
"Unit test of is valid parameter dimension sequence failed.");
// Static parameter dims unit test
static_assert(
std::is_same<StaticParameterDims<4, 2, 1>::Parameters,
- integer_sequence<int, 4, 2, 1>>::value == true,
+ std::integer_sequence<int, 4, 2, 1>>::value == true,
"Unit test of type 'parameters' for static parameter dims failed.");
static_assert(StaticParameterDims<4, 2, 1>::kIsValid == true,
diff --git a/internal/ceres/program_evaluator.h b/internal/ceres/program_evaluator.h
index 5daface..97ee590 100644
--- a/internal/ceres/program_evaluator.h
+++ b/internal/ceres/program_evaluator.h
@@ -43,7 +43,7 @@
// residual jacobians are written directly into their final position in the
// block sparse matrix by the user's CostFunction; there is no copying.
//
-// The evaluation is threaded with OpenMP or C++11 threads.
+// The evaluation is threaded with OpenMP or C++ threads.
//
// The EvaluatePreparer and JacobianWriter interfaces are as follows:
//
diff --git a/internal/ceres/program_test.cc b/internal/ceres/program_test.cc
index 74dcd75..be6ad87 100644
--- a/internal/ceres/program_test.cc
+++ b/internal/ceres/program_test.cc
@@ -33,6 +33,7 @@
#include <cmath>
#include <limits>
#include <memory>
+#include <utility>
#include <vector>
#include "ceres/internal/integer_sequence_algorithm.h"
@@ -69,7 +70,7 @@
bool Evaluate(double const* const* parameters,
double* residuals,
double** jacobians) const final {
- const int kNumParameters = Sum<integer_sequence<int, Ns...>>::Value;
+ const int kNumParameters = Sum<std::integer_sequence<int, Ns...>>::Value;
for (int i = 0; i < kNumResiduals; ++i) {
residuals[i] = kNumResiduals + kNumParameters;
diff --git a/internal/ceres/stringprintf.cc b/internal/ceres/stringprintf.cc
index b3b7474..7a21f0e 100644
--- a/internal/ceres/stringprintf.cc
+++ b/internal/ceres/stringprintf.cc
@@ -43,28 +43,6 @@
using std::string;
-// va_copy() was defined in the C99 standard. However, it did not appear in the
-// C++ standard until C++11. This means that if Ceres is being compiled with a
-// strict pre-C++11 standard (e.g. -std=c++03), va_copy() will NOT be defined,
-// as we are using the C++ compiler (it would however be defined if we were
-// using the C compiler). Note however that both GCC & Clang will in fact
-// define va_copy() when compiling for C++ if the C++ standard is not explicitly
-// specified (i.e. no -std=c++<XX> arg), even though it should not strictly be
-// defined unless -std=c++11 (or greater) was passed.
-#if !defined(va_copy)
-#if defined (__GNUC__)
-// On GCC/Clang, if va_copy() is not defined (C++ standard < C++11 explicitly
-// specified), use the internal __va_copy() version, which should be present
-// in even very old GCC versions.
-#define va_copy(d, s) __va_copy(d, s)
-#else
-// Some older versions of MSVC do not have va_copy(), in which case define it.
-// Although this is required for older MSVC versions, it should also work for
-// other non-GCC/Clang compilers which also do not defined va_copy().
-#define va_copy(d, s) ((d) = (s))
-#endif // defined (__GNUC__)
-#endif // !defined(va_copy)
-
void StringAppendV(string* dst, const char* format, va_list ap) {
// First try with a small fixed size buffer
char space[1024];
diff --git a/internal/ceres/thread_pool.cc b/internal/ceres/thread_pool.cc
index 991da30..5a52c9d 100644
--- a/internal/ceres/thread_pool.cc
+++ b/internal/ceres/thread_pool.cc
@@ -31,7 +31,7 @@
// This include must come before any #ifndef check on Ceres compile options.
#include "ceres/internal/port.h"
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
#include "ceres/thread_pool.h"
@@ -113,4 +113,4 @@
} // namespace internal
} // namespace ceres
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/thread_pool_test.cc b/internal/ceres/thread_pool_test.cc
index 2b1bf87..48ba9d1 100644
--- a/internal/ceres/thread_pool_test.cc
+++ b/internal/ceres/thread_pool_test.cc
@@ -31,7 +31,7 @@
// This include must come before any #ifndef check on Ceres compile options.
#include "ceres/internal/port.h"
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
#include "ceres/thread_pool.h"
@@ -197,4 +197,4 @@
} // namespace internal
} // namespace ceres
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/thread_token_provider.cc b/internal/ceres/thread_token_provider.cc
index 337217b..b04cf84 100644
--- a/internal/ceres/thread_token_provider.cc
+++ b/internal/ceres/thread_token_provider.cc
@@ -39,7 +39,7 @@
ThreadTokenProvider::ThreadTokenProvider(int num_threads) {
(void)num_threads;
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
for (int i = 0; i < num_threads; i++) {
pool_.Push(i);
}
@@ -56,7 +56,7 @@
return 0;
#endif
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
int thread_id;
CHECK(pool_.Wait(&thread_id));
return thread_id;
@@ -66,7 +66,7 @@
void ThreadTokenProvider::Release(int thread_id) {
(void)thread_id;
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
pool_.Push(thread_id);
#endif
diff --git a/internal/ceres/thread_token_provider.h b/internal/ceres/thread_token_provider.h
index f6298b7..06dc043 100644
--- a/internal/ceres/thread_token_provider.h
+++ b/internal/ceres/thread_token_provider.h
@@ -34,15 +34,15 @@
#include "ceres/internal/config.h"
#include "ceres/internal/port.h"
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
#include "ceres/concurrent_queue.h"
#endif
namespace ceres {
namespace internal {
-// Helper for C++11 thread number identification that is similar to
-// omp_get_thread_num() behaviour. This is necessary to support C++11
+// Helper for C++ thread number identification that is similar to
+// omp_get_thread_num() behaviour. This is necessary to support C++
// threading with a sequential thread id. This is used to access preallocated
// resources in the parallelized code parts. The sequence of tokens varies from
// 0 to num_threads - 1 that can be acquired to identify the thread in a thread
@@ -78,7 +78,7 @@
void Release(int thread_id);
private:
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
// This queue initially holds a sequence from 0..num_threads-1. Every
// Acquire() call the first number is removed from here. When the token is not
// needed anymore it shall be given back with corresponding Release()
