allOperators.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2025 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 <complex>
 
#include "../../config.h"
#include "../../misc/macros.hpp"
#include "../computeExpression.hpp"
#include "../expressionInterface.hpp"
#include "../real/allOperators.hpp"
#include "complexPredef.hpp"
#include "realToComplexCast.hpp"

namespace codi {
 
  template<typename T_Tape, typename T_ParallelToolbox>
  struct ParallelActiveType;
 
  using std::abs;
  using std::arg;
  using std::conj;
  using std::imag;
  using std::norm;
  using std::polar;
  using std::proj;
  using std::real;
 
  /*******************************************************************************/
 
// Use the Logic from the real definition
#define OPERATION_LOGIC OperationAdd
#define FUNCTION operator+
#include "binaryMixedComplexAndRealOverloads.tpp"
 
#define OPERATION_LOGIC OperationSubstract
#define FUNCTION operator-
#include "binaryMixedComplexAndRealOverloads.tpp"
 
#define OPERATION_LOGIC OperationMultiply
#define FUNCTION operator*
#include "binaryMixedComplexAndRealOverloads.tpp"
 
#define OPERATION_LOGIC OperationDivide
#define FUNCTION operator/
#include "binaryMixedComplexAndRealOverloads.tpp"

  /*******************************************************************************/
  /// @name Standard math library binary operators
  /// @{

  template<typename T_ComplexReal>
  struct OperationComplexPolar : public BinaryOperation<T_ComplexReal, OperationComplexPolar<T_ComplexReal>> {
    public:
 
      using ComplexReal = CODI_DD(T_ComplexReal, std::complex<double>);  
 
      using Real = typename ComplexReal::value_type;  


      template<typename ArgA, typename ArgB>
      static CODI_INLINE ComplexReal primal(ArgA const& argA, ArgB const& argB) {
        return polar(argA, argB);
      }

      template<typename Tangent, typename ArgA, typename ArgB>
      static CODI_INLINE auto applyTangentArgA(Tangent const& tangent, ComplexReal const& result, ArgA const& argA,
                                               ArgB const& argB);
      // TODO: Implement

      /// \copydoc codi::BinaryOperation::applyAdjointArgA
      template<typename Adjoint, typename ArgA, typename ArgB>
      static CODI_INLINE Real applyAdjointArgA(Adjoint const& adjoint, ComplexReal const& result, ArgA const& argA,
                                               ArgB const& argB) {
        CODI_UNUSED(result, argA);
        return cos(argB) * std::real(adjoint) + sin(argB) * std::imag(adjoint);
      }

      template<typename Tangent, typename ArgA, typename ArgB>
      static CODI_INLINE auto applyTangentArgB(Tangent const& tangent, ComplexReal const& result, ArgA const& argA,
                                               ArgB const& argB);
      // TODO: Implement

      template<typename Adjoint, typename ArgA, typename ArgB>
      static CODI_INLINE Real applyAdjointArgB(Adjoint const& adjoint, ComplexReal const& result, ArgA const& argA,
                                               ArgB const& argB) {
        CODI_UNUSED(argA, argB);
 
        return -std::imag(result) * std::real(adjoint) + std::real(result) * std::imag(adjoint);
      }

      static CODI_INLINE std::string getMathRep() {
        return "polar()";
      }
  };
 
#define FUNCTION polar
#define OPERATION_LOGIC OperationComplexPolar
#include "binaryRealToComplexOverloads.tpp"

  template<typename T_Real>
  struct OperationPow<std::complex<T_Real>>
      : public BinaryJacobianOperation<std::complex<T_Real>, OperationPow<std::complex<T_Real>>> {
    public:
 
      using ComplexReal = CODI_DD(std::complex<T_Real>, std::complex<double>);  

      template<typename ArgA, typename ArgB>
      static CODI_INLINE ComplexReal primal(ArgA const& argA, ArgB const& argB) {
        return pow(argA, argB);
      }

      template<typename ArgA, typename ArgB>
      static CODI_INLINE ComplexReal gradientA(ArgA const& argA, ArgB const& argB, ComplexReal const& result) {
        CODI_UNUSED(result);
 
        return argB * pow(argA, argB - 1.0);
      }

      template<typename ArgA, typename ArgB>
      static CODI_INLINE ComplexReal gradientB(ArgA const& argA, ArgB const& argB, ComplexReal const& result) {
        CODI_UNUSED(argB);
 
        // Complex cast for argA, since the real log for negative numbers is not defined.
        return log(ComplexReal(argA)) * result;
      }

      static CODI_INLINE std::string getMathRep() {
        return "pow()";
      }
  };
 
#define OPERATION_LOGIC OperationPow
#define FUNCTION pow
#include "binaryMixedComplexAndRealOverloads.tpp"

  /*******************************************************************************/
 
#define OPERATOR ==
#include "conditionalBinaryMixedComplexAndRealOverloads.tpp"
 
#define OPERATOR !=
#include "conditionalBinaryMixedComplexAndRealOverloads.tpp"

  /*******************************************************************************/
 
  // Functions handled by the real definitions:
  // exp, log, log10, sqrt, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh,
  // Unary operators handled by the real definitions:
  // operator+, operator-

  template<typename T_Real>
  struct OperationComplexAbs : public UnaryJacobianOperation<T_Real, OperationComplexAbs<T_Real>> {
    public:
 
      using Real = CODI_DD(T_Real, double);  
      using Jacobian = std::complex<Real>;   

      template<typename Arg>
      static CODI_INLINE Real primal(Arg const& arg) {
        return abs(arg);
      }

      template<typename Arg>
      static CODI_INLINE Jacobian gradient(Arg const& arg, Real const& result) {
        checkResult(result);
        if (result != 0.0) {
          return Jacobian(real(arg) / result, -imag(arg) / result);
        } else {
          return Jacobian(0.0);
        }
      }

      static CODI_INLINE std::string getMathRep() {
        return "abs";
      }
 
    private:
      static CODI_INLINE void checkResult(Real const& result) {
        if (Config::CheckExpressionArguments) {
          if (RealTraits::getPassiveValue(result) == 0.0) {
            CODI_EXCEPTION("Zero divisor for abs derivative.");
          }
        }
      }
  };
 
#define FUNCTION abs
#define OPERATION_LOGIC OperationComplexAbs
#include "unaryComplexToRealOverloads.tpp"

  template<typename T_Real>
  struct OperationComplexArg : public UnaryJacobianOperation<T_Real, OperationComplexArg<T_Real>> {
    public:
 
      using Real = CODI_DD(T_Real, double);  
      using Jacobian = std::complex<Real>;   

      template<typename Argument>
      static CODI_INLINE Real primal(Argument const& argument) {
        return arg(argument);
      }

      template<typename Argument>
      static CODI_INLINE Jacobian gradient(Argument const& argument, Real const& result) {
        CODI_UNUSED(result);
 
        Real divisor = real(argument) * real(argument) + imag(argument) * imag(argument);
        checkDivisor(divisor);
        divisor = 1.0 / divisor;
 
        return Jacobian(-imag(argument) * divisor, -real(argument) * divisor);
      }

      static CODI_INLINE std::string getMathRep() {
        return "arg";
      }
 
    private:
      static CODI_INLINE void checkDivisor(Real const& devisor) {
        if (Config::CheckExpressionArguments) {
          if (RealTraits::getPassiveValue(devisor) == 0.0) {
            CODI_EXCEPTION("Zero divisor for arg derivative.");
          }
        }
      }
  };
 
#define FUNCTION arg
#define OPERATION_LOGIC OperationComplexArg
#include "unaryComplexToRealOverloads.tpp"

  template<typename T_ComplexReal>
  struct OperationComplexConj : public UnaryOperation<T_ComplexReal, OperationComplexConj<T_ComplexReal>> {
    public:
 
      using ComplexReal = CODI_DD(T_ComplexReal, std::complex<double>);  

      template<typename Arg>
      static CODI_INLINE ComplexReal primal(Arg const& arg) {
        return conj(arg);
      }

      template<typename Tangent, typename Arg>
      static CODI_INLINE auto applyTangentArg(Tangent const& tangent, ComplexReal const& result, Arg const& arg) {
        CODI_UNUSED(arg, result);
 
        return conj(tangent);
      }

      template<typename Adjoint, typename Arg>
      static CODI_INLINE auto applyAdjointArg(Adjoint const& adjoint, ComplexReal const& result, Arg const& arg) {
        CODI_UNUSED(arg, result);
 
        return conj(adjoint);
      }

      static CODI_INLINE std::string getMathRep() {
        return "conj";
      }
  };
 
#define FUNCTION conj
#define OPERATION_LOGIC OperationComplexConj
#include "../real/unaryOverloads.tpp"

  template<typename T_Real>
  struct OperationComplexImag : public UnaryJacobianOperation<T_Real, OperationComplexImag<T_Real>> {
    public:
 
      using Real = CODI_DD(T_Real, double);  
      using Jacobian = std::complex<Real>;   

      template<typename Arg>
      static CODI_INLINE Real primal(Arg const& arg) {
        return arg.imag();
      }

      template<typename Arg>
      static CODI_INLINE Jacobian gradient(Arg const& arg, Real const& result) {
        CODI_UNUSED(arg, result);
 
        return Jacobian(0.0, -1.0);
      }

      static CODI_INLINE std::string getMathRep() {
        return "imag";
      }
  };
 
#define FUNCTION imag
#define OPERATION_LOGIC OperationComplexImag
#include "unaryComplexToRealOverloads.tpp"

  template<typename T_Real>
  struct OperationComplexNorm : public UnaryJacobianOperation<T_Real, OperationComplexNorm<T_Real>> {
    public:
 
      using Real = CODI_DD(T_Real, double);  
      using Jacobian = std::complex<Real>;   

      template<typename Arg>
      static CODI_INLINE Real primal(Arg const& arg) {
        return norm(arg);
      }

      template<typename Arg>
      static CODI_INLINE Jacobian gradient(Arg const& arg, Real const& result) {
        CODI_UNUSED(result);
 
        return Jacobian(2.0 * real(arg), -2.0 * imag(arg));
      }

      static CODI_INLINE std::string getMathRep() {
        return "norm";
      }
  };
 
#define FUNCTION norm
#define OPERATION_LOGIC OperationComplexNorm
#include "unaryComplexToRealOverloads.tpp"

  template<typename T_ComplexReal>
  struct OperationComplexProj : public UnaryJacobianOperation<T_ComplexReal, OperationComplexProj<T_ComplexReal>> {
    public:
 
      using ComplexReal = CODI_DD(T_ComplexReal, std::complex<double>);  
      using Jacobian = double;                                           

      template<typename Arg>
      static CODI_INLINE ComplexReal primal(Arg const& argument) {
        return proj(argument);
      }

      template<typename Arg>
      static CODI_INLINE Jacobian gradient(Arg const& argument, ComplexReal const& result) {
        CODI_UNUSED(argument, result);
 
        return 1.0;
      }

      static CODI_INLINE std::string getMathRep() {
        return "proj";
      }
  };
 
#define FUNCTION proj
#define OPERATION_LOGIC OperationComplexProj
#include "../real/unaryOverloads.tpp"

  template<typename T_Real>
  struct OperationComplexReal : public UnaryJacobianOperation<T_Real, OperationComplexReal<T_Real>> {
    public:
 
      using Real = CODI_DD(T_Real, double);  
      using Jacobian = std::complex<Real>;   

      template<typename Arg>
      static CODI_INLINE Real primal(Arg const& arg) {
        return arg.real();
      }

      template<typename Arg>
      static CODI_INLINE Jacobian gradient(Arg const& arg, Real const& result) {
        CODI_UNUSED(arg, result);
 
        return Jacobian(1.0, 0.0);
      }

      static CODI_INLINE std::string getMathRep() {
        return "real";
      }
  };
 
#define FUNCTION real
#define OPERATION_LOGIC OperationComplexReal
#include "unaryComplexToRealOverloads.tpp"

}
 
namespace std {
  template<typename Real>
  bool isfinite(std::complex<Real> arg) {
    return isfinite(arg.real()) && isfinite(arg.imag());
  }
 
  using codi::abs;
  using codi::imag;
  using codi::real;
 
}