668 Assert(is_registered_tape(active_tape_index),
669 ExcMessage(
"This tape has not yet been recorded."));
671 scalar_type
value = 0.0;
673 status[active_tape_index] =
674 ::function(active_tape_index,
676 independent_variables.size(),
677 const_cast<double *
>(independent_variables.data()),
684 template <
typename ADNumberType>
688 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
691 const std::vector<scalar_type> &independent_variables,
699 Assert(gradient.size() == independent_variables.size(),
701 independent_variables.size()));
702 Assert(is_registered_tape(active_tape_index),
703 ExcMessage(
"This tape has not yet been recorded."));
708 status[active_tape_index] =
709 ::gradient(active_tape_index,
710 independent_variables.size(),
711 const_cast<scalar_type *
>(independent_variables.data()),
716 template <
typename ADNumberType>
718 TapedDrivers<ADNumberType,
720 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
723 const std::vector<scalar_type> &independent_variables,
731 Assert(hessian.m() == independent_variables.size(),
733 Assert(hessian.n() == independent_variables.size(),
735 Assert(is_registered_tape(active_tape_index),
736 ExcMessage(
"This tape has not yet been recorded."));
738 const unsigned int n_independent_variables = independent_variables.size();
739 std::vector<scalar_type *> H(n_independent_variables);
740 for (
unsigned int i = 0; i < n_independent_variables; ++i)
741 H[i] = &hessian[i][0];
743 status[active_tape_index] =
744 ::hessian(active_tape_index,
745 n_independent_variables,
746 const_cast<scalar_type *
>(independent_variables.data()),
752 for (
unsigned int i = 0; i < n_independent_variables; ++i)
753 for (
unsigned int j = 0; j < i; ++j)
754 hessian[j][i] = hessian[i][j];
758 template <
typename ADNumberType>
760 TapedDrivers<ADNumberType,
762 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
765 const unsigned int n_dependent_variables,
766 const std::vector<scalar_type> &independent_variables,
769 Assert(values.size() == n_dependent_variables,
771 Assert(is_registered_tape(active_tape_index),
772 ExcMessage(
"This tape has not yet been recorded."));
777 status[active_tape_index] =
778 ::function(active_tape_index,
779 n_dependent_variables,
780 independent_variables.size(),
781 const_cast<scalar_type *
>(independent_variables.data()),
786 template <
typename ADNumberType>
790 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
793 const unsigned int n_dependent_variables,
794 const std::vector<scalar_type> &independent_variables,
795 FullMatrix<scalar_type> &jacobian)
const
797 Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
800 AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels,
802 Assert(jacobian.
m() == n_dependent_variables,
804 Assert(jacobian.
n() == independent_variables.size(),
806 Assert(is_registered_tape(active_tape_index),
807 ExcMessage(
"This tape has not yet been recorded."));
809 std::vector<scalar_type *> J(n_dependent_variables);
810 for (
unsigned int i = 0; i < n_dependent_variables; ++i)
811 J[i] = &jacobian[i][0];
813 status[active_tape_index] = ::jacobian(active_tape_index,
814 n_dependent_variables,
815 independent_variables.size(),
816 independent_variables.data(),
824 template <
typename ADNumberType>
828 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
837 template <
typename ADNumberType>
842 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
850 template <
typename ADNumberType>
854 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
856 keep_independent_values()
const
863 template <
typename ADNumberType>
867 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
876 template <
typename ADNumberType>
880 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
882 set_tape_buffer_sizes(
892 template <
typename ADNumberType>
896 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
904 template <
typename ADNumberType>
908 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
916 template <
typename ADNumberType>
917 std::vector<typename Types<ADNumberType>::tape_index>
920 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
922 get_registered_tape_indices()
const
925 return std::vector<typename Types<ADNumberType>::tape_index>();
929 template <
typename ADNumberType>
933 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
941 template <
typename ADNumberType>
945 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
954 template <
typename ADNumberType>
958 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
960 last_action_requires_retaping()
const
967 template <
typename ADNumberType>
971 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
979 template <
typename ADNumberType>
983 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
990 template <
typename ADNumberType>
994 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1002 template <
typename ADNumberType>
1006 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1009 std::ostream &)
const
1015 template <
typename ADNumberType>
1019 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1023 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1026 const std::vector<scalar_type> &)
const
1033 template <
typename ADNumberType>
1037 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1040 const std::vector<scalar_type> &,
1041 Vector<scalar_type> &)
const
1047 template <
typename ADNumberType>
1051 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1054 const std::vector<scalar_type> &,
1055 FullMatrix<scalar_type> &)
const
1061 template <
typename ADNumberType>
1065 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1069 const std::vector<scalar_type> &,
1070 Vector<scalar_type> &)
const
1076 template <
typename ADNumberType>
1080 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1084 const std::vector<scalar_type> &,
1085 FullMatrix<scalar_type> &)
const
1096 template <
typename ADNumberType>
1100 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1106 return taped_driver.is_recording();
1110 template <
typename ADNumberType>
1115 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1120 return taped_driver.active_tape_index();
1124 template <
typename ADNumberType>
1128 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1130 keep_independent_values()
const
1132 return taped_driver.keep_independent_values();
1136 template <
typename ADNumberType>
1140 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1147 return taped_driver.is_registered_tape(tape_index);
1151 template <
typename ADNumberType>
1155 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1157 set_tape_buffer_sizes(
1165 taped_driver.set_tape_buffer_sizes(obufsize,
1172 template <
typename ADNumberType>
1176 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1179 const bool keep_independent_values)
1183 taped_driver.start_taping(tape_index, keep_independent_values);
1187 template <
typename ADNumberType>
1191 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1195 const bool write_tapes_to_file)
1199 taped_driver.stop_taping(active_tape_index, write_tapes_to_file);
1203 template <
typename ADNumberType>
1204 std::vector<typename Types<ADNumberType>::tape_index>
1207 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1209 get_registered_tape_indices()
const
1211 return taped_driver.get_registered_tape_indices();
1215 template <
typename ADNumberType>
1219 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1223 taped_driver.activate_tape(tape_index);
1227 template <
typename ADNumberType>
1231 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1236 return taped_driver.requires_retaping(tape_index);
1240 template <
typename ADNumberType>
1244 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1246 last_action_requires_retaping()
const
1248 return taped_driver.last_action_requires_retaping();
1252 template <
typename ADNumberType>
1256 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1260 taped_driver.remove_tape(tape_index);
1264 template <
typename ADNumberType>
1268 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1270 reset(
const bool clear_registered_tapes)
1272 taped_driver.reset(clear_registered_tapes);
1276 template <
typename ADNumberType>
1280 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1285 taped_driver.print(stream);
1289 template <
typename ADNumberType>
1293 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1297 std::ostream &stream)
const
1301 taped_driver.print_tape_stats(tape_index, stream);
1305 template <
typename ADNumberType>
1309 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1313 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1316 const std::vector<scalar_type> &independent_variables)
const
1320 return taped_driver.value(active_tape_index,
1321 vector_float_to_double(independent_variables));
1325 template <
typename ADNumberType>
1329 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1332 const std::vector<scalar_type> &independent_variables,
1333 Vector<scalar_type> &gradient)
const
1335 Vector<double> gradient_double(
gradient.size());
1338 taped_driver.gradient(active_tape_index,
1339 vector_float_to_double(independent_variables),
1345 template <
typename ADNumberType>
1349 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1352 const std::vector<scalar_type> &independent_variables,
1353 FullMatrix<scalar_type> &hessian)
const
1358 taped_driver.hessian(active_tape_index,
1359 vector_float_to_double(independent_variables),
1365 template <
typename ADNumberType>
1369 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1372 const unsigned int n_dependent_variables,
1373 const std::vector<scalar_type> &independent_variables,
1374 Vector<scalar_type> &values)
const
1376 Vector<double> values_double(
values.size());
1379 taped_driver.values(active_tape_index,
1380 n_dependent_variables,
1381 vector_float_to_double(independent_variables),
1387 template <
typename ADNumberType>
1391 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1394 const unsigned int n_dependent_variables,
1395 const std::vector<scalar_type> &independent_variables,
1396 FullMatrix<scalar_type> &jacobian)
const
1398 FullMatrix<double> jacobian_double(jacobian.
m(), jacobian.
n());
1401 taped_driver.jacobian(active_tape_index,
1402 n_dependent_variables,
1403 vector_float_to_double(independent_variables),
1405 jacobian = jacobian_double;
1410 template <
typename ADNumberType>
1414 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1416 vector_float_to_double(
const std::vector<float> &in)
const
1418 std::vector<double> out(in.size());
1419 std::copy(in.begin(), in.end(), out.begin());
1428 template <
typename ADNumberType,
typename ScalarType,
typename T>
1436 template <
typename ADNumberType,
typename ScalarType,
typename T>
1444 template <
typename ADNumberType,
typename ScalarType,
typename T>
1452 template <
typename ADNumberType,
typename ScalarType,
typename T>
1462 template <
typename ADNumberType,
typename ScalarType,
typename T>
1465 const std::vector<ADNumberType> &)
const
1468 return ScalarType(0.0);
1472 template <
typename ADNumberType,
typename ScalarType,
typename T>
1475 const std::vector<ADNumberType> &,
1476 const std::vector<ADNumberType> &,
1483 template <
typename ADNumberType,
typename ScalarType,
typename T>
1486 const std::vector<ADNumberType> &,
1487 const std::vector<ADNumberType> &,
1494 template <
typename ADNumberType,
typename ScalarType,
typename T>
1497 const std::vector<ADNumberType> &,
1504 template <
typename ADNumberType,
typename ScalarType,
typename T>
1507 const std::vector<ADNumberType> &,
1508 const std::vector<ADNumberType> &,