From ab4911370e3a00f5f560f7a95f8f224219846bc3 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Thu, 12 Sep 2024 21:29:57 +0200 Subject: [PATCH 01/28] add interface src --- ADOL-C/c_interface/ADOLCTBInterface.cpp | 313 ++++++++++++++++++++++++ ADOL-C/c_interface/ADOLCTBInterface.h | 138 +++++++++++ ADOL-C/c_interface/ADOLCTLInterface.cpp | 297 ++++++++++++++++++++++ ADOL-C/c_interface/ADOLCTLInterface.h | 125 ++++++++++ ADOL-C/c_interface/CMakeLists.txt | 13 + ADOL-C/c_interface/array_handler.cpp | 51 ++++ ADOL-C/c_interface/array_handler.h | 17 ++ 7 files changed, 954 insertions(+) create mode 100644 ADOL-C/c_interface/ADOLCTBInterface.cpp create mode 100644 ADOL-C/c_interface/ADOLCTBInterface.h create mode 100644 ADOL-C/c_interface/ADOLCTLInterface.cpp create mode 100644 ADOL-C/c_interface/ADOLCTLInterface.h create mode 100644 ADOL-C/c_interface/CMakeLists.txt create mode 100644 ADOL-C/c_interface/array_handler.cpp create mode 100644 ADOL-C/c_interface/array_handler.h diff --git a/ADOL-C/c_interface/ADOLCTBInterface.cpp b/ADOL-C/c_interface/ADOLCTBInterface.cpp new file mode 100644 index 00000000..a43ee394 --- /dev/null +++ b/ADOL-C/c_interface/ADOLCTBInterface.cpp @@ -0,0 +1,313 @@ +#include +#include "ADOLCTBInterface.h" + +/* +Constructor & Destructor for class tape-based adouble +*/ +extern "C" +{ + // Constructor + TBAdoubleHandle create_tb_adouble(double x) + { + return new adouble(x); + } + TBAdoubleHandle create_tb_adouble_empty() + { + return new adouble(); + } + + // Destructor + void free_tb_adouble(TBAdoubleHandle a) + { + return delete static_cast(a); + } +} + +/* +Utilities for adouble +*/ +extern "C" +{ + double get_tb_value(TBAdoubleHandle a) + { + return static_cast(a)->getValue(); + } +} + +/* +Arithmetics for class adouble +*/ +extern "C" +{ + TBAdoubleHandle add_tb_adouble(const TBAdoubleHandle a, const TBAdoubleHandle b) + { + return new adouble(*static_cast(a) + *static_cast(b)); + } + TBAdoubleHandle add_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(x + *static_cast(b)); + } + TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(*static_cast(a) + x); + } + TBAdoubleHandle mult_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(*static_cast(a) * *static_cast(b)); + } + TBAdoubleHandle mult_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(x * *static_cast(b)); + } + TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(*static_cast(a) * x); + } + TBAdoubleHandle subtr_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(*static_cast(a) - *static_cast(b)); + } + TBAdoubleHandle subtr_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(x - *static_cast(b)); + } + TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(*static_cast(a) - x); + } + TBAdoubleHandle div_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(*static_cast(a) / *static_cast(b)); + } + TBAdoubleHandle div_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(x / *static_cast(b)); + } + TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(*static_cast(a) / x); + } + TBAdoubleHandle max_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(fmax(*static_cast(a), *static_cast(b))); + } + TBAdoubleHandle max_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(fmax(x, *static_cast(b))); + } + TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(fmax(*static_cast(a), x)); + } + TBAdoubleHandle min_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(fmin(*static_cast(a), *static_cast(b))); + } + TBAdoubleHandle min_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(fmin(x, *static_cast(b))); + } + TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(fmin(*static_cast(a), x)); + } + TBAdoubleHandle pow_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(pow(*static_cast(a), *static_cast(b))); + } + TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(pow(*static_cast(a), x)); + } + bool ge_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) >= *static_cast(b); + } + bool ge_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x >= *static_cast(b); + } + bool ge_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) >= x; + } + bool g_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) > *static_cast(b); + } + bool g_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x > *static_cast(b); + } + bool g_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) > x; + } + bool le_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) <= *static_cast(b); + } + bool le_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x <= *static_cast(b); + } + bool le_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) <= x; + } + bool l_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) < *static_cast(b); + } + bool l_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x < *static_cast(b); + } + bool l_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) < x; + } + bool eq_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) == *static_cast(b); + } + bool eq_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x == *static_cast(b); + } + bool eq_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) == x; + } + TBAdoubleHandle tb_abs(TBAdoubleHandle a) + { + return new adouble(fabs(*static_cast(a))); + } + TBAdoubleHandle tb_sqrt(TBAdoubleHandle a) + { + return new adouble(sqrt(*static_cast(a))); + } + TBAdoubleHandle tb_log(TBAdoubleHandle a) + { + return new adouble(log(*static_cast(a))); + } + TBAdoubleHandle tb_log10(TBAdoubleHandle a) + { + return new adouble(log10(*static_cast(a))); + } + TBAdoubleHandle tb_sin(TBAdoubleHandle a) + { + return new adouble(sin(*static_cast(a))); + } + TBAdoubleHandle tb_cos(TBAdoubleHandle a) + { + return new adouble(cos(*static_cast(a))); + } + TBAdoubleHandle tb_tan(TBAdoubleHandle a) + { + return new adouble(tan(*static_cast(a))); + } + TBAdoubleHandle tb_exp(TBAdoubleHandle a) + { + return new adouble(exp(*static_cast(a))); + } + TBAdoubleHandle tb_asin(TBAdoubleHandle a) + { + return new adouble(asin(*static_cast(a))); + } + TBAdoubleHandle tb_acos(TBAdoubleHandle a) + { + return new adouble(acos(*static_cast(a))); + } + TBAdoubleHandle tb_atan(TBAdoubleHandle a) + { + return new adouble(atan(*static_cast(a))); + } + TBAdoubleHandle tb_sinh(TBAdoubleHandle a) + { + return new adouble(sinh(*static_cast(a))); + } + TBAdoubleHandle tb_cosh(TBAdoubleHandle a) + { + return new adouble(cosh(*static_cast(a))); + } + TBAdoubleHandle tb_tanh(TBAdoubleHandle a) + { + return new adouble(tanh(*static_cast(a))); + } + TBAdoubleHandle tb_asinh(TBAdoubleHandle a) + { + return new adouble(asinh(*static_cast(a))); + } + TBAdoubleHandle tb_acosh(TBAdoubleHandle a) + { + return new adouble(acosh(*static_cast(a))); + } + TBAdoubleHandle tb_atanh(TBAdoubleHandle a) + { + return new adouble(atanh(*static_cast(a))); + } + TBAdoubleHandle tb_ceil(TBAdoubleHandle a) + { + return new adouble(ceil(*static_cast(a))); + } + TBAdoubleHandle tb_floor(TBAdoubleHandle a) + { + return new adouble(floor(*static_cast(a))); + } + TBAdoubleHandle tb_ldexp(TBAdoubleHandle a, int n) + { + return new adouble(ldexp(*static_cast(a), n)); + } + TBAdoubleHandle tb_erf(TBAdoubleHandle a) + { + return new adouble(erf(*static_cast(a))); + } +} + +/* +Tape utilities +*/ +extern "C" +{ + int c_trace_on(short int tag, int keep) + { + return trace_on(tag, keep); + } + void c_trace_off(int flag) + { + return trace_off(flag); + } + void create_independent(TBAdoubleHandle a, double x) + { + *static_cast(a) <<= x; + } + void create_dependent(TBAdoubleHandle a, double *y) + { + *static_cast(a) >>= *y; + } + size_t num_independent(short tape_id) + { + size_t y[STAT_SIZE]; + tapestats(tape_id, y); + return y[NUM_INDEPENDENTS]; + } + size_t num_dependent(short tape_id) + { + size_t y[STAT_SIZE]; + tapestats(tape_id, y); + return y[NUM_DEPENDENTS]; + } + void enable_min_max_using_abs() + { + return enableMinMaxUsingAbs(); + } + void disable_min_max_using_abs() + { + return disableMinMaxUsingAbs(); + } + TBAdoubleHandle mkparam_(const double val) + { + return new adouble(mkparam(val)); + } +} diff --git a/ADOL-C/c_interface/ADOLCTBInterface.h b/ADOL-C/c_interface/ADOLCTBInterface.h new file mode 100644 index 00000000..57296e9c --- /dev/null +++ b/ADOL-C/c_interface/ADOLCTBInterface.h @@ -0,0 +1,138 @@ + +#ifdef __cplusplus +extern "C" +{ +#endif + // Used to handle Tape-based adouble as void* + typedef void *TBAdoubleHandle; +#ifdef __cplusplus +} +#endif + +/* +Constructor & Destructor for class adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + // Constructor + TBAdoubleHandle create_tb_adouble(double x); + TBAdoubleHandle create_tb_adouble_empty(); + + // Destructor + void free_tb_adouble(TBAdoubleHandle a); +#ifdef __cplusplus +} +#endif + +/* +Utilities for adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + double get_tb_value(TBAdoubleHandle a); +#ifdef __cplusplus +} +#endif + +/* +Arithmetics for class tb adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + TBAdoubleHandle add_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle add_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle mult_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle mult_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle subtr_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle subtr_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle div_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle div_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle max_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle max_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle min_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle min_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle pow_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, double x); + + bool ge_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool ge_double_tb_adouble(double x, TBAdoubleHandle b); + bool ge_tb_adouble_double(TBAdoubleHandle a, double x); + + bool g_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool g_double_tb_adouble(double x, TBAdoubleHandle b); + bool g_tb_adouble_double(TBAdoubleHandle a, double x); + + bool le_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool le_double_tb_adouble(double x, TBAdoubleHandle b); + bool le_tb_adouble_double(TBAdoubleHandle a, double x); + + bool l_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool l_double_tb_adouble(double x, TBAdoubleHandle b); + bool l_tb_adouble_double(TBAdoubleHandle a, double x); + + bool eq_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool eq_double_tb_adouble(double x, TBAdoubleHandle b); + bool eq_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle tb_abs(TBAdoubleHandle a); + TBAdoubleHandle tb_sqrt(TBAdoubleHandle a); + TBAdoubleHandle tb_log(TBAdoubleHandle a); + TBAdoubleHandle tb_log10(TBAdoubleHandle a); + TBAdoubleHandle tb_sin(TBAdoubleHandle a); + TBAdoubleHandle tb_cos(TBAdoubleHandle a); + TBAdoubleHandle tb_tan(TBAdoubleHandle a); + TBAdoubleHandle tb_exp(TBAdoubleHandle a); + TBAdoubleHandle tb_asin(TBAdoubleHandle a); + TBAdoubleHandle tb_acos(TBAdoubleHandle a); + TBAdoubleHandle tb_atan(TBAdoubleHandle a); + TBAdoubleHandle tb_sinh(TBAdoubleHandle a); + TBAdoubleHandle tb_cosh(TBAdoubleHandle a); + TBAdoubleHandle tb_tanh(TBAdoubleHandle a); + TBAdoubleHandle tb_asinh(TBAdoubleHandle a); + TBAdoubleHandle tb_acosh(TBAdoubleHandle a); + TBAdoubleHandle tb_atanh(TBAdoubleHandle a); + TBAdoubleHandle tb_ceil(TBAdoubleHandle a); + TBAdoubleHandle tb_floor(TBAdoubleHandle a); + TBAdoubleHandle tb_ldexp(TBAdoubleHandle a, int n); + TBAdoubleHandle tb_erf(TBAdoubleHandle a); +#ifdef __cplusplus +} +#endif + +/* +Tape utilities +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + int c_trace_on(short int tag, int keep = 0); + void c_trace_off(int flag = 0); + void create_independent(TBAdoubleHandle a, double x); + void create_dependent(TBAdoubleHandle a, double *y); + size_t num_independent(short tape_id); + size_t num_dependent(short tape_id); + void enable_min_max_using_abs(); + void disable_min_max_using_abs(); + TBAdoubleHandle mkparam_(const double val); +#ifdef __cplusplus +} +#endif diff --git a/ADOL-C/c_interface/ADOLCTLInterface.cpp b/ADOL-C/c_interface/ADOLCTLInterface.cpp new file mode 100644 index 00000000..14258d9d --- /dev/null +++ b/ADOL-C/c_interface/ADOLCTLInterface.cpp @@ -0,0 +1,297 @@ +#include +#include "ADOLCTLInterface.h" + +/* +Constructor & Destructor for class tape-less adouble +*/ +extern "C" +{ + // Constructor + TLAdoubleHandle create_tl_adouble(const double x) + { + return new adtl::adouble(x); + } + TLAdoubleHandle create_tl_adouble_empty() + { + return new adtl::adouble(); + } + TLAdoubleHandle create_tl_adouble_with_ad(const double val, const double *ad_val) + { + return new adtl::adouble(val, ad_val); + } + // Destructor + void free_tl_adouble(TLAdoubleHandle a) + { + return delete static_cast(a); + } +} + +/* +Utilities for adouble +*/ +extern "C" +{ + void set_num_dir(const size_t n) + { + return adtl::setNumDir(n); + } + + void set_tl_value(TLAdoubleHandle a, const double val) + { + return static_cast(a)->setValue(val); + } + + void set_tl_ad_value(TLAdoubleHandle a, const double *const val) + { + return static_cast(a)->setADValue(val); + } + + void set_tl_ad_value_idx(TLAdoubleHandle a, size_t pos, const double val) + { + return static_cast(a)->setADValue(pos, val); + } + + double get_tl_value(TLAdoubleHandle a) + { + return static_cast(a)->getValue(); + } + const double *get_tl_ad_values(TLAdoubleHandle a) + { + return (static_cast(a))->getADValue(); + } + double get_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos) + { + return static_cast(a)->getADValue(pos); + } +} + +/* +Arithmetics for class adouble +*/ +extern "C" +{ + TLAdoubleHandle add_tl_adouble(const TLAdoubleHandle a, const TLAdoubleHandle b) + { + return new adtl::adouble(*static_cast(a) + *static_cast(b)); + } + TLAdoubleHandle add_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(x + *static_cast(b)); + } + TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(*static_cast(a) + x); + } + TLAdoubleHandle mult_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(*static_cast(a) * *static_cast(b)); + } + TLAdoubleHandle mult_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(x * *static_cast(b)); + } + TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(*static_cast(a) * x); + } + TLAdoubleHandle subtr_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(*static_cast(a) - *static_cast(b)); + } + TLAdoubleHandle subtr_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(x - *static_cast(b)); + } + TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(*static_cast(a) - x); + } + TLAdoubleHandle div_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(*static_cast(a) / *static_cast(b)); + } + TLAdoubleHandle div_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(x / *static_cast(b)); + } + TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(*static_cast(a) / x); + } + TLAdoubleHandle max_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(fmax(*static_cast(a), *static_cast(b))); + } + TLAdoubleHandle max_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(fmax(x, *static_cast(b))); + } + TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(fmax(*static_cast(a), x)); + } + TLAdoubleHandle min_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(fmin(*static_cast(a), *static_cast(b))); + } + TLAdoubleHandle min_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(fmin(x, *static_cast(b))); + } + TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(fmin(*static_cast(a), x)); + } + TLAdoubleHandle pow_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(pow(*static_cast(a), *static_cast(b))); + } + TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(pow(*static_cast(a), x)); + } + bool ge_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) >= *static_cast(b); + } + bool ge_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x >= *static_cast(b); + } + bool ge_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) >= x; + } + bool g_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) > *static_cast(b); + } + bool g_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x > *static_cast(b); + } + bool g_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) > x; + } + bool le_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) <= *static_cast(b); + } + bool le_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x <= *static_cast(b); + } + bool le_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) <= x; + } + bool l_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) < *static_cast(b); + } + bool l_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x < *static_cast(b); + } + bool l_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) < x; + } + bool eq_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) == *static_cast(b); + } + bool eq_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x == *static_cast(b); + } + bool eq_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) == x; + } + TLAdoubleHandle tl_abs(TLAdoubleHandle a) + { + return new adtl::adouble(fabs(*static_cast(a))); + } + TLAdoubleHandle tl_sqrt(TLAdoubleHandle a) + { + return new adtl::adouble(sqrt(*static_cast(a))); + } + TLAdoubleHandle tl_log(TLAdoubleHandle a) + { + return new adtl::adouble(log(*static_cast(a))); + } + TLAdoubleHandle tl_log10(TLAdoubleHandle a) + { + return new adtl::adouble(log10(*static_cast(a))); + } + TLAdoubleHandle tl_sin(TLAdoubleHandle a) + { + return new adtl::adouble(sin(*static_cast(a))); + } + TLAdoubleHandle tl_cos(TLAdoubleHandle a) + { + return new adtl::adouble(cos(*static_cast(a))); + } + TLAdoubleHandle tl_tan(TLAdoubleHandle a) + { + return new adtl::adouble(tan(*static_cast(a))); + } + TLAdoubleHandle tl_exp(TLAdoubleHandle a) + { + return new adtl::adouble(exp(*static_cast(a))); + } + TLAdoubleHandle tl_asin(TLAdoubleHandle a) + { + return new adtl::adouble(asin(*static_cast(a))); + } + TLAdoubleHandle tl_acos(TLAdoubleHandle a) + { + return new adtl::adouble(acos(*static_cast(a))); + } + TLAdoubleHandle tl_atan(TLAdoubleHandle a) + { + return new adtl::adouble(atan(*static_cast(a))); + } + TLAdoubleHandle tl_sinh(TLAdoubleHandle a) + { + return new adtl::adouble(sinh(*static_cast(a))); + } + TLAdoubleHandle tl_cosh(TLAdoubleHandle a) + { + return new adtl::adouble(cosh(*static_cast(a))); + } + TLAdoubleHandle tl_tanh(TLAdoubleHandle a) + { + return new adtl::adouble(tanh(*static_cast(a))); + } + TLAdoubleHandle tl_asinh(TLAdoubleHandle a) + { + return new adtl::adouble(asinh(*static_cast(a))); + } + TLAdoubleHandle tl_acosh(TLAdoubleHandle a) + { + return new adtl::adouble(acosh(*static_cast(a))); + } + TLAdoubleHandle tl_atanh(TLAdoubleHandle a) + { + return new adtl::adouble(atanh(*static_cast(a))); + } + TLAdoubleHandle tl_ceil(TLAdoubleHandle a) + { + return new adtl::adouble(ceil(*static_cast(a))); + } + TLAdoubleHandle tl_floor(TLAdoubleHandle a) + { + return new adtl::adouble(floor(*static_cast(a))); + } + TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, int n) + { + return new adtl::adouble(ldexp(*static_cast(a), n)); + } + TLAdoubleHandle tl_erf(TLAdoubleHandle a) + { + return new adtl::adouble(erf(*static_cast(a))); + } +} diff --git a/ADOL-C/c_interface/ADOLCTLInterface.h b/ADOL-C/c_interface/ADOLCTLInterface.h new file mode 100644 index 00000000..bc635ce3 --- /dev/null +++ b/ADOL-C/c_interface/ADOLCTLInterface.h @@ -0,0 +1,125 @@ + +#ifdef __cplusplus +extern "C" +{ +#endif + // Used to handle Tape-based adouble as void* + typedef void *TLAdoubleHandle; +#ifdef __cplusplus +} +#endif + +/* +Constructor & Destructor for class tape-less adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + // Constructor + TLAdoubleHandle create_tl_adouble(double x); + TLAdoubleHandle create_tl_adouble_with_ad(const double val, const double *ad_val); + TLAdoubleHandle create_tl_adouble_empty(); + + // Destructor + void free_tl_adouble(TLAdoubleHandle a); +#ifdef __cplusplus +} +#endif + +/* +Utilities for adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + void set_num_dir(const size_t n); + void set_tl_value(TLAdoubleHandle a, const double val); + void set_tl_ad_value(TLAdoubleHandle a, const double *const val); + void set_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos, const double val); + double get_tl_value(TLAdoubleHandle a); + const double *get_tl_ad_values(TLAdoubleHandle a); + double get_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos); +#ifdef __cplusplus +} +#endif + +/* +Arithmetics for class tl adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + TLAdoubleHandle add_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle add_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle mult_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle mult_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle subtr_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle subtr_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle div_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle div_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle max_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle max_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle min_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle min_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle pow_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, double x); + + bool ge_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool ge_double_tl_adouble(double x, TLAdoubleHandle b); + bool ge_tl_adouble_double(TLAdoubleHandle a, double x); + + bool g_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool g_double_tl_adouble(double x, TLAdoubleHandle b); + bool g_tl_adouble_double(TLAdoubleHandle a, double x); + + bool le_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool le_double_tl_adouble(double x, TLAdoubleHandle b); + bool le_tl_adouble_double(TLAdoubleHandle a, double x); + + bool l_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool l_double_tl_adouble(double x, TLAdoubleHandle b); + bool l_tl_adouble_double(TLAdoubleHandle a, double x); + + bool eq_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool eq_double_tl_adouble(double x, TLAdoubleHandle b); + bool eq_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle tl_abs(TLAdoubleHandle a); + TLAdoubleHandle tl_sqrt(TLAdoubleHandle a); + TLAdoubleHandle tl_log(TLAdoubleHandle a); + TLAdoubleHandle tl_log10(TLAdoubleHandle a); + TLAdoubleHandle tl_sin(TLAdoubleHandle a); + TLAdoubleHandle tl_cos(TLAdoubleHandle a); + TLAdoubleHandle tl_tan(TLAdoubleHandle a); + TLAdoubleHandle tl_exp(TLAdoubleHandle a); + TLAdoubleHandle tl_asin(TLAdoubleHandle a); + TLAdoubleHandle tl_acos(TLAdoubleHandle a); + TLAdoubleHandle tl_atan(TLAdoubleHandle a); + TLAdoubleHandle tl_sinh(TLAdoubleHandle a); + TLAdoubleHandle tl_cosh(TLAdoubleHandle a); + TLAdoubleHandle tl_tanh(TLAdoubleHandle a); + TLAdoubleHandle tl_asinh(TLAdoubleHandle a); + TLAdoubleHandle tl_acosh(TLAdoubleHandle a); + TLAdoubleHandle tl_atanh(TLAdoubleHandle a); + TLAdoubleHandle tl_ceil(TLAdoubleHandle a); + TLAdoubleHandle tl_floor(TLAdoubleHandle a); + TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, int n); + TLAdoubleHandle tl_erf(TLAdoubleHandle a); +#ifdef __cplusplus +} +#endif diff --git a/ADOL-C/c_interface/CMakeLists.txt b/ADOL-C/c_interface/CMakeLists.txt new file mode 100644 index 00000000..3c09d78e --- /dev/null +++ b/ADOL-C/c_interface/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 3.27) + +project(TestADOLC VERSION 1.0) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +add_library(ExternalADOLC SHARED IMPORTED) +set_target_properties(ExternalADOLC PROPERTIES + IMPORTED_LOCATION "${CMAKE_SOURCE_DIR}/lib/libadolc.dylib" + INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include" +) +add_library(ADOLCInterface SHARED ADOLCTBInterface.cpp ADOLCTLInterface.cpp array_handler.cpp) +target_link_libraries(ADOLCInterface ExternalADOLC) diff --git a/ADOL-C/c_interface/array_handler.cpp b/ADOL-C/c_interface/array_handler.cpp new file mode 100644 index 00000000..25b62035 --- /dev/null +++ b/ADOL-C/c_interface/array_handler.cpp @@ -0,0 +1,51 @@ +#include "array_handler.h" + +/* +Setter and getter for vectors, matrizes and tensors. +*/ +extern "C" +{ + const double getindex_vec(const double *A, const int row) + { + return A[row]; + } + void setindex_vec(double *A, const double val, const int row) + { + A[row] = val; + } + + const double getindex_mat(const double **A, const int row, const int col) + { + return A[row][col]; + } + void setindex_mat(double **A, const double val, const int row, const int col) + { + A[row][col] = val; + } + const double **getindex_ten(const double ***A, const int dim) + { + return A[dim]; + } + const double getindex_tens(const double ***A, const int dim, const int row, const int col) + { + return A[dim][row][col]; + } + void setindex_tens(double ***A, const double val, const int dim, const int row, const int col) + { + A[dim][row][col] = val; + } + + short **alloc_short_mat(const int rows, const int cols) + { + short **s = new short *[rows]; + for (int i = 0; i < rows; i++) + { + s[i] = new short[cols]; + } + return s; + } + void free_short_mat(short **s) + { + delete s; + } +} \ No newline at end of file diff --git a/ADOL-C/c_interface/array_handler.h b/ADOL-C/c_interface/array_handler.h new file mode 100644 index 00000000..16740795 --- /dev/null +++ b/ADOL-C/c_interface/array_handler.h @@ -0,0 +1,17 @@ + +#ifdef __cplusplus +extern "C" +{ +#endif + const double getindex_vec(const double *A, const int row); + void setindex_vec(double *A, const double val, const int row); + const double getindex_mat(const double **A, const int row, const int col); + void setindex_mat(double **A, const double val, const int row, const int col); + const double **getindex_ten(const double ***A, const int dim); + const double getindex_tens(const double ***A, const int dim, const int row, const int col); + void setindex_tens(double ***A, const double val, const int dim, const int row, const int col); + short **alloc_short_mat(const int row, const int col); + void free_short_mat(short **s); +#ifdef __cplusplus +} +#endif \ No newline at end of file From 7fd008db4ca7bea9045cf30f1bcbd0ec5da2a898 Mon Sep 17 00:00:00 2001 From: TimSiebert1 <128799979+TimSiebert1@users.noreply.github.com> Date: Thu, 12 Sep 2024 21:32:34 +0200 Subject: [PATCH 02/28] Create cmake-multi-platform.yml --- .github/workflows/cmake-multi-platform.yml | 75 ++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 .github/workflows/cmake-multi-platform.yml diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml new file mode 100644 index 00000000..f21a025c --- /dev/null +++ b/.github/workflows/cmake-multi-platform.yml @@ -0,0 +1,75 @@ +# This starter workflow is for a CMake project running on multiple platforms. There is a different starter workflow if you just want a single platform. +# See: https://github.com/actions/starter-workflows/blob/main/ci/cmake-single-platform.yml +name: CMake on multiple platforms + +on: + push: + branches: [ "master" ] + pull_request: + branches: [ "master" ] + +jobs: + build: + runs-on: ${{ matrix.os }} + + strategy: + # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable. + fail-fast: false + + # Set up a matrix to run the following 3 configurations: + # 1. + # 2. + # 3. + # + # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list. + matrix: + os: [ubuntu-latest, windows-latest] + build_type: [Release] + c_compiler: [gcc, clang, cl] + include: + - os: windows-latest + c_compiler: cl + cpp_compiler: cl + - os: ubuntu-latest + c_compiler: gcc + cpp_compiler: g++ + - os: ubuntu-latest + c_compiler: clang + cpp_compiler: clang++ + exclude: + - os: windows-latest + c_compiler: gcc + - os: windows-latest + c_compiler: clang + - os: ubuntu-latest + c_compiler: cl + + steps: + - uses: actions/checkout@v4 + + - name: Set reusable strings + # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file. + id: strings + shell: bash + run: | + echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT" + + - name: Configure CMake + # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make. + # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type + run: > + cmake -B ${{ steps.strings.outputs.build-output-dir }} + -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }} + -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} + -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} + -S ${{ github.workspace }} + + - name: Build + # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). + run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }} + + - name: Test + working-directory: ${{ steps.strings.outputs.build-output-dir }} + # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). + # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail + run: ctest --build-config ${{ matrix.build_type }} From 18d906bb544c4744fd5d34f022a719ff0ea54f91 Mon Sep 17 00:00:00 2001 From: TimSiebert1 <128799979+TimSiebert1@users.noreply.github.com> Date: Thu, 12 Sep 2024 21:38:29 +0200 Subject: [PATCH 03/28] ignore win for the moment --- .github/workflows/cmake-multi-platform.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml index f21a025c..2dbc55dd 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/cmake-multi-platform.yml @@ -27,9 +27,9 @@ jobs: build_type: [Release] c_compiler: [gcc, clang, cl] include: - - os: windows-latest - c_compiler: cl - cpp_compiler: cl + #- os: windows-latest + # c_compiler: cl + # cpp_compiler: cl - os: ubuntu-latest c_compiler: gcc cpp_compiler: g++ From b8f3e0765f9a318c936b0f7c978176c2c24a855e Mon Sep 17 00:00:00 2001 From: TimSiebert1 <128799979+TimSiebert1@users.noreply.github.com> Date: Thu, 12 Sep 2024 21:42:29 +0200 Subject: [PATCH 04/28] try macOS --- .github/workflows/cmake-multi-platform.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml index 2dbc55dd..cc80fd38 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/cmake-multi-platform.yml @@ -23,7 +23,8 @@ jobs: # # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list. matrix: - os: [ubuntu-latest, windows-latest] + # os: [ubuntu-latest, macOS-latest, windows-latest] + os: [ubuntu-latest, macOS-latest] build_type: [Release] c_compiler: [gcc, clang, cl] include: From 5b63bd92440d8539f80d0c533d3588bb42999138 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Fri, 13 Sep 2024 07:12:08 +0200 Subject: [PATCH 05/28] add interface build option --- ADOL-C/c_interface/CMakeLists.txt | 4 ++-- CMakeLists.txt | 9 +++++++++ 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/ADOL-C/c_interface/CMakeLists.txt b/ADOL-C/c_interface/CMakeLists.txt index 3c09d78e..7a07eefd 100644 --- a/ADOL-C/c_interface/CMakeLists.txt +++ b/ADOL-C/c_interface/CMakeLists.txt @@ -6,8 +6,8 @@ set(CMAKE_CXX_STANDARD_REQUIRED True) add_library(ExternalADOLC SHARED IMPORTED) set_target_properties(ExternalADOLC PROPERTIES - IMPORTED_LOCATION "${CMAKE_SOURCE_DIR}/lib/libadolc.dylib" - INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include" + IMPORTED_LOCATION "${CMAKE_INSTALL_PREFIX}/lib/libadolc.dylib" + INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/include" ) add_library(ADOLCInterface SHARED ADOLCTBInterface.cpp ADOLCTLInterface.cpp array_handler.cpp) target_link_libraries(ADOLCInterface ExternalADOLC) diff --git a/CMakeLists.txt b/CMakeLists.txt index cf2fe31c..caf4d041 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -61,3 +61,12 @@ install(EXPORT adolcTargets FILE adolc-targets.cmake NAMESPACE adolc:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/adolc) + + +# build the ADOL-C C Interface +# ---------------------------- + +option(CINTERFACE "if the c interface is built" OFF) +if(CINTERFACE) + add_subdirectory(ADOL-C/c_interface) +endif() \ No newline at end of file From 547fc88fe64b89b70d35df5ccb5c5380d1b85163 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Fri, 13 Sep 2024 07:22:32 +0200 Subject: [PATCH 06/28] adding some cmake ignores --- .gitignore | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/.gitignore b/.gitignore index 613c1b2f..b4df1807 100644 --- a/.gitignore +++ b/.gitignore @@ -41,3 +41,11 @@ config.h.in config.h config.log config.guess + +# Ignore file generated by cmake + +CMakeLists.txt.user +CMakeCache.txt +CMakeFiles +CMakeScripts +cmake_install.cmake From f04a3c8be0e1443f5a32163a364f4354599ded40 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Fri, 13 Sep 2024 07:34:49 +0200 Subject: [PATCH 07/28] update source paths --- .gitignore | 4 ++++ ADOL-C/c_interface/CMakeLists.txt | 5 +++-- CMakeLists.txt | 2 +- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index b4df1807..b831cbf2 100644 --- a/.gitignore +++ b/.gitignore @@ -49,3 +49,7 @@ CMakeCache.txt CMakeFiles CMakeScripts cmake_install.cmake +install_manifest.txt +*.dylib +*.so +*.dll diff --git a/ADOL-C/c_interface/CMakeLists.txt b/ADOL-C/c_interface/CMakeLists.txt index 7a07eefd..10d50d0a 100644 --- a/ADOL-C/c_interface/CMakeLists.txt +++ b/ADOL-C/c_interface/CMakeLists.txt @@ -6,8 +6,9 @@ set(CMAKE_CXX_STANDARD_REQUIRED True) add_library(ExternalADOLC SHARED IMPORTED) set_target_properties(ExternalADOLC PROPERTIES - IMPORTED_LOCATION "${CMAKE_INSTALL_PREFIX}/lib/libadolc.dylib" - INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/include" + IMPORTED_LOCATION "${CMAKE_SOURCE_DIR}/libadolc.dylib" + INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_SOURCE_DIR}/ADOL-C/include" ) add_library(ADOLCInterface SHARED ADOLCTBInterface.cpp ADOLCTLInterface.cpp array_handler.cpp) target_link_libraries(ADOLCInterface ExternalADOLC) + diff --git a/CMakeLists.txt b/CMakeLists.txt index caf4d041..72799c27 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -66,7 +66,7 @@ install(EXPORT adolcTargets # build the ADOL-C C Interface # ---------------------------- -option(CINTERFACE "if the c interface is built" OFF) +option(CINTERFACE "if ON, the c interface is built" OFF) if(CINTERFACE) add_subdirectory(ADOL-C/c_interface) endif() \ No newline at end of file From 4c6299390e1afb6797e40fcb22a1102ed35afbda Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Fri, 13 Sep 2024 07:37:00 +0200 Subject: [PATCH 08/28] try only linux --- .github/workflows/cmake-multi-platform.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml index cc80fd38..3433d7fd 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/cmake-multi-platform.yml @@ -24,7 +24,8 @@ jobs: # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list. matrix: # os: [ubuntu-latest, macOS-latest, windows-latest] - os: [ubuntu-latest, macOS-latest] + # os: [ubuntu-latest, macOS-latest] + os: [ubuntu-latest] build_type: [Release] c_compiler: [gcc, clang, cl] include: From 6bea3f0a76d1eed3b8fe256210fbb6e55688a1c4 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Fri, 27 Sep 2024 14:18:18 +0200 Subject: [PATCH 09/28] add include guards --- ADOL-C/c_interface/ADOLCTBInterface.h | 4 ++++ ADOL-C/c_interface/ADOLCTLInterface.h | 4 ++++ ADOL-C/c_interface/array_handler.h | 6 +++++- 3 files changed, 13 insertions(+), 1 deletion(-) diff --git a/ADOL-C/c_interface/ADOLCTBInterface.h b/ADOL-C/c_interface/ADOLCTBInterface.h index 57296e9c..df889959 100644 --- a/ADOL-C/c_interface/ADOLCTBInterface.h +++ b/ADOL-C/c_interface/ADOLCTBInterface.h @@ -1,3 +1,5 @@ +#ifndef ADOLC_TB_INTERFACE_H +#define ADOLC_TB_INTERFACE_H #ifdef __cplusplus extern "C" @@ -136,3 +138,5 @@ extern "C" #ifdef __cplusplus } #endif + +#endif // ADOLC_TB_INTERFACE_H \ No newline at end of file diff --git a/ADOL-C/c_interface/ADOLCTLInterface.h b/ADOL-C/c_interface/ADOLCTLInterface.h index bc635ce3..f82609a8 100644 --- a/ADOL-C/c_interface/ADOLCTLInterface.h +++ b/ADOL-C/c_interface/ADOLCTLInterface.h @@ -1,3 +1,5 @@ +#ifdef ADOLC_TL_INTERFACE_H +#define ADOLC_TL_INTERFACE_H #ifdef __cplusplus extern "C" @@ -123,3 +125,5 @@ extern "C" #ifdef __cplusplus } #endif + +#endif // ADOLC_TL_INTERFACE_H \ No newline at end of file diff --git a/ADOL-C/c_interface/array_handler.h b/ADOL-C/c_interface/array_handler.h index 16740795..95fdeb61 100644 --- a/ADOL-C/c_interface/array_handler.h +++ b/ADOL-C/c_interface/array_handler.h @@ -1,3 +1,5 @@ +#ifndef ARRAY_HANDLER_H +#define ARRAY_HANDLER_H #ifdef __cplusplus extern "C" @@ -14,4 +16,6 @@ extern "C" void free_short_mat(short **s); #ifdef __cplusplus } -#endif \ No newline at end of file +#endif + +#endif // ARRAY_HANDLER_H \ No newline at end of file From 34823d22a3b4ff56af5f796d8bc49612d2f028d1 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Fri, 27 Sep 2024 14:20:08 +0200 Subject: [PATCH 10/28] rename files --- ADOL-C/c_interface/ADOLC_TB_interface.cpp | 313 ++++++++++++++++++++++ ADOL-C/c_interface/ADOLC_TB_interface.h | 142 ++++++++++ ADOL-C/c_interface/ADOLC_TL_interface.cpp | 297 ++++++++++++++++++++ ADOL-C/c_interface/ADOLC_TL_interface.h | 129 +++++++++ 4 files changed, 881 insertions(+) create mode 100644 ADOL-C/c_interface/ADOLC_TB_interface.cpp create mode 100644 ADOL-C/c_interface/ADOLC_TB_interface.h create mode 100644 ADOL-C/c_interface/ADOLC_TL_interface.cpp create mode 100644 ADOL-C/c_interface/ADOLC_TL_interface.h diff --git a/ADOL-C/c_interface/ADOLC_TB_interface.cpp b/ADOL-C/c_interface/ADOLC_TB_interface.cpp new file mode 100644 index 00000000..a43ee394 --- /dev/null +++ b/ADOL-C/c_interface/ADOLC_TB_interface.cpp @@ -0,0 +1,313 @@ +#include +#include "ADOLCTBInterface.h" + +/* +Constructor & Destructor for class tape-based adouble +*/ +extern "C" +{ + // Constructor + TBAdoubleHandle create_tb_adouble(double x) + { + return new adouble(x); + } + TBAdoubleHandle create_tb_adouble_empty() + { + return new adouble(); + } + + // Destructor + void free_tb_adouble(TBAdoubleHandle a) + { + return delete static_cast(a); + } +} + +/* +Utilities for adouble +*/ +extern "C" +{ + double get_tb_value(TBAdoubleHandle a) + { + return static_cast(a)->getValue(); + } +} + +/* +Arithmetics for class adouble +*/ +extern "C" +{ + TBAdoubleHandle add_tb_adouble(const TBAdoubleHandle a, const TBAdoubleHandle b) + { + return new adouble(*static_cast(a) + *static_cast(b)); + } + TBAdoubleHandle add_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(x + *static_cast(b)); + } + TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(*static_cast(a) + x); + } + TBAdoubleHandle mult_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(*static_cast(a) * *static_cast(b)); + } + TBAdoubleHandle mult_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(x * *static_cast(b)); + } + TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(*static_cast(a) * x); + } + TBAdoubleHandle subtr_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(*static_cast(a) - *static_cast(b)); + } + TBAdoubleHandle subtr_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(x - *static_cast(b)); + } + TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(*static_cast(a) - x); + } + TBAdoubleHandle div_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(*static_cast(a) / *static_cast(b)); + } + TBAdoubleHandle div_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(x / *static_cast(b)); + } + TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(*static_cast(a) / x); + } + TBAdoubleHandle max_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(fmax(*static_cast(a), *static_cast(b))); + } + TBAdoubleHandle max_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(fmax(x, *static_cast(b))); + } + TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(fmax(*static_cast(a), x)); + } + TBAdoubleHandle min_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(fmin(*static_cast(a), *static_cast(b))); + } + TBAdoubleHandle min_double_tb_adouble(double x, TBAdoubleHandle b) + { + return new adouble(fmin(x, *static_cast(b))); + } + TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(fmin(*static_cast(a), x)); + } + TBAdoubleHandle pow_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return new adouble(pow(*static_cast(a), *static_cast(b))); + } + TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, double x) + { + return new adouble(pow(*static_cast(a), x)); + } + bool ge_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) >= *static_cast(b); + } + bool ge_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x >= *static_cast(b); + } + bool ge_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) >= x; + } + bool g_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) > *static_cast(b); + } + bool g_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x > *static_cast(b); + } + bool g_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) > x; + } + bool le_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) <= *static_cast(b); + } + bool le_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x <= *static_cast(b); + } + bool le_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) <= x; + } + bool l_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) < *static_cast(b); + } + bool l_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x < *static_cast(b); + } + bool l_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) < x; + } + bool eq_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) + { + return *static_cast(a) == *static_cast(b); + } + bool eq_double_tb_adouble(double x, TBAdoubleHandle b) + { + return x == *static_cast(b); + } + bool eq_tb_adouble_double(TBAdoubleHandle a, double x) + { + return *static_cast(a) == x; + } + TBAdoubleHandle tb_abs(TBAdoubleHandle a) + { + return new adouble(fabs(*static_cast(a))); + } + TBAdoubleHandle tb_sqrt(TBAdoubleHandle a) + { + return new adouble(sqrt(*static_cast(a))); + } + TBAdoubleHandle tb_log(TBAdoubleHandle a) + { + return new adouble(log(*static_cast(a))); + } + TBAdoubleHandle tb_log10(TBAdoubleHandle a) + { + return new adouble(log10(*static_cast(a))); + } + TBAdoubleHandle tb_sin(TBAdoubleHandle a) + { + return new adouble(sin(*static_cast(a))); + } + TBAdoubleHandle tb_cos(TBAdoubleHandle a) + { + return new adouble(cos(*static_cast(a))); + } + TBAdoubleHandle tb_tan(TBAdoubleHandle a) + { + return new adouble(tan(*static_cast(a))); + } + TBAdoubleHandle tb_exp(TBAdoubleHandle a) + { + return new adouble(exp(*static_cast(a))); + } + TBAdoubleHandle tb_asin(TBAdoubleHandle a) + { + return new adouble(asin(*static_cast(a))); + } + TBAdoubleHandle tb_acos(TBAdoubleHandle a) + { + return new adouble(acos(*static_cast(a))); + } + TBAdoubleHandle tb_atan(TBAdoubleHandle a) + { + return new adouble(atan(*static_cast(a))); + } + TBAdoubleHandle tb_sinh(TBAdoubleHandle a) + { + return new adouble(sinh(*static_cast(a))); + } + TBAdoubleHandle tb_cosh(TBAdoubleHandle a) + { + return new adouble(cosh(*static_cast(a))); + } + TBAdoubleHandle tb_tanh(TBAdoubleHandle a) + { + return new adouble(tanh(*static_cast(a))); + } + TBAdoubleHandle tb_asinh(TBAdoubleHandle a) + { + return new adouble(asinh(*static_cast(a))); + } + TBAdoubleHandle tb_acosh(TBAdoubleHandle a) + { + return new adouble(acosh(*static_cast(a))); + } + TBAdoubleHandle tb_atanh(TBAdoubleHandle a) + { + return new adouble(atanh(*static_cast(a))); + } + TBAdoubleHandle tb_ceil(TBAdoubleHandle a) + { + return new adouble(ceil(*static_cast(a))); + } + TBAdoubleHandle tb_floor(TBAdoubleHandle a) + { + return new adouble(floor(*static_cast(a))); + } + TBAdoubleHandle tb_ldexp(TBAdoubleHandle a, int n) + { + return new adouble(ldexp(*static_cast(a), n)); + } + TBAdoubleHandle tb_erf(TBAdoubleHandle a) + { + return new adouble(erf(*static_cast(a))); + } +} + +/* +Tape utilities +*/ +extern "C" +{ + int c_trace_on(short int tag, int keep) + { + return trace_on(tag, keep); + } + void c_trace_off(int flag) + { + return trace_off(flag); + } + void create_independent(TBAdoubleHandle a, double x) + { + *static_cast(a) <<= x; + } + void create_dependent(TBAdoubleHandle a, double *y) + { + *static_cast(a) >>= *y; + } + size_t num_independent(short tape_id) + { + size_t y[STAT_SIZE]; + tapestats(tape_id, y); + return y[NUM_INDEPENDENTS]; + } + size_t num_dependent(short tape_id) + { + size_t y[STAT_SIZE]; + tapestats(tape_id, y); + return y[NUM_DEPENDENTS]; + } + void enable_min_max_using_abs() + { + return enableMinMaxUsingAbs(); + } + void disable_min_max_using_abs() + { + return disableMinMaxUsingAbs(); + } + TBAdoubleHandle mkparam_(const double val) + { + return new adouble(mkparam(val)); + } +} diff --git a/ADOL-C/c_interface/ADOLC_TB_interface.h b/ADOL-C/c_interface/ADOLC_TB_interface.h new file mode 100644 index 00000000..df889959 --- /dev/null +++ b/ADOL-C/c_interface/ADOLC_TB_interface.h @@ -0,0 +1,142 @@ +#ifndef ADOLC_TB_INTERFACE_H +#define ADOLC_TB_INTERFACE_H + +#ifdef __cplusplus +extern "C" +{ +#endif + // Used to handle Tape-based adouble as void* + typedef void *TBAdoubleHandle; +#ifdef __cplusplus +} +#endif + +/* +Constructor & Destructor for class adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + // Constructor + TBAdoubleHandle create_tb_adouble(double x); + TBAdoubleHandle create_tb_adouble_empty(); + + // Destructor + void free_tb_adouble(TBAdoubleHandle a); +#ifdef __cplusplus +} +#endif + +/* +Utilities for adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + double get_tb_value(TBAdoubleHandle a); +#ifdef __cplusplus +} +#endif + +/* +Arithmetics for class tb adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + TBAdoubleHandle add_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle add_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle mult_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle mult_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle subtr_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle subtr_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle div_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle div_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle max_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle max_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle min_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle min_double_tb_adouble(double x, TBAdoubleHandle b); + TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle pow_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, double x); + + bool ge_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool ge_double_tb_adouble(double x, TBAdoubleHandle b); + bool ge_tb_adouble_double(TBAdoubleHandle a, double x); + + bool g_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool g_double_tb_adouble(double x, TBAdoubleHandle b); + bool g_tb_adouble_double(TBAdoubleHandle a, double x); + + bool le_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool le_double_tb_adouble(double x, TBAdoubleHandle b); + bool le_tb_adouble_double(TBAdoubleHandle a, double x); + + bool l_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool l_double_tb_adouble(double x, TBAdoubleHandle b); + bool l_tb_adouble_double(TBAdoubleHandle a, double x); + + bool eq_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); + bool eq_double_tb_adouble(double x, TBAdoubleHandle b); + bool eq_tb_adouble_double(TBAdoubleHandle a, double x); + + TBAdoubleHandle tb_abs(TBAdoubleHandle a); + TBAdoubleHandle tb_sqrt(TBAdoubleHandle a); + TBAdoubleHandle tb_log(TBAdoubleHandle a); + TBAdoubleHandle tb_log10(TBAdoubleHandle a); + TBAdoubleHandle tb_sin(TBAdoubleHandle a); + TBAdoubleHandle tb_cos(TBAdoubleHandle a); + TBAdoubleHandle tb_tan(TBAdoubleHandle a); + TBAdoubleHandle tb_exp(TBAdoubleHandle a); + TBAdoubleHandle tb_asin(TBAdoubleHandle a); + TBAdoubleHandle tb_acos(TBAdoubleHandle a); + TBAdoubleHandle tb_atan(TBAdoubleHandle a); + TBAdoubleHandle tb_sinh(TBAdoubleHandle a); + TBAdoubleHandle tb_cosh(TBAdoubleHandle a); + TBAdoubleHandle tb_tanh(TBAdoubleHandle a); + TBAdoubleHandle tb_asinh(TBAdoubleHandle a); + TBAdoubleHandle tb_acosh(TBAdoubleHandle a); + TBAdoubleHandle tb_atanh(TBAdoubleHandle a); + TBAdoubleHandle tb_ceil(TBAdoubleHandle a); + TBAdoubleHandle tb_floor(TBAdoubleHandle a); + TBAdoubleHandle tb_ldexp(TBAdoubleHandle a, int n); + TBAdoubleHandle tb_erf(TBAdoubleHandle a); +#ifdef __cplusplus +} +#endif + +/* +Tape utilities +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + int c_trace_on(short int tag, int keep = 0); + void c_trace_off(int flag = 0); + void create_independent(TBAdoubleHandle a, double x); + void create_dependent(TBAdoubleHandle a, double *y); + size_t num_independent(short tape_id); + size_t num_dependent(short tape_id); + void enable_min_max_using_abs(); + void disable_min_max_using_abs(); + TBAdoubleHandle mkparam_(const double val); +#ifdef __cplusplus +} +#endif + +#endif // ADOLC_TB_INTERFACE_H \ No newline at end of file diff --git a/ADOL-C/c_interface/ADOLC_TL_interface.cpp b/ADOL-C/c_interface/ADOLC_TL_interface.cpp new file mode 100644 index 00000000..14258d9d --- /dev/null +++ b/ADOL-C/c_interface/ADOLC_TL_interface.cpp @@ -0,0 +1,297 @@ +#include +#include "ADOLCTLInterface.h" + +/* +Constructor & Destructor for class tape-less adouble +*/ +extern "C" +{ + // Constructor + TLAdoubleHandle create_tl_adouble(const double x) + { + return new adtl::adouble(x); + } + TLAdoubleHandle create_tl_adouble_empty() + { + return new adtl::adouble(); + } + TLAdoubleHandle create_tl_adouble_with_ad(const double val, const double *ad_val) + { + return new adtl::adouble(val, ad_val); + } + // Destructor + void free_tl_adouble(TLAdoubleHandle a) + { + return delete static_cast(a); + } +} + +/* +Utilities for adouble +*/ +extern "C" +{ + void set_num_dir(const size_t n) + { + return adtl::setNumDir(n); + } + + void set_tl_value(TLAdoubleHandle a, const double val) + { + return static_cast(a)->setValue(val); + } + + void set_tl_ad_value(TLAdoubleHandle a, const double *const val) + { + return static_cast(a)->setADValue(val); + } + + void set_tl_ad_value_idx(TLAdoubleHandle a, size_t pos, const double val) + { + return static_cast(a)->setADValue(pos, val); + } + + double get_tl_value(TLAdoubleHandle a) + { + return static_cast(a)->getValue(); + } + const double *get_tl_ad_values(TLAdoubleHandle a) + { + return (static_cast(a))->getADValue(); + } + double get_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos) + { + return static_cast(a)->getADValue(pos); + } +} + +/* +Arithmetics for class adouble +*/ +extern "C" +{ + TLAdoubleHandle add_tl_adouble(const TLAdoubleHandle a, const TLAdoubleHandle b) + { + return new adtl::adouble(*static_cast(a) + *static_cast(b)); + } + TLAdoubleHandle add_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(x + *static_cast(b)); + } + TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(*static_cast(a) + x); + } + TLAdoubleHandle mult_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(*static_cast(a) * *static_cast(b)); + } + TLAdoubleHandle mult_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(x * *static_cast(b)); + } + TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(*static_cast(a) * x); + } + TLAdoubleHandle subtr_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(*static_cast(a) - *static_cast(b)); + } + TLAdoubleHandle subtr_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(x - *static_cast(b)); + } + TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(*static_cast(a) - x); + } + TLAdoubleHandle div_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(*static_cast(a) / *static_cast(b)); + } + TLAdoubleHandle div_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(x / *static_cast(b)); + } + TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(*static_cast(a) / x); + } + TLAdoubleHandle max_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(fmax(*static_cast(a), *static_cast(b))); + } + TLAdoubleHandle max_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(fmax(x, *static_cast(b))); + } + TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(fmax(*static_cast(a), x)); + } + TLAdoubleHandle min_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(fmin(*static_cast(a), *static_cast(b))); + } + TLAdoubleHandle min_double_tl_adouble(double x, TLAdoubleHandle b) + { + return new adtl::adouble(fmin(x, *static_cast(b))); + } + TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(fmin(*static_cast(a), x)); + } + TLAdoubleHandle pow_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return new adtl::adouble(pow(*static_cast(a), *static_cast(b))); + } + TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, double x) + { + return new adtl::adouble(pow(*static_cast(a), x)); + } + bool ge_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) >= *static_cast(b); + } + bool ge_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x >= *static_cast(b); + } + bool ge_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) >= x; + } + bool g_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) > *static_cast(b); + } + bool g_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x > *static_cast(b); + } + bool g_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) > x; + } + bool le_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) <= *static_cast(b); + } + bool le_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x <= *static_cast(b); + } + bool le_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) <= x; + } + bool l_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) < *static_cast(b); + } + bool l_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x < *static_cast(b); + } + bool l_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) < x; + } + bool eq_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) + { + return *static_cast(a) == *static_cast(b); + } + bool eq_double_tl_adouble(double x, TLAdoubleHandle b) + { + return x == *static_cast(b); + } + bool eq_tl_adouble_double(TLAdoubleHandle a, double x) + { + return *static_cast(a) == x; + } + TLAdoubleHandle tl_abs(TLAdoubleHandle a) + { + return new adtl::adouble(fabs(*static_cast(a))); + } + TLAdoubleHandle tl_sqrt(TLAdoubleHandle a) + { + return new adtl::adouble(sqrt(*static_cast(a))); + } + TLAdoubleHandle tl_log(TLAdoubleHandle a) + { + return new adtl::adouble(log(*static_cast(a))); + } + TLAdoubleHandle tl_log10(TLAdoubleHandle a) + { + return new adtl::adouble(log10(*static_cast(a))); + } + TLAdoubleHandle tl_sin(TLAdoubleHandle a) + { + return new adtl::adouble(sin(*static_cast(a))); + } + TLAdoubleHandle tl_cos(TLAdoubleHandle a) + { + return new adtl::adouble(cos(*static_cast(a))); + } + TLAdoubleHandle tl_tan(TLAdoubleHandle a) + { + return new adtl::adouble(tan(*static_cast(a))); + } + TLAdoubleHandle tl_exp(TLAdoubleHandle a) + { + return new adtl::adouble(exp(*static_cast(a))); + } + TLAdoubleHandle tl_asin(TLAdoubleHandle a) + { + return new adtl::adouble(asin(*static_cast(a))); + } + TLAdoubleHandle tl_acos(TLAdoubleHandle a) + { + return new adtl::adouble(acos(*static_cast(a))); + } + TLAdoubleHandle tl_atan(TLAdoubleHandle a) + { + return new adtl::adouble(atan(*static_cast(a))); + } + TLAdoubleHandle tl_sinh(TLAdoubleHandle a) + { + return new adtl::adouble(sinh(*static_cast(a))); + } + TLAdoubleHandle tl_cosh(TLAdoubleHandle a) + { + return new adtl::adouble(cosh(*static_cast(a))); + } + TLAdoubleHandle tl_tanh(TLAdoubleHandle a) + { + return new adtl::adouble(tanh(*static_cast(a))); + } + TLAdoubleHandle tl_asinh(TLAdoubleHandle a) + { + return new adtl::adouble(asinh(*static_cast(a))); + } + TLAdoubleHandle tl_acosh(TLAdoubleHandle a) + { + return new adtl::adouble(acosh(*static_cast(a))); + } + TLAdoubleHandle tl_atanh(TLAdoubleHandle a) + { + return new adtl::adouble(atanh(*static_cast(a))); + } + TLAdoubleHandle tl_ceil(TLAdoubleHandle a) + { + return new adtl::adouble(ceil(*static_cast(a))); + } + TLAdoubleHandle tl_floor(TLAdoubleHandle a) + { + return new adtl::adouble(floor(*static_cast(a))); + } + TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, int n) + { + return new adtl::adouble(ldexp(*static_cast(a), n)); + } + TLAdoubleHandle tl_erf(TLAdoubleHandle a) + { + return new adtl::adouble(erf(*static_cast(a))); + } +} diff --git a/ADOL-C/c_interface/ADOLC_TL_interface.h b/ADOL-C/c_interface/ADOLC_TL_interface.h new file mode 100644 index 00000000..f82609a8 --- /dev/null +++ b/ADOL-C/c_interface/ADOLC_TL_interface.h @@ -0,0 +1,129 @@ +#ifdef ADOLC_TL_INTERFACE_H +#define ADOLC_TL_INTERFACE_H + +#ifdef __cplusplus +extern "C" +{ +#endif + // Used to handle Tape-based adouble as void* + typedef void *TLAdoubleHandle; +#ifdef __cplusplus +} +#endif + +/* +Constructor & Destructor for class tape-less adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + // Constructor + TLAdoubleHandle create_tl_adouble(double x); + TLAdoubleHandle create_tl_adouble_with_ad(const double val, const double *ad_val); + TLAdoubleHandle create_tl_adouble_empty(); + + // Destructor + void free_tl_adouble(TLAdoubleHandle a); +#ifdef __cplusplus +} +#endif + +/* +Utilities for adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + void set_num_dir(const size_t n); + void set_tl_value(TLAdoubleHandle a, const double val); + void set_tl_ad_value(TLAdoubleHandle a, const double *const val); + void set_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos, const double val); + double get_tl_value(TLAdoubleHandle a); + const double *get_tl_ad_values(TLAdoubleHandle a); + double get_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos); +#ifdef __cplusplus +} +#endif + +/* +Arithmetics for class tl adouble +*/ +#ifdef __cplusplus +extern "C" +{ +#endif + TLAdoubleHandle add_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle add_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle mult_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle mult_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle subtr_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle subtr_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle div_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle div_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle max_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle max_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle min_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle min_double_tl_adouble(double x, TLAdoubleHandle b); + TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle pow_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, double x); + + bool ge_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool ge_double_tl_adouble(double x, TLAdoubleHandle b); + bool ge_tl_adouble_double(TLAdoubleHandle a, double x); + + bool g_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool g_double_tl_adouble(double x, TLAdoubleHandle b); + bool g_tl_adouble_double(TLAdoubleHandle a, double x); + + bool le_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool le_double_tl_adouble(double x, TLAdoubleHandle b); + bool le_tl_adouble_double(TLAdoubleHandle a, double x); + + bool l_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool l_double_tl_adouble(double x, TLAdoubleHandle b); + bool l_tl_adouble_double(TLAdoubleHandle a, double x); + + bool eq_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); + bool eq_double_tl_adouble(double x, TLAdoubleHandle b); + bool eq_tl_adouble_double(TLAdoubleHandle a, double x); + + TLAdoubleHandle tl_abs(TLAdoubleHandle a); + TLAdoubleHandle tl_sqrt(TLAdoubleHandle a); + TLAdoubleHandle tl_log(TLAdoubleHandle a); + TLAdoubleHandle tl_log10(TLAdoubleHandle a); + TLAdoubleHandle tl_sin(TLAdoubleHandle a); + TLAdoubleHandle tl_cos(TLAdoubleHandle a); + TLAdoubleHandle tl_tan(TLAdoubleHandle a); + TLAdoubleHandle tl_exp(TLAdoubleHandle a); + TLAdoubleHandle tl_asin(TLAdoubleHandle a); + TLAdoubleHandle tl_acos(TLAdoubleHandle a); + TLAdoubleHandle tl_atan(TLAdoubleHandle a); + TLAdoubleHandle tl_sinh(TLAdoubleHandle a); + TLAdoubleHandle tl_cosh(TLAdoubleHandle a); + TLAdoubleHandle tl_tanh(TLAdoubleHandle a); + TLAdoubleHandle tl_asinh(TLAdoubleHandle a); + TLAdoubleHandle tl_acosh(TLAdoubleHandle a); + TLAdoubleHandle tl_atanh(TLAdoubleHandle a); + TLAdoubleHandle tl_ceil(TLAdoubleHandle a); + TLAdoubleHandle tl_floor(TLAdoubleHandle a); + TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, int n); + TLAdoubleHandle tl_erf(TLAdoubleHandle a); +#ifdef __cplusplus +} +#endif + +#endif // ADOLC_TL_INTERFACE_H \ No newline at end of file From 4351bb02e5461076ef8acd2bbe4af9b32df5d07a Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Fri, 27 Sep 2024 15:26:11 +0200 Subject: [PATCH 11/28] rm interface option --- CMakeLists.txt | 7 ------- 1 file changed, 7 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 72799c27..b17c307b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -63,10 +63,3 @@ install(EXPORT adolcTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/adolc) -# build the ADOL-C C Interface -# ---------------------------- - -option(CINTERFACE "if ON, the c interface is built" OFF) -if(CINTERFACE) - add_subdirectory(ADOL-C/c_interface) -endif() \ No newline at end of file From ab6c401dfa5d56ad7997646d6700b53b875f9003 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Fri, 27 Sep 2024 15:26:37 +0200 Subject: [PATCH 12/28] rename files --- ADOL-C/c_interface/ADOLC_TB_interface.cpp | 2 +- ADOL-C/c_interface/ADOLC_TL_interface.cpp | 2 +- ADOL-C/c_interface/ADOLC_TL_interface.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ADOL-C/c_interface/ADOLC_TB_interface.cpp b/ADOL-C/c_interface/ADOLC_TB_interface.cpp index a43ee394..d0b47252 100644 --- a/ADOL-C/c_interface/ADOLC_TB_interface.cpp +++ b/ADOL-C/c_interface/ADOLC_TB_interface.cpp @@ -1,5 +1,5 @@ #include -#include "ADOLCTBInterface.h" +#include "ADOLC_TB_Interface.h" /* Constructor & Destructor for class tape-based adouble diff --git a/ADOL-C/c_interface/ADOLC_TL_interface.cpp b/ADOL-C/c_interface/ADOLC_TL_interface.cpp index 14258d9d..7a08d62a 100644 --- a/ADOL-C/c_interface/ADOLC_TL_interface.cpp +++ b/ADOL-C/c_interface/ADOLC_TL_interface.cpp @@ -1,5 +1,5 @@ #include -#include "ADOLCTLInterface.h" +#include "ADOLC_TL_interface.h" /* Constructor & Destructor for class tape-less adouble diff --git a/ADOL-C/c_interface/ADOLC_TL_interface.h b/ADOL-C/c_interface/ADOLC_TL_interface.h index f82609a8..386cc62a 100644 --- a/ADOL-C/c_interface/ADOLC_TL_interface.h +++ b/ADOL-C/c_interface/ADOLC_TL_interface.h @@ -1,4 +1,4 @@ -#ifdef ADOLC_TL_INTERFACE_H +#ifndef ADOLC_TL_INTERFACE_H #define ADOLC_TL_INTERFACE_H #ifdef __cplusplus From 267189841c5999d9f9bc3180a73fd4cfc4ed8515 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Fri, 27 Sep 2024 15:27:09 +0200 Subject: [PATCH 13/28] add interface for forward and reverse drivers --- ADOL-C/c_interface/driver_interface.cpp | 168 ++++++++++++++++++++++++ ADOL-C/c_interface/driver_interface.h | 158 ++++++++++++++++++++++ 2 files changed, 326 insertions(+) create mode 100644 ADOL-C/c_interface/driver_interface.cpp create mode 100644 ADOL-C/c_interface/driver_interface.h diff --git a/ADOL-C/c_interface/driver_interface.cpp b/ADOL-C/c_interface/driver_interface.cpp new file mode 100644 index 00000000..9512bcc7 --- /dev/null +++ b/ADOL-C/c_interface/driver_interface.cpp @@ -0,0 +1,168 @@ +#include +#include "driver_interface.h" +/* +This file generates an interface to the overloaded forward and reverse mode calls. +*/ + +int forward1(short tag, + int m, + int n, + int d, + int keep, + double **X, + double **Y) +{ + return forward(tag, m, n, d, keep, X, Y); +} +int forward2(short tag, + int m, + int n, + int d, + int keep, + double **X, + double *Y) +{ + return forward(tag, m, n, d, keep, X, Y); +} +int forward3(short tag, + int m, + int n, + int d, + int keep, + double *X, + double *Y) +{ + return forward(tag, m, n, d, keep, X, Y); +} +int forward4(short tag, + int m, + int n, + int keep, + double *X, + double *Y) +{ + return forward(tag, m, n, keep, X, Y); +} +int forward5(short tag, + int m, + int n, + int d, + int p, + double *x, + double ***X, + double *y, + double ***Y) +{ + return forward(tag, m, n, d, p, x, X, y, Y); +} + +int forward6(short tag, + int m, + int n, + int p, + double *x, + double **X, + double *y, + double **Y) +{ + return forward(tag, m, n, p, x, X, y, Y); +} +int reverse1(short tag, + int m, + int n, + int d, + double *u, + double **Z) +{ + return reverse(tag, m, n, d, u, Z); +} +int reverse2(short tag, + int m, + int n, + int d, + double u, + double **Z) +{ + return reverse(tag, m, n, d, u, Z); +} +int reverse3(short tag, + int m, + int n, + int d, + double *u, + double *Z) +{ + return reverse(tag, m, n, d, u, Z); +} +int reverse4(short tag, + int m, + int n, + int d, + double u, + double *Z) +{ + return reverse(tag, m, n, d, u, Z); +} +int reverse5(short tag, + int m, + int n, + int d, + int q, + double **U, + double ***Z, + short **nz) +{ + return reverse(tag, m, n, d, q, U, Z, nz); +} +int reverse6(short tag, + int m, + int n, + int d, + int q, + double *U, + double ***Z, + short **nz) +{ + return reverse(tag, m, n, d, q, U, Z, nz); +} + +int reverse7(short tag, + int m, + int n, + int d, + int q, + double **U, + double **Z) +{ + return reverse(tag, m, n, d, q, U, Z); +} + +int reverse8(short tag, + int m, + int n, + int q, + double **U, + double **Z) +{ + return reverse(tag, m, n, q, U, Z); +} +int reverse9(short tag, + int m, + int n, + int d, + int q, + double *U, + double **Z) +{ + return reverse(tag, m, n, d, q, U, Z); +} + +int reverse10(short tag, + int m, + int n, + int d, + double ***Z, + short **nz) +{ + return reverse(tag, m, n, d, Z, nz); +} diff --git a/ADOL-C/c_interface/driver_interface.h b/ADOL-C/c_interface/driver_interface.h new file mode 100644 index 00000000..b7f5bc33 --- /dev/null +++ b/ADOL-C/c_interface/driver_interface.h @@ -0,0 +1,158 @@ +/* +This file generates an interface to the overloaded forward and reverse mode calls. +*/ + +#ifndef DRIVER_INTERFACE_H +#define DRIVER_INTERFACE_H + +#ifdef __cplusplus +extern "C" +{ +#endif + /* forward(tag, m, n, d, keep, X[n][d+1], Y[m][d+1]) */ + int forward1(short tag, + int m, + int n, + int d, + int keep, + double **X, + double **Y); + + /* forward(tag, m, n, d, keep, X[n][d+1], Y[d+1]) : hos || fos || zos */ + int forward2(short tag, + int m, + int n, + int d, + int keep, + double **X, + double *Y); + + /* forward(tag, m, n, d, keep, X[n], Y[m]) : zos */ + int forward3(short tag, + int m, + int n, + int d, + int keep, + double *X, + double *Y); + + /* forward(tag, m, n, keep, X[n], Y[m]) : zos */ + int forward4(short tag, + int m, + int n, + int keep, + double *X, + double *Y); + + /* forward(tag, m, n, d, p, x[n], X[n][p][d], y[m], Y[m][p][d]) : hov */ + int forward5(short tag, + int m, + int n, + int d, + int p, + double *x, + double ***X, + double *y, + double ***Y); + + /* forward(tag, m, n, p, x[n], X[n][p], y[m], Y[m][p]) : fov */ + int forward6(short tag, + int m, + int n, + int p, + double *x, + double **X, + double *y, + double **Y); + + /* reverse(tag, m, n, d, u[m], Z[n][d + 1]) */ + int reverse1(short tag, + int m, + int n, + int d, + double *u, + double **Z); + + /* reverse(tag, 1, n, 0, u, Z[n][d+1]), m=1 => u scalar */ + int reverse2(short tag, + int m, + int n, + int d, + double u, + double **Z); + + /* reverse(tag, m, n, 0, u[m], Z[n]), d=0 */ + int reverse3(short tag, + int m, + int n, + int d, + double *u, + double *Z); + + /* reverse(tag, 1, n, 0, u, Z[n]), m=1 and d=0 => u and Z scalars */ + int reverse4(short tag, + int m, + int n, + int d, + double u, + double *Z); + + /* reverse(tag, m, n, d, q, U[q][m], Z[q][n][d+1], nz[q][n]) */ + int reverse5(short tag, + int m, + int n, + int d, + int q, + double **U, + double ***Z, + short **nz); + + /* reverse(tag, m, n, d, q, U[q], Z[q][n][d+1], nz[q][n]) : hov */ + int reverse6(short tag, + int m, + int n, + int d, + int q, + double *U, + double ***Z, + short **nz); + + /* reverse(tag, 1, n, d, q, U[q], Z[q][n][d+1], nz[q][n]), m=1 => u vector */ + int reverse7(short tag, + int m, + int n, + int d, + int q, + double **U, + double **Z); + + /* reverse(tag, m, n, q, U[q][m], Z[q][n]) */ + int reverse8(short tag, + int m, + int n, + int q, + double **U, + double **Z); + + /* reverse(tag, m, n, d, q, U[q], Z[q][n]) */ + int reverse9(short tag, + int m, + int n, + int d, + int q, + double *U, + double **Z); + + /* reverse(tag, m, n, d, Z[q][n][d+1], nz[q][n]) : hov */ + int reverse10(short tag, + int m, + int n, + int d, + double ***Z, + short **nz); + +#ifdef __cplusplus +} +#endif + +#endif // DRIVER_INTERFACE_H \ No newline at end of file From 6bf3e89413dbb160aa9f49bbd76485f8cf36e8fa Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Thu, 10 Oct 2024 07:17:36 +0200 Subject: [PATCH 14/28] update cmake --- ADOL-C/c_interface/ADOLCTBInterface.cpp | 313 ------------------------ ADOL-C/c_interface/ADOLCTBInterface.h | 142 ----------- ADOL-C/c_interface/ADOLCTLInterface.cpp | 297 ---------------------- ADOL-C/c_interface/ADOLCTLInterface.h | 129 ---------- ADOL-C/c_interface/CMakeLists.txt | 7 +- 5 files changed, 3 insertions(+), 885 deletions(-) delete mode 100644 ADOL-C/c_interface/ADOLCTBInterface.cpp delete mode 100644 ADOL-C/c_interface/ADOLCTBInterface.h delete mode 100644 ADOL-C/c_interface/ADOLCTLInterface.cpp delete mode 100644 ADOL-C/c_interface/ADOLCTLInterface.h diff --git a/ADOL-C/c_interface/ADOLCTBInterface.cpp b/ADOL-C/c_interface/ADOLCTBInterface.cpp deleted file mode 100644 index a43ee394..00000000 --- a/ADOL-C/c_interface/ADOLCTBInterface.cpp +++ /dev/null @@ -1,313 +0,0 @@ -#include -#include "ADOLCTBInterface.h" - -/* -Constructor & Destructor for class tape-based adouble -*/ -extern "C" -{ - // Constructor - TBAdoubleHandle create_tb_adouble(double x) - { - return new adouble(x); - } - TBAdoubleHandle create_tb_adouble_empty() - { - return new adouble(); - } - - // Destructor - void free_tb_adouble(TBAdoubleHandle a) - { - return delete static_cast(a); - } -} - -/* -Utilities for adouble -*/ -extern "C" -{ - double get_tb_value(TBAdoubleHandle a) - { - return static_cast(a)->getValue(); - } -} - -/* -Arithmetics for class adouble -*/ -extern "C" -{ - TBAdoubleHandle add_tb_adouble(const TBAdoubleHandle a, const TBAdoubleHandle b) - { - return new adouble(*static_cast(a) + *static_cast(b)); - } - TBAdoubleHandle add_double_tb_adouble(double x, TBAdoubleHandle b) - { - return new adouble(x + *static_cast(b)); - } - TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, double x) - { - return new adouble(*static_cast(a) + x); - } - TBAdoubleHandle mult_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return new adouble(*static_cast(a) * *static_cast(b)); - } - TBAdoubleHandle mult_double_tb_adouble(double x, TBAdoubleHandle b) - { - return new adouble(x * *static_cast(b)); - } - TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, double x) - { - return new adouble(*static_cast(a) * x); - } - TBAdoubleHandle subtr_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return new adouble(*static_cast(a) - *static_cast(b)); - } - TBAdoubleHandle subtr_double_tb_adouble(double x, TBAdoubleHandle b) - { - return new adouble(x - *static_cast(b)); - } - TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, double x) - { - return new adouble(*static_cast(a) - x); - } - TBAdoubleHandle div_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return new adouble(*static_cast(a) / *static_cast(b)); - } - TBAdoubleHandle div_double_tb_adouble(double x, TBAdoubleHandle b) - { - return new adouble(x / *static_cast(b)); - } - TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, double x) - { - return new adouble(*static_cast(a) / x); - } - TBAdoubleHandle max_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return new adouble(fmax(*static_cast(a), *static_cast(b))); - } - TBAdoubleHandle max_double_tb_adouble(double x, TBAdoubleHandle b) - { - return new adouble(fmax(x, *static_cast(b))); - } - TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, double x) - { - return new adouble(fmax(*static_cast(a), x)); - } - TBAdoubleHandle min_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return new adouble(fmin(*static_cast(a), *static_cast(b))); - } - TBAdoubleHandle min_double_tb_adouble(double x, TBAdoubleHandle b) - { - return new adouble(fmin(x, *static_cast(b))); - } - TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, double x) - { - return new adouble(fmin(*static_cast(a), x)); - } - TBAdoubleHandle pow_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return new adouble(pow(*static_cast(a), *static_cast(b))); - } - TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, double x) - { - return new adouble(pow(*static_cast(a), x)); - } - bool ge_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return *static_cast(a) >= *static_cast(b); - } - bool ge_double_tb_adouble(double x, TBAdoubleHandle b) - { - return x >= *static_cast(b); - } - bool ge_tb_adouble_double(TBAdoubleHandle a, double x) - { - return *static_cast(a) >= x; - } - bool g_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return *static_cast(a) > *static_cast(b); - } - bool g_double_tb_adouble(double x, TBAdoubleHandle b) - { - return x > *static_cast(b); - } - bool g_tb_adouble_double(TBAdoubleHandle a, double x) - { - return *static_cast(a) > x; - } - bool le_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return *static_cast(a) <= *static_cast(b); - } - bool le_double_tb_adouble(double x, TBAdoubleHandle b) - { - return x <= *static_cast(b); - } - bool le_tb_adouble_double(TBAdoubleHandle a, double x) - { - return *static_cast(a) <= x; - } - bool l_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return *static_cast(a) < *static_cast(b); - } - bool l_double_tb_adouble(double x, TBAdoubleHandle b) - { - return x < *static_cast(b); - } - bool l_tb_adouble_double(TBAdoubleHandle a, double x) - { - return *static_cast(a) < x; - } - bool eq_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b) - { - return *static_cast(a) == *static_cast(b); - } - bool eq_double_tb_adouble(double x, TBAdoubleHandle b) - { - return x == *static_cast(b); - } - bool eq_tb_adouble_double(TBAdoubleHandle a, double x) - { - return *static_cast(a) == x; - } - TBAdoubleHandle tb_abs(TBAdoubleHandle a) - { - return new adouble(fabs(*static_cast(a))); - } - TBAdoubleHandle tb_sqrt(TBAdoubleHandle a) - { - return new adouble(sqrt(*static_cast(a))); - } - TBAdoubleHandle tb_log(TBAdoubleHandle a) - { - return new adouble(log(*static_cast(a))); - } - TBAdoubleHandle tb_log10(TBAdoubleHandle a) - { - return new adouble(log10(*static_cast(a))); - } - TBAdoubleHandle tb_sin(TBAdoubleHandle a) - { - return new adouble(sin(*static_cast(a))); - } - TBAdoubleHandle tb_cos(TBAdoubleHandle a) - { - return new adouble(cos(*static_cast(a))); - } - TBAdoubleHandle tb_tan(TBAdoubleHandle a) - { - return new adouble(tan(*static_cast(a))); - } - TBAdoubleHandle tb_exp(TBAdoubleHandle a) - { - return new adouble(exp(*static_cast(a))); - } - TBAdoubleHandle tb_asin(TBAdoubleHandle a) - { - return new adouble(asin(*static_cast(a))); - } - TBAdoubleHandle tb_acos(TBAdoubleHandle a) - { - return new adouble(acos(*static_cast(a))); - } - TBAdoubleHandle tb_atan(TBAdoubleHandle a) - { - return new adouble(atan(*static_cast(a))); - } - TBAdoubleHandle tb_sinh(TBAdoubleHandle a) - { - return new adouble(sinh(*static_cast(a))); - } - TBAdoubleHandle tb_cosh(TBAdoubleHandle a) - { - return new adouble(cosh(*static_cast(a))); - } - TBAdoubleHandle tb_tanh(TBAdoubleHandle a) - { - return new adouble(tanh(*static_cast(a))); - } - TBAdoubleHandle tb_asinh(TBAdoubleHandle a) - { - return new adouble(asinh(*static_cast(a))); - } - TBAdoubleHandle tb_acosh(TBAdoubleHandle a) - { - return new adouble(acosh(*static_cast(a))); - } - TBAdoubleHandle tb_atanh(TBAdoubleHandle a) - { - return new adouble(atanh(*static_cast(a))); - } - TBAdoubleHandle tb_ceil(TBAdoubleHandle a) - { - return new adouble(ceil(*static_cast(a))); - } - TBAdoubleHandle tb_floor(TBAdoubleHandle a) - { - return new adouble(floor(*static_cast(a))); - } - TBAdoubleHandle tb_ldexp(TBAdoubleHandle a, int n) - { - return new adouble(ldexp(*static_cast(a), n)); - } - TBAdoubleHandle tb_erf(TBAdoubleHandle a) - { - return new adouble(erf(*static_cast(a))); - } -} - -/* -Tape utilities -*/ -extern "C" -{ - int c_trace_on(short int tag, int keep) - { - return trace_on(tag, keep); - } - void c_trace_off(int flag) - { - return trace_off(flag); - } - void create_independent(TBAdoubleHandle a, double x) - { - *static_cast(a) <<= x; - } - void create_dependent(TBAdoubleHandle a, double *y) - { - *static_cast(a) >>= *y; - } - size_t num_independent(short tape_id) - { - size_t y[STAT_SIZE]; - tapestats(tape_id, y); - return y[NUM_INDEPENDENTS]; - } - size_t num_dependent(short tape_id) - { - size_t y[STAT_SIZE]; - tapestats(tape_id, y); - return y[NUM_DEPENDENTS]; - } - void enable_min_max_using_abs() - { - return enableMinMaxUsingAbs(); - } - void disable_min_max_using_abs() - { - return disableMinMaxUsingAbs(); - } - TBAdoubleHandle mkparam_(const double val) - { - return new adouble(mkparam(val)); - } -} diff --git a/ADOL-C/c_interface/ADOLCTBInterface.h b/ADOL-C/c_interface/ADOLCTBInterface.h deleted file mode 100644 index df889959..00000000 --- a/ADOL-C/c_interface/ADOLCTBInterface.h +++ /dev/null @@ -1,142 +0,0 @@ -#ifndef ADOLC_TB_INTERFACE_H -#define ADOLC_TB_INTERFACE_H - -#ifdef __cplusplus -extern "C" -{ -#endif - // Used to handle Tape-based adouble as void* - typedef void *TBAdoubleHandle; -#ifdef __cplusplus -} -#endif - -/* -Constructor & Destructor for class adouble -*/ -#ifdef __cplusplus -extern "C" -{ -#endif - // Constructor - TBAdoubleHandle create_tb_adouble(double x); - TBAdoubleHandle create_tb_adouble_empty(); - - // Destructor - void free_tb_adouble(TBAdoubleHandle a); -#ifdef __cplusplus -} -#endif - -/* -Utilities for adouble -*/ -#ifdef __cplusplus -extern "C" -{ -#endif - double get_tb_value(TBAdoubleHandle a); -#ifdef __cplusplus -} -#endif - -/* -Arithmetics for class tb adouble -*/ -#ifdef __cplusplus -extern "C" -{ -#endif - TBAdoubleHandle add_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle add_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, double x); - - TBAdoubleHandle mult_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle mult_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, double x); - - TBAdoubleHandle subtr_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle subtr_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, double x); - - TBAdoubleHandle div_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle div_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, double x); - - TBAdoubleHandle max_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle max_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, double x); - - TBAdoubleHandle min_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle min_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, double x); - - TBAdoubleHandle pow_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, double x); - - bool ge_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool ge_double_tb_adouble(double x, TBAdoubleHandle b); - bool ge_tb_adouble_double(TBAdoubleHandle a, double x); - - bool g_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool g_double_tb_adouble(double x, TBAdoubleHandle b); - bool g_tb_adouble_double(TBAdoubleHandle a, double x); - - bool le_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool le_double_tb_adouble(double x, TBAdoubleHandle b); - bool le_tb_adouble_double(TBAdoubleHandle a, double x); - - bool l_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool l_double_tb_adouble(double x, TBAdoubleHandle b); - bool l_tb_adouble_double(TBAdoubleHandle a, double x); - - bool eq_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool eq_double_tb_adouble(double x, TBAdoubleHandle b); - bool eq_tb_adouble_double(TBAdoubleHandle a, double x); - - TBAdoubleHandle tb_abs(TBAdoubleHandle a); - TBAdoubleHandle tb_sqrt(TBAdoubleHandle a); - TBAdoubleHandle tb_log(TBAdoubleHandle a); - TBAdoubleHandle tb_log10(TBAdoubleHandle a); - TBAdoubleHandle tb_sin(TBAdoubleHandle a); - TBAdoubleHandle tb_cos(TBAdoubleHandle a); - TBAdoubleHandle tb_tan(TBAdoubleHandle a); - TBAdoubleHandle tb_exp(TBAdoubleHandle a); - TBAdoubleHandle tb_asin(TBAdoubleHandle a); - TBAdoubleHandle tb_acos(TBAdoubleHandle a); - TBAdoubleHandle tb_atan(TBAdoubleHandle a); - TBAdoubleHandle tb_sinh(TBAdoubleHandle a); - TBAdoubleHandle tb_cosh(TBAdoubleHandle a); - TBAdoubleHandle tb_tanh(TBAdoubleHandle a); - TBAdoubleHandle tb_asinh(TBAdoubleHandle a); - TBAdoubleHandle tb_acosh(TBAdoubleHandle a); - TBAdoubleHandle tb_atanh(TBAdoubleHandle a); - TBAdoubleHandle tb_ceil(TBAdoubleHandle a); - TBAdoubleHandle tb_floor(TBAdoubleHandle a); - TBAdoubleHandle tb_ldexp(TBAdoubleHandle a, int n); - TBAdoubleHandle tb_erf(TBAdoubleHandle a); -#ifdef __cplusplus -} -#endif - -/* -Tape utilities -*/ -#ifdef __cplusplus -extern "C" -{ -#endif - int c_trace_on(short int tag, int keep = 0); - void c_trace_off(int flag = 0); - void create_independent(TBAdoubleHandle a, double x); - void create_dependent(TBAdoubleHandle a, double *y); - size_t num_independent(short tape_id); - size_t num_dependent(short tape_id); - void enable_min_max_using_abs(); - void disable_min_max_using_abs(); - TBAdoubleHandle mkparam_(const double val); -#ifdef __cplusplus -} -#endif - -#endif // ADOLC_TB_INTERFACE_H \ No newline at end of file diff --git a/ADOL-C/c_interface/ADOLCTLInterface.cpp b/ADOL-C/c_interface/ADOLCTLInterface.cpp deleted file mode 100644 index 14258d9d..00000000 --- a/ADOL-C/c_interface/ADOLCTLInterface.cpp +++ /dev/null @@ -1,297 +0,0 @@ -#include -#include "ADOLCTLInterface.h" - -/* -Constructor & Destructor for class tape-less adouble -*/ -extern "C" -{ - // Constructor - TLAdoubleHandle create_tl_adouble(const double x) - { - return new adtl::adouble(x); - } - TLAdoubleHandle create_tl_adouble_empty() - { - return new adtl::adouble(); - } - TLAdoubleHandle create_tl_adouble_with_ad(const double val, const double *ad_val) - { - return new adtl::adouble(val, ad_val); - } - // Destructor - void free_tl_adouble(TLAdoubleHandle a) - { - return delete static_cast(a); - } -} - -/* -Utilities for adouble -*/ -extern "C" -{ - void set_num_dir(const size_t n) - { - return adtl::setNumDir(n); - } - - void set_tl_value(TLAdoubleHandle a, const double val) - { - return static_cast(a)->setValue(val); - } - - void set_tl_ad_value(TLAdoubleHandle a, const double *const val) - { - return static_cast(a)->setADValue(val); - } - - void set_tl_ad_value_idx(TLAdoubleHandle a, size_t pos, const double val) - { - return static_cast(a)->setADValue(pos, val); - } - - double get_tl_value(TLAdoubleHandle a) - { - return static_cast(a)->getValue(); - } - const double *get_tl_ad_values(TLAdoubleHandle a) - { - return (static_cast(a))->getADValue(); - } - double get_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos) - { - return static_cast(a)->getADValue(pos); - } -} - -/* -Arithmetics for class adouble -*/ -extern "C" -{ - TLAdoubleHandle add_tl_adouble(const TLAdoubleHandle a, const TLAdoubleHandle b) - { - return new adtl::adouble(*static_cast(a) + *static_cast(b)); - } - TLAdoubleHandle add_double_tl_adouble(double x, TLAdoubleHandle b) - { - return new adtl::adouble(x + *static_cast(b)); - } - TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, double x) - { - return new adtl::adouble(*static_cast(a) + x); - } - TLAdoubleHandle mult_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return new adtl::adouble(*static_cast(a) * *static_cast(b)); - } - TLAdoubleHandle mult_double_tl_adouble(double x, TLAdoubleHandle b) - { - return new adtl::adouble(x * *static_cast(b)); - } - TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, double x) - { - return new adtl::adouble(*static_cast(a) * x); - } - TLAdoubleHandle subtr_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return new adtl::adouble(*static_cast(a) - *static_cast(b)); - } - TLAdoubleHandle subtr_double_tl_adouble(double x, TLAdoubleHandle b) - { - return new adtl::adouble(x - *static_cast(b)); - } - TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, double x) - { - return new adtl::adouble(*static_cast(a) - x); - } - TLAdoubleHandle div_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return new adtl::adouble(*static_cast(a) / *static_cast(b)); - } - TLAdoubleHandle div_double_tl_adouble(double x, TLAdoubleHandle b) - { - return new adtl::adouble(x / *static_cast(b)); - } - TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, double x) - { - return new adtl::adouble(*static_cast(a) / x); - } - TLAdoubleHandle max_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return new adtl::adouble(fmax(*static_cast(a), *static_cast(b))); - } - TLAdoubleHandle max_double_tl_adouble(double x, TLAdoubleHandle b) - { - return new adtl::adouble(fmax(x, *static_cast(b))); - } - TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, double x) - { - return new adtl::adouble(fmax(*static_cast(a), x)); - } - TLAdoubleHandle min_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return new adtl::adouble(fmin(*static_cast(a), *static_cast(b))); - } - TLAdoubleHandle min_double_tl_adouble(double x, TLAdoubleHandle b) - { - return new adtl::adouble(fmin(x, *static_cast(b))); - } - TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, double x) - { - return new adtl::adouble(fmin(*static_cast(a), x)); - } - TLAdoubleHandle pow_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return new adtl::adouble(pow(*static_cast(a), *static_cast(b))); - } - TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, double x) - { - return new adtl::adouble(pow(*static_cast(a), x)); - } - bool ge_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return *static_cast(a) >= *static_cast(b); - } - bool ge_double_tl_adouble(double x, TLAdoubleHandle b) - { - return x >= *static_cast(b); - } - bool ge_tl_adouble_double(TLAdoubleHandle a, double x) - { - return *static_cast(a) >= x; - } - bool g_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return *static_cast(a) > *static_cast(b); - } - bool g_double_tl_adouble(double x, TLAdoubleHandle b) - { - return x > *static_cast(b); - } - bool g_tl_adouble_double(TLAdoubleHandle a, double x) - { - return *static_cast(a) > x; - } - bool le_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return *static_cast(a) <= *static_cast(b); - } - bool le_double_tl_adouble(double x, TLAdoubleHandle b) - { - return x <= *static_cast(b); - } - bool le_tl_adouble_double(TLAdoubleHandle a, double x) - { - return *static_cast(a) <= x; - } - bool l_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return *static_cast(a) < *static_cast(b); - } - bool l_double_tl_adouble(double x, TLAdoubleHandle b) - { - return x < *static_cast(b); - } - bool l_tl_adouble_double(TLAdoubleHandle a, double x) - { - return *static_cast(a) < x; - } - bool eq_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) - { - return *static_cast(a) == *static_cast(b); - } - bool eq_double_tl_adouble(double x, TLAdoubleHandle b) - { - return x == *static_cast(b); - } - bool eq_tl_adouble_double(TLAdoubleHandle a, double x) - { - return *static_cast(a) == x; - } - TLAdoubleHandle tl_abs(TLAdoubleHandle a) - { - return new adtl::adouble(fabs(*static_cast(a))); - } - TLAdoubleHandle tl_sqrt(TLAdoubleHandle a) - { - return new adtl::adouble(sqrt(*static_cast(a))); - } - TLAdoubleHandle tl_log(TLAdoubleHandle a) - { - return new adtl::adouble(log(*static_cast(a))); - } - TLAdoubleHandle tl_log10(TLAdoubleHandle a) - { - return new adtl::adouble(log10(*static_cast(a))); - } - TLAdoubleHandle tl_sin(TLAdoubleHandle a) - { - return new adtl::adouble(sin(*static_cast(a))); - } - TLAdoubleHandle tl_cos(TLAdoubleHandle a) - { - return new adtl::adouble(cos(*static_cast(a))); - } - TLAdoubleHandle tl_tan(TLAdoubleHandle a) - { - return new adtl::adouble(tan(*static_cast(a))); - } - TLAdoubleHandle tl_exp(TLAdoubleHandle a) - { - return new adtl::adouble(exp(*static_cast(a))); - } - TLAdoubleHandle tl_asin(TLAdoubleHandle a) - { - return new adtl::adouble(asin(*static_cast(a))); - } - TLAdoubleHandle tl_acos(TLAdoubleHandle a) - { - return new adtl::adouble(acos(*static_cast(a))); - } - TLAdoubleHandle tl_atan(TLAdoubleHandle a) - { - return new adtl::adouble(atan(*static_cast(a))); - } - TLAdoubleHandle tl_sinh(TLAdoubleHandle a) - { - return new adtl::adouble(sinh(*static_cast(a))); - } - TLAdoubleHandle tl_cosh(TLAdoubleHandle a) - { - return new adtl::adouble(cosh(*static_cast(a))); - } - TLAdoubleHandle tl_tanh(TLAdoubleHandle a) - { - return new adtl::adouble(tanh(*static_cast(a))); - } - TLAdoubleHandle tl_asinh(TLAdoubleHandle a) - { - return new adtl::adouble(asinh(*static_cast(a))); - } - TLAdoubleHandle tl_acosh(TLAdoubleHandle a) - { - return new adtl::adouble(acosh(*static_cast(a))); - } - TLAdoubleHandle tl_atanh(TLAdoubleHandle a) - { - return new adtl::adouble(atanh(*static_cast(a))); - } - TLAdoubleHandle tl_ceil(TLAdoubleHandle a) - { - return new adtl::adouble(ceil(*static_cast(a))); - } - TLAdoubleHandle tl_floor(TLAdoubleHandle a) - { - return new adtl::adouble(floor(*static_cast(a))); - } - TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, int n) - { - return new adtl::adouble(ldexp(*static_cast(a), n)); - } - TLAdoubleHandle tl_erf(TLAdoubleHandle a) - { - return new adtl::adouble(erf(*static_cast(a))); - } -} diff --git a/ADOL-C/c_interface/ADOLCTLInterface.h b/ADOL-C/c_interface/ADOLCTLInterface.h deleted file mode 100644 index f82609a8..00000000 --- a/ADOL-C/c_interface/ADOLCTLInterface.h +++ /dev/null @@ -1,129 +0,0 @@ -#ifdef ADOLC_TL_INTERFACE_H -#define ADOLC_TL_INTERFACE_H - -#ifdef __cplusplus -extern "C" -{ -#endif - // Used to handle Tape-based adouble as void* - typedef void *TLAdoubleHandle; -#ifdef __cplusplus -} -#endif - -/* -Constructor & Destructor for class tape-less adouble -*/ -#ifdef __cplusplus -extern "C" -{ -#endif - // Constructor - TLAdoubleHandle create_tl_adouble(double x); - TLAdoubleHandle create_tl_adouble_with_ad(const double val, const double *ad_val); - TLAdoubleHandle create_tl_adouble_empty(); - - // Destructor - void free_tl_adouble(TLAdoubleHandle a); -#ifdef __cplusplus -} -#endif - -/* -Utilities for adouble -*/ -#ifdef __cplusplus -extern "C" -{ -#endif - void set_num_dir(const size_t n); - void set_tl_value(TLAdoubleHandle a, const double val); - void set_tl_ad_value(TLAdoubleHandle a, const double *const val); - void set_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos, const double val); - double get_tl_value(TLAdoubleHandle a); - const double *get_tl_ad_values(TLAdoubleHandle a); - double get_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos); -#ifdef __cplusplus -} -#endif - -/* -Arithmetics for class tl adouble -*/ -#ifdef __cplusplus -extern "C" -{ -#endif - TLAdoubleHandle add_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle add_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, double x); - - TLAdoubleHandle mult_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle mult_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, double x); - - TLAdoubleHandle subtr_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle subtr_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, double x); - - TLAdoubleHandle div_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle div_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, double x); - - TLAdoubleHandle max_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle max_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, double x); - - TLAdoubleHandle min_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle min_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, double x); - - TLAdoubleHandle pow_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, double x); - - bool ge_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool ge_double_tl_adouble(double x, TLAdoubleHandle b); - bool ge_tl_adouble_double(TLAdoubleHandle a, double x); - - bool g_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool g_double_tl_adouble(double x, TLAdoubleHandle b); - bool g_tl_adouble_double(TLAdoubleHandle a, double x); - - bool le_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool le_double_tl_adouble(double x, TLAdoubleHandle b); - bool le_tl_adouble_double(TLAdoubleHandle a, double x); - - bool l_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool l_double_tl_adouble(double x, TLAdoubleHandle b); - bool l_tl_adouble_double(TLAdoubleHandle a, double x); - - bool eq_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool eq_double_tl_adouble(double x, TLAdoubleHandle b); - bool eq_tl_adouble_double(TLAdoubleHandle a, double x); - - TLAdoubleHandle tl_abs(TLAdoubleHandle a); - TLAdoubleHandle tl_sqrt(TLAdoubleHandle a); - TLAdoubleHandle tl_log(TLAdoubleHandle a); - TLAdoubleHandle tl_log10(TLAdoubleHandle a); - TLAdoubleHandle tl_sin(TLAdoubleHandle a); - TLAdoubleHandle tl_cos(TLAdoubleHandle a); - TLAdoubleHandle tl_tan(TLAdoubleHandle a); - TLAdoubleHandle tl_exp(TLAdoubleHandle a); - TLAdoubleHandle tl_asin(TLAdoubleHandle a); - TLAdoubleHandle tl_acos(TLAdoubleHandle a); - TLAdoubleHandle tl_atan(TLAdoubleHandle a); - TLAdoubleHandle tl_sinh(TLAdoubleHandle a); - TLAdoubleHandle tl_cosh(TLAdoubleHandle a); - TLAdoubleHandle tl_tanh(TLAdoubleHandle a); - TLAdoubleHandle tl_asinh(TLAdoubleHandle a); - TLAdoubleHandle tl_acosh(TLAdoubleHandle a); - TLAdoubleHandle tl_atanh(TLAdoubleHandle a); - TLAdoubleHandle tl_ceil(TLAdoubleHandle a); - TLAdoubleHandle tl_floor(TLAdoubleHandle a); - TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, int n); - TLAdoubleHandle tl_erf(TLAdoubleHandle a); -#ifdef __cplusplus -} -#endif - -#endif // ADOLC_TL_INTERFACE_H \ No newline at end of file diff --git a/ADOL-C/c_interface/CMakeLists.txt b/ADOL-C/c_interface/CMakeLists.txt index 10d50d0a..0d142676 100644 --- a/ADOL-C/c_interface/CMakeLists.txt +++ b/ADOL-C/c_interface/CMakeLists.txt @@ -1,14 +1,13 @@ cmake_minimum_required(VERSION 3.27) -project(TestADOLC VERSION 1.0) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED True) add_library(ExternalADOLC SHARED IMPORTED) set_target_properties(ExternalADOLC PROPERTIES - IMPORTED_LOCATION "${CMAKE_SOURCE_DIR}/libadolc.dylib" - INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_SOURCE_DIR}/ADOL-C/include" + IMPORTED_LOCATION ${ADOLC_INSTALL_DIR}/lib/libadolc.dylib + INTERFACE_INCLUDE_DIRECTORIES ${ADOLC_INSTALL_DIR}/include ) -add_library(ADOLCInterface SHARED ADOLCTBInterface.cpp ADOLCTLInterface.cpp array_handler.cpp) +add_library(ADOLCInterface SHARED ADOLC_TB_interface.cpp ADOLC_TL_interface.cpp array_handler.cpp driver_interface.cpp) target_link_libraries(ADOLCInterface ExternalADOLC) From f8a5ebb5d7f6d3c661fe9fe6528dd693f394b3ab Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Thu, 10 Oct 2024 14:41:10 +0200 Subject: [PATCH 15/28] add rpath, fix typo, add option, clean cmake file --- ADOL-C/c_interface/ADOLC_TB_interface.cpp | 2 +- ADOL-C/c_interface/CMakeLists.txt | 12 +----------- CMakeLists.txt | 12 ++++++++++++ 3 files changed, 14 insertions(+), 12 deletions(-) diff --git a/ADOL-C/c_interface/ADOLC_TB_interface.cpp b/ADOL-C/c_interface/ADOLC_TB_interface.cpp index d0b47252..2d96209c 100644 --- a/ADOL-C/c_interface/ADOLC_TB_interface.cpp +++ b/ADOL-C/c_interface/ADOLC_TB_interface.cpp @@ -1,5 +1,5 @@ #include -#include "ADOLC_TB_Interface.h" +#include "ADOLC_TB_interface.h" /* Constructor & Destructor for class tape-based adouble diff --git a/ADOL-C/c_interface/CMakeLists.txt b/ADOL-C/c_interface/CMakeLists.txt index 0d142676..961b061c 100644 --- a/ADOL-C/c_interface/CMakeLists.txt +++ b/ADOL-C/c_interface/CMakeLists.txt @@ -1,13 +1,3 @@ -cmake_minimum_required(VERSION 3.27) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED True) - -add_library(ExternalADOLC SHARED IMPORTED) -set_target_properties(ExternalADOLC PROPERTIES - IMPORTED_LOCATION ${ADOLC_INSTALL_DIR}/lib/libadolc.dylib - INTERFACE_INCLUDE_DIRECTORIES ${ADOLC_INSTALL_DIR}/include -) add_library(ADOLCInterface SHARED ADOLC_TB_interface.cpp ADOLC_TL_interface.cpp array_handler.cpp driver_interface.cpp) -target_link_libraries(ADOLCInterface ExternalADOLC) - +target_link_libraries(ADOLCInterface adolc) diff --git a/CMakeLists.txt b/CMakeLists.txt index b17c307b..cc466f6e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,6 +6,7 @@ project(adol-c DESCRIPTION "A Package for Automatic Differentiation of Algorithms Written in C/C++" HOMEPAGE_URL "https://github.com/coin-or/ADOL-C") +set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") add_library(adolc SHARED) add_library(adolc::adolc ALIAS adolc) @@ -49,6 +50,11 @@ set(USE_BOOST_POOL "#undef USE_BOOST_POOL") add_subdirectory(ADOL-C) +option(BUILD_INTERFACE OFF) + +if(BUILD_INTERFACE) + add_subdirectory(ADOL-C/c_interface) +endif() # export the targets # ------------------ @@ -57,9 +63,15 @@ include(CMakePackageConfigHelpers) include(GNUInstallDirs) install(TARGETS adolc EXPORT adolcTargets) +install(TARGETS ADOLCInterface EXPORT ADOLCInterfaceTargets) install(EXPORT adolcTargets FILE adolc-targets.cmake NAMESPACE adolc:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/adolc) +install(EXPORT ADOLCInterfaceTargets + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/adolc) + + + From 009bf71c6de6242936445b8632847140914e59d7 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Thu, 10 Oct 2024 14:44:42 +0200 Subject: [PATCH 16/28] update structure of interface part --- CMakeLists.txt | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index cc466f6e..7dbb3ae5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,7 +6,7 @@ project(adol-c DESCRIPTION "A Package for Automatic Differentiation of Algorithms Written in C/C++" HOMEPAGE_URL "https://github.com/coin-or/ADOL-C") -set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") + add_library(adolc SHARED) add_library(adolc::adolc ALIAS adolc) @@ -50,9 +50,13 @@ set(USE_BOOST_POOL "#undef USE_BOOST_POOL") add_subdirectory(ADOL-C) -option(BUILD_INTERFACE OFF) +# include the c interface of adolc +# ---------------------------------------------------------------- +option(BUILD_INTERFACE OFF) if(BUILD_INTERFACE) + # set rpath for execution to the install location of adolc + set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") add_subdirectory(ADOL-C/c_interface) endif() From 44008593438124d2173b9d25216e3f86cb9586d7 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Thu, 10 Oct 2024 16:14:31 +0200 Subject: [PATCH 17/28] fix install --- CMakeLists.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 7dbb3ae5..21efce5c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -58,6 +58,9 @@ if(BUILD_INTERFACE) # set rpath for execution to the install location of adolc set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") add_subdirectory(ADOL-C/c_interface) + install(TARGETS ADOLCInterface EXPORT ADOLCInterfaceTargets) + install(EXPORT ADOLCInterfaceTargets + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/adolc) endif() # export the targets From 6663321f577b465c4aa653992e31a17fd1326293 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Thu, 10 Oct 2024 16:15:46 +0200 Subject: [PATCH 18/28] fix install --- CMakeLists.txt | 4 ---- 1 file changed, 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 21efce5c..061f580e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -70,15 +70,11 @@ include(CMakePackageConfigHelpers) include(GNUInstallDirs) install(TARGETS adolc EXPORT adolcTargets) -install(TARGETS ADOLCInterface EXPORT ADOLCInterfaceTargets) install(EXPORT adolcTargets FILE adolc-targets.cmake NAMESPACE adolc:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/adolc) -install(EXPORT ADOLCInterfaceTargets - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/adolc) - From a1553fbeaf7e54eaf2386d02f9fd9493d63349ec Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Mon, 14 Oct 2024 19:18:16 +0200 Subject: [PATCH 19/28] rename --- .github/workflows/{cmake-multi-platform.yml => ci.yml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename .github/workflows/{cmake-multi-platform.yml => ci.yml} (100%) diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/ci.yml similarity index 100% rename from .github/workflows/cmake-multi-platform.yml rename to .github/workflows/ci.yml From 718d2874b3b0d6e8b651b19577329662cc5e2435 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Mon, 14 Oct 2024 19:24:01 +0200 Subject: [PATCH 20/28] update ci --- .github/workflows/ci.yml | 37 +++++-------------------------------- 1 file changed, 5 insertions(+), 32 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3433d7fd..35c8c4d0 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,7 +1,6 @@ # This starter workflow is for a CMake project running on multiple platforms. There is a different starter workflow if you just want a single platform. # See: https://github.com/actions/starter-workflows/blob/main/ci/cmake-single-platform.yml -name: CMake on multiple platforms - +name: build-multi-platform on: push: branches: [ "master" ] @@ -20,31 +19,11 @@ jobs: # 1. # 2. # 3. - # - # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list. matrix: - # os: [ubuntu-latest, macOS-latest, windows-latest] - # os: [ubuntu-latest, macOS-latest] - os: [ubuntu-latest] + os: [ubuntu-latest, macos-latest] build_type: [Release] - c_compiler: [gcc, clang, cl] - include: - #- os: windows-latest - # c_compiler: cl - # cpp_compiler: cl - - os: ubuntu-latest - c_compiler: gcc - cpp_compiler: g++ - - os: ubuntu-latest - c_compiler: clang - cpp_compiler: clang++ - exclude: - - os: windows-latest - c_compiler: gcc - - os: windows-latest - c_compiler: clang - - os: ubuntu-latest - c_compiler: cl + c_compiler: [gcc, clang] + cpp_compiler: [g++, clang++] steps: - uses: actions/checkout@v4 @@ -68,10 +47,4 @@ jobs: - name: Build # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). - run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }} - - - name: Test - working-directory: ${{ steps.strings.outputs.build-output-dir }} - # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). - # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail - run: ctest --build-config ${{ matrix.build_type }} + run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }} \ No newline at end of file From 72d16a21695292328e545a70ba20cfe051e31d6d Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Mon, 14 Oct 2024 19:26:11 +0200 Subject: [PATCH 21/28] update ci --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 35c8c4d0..93852b17 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -20,7 +20,7 @@ jobs: # 2. # 3. matrix: - os: [ubuntu-latest, macos-latest] + os: [ubuntu-latest, macos-latest, windows-latest] build_type: [Release] c_compiler: [gcc, clang] cpp_compiler: [g++, clang++] From 4e9ad135d535532f7d9ec3368399b0bf162034a9 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Mon, 14 Oct 2024 20:14:02 +0200 Subject: [PATCH 22/28] add macro for win --- CMakeLists.txt | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 061f580e..0d418fb5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -18,6 +18,16 @@ target_compile_definitions(adolc PRIVATE ADOLC_SUBVERSION=${adol-c_VERSION_MINOR} ADOLC_PATCHLEVEL=${adol-c_VERSION_PATCH}) + +# win specific flags +if (WIN32) + target_compile_definitions(adolc PRIVATE + # handles __declspec + ADOLC_DLL + ) +endif(WIN32) + + # Set the public include directory containing headers that will be installed target_include_directories(adolc PUBLIC From 76ef1567c2bf1bb42665b02ce02c613b2a7b9181 Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Mon, 14 Oct 2024 20:22:11 +0200 Subject: [PATCH 23/28] fix function signature --- ADOL-C/include/adolc/fixpoint.h | 36 ++++++++++++++++----------------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/ADOL-C/include/adolc/fixpoint.h b/ADOL-C/include/adolc/fixpoint.h index f79f285f..5b4de509 100644 --- a/ADOL-C/include/adolc/fixpoint.h +++ b/ADOL-C/include/adolc/fixpoint.h @@ -4,13 +4,13 @@ Revision: $Id$ Contents: all C functions directly accessing at least one of the four tapes (operations, locations, constants, value stack) - + Copyright (c) Andreas Kowarz, Sebastian Schlenkrich - + This file is part of ADOL-C. This software is provided as open source. - Any use, reproduction, or distribution of the software constitutes + Any use, reproduction, or distribution of the software constitutes recipient's acceptance of the terms of the accompanying license file. - + ----------------------------------------------------------------------------*/ #if !defined(ADOLC_FIXPOINT_H) @@ -20,20 +20,20 @@ BEGIN_C_DECLS -int fp_iteration ( int sub_tape_num, - int (*double_F)(double*, double* ,double*, int, int), - int (*adouble_F)(adouble*, adouble*, adouble*, int, int), - double (*norm)(double*, int), - double (*norm_deriv)(double*, int), - double epsilon, - double epsilon_deriv, - int N_max, - int N_max_deriv, - adouble *x_0, - adouble *u, - adouble *x_fix, - int dim_x, - int dim_u ); +ADOLC_DLL_EXPORT int fp_iteration(int sub_tape_num, + int (*double_F)(double *, double *, double *, int, int), + int (*adouble_F)(adouble *, adouble *, adouble *, int, int), + double (*norm)(double *, int), + double (*norm_deriv)(double *, int), + double epsilon, + double epsilon_deriv, + int N_max, + int N_max_deriv, + adouble *x_0, + adouble *u, + adouble *x_fix, + int dim_x, + int dim_u); END_C_DECLS From 361fc61f7085d59c3be818921106ccfa997ba80b Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Mon, 14 Oct 2024 20:26:03 +0200 Subject: [PATCH 24/28] change to md --- README.md | 128 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 00000000..361f80da --- /dev/null +++ b/README.md @@ -0,0 +1,128 @@ + + ADOL-C + +This new version of ADOL-C features new library functions for + + - sparse Jacobians and sparse Hessians + - external differentiated functions + - optimal checkpointing + - adapted differentiation of fixed point iterations + - parallel differentiation of OpenMP-parallel loops + - Lie derivatives of scalar, vector and covector fields + +and many bug fixes. + +Furthermore the source code was adapted to allow a compilation with +WINDOWS compilers. See file "INSTALL" for generic installation +instructions and special instructions for the installation on a WINDOWS +platform. + +The complete documentation can be found in the subdirectory "doc". + + +Local installation using CMake +============================== + +1. Create a build directory somewhere, and move into that directory + +2. Call CMake: + + cmake -DCMAKE_INSTALL_PREFIX=/path/you/want/to/install/in path/to/adolc/sources + +3. Build and install: + + make + make install + + +Local installation using the AutoTools +====================================== + +1. Type autoreconf -fi + +2. Run configure with possibly using one of these options: + + --prefix=PREFIX install library and header files in PREFIX + (default: ${HOME}/adolc_base) + + --enable-sparse build sparse drivers [default=no] + + --with-openmp-flag=FLAG use FLAG to enable OpenMP at compile time + [default=none] + + --enable-docexa build documented examples [default=no] + --enable-addexa build additional examples [default=no] + --enable-parexa build parallel example [default=no], if yes + -with-openmp-flag=FLAG required + + --with-cflags=FLAGS use CFLAGS=FLAGS (default: -g -O2) + --with-cxxflags=FLAGS use CXXFLAGS=FLAGS (default: -g -02 -std=c++11) + + --with-boost=BOOST_PATH path to the compiled boost library, otherwise + the system one is chosen by default (if exists) + +3. Type make + +4. Type make install + + By default, `make install' will install all the files in ${PREFIX}/lib and + ${PREFIX}/include. You can specify another installation directory by using + the --prefix-option in the configure call. + +This procedure provides all makefiles required in the appropriate directories. +Execute 'configure --help' for more details on other available option. + + + +Nonlocal installation +===================== + +As mentioned in INSTALL one can configure the adolc package to be installed +in a different directory than "${HOME}/adolc_base" by using the "--prefix=PATH" +configure option. This is typically used for global installations. Common PATHs +are "/usr" and "/usr/local/", and others are known to be used. Fine control +over the installation directories can be gained by supplying additional +configure options. See "./configure --help" for details. + +Completing the installation by executing "make install" requires write +permissions for all target directories. Make sure to have them or the result +may be surprising otherwise. + +A global installation can be helpfull if many users need the library. By adding +the library's path to "/etc/ld.so.conf" the usage of LD_LIBRARY_PATH and the +"-L" link switch becomes unnecessary. In many cases, for instance for +PATH=/usr/local, the use of the -I directive for compiling sources becomes +unnecessary too. + + + +Examples +======== + +Examples must be configured to build by using the configure switches + --enable-docexa or --enable-addexa. +They will never be installed by make install but can be found in the +appropriate example subdirectory. + + +Windows Compilation with MINGW +============================== + +Please refer to INSTALL + +Windows Compilation with Visual Studio +====================================== + +Please refer to the file windows/Readme_VC++.txt for building the library and +ADOL-C/examples/Readme_VC++.txt for the documented examples. + + + +Unit tests +========== + +ADOL-C provides more than 400 unit tests to verify its basic functionality. +For more information how to run the tests, please check the README file in ADOL-C/boost-test directory. + +Enjoy this new version! + From 1f3af2cb8603243a6826e1bbcb13437d091088ae Mon Sep 17 00:00:00 2001 From: TimSiebert1 <128799979+TimSiebert1@users.noreply.github.com> Date: Mon, 14 Oct 2024 20:27:17 +0200 Subject: [PATCH 25/28] Update README.md --- README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/README.md b/README.md index 361f80da..f4a29b1d 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,4 @@ - - ADOL-C +# ADOL-C This new version of ADOL-C features new library functions for From 7a8beb3088c1590ffc342cbebff5203f46c433fc Mon Sep 17 00:00:00 2001 From: TimSiebert1 <128799979+TimSiebert1@users.noreply.github.com> Date: Mon, 14 Oct 2024 20:37:24 +0200 Subject: [PATCH 26/28] Update README.md --- README.md | 95 ++++++++++++++++++++++++++----------------------------- 1 file changed, 44 insertions(+), 51 deletions(-) diff --git a/README.md b/README.md index f4a29b1d..2346b291 100644 --- a/README.md +++ b/README.md @@ -12,116 +12,109 @@ This new version of ADOL-C features new library functions for and many bug fixes. Furthermore the source code was adapted to allow a compilation with -WINDOWS compilers. See file "INSTALL" for generic installation +WINDOWS compilers. See file `ÌNSTALL` for generic installation instructions and special instructions for the installation on a WINDOWS platform. The complete documentation can be found in the subdirectory "doc". -Local installation using CMake -============================== +## Local installation using CMake 1. Create a build directory somewhere, and move into that directory 2. Call CMake: - cmake -DCMAKE_INSTALL_PREFIX=/path/you/want/to/install/in path/to/adolc/sources + `cmake -DCMAKE_INSTALL_PREFIX=/path/you/want/to/install/in path/to/adolc/sources` 3. Build and install: - make - make install + `make` + `make install` -Local installation using the AutoTools -====================================== +## Local installation using the AutoTools -1. Type autoreconf -fi +1. Type `autoreconf -fi` 2. Run configure with possibly using one of these options: - --prefix=PREFIX install library and header files in PREFIX - (default: ${HOME}/adolc_base) + `--prefix=PREFIX` install library and header files in PREFIX + (default: `${HOME}/adolc_base`) - --enable-sparse build sparse drivers [default=no] + `--enable-sparse` build sparse drivers [default=no] - --with-openmp-flag=FLAG use FLAG to enable OpenMP at compile time - [default=none] + `--with-openmp-flag=FLAG` use FLAG to enable OpenMP at compile time + [default=none] - --enable-docexa build documented examples [default=no] - --enable-addexa build additional examples [default=no] - --enable-parexa build parallel example [default=no], if yes - -with-openmp-flag=FLAG required + `--enable-docexa` build documented examples [default=no] + `--enable-addexa` build additional examples [default=no] + `--enable-parexa` build parallel example [default=no], if yes + `-with-openmp-flag=FLAG` required - --with-cflags=FLAGS use CFLAGS=FLAGS (default: -g -O2) - --with-cxxflags=FLAGS use CXXFLAGS=FLAGS (default: -g -02 -std=c++11) + `--with-cflags=FLAGS` use `CFLAGS=FLAGS` (default=`-g -02`) + `--with-cxxflags=FLAGS` use `CXXFLAGS=FLAGS` (default=`-g -02 -std=c++11`) - --with-boost=BOOST_PATH path to the compiled boost library, otherwise - the system one is chosen by default (if exists) + `--with-boost=BOOST_PATH` path to the compiled boost library, otherwise + the system one is chosen by default (if exists) -3. Type make +3. Type `make` -4. Type make install +4. Type `make install` - By default, `make install' will install all the files in ${PREFIX}/lib and - ${PREFIX}/include. You can specify another installation directory by using - the --prefix-option in the configure call. + By default, `make install` will install all the files in `${PREFIX}/lib` and + `${PREFIX}/include`. You can specify another installation directory by using + the `--prefix-option` in the configure call. This procedure provides all makefiles required in the appropriate directories. -Execute 'configure --help' for more details on other available option. +Execute `configure --help` for more details on other available option. -Nonlocal installation -===================== +## Nonlocal installation As mentioned in INSTALL one can configure the adolc package to be installed -in a different directory than "${HOME}/adolc_base" by using the "--prefix=PATH" +in a different directory than `${HOME}/adolc_base` by using the `--prefix=PATH` configure option. This is typically used for global installations. Common PATHs -are "/usr" and "/usr/local/", and others are known to be used. Fine control +are `/usr` and `/usr/local/`, and others are known to be used. Fine control over the installation directories can be gained by supplying additional -configure options. See "./configure --help" for details. +configure options. See `./configure --help` for details. -Completing the installation by executing "make install" requires write +Completing the installation by executing `make install` requires write permissions for all target directories. Make sure to have them or the result may be surprising otherwise. -A global installation can be helpfull if many users need the library. By adding -the library's path to "/etc/ld.so.conf" the usage of LD_LIBRARY_PATH and the -"-L" link switch becomes unnecessary. In many cases, for instance for -PATH=/usr/local, the use of the -I directive for compiling sources becomes +A global installation can be helpful if many users need the library. By adding +the library's path to `/etc/ld.so.conf` the usage of `LD_LIBRARY_PATH` and the +`-L` link switch becomes unnecessary. In many cases, for instance for +`PATH=/usr/local`, the use of the `-I` directive for compiling sources becomes unnecessary too. -Examples -======== +## Examples Examples must be configured to build by using the configure switches - --enable-docexa or --enable-addexa. + `--enable-docexa` or `--enable-addexa`. They will never be installed by make install but can be found in the appropriate example subdirectory. -Windows Compilation with MINGW -============================== +## Windows Compilation with MINGW -Please refer to INSTALL +Please refer to `INSTALL` -Windows Compilation with Visual Studio -====================================== +## Windows Compilation with Visual Studio -Please refer to the file windows/Readme_VC++.txt for building the library and -ADOL-C/examples/Readme_VC++.txt for the documented examples. +Please refer to the file `MSMSVisualStudio/v14/Readme_VC++.txt` for building the library and +`ADOL-C/examples/Readme_VC++.txt` for the documented examples. -Unit tests -========== +## Unit tests ADOL-C provides more than 400 unit tests to verify its basic functionality. -For more information how to run the tests, please check the README file in ADOL-C/boost-test directory. +For more information on how to run the tests, please check the `README` file in `ADOL-C/boost-test` directory. Enjoy this new version! From d2e86b7a0b103d01b7d5f3c77c1bbcbc6359baca Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Mon, 14 Oct 2024 21:00:27 +0200 Subject: [PATCH 27/28] add doc and clean cmake file --- ADOL-C/c_interface/ADOLC_TB_interface.cpp | 54 ++++++++++---------- ADOL-C/c_interface/ADOLC_TB_interface.h | 50 +++++++++---------- ADOL-C/c_interface/ADOLC_TL_interface.cpp | 60 +++++++++++------------ ADOL-C/c_interface/ADOLC_TL_interface.h | 56 ++++++++++----------- ADOL-C/c_interface/CMakeLists.txt | 1 - 5 files changed, 108 insertions(+), 113 deletions(-) diff --git a/ADOL-C/c_interface/ADOLC_TB_interface.cpp b/ADOL-C/c_interface/ADOLC_TB_interface.cpp index 2d96209c..1e7036d4 100644 --- a/ADOL-C/c_interface/ADOLC_TB_interface.cpp +++ b/ADOL-C/c_interface/ADOLC_TB_interface.cpp @@ -6,8 +6,7 @@ Constructor & Destructor for class tape-based adouble */ extern "C" { - // Constructor - TBAdoubleHandle create_tb_adouble(double x) + TBAdoubleHandle create_tb_adouble(const double x) { return new adouble(x); } @@ -16,7 +15,6 @@ extern "C" return new adouble(); } - // Destructor void free_tb_adouble(TBAdoubleHandle a) { return delete static_cast(a); @@ -43,11 +41,11 @@ extern "C" { return new adouble(*static_cast(a) + *static_cast(b)); } - TBAdoubleHandle add_double_tb_adouble(double x, TBAdoubleHandle b) + TBAdoubleHandle add_double_tb_adouble(const double x, TBAdoubleHandle b) { return new adouble(x + *static_cast(b)); } - TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, double x) + TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, const double x) { return new adouble(*static_cast(a) + x); } @@ -55,11 +53,11 @@ extern "C" { return new adouble(*static_cast(a) * *static_cast(b)); } - TBAdoubleHandle mult_double_tb_adouble(double x, TBAdoubleHandle b) + TBAdoubleHandle mult_double_tb_adouble(const double x, TBAdoubleHandle b) { return new adouble(x * *static_cast(b)); } - TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, double x) + TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, const double x) { return new adouble(*static_cast(a) * x); } @@ -67,11 +65,11 @@ extern "C" { return new adouble(*static_cast(a) - *static_cast(b)); } - TBAdoubleHandle subtr_double_tb_adouble(double x, TBAdoubleHandle b) + TBAdoubleHandle subtr_double_tb_adouble(const double x, TBAdoubleHandle b) { return new adouble(x - *static_cast(b)); } - TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, double x) + TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, const double x) { return new adouble(*static_cast(a) - x); } @@ -79,11 +77,11 @@ extern "C" { return new adouble(*static_cast(a) / *static_cast(b)); } - TBAdoubleHandle div_double_tb_adouble(double x, TBAdoubleHandle b) + TBAdoubleHandle div_double_tb_adouble(const double x, TBAdoubleHandle b) { return new adouble(x / *static_cast(b)); } - TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, double x) + TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, const double x) { return new adouble(*static_cast(a) / x); } @@ -91,11 +89,11 @@ extern "C" { return new adouble(fmax(*static_cast(a), *static_cast(b))); } - TBAdoubleHandle max_double_tb_adouble(double x, TBAdoubleHandle b) + TBAdoubleHandle max_double_tb_adouble(const double x, TBAdoubleHandle b) { return new adouble(fmax(x, *static_cast(b))); } - TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, double x) + TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, const double x) { return new adouble(fmax(*static_cast(a), x)); } @@ -103,11 +101,11 @@ extern "C" { return new adouble(fmin(*static_cast(a), *static_cast(b))); } - TBAdoubleHandle min_double_tb_adouble(double x, TBAdoubleHandle b) + TBAdoubleHandle min_double_tb_adouble(const double x, TBAdoubleHandle b) { return new adouble(fmin(x, *static_cast(b))); } - TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, double x) + TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, const double x) { return new adouble(fmin(*static_cast(a), x)); } @@ -115,7 +113,7 @@ extern "C" { return new adouble(pow(*static_cast(a), *static_cast(b))); } - TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, double x) + TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, const double x) { return new adouble(pow(*static_cast(a), x)); } @@ -123,11 +121,11 @@ extern "C" { return *static_cast(a) >= *static_cast(b); } - bool ge_double_tb_adouble(double x, TBAdoubleHandle b) + bool ge_double_tb_adouble(const double x, TBAdoubleHandle b) { return x >= *static_cast(b); } - bool ge_tb_adouble_double(TBAdoubleHandle a, double x) + bool ge_tb_adouble_double(TBAdoubleHandle a, const double x) { return *static_cast(a) >= x; } @@ -135,11 +133,11 @@ extern "C" { return *static_cast(a) > *static_cast(b); } - bool g_double_tb_adouble(double x, TBAdoubleHandle b) + bool g_double_tb_adouble(const double x, TBAdoubleHandle b) { return x > *static_cast(b); } - bool g_tb_adouble_double(TBAdoubleHandle a, double x) + bool g_tb_adouble_double(TBAdoubleHandle a, const double x) { return *static_cast(a) > x; } @@ -147,11 +145,11 @@ extern "C" { return *static_cast(a) <= *static_cast(b); } - bool le_double_tb_adouble(double x, TBAdoubleHandle b) + bool le_double_tb_adouble(const double x, TBAdoubleHandle b) { return x <= *static_cast(b); } - bool le_tb_adouble_double(TBAdoubleHandle a, double x) + bool le_tb_adouble_double(TBAdoubleHandle a, const double x) { return *static_cast(a) <= x; } @@ -159,11 +157,11 @@ extern "C" { return *static_cast(a) < *static_cast(b); } - bool l_double_tb_adouble(double x, TBAdoubleHandle b) + bool l_double_tb_adouble(const double x, TBAdoubleHandle b) { return x < *static_cast(b); } - bool l_tb_adouble_double(TBAdoubleHandle a, double x) + bool l_tb_adouble_double(TBAdoubleHandle a, const double x) { return *static_cast(a) < x; } @@ -171,11 +169,11 @@ extern "C" { return *static_cast(a) == *static_cast(b); } - bool eq_double_tb_adouble(double x, TBAdoubleHandle b) + bool eq_double_tb_adouble(const double x, TBAdoubleHandle b) { return x == *static_cast(b); } - bool eq_tb_adouble_double(TBAdoubleHandle a, double x) + bool eq_tb_adouble_double(TBAdoubleHandle a, const double x) { return *static_cast(a) == x; } @@ -255,7 +253,7 @@ extern "C" { return new adouble(floor(*static_cast(a))); } - TBAdoubleHandle tb_ldexp(TBAdoubleHandle a, int n) + TBAdoubleHandle tb_ldexp(TBAdoubleHandle a, const int n) { return new adouble(ldexp(*static_cast(a), n)); } @@ -278,7 +276,7 @@ extern "C" { return trace_off(flag); } - void create_independent(TBAdoubleHandle a, double x) + void create_independent(TBAdoubleHandle a, const double x) { *static_cast(a) <<= x; } diff --git a/ADOL-C/c_interface/ADOLC_TB_interface.h b/ADOL-C/c_interface/ADOLC_TB_interface.h index df889959..438d42e4 100644 --- a/ADOL-C/c_interface/ADOLC_TB_interface.h +++ b/ADOL-C/c_interface/ADOLC_TB_interface.h @@ -19,7 +19,7 @@ extern "C" { #endif // Constructor - TBAdoubleHandle create_tb_adouble(double x); + TBAdoubleHandle create_tb_adouble(const double x); TBAdoubleHandle create_tb_adouble_empty(); // Destructor @@ -48,51 +48,51 @@ extern "C" { #endif TBAdoubleHandle add_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle add_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, double x); + TBAdoubleHandle add_double_tb_adouble(const double x, TBAdoubleHandle b); + TBAdoubleHandle add_tb_adouble_double(TBAdoubleHandle a, const double x); TBAdoubleHandle mult_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle mult_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, double x); + TBAdoubleHandle mult_double_tb_adouble(const double x, TBAdoubleHandle b); + TBAdoubleHandle mult_tb_adouble_double(TBAdoubleHandle a, const double x); TBAdoubleHandle subtr_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle subtr_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, double x); + TBAdoubleHandle subtr_double_tb_adouble(const double x, TBAdoubleHandle b); + TBAdoubleHandle subtr_tb_adouble_double(TBAdoubleHandle a, const double x); TBAdoubleHandle div_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle div_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, double x); + TBAdoubleHandle div_double_tb_adouble(const double x, TBAdoubleHandle b); + TBAdoubleHandle div_tb_adouble_double(TBAdoubleHandle a, const double x); TBAdoubleHandle max_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle max_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, double x); + TBAdoubleHandle max_double_tb_adouble(const double x, TBAdoubleHandle b); + TBAdoubleHandle max_tb_adouble_double(TBAdoubleHandle a, const double x); TBAdoubleHandle min_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle min_double_tb_adouble(double x, TBAdoubleHandle b); - TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, double x); + TBAdoubleHandle min_double_tb_adouble(const double x, TBAdoubleHandle b); + TBAdoubleHandle min_tb_adouble_double(TBAdoubleHandle a, const double x); TBAdoubleHandle pow_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, double x); + TBAdoubleHandle pow_tb_adouble_double(TBAdoubleHandle a, const double x); bool ge_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool ge_double_tb_adouble(double x, TBAdoubleHandle b); - bool ge_tb_adouble_double(TBAdoubleHandle a, double x); + bool ge_double_tb_adouble(const double x, TBAdoubleHandle b); + bool ge_tb_adouble_double(TBAdoubleHandle a, const double x); bool g_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool g_double_tb_adouble(double x, TBAdoubleHandle b); - bool g_tb_adouble_double(TBAdoubleHandle a, double x); + bool g_double_tb_adouble(const double x, TBAdoubleHandle b); + bool g_tb_adouble_double(TBAdoubleHandle a, const double x); bool le_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool le_double_tb_adouble(double x, TBAdoubleHandle b); - bool le_tb_adouble_double(TBAdoubleHandle a, double x); + bool le_double_tb_adouble(const double x, TBAdoubleHandle b); + bool le_tb_adouble_double(TBAdoubleHandle a, const double x); bool l_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool l_double_tb_adouble(double x, TBAdoubleHandle b); - bool l_tb_adouble_double(TBAdoubleHandle a, double x); + bool l_double_tb_adouble(const double x, TBAdoubleHandle b); + bool l_tb_adouble_double(TBAdoubleHandle a, const double x); bool eq_tb_adouble(TBAdoubleHandle a, TBAdoubleHandle b); - bool eq_double_tb_adouble(double x, TBAdoubleHandle b); - bool eq_tb_adouble_double(TBAdoubleHandle a, double x); + bool eq_double_tb_adouble(const double x, TBAdoubleHandle b); + bool eq_tb_adouble_double(TBAdoubleHandle a, const double x); TBAdoubleHandle tb_abs(TBAdoubleHandle a); TBAdoubleHandle tb_sqrt(TBAdoubleHandle a); @@ -128,7 +128,7 @@ extern "C" #endif int c_trace_on(short int tag, int keep = 0); void c_trace_off(int flag = 0); - void create_independent(TBAdoubleHandle a, double x); + void create_independent(TBAdoubleHandle a, const double x); void create_dependent(TBAdoubleHandle a, double *y); size_t num_independent(short tape_id); size_t num_dependent(short tape_id); diff --git a/ADOL-C/c_interface/ADOLC_TL_interface.cpp b/ADOL-C/c_interface/ADOLC_TL_interface.cpp index 7a08d62a..de85c659 100644 --- a/ADOL-C/c_interface/ADOLC_TL_interface.cpp +++ b/ADOL-C/c_interface/ADOLC_TL_interface.cpp @@ -6,7 +6,6 @@ Constructor & Destructor for class tape-less adouble */ extern "C" { - // Constructor TLAdoubleHandle create_tl_adouble(const double x) { return new adtl::adouble(x); @@ -19,7 +18,6 @@ extern "C" { return new adtl::adouble(val, ad_val); } - // Destructor void free_tl_adouble(TLAdoubleHandle a) { return delete static_cast(a); @@ -46,20 +44,20 @@ extern "C" return static_cast(a)->setADValue(val); } - void set_tl_ad_value_idx(TLAdoubleHandle a, size_t pos, const double val) + void set_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos, const double val) { return static_cast(a)->setADValue(pos, val); } - double get_tl_value(TLAdoubleHandle a) + double get_tl_value(const TLAdoubleHandle a) { return static_cast(a)->getValue(); } - const double *get_tl_ad_values(TLAdoubleHandle a) + const double *get_tl_ad_values(const TLAdoubleHandle a) { return (static_cast(a))->getADValue(); } - double get_tl_ad_value_idx(TLAdoubleHandle a, const size_t pos) + double get_tl_ad_value_idx(const TLAdoubleHandle a, const size_t pos) { return static_cast(a)->getADValue(pos); } @@ -70,15 +68,15 @@ Arithmetics for class adouble */ extern "C" { - TLAdoubleHandle add_tl_adouble(const TLAdoubleHandle a, const TLAdoubleHandle b) + TLAdoubleHandle add_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b) { return new adtl::adouble(*static_cast(a) + *static_cast(b)); } - TLAdoubleHandle add_double_tl_adouble(double x, TLAdoubleHandle b) + TLAdoubleHandle add_double_tl_adouble(const double x, TLAdoubleHandle b) { return new adtl::adouble(x + *static_cast(b)); } - TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, double x) + TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, const double x) { return new adtl::adouble(*static_cast(a) + x); } @@ -86,11 +84,11 @@ extern "C" { return new adtl::adouble(*static_cast(a) * *static_cast(b)); } - TLAdoubleHandle mult_double_tl_adouble(double x, TLAdoubleHandle b) + TLAdoubleHandle mult_double_tl_adouble(const double x, TLAdoubleHandle b) { return new adtl::adouble(x * *static_cast(b)); } - TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, double x) + TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, const double x) { return new adtl::adouble(*static_cast(a) * x); } @@ -98,11 +96,11 @@ extern "C" { return new adtl::adouble(*static_cast(a) - *static_cast(b)); } - TLAdoubleHandle subtr_double_tl_adouble(double x, TLAdoubleHandle b) + TLAdoubleHandle subtr_double_tl_adouble(const double x, TLAdoubleHandle b) { return new adtl::adouble(x - *static_cast(b)); } - TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, double x) + TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, const double x) { return new adtl::adouble(*static_cast(a) - x); } @@ -110,11 +108,11 @@ extern "C" { return new adtl::adouble(*static_cast(a) / *static_cast(b)); } - TLAdoubleHandle div_double_tl_adouble(double x, TLAdoubleHandle b) + TLAdoubleHandle div_double_tl_adouble(const double x, TLAdoubleHandle b) { return new adtl::adouble(x / *static_cast(b)); } - TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, double x) + TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, const double x) { return new adtl::adouble(*static_cast(a) / x); } @@ -122,11 +120,11 @@ extern "C" { return new adtl::adouble(fmax(*static_cast(a), *static_cast(b))); } - TLAdoubleHandle max_double_tl_adouble(double x, TLAdoubleHandle b) + TLAdoubleHandle max_double_tl_adouble(const double x, TLAdoubleHandle b) { return new adtl::adouble(fmax(x, *static_cast(b))); } - TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, double x) + TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, const double x) { return new adtl::adouble(fmax(*static_cast(a), x)); } @@ -134,11 +132,11 @@ extern "C" { return new adtl::adouble(fmin(*static_cast(a), *static_cast(b))); } - TLAdoubleHandle min_double_tl_adouble(double x, TLAdoubleHandle b) + TLAdoubleHandle min_double_tl_adouble(const double x, TLAdoubleHandle b) { return new adtl::adouble(fmin(x, *static_cast(b))); } - TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, double x) + TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, const double x) { return new adtl::adouble(fmin(*static_cast(a), x)); } @@ -146,7 +144,7 @@ extern "C" { return new adtl::adouble(pow(*static_cast(a), *static_cast(b))); } - TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, double x) + TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, const double x) { return new adtl::adouble(pow(*static_cast(a), x)); } @@ -154,11 +152,11 @@ extern "C" { return *static_cast(a) >= *static_cast(b); } - bool ge_double_tl_adouble(double x, TLAdoubleHandle b) + bool ge_double_tl_adouble(const double x, TLAdoubleHandle b) { return x >= *static_cast(b); } - bool ge_tl_adouble_double(TLAdoubleHandle a, double x) + bool ge_tl_adouble_double(TLAdoubleHandle a, const double x) { return *static_cast(a) >= x; } @@ -166,11 +164,11 @@ extern "C" { return *static_cast(a) > *static_cast(b); } - bool g_double_tl_adouble(double x, TLAdoubleHandle b) + bool g_double_tl_adouble(const double x, TLAdoubleHandle b) { return x > *static_cast(b); } - bool g_tl_adouble_double(TLAdoubleHandle a, double x) + bool g_tl_adouble_double(TLAdoubleHandle a, const double x) { return *static_cast(a) > x; } @@ -178,11 +176,11 @@ extern "C" { return *static_cast(a) <= *static_cast(b); } - bool le_double_tl_adouble(double x, TLAdoubleHandle b) + bool le_double_tl_adouble(const double x, TLAdoubleHandle b) { return x <= *static_cast(b); } - bool le_tl_adouble_double(TLAdoubleHandle a, double x) + bool le_tl_adouble_double(TLAdoubleHandle a, const double x) { return *static_cast(a) <= x; } @@ -190,11 +188,11 @@ extern "C" { return *static_cast(a) < *static_cast(b); } - bool l_double_tl_adouble(double x, TLAdoubleHandle b) + bool l_double_tl_adouble(const double x, TLAdoubleHandle b) { return x < *static_cast(b); } - bool l_tl_adouble_double(TLAdoubleHandle a, double x) + bool l_tl_adouble_double(TLAdoubleHandle a, const double x) { return *static_cast(a) < x; } @@ -202,11 +200,11 @@ extern "C" { return *static_cast(a) == *static_cast(b); } - bool eq_double_tl_adouble(double x, TLAdoubleHandle b) + bool eq_double_tl_adouble(const double x, TLAdoubleHandle b) { return x == *static_cast(b); } - bool eq_tl_adouble_double(TLAdoubleHandle a, double x) + bool eq_tl_adouble_double(TLAdoubleHandle a, const double x) { return *static_cast(a) == x; } @@ -286,7 +284,7 @@ extern "C" { return new adtl::adouble(floor(*static_cast(a))); } - TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, int n) + TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, const int n) { return new adtl::adouble(ldexp(*static_cast(a), n)); } diff --git a/ADOL-C/c_interface/ADOLC_TL_interface.h b/ADOL-C/c_interface/ADOLC_TL_interface.h index 386cc62a..5558463e 100644 --- a/ADOL-C/c_interface/ADOLC_TL_interface.h +++ b/ADOL-C/c_interface/ADOLC_TL_interface.h @@ -5,7 +5,7 @@ extern "C" { #endif - // Used to handle Tape-based adouble as void* + // Used to handle Tape-Less adouble as void* typedef void *TLAdoubleHandle; #ifdef __cplusplus } @@ -19,7 +19,7 @@ extern "C" { #endif // Constructor - TLAdoubleHandle create_tl_adouble(double x); + TLAdoubleHandle create_tl_adouble(const double x); TLAdoubleHandle create_tl_adouble_with_ad(const double val, const double *ad_val); TLAdoubleHandle create_tl_adouble_empty(); @@ -30,7 +30,7 @@ extern "C" #endif /* -Utilities for adouble +Utilities for tape-less adouble */ #ifdef __cplusplus extern "C" @@ -48,58 +48,58 @@ extern "C" #endif /* -Arithmetics for class tl adouble +Arithmetics for class tape-less adouble */ #ifdef __cplusplus extern "C" { #endif TLAdoubleHandle add_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle add_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, double x); + TLAdoubleHandle add_double_tl_adouble(const double x, TLAdoubleHandle b); + TLAdoubleHandle add_tl_adouble_double(TLAdoubleHandle a, const double x); TLAdoubleHandle mult_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle mult_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, double x); + TLAdoubleHandle mult_double_tl_adouble(const double x, TLAdoubleHandle b); + TLAdoubleHandle mult_tl_adouble_double(TLAdoubleHandle a, const double x); TLAdoubleHandle subtr_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle subtr_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, double x); + TLAdoubleHandle subtr_double_tl_adouble(const double x, TLAdoubleHandle b); + TLAdoubleHandle subtr_tl_adouble_double(TLAdoubleHandle a, const double x); TLAdoubleHandle div_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle div_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, double x); + TLAdoubleHandle div_double_tl_adouble(const double x, TLAdoubleHandle b); + TLAdoubleHandle div_tl_adouble_double(TLAdoubleHandle a, const double x); TLAdoubleHandle max_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle max_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, double x); + TLAdoubleHandle max_double_tl_adouble(const double x, TLAdoubleHandle b); + TLAdoubleHandle max_tl_adouble_double(TLAdoubleHandle a, const double x); TLAdoubleHandle min_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle min_double_tl_adouble(double x, TLAdoubleHandle b); - TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, double x); + TLAdoubleHandle min_double_tl_adouble(const double x, TLAdoubleHandle b); + TLAdoubleHandle min_tl_adouble_double(TLAdoubleHandle a, const double x); TLAdoubleHandle pow_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, double x); + TLAdoubleHandle pow_tl_adouble_double(TLAdoubleHandle a, const double x); bool ge_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool ge_double_tl_adouble(double x, TLAdoubleHandle b); - bool ge_tl_adouble_double(TLAdoubleHandle a, double x); + bool ge_double_tl_adouble(const double x, TLAdoubleHandle b); + bool ge_tl_adouble_double(TLAdoubleHandle a, const double x); bool g_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool g_double_tl_adouble(double x, TLAdoubleHandle b); - bool g_tl_adouble_double(TLAdoubleHandle a, double x); + bool g_double_tl_adouble(const double x, TLAdoubleHandle b); + bool g_tl_adouble_double(TLAdoubleHandle a, const double x); bool le_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool le_double_tl_adouble(double x, TLAdoubleHandle b); - bool le_tl_adouble_double(TLAdoubleHandle a, double x); + bool le_double_tl_adouble(const double x, TLAdoubleHandle b); + bool le_tl_adouble_double(TLAdoubleHandle a, const double x); bool l_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool l_double_tl_adouble(double x, TLAdoubleHandle b); - bool l_tl_adouble_double(TLAdoubleHandle a, double x); + bool l_double_tl_adouble(const double x, TLAdoubleHandle b); + bool l_tl_adouble_double(TLAdoubleHandle a, const double x); bool eq_tl_adouble(TLAdoubleHandle a, TLAdoubleHandle b); - bool eq_double_tl_adouble(double x, TLAdoubleHandle b); - bool eq_tl_adouble_double(TLAdoubleHandle a, double x); + bool eq_double_tl_adouble(const double x, TLAdoubleHandle b); + bool eq_tl_adouble_double(TLAdoubleHandle a, const double x); TLAdoubleHandle tl_abs(TLAdoubleHandle a); TLAdoubleHandle tl_sqrt(TLAdoubleHandle a); @@ -120,7 +120,7 @@ extern "C" TLAdoubleHandle tl_atanh(TLAdoubleHandle a); TLAdoubleHandle tl_ceil(TLAdoubleHandle a); TLAdoubleHandle tl_floor(TLAdoubleHandle a); - TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, int n); + TLAdoubleHandle tl_ldexp(TLAdoubleHandle a, const int n); TLAdoubleHandle tl_erf(TLAdoubleHandle a); #ifdef __cplusplus } diff --git a/ADOL-C/c_interface/CMakeLists.txt b/ADOL-C/c_interface/CMakeLists.txt index 961b061c..cc669382 100644 --- a/ADOL-C/c_interface/CMakeLists.txt +++ b/ADOL-C/c_interface/CMakeLists.txt @@ -1,3 +1,2 @@ - add_library(ADOLCInterface SHARED ADOLC_TB_interface.cpp ADOLC_TL_interface.cpp array_handler.cpp driver_interface.cpp) target_link_libraries(ADOLCInterface adolc) From a20d760886422ce63b34c48c2e5e4ffe34b4520e Mon Sep 17 00:00:00 2001 From: Tim Siebert Date: Mon, 14 Oct 2024 21:00:39 +0200 Subject: [PATCH 28/28] del --- README | 128 --------------------------------------------------------- 1 file changed, 128 deletions(-) delete mode 100644 README diff --git a/README b/README deleted file mode 100644 index 361f80da..00000000 --- a/README +++ /dev/null @@ -1,128 +0,0 @@ - - ADOL-C - -This new version of ADOL-C features new library functions for - - - sparse Jacobians and sparse Hessians - - external differentiated functions - - optimal checkpointing - - adapted differentiation of fixed point iterations - - parallel differentiation of OpenMP-parallel loops - - Lie derivatives of scalar, vector and covector fields - -and many bug fixes. - -Furthermore the source code was adapted to allow a compilation with -WINDOWS compilers. See file "INSTALL" for generic installation -instructions and special instructions for the installation on a WINDOWS -platform. - -The complete documentation can be found in the subdirectory "doc". - - -Local installation using CMake -============================== - -1. Create a build directory somewhere, and move into that directory - -2. Call CMake: - - cmake -DCMAKE_INSTALL_PREFIX=/path/you/want/to/install/in path/to/adolc/sources - -3. Build and install: - - make - make install - - -Local installation using the AutoTools -====================================== - -1. Type autoreconf -fi - -2. Run configure with possibly using one of these options: - - --prefix=PREFIX install library and header files in PREFIX - (default: ${HOME}/adolc_base) - - --enable-sparse build sparse drivers [default=no] - - --with-openmp-flag=FLAG use FLAG to enable OpenMP at compile time - [default=none] - - --enable-docexa build documented examples [default=no] - --enable-addexa build additional examples [default=no] - --enable-parexa build parallel example [default=no], if yes - -with-openmp-flag=FLAG required - - --with-cflags=FLAGS use CFLAGS=FLAGS (default: -g -O2) - --with-cxxflags=FLAGS use CXXFLAGS=FLAGS (default: -g -02 -std=c++11) - - --with-boost=BOOST_PATH path to the compiled boost library, otherwise - the system one is chosen by default (if exists) - -3. Type make - -4. Type make install - - By default, `make install' will install all the files in ${PREFIX}/lib and - ${PREFIX}/include. You can specify another installation directory by using - the --prefix-option in the configure call. - -This procedure provides all makefiles required in the appropriate directories. -Execute 'configure --help' for more details on other available option. - - - -Nonlocal installation -===================== - -As mentioned in INSTALL one can configure the adolc package to be installed -in a different directory than "${HOME}/adolc_base" by using the "--prefix=PATH" -configure option. This is typically used for global installations. Common PATHs -are "/usr" and "/usr/local/", and others are known to be used. Fine control -over the installation directories can be gained by supplying additional -configure options. See "./configure --help" for details. - -Completing the installation by executing "make install" requires write -permissions for all target directories. Make sure to have them or the result -may be surprising otherwise. - -A global installation can be helpfull if many users need the library. By adding -the library's path to "/etc/ld.so.conf" the usage of LD_LIBRARY_PATH and the -"-L" link switch becomes unnecessary. In many cases, for instance for -PATH=/usr/local, the use of the -I directive for compiling sources becomes -unnecessary too. - - - -Examples -======== - -Examples must be configured to build by using the configure switches - --enable-docexa or --enable-addexa. -They will never be installed by make install but can be found in the -appropriate example subdirectory. - - -Windows Compilation with MINGW -============================== - -Please refer to INSTALL - -Windows Compilation with Visual Studio -====================================== - -Please refer to the file windows/Readme_VC++.txt for building the library and -ADOL-C/examples/Readme_VC++.txt for the documented examples. - - - -Unit tests -========== - -ADOL-C provides more than 400 unit tests to verify its basic functionality. -For more information how to run the tests, please check the README file in ADOL-C/boost-test directory. - -Enjoy this new version! -