sparse_fo_rev.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 ADOL-C -- Automatic Differentiation by Overloading in C++
 File:     sparse/sparse_fo_rev.h
 Revision: $Id$
 Contents: This file contains some "Easy To Use" interfaces of the sparse
package.
 
 
 Copyright (c) Andrea Walther, Christo Mitev
 
 This file is part of ADOL-C. This software is provided as open source.
 Any use, reproduction, or distribution of the software constitutes
 recipient's acceptance of the terms of the accompanying license file.
 
----------------------------------------------------------------------------*/
#ifndef ADOLC_SPARSE_FO_REV_H
#define ADOLC_SPARSE_FO_REV_H
#include <adolc/adolcerror.h>
#include <adolc/adolcexport.h>
#include <adolc/dvlparms.h>
#include <adolc/interfaces.h>
#include <adolc/internal/common.h>
#include <adolc/sparse/sparse_fo_rev.h>
#include <adolc/sparse/sparse_options.h>
#include <vector>
 
namespace ADOLC::Sparse {
template <ControlFlowMode CFM>
ADOLC_API int forward(short tag, int m, int n, int p, double *x,
                      std::vector<bitword_t *> &X, double *y,
                      std::vector<bitword_t *> &Y) {
  if constexpr (CFM == ControlFlowMode::Tight) {
    if (x != nullptr)
      return int_forward_tight(tag, m, n, p, x, X.data(), y, Y.data());
    else
      ADOLCError::fail(ADOLCError::ErrorType::SPARSE_NO_BP, CURRENT_LOCATION);
 
  } else if constexpr (CFM == ControlFlowMode::Safe)
    return int_forward_safe(tag, m, n, p, X.data(), Y.data());
  else
    static_assert(is_dependent_v<CFM>,
                  "Mode must be either 'safe' or 'tight'!");
}
 
template <ControlFlowMode CFM>
ADOLC_API int forward(short tag, int m, int n, int p,
                      std::vector<bitword_t *> &X,
                      std::vector<bitword_t *> &Y) {
  if constexpr (CFM == ControlFlowMode::Safe)
    return int_forward_safe(tag, m, n, p, X.data(), Y.data());
  else
    static_assert(is_dependent_v<CFM>, "Mode has to be 'safe'!");
}
 
template <ControlFlowMode CFM>
ADOLC_API int reverse(short tag, int m, int n, int q,
                      std::vector<bitword_t *> &U,
                      std::vector<bitword_t *> &Z) {
  if constexpr (CFM == ControlFlowMode::Safe)
    return int_reverse_safe(tag, m, n, q, U.data(), Z.data());
  else if constexpr (CFM == ControlFlowMode::Tight)
    return int_reverse_tight(tag, m, n, q, U.data(), Z.data());
  else
    static_assert(is_dependent_v<CFM>,
                  "Mode must be either 'safe' or 'tight'!");
}
 
ADOLC_API int forward(short tag, int m, int n, int p, double *x, bitword_t **X,
                      double *y, bitword_t **Y, char mode);
 
ADOLC_API int forward(short tag, int m, int n, int p, bitword_t **X,
                      bitword_t **Y, char mode);
 
ADOLC_API int reverse(short tag, int m, int n, int q, bitword_t **U,
                      bitword_t **Z, char mode);
} // namespace ADOLC::Sparse
#endif // ADOLC_SPARSE_FO_REV_H