669 Assert(is_registered_tape(active_tape_index),
670 ExcMessage(
"This tape has not yet been recorded."));
672 scalar_type value = 0.0;
674 status[active_tape_index] =
675 ::function(active_tape_index,
677 independent_variables.size(),
678 const_cast<double *
>(independent_variables.data()),
685 template <
typename ADNumberType>
689 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
690 NumberTypes::adolc_taped>>::
692 const std::vector<scalar_type> &independent_variables,
697 ExcSupportedDerivativeLevels(
700 Assert(gradient.size() == independent_variables.size(),
702 independent_variables.size()));
703 Assert(is_registered_tape(active_tape_index),
704 ExcMessage(
"This tape has not yet been recorded."));
709 status[active_tape_index] =
710 ::gradient(active_tape_index,
711 independent_variables.size(),
712 const_cast<scalar_type *
>(independent_variables.data()),
717 template <
typename ADNumberType>
719 TapedDrivers<ADNumberType,
721 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
722 NumberTypes::adolc_taped>>::
723 hessian(
const typename Types<ADNumberType>::tape_index active_tape_index,
724 const std::vector<scalar_type> &independent_variables,
729 ExcSupportedDerivativeLevels(
732 Assert(hessian.m() == independent_variables.size(),
734 Assert(hessian.n() == independent_variables.size(),
736 Assert(is_registered_tape(active_tape_index),
737 ExcMessage(
"This tape has not yet been recorded."));
739 const unsigned int n_independent_variables = independent_variables.size();
740 std::vector<scalar_type *> H(n_independent_variables);
741 for (
unsigned int i = 0; i < n_independent_variables; ++i)
742 H[i] = &hessian[i][0];
744 status[active_tape_index] =
745 ::hessian(active_tape_index,
746 n_independent_variables,
747 const_cast<scalar_type *
>(independent_variables.data()),
753 for (
unsigned int i = 0; i < n_independent_variables; ++i)
754 for (
unsigned int j = 0; j < i; ++j)
755 hessian[j][i] = hessian[i][j];
759 template <
typename ADNumberType>
761 TapedDrivers<ADNumberType,
763 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
764 NumberTypes::adolc_taped>>::
765 values(
const typename Types<ADNumberType>::tape_index active_tape_index,
766 const unsigned int n_dependent_variables,
767 const std::vector<scalar_type> &independent_variables,
770 Assert(values.size() == n_dependent_variables,
772 Assert(is_registered_tape(active_tape_index),
773 ExcMessage(
"This tape has not yet been recorded."));
778 status[active_tape_index] =
779 ::function(active_tape_index,
780 n_dependent_variables,
781 independent_variables.size(),
782 const_cast<scalar_type *
>(independent_variables.data()),
787 template <
typename ADNumberType>
789 TapedDrivers<ADNumberType,
791 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
792 NumberTypes::adolc_taped>>::
793 jacobian(
const typename Types<ADNumberType>::tape_index active_tape_index,
794 const unsigned int n_dependent_variables,
795 const std::vector<scalar_type> &independent_variables,
798 Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
800 ExcSupportedDerivativeLevels(
801 AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels,
803 Assert(jacobian.
m() == n_dependent_variables,
805 Assert(jacobian.
n() == independent_variables.size(),
807 Assert(is_registered_tape(active_tape_index),
808 ExcMessage(
"This tape has not yet been recorded."));
810 std::vector<scalar_type *> J(n_dependent_variables);
811 for (
unsigned int i = 0; i < n_dependent_variables; ++i)
812 J[i] = &jacobian[i][0];
814 status[active_tape_index] = ::jacobian(active_tape_index,
815 n_dependent_variables,
816 independent_variables.size(),
817 independent_variables.data(),
825 template <
typename ADNumberType>
827 TapedDrivers<ADNumberType,
829 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
830 NumberTypes::adolc_taped>>::is_recording()
838 template <
typename ADNumberType>
839 typename Types<ADNumberType>::tape_index
843 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
844 NumberTypes::adolc_taped>>::active_tape_index()
const
847 return Numbers<ADNumberType>::invalid_tape_index;
851 template <
typename ADNumberType>
853 TapedDrivers<ADNumberType,
855 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
856 NumberTypes::adolc_taped>>::
857 keep_independent_values()
const
864 template <
typename ADNumberType>
866 TapedDrivers<ADNumberType,
868 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
869 NumberTypes::adolc_taped>>::
870 is_registered_tape(
const typename Types<ADNumberType>::tape_index)
const
877 template <
typename ADNumberType>
879 TapedDrivers<ADNumberType,
881 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
882 NumberTypes::adolc_taped>>::
883 set_tape_buffer_sizes(
884 const typename Types<ADNumberType>::tape_buffer_sizes,
885 const typename Types<ADNumberType>::tape_buffer_sizes,
886 const typename Types<ADNumberType>::tape_buffer_sizes,
887 const typename Types<ADNumberType>::tape_buffer_sizes)
893 template <
typename ADNumberType>
895 TapedDrivers<ADNumberType,
897 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
898 NumberTypes::adolc_taped>>::
899 start_taping(
const typename Types<ADNumberType>::tape_index,
const bool)
905 template <
typename ADNumberType>
907 TapedDrivers<ADNumberType,
909 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
910 NumberTypes::adolc_taped>>::
911 stop_taping(
const typename Types<ADNumberType>::tape_index,
const bool)
917 template <
typename ADNumberType>
918 std::vector<typename Types<ADNumberType>::tape_index>
919 TapedDrivers<ADNumberType,
921 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
922 NumberTypes::adolc_taped>>::
923 get_registered_tape_indices()
const
926 return std::vector<typename Types<ADNumberType>::tape_index>();
930 template <
typename ADNumberType>
932 TapedDrivers<ADNumberType,
934 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
935 NumberTypes::adolc_taped>>::
936 activate_tape(
const typename Types<ADNumberType>::tape_index)
942 template <
typename ADNumberType>
944 TapedDrivers<ADNumberType,
946 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
947 NumberTypes::adolc_taped>>::
948 requires_retaping(
const typename Types<ADNumberType>::tape_index)
const
955 template <
typename ADNumberType>
957 TapedDrivers<ADNumberType,
959 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
960 NumberTypes::adolc_taped>>::
961 last_action_requires_retaping()
const
968 template <
typename ADNumberType>
970 TapedDrivers<ADNumberType,
972 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
973 NumberTypes::adolc_taped>>::
974 remove_tape(
const typename Types<ADNumberType>::tape_index)
980 template <
typename ADNumberType>
982 TapedDrivers<ADNumberType,
984 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
985 NumberTypes::adolc_taped>>::reset(
const bool)
991 template <
typename ADNumberType>
993 TapedDrivers<ADNumberType,
995 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
996 NumberTypes::adolc_taped>>::print(std::ostream
1003 template <
typename ADNumberType>
1005 TapedDrivers<ADNumberType,
1007 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1008 NumberTypes::adolc_taped>>::
1009 print_tape_stats(
const typename Types<ADNumberType>::tape_index,
1010 std::ostream &)
const
1016 template <
typename ADNumberType>
1017 typename TapedDrivers<
1020 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1021 NumberTypes::adolc_taped>>::scalar_type
1022 TapedDrivers<ADNumberType,
1024 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1025 NumberTypes::adolc_taped>>::
1026 value(
const typename Types<ADNumberType>::tape_index,
1027 const std::vector<scalar_type> &)
const
1034 template <
typename ADNumberType>
1036 TapedDrivers<ADNumberType,
1038 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1039 NumberTypes::adolc_taped>>::
1040 gradient(
const typename Types<ADNumberType>::tape_index,
1041 const std::vector<scalar_type> &,
1048 template <
typename ADNumberType>
1050 TapedDrivers<ADNumberType,
1052 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1053 NumberTypes::adolc_taped>>::
1054 hessian(
const typename Types<ADNumberType>::tape_index,
1055 const std::vector<scalar_type> &,
1062 template <
typename ADNumberType>
1064 TapedDrivers<ADNumberType,
1066 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1067 NumberTypes::adolc_taped>>::
1068 values(
const typename Types<ADNumberType>::tape_index,
1070 const std::vector<scalar_type> &,
1077 template <
typename ADNumberType>
1079 TapedDrivers<ADNumberType,
1081 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1082 NumberTypes::adolc_taped>>::
1083 jacobian(
const typename Types<ADNumberType>::tape_index,
1085 const std::vector<scalar_type> &,
1097 template <
typename ADNumberType>
1099 TapedDrivers<ADNumberType,
1101 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1102 NumberTypes::adolc_taped>>::is_recording()
1107 return taped_driver.is_recording();
1111 template <
typename ADNumberType>
1112 typename Types<ADNumberType>::tape_index
1116 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1117 NumberTypes::adolc_taped>>::active_tape_index()
const
1121 return taped_driver.active_tape_index();
1125 template <
typename ADNumberType>
1127 TapedDrivers<ADNumberType,
1129 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1130 NumberTypes::adolc_taped>>::
1131 keep_independent_values()
const
1133 return taped_driver.keep_independent_values();
1137 template <
typename ADNumberType>
1139 TapedDrivers<ADNumberType,
1141 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1142 NumberTypes::adolc_taped>>::
1144 const typename Types<ADNumberType>::tape_index tape_index)
const
1148 return taped_driver.is_registered_tape(tape_index);
1152 template <
typename ADNumberType>
1154 TapedDrivers<ADNumberType,
1156 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1157 NumberTypes::adolc_taped>>::
1158 set_tape_buffer_sizes(
1159 const typename Types<ADNumberType>::tape_buffer_sizes obufsize,
1160 const typename Types<ADNumberType>::tape_buffer_sizes lbufsize,
1161 const typename Types<ADNumberType>::tape_buffer_sizes vbufsize,
1162 const typename Types<ADNumberType>::tape_buffer_sizes tbufsize)
1166 taped_driver.set_tape_buffer_sizes(obufsize,
1173 template <
typename ADNumberType>
1175 TapedDrivers<ADNumberType,
1177 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1178 NumberTypes::adolc_taped>>::
1179 start_taping(
const typename Types<ADNumberType>::tape_index tape_index,
1180 const bool keep_independent_values)
1184 taped_driver.start_taping(tape_index, keep_independent_values);
1188 template <
typename ADNumberType>
1190 TapedDrivers<ADNumberType,
1192 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1193 NumberTypes::adolc_taped>>::
1195 const typename Types<ADNumberType>::tape_index active_tape_index,
1196 const bool write_tapes_to_file)
1200 taped_driver.stop_taping(active_tape_index, write_tapes_to_file);
1204 template <
typename ADNumberType>
1205 std::vector<typename Types<ADNumberType>::tape_index>
1206 TapedDrivers<ADNumberType,
1208 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1209 NumberTypes::adolc_taped>>::
1210 get_registered_tape_indices()
const
1212 return taped_driver.get_registered_tape_indices();
1216 template <
typename ADNumberType>
1218 TapedDrivers<ADNumberType,
1220 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1221 NumberTypes::adolc_taped>>::
1222 activate_tape(
const typename Types<ADNumberType>::tape_index tape_index)
1224 taped_driver.activate_tape(tape_index);
1228 template <
typename ADNumberType>
1230 TapedDrivers<ADNumberType,
1232 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1233 NumberTypes::adolc_taped>>::
1235 const typename Types<ADNumberType>::tape_index tape_index)
const
1237 return taped_driver.requires_retaping(tape_index);
1241 template <
typename ADNumberType>
1243 TapedDrivers<ADNumberType,
1245 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1246 NumberTypes::adolc_taped>>::
1247 last_action_requires_retaping()
const
1249 return taped_driver.last_action_requires_retaping();
1253 template <
typename ADNumberType>
1255 TapedDrivers<ADNumberType,
1257 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1258 NumberTypes::adolc_taped>>::
1259 remove_tape(
const typename Types<ADNumberType>::tape_index tape_index)
1261 taped_driver.remove_tape(tape_index);
1265 template <
typename ADNumberType>
1267 TapedDrivers<ADNumberType,
1269 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1270 NumberTypes::adolc_taped>>::
1271 reset(
const bool clear_registered_tapes)
1273 taped_driver.reset(clear_registered_tapes);
1277 template <
typename ADNumberType>
1279 TapedDrivers<ADNumberType,
1281 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1282 NumberTypes::adolc_taped>>::print(std::ostream
1286 taped_driver.print(stream);
1290 template <
typename ADNumberType>
1292 TapedDrivers<ADNumberType,
1294 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1295 NumberTypes::adolc_taped>>::
1297 const typename Types<ADNumberType>::tape_index tape_index,
1298 std::ostream & stream)
const
1302 taped_driver.print_tape_stats(tape_index, stream);
1306 template <
typename ADNumberType>
1307 typename TapedDrivers<
1310 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1311 NumberTypes::adolc_taped>>::scalar_type
1312 TapedDrivers<ADNumberType,
1314 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1315 NumberTypes::adolc_taped>>::
1316 value(
const typename Types<ADNumberType>::tape_index active_tape_index,
1317 const std::vector<scalar_type> &independent_variables)
const
1321 return taped_driver.value(active_tape_index,
1322 vector_float_to_double(independent_variables));
1326 template <
typename ADNumberType>
1328 TapedDrivers<ADNumberType,
1330 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1331 NumberTypes::adolc_taped>>::
1332 gradient(
const typename Types<ADNumberType>::tape_index active_tape_index,
1333 const std::vector<scalar_type> &independent_variables,
1339 taped_driver.gradient(active_tape_index,
1340 vector_float_to_double(independent_variables),
1346 template <
typename ADNumberType>
1348 TapedDrivers<ADNumberType,
1350 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1351 NumberTypes::adolc_taped>>::
1352 hessian(
const typename Types<ADNumberType>::tape_index active_tape_index,
1353 const std::vector<scalar_type> &independent_variables,
1359 taped_driver.hessian(active_tape_index,
1360 vector_float_to_double(independent_variables),
1366 template <
typename ADNumberType>
1368 TapedDrivers<ADNumberType,
1370 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1371 NumberTypes::adolc_taped>>::
1372 values(
const typename Types<ADNumberType>::tape_index active_tape_index,
1373 const unsigned int n_dependent_variables,
1374 const std::vector<scalar_type> &independent_variables,
1380 taped_driver.values(active_tape_index,
1381 n_dependent_variables,
1382 vector_float_to_double(independent_variables),
1384 values = values_double;
1388 template <
typename ADNumberType>
1390 TapedDrivers<ADNumberType,
1392 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1393 NumberTypes::adolc_taped>>::
1394 jacobian(
const typename Types<ADNumberType>::tape_index active_tape_index,
1395 const unsigned int n_dependent_variables,
1396 const std::vector<scalar_type> &independent_variables,
1402 taped_driver.jacobian(active_tape_index,
1403 n_dependent_variables,
1404 vector_float_to_double(independent_variables),
1406 jacobian = jacobian_double;
1411 template <
typename ADNumberType>
1413 TapedDrivers<ADNumberType,
1415 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1416 NumberTypes::adolc_taped>>::
1417 vector_float_to_double(
const std::vector<float> &in)
const
1419 std::vector<double> out(in.size());
1420 std::copy(in.begin(), in.end(), out.begin());
1429 template <
typename ADNumberType,
typename ScalarType,
typename T>
1434 AssertThrow(
false, ExcRequiresADNumberSpecialization());
1437 template <
typename ADNumberType,
typename ScalarType,
typename T>
1442 AssertThrow(
false, ExcRequiresADNumberSpecialization());
1445 template <
typename ADNumberType,
typename ScalarType,
typename T>
1450 AssertThrow(
false, ExcRequiresADNumberSpecialization());
1453 template <
typename ADNumberType,
typename ScalarType,
typename T>
1458 AssertThrow(
false, ExcRequiresADNumberSpecialization());
1463 template <
typename ADNumberType,
typename ScalarType,
typename T>
1466 const std::vector<ADNumberType> &)
const
1468 AssertThrow(
false, ExcRequiresADNumberSpecialization());
1469 return ScalarType(0.0);
1473 template <
typename ADNumberType,
typename ScalarType,
typename T>
1476 const std::vector<ADNumberType> &,
1477 const std::vector<ADNumberType> &,
1480 AssertThrow(
false, ExcRequiresADNumberSpecialization());
1484 template <
typename ADNumberType,
typename ScalarType,
typename T>
1487 const std::vector<ADNumberType> &,
1488 const std::vector<ADNumberType> &,
1491 AssertThrow(
false, ExcRequiresADNumberSpecialization());
1495 template <
typename ADNumberType,
typename ScalarType,
typename T>
1498 const std::vector<ADNumberType> &,
1501 AssertThrow(
false, ExcRequiresADNumberSpecialization());
1505 template <
typename ADNumberType,
typename ScalarType,
typename T>
1508 const std::vector<ADNumberType> &,
1509 const std::vector<ADNumberType> &,
1512 AssertThrow(
false, ExcRequiresADNumberSpecialization());