171 lines
7.3 KiB
C++
171 lines
7.3 KiB
C++
// Ceres Solver - A fast non-linear least squares minimizer
|
|
// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
|
|
// http://code.google.com/p/ceres-solver/
|
|
//
|
|
// 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.
|
|
//
|
|
//
|
|
// Various Google-specific macros.
|
|
//
|
|
// This code is compiled directly on many platforms, including client
|
|
// platforms like Windows, Mac, and embedded systems. Before making
|
|
// any changes here, make sure that you're not breaking any platforms.
|
|
|
|
#ifndef CERES_PUBLIC_INTERNAL_MACROS_H_
|
|
#define CERES_PUBLIC_INTERNAL_MACROS_H_
|
|
|
|
#include <cstddef> // For size_t.
|
|
|
|
// A macro to disallow the copy constructor and operator= functions
|
|
// This should be used in the private: declarations for a class
|
|
//
|
|
// For disallowing only assign or copy, write the code directly, but declare
|
|
// the intend in a comment, for example:
|
|
//
|
|
// void operator=(const TypeName&); // _DISALLOW_ASSIGN
|
|
|
|
// Note, that most uses of CERES_DISALLOW_ASSIGN and CERES_DISALLOW_COPY
|
|
// are broken semantically, one should either use disallow both or
|
|
// neither. Try to avoid these in new code.
|
|
#define CERES_DISALLOW_COPY_AND_ASSIGN(TypeName) \
|
|
TypeName(const TypeName&); \
|
|
void operator=(const TypeName&)
|
|
|
|
// A macro to disallow all the implicit constructors, namely the
|
|
// default constructor, copy constructor and operator= functions.
|
|
//
|
|
// This should be used in the private: declarations for a class
|
|
// that wants to prevent anyone from instantiating it. This is
|
|
// especially useful for classes containing only static methods.
|
|
#define CERES_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
|
|
TypeName(); \
|
|
CERES_DISALLOW_COPY_AND_ASSIGN(TypeName)
|
|
|
|
// The arraysize(arr) macro returns the # of elements in an array arr.
|
|
// The expression is a compile-time constant, and therefore can be
|
|
// used in defining new arrays, for example. If you use arraysize on
|
|
// a pointer by mistake, you will get a compile-time error.
|
|
//
|
|
// One caveat is that arraysize() doesn't accept any array of an
|
|
// anonymous type or a type defined inside a function. In these rare
|
|
// cases, you have to use the unsafe ARRAYSIZE() macro below. This is
|
|
// due to a limitation in C++'s template system. The limitation might
|
|
// eventually be removed, but it hasn't happened yet.
|
|
|
|
// This template function declaration is used in defining arraysize.
|
|
// Note that the function doesn't need an implementation, as we only
|
|
// use its type.
|
|
template <typename T, size_t N>
|
|
char (&ArraySizeHelper(T (&array)[N]))[N];
|
|
|
|
// That gcc wants both of these prototypes seems mysterious. VC, for
|
|
// its part, can't decide which to use (another mystery). Matching of
|
|
// template overloads: the final frontier.
|
|
#ifndef _WIN32
|
|
template <typename T, size_t N>
|
|
char (&ArraySizeHelper(const T (&array)[N]))[N];
|
|
#endif
|
|
|
|
#define arraysize(array) (sizeof(ArraySizeHelper(array)))
|
|
|
|
// ARRAYSIZE performs essentially the same calculation as arraysize,
|
|
// but can be used on anonymous types or types defined inside
|
|
// functions. It's less safe than arraysize as it accepts some
|
|
// (although not all) pointers. Therefore, you should use arraysize
|
|
// whenever possible.
|
|
//
|
|
// The expression ARRAYSIZE(a) is a compile-time constant of type
|
|
// size_t.
|
|
//
|
|
// ARRAYSIZE catches a few type errors. If you see a compiler error
|
|
//
|
|
// "warning: division by zero in ..."
|
|
//
|
|
// when using ARRAYSIZE, you are (wrongfully) giving it a pointer.
|
|
// You should only use ARRAYSIZE on statically allocated arrays.
|
|
//
|
|
// The following comments are on the implementation details, and can
|
|
// be ignored by the users.
|
|
//
|
|
// ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in
|
|
// the array) and sizeof(*(arr)) (the # of bytes in one array
|
|
// element). If the former is divisible by the latter, perhaps arr is
|
|
// indeed an array, in which case the division result is the # of
|
|
// elements in the array. Otherwise, arr cannot possibly be an array,
|
|
// and we generate a compiler error to prevent the code from
|
|
// compiling.
|
|
//
|
|
// Since the size of bool is implementation-defined, we need to cast
|
|
// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
|
|
// result has type size_t.
|
|
//
|
|
// This macro is not perfect as it wrongfully accepts certain
|
|
// pointers, namely where the pointer size is divisible by the pointee
|
|
// size. Since all our code has to go through a 32-bit compiler,
|
|
// where a pointer is 4 bytes, this means all pointers to a type whose
|
|
// size is 3 or greater than 4 will be (righteously) rejected.
|
|
//
|
|
// Kudos to Jorg Brown for this simple and elegant implementation.
|
|
//
|
|
// - wan 2005-11-16
|
|
//
|
|
// Starting with Visual C++ 2005, WinNT.h includes ARRAYSIZE. However,
|
|
// the definition comes from the over-broad windows.h header that
|
|
// introduces a macro, ERROR, that conflicts with the logging framework
|
|
// that Ceres uses. Instead, rename ARRAYSIZE to CERES_ARRAYSIZE.
|
|
#define CERES_ARRAYSIZE(a) \
|
|
((sizeof(a) / sizeof(*(a))) / \
|
|
static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
|
|
|
|
// Tell the compiler to warn about unused return values for functions
|
|
// declared with this macro. The macro should be used on function
|
|
// declarations following the argument list:
|
|
//
|
|
// Sprocket* AllocateSprocket() MUST_USE_RESULT;
|
|
//
|
|
#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \
|
|
&& !defined(COMPILER_ICC)
|
|
#define CERES_MUST_USE_RESULT __attribute__ ((warn_unused_result))
|
|
#else
|
|
#define CERES_MUST_USE_RESULT
|
|
#endif
|
|
|
|
// Platform independent macros to get aligned memory allocations.
|
|
// For example
|
|
//
|
|
// MyFoo my_foo CERES_ALIGN_ATTRIBUTE(16);
|
|
//
|
|
// Gives us an instance of MyFoo which is aligned at a 16 byte
|
|
// boundary.
|
|
#if defined(_MSC_VER)
|
|
#define CERES_ALIGN_ATTRIBUTE(n) __declspec(align(n))
|
|
#define CERES_ALIGN_OF(T) __alignof(T)
|
|
#elif defined(__GNUC__)
|
|
#define CERES_ALIGN_ATTRIBUTE(n) __attribute__((aligned(n)))
|
|
#define CERES_ALIGN_OF(T) __alignof(T)
|
|
#endif
|
|
|
|
#endif // CERES_PUBLIC_INTERNAL_MACROS_H_
|