macros.hpp

Go to the documentation of this file.

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2026 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://scicomp.rptu.de
 * Contact:  Prof. Nicolas R. Gauger (codi@scicomp.uni-kl.de)
 *
 * Lead developers: Max Sagebaum, Johannes Blühdorn (SciComp, University of Kaiserslautern-Landau)
 *
 * This file is part of CoDiPack (http://scicomp.rptu.de/software/codi).
 *
 * CoDiPack is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * CoDiPack is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU
 * General Public License along with CoDiPack.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * For other licensing options please contact us.
 *
 * Authors:
 *  - SciComp, University of Kaiserslautern-Landau:
 *    - Max Sagebaum
 *    - Johannes Blühdorn
 *    - Former members:
 *      - Tim Albring
 */
#pragma once
 
#include "../config.h"


namespace codi {
 
  struct EmptyPosition;
 
  template<typename T_Real, typename T_Gradient, typename T_Identifier, typename T_Position,
           typename T_ActiveTypeTapeData>
  struct FullTapeInterface;
 
  template<typename T_Tape>
  struct ActiveType;

  template<typename... Args>
  CODI_INLINE void CODI_UNUSED(Args const&...) {}

#define CODI_UNUSED_ARG(arg) /* arg */

#define CODI_ENABLE_CHECK(option, condition) (!(option) || (condition))

#define CODI_TO_STRING2(expression) #expression

#define CODI_TO_STRING(expression) CODI_TO_STRING2(expression)
 
/*******************************************************************************/

#if CODI_IDE
  #define CODI_DECLARE_DEFAULT(Type, Default) Default
#else
  #define CODI_DECLARE_DEFAULT(Type, Default) Type
#endif

// Does not work in QT if CODI_DECLARE_DEFAULT is used
#if CODI_IDE
  #define CODI_DD(Type, Default) Default
#else
  #define CODI_DD(Type, Default) Type
#endif

#define CODI_ANY int

#define CODI_ANY_T(Type) Type
 
#ifndef DOXYGEN_DISABLE
  struct ImplProxy {};
#endif
#define CODI_IMPLEMENTATION ImplProxy

#define CODI_TEMPLATE(...) __VA_ARGS__

#define CODI_T(...) CODI_TEMPLATE(__VA_ARGS__)

#define CODI_UNDEFINED char

#define CODI_UNDEFINED_VALUE false

#if CODI_IDE
  #define CODI_STATIC_ASSERT(cond, message) /* Do not check in IDE mode */
#else
  #define CODI_STATIC_ASSERT(cond, message) static_assert(cond, message)
#endif
 
#if CODI_IDE
  struct ActiveTypeProxy {
      using Real = double;
      using Identifier = int;
      using TapeData = int;
  };

  #define CODI_DEFAULT_TAPE FullTapeInterface<double, double, int, EmptyPosition, int>

  #define CODI_DEFAULT_PARALLEL_TAPE CODI_UNION<CODI_DEFAULT_TAPE, EditingTapeInterface<EmptyPosition>>

  #define CODI_DEFAULT_LHS_EXPRESSION LhsExpressionInterface<double, double, CODI_DEFAULT_TAPE, CODI_ANY>

  #define CODI_DEFAULT_ACTIVE_TYPE ActiveType<CODI_DEFAULT_TAPE>
#endif
 
#ifndef DOXYGEN_DISABLE
  template<typename First, typename... Tail>
  struct CODI_UNION : public First, public CODI_UNION<Tail...> {};
#endif

  template<typename First>
  struct CODI_UNION<First> : public First {};


#define CODI_WRAP_FUNCTION(NAME, FUNC)        \
  struct NAME {                               \
    public:                                   \
                            \
      template<typename... Args>              \
      void operator()(Args&&... args) const { \
        FUNC(std::forward<Args>(args)...);    \
      }                                       \
  }

#define CODI_WRAP_FUNCTION_TEMPLATE(NAME, FUNC)   \
  template<typename... TT>                        \
  struct NAME {                                   \
    public:                                       \
                                \
      template<typename... Args>                  \
      void operator()(Args&&... args) const {     \
        FUNC<TT...>(std::forward<Args>(args)...); \
      }                                           \
  }
}