Showing preview only (8,728K chars total). Download the full file or copy to clipboard to get everything.
Repository: coin-or/CppAD
Branch: main
Commit: 5c27de281a69
Files: 1472
Total size: 8.1 MB
Directory structure:
gitextract_tk_667wh/
├── .circleci/
│ └── config.yml
├── .github/
│ └── workflows/
│ ├── conda/
│ │ └── conda-env.yml
│ ├── conda-bash.yml
│ ├── conda-windows-clang.yml
│ ├── conda-windows-eigen.yml
│ ├── conda-windows-v142.yml
│ ├── ubuntu-macos.yml
│ └── windows-msys2.yml
├── .gitignore
├── .readthedocs.yaml
├── .travis.yml
├── CMakeLists.txt
├── COPYING
├── appendix/
│ ├── addon.xrst
│ ├── appendix.xrst
│ ├── bib.xrst
│ ├── deprecated/
│ │ ├── compare_change.xrst
│ │ ├── deprecated.xrst
│ │ ├── fun_deprecated.xrst
│ │ ├── include_deprecated.xrst
│ │ └── omp_alloc.xrst
│ ├── directory.xrst
│ ├── faq.xrst
│ ├── glossary.xrst
│ ├── license.xrst
│ ├── numeric_ad.xrst
│ ├── whats_new/
│ │ ├── 2003.xrst
│ │ ├── 2004.xrst
│ │ ├── 2005.xrst
│ │ ├── 2006.xrst
│ │ ├── 2007.xrst
│ │ ├── 2008.xrst
│ │ ├── 2009.xrst
│ │ ├── 2010.xrst
│ │ ├── 2011.xrst
│ │ ├── 2012.xrst
│ │ ├── 2013.xrst
│ │ ├── 2014.xrst
│ │ ├── 2015.xrst
│ │ ├── 2016.xrst
│ │ ├── 2017.xrst
│ │ ├── 2018.xrst
│ │ ├── 2019.xrst
│ │ ├── 2020.xrst
│ │ ├── 2021.xrst
│ │ ├── 2022.xrst
│ │ ├── 2023.xrst
│ │ ├── 2024.xrst
│ │ ├── 2025.xrst
│ │ ├── 2026.xrst
│ │ └── whats_new.xrst
│ └── wish_list.xrst
├── appveyor.yml
├── authors
├── batch_edit.sed
├── bin/
│ ├── appveyor.sh
│ ├── build.bat
│ ├── check_addon.sh
│ ├── check_all.sh
│ ├── check_copy.sh
│ ├── check_define.sh
│ ├── check_deprecated.sh
│ ├── check_doxygen.sh
│ ├── check_example.sh
│ ├── check_if.sh
│ ├── check_include_def.sh
│ ├── check_include_file.sh
│ ├── check_include_xrst.sh
│ ├── check_invisible.sh
│ ├── check_nominmax.sh
│ ├── check_op_code.sh
│ ├── check_sort.sh
│ ├── check_tab.sh
│ ├── check_tempfile.sh
│ ├── check_trace.sh
│ ├── check_user_def.py
│ ├── check_version.sh
│ ├── colpack.sh
│ ├── deprecate_xam.sh
│ ├── dev_settings.sh
│ ├── dos_build.bat
│ ├── doxyfile.sh
│ ├── get_adolc.sh
│ ├── get_colpack.sh
│ ├── get_cppadcg.sh
│ ├── get_fadbad.sh
│ ├── get_ipopt.sh
│ ├── get_optional.sh
│ ├── get_sacado.sh
│ ├── git_commit.sh
│ ├── grep_and_sed.sh
│ ├── group_list.sh
│ ├── master_revert.sh
│ ├── new_release.sh
│ ├── no_bitwise.sh
│ ├── package.sh
│ ├── run_cmake.sh
│ ├── run_configure.sh
│ ├── run_doxygen.sh
│ ├── run_xrst.sh
│ ├── sort.sh
│ ├── speed_branch.sh
│ ├── speed_diff.sh
│ ├── speed_new.sh
│ ├── speed_package.sh
│ ├── tag_month.sh
│ ├── test_install.sh
│ ├── test_multi_thread.sh
│ ├── test_one.sh.in
│ ├── trace.sh
│ ├── travis.sh
│ ├── twine.sh
│ └── valgrind.sh
├── bug/
│ ├── boost_lu.sh
│ ├── clang_simple.sh
│ ├── cmake_target.sh
│ ├── cppad_cg.sh
│ ├── doxy_member.sh
│ ├── eigen_shadow.sh
│ ├── gcc_complex.sh
│ ├── numeric_limit.sh
│ ├── pow.sh
│ ├── sparsity.sh
│ ├── std_vector.sh
│ ├── subgraph.sh
│ ├── template.sh
│ ├── test_install.sh
│ └── vec_itr_speed.sh
├── cmake/
│ ├── add_check_executable.cmake
│ ├── add_to_list.cmake
│ ├── assert.cmake
│ ├── assert_value_in_set.cmake
│ ├── command_line_arg.cmake
│ ├── compile_source_test.cmake
│ ├── cppad_uninstall.cmake
│ ├── dos_path_to_unix.cmake
│ ├── eigen_info.cmake
│ ├── pkgconfig_info.cmake
│ ├── prefix_info.cmake
│ ├── print_variable.cmake
│ ├── run_source_test.cmake
│ └── set_compile_flags.cmake
├── configure
├── cppad_ipopt/
│ ├── CMakeLists.txt
│ ├── example/
│ │ ├── CMakeLists.txt
│ │ ├── example.cpp
│ │ ├── get_started.cpp
│ │ ├── ode1.xrst
│ │ ├── ode2.xrst
│ │ ├── ode_check.cpp
│ │ ├── ode_check.hpp
│ │ ├── ode_fast.hpp
│ │ ├── ode_fast_check.cpp
│ │ ├── ode_problem.hpp
│ │ ├── ode_run.hpp
│ │ ├── ode_simple.hpp
│ │ ├── ode_simple_check.cpp
│ │ └── test.sh.in
│ ├── speed/
│ │ ├── CMakeLists.txt
│ │ ├── ode_speed.cpp
│ │ ├── speed.cpp
│ │ └── test.sh.in
│ ├── src/
│ │ ├── CMakeLists.txt
│ │ ├── cppad_ipopt_nlp.cpp
│ │ ├── cppad_ipopt_nlp.hpp
│ │ ├── fun_record.hpp
│ │ ├── hes_fg_map.cpp
│ │ ├── hes_fg_map.hpp
│ │ ├── jac_g_map.cpp
│ │ ├── jac_g_map.hpp
│ │ ├── sparse_map2vec.cpp
│ │ ├── sparse_map2vec.hpp
│ │ ├── vec_fun_pattern.cpp
│ │ └── vec_fun_pattern.hpp
│ └── test/
│ ├── CMakeLists.txt
│ ├── k_gt_one.cpp
│ ├── multiple_solution.cpp
│ ├── retape_k1_l1.cpp
│ ├── retape_k1_l2.cpp
│ ├── test.sh.in
│ └── test_more.cpp
├── cppad_lib/
│ ├── CMakeLists.txt
│ ├── code_gen_fun.cpp
│ ├── cpp_graph_op.cpp
│ ├── cppad_colpack.cpp
│ ├── csrc_writer.cpp
│ ├── json_lexer.cpp
│ ├── json_parser.cpp
│ ├── json_writer.cpp
│ ├── link_dll_lib.cpp
│ └── temp_file.cpp
├── epl-2.0.txt
├── example/
│ ├── CMakeLists.txt
│ ├── abs_normal/
│ │ ├── CMakeLists.txt
│ │ ├── abs_eval.cpp
│ │ ├── abs_eval.hpp
│ │ ├── abs_eval.xrst
│ │ ├── abs_min_linear.cpp
│ │ ├── abs_min_linear.hpp
│ │ ├── abs_min_linear.xrst
│ │ ├── abs_min_quad.cpp
│ │ ├── abs_min_quad.hpp
│ │ ├── abs_min_quad.xrst
│ │ ├── abs_normal.cpp
│ │ ├── abs_normal.xrst
│ │ ├── abs_print_mat.hpp
│ │ ├── get_started.cpp
│ │ ├── lp_box.cpp
│ │ ├── lp_box.hpp
│ │ ├── lp_box.xrst
│ │ ├── min_nso_linear.cpp
│ │ ├── min_nso_linear.hpp
│ │ ├── min_nso_linear.xrst
│ │ ├── min_nso_quad.cpp
│ │ ├── min_nso_quad.hpp
│ │ ├── min_nso_quad.xrst
│ │ ├── qp_box.cpp
│ │ ├── qp_box.hpp
│ │ ├── qp_box.xrst
│ │ ├── qp_interior.cpp
│ │ ├── qp_interior.hpp
│ │ ├── qp_interior.xrst
│ │ ├── simplex_method.cpp
│ │ ├── simplex_method.hpp
│ │ ├── simplex_method.xrst
│ │ └── talk.tex
│ ├── atomic_four/
│ │ ├── CMakeLists.txt
│ │ ├── atomic_four.cpp
│ │ ├── atomic_four.xrst
│ │ ├── bilinear.cpp
│ │ ├── dynamic.cpp
│ │ ├── forward.cpp
│ │ ├── get_started.cpp
│ │ ├── lin_ode/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── forward.cpp
│ │ │ ├── lin_ode.cpp
│ │ │ ├── rev_depend.cpp
│ │ │ ├── reverse.cpp
│ │ │ └── sparsity.cpp
│ │ ├── mat_mul/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── forward.cpp
│ │ │ ├── identical_zero.cpp
│ │ │ ├── mat_mul.cpp
│ │ │ ├── rev_depend.cpp
│ │ │ ├── reverse.cpp
│ │ │ └── sparsity.cpp
│ │ ├── norm_sq.cpp
│ │ └── vector/
│ │ ├── CMakeLists.txt
│ │ ├── add.cpp
│ │ ├── div.cpp
│ │ ├── hes_sparsity.cpp
│ │ ├── jac_sparsity.cpp
│ │ ├── mul.cpp
│ │ ├── neg.cpp
│ │ ├── rev_depend.cpp
│ │ ├── sub.cpp
│ │ └── vector.cpp
│ ├── atomic_three/
│ │ ├── CMakeLists.txt
│ │ ├── atomic_three.cpp
│ │ ├── atomic_three.xrst
│ │ ├── base2ad.cpp
│ │ ├── dynamic.cpp
│ │ ├── forward.cpp
│ │ ├── get_started.cpp
│ │ ├── hes_sparsity.cpp
│ │ ├── jac_sparsity.cpp
│ │ ├── mat_mul.cpp
│ │ ├── norm_sq.cpp
│ │ ├── reciprocal.cpp
│ │ ├── rev_depend.cpp
│ │ ├── reverse.cpp
│ │ └── tangent.cpp
│ ├── atomic_two/
│ │ ├── CMakeLists.txt
│ │ ├── atomic_two.cpp
│ │ ├── eigen_cholesky.cpp
│ │ ├── eigen_mat_inv.cpp
│ │ └── eigen_mat_mul.cpp
│ ├── chkpoint_two/
│ │ ├── CMakeLists.txt
│ │ ├── base2ad.cpp
│ │ ├── chkpoint_two.cpp
│ │ ├── compare.cpp
│ │ ├── dynamic.cpp
│ │ ├── get_started.cpp
│ │ └── ode.cpp
│ ├── compare_change/
│ │ ├── CMakeLists.txt
│ │ └── compare_change.cpp
│ ├── cppad_code_gen/
│ │ ├── CMakeLists.txt
│ │ ├── cppad_code_gen.cpp
│ │ ├── file.cpp
│ │ ├── function.cpp
│ │ ├── jac_as_fun.cpp
│ │ ├── jacobian.cpp
│ │ ├── sparse_jac_as_fun.cpp
│ │ └── sparse_jacobian.cpp
│ ├── general/
│ │ ├── CMakeLists.txt
│ │ ├── abort_recording.cpp
│ │ ├── acos.cpp
│ │ ├── acosh.cpp
│ │ ├── ad_assign.cpp
│ │ ├── ad_ctor.cpp
│ │ ├── ad_fun.cpp
│ │ ├── ad_in_c.cpp
│ │ ├── ad_input.cpp
│ │ ├── ad_output.cpp
│ │ ├── add.cpp
│ │ ├── add_eq.cpp
│ │ ├── asin.cpp
│ │ ├── asinh.cpp
│ │ ├── atan.cpp
│ │ ├── atan2.cpp
│ │ ├── atanh.cpp
│ │ ├── azmul.cpp
│ │ ├── base2ad.cpp
│ │ ├── base2vec_ad.cpp
│ │ ├── base_alloc.hpp
│ │ ├── base_require.cpp
│ │ ├── bender_quad.cpp
│ │ ├── bool_fun.cpp
│ │ ├── capacity_order.cpp
│ │ ├── change_param.cpp
│ │ ├── check_for_nan.cpp
│ │ ├── compare.cpp
│ │ ├── complex_poly.cpp
│ │ ├── con_dyn_var.cpp
│ │ ├── cond_exp.cpp
│ │ ├── cos.cpp
│ │ ├── cosh.cpp
│ │ ├── div.cpp
│ │ ├── div_eq.cpp
│ │ ├── eigen_array.cpp
│ │ ├── eigen_det.cpp
│ │ ├── equal_op_seq.cpp
│ │ ├── erf.cpp
│ │ ├── erfc.cpp
│ │ ├── exp.cpp
│ │ ├── expm1.cpp
│ │ ├── fabs.cpp
│ │ ├── for_one.cpp
│ │ ├── for_two.cpp
│ │ ├── forward.cpp
│ │ ├── forward_dir.cpp
│ │ ├── forward_order.cpp
│ │ ├── fun_assign.cpp
│ │ ├── fun_check.cpp
│ │ ├── fun_property.cpp
│ │ ├── function_name.cpp
│ │ ├── general.cpp
│ │ ├── hes_lagrangian.cpp
│ │ ├── hes_lu_det.cpp
│ │ ├── hes_minor_det.cpp
│ │ ├── hes_times_dir.cpp
│ │ ├── hessian.cpp
│ │ ├── independent.cpp
│ │ ├── integer.cpp
│ │ ├── interface2c.cpp
│ │ ├── interp_onetape.cpp
│ │ ├── interp_retape.cpp
│ │ ├── jac_lu_det.cpp
│ │ ├── jac_minor_det.cpp
│ │ ├── jacobian.cpp
│ │ ├── log.cpp
│ │ ├── log10.cpp
│ │ ├── log1p.cpp
│ │ ├── lu_ratio.cpp
│ │ ├── lu_vec_ad.cpp
│ │ ├── lu_vec_ad.hpp
│ │ ├── lu_vec_ad_ok.cpp
│ │ ├── mul.cpp
│ │ ├── mul_eq.cpp
│ │ ├── mul_level.cpp
│ │ ├── mul_level_adolc.cpp
│ │ ├── mul_level_adolc_ode.cpp
│ │ ├── mul_level_ode.cpp
│ │ ├── near_equal_ext.cpp
│ │ ├── new_dynamic.cpp
│ │ ├── num_limits.cpp
│ │ ├── number_skip.cpp
│ │ ├── numeric_type.cpp
│ │ ├── ode_stiff.cpp
│ │ ├── opt_val_hes.cpp
│ │ ├── pow.cpp
│ │ ├── pow_nan.cpp
│ │ ├── print_for.cpp
│ │ ├── rev_checkpoint.cpp
│ │ ├── rev_one.cpp
│ │ ├── rev_two.cpp
│ │ ├── reverse_one.cpp
│ │ ├── reverse_three.cpp
│ │ ├── reverse_two.cpp
│ │ ├── sign.cpp
│ │ ├── sin.cpp
│ │ ├── sinh.cpp
│ │ ├── sqrt.cpp
│ │ ├── stack_machine.cpp
│ │ ├── sub.cpp
│ │ ├── sub_eq.cpp
│ │ ├── tan.cpp
│ │ ├── tanh.cpp
│ │ ├── tape_index.cpp
│ │ ├── taylor_ode.cpp
│ │ ├── unary_minus.cpp
│ │ ├── unary_plus.cpp
│ │ ├── value.cpp
│ │ ├── var2par.cpp
│ │ └── vec_ad.cpp
│ ├── get_started/
│ │ ├── CMakeLists.txt
│ │ └── get_started.cpp
│ ├── graph/
│ │ ├── CMakeLists.txt
│ │ ├── add_op.cpp
│ │ ├── atom4_op.cpp
│ │ ├── atom_op.cpp
│ │ ├── azmul_op.cpp
│ │ ├── cexp_op.cpp
│ │ ├── comp_op.cpp
│ │ ├── discrete_op.cpp
│ │ ├── div_op.cpp
│ │ ├── graph.cpp
│ │ ├── mul_op.cpp
│ │ ├── pow_op.cpp
│ │ ├── print_graph.cpp
│ │ ├── print_op.cpp
│ │ ├── sub_op.cpp
│ │ ├── sum_op.cpp
│ │ ├── switch_var_dyn.cpp
│ │ └── unary_op.cpp
│ ├── ipopt_solve/
│ │ ├── CMakeLists.txt
│ │ ├── get_started.cpp
│ │ ├── ipopt_solve.cpp
│ │ ├── ode_inverse.cpp
│ │ ├── retape.cpp
│ │ └── test.sh.in
│ ├── jit/
│ │ ├── CMakeLists.txt
│ │ ├── atomic.cpp
│ │ ├── compare_change.cpp
│ │ ├── compile.cpp
│ │ ├── dynamic.cpp
│ │ ├── get_started.cpp
│ │ ├── jit.cpp
│ │ └── jit.xrst
│ ├── json/
│ │ ├── CMakeLists.txt
│ │ ├── add_op.cpp
│ │ ├── atom4_op.cpp
│ │ ├── atom_op.cpp
│ │ ├── azmul_op.cpp
│ │ ├── cexp_op.cpp
│ │ ├── comp_op.cpp
│ │ ├── discrete_op.cpp
│ │ ├── div_op.cpp
│ │ ├── from_json.cpp
│ │ ├── get_started.cpp
│ │ ├── json.cpp
│ │ ├── mul_op.cpp
│ │ ├── pow_op.cpp
│ │ ├── print_op.cpp
│ │ ├── sparse.cpp
│ │ ├── sub_op.cpp
│ │ ├── sum_op.cpp
│ │ ├── to_json.cpp
│ │ └── unary_op.cpp
│ ├── multi_thread/
│ │ ├── CMakeLists.txt
│ │ ├── bthread/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── a11c_bthread.cpp
│ │ │ ├── get_started.cpp
│ │ │ └── team_bthread.cpp
│ │ ├── harmonic.cpp
│ │ ├── harmonic.hpp
│ │ ├── harmonic.xrst
│ │ ├── multi_atomic_three.cpp
│ │ ├── multi_atomic_three.hpp
│ │ ├── multi_atomic_three.xrst
│ │ ├── multi_atomic_two.cpp
│ │ ├── multi_atomic_two.hpp
│ │ ├── multi_atomic_two.xrst
│ │ ├── multi_chkpoint_one.cpp
│ │ ├── multi_chkpoint_one.hpp
│ │ ├── multi_chkpoint_one.xrst
│ │ ├── multi_chkpoint_two.cpp
│ │ ├── multi_chkpoint_two.hpp
│ │ ├── multi_chkpoint_two.xrst
│ │ ├── multi_newton.cpp
│ │ ├── multi_newton.hpp
│ │ ├── multi_newton.xrst
│ │ ├── openmp/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── a11c_openmp.cpp
│ │ │ ├── get_started.cpp
│ │ │ └── team_openmp.cpp
│ │ ├── pthread/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── a11c_pthread.cpp
│ │ │ ├── get_started.cpp
│ │ │ └── team_pthread.cpp
│ │ ├── sthread/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── a11c_sthread.cpp
│ │ │ ├── get_started.cpp
│ │ │ └── team_sthread.cpp
│ │ ├── team_example.cpp
│ │ ├── team_example.hpp
│ │ ├── team_thread.hpp
│ │ ├── template/
│ │ │ └── get_started.xrst
│ │ └── thread_test.cpp
│ ├── optimize/
│ │ ├── CMakeLists.txt
│ │ ├── compare_op.cpp
│ │ ├── conditional_skip.cpp
│ │ ├── cumulative_sum.cpp
│ │ ├── forward_active.cpp
│ │ ├── nest_conditional.cpp
│ │ ├── optimize.cpp
│ │ ├── optimize_twice.cpp
│ │ ├── print_for.cpp
│ │ └── reverse_active.cpp
│ ├── print_for/
│ │ ├── CMakeLists.txt
│ │ ├── print_for.cpp
│ │ └── test.sh
│ ├── sparse/
│ │ ├── CMakeLists.txt
│ │ ├── colpack_hes.cpp
│ │ ├── colpack_hessian.cpp
│ │ ├── colpack_jac.cpp
│ │ ├── colpack_jacobian.cpp
│ │ ├── conj_grad.cpp
│ │ ├── dependency.cpp
│ │ ├── for_hes_sparsity.cpp
│ │ ├── for_jac_sparsity.cpp
│ │ ├── for_sparse_hes.cpp
│ │ ├── for_sparse_jac.cpp
│ │ ├── rc_sparsity.cpp
│ │ ├── rev_hes_sparsity.cpp
│ │ ├── rev_jac_sparsity.cpp
│ │ ├── rev_sparse_hes.cpp
│ │ ├── rev_sparse_jac.cpp
│ │ ├── sparse.cpp
│ │ ├── sparse2eigen.cpp
│ │ ├── sparse_hes.cpp
│ │ ├── sparse_hessian.cpp
│ │ ├── sparse_jac_for.cpp
│ │ ├── sparse_jac_rev.cpp
│ │ ├── sparse_jacobian.cpp
│ │ ├── sparse_sub_hes.cpp
│ │ ├── sparsity_sub.cpp
│ │ ├── sub_sparse_hes.cpp
│ │ ├── subgraph_hes2jac.cpp
│ │ ├── subgraph_jac_rev.cpp
│ │ ├── subgraph_reverse.cpp
│ │ └── subgraph_sparsity.cpp
│ ├── utility/
│ │ ├── CMakeLists.txt
│ │ ├── check_numeric_type.cpp
│ │ ├── check_simple_vector.cpp
│ │ ├── cppad_vector.cpp
│ │ ├── dll_lib.cpp
│ │ ├── error_handler.cpp
│ │ ├── index_sort.cpp
│ │ ├── lu_factor.cpp
│ │ ├── lu_invert.cpp
│ │ ├── lu_solve.cpp
│ │ ├── nan.cpp
│ │ ├── near_equal.cpp
│ │ ├── ode_err_control.cpp
│ │ ├── ode_err_maxabs.cpp
│ │ ├── ode_gear.cpp
│ │ ├── ode_gear_control.cpp
│ │ ├── poly.cpp
│ │ ├── pow_int.cpp
│ │ ├── romberg_mul.cpp
│ │ ├── romberg_one.cpp
│ │ ├── rosen_34.cpp
│ │ ├── runge45_1.cpp
│ │ ├── runge_45.cpp
│ │ ├── set_union.cpp
│ │ ├── simple_vector.cpp
│ │ ├── sparse_rc.cpp
│ │ ├── sparse_rcv.cpp
│ │ ├── thread_alloc.cpp
│ │ ├── to_string.cpp
│ │ ├── utility.cpp
│ │ └── vector_bool.cpp
│ └── valvector/
│ ├── CMakeLists.txt
│ ├── ad_join.cpp
│ ├── ad_split.cpp
│ ├── ad_sum.cpp
│ ├── assign.cpp
│ ├── azmul.cpp
│ ├── base_require.cpp
│ ├── binary_op.cpp
│ ├── compare_op.cpp
│ ├── compound_op.cpp
│ ├── condexp.cpp
│ ├── ctor.cpp
│ ├── element.cpp
│ ├── get_started.cpp
│ ├── llsq_obj.cpp
│ ├── output.cpp
│ ├── pow.cpp
│ ├── resize.cpp
│ ├── size.cpp
│ ├── sum.cpp
│ ├── unary_math.cpp
│ ├── unary_op.cpp
│ └── valvector.cpp
├── include/
│ └── cppad/
│ ├── CMakeLists.txt
│ ├── base_require.hpp
│ ├── configure.hpp.in
│ ├── core/
│ │ ├── abort_recording.hpp
│ │ ├── abs.hpp
│ │ ├── abs_normal_fun.hpp
│ │ ├── ad.hpp
│ │ ├── ad_assign.hpp
│ │ ├── ad_binary.hpp
│ │ ├── ad_ctor.hpp
│ │ ├── ad_fun.hpp
│ │ ├── ad_fun.xrst
│ │ ├── ad_io.hpp
│ │ ├── ad_to_string.hpp
│ │ ├── ad_type.hpp
│ │ ├── ad_valued.hpp
│ │ ├── add.hpp
│ │ ├── add_eq.hpp
│ │ ├── arithmetic.hpp
│ │ ├── atan2.hpp
│ │ ├── atomic/
│ │ │ ├── atomic.xrst
│ │ │ ├── four/
│ │ │ │ ├── atomic.hpp
│ │ │ │ ├── atomic.xrst
│ │ │ │ ├── call.hpp
│ │ │ │ ├── ctor.hpp
│ │ │ │ ├── devel/
│ │ │ │ │ ├── devel.xrst
│ │ │ │ │ ├── hes_sparsity.hpp
│ │ │ │ │ └── jac_sparsity.hpp
│ │ │ │ ├── for_type.hpp
│ │ │ │ ├── forward.hpp
│ │ │ │ ├── hes_sparsity.hpp
│ │ │ │ ├── jac_sparsity.hpp
│ │ │ │ ├── rev_depend.hpp
│ │ │ │ └── reverse.hpp
│ │ │ ├── one/
│ │ │ │ └── atomic.hpp
│ │ │ ├── three/
│ │ │ │ ├── afun.hpp
│ │ │ │ ├── atomic.hpp
│ │ │ │ ├── atomic.xrst
│ │ │ │ ├── ctor.hpp
│ │ │ │ ├── for_type.hpp
│ │ │ │ ├── forward.hpp
│ │ │ │ ├── hes_sparsity.hpp
│ │ │ │ ├── jac_sparsity.hpp
│ │ │ │ ├── rev_depend.hpp
│ │ │ │ └── reverse.hpp
│ │ │ └── two/
│ │ │ ├── afun.hpp
│ │ │ ├── atomic.hpp
│ │ │ ├── clear.hpp
│ │ │ ├── ctor.hpp
│ │ │ ├── for_sparse_hes.hpp
│ │ │ ├── for_sparse_jac.hpp
│ │ │ ├── forward.hpp
│ │ │ ├── option.hpp
│ │ │ ├── rev_depend.hpp
│ │ │ ├── rev_sparse_hes.hpp
│ │ │ ├── rev_sparse_jac.hpp
│ │ │ └── reverse.hpp
│ │ ├── azmul.hpp
│ │ ├── base2ad.hpp
│ │ ├── base_complex.hpp
│ │ ├── base_cond_exp.hpp
│ │ ├── base_double.hpp
│ │ ├── base_float.hpp
│ │ ├── base_hash.hpp
│ │ ├── base_limits.hpp
│ │ ├── base_std_math.hpp
│ │ ├── base_to_string.hpp
│ │ ├── bender_quad.hpp
│ │ ├── bool_fun.hpp
│ │ ├── bool_valued.hpp
│ │ ├── capacity_order.hpp
│ │ ├── check_for_nan.hpp
│ │ ├── chkpoint_one/
│ │ │ ├── chkpoint_one.hpp
│ │ │ ├── ctor.hpp
│ │ │ ├── for_sparse_jac.hpp
│ │ │ ├── forward.hpp
│ │ │ ├── rev_sparse_hes.hpp
│ │ │ ├── rev_sparse_jac.hpp
│ │ │ ├── reverse.hpp
│ │ │ ├── set_hes_sparse_bool.hpp
│ │ │ ├── set_hes_sparse_set.hpp
│ │ │ ├── set_jac_sparse_bool.hpp
│ │ │ └── set_jac_sparse_set.hpp
│ │ ├── chkpoint_two/
│ │ │ ├── chk_fun.xrst
│ │ │ ├── chkpoint_two.hpp
│ │ │ ├── ctor.hpp
│ │ │ ├── dynamic.hpp
│ │ │ ├── for_type.hpp
│ │ │ ├── forward.hpp
│ │ │ ├── hes_sparsity.hpp
│ │ │ ├── jac_sparsity.hpp
│ │ │ ├── rev_depend.hpp
│ │ │ └── reverse.hpp
│ │ ├── compare.hpp
│ │ ├── compound_assign.hpp
│ │ ├── con_dyn_var.hpp
│ │ ├── cond_exp.hpp
│ │ ├── convert.hpp
│ │ ├── cppad_assert.hpp
│ │ ├── dependent.hpp
│ │ ├── discrete/
│ │ │ ├── devel.xrst
│ │ │ ├── discrete.hpp
│ │ │ └── user.xrst
│ │ ├── div.hpp
│ │ ├── div_eq.hpp
│ │ ├── drivers.hpp
│ │ ├── epsilon.hpp
│ │ ├── equal_op_seq.hpp
│ │ ├── for_hes_sparsity.hpp
│ │ ├── for_jac_sparsity.hpp
│ │ ├── for_one.hpp
│ │ ├── for_sparse_hes.hpp
│ │ ├── for_sparse_jac.hpp
│ │ ├── for_two.hpp
│ │ ├── forward/
│ │ │ ├── compare_change.xrst
│ │ │ ├── devel.xrst
│ │ │ ├── forward.hpp
│ │ │ ├── forward_dir.xrst
│ │ │ ├── forward_one.xrst
│ │ │ ├── forward_order.xrst
│ │ │ ├── forward_two.xrst
│ │ │ ├── forward_zero.xrst
│ │ │ └── size_order.xrst
│ │ ├── fun_check.hpp
│ │ ├── fun_construct.hpp
│ │ ├── fun_eval.hpp
│ │ ├── fun_property.xrst
│ │ ├── function_name.xrst
│ │ ├── graph/
│ │ │ ├── cpp_ad_graph.xrst
│ │ │ ├── cpp_graph.hpp
│ │ │ ├── cpp_graph.xrst
│ │ │ ├── from_graph.hpp
│ │ │ ├── from_json.hpp
│ │ │ ├── graph_op_enum.hpp
│ │ │ ├── json_ad_graph.xrst
│ │ │ ├── json_graph_op.xrst
│ │ │ ├── to_graph.hpp
│ │ │ └── to_json.hpp
│ │ ├── hash_code.hpp
│ │ ├── hessian.hpp
│ │ ├── identical.hpp
│ │ ├── independent/
│ │ │ ├── devel.xrst
│ │ │ ├── independent.hpp
│ │ │ └── user.xrst
│ │ ├── integer.hpp
│ │ ├── jacobian.hpp
│ │ ├── lu_ratio.hpp
│ │ ├── mul.hpp
│ │ ├── mul_eq.hpp
│ │ ├── near_equal_ext.hpp
│ │ ├── new_dynamic.hpp
│ │ ├── num_skip.hpp
│ │ ├── numeric_limits.hpp
│ │ ├── omp_max_thread.hpp
│ │ ├── opt_val_hes.hpp
│ │ ├── optimize.hpp
│ │ ├── ordered.hpp
│ │ ├── parallel_ad.hpp
│ │ ├── pow.hpp
│ │ ├── print_for.hpp
│ │ ├── rev_hes_sparsity.hpp
│ │ ├── rev_jac_sparsity.hpp
│ │ ├── rev_one.hpp
│ │ ├── rev_sparse_hes.hpp
│ │ ├── rev_sparse_jac.hpp
│ │ ├── rev_two.hpp
│ │ ├── reverse.hpp
│ │ ├── sign.hpp
│ │ ├── sparse.hpp
│ │ ├── sparse_hes.hpp
│ │ ├── sparse_hessian.hpp
│ │ ├── sparse_jac.hpp
│ │ ├── sparse_jacobian.hpp
│ │ ├── standard_math.hpp
│ │ ├── std_math_11.hpp
│ │ ├── sub.hpp
│ │ ├── sub_eq.hpp
│ │ ├── subgraph_jac_rev.hpp
│ │ ├── subgraph_reverse.hpp
│ │ ├── subgraph_sparsity.hpp
│ │ ├── tape_link.hpp
│ │ ├── testvector.hpp
│ │ ├── to_csrc.hpp
│ │ ├── unary_minus.hpp
│ │ ├── unary_plus.hpp
│ │ ├── undef.hpp
│ │ ├── user_ad.hpp
│ │ ├── value.hpp
│ │ ├── var2par.hpp
│ │ ├── vec_ad/
│ │ │ ├── user.xrst
│ │ │ └── vec_ad.hpp
│ │ └── zdouble.hpp
│ ├── cppad.hpp
│ ├── example/
│ │ ├── atomic_four/
│ │ │ ├── lin_ode/
│ │ │ │ ├── base_solver.hpp
│ │ │ │ ├── for_type.hpp
│ │ │ │ ├── forward.hpp
│ │ │ │ ├── get.hpp
│ │ │ │ ├── hes_sparsity.hpp
│ │ │ │ ├── implement.xrst
│ │ │ │ ├── jac_sparsity.hpp
│ │ │ │ ├── lin_ode.hpp
│ │ │ │ ├── lin_ode.xrst
│ │ │ │ ├── rev_depend.hpp
│ │ │ │ ├── reverse.hpp
│ │ │ │ ├── reverse_2.xrst
│ │ │ │ └── set.hpp
│ │ │ ├── mat_mul/
│ │ │ │ ├── base_mat_mul.hpp
│ │ │ │ ├── for_type.hpp
│ │ │ │ ├── forward.hpp
│ │ │ │ ├── get.hpp
│ │ │ │ ├── hes_sparsity.hpp
│ │ │ │ ├── implement.xrst
│ │ │ │ ├── jac_sparsity.hpp
│ │ │ │ ├── mat_mul.hpp
│ │ │ │ ├── mat_mul.xrst
│ │ │ │ ├── rev_depend.hpp
│ │ │ │ ├── reverse.hpp
│ │ │ │ └── set.hpp
│ │ │ └── vector/
│ │ │ ├── add_op.hpp
│ │ │ ├── div_op.hpp
│ │ │ ├── for_type.hpp
│ │ │ ├── forward_op.hpp
│ │ │ ├── hes_sparsity.hpp
│ │ │ ├── implement.xrst
│ │ │ ├── jac_sparsity.hpp
│ │ │ ├── mul_op.hpp
│ │ │ ├── neg_op.hpp
│ │ │ ├── rev_depend.hpp
│ │ │ ├── reverse_op.hpp
│ │ │ ├── sub_op.hpp
│ │ │ ├── vector.hpp
│ │ │ └── vector.xrst
│ │ ├── atomic_three/
│ │ │ └── mat_mul.hpp
│ │ ├── atomic_two/
│ │ │ ├── eigen_cholesky.hpp
│ │ │ ├── eigen_mat_inv.hpp
│ │ │ └── eigen_mat_mul.hpp
│ │ ├── base_adolc.hpp
│ │ ├── code_gen_fun.hpp
│ │ ├── cppad_eigen.hpp
│ │ ├── eigen_plugin.hpp
│ │ └── valvector/
│ │ ├── class.hpp
│ │ ├── split_join.hpp
│ │ └── sum.hpp
│ ├── ipopt/
│ │ ├── solve.hpp
│ │ ├── solve_callback.hpp
│ │ └── solve_result.hpp
│ ├── local/
│ │ ├── ad_tape.hpp
│ │ ├── atom_state.hpp
│ │ ├── atomic_index.hpp
│ │ ├── color_general.hpp
│ │ ├── color_symmetric.hpp
│ │ ├── cppad_colpack.hpp
│ │ ├── declare_ad.hpp
│ │ ├── define.hpp
│ │ ├── graph/
│ │ │ ├── cpp_graph_itr.hpp
│ │ │ ├── cpp_graph_itr.xrst
│ │ │ ├── cpp_graph_op.hpp
│ │ │ ├── csrc_writer.hpp
│ │ │ ├── json_lexer.hpp
│ │ │ ├── json_lexer.xrst
│ │ │ ├── json_parser.hpp
│ │ │ └── json_writer.hpp
│ │ ├── hash_code.hpp
│ │ ├── independent.hpp
│ │ ├── is_pod.hpp
│ │ ├── is_pod.hpp.in
│ │ ├── op_code_dyn.hpp
│ │ ├── op_code_var.hpp
│ │ ├── optimize/
│ │ │ ├── cexp_info.hpp
│ │ │ ├── csum_op_info.hpp
│ │ │ ├── csum_stacks.hpp
│ │ │ ├── extract_option.hpp
│ │ │ ├── get_cexp_info.hpp
│ │ │ ├── get_dyn_previous.hpp
│ │ │ ├── get_op_previous.hpp
│ │ │ ├── get_op_usage.hpp
│ │ │ ├── get_par_usage.hpp
│ │ │ ├── hash_code.hpp
│ │ │ ├── match_op.hpp
│ │ │ ├── optimize_run.hpp
│ │ │ ├── record_csum.hpp
│ │ │ ├── record_pv.hpp
│ │ │ ├── record_vp.hpp
│ │ │ ├── record_vv.hpp
│ │ │ ├── size_pair.hpp
│ │ │ └── usage.hpp
│ │ ├── play/
│ │ │ ├── addr_enum.hpp
│ │ │ ├── atom_op_info.hpp
│ │ │ ├── dyn_player.hpp
│ │ │ ├── player.hpp
│ │ │ ├── random_iterator.hpp
│ │ │ ├── random_setup.hpp
│ │ │ ├── sequential_iterator.hpp
│ │ │ └── subgraph_iterator.hpp
│ │ ├── pod_vector.hpp
│ │ ├── record/
│ │ │ ├── comp_op.hpp
│ │ │ ├── cond_exp.hpp
│ │ │ ├── dyn_recorder.hpp
│ │ │ ├── put_dyn_atomic.hpp
│ │ │ ├── put_var_atomic.hpp
│ │ │ ├── put_var_vecad.hpp
│ │ │ └── recorder.hpp
│ │ ├── set_get_in_parallel.hpp
│ │ ├── sparse/
│ │ │ ├── dev_sparse.xrst
│ │ │ ├── internal.hpp
│ │ │ ├── list_setvec.hpp
│ │ │ ├── pack_setvec.hpp
│ │ │ ├── pack_setvec.xrst
│ │ │ ├── setvector.xrst
│ │ │ ├── size_setvec.hpp
│ │ │ └── svec_setvec.hpp
│ │ ├── std_set.hpp
│ │ ├── subgraph/
│ │ │ ├── arg_variable.hpp
│ │ │ ├── entire_call.hpp
│ │ │ ├── get_rev.hpp
│ │ │ ├── info.hpp
│ │ │ ├── init_rev.hpp
│ │ │ └── sparsity.hpp
│ │ ├── sweep/
│ │ │ ├── call_atomic.hpp
│ │ │ ├── dev_sweep.xrst
│ │ │ ├── dynamic.hpp
│ │ │ ├── for_hes.hpp
│ │ │ ├── for_jac.hpp
│ │ │ ├── forward_0.hpp
│ │ │ ├── forward_any.hpp
│ │ │ ├── forward_dir.hpp
│ │ │ ├── rev_hes.hpp
│ │ │ ├── rev_jac.hpp
│ │ │ ├── reverse.hpp
│ │ │ └── template/
│ │ │ └── forward_sweep.xrst
│ │ ├── temp_file.hpp
│ │ ├── utility/
│ │ │ ├── cppad_vector_itr.hpp
│ │ │ └── vector_bool.hpp
│ │ ├── val_graph/
│ │ │ ├── base_op.hpp
│ │ │ ├── binary_op.hpp
│ │ │ ├── call_atomic.hpp
│ │ │ ├── call_op.hpp
│ │ │ ├── cexp_op.hpp
│ │ │ ├── comp_op.hpp
│ │ │ ├── compress.hpp
│ │ │ ├── con_op.hpp
│ │ │ ├── csum_op.hpp
│ │ │ ├── cumulative.hpp
│ │ │ ├── dead_code.hpp
│ │ │ ├── dis_op.hpp
│ │ │ ├── dyn_type.hpp
│ │ │ ├── enable_parallel.hpp
│ │ │ ├── fold_con.hpp
│ │ │ ├── fun2val.hpp
│ │ │ ├── op2arg_index.hpp
│ │ │ ├── op_enum2class.hpp
│ │ │ ├── op_hash_table.hpp
│ │ │ ├── op_iterator.hpp
│ │ │ ├── option.hpp
│ │ │ ├── pri_op.hpp
│ │ │ ├── print_op.hpp
│ │ │ ├── record.hpp
│ │ │ ├── record_new.hpp
│ │ │ ├── renumber.hpp
│ │ │ ├── rev_depend.hpp
│ │ │ ├── summation.hpp
│ │ │ ├── tape.hpp
│ │ │ ├── unary_op.hpp
│ │ │ ├── val2fun.hpp
│ │ │ ├── val_graph.xrst
│ │ │ ├── val_optimize.hpp
│ │ │ ├── val_type.hpp
│ │ │ ├── var_type.hpp
│ │ │ └── vector_op.hpp
│ │ └── var_op/
│ │ ├── abs_op.hpp
│ │ ├── acos_op.hpp
│ │ ├── acosh_op.hpp
│ │ ├── add_op.hpp
│ │ ├── asin_op.hpp
│ │ ├── asinh_op.hpp
│ │ ├── atan_op.hpp
│ │ ├── atanh_op.hpp
│ │ ├── atomic_op.hpp
│ │ ├── binary_op.xrst
│ │ ├── cexp_op.hpp
│ │ ├── compare_op.hpp
│ │ ├── cos_op.hpp
│ │ ├── cosh_op.hpp
│ │ ├── cskip_op.hpp
│ │ ├── csum_op.hpp
│ │ ├── dis_op.hpp
│ │ ├── div_op.hpp
│ │ ├── erf_op.hpp
│ │ ├── exp_op.hpp
│ │ ├── expm1_op.hpp
│ │ ├── load_op.hpp
│ │ ├── log1p_op.hpp
│ │ ├── log_op.hpp
│ │ ├── mul_op.hpp
│ │ ├── neg_op.hpp
│ │ ├── one_var.hpp
│ │ ├── par_op.hpp
│ │ ├── pow_op.hpp
│ │ ├── pri_op.hpp
│ │ ├── prototype_op.hpp
│ │ ├── sign_op.hpp
│ │ ├── sin_op.hpp
│ │ ├── sinh_op.hpp
│ │ ├── sqrt_op.hpp
│ │ ├── store_op.hpp
│ │ ├── sub_op.hpp
│ │ ├── tan_op.hpp
│ │ ├── tanh_op.hpp
│ │ ├── template/
│ │ │ ├── atomic_op.xrst
│ │ │ ├── forward_dir.xrst
│ │ │ ├── forward_op.xrst
│ │ │ └── reverse_op.xrst
│ │ ├── two_var.hpp
│ │ ├── unary_op.xrst
│ │ ├── var_op.hpp
│ │ └── zmul_op.hpp
│ ├── speed/
│ │ ├── det_33.hpp
│ │ ├── det_by_lu.hpp
│ │ ├── det_by_minor.hpp
│ │ ├── det_grad_33.hpp
│ │ ├── det_of_minor.hpp
│ │ ├── mat_sum_sq.hpp
│ │ ├── ode_evaluate.hpp
│ │ ├── sparse_hes_fun.hpp
│ │ ├── sparse_jac_fun.hpp
│ │ └── uniform_01.hpp
│ ├── utility/
│ │ ├── check_numeric_type.hpp
│ │ ├── check_simple_vector.hpp
│ │ ├── create_dll_lib.hpp
│ │ ├── elapsed_seconds.hpp
│ │ ├── error_handler.hpp
│ │ ├── index_sort.hpp
│ │ ├── link_dll_lib.hpp
│ │ ├── lu_factor.hpp
│ │ ├── lu_invert.hpp
│ │ ├── lu_solve.hpp
│ │ ├── memory_leak.hpp
│ │ ├── nan.hpp
│ │ ├── near_equal.hpp
│ │ ├── ode_err_control.hpp
│ │ ├── ode_gear.hpp
│ │ ├── ode_gear_control.hpp
│ │ ├── omp_alloc.hpp
│ │ ├── poly.hpp
│ │ ├── pow_int.hpp
│ │ ├── romberg_mul.hpp
│ │ ├── romberg_one.hpp
│ │ ├── rosen_34.hpp
│ │ ├── runge_45.hpp
│ │ ├── set_union.hpp
│ │ ├── sparse2eigen.hpp
│ │ ├── sparse_rc.hpp
│ │ ├── sparse_rcv.hpp
│ │ ├── speed_test.hpp
│ │ ├── test_boolofvoid.hpp
│ │ ├── thread_alloc.hpp
│ │ ├── time_test.hpp
│ │ ├── to_string.hpp
│ │ ├── track_new_del.hpp
│ │ ├── vector.hpp
│ │ ├── vector_bool.hpp
│ │ └── xrst/
│ │ ├── cppad_vector.xrst
│ │ ├── dev_cppad_vector.xrst
│ │ ├── dev_utility.xrst
│ │ ├── dev_vector_bool.xrst
│ │ └── utility.xrst
│ ├── utility.hpp
│ └── wno_conversion.hpp
├── introduction/
│ ├── CMakeLists.txt
│ ├── exp_2.cpp
│ ├── exp_2.hpp
│ ├── exp_2.xrst
│ ├── exp_2_cppad.cpp
│ ├── exp_2_for0.cpp
│ ├── exp_2_for1.cpp
│ ├── exp_2_for2.cpp
│ ├── exp_2_rev1.cpp
│ ├── exp_2_rev2.cpp
│ ├── exp_eps.cpp
│ ├── exp_eps.hpp
│ ├── exp_eps.xrst
│ ├── exp_eps_cppad.cpp
│ ├── exp_eps_for0.cpp
│ ├── exp_eps_for1.cpp
│ ├── exp_eps_for2.cpp
│ ├── exp_eps_rev1.cpp
│ ├── exp_eps_rev2.cpp
│ └── introduction.cpp
├── pkgconfig/
│ ├── CMakeLists.txt
│ ├── cppad-uninstalled.pc.in
│ └── cppad.pc.in
├── readme.md
├── speed/
│ ├── CMakeLists.txt
│ ├── add_test.sh
│ ├── adolc/
│ │ ├── CMakeLists.txt
│ │ ├── adolc_alloc_mat.hpp
│ │ ├── adolc_usrparms.sh
│ │ ├── alloc_mat.cpp
│ │ ├── det_lu.cpp
│ │ ├── det_minor.cpp
│ │ ├── mat_mul.cpp
│ │ ├── ode.cpp
│ │ ├── poly.cpp
│ │ ├── sparse_hessian.cpp
│ │ ├── sparse_jacobian.cpp
│ │ └── speed_adolc.xrst
│ ├── cppad/
│ │ ├── CMakeLists.txt
│ │ ├── det_lu.cpp
│ │ ├── det_minor.cpp
│ │ ├── mat_mul.cpp
│ │ ├── ode.cpp
│ │ ├── poly.cpp
│ │ ├── sparse_hessian.cpp
│ │ ├── sparse_jacobian.cpp
│ │ └── speed_cppad.xrst
│ ├── cppad_jit/
│ │ ├── CMakeLists.txt
│ │ ├── det_lu.cpp
│ │ ├── det_minor.cpp
│ │ ├── mat_mul.cpp
│ │ ├── ode.cpp
│ │ ├── poly.cpp
│ │ ├── sparse_hessian.cpp
│ │ ├── sparse_jacobian.cpp
│ │ └── speed_cppad_jit.xrst
│ ├── cppadcg/
│ │ ├── CMakeLists.txt
│ │ ├── det_lu.cpp
│ │ ├── det_minor.cpp
│ │ ├── mat_mul.cpp
│ │ ├── ode.cpp
│ │ ├── poly.cpp
│ │ ├── sparse_hessian.cpp
│ │ ├── sparse_jacobian.cpp
│ │ └── speed_cppadcg.xrst
│ ├── dev_speed.xrst
│ ├── double/
│ │ ├── CMakeLists.txt
│ │ ├── det_lu.cpp
│ │ ├── det_minor.cpp
│ │ ├── mat_mul.cpp
│ │ ├── ode.cpp
│ │ ├── poly.cpp
│ │ ├── sparse_hessian.cpp
│ │ ├── sparse_jacobian.cpp
│ │ └── speed_double.xrst
│ ├── example/
│ │ ├── CMakeLists.txt
│ │ ├── det_by_lu.cpp
│ │ ├── det_by_minor.cpp
│ │ ├── det_of_minor.cpp
│ │ ├── elapsed_seconds.cpp
│ │ ├── example.cpp
│ │ ├── mat_sum_sq.cpp
│ │ ├── ode_evaluate.cpp
│ │ ├── sparse_hes_fun.cpp
│ │ ├── sparse_jac_fun.cpp
│ │ ├── speed_program.cpp
│ │ ├── speed_test.cpp
│ │ └── time_test.cpp
│ ├── fadbad/
│ │ ├── CMakeLists.txt
│ │ ├── det_lu.cpp
│ │ ├── det_minor.cpp
│ │ ├── mat_mul.cpp
│ │ ├── ode.cpp
│ │ ├── poly.cpp
│ │ ├── sparse_hessian.cpp
│ │ ├── sparse_jacobian.cpp
│ │ └── speed_fadbad.xrst
│ ├── main.cpp
│ ├── profile/
│ │ ├── CMakeLists.txt
│ │ └── gprof.sed.in
│ ├── sacado/
│ │ ├── CMakeLists.txt
│ │ ├── det_lu.cpp
│ │ ├── det_minor.cpp
│ │ ├── mat_mul.cpp
│ │ ├── ode.cpp
│ │ ├── poly.cpp
│ │ ├── sparse_hessian.cpp
│ │ ├── sparse_jacobian.cpp
│ │ └── speed_sacado.xrst
│ ├── speed.xrst
│ ├── speed_utility.xrst
│ ├── src/
│ │ ├── CMakeLists.txt
│ │ ├── dev_link.xrst
│ │ ├── dev_sparse_hessian.xrst
│ │ ├── link.xrst
│ │ ├── link_det_lu.cpp
│ │ ├── link_det_minor.cpp
│ │ ├── link_mat_mul.cpp
│ │ ├── link_ode.cpp
│ │ ├── link_poly.cpp
│ │ ├── link_sparse_hessian.cpp
│ │ ├── link_sparse_hessian.hpp
│ │ ├── link_sparse_jacobian.cpp
│ │ └── link_sparse_jacobian.hpp
│ └── xpackage/
│ ├── CMakeLists.txt
│ ├── det_lu.cpp
│ ├── det_minor.cpp
│ ├── mat_mul.cpp
│ ├── ode.cpp
│ ├── poly.cpp
│ ├── sparse_hessian.cpp
│ ├── sparse_jacobian.cpp
│ └── speed_xpackage.xrst
├── test_more/
│ ├── CMakeLists.txt
│ ├── compare_c/
│ │ ├── CMakeLists.txt
│ │ ├── c/
│ │ │ └── CMakeLists.txt
│ │ ├── cpp/
│ │ │ └── CMakeLists.txt
│ │ └── det_by_minor.c
│ ├── cppad_for_tmb/
│ │ ├── CMakeLists.txt
│ │ ├── cppad_for_tmb.cpp
│ │ ├── implicit_ctor.cpp
│ │ ├── multi_atomic_three.cpp
│ │ ├── multi_atomic_two.cpp
│ │ ├── multi_chkpoint_one.cpp
│ │ ├── multi_chkpoint_two.cpp
│ │ └── prefer_reverse.cpp
│ ├── debug_rel/
│ │ ├── CMakeLists.txt
│ │ ├── debug.cpp
│ │ ├── debug_rel.cpp
│ │ └── release.cpp
│ ├── deprecated/
│ │ ├── CMakeLists.txt
│ │ ├── atomic_two/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── atomic_sparsity.cpp
│ │ │ ├── atomic_two.cpp
│ │ │ ├── base2ad.cpp
│ │ │ ├── for_sparse_hes.cpp
│ │ │ ├── for_sparse_jac.cpp
│ │ │ ├── forward.cpp
│ │ │ ├── get_started.cpp
│ │ │ ├── mat_mul.cpp
│ │ │ ├── mat_mul.hpp
│ │ │ ├── norm_sq.cpp
│ │ │ ├── reciprocal.cpp
│ │ │ ├── rev_sparse_hes.cpp
│ │ │ ├── rev_sparse_jac.cpp
│ │ │ ├── reverse.cpp
│ │ │ ├── set_sparsity.cpp
│ │ │ └── tangent.cpp
│ │ ├── chkpoint_one/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── chkpoint_one.cpp
│ │ │ ├── extended_ode.cpp
│ │ │ ├── get_started.cpp
│ │ │ ├── mul_level.cpp
│ │ │ └── ode.cpp
│ │ ├── deprecated.cpp
│ │ ├── old_mat_mul.cpp
│ │ ├── old_mat_mul.hpp
│ │ ├── old_reciprocal.cpp
│ │ ├── old_tan.cpp
│ │ ├── old_usead_1.cpp
│ │ ├── old_usead_2.cpp
│ │ ├── omp_alloc.cpp
│ │ ├── track_new_del.cpp
│ │ └── zdouble.cpp
│ └── general/
│ ├── CMakeLists.txt
│ ├── abs_normal.cpp
│ ├── acos.cpp
│ ├── acosh.cpp
│ ├── add.cpp
│ ├── add_eq.cpp
│ ├── add_zero.cpp
│ ├── adfun.cpp
│ ├── alloc_openmp.cpp
│ ├── asin.cpp
│ ├── asinh.cpp
│ ├── assign.cpp
│ ├── atan.cpp
│ ├── atan2.cpp
│ ├── atanh.cpp
│ ├── atomic_four.cpp
│ ├── atomic_three.cpp
│ ├── azmul.cpp
│ ├── base2ad.cpp
│ ├── base_adolc.cpp
│ ├── base_alloc.cpp
│ ├── base_complex.cpp
│ ├── bool_sparsity.cpp
│ ├── check_simple_vector.cpp
│ ├── chkpoint_one.cpp
│ ├── chkpoint_two.cpp
│ ├── compare.cpp
│ ├── compare_change.cpp
│ ├── cond_exp.cpp
│ ├── cond_exp_ad.cpp
│ ├── cond_exp_rev.cpp
│ ├── copy.cpp
│ ├── cos.cpp
│ ├── cosh.cpp
│ ├── cpp_graph.cpp
│ ├── cppad_eigen.cpp
│ ├── cppad_vector.cpp
│ ├── dbl_epsilon.cpp
│ ├── dependency.cpp
│ ├── div.cpp
│ ├── div_eq.cpp
│ ├── div_zero_one.cpp
│ ├── eigen_mat_inv.cpp
│ ├── erf.cpp
│ ├── exp.cpp
│ ├── expm1.cpp
│ ├── extern_value.cpp
│ ├── extern_value.hpp
│ ├── fabs.cpp
│ ├── for_hes_sparsity.cpp
│ ├── for_hess.cpp
│ ├── for_jac_sparsity.cpp
│ ├── forward.cpp
│ ├── forward_dir.cpp
│ ├── forward_order.cpp
│ ├── from_base.cpp
│ ├── fun_check.cpp
│ ├── general.cpp
│ ├── hes_sparsity.cpp
│ ├── ipopt_solve.cpp
│ ├── jacobian.cpp
│ ├── json_graph.cpp
│ ├── local/
│ │ ├── is_pod.cpp
│ │ ├── json_lexer.cpp
│ │ ├── json_parser.cpp
│ │ ├── temp_file.cpp
│ │ └── vector_set.cpp
│ ├── log.cpp
│ ├── log10.cpp
│ ├── log1p.cpp
│ ├── mul.cpp
│ ├── mul_cond_rev.cpp
│ ├── mul_cskip.cpp
│ ├── mul_eq.cpp
│ ├── mul_level.cpp
│ ├── mul_zdouble.cpp
│ ├── mul_zero_one.cpp
│ ├── near_equal_ext.cpp
│ ├── neg.cpp
│ ├── new_dynamic.cpp
│ ├── num_limits.cpp
│ ├── ode_err_control.cpp
│ ├── optimize.cpp
│ ├── parameter.cpp
│ ├── poly.cpp
│ ├── pow.cpp
│ ├── pow_int.cpp
│ ├── print_for.cpp
│ ├── rev_sparse_jac.cpp
│ ├── rev_two.cpp
│ ├── reverse.cpp
│ ├── romberg_one.cpp
│ ├── rosen_34.cpp
│ ├── runge_45.cpp
│ ├── simple_vector.cpp
│ ├── sin.cpp
│ ├── sin_cos.cpp
│ ├── sinh.cpp
│ ├── sparse_hessian.cpp
│ ├── sparse_jac_work.cpp
│ ├── sparse_jacobian.cpp
│ ├── sparse_sub_hes.cpp
│ ├── sparse_vec_ad.cpp
│ ├── sqrt.cpp
│ ├── std_math.cpp
│ ├── sub.cpp
│ ├── sub_eq.cpp
│ ├── sub_zero.cpp
│ ├── subgraph_1.cpp
│ ├── subgraph_2.cpp
│ ├── subgraph_hes2jac.cpp
│ ├── tan.cpp
│ ├── to_csrc.cpp
│ ├── to_string.cpp
│ ├── value.cpp
│ ├── vec_ad.cpp
│ ├── vec_ad_par.cpp
│ └── vec_unary.cpp
├── typos.toml
├── user_guide.xrst
├── uw_copy_040507.html
├── val_graph/
│ ├── CMakeLists.txt
│ ├── atomic_xam.hpp
│ ├── binary_xam.cpp
│ ├── call_xam.cpp
│ ├── cexp_xam.cpp
│ ├── comp_xam.cpp
│ ├── compress_xam.cpp
│ ├── con_xam.cpp
│ ├── csum_xam.cpp
│ ├── cumulative_xam.cpp
│ ├── dead_xam.cpp
│ ├── dis_xam.cpp
│ ├── fold_con_xam.cpp
│ ├── fun2val_xam.cpp
│ ├── pri_xam.cpp
│ ├── renumber_xam.cpp
│ ├── summation_xam.cpp
│ ├── test/
│ │ ├── ad_double.cpp
│ │ ├── fold.cpp
│ │ ├── fun2val.cpp
│ │ ├── nan.cpp
│ │ ├── opt_call.cpp
│ │ ├── optimize.cpp
│ │ ├── val2fun.cpp
│ │ └── val_optimize.cpp
│ ├── unary_xam.cpp
│ ├── val2fun_xam.cpp
│ ├── val_graph.cpp
│ └── vec_xam.cpp
├── xrst/
│ ├── base_require/
│ │ ├── base_example.xrst
│ │ ├── base_identical.xrst
│ │ ├── base_member.xrst
│ │ └── base_ordered.xrst
│ ├── det_33_hpp.xrst
│ ├── det_by_lu_hpp.xrst
│ ├── det_by_minor_hpp.xrst
│ ├── det_grad_33_hpp.xrst
│ ├── det_of_minor_hpp.xrst
│ ├── devel/
│ │ ├── devel.xrst
│ │ ├── dynamic.xrst
│ │ └── whats_new/
│ │ └── 2024.xrst
│ ├── example.xrst
│ ├── example_list.xrst
│ ├── install/
│ │ ├── adolc.xrst
│ │ ├── cmake.xrst
│ │ ├── cmake_check.xrst
│ │ ├── colpack_prefix.xrst
│ │ ├── cppadcg.xrst
│ │ ├── download.xrst
│ │ ├── eigen.xrst
│ │ ├── fadbad_prefix.xrst
│ │ ├── install.xrst
│ │ ├── ipopt.xrst
│ │ ├── sacado_prefix.xrst
│ │ └── testvector.xrst
│ ├── introduction.xrst
│ ├── lu_det_and_solve.xrst
│ ├── lu_factor_hpp.xrst
│ ├── lu_invert_hpp.xrst
│ ├── lu_solve_hpp.xrst
│ ├── mat_sum_sq_hpp.xrst
│ ├── mul_level.xrst
│ ├── multi_thread.xrst
│ ├── numeric_type.xrst
│ ├── ode_evaluate.xrst
│ ├── poly_hpp.xrst
│ ├── preprocessor.xrst
│ ├── reverse/
│ │ ├── reverse_any.xrst
│ │ ├── reverse_one.xrst
│ │ └── reverse_two.xrst
│ ├── simple_vector.xrst
│ ├── sparse_hes_fun.xrst
│ ├── sparse_jac_fun.xrst
│ ├── theory/
│ │ ├── acos_forward.xrst
│ │ ├── acos_reverse.xrst
│ │ ├── asin_forward.xrst
│ │ ├── asin_reverse.xrst
│ │ ├── atan_forward.xrst
│ │ ├── atan_reverse.xrst
│ │ ├── cholesky.xrst
│ │ ├── erf_forward.xrst
│ │ ├── erf_reverse.xrst
│ │ ├── exp_forward.xrst
│ │ ├── exp_reverse.xrst
│ │ ├── forward_theory.xrst
│ │ ├── log_forward.xrst
│ │ ├── log_reverse.xrst
│ │ ├── pow_forward.xrst
│ │ ├── pow_reverse.xrst
│ │ ├── research.xrst
│ │ ├── reverse_identity.xrst
│ │ ├── reverse_theory.xrst
│ │ ├── sin_cos_forward.xrst
│ │ ├── sin_cos_reverse.xrst
│ │ ├── sqrt_forward.xrst
│ │ ├── sqrt_reverse.xrst
│ │ ├── tan_forward.xrst
│ │ ├── tan_reverse.xrst
│ │ ├── taylor_ode.xrst
│ │ └── theory.xrst
│ ├── thread_alloc.xrst
│ └── uniform_01_hpp.xrst
└── xrst.toml
================================================
FILE CONTENTS
================================================
================================================
FILE: .circleci/config.yml
================================================
# https://circleci.com/docs/hello-world/
version: 2.1
jobs:
hello-job:
docker:
- image: cimg/node:17.2.0 # the primary container, where your job's commands are run
steps:
- checkout # check out the code in the project directory
- run: echo "hello world" # run the `echo` command
workflows:
my-workflow:
jobs:
- hello-job
================================================
FILE: .github/workflows/conda/conda-env.yml
================================================
name: cppad
channels:
- conda-forge
- nodefaults
dependencies:
- boost
- python
================================================
FILE: .github/workflows/conda-bash.yml
================================================
name: conda-bash
on:
pull_request:
push:
branches:
- master
- 'stable/*'
env:
BUILD_TYPE: Release
jobs:
build:
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
# os: ["ubuntu-latest", "macos-latest"] 2024-04-26 macos-latest failing
# Error: No installed conda 'base' environment found ...; see
os: ["ubuntu-latest", "macos-latest", "windows-latest"]
steps:
- uses: actions/checkout@v4
- uses: conda-incubator/setup-miniconda@v3
with:
activate-environment: cppad
auto-update-conda: true
- name: Install cmake and pkgconfig
shell: bash -l {0}
run: |
conda activate cppad
conda install -y cmake
conda install -y pkgconfig
- name: Build CppAD
shell: bash -l {0}
run: |
conda activate cppad
if [ "$RUNNER_OS" == "macOS" ]
then
generator='Unix Makefiles'
export SDKROOT=$(xcrun --sdk macosx --show-sdk-path)
n_job=$(sysctl -n hw.ncpu)
elif [ "$RUNNER_OS" == "Windows" ]
then
generator='Visual Studio 17 2022'
n_job=1
else
generator='Unix Makefiles'
n_job=$(nproc)
fi
echo "RUNNER_OS=$RUNNER_OS, n_job=$n_job, generator=$generator"
conda activate cppad
echo $CONDA_PREFIX
mkdir build
cd build
cmake .. \
-G "$generator" \
-D CMAKE_INSTALL_PREFIX=$CONDA_PREFIX \
-D CMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
cmake --build . \
--config ${{env.BUILD_TYPE}} \
--target check install \
--parallel $n_job
================================================
FILE: .github/workflows/conda-windows-clang.yml
================================================
name: conda-windows-clang
on:
pull_request:
push:
branches:
- master
- 'stable/*'
env:
# Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
BUILD_TYPE: Release
jobs:
build:
runs-on: ${{ matrix.os }}
strategy:
fail-fast: true
matrix:
name: [windows-latest-clang-cl]
include:
- name: windows-latest-clang-cl
os: windows-2019
compiler: clang-cl
steps:
- uses: actions/checkout@v4
- name: Checkout submodules
run: |
git submodule update --init
- uses: conda-incubator/setup-miniconda@v3
env:
ACTIONS_ALLOW_UNSECURE_COMMANDS: 'true'
with:
activate-environment: cppad
environment-file: .github/workflows/conda/conda-env.yml
python-version: 3.7
- name: Install cmake , pkgconfig, and update conda
run: |
conda install cmake -c main
conda install pkgconfig -c conda-forge
- name: Build CppAD
shell: cmd /C CALL {0}
env:
ACTIONS_ALLOW_UNSECURE_COMMANDS: 'true'
run: |
:: unset extra Boost envs
set Boost_ROOT=
set BOOST_ROOT_1_69_0=
set BOOST_ROOT_1_72_0=
set PATH=%PATH:C:\hostedtoolcache\windows\Boost\1.72.0;=%
:: Create build directory
mkdir build
pushd build
:: Configure
# wd6316 is same as gnu -Wno-bitwise-instead-of-logical
# https://learn.microsoft.com/en-us/cpp/code-quality/c6316
cmake ^
-G "Visual Studio 16 2019" -T "ClangCl" ^
-DCMAKE_GENERATOR_PLATFORM=x64 ^
-DCMAKE_INSTALL_PREFIX=%CONDA_PREFIX%\Library ^
-DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} ^
-Dcppad_cxx_flags="/wd6316" ^
-Dcppad_static_lib=TRUE ^
..
:: Build
cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --target check install
================================================
FILE: .github/workflows/conda-windows-eigen.yml
================================================
name: conda-windows-eigen
on:
push:
branches:
- master
- 'stable/*'
jobs:
build:
runs-on: windows-2019
steps:
- uses: actions/checkout@v4
- uses: conda-incubator/setup-miniconda@v3
with:
activate-environment: conda_env
- name: Use conda to install eigen and pkgconfig
shell: cmd /C CALL {0}
run: |
echo conda install --yes eigen pkgconfig
conda install --yes eigen pkgconfig
- name: Create and check Eigen link, check for eigen3.pc
shell: cmd /C CALL {0}
run: |
mklink /d %CONDA_PREFIX%\Library\include\Eigen^
%CONDA_PREFIX%\Library\include\eigen3\Eigen
echo dir %CONDA_PREFIX%\Library\include\Eigen\Core
dir %CONDA_PREFIX%\Library\include\Eigen\Core
echo dir %CONDA_PREFIX%\Library\share\pkgconfig\eigen3.pc
dir %CONDA_PREFIX%\Library\share\pkgconfig\eigen3.pc
- name: Build and test CppAD with Eigen
shell: cmd /C CALL {0}
run: |
echo Use vcvarsall.bat to get proper version of cmake
call "%programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" amd64
echo where camke
where cmake
echo mkdir build
mkdir build
echo cd build
cd build
echo set PKG_CONFIG_PATH=%CONDA_PREFIX%\Library\share\pkgconfig
set PKG_CONFIG_PATH=%CONDA_PREFIX%\Library\share\pkgconfig
echo run cmake
cmake ^
-D CMAKE_CXX_COMPILER=cl ^
-D CMAKE_C_COMPILER=cl ^
-D CMAKE_BUILD_TYPE=release ^
-G "NMake Makefiles" ^
-D cppad_static_lib=TRUE ^
-D cppad_cxx_flags="/MP /EHs /EHc /std:c++17 /Zc:__cplusplus" ^
..
REM Build and run tests.
cmake --build . --target check --parallel 4
================================================
FILE: .github/workflows/conda-windows-v142.yml
================================================
name: conda-windows-v142
on:
pull_request:
push:
branches:
- master
- 'stable/*'
env:
# Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
BUILD_TYPE: Release
jobs:
build:
runs-on: ${{ matrix.os }}
strategy:
fail-fast: true
matrix:
name: [windows-latest]
include:
- name: windows-latest
os: windows-2019
steps:
- uses: actions/checkout@v4
- name: Checkout submodules
run: |
git submodule update --init
- uses: conda-incubator/setup-miniconda@v3
env:
ACTIONS_ALLOW_UNSECURE_COMMANDS: 'true'
with:
activate-environment: cppad
environment-file: .github/workflows/conda/conda-env.yml
python-version: 3.7
- name: Install cmake , pkgconfig and update conda
run: |
conda install cmake -c main
conda install pkgconfig -c conda-forge
- name: Build CppAD
shell: cmd /C CALL {0}
env:
ACTIONS_ALLOW_UNSECURE_COMMANDS: 'true'
run: |
:: unset extra Boost envs
set Boost_ROOT=
set BOOST_ROOT_1_69_0=
set BOOST_ROOT_1_72_0=
set PATH=%PATH:C:\hostedtoolcache\windows\Boost\1.72.0;=%
:: Create build directory
mkdir build
pushd build
:: Configure
cmake ^
-G "Visual Studio 16 2019" -T "v142" -DCMAKE_GENERATOR_PLATFORM=x64 ^
-DCMAKE_INSTALL_PREFIX=%CONDA_PREFIX%\Library ^
-DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} ^
-Dcppad_static_lib=TRUE ^
..
:: Build, check and Install
# https://gitlab.kitware.com/cmake/cmake/-/issues/20564
# --parallel 1 works
# --parallel 4 does not work
cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --target check install --parallel 1
================================================
FILE: .github/workflows/ubuntu-macos.yml
================================================
name: ubuntu-macos
on:
pull_request:
push:
branches:
- master
- 'stable/*'
jobs:
run_tests:
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ ubuntu-latest, macos-latest ]
steps:
- name: Check out repository code
uses: actions/checkout@v4
- name: set debug_which
run: |
mkdir build
cd build
set +e
random_03=$(expr $RANDOM % 4)
set -e
case $random_03 in
0) debug_which='debug_all'
;;
1) debug_which='debug_even'
;;
2) debug_which='debug_odd'
;;
3) debug_which='debug_none'
;;
esac
echo "$debug_which" > debug_which
- name: run cmake
run: |
cd build
debug_which=$(cat debug_which)
echo "cmake -D cppad_debug_which=$debug_which" ..
cmake -D cppad_debug_which=$debug_which ..
- name: run make check
run: |
if [ "$RUNNER_OS" == "macOS" ]
then
export SDKROOT=$(xcrun --sdk macosx --show-sdk-path)
fi
if which nproc >& /dev/null
then
n_job=$(nproc)
else
n_job=$(sysctl -n hw.ncpu)
fi
cd build
echo "make -j $n_job check"
make -j $n_job check
- run: echo "job.status = ${{ job.status }}"
================================================
FILE: .github/workflows/windows-msys2.yml
================================================
name: windows-msys2
on:
pull_request:
push:
branches:
- master
- 'stable/*'
jobs:
build:
runs-on: windows-latest
defaults:
run:
shell: msys2 {0}
steps:
- uses: actions/checkout@v4
- uses: msys2/setup-msys2@v2
with:
msystem: MINGW64
update: true
install: git mingw-w64-x86_64-cc mingw-w64-x86_64-cmake make
- name: CppAD check
run: |
#
# Create build directory
mkdir build
pushd build
#
# configure
cmake -G "MSYS Makefiles" -D cppad_static_lib=TRUE ..
#
# check
cmake --build . --target check --parallel 1
================================================
FILE: .gitignore
================================================
# ----------------------------------------------------------------------------
# specific files
#
#
# cmake configure files
/bin/test_one.sh
/include/cppad/configure.hpp
#
# create by bin/test_one.sh
/test_one.cpp
/test_one.exe
/test_one.exe.dSYM/
#
# git commit script
/git_commit.sh
# ----------------------------------------------------------------------------
# specific directories
#
# buld directories
/build/
/build2/
#
# for building external packages
/external/
#
# for caching git changes
/new/
/new.*/
# ----------------------------------------------------------------------------
# specific extensions in top direcotry
/*.err
/*.log
/*.tmp
# ----------------------------------------------------------------------------
# vim swap files in any directory
*.swp
# ----------------------------------------------------------------------------
# temp files in any directory
temp
temp.*
================================================
FILE: .readthedocs.yaml
================================================
# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!
# {xrst_comment_ch #}
#
# Example Read the Docs Configuration
# ###################################
#
# Read the Docs Specification
# ***************************
# `<https://docs.readthedocs.com/platform/stable/config-file>`_
#
# This Example File
# *****************
# {xrst_literal}
#
version: 2
build:
os: "ubuntu-22.04"
tools:
python: "3.10"
#
# The readthedocs commands feature is still in beta
commands:
#
# xrst
- pip install xrst
#
# This is only necessary if you need the most recent testing verison
- pip uninstall -y xrst
- pip install --index-url https://test.pypi.org/simple/ xrst
#
# This command prints the version of xrst that is being used
- xrst --version
#
# build/html
# This comamnd builds the xrst user documentation.
# Suppress spell warnings because readthdocs uses a different dictionry.
- xrst
--page_source
--html_theme furo
--group_list default app
--index_page_name user_guide
--suppress_spell_warnings
#
# _readthedocs/html
# The directory that Read the Docs uploads when commands is used.
- mkdir _readthedocs
- rm -r build/html/.doctrees
- cp -r build/html _readthedocs/html
================================================
FILE: .travis.yml
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-22 Bradley M. Bell
# ----------------------------------------------------------------------------
#
sudo: false
language: cpp
compiler: gcc
script:
# bin/travis.sh (make|test_one) target1 target2 ...
#
bin/travis.sh make check install uninstall
notifications:
email:
recipients:
bradbell@seanet.com
on_success: change # send e-mail what success status changes
on_failure: always # always send e-mail when a test fails
================================================
FILE: CMakeLists.txt
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-26 Bradley M. Bell
# ----------------------------------------------------------------------------
# =============================================================================
# Some constants
# =============================================================================
#
# Set the minimum required version of cmake for this project.
# see https://cmake.org//pipermail/cmake/2013-January/053213.html
CMAKE_MINIMUM_REQUIRED(VERSION 3.10)
#
# Use the version of BoostConfig.cmake provided by boost.
IF( POLICY CMP0167 )
CMAKE_POLICY(SET CMP0167 NEW)
ENDIF( POLICY CMP0167 )
#
# Only interpret if() arguments as variables or keywords when unquoted.
IF( POLICY CMP0054 )
CMAKE_POLICY(SET CMP0054 NEW)
ENDIF( POLICY CMP0054 )
#
# cppad_version is used by version.sh to get the version number.
SET(cppad_version "20260408")
SET(cppad_url "https://coin-or.github.io/CppAD" )
SET(cppad_description "Differentiation of C++ Algorithms" )
IF( NOT DEFINED CMAKE_BUILD_TYPE)
SET(CMAKE_BUILD_TYPE "NOTFOUND")
ENDIF( NOT DEFINED CMAKE_BUILD_TYPE)
#
# Set name of this project and create the variables
# cppad_BINARY_DIR and cppad_SOURCE_DIR.
# project(projectname [CXX] [C] [Java])
PROJECT(cppad)
#
# Add the include sub-directory to the list of C++ preprocessor
# include directories for the entire project. The SYSTEM flag is not included
# so warnings will be geenreated for this directory.
INCLUDE_DIRECTORIES( ${cppad_SOURCE_DIR}/include )
#
# =============================================================================
# Some system cmake language extensions
# =============================================================================
# CHECK_CXX_SOURCE_COMPILES(source variable)
# Checks whether the code given in source will compile, link and run and
# return zero status. You can set
# CMAKE_REQUIRED_LIBRARIES, CMAKE_REQUIRED_FLAGS and CMAKE_REQUIRED_INCLUDES
# accordingly if additional libraries or compiler flags are required.
INCLUDE(CheckCXXSourceCompiles)
# ============================================================================
# Some local cmake language
# ============================================================================
# assert_value_in_set(value element_1 ... element_n)
INCLUDE(cmake/assert_value_in_set.cmake)
#
# dos_path_to_unix(dos_path unix_path)
INCLUDE(cmake/dos_path_to_unix.cmake)
#
# add_to_list(variable_list constant_value)
INCLUDE(cmake/add_to_list.cmake)
#
# command_line_arg(variable default type description)
INCLUDE(cmake/command_line_arg.cmake)
#
# prefix_info(package description)
INCLUDE(cmake/prefix_info.cmake)
#
# compile_source_test(source variable)
INCLUDE(cmake/compile_source_test.cmake)
#
# assert(variable)
INCLUDE(cmake/assert.cmake)
#
# print_variable(variable)
INCLUDE(cmake/print_variable.cmake)
#
# set_compile_flags( program_name debug_which source_list)
INCLUDE(cmake/set_compile_flags.cmake)
#
# pkgconfig_info(name, system)
INCLUDE(cmake/pkgconfig_info.cmake)
#
# eigen_info()
INCLUDE(cmake/eigen_info.cmake)
#
# add_check_executable(parent_target short_name)
INCLUDE(cmake/add_check_executable.cmake)
# =============================================================================
# command line arguments
# =============================================================================
# Arguments that are no longer used
#
IF( debug_which )
MESSAGE(FATAL_ERROR
"Using debug_which, use cppad_debug_which or CMAKE_BUILD_TYPE instead"
)
ENDIF( debug_which )
#
IF( cppad_sparse_list )
MESSAGE(FATAL_ERROR
"cppad_sparse_list has been removed from cmake command"
)
ENDIF( cppad_sparse_list )
#
IF( cppad_deprecated )
MESSAGE(FATAL_ERROR "cppad_deprecated has been removed from cmake command" )
ENDIF( cppad_deprecated )
#
IF( cmake_install_prefix )
MESSAGE(FATAL_ERROR
"cmake_install_prefix has been changed to cppad_prefix"
)
ENDIF( cmake_install_prefix )
#
IF( cmake_install_postfix )
MESSAGE(FATAL_ERROR
"cmake_install_postfix has been changed to cppad_postfix"
)
ENDIF( cmake_install_postfix )
#
FOREACH(pkg adolc eigen ipopt cppadcg)
IF( ${pkg}_prefix )
MESSAGE(FATAL_ERROR
"-D ${pkg}_prefix=value has been changed to -D include_${pkg}=true"
)
ENDIF( ${pkg}_prefix )
ENDFOREACH(pkg adolc eigen ipopt cppadcg)
#
IF( cmake_needs_dot_slash )
MESSAGE(FATAL_ERROR
"cmake_needs_dot_slash was removed; see release notes for 2023-06-01"
)
ENDIF( cmake_needs_dot_slash )
#
IF( include_eigen )
MESSAGE(FATAL_ERROR
"include_eigen was removed; see release notes for 2024-10-02"
)
ENDIF( )
# -----------------------------------------------------------------------------
# Current Arguments
#
# cmake_install_datadir
command_line_arg(cmake_install_datadir share STRING
"directory, below prefix, where cmake installs cppad data files"
)
#
# cmake_install_docdir
command_line_arg(cmake_install_docdir NOTFOUND STRING
"directory, below prefix, where cmake installs cppad documentation files"
)
#
# cmake_install_includedirs
command_line_arg(cmake_install_includedirs include STRING
"directories, below prefix, where cmake installs include files"
)
#
# cmake_install_libdirs
command_line_arg(cmake_install_libdirs "lib;lib64" STRING
"directories, below prefix, where cmake installs library files"
)
#
# cmake_defined_ok
command_line_arg(cmake_defined_ok TRUE BOOL
"If false, check that some symbols only get defined once"
"If true, you can use CMakeCache.txt to store previous settings"
)
#
# cppad_prefix
command_line_arg(cppad_prefix "${CMAKE_INSTALL_PREFIX}" PATH
"cppad install prefix"
)
#
# cppad_postfix
command_line_arg(cppad_postfix NOTFOUND STRING
"cppad install postfix"
)
#
# cppad_cxx_flags
command_line_arg(cppad_cxx_flags "" STRING
"compile flags used with cppad (besides debug, release, and profile flags)"
)
#
# cppad_link_flags
command_line_arg(cppad_link_flags "" STRING
"additional linker flags)"
)
#
# cppad_profile_flag
command_line_arg(cppad_profile_flag NOTFOUND STRING
"compile flag used to compile and link a profile version of a program"
)
#
# cppad_testvector
command_line_arg(cppad_testvector cppad STRING
"Namespace of vector used for testing, one of: boost, cppad, eigen, std"
)
assert_value_in_set(cppad_testvector boost cppad eigen std)
#
# cppad_max_num_threads
command_line_arg(cppad_max_num_threads 48 STRING
"maximum number of threads that CppAD can use use"
)
IF( "${cppad_max_num_threads}" LESS "4" )
MESSAGE(FATAL_ERROR
"cppad_max_num_threads is not an integer greater than or equal 4"
)
ENDIF( "${cppad_max_num_threads}" LESS "4" )
#
# cppad_tape_id_type
command_line_arg(cppad_tape_id_type "unsigned int" STRING
"type used to identify different tapes, size must be <= sizeof(size_t)"
)
#
# cppad_tape_addr_type
command_line_arg(cppad_tape_addr_type "unsigned int" STRING
"type used to identify variables on one tape, size must be <= sizeof(size_t)"
)
#
# cppad_debug_and_release
command_line_arg(cppad_debug_and_release TRUE BOOL
"If true the cppad library and tests will be able to mix debug and release"
)
#
# cppad_static_lib
STRING( REGEX MATCH "^MSYS" is_msys "${CMAKE_SYSTEM_NAME}" )
STRING( REGEX MATCH "^CYGWIN" is_cygwin "${CMAKE_SYSTEM_NAME}" )
STRING( REGEX MATCH "^Windows" is_windows "${CMAKE_SYSTEM_NAME}" )
IF( is_msys OR is_cygwin OR is_windows )
SET(default_cppad_static_lib TRUE)
ELSE( )
SET(default_cppad_static_lib FALSE)
ENDIF( )
#
# cppad_static_lib
command_line_arg(cppad_static_lib ${default_cppad_static_lib} BOOL
"If true (false) the cppad library will be static (shared)"
)
# ----------------------------------------------------------------------------
#
# Ensure c++11 support
SET(CMAKE_REQUIRED_DEFINITIONS "")
SET(CMAKE_REQUIRED_FLAGS "${cppad_cxx_flags}")
SET(CMAKE_REQUIRED_INCLUDES "")
SET(CMAKE_REQUIRED_LIBRARIES "")
SET(source "
int main(void)
{ static_assert( __cplusplus >= 201103 , \"c++11 is supported\" );
return 0;
}"
)
compile_source_test(${cmake_defined_ok} "${source}" minimal_cplusplus )
IF( NOT minimal_cplusplus )
MESSAGE(STATUS "setting C++ standard to 2011")
SET(CMAKE_CXX_STANDARD 11)
SET(CMAKE_CXX_STANDARD_REQUIRED ON)
ENDIF( NOT minimal_cplusplus )
#
# use_cplusplus_2014_ok
SET(source "
int main(void)
{ static_assert( __cplusplus >= 201302L , \"c++17 is supported\" );
return 0;
}"
)
compile_source_test(${cmake_defined_ok} "${source}" use_cplusplus_2014_ok )
#
# use_cplusplus_2017_ok
SET(source "
int main(void)
{ static_assert( __cplusplus >= 201703L , \"c++17 is supported\" );
return 0;
}"
)
compile_source_test(${cmake_defined_ok} "${source}" use_cplusplus_2017_ok )
# ----------------------------------------------------------------------------
#
# cppad_debug_and_release_01
IF (cppad_debug_and_release )
SET(cppad_debug_and_release_01 1 )
ELSE (cppad_debug_and_release )
SET(cppad_debug_and_release_01 0 )
ENDIF ( )
#
# cppad_debug_which
# CMAKE_BUILD_TYPE
SET(debug_even_or_odd FALSE)
IF( NOT ${cppad_debug_which} STREQUAL "" )
assert_value_in_set(
cppad_debug_which debug_even debug_odd debug_all debug_none
)
ENDIF( NOT ${cppad_debug_which} STREQUAL "" )
IF( CMAKE_BUILD_TYPE )
IF( NOT ${cppad_debug_which} STREQUAL "" )
print_variable(CMAKE_BUILD_TYPE)
print_variable(cppad_debug_which)
MESSAGE(FATAL_ERROR
"Both CMAKE_BUILD_TYPE and cppad_debug_which specified"
)
ENDIF( )
STRING( TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lower )
IF(cmake_build_type_lower MATCHES debug)
SET(cppad_debug_which "debug_all")
ELSEIF(cmake_build_type_lower MATCHES release)
SET(cppad_debug_which "debug_none")
ELSEIF(cmake_build_type_lower MATCHES relwithdebInfo)
SET(cppad_debug_which "debug_none")
ELSEIF(cmake_build_type_lower MATCHES minsizerel)
SET(cppad_debug_which "debug_none")
ELSE( )
MESSAGE(FATAL_ERROR
"Unknown CMAKE_BUILD_TYPE = ${CMAKE_BUILD_TYPE}"
)
ENDIF( )
ELSE( ) # CMAKE_BUILD_TYPE
IF( "${cppad_debug_which}" STREQUAL debug_all)
SET(CMAKE_BUILD_TYPE Debug)
ELSEIF( "${cppad_debug_which}" STREQUAL debug_none)
SET(CMAKE_BUILD_TYPE Release)
ELSEIF( "${cppad_debug_which}" STREQUAL debug_odd)
SET(CMAKE_BUILD_TYPE Debug)
SET(debug_even_or_odd TRUE)
ELSEIF( "${cppad_debug_which}" STREQUAL debug_even)
SET(CMAKE_BUILD_TYPE Release)
SET(debug_even_or_odd TRUE)
ENDIF( "${cppad_debug_which}" STREQUAL debug_all)
ENDIF( ) # CMAKE_BUILD_TYPE
IF( debug_even_or_odd )
IF ( NOT cppad_debug_and_release )
MESSAGE(FATAL_ERROR
"cppad_debug_and_release is false and cppad_debug_which = ${cppad_debug_which}"
)
ENDIF ( NOT cppad_debug_and_release )
IF( ${CMAKE_SYSTEM_NAME} STREQUAL "Windows" )
MESSAGE(FATAL_ERROR
"Cannot have cppad_debug_which equal ${cppad_debug_which} on Windows."
)
ENDIF( ${CMAKE_SYSTEM_NAME} STREQUAL "Windows" )
ENDIF( debug_even_or_odd )
print_variable(CMAKE_SYSTEM_NAME)
print_variable(cppad_debug_which)
print_variable(CMAKE_BUILD_TYPE)
MESSAGE(STATUS "make check: available")
# -----------------------------------------------------------------------------
# CMAKE_INSTALL_PREFIX
SET(CMAKE_INSTALL_PREFIX "${cppad_prefix}"
CACHE PATH "value copied from cppad_prefix" FORCE
)
# -----------------------------------------------------------------------------
# Optional package information
# cppad_has_{package}, {package}_LINK_LIBRARIES, package INCLUDE_DIRECTORIES
#
# system_include
SET(system_include TRUE)
#
# package = eigen
eigen_info()
#
# package = adolc
pkgconfig_info(adolc ${system_include})
#
# package = ipopt
pkgconfig_info(ipopt ${system_include})
#
# package = colpack
prefix_info(colpack ${system_include} )
#
# package = sacado
prefix_info(sacado ${system_include} )
#
# package = fadbad
prefix_info(fadbad ${system_include} )
#
# check sacado
IF( ${cppad_has_sacado} )
IF( NOT ${use_cplusplus_2017_ok} )
MESSAGE(FATAL_ERROR "sacado_prefix is defined but c++17 not supported")
ENDIF( )
ENDIF( )
#
# package = cppadcg
SET( include_cppadcg FALSE CACHE BOOL "include cppadcg" )
IF( include_cppadcg )
#
# cppad_has_cppadcg
SET(cppad_has_cppadcg 1)
#
# Assume bin/get_cppadcg.sh puts include files in this directory
SET(cppadcg_include_dir "${CMAKE_BINARY_DIR}/prefix/include" )
print_variable(cppadcg_include_dir)
INCLUDE_DIRECTORIES( SYSTEM ${cppadcg_include_dir})
ELSE( )
# cppad_has_cppadcg
SET(cppad_has_cppadcg 0)
ENDIF( include_cppadcg )
#
# package = xrst
SET( include_doc FALSE CACHE BOOL "include documentation")
IF( include_doc )
#
# xrst_path
FIND_PROGRAM( xrst_path xrst )
IF( "${xrst_path}" STREQUAL "xrst_path-NOTFOUND" )
MESSAGE(FATAL_ERROR
"include_doc is true and cannot find xrst in system path"
)
ENDIF( )
#
# processor_count
INCLUDE(ProcessorCount)
ProcessorCount(processor_count)
IF( processor_count EQUAL 0 )
SET(processor_count 1)
ENDIF( )
#
# see
# https://discourse.cmake.org/t/how-to-install-a-generated-directory/1267
#
# doc_dir
SET(doc_dir "${CMAKE_SOURCE_DIR}/build/html")
#
# doc_user
ADD_CUSTOM_TARGET(doc_user ALL
COMMAND xrst
--group_list default app
--local_toc
--html_theme sphinx_rtd_theme
--number_jobs ${processor_count}
--index_page_name user_guide
--suppress_spell_warnings
--config_file "${CMAKE_SOURCE_DIR}/xrst.toml"
)
#
# doc_dev
ADD_CUSTOM_TARGET(doc_dev
COMMAND xrst
--group_list default app dev
--local_toc
--html_theme sphinx_rtd_theme
--number_jobs ${processor_count}
--index_page_name user_guide
--suppress_spell_warnings
--config_file "${CMAKE_SOURCE_DIR}/xrst.toml"
)
ENDIF( include_doc )
# =============================================================================
# cppad_lib
# Perhaps in the future cppad_lib will depend on cmake header only flag ?
SET( cppad_lib "cppad_lib" )
LINK_DIRECTORIES( ${cppad_BINARY_DIR}/cppad_lib )
# =============================================================================
# colpack_libs
#
IF( cppad_has_colpack )
SET( colpack_libs "ColPack" )
ELSE( cppad_has_colpack )
SET( colpack_libs "" )
ENDIF( cppad_has_colpack )
# =============================================================================
# automated system configuration
# =============================================================================
# CMAKE_CXX_FLAGS
IF( "${cppad_debug_which}" STREQUAL "debug_all" )
print_variable(CMAKE_CXX_FLAGS_DEBUG)
ELSEIF( "${cppad_debug_which}" STREQUAL "debug_none" )
print_variable(CMAKE_CXX_FLAGS_RELEASE)
ELSE( "${cppad_debug_which}" )
print_variable(CMAKE_CXX_FLAGS_DEBUG)
print_variable(CMAKE_CXX_FLAGS_RELEASE)
ENDIF( "${cppad_debug_which}" STREQUAL "debug_all" )
# -----------------------------------------------------------------------------
# cppad_abs_includedir, cppad_abs_libdir, cppad_abs_datadir, cppad_abs_docdir
#
# for dir_types = includedirs, libdirs, datadir, docdir
FOREACH(dir_types includedirs libdirs datadir docdir)
# set dir_type = dir_types with "dirs" -> "dir"
STRING(REGEX REPLACE "dirs" "dir" dir_type ${dir_types})
#
# set dir_name to first directory in cmake_install_${dir_types}
SET(dir_name NOTFOUND)
FOREACH(dir ${cmake_install_${dir_types}})
IF( NOT dir_name )
SET(dir_name ${dir})
ENDIF( NOT dir_name )
ENDFOREACH(dir ${cmake_install_${dir_types}})
#
# set cppad_abs_${dir_type}
SET(cppad_abs_${dir_type} "${cppad_prefix}/${dir_name}" )
#
# check if we need to add a postfix to it
IF( cppad_postfix )
SET(cppad_abs_${dir_type} ${cppad_abs_${dir_type}}/${cppad_postfix} )
ENDIF( cppad_postfix )
ENDFOREACH(dir_types includedirs libdirs datadir docdir)
# ----------------------------------------------------------------------------
# https://gitlab.kitware.com/cmake/community/-/wikis/doc/cmake/RPATH-handling
#
# CMAKE_SKIP_BUILD_RPATH
# use, i.e. don't skip the full RPATH for the build tree
SET(CMAKE_SKIP_BUILD_RPATH FALSE)
#
# CMAKE_BUILD_WITH_INSTALL_RPATH
# when building shared libraries, don't use the install RPATH already
# (but later on when installing)
SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
#
# CMAKE_INSTAL_RPATH_USE_LINK_PATH
# add the automatically determined parts of the RPATH
# which point to directories outside the build tree to the install RPATH
SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
#
# isSystemDir
# is this RPATH choice a system directory
LIST(FIND
CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES
"${cppad_abs_libdir}"
isSystemDir
)
#
# CMAKE_INSTALL_RPATH
# the RPATH to be used when installing, but only if it's not a system directory
SET(CMAKE_INSTALL_RPATH "")
if("${isSystemDir}" STREQUAL "-1")
SET(CMAKE_INSTALL_RPATH "${cppad_abs_libdir}")
endif("${isSystemDir}" STREQUAL "-1")
print_variable( CMAKE_INSTALL_RPATH )
# -----------------------------------------------------------------------------
# cppad_link_flags_has_m32
STRING( FIND "${cppad_link_flags}" "-m32" index)
IF( "${index}" STREQUAL "-1" )
SET(cppad_link_flags_has_m32 0)
ELSE ( )
SET(cppad_link_flags_has_m32 1)
ENDIF( )
# -----------------------------------------------------------------------------
# OpenMP_CXX_FOUND, OpenMP_CXX_FLAGS
IF( cppad_link_flags_has_m32 )
SET(OpenMP_CXX_FOUND FALSE)
MESSAGE(STATUS
"Skipping OpenMP because -m32 is in cppad_link_flags"
)
ELSEIF( ${CMAKE_SYSTEM_NAME} STREQUAL "Darwin" )
SET(OpenMP_CXX_FOUND FALSE)
MESSAGE(STATUS
"Skipping OpenMP on Darwin (Mac) systems. 2DO: fix this"
)
ELSE( )
FIND_PACKAGE(OpenMP)
ENDIF( )
# -----------------------------------------------------------------------------
# Boost_Found, cppad_has_boost
# Only need components for object libraries, not include libraries.
IF( cppad_link_flags_has_m32 )
MESSAGE(STATUS
"Skipping Boost because -m32 is in cppad_link_flags"
)
SET( Boost_FOUND 0)
SET(cppad_has_boost 0)
ELSE ( )
SET(CMAKE_REQUIRED_FLAGS "") # 2DO: why is this necessary with clang ?
FIND_PACKAGE(Boost COMPONENTS thread)
SET(CMAKE_REQUIRED_FLAGS "${cppad_cxx_flags}")
ENDIF( )
IF ( Boost_FOUND )
SET(cppad_has_boost 1)
#
# Extract the Boost prefix from Boost_INCLUDE_DIRS
#
# convert to using unix directory separator
dos_path_to_unix("${Boost_INCLUDE_DIRS}" boost_include_dirs)
#
# convert to just one directory
STRING(REGEX REPLACE
"([^ ]+).*" "\\1"
boost_include_dir "${boost_include_dirs}"
)
#
# extract part before last backslash
STRING(REGEX REPLACE
"([^ ]*)/[^/ ]*" "\\1"
boost_prefix "${boost_include_dir}"
)
print_variable(boost_prefix)
#
# add boost include directories
FOREACH(dir ${cmake_install_includedirs})
IF( IS_DIRECTORY ${boost_prefix}/${dir} )
INCLUDE_DIRECTORIES( ${boost_prefix}/${dir} )
MESSAGE(STATUS "Found ${boost_prefix}/${dir}")
ENDIF( IS_DIRECTORY ${boost_prefix}/${dir} )
ENDFOREACH( dir )
#
# add boost link directories
FOREACH(dir ${cmake_install_libdirs})
IF( IS_DIRECTORY ${boost_prefix}/${dir} )
LINK_DIRECTORIES( ${boost_prefix}/${dir} )
MESSAGE(STATUS "Found ${boost_prefix}/${dir}")
ENDIF( IS_DIRECTORY ${boost_prefix}/${dir} )
ENDFOREACH( dir )
ENDIF ( Boost_FOUND )
# -----------------------------------------------------------------------------
# ipopt_LIBRARIES and ipopt_LIBRARY_DIRS
IF( cppad_has_ipopt )
#
# Set the system environment variable PKG_CONFIG_PATH
FOREACH(dir ${cmake_install_libdirs})
IF(EXISTS "${ipopt_prefix}/${dir}/pkgconfig/ipopt.pc")
SET( ENV{PKG_CONFIG_PATH} ${ipopt_prefix}/${dir}/pkgconfig )
ENDIF(EXISTS "${ipopt_prefix}/${dir}/pkgconfig/ipopt.pc")
ENDFOREACH(dir)
#
# pkg_check_modules(<PREFIX> [REQUIRED] <MODULE> [<MODULE>]*)
# ipopt_LIBRARIES ... only the libraries (w/o the '-l')
# ipopt_LIBRARY_DIRS ... the paths of the libraries (w/o the '-L')
pkg_check_modules(ipopt ipopt)
IF( NOT ipopt_FOUND )
MESSAGE(FATAL_ERROR
"For all directories dir in cmake_install_libdirs, cannot find the file
ipopt_prefix/dir/pkgconfig/ipopt.pc
where
ipopt_prefix = ${ipopt_prefix}
cmake_install_libdirs = ${cmake_install_libdirs}
"
)
ENDIF( NOT ipopt_FOUND )
ENDIF( cppad_has_ipopt )
# =============================================================================
# Currently building tests as normal executables
# =============================================================================
# The CMakeLists.txt file in the specified source directory is processed
# before the current input file continues beyond this command.
# add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])
#
#
# is_cppad_lib_dynamic
IF( cppad_static_lib )
SET(is_cppad_lib_dynamic 0)
ELSE( )
SET(is_cppad_lib_dynamic 1)
ENDIF( )
print_variable(is_cppad_lib_dynamic)
#
# CMAKE_EXE_LINKER_FLAGS
SET(CMAKE_EXE_LINKER_FLAGS "${cppad_link_flags}" )
#
# Initialize list of tests as empty
SET(check_depends "")
#
# directories with no check depends entries
ADD_SUBDIRECTORY(include/cppad)
ADD_SUBDIRECTORY(pkgconfig)
ADD_SUBDIRECTORY(cppad_lib)
#
IF( NOT ( "${check_depends}" STREQUAL "" ) )
MESSAGE(FATAL_ERROR "Error in CMakeLists.txt scripts")
ENDIF( NOT ( "${check_depends}" STREQUAL "" ) )
#
# directories with check depends entries
ADD_SUBDIRECTORY(val_graph)
ADD_SUBDIRECTORY(example)
ADD_SUBDIRECTORY(introduction)
ADD_SUBDIRECTORY(test_more)
ADD_SUBDIRECTORY(speed)
IF( cppad_has_ipopt )
ADD_SUBDIRECTORY(cppad_ipopt)
ENDIF( cppad_has_ipopt )
#
# check, test
ADD_CUSTOM_TARGET(check DEPENDS ${check_depends})
ADD_CUSTOM_TARGET(test DEPENDS ${check_depends})
# ============================================================================
# Copy a file to another location and modify its contents.
# configure_file(InputFile OutputFile [COPYONLY] [ESCAPE_QUOTES] [@ONLY])
CONFIGURE_FILE(
${CMAKE_CURRENT_SOURCE_DIR}/bin/test_one.sh.in
${CMAKE_CURRENT_SOURCE_DIR}/bin/test_one.sh
)
# =============================================================================
# install procedure
# =============================================================================
# install(DIRECTORY dirs... DESTINATION <dir>
# [FILE_PERMISSIONS permissions...]
# [DIRECTORY_PERMISSIONS permissions...]
# [USE_SOURCE_PERMISSIONS] [OPTIONAL]
# [CONFIGURATIONS [Debug|Release|...]]
# [COMPONENT <component>] [FILES_MATCHING]
# [[PATTERN <pattern> | REGEX <regex>]
# [EXCLUDE] [PERMISSIONS permissions...]] [...]
# )
# Note a trailing / in the source directory name drops the source directory
# name during the copy.
#
# During install copy all the cppad include files to
# ${cppad_abs_includedir}/cppad
INSTALL(
DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/cppad/"
DESTINATION ${cppad_abs_includedir}/cppad
FILES_MATCHING PATTERN "*.hpp" PATTERN "xrst" EXCLUDE
)
#
# During install copy doc direcrory to cppad_abs_docdir/cppad
IF ( cmake_install_docdir AND include_doc )
INSTALL(
DIRECTORY "${CMAKE_SOURCE_DIR}/build/html/"
DESTINATION ${cppad_abs_docdir}/cppad
)
ENDIF ( cmake_install_docdir AND include_doc )
# =============================================================================
# uninstall procedure
# =============================================================================
ADD_CUSTOM_TARGET(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cppad_uninstall.cmake)
================================================
FILE: COPYING
================================================
-----------------------------------------------------------------------------
CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-18 Bradley M. Bell
CppAD is distributed under the terms of the
Eclipse Public License Version 2.0.
This Source Code may also be made available under the following
Secondary License when the conditions for such availability set forth
in the Eclipse Public License, Version 2.0 are satisfied:
GNU General Public License, Version 2.0 or later.
-----------------------------------------------------------------------------
================================================
FILE: appendix/addon.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin addon app}
{xrst_spell
adcomp
addons
cg
ext
includedir
libcppad
libdir
py
pycppad
tmb
}
CppAD Addons
############
Name
****
Each CppAD addon has a short name which we denote by *name* below,
a longer name *longer* and a *description* :
.. list-table::
:widths: auto
* - *name*
- *longer*
- *description*
* - `tmb <https://github.com/kaskr/adcomp>`_
- ``adcomp``
- An R Interface to CppAD with Random Effects Modeling Utilities
* - `cg <https://github.com/joaoleal/CppADCodeGen/>`_
- ``CppADCodeGen``
- C++ Source Code Generation of CppAD Derivative Calculations
* - `mixed <https://bradbell.github.io/cppad_mixed>`_
- ``cppad_mixed``
- A C++ Interface to Random Effects Laplace Approximation
* - `cppad_py <https://cppad-py.readthedocs.io>`_
- ``cppad_py``
- A Python Interface to CppAD
* - `swig <https://bradbell.github.io/cppad_swig>`_
- ``cppad_swig``
- A C++ AD Library with a Swig Interface to Perl, Octave, and Python
(no longer being developed)
* - `pycppad <https://github.com/b45ch1/pycppad>`_
- ``pycppad``
- A Python Interface to CppAD (no longer being developed)
Include Files
*************
If *includedir* is the directory where the include files are installed,
the file
*includedir* / ``include/cppad/`` *name* . ``hpp``
and the directory
*includedir* / ``include/cppad/`` *name*
are reserved for use by the *name* addon.
Library Files
*************
If *libdir* is the directory where CppAD library files are installed,
files with the name
| |tab| *libdir* / ``libcppad_`` *name* . *ext*
| |tab| *libdir* / ``libcppad_`` *name* _ *anything* . *ext*
where *anything* and *ext* are arbitrary,
are reserved for use by the *name* addon.
Preprocessor Symbols
********************
C++ preprocessor symbols that begin with
``CPPAD_`` *NAME* _
where *NAME* is a upper-case version of *name* ,
are reserved for use by the *name* addon.
Namespace
*********
The C++ namespace
``CppAD::`` *name*
is reserved for use by the *name* addon.
{xrst_end addon}
================================================
FILE: appendix/appendix.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-22 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin appendix app}
Appendix
########
Contents
********
{xrst_toc_table
appendix/faq.xrst
appendix/directory.xrst
appendix/glossary.xrst
appendix/bib.xrst
appendix/wish_list.xrst
appendix/whats_new/whats_new.xrst
appendix/deprecated/deprecated.xrst
test_more/compare_c/CMakeLists.txt
appendix/numeric_ad.xrst
appendix/addon.xrst
appendix/license.xrst
}
{xrst_end appendix}
================================================
FILE: appendix/bib.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin Bib app}
{xrst_spell
abramowitz
andreas
bjarne
flannery
fortran
griewank
rosenbrock
shampine
stegun
stroustrup
teukolsky
vetterling
vol
}
Bibliography
############
Abramowitz and Stegun
*********************
Handbook of Mathematical Functions,
Dover, New York.
The C++ Programming Language
****************************
Bjarne Stroustrup,
The C++ Programming Language,
Special ed.,
AT&T, 2000
Evaluating Derivatives
**********************
Evaluating Derivatives: Principles and Techniques of
Algorithmic Differentiation,
Andreas Griewank,
SIAM,
Philadelphia,
2000
Numerical Recipes
*****************
Numerical Recipes in Fortran:
The Art of Scientific Computing,
Second Edition,
William H. Press,
William T. Vetterling,
Saul, A. Teukolsky,
Brian R. Flannery,
Cambridge University Press,
1992
Shampine, L.F.
**************
Implementation of Rosenbrock Methods,
ACM Transactions on Mathematical Software,
Vol. 8,
No. 2,
June 1982.
{xrst_end Bib}
================================================
FILE: appendix/deprecated/compare_change.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin CompareChange app}
Comparison Changes During Zero Order Forward Mode
#################################################
Syntax
******
| *c* = *f* . ``CompareChange`` ()
See Also
********
:ref:`FunCheck-name`
Deprecated 2015-01-20
*********************
This routine has been deprecated, use :ref:`compare_change-name`
instead.
Purpose
*******
We use :math:`F : \B{R}^n \rightarrow \B{R}^m` to denote the
:ref:`glossary@AD Function` corresponding to *f* .
This function may be not agree with the algorithm that was used
to create the corresponding
AD of *Base*
:ref:`operation sequence<glossary@Operation@Sequence>`
because of changes in AD
:ref:`comparison<Compare-name>` results.
The ``CompareChange`` function can be used to detect these changes.
f
*
The object *f* has prototype
``const ADFun`` < *Base* > *f*
c
*
The result *c* has prototype
``size_t`` *c*
It is the number of
``AD`` < *Base* > :ref:`comparison<Compare-name>`
operations,
corresponding to the previous call to :ref:`Forward-name`
*f* . ``Forward`` (0, *x* )
that have a different result from
when *F* was created by taping an algorithm.
Discussion
**********
If *c* is not zero,
the boolean values resulting from some of the
:ref:`comparison operations<Compare-name>` corresponding to *x*
are different from when the
AD of *Base*
:ref:`operation sequence<glossary@Operation@Sequence>` was created.
In this case, you may want to re-tape the algorithm with the
:ref:`independent variables<glossary@Tape@Independent Variable>`
equal to the values in *x*
(so AD operation sequence properly represents the algorithm
for this value of independent variables).
On the other hand, re-taping the AD operation sequence usually takes
significantly more time than evaluation using :ref:`forward_zero-name` .
If the functions values have not changed (see :ref:`FunCheck-name` )
it may not be worth re-taping a new AD operation sequence.
{xrst_end CompareChange}
================================================
FILE: appendix/deprecated/deprecated.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin deprecated app}
{xrst_spell
colpack
}
CppAD Deprecated API Features
#############################
Contents
********
{xrst_toc_table
appendix/deprecated/include_deprecated.xrst
appendix/deprecated/fun_deprecated.xrst
appendix/deprecated/compare_change.xrst
include/cppad/core/omp_max_thread.hpp
include/cppad/utility/track_new_del.hpp
appendix/deprecated/omp_alloc.xrst
include/cppad/utility/memory_leak.hpp
include/cppad/core/epsilon.hpp
cppad_ipopt/src/cppad_ipopt_nlp.hpp
include/cppad/core/atomic/one/atomic.hpp
include/cppad/core/atomic/two/atomic.hpp
example/multi_thread/multi_atomic_two.xrst
include/cppad/core/chkpoint_one/chkpoint_one.hpp
example/multi_thread/multi_chkpoint_one.xrst
include/cppad/core/zdouble.hpp
configure
}
Name Changes
************
.. list-table::
:widths: auto
* - ``CppADCreateUnaryBool``
- see Deprecated 2007-07-31 in :ref:`bool_fun-title`
* - ``CppADCreateDiscrete``
- see Deprecated 2007-07-31 in :ref:`bool_fun-title`
* - ``nan`` ( *zero* )
- :ref:`nan@nan(zero)`
* - ``colpack.star`` coloring
- see
:ref:`sparse_hes<sparse_hes@coloring@colpack.star Deprecated 2017-06-01>`
and
:ref:`sparse_hessian<sparse_hessian@work@colpack.star Deprecated 2017-06-01>`
{xrst_end deprecated}
================================================
FILE: appendix/deprecated/fun_deprecated.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin fun_deprecated app}
ADFun Object Deprecated Member Functions
########################################
Syntax
******
| *f* . ``Dependent`` ( *y* )
| *o* = *f* . ``Order`` ()
| *m* = *f* . ``Memory`` ()
| *s* = *f* . ``Size`` ()
| *t* = *f* . ``taylor_size`` ()
| *u* = *f* . ``use_VecAD`` ()
| *v* = *f* . ``size_taylor`` ()
| *w* = *f* . ``capacity_taylor`` ()
Purpose
*******
The ``ADFun`` < *Base* > functions documented here have been deprecated;
i.e., they are no longer approved of and may be removed from some future
version of CppAD.
Dependent
*********
A recording of and AD of *Base*
:ref:`operation sequence<glossary@Operation@Sequence>`
is started by a call of the form
``Independent`` ( *x* )
If there is only one such recording at the current time,
you can use *f* . ``Dependent`` ( *y* ) in place of
*f* . ``Dependent`` ( *x* , *y* )
See :ref:`Dependent-name` for a description of this operation.
Deprecated 2007-08-07
=====================
This syntax was deprecated when CppAD was extended to allow
for more than one ``AD`` < *Base* > recording to be
active at one time.
This was necessary to allow for multiple threading applications.
Order
*****
The result *o* has prototype
``size_t`` *o*
and is the order of the previous forward operation
using the function *f* .
This is the highest order of the
:ref:`Taylor coefficients<glossary@Taylor Coefficient>`
that are currently stored in *f* .
Deprecated 2006-03-31
=====================
Zero order corresponds to function values being stored in *f* .
In the future, we would like to be able to erase the function
values so that *f* uses less memory.
In this case, the return value of ``Order`` would not make sense.
Use :ref:`size_order-name` to obtain
the number of Taylor coefficients currently stored
in the ADFun object *f*
(which is equal to the order plus one).
Memory
******
The result
``size_t`` *m*
and is the number of memory units (``sizeof`` ) required for the
information currently stored in *f* .
This memory is returned to the system when the destructor for
*f* is called.
Deprecated 2006-03-31
=====================
It used to be the case that an ADFun object just kept increasing its
buffers to the maximum size necessary during its lifetime.
It would then return the buffers to the system when its destructor
was called.
This is no longer the case, an ADFun object now returns memory
when it no longer needs the values stored in that memory.
Thus the ``Memory`` function is no longer well defined.
Size
****
The result *s* has prototype
``size_t`` *s*
and is the number of variables in the operation sequence plus the following:
one for a phantom variable with tape address zero,
one for each component of the domain that is a parameter.
The amount of work and memory necessary for computing function values
and derivatives using *f* is roughly proportional to *s* .
Deprecated 2006-04-03
=====================
There are other sizes attached to an ADFun object, for example,
the number of operations in the sequence.
In order to avoid confusion with these other sizes,
use :ref:`fun_property@size_var` to obtain
the number of variables in the operation sequence.
taylor_size
***********
The result *t* has prototype
``size_t`` *t*
and is the number of Taylor coefficient orders
currently calculated and stored in the ADFun object *f* .
Deprecated 2006-06-17
=====================
This function has been replaced by :ref:`size_order-name` .
use_VecAD
*********
The result *u* has prototype
``bool`` *u*
If it is true, the
AD of *Base*
:ref:`operation sequence<glossary@Operation@Sequence>`
stored in *f* contains
:ref:`VecAD<VecAD@VecAD<Base\>::reference>` operands.
Otherwise *u* is false.
Deprecated 2006-04-08
=====================
You can instead use
*u* = *f* . ``size_VecAD`` () > 0
size_taylor
***********
The result *v* has prototype
``size_t`` *v*
and is the number of Taylor coefficient orders
currently calculated and stored in the ADFun object *f* .
Deprecated 2014-03-18
=====================
This function has been replaced by :ref:`size_order-name` .
capacity_taylor
***************
The result *w* has prototype
``size_t`` *w*
and is the number of Taylor coefficient orders currently allocated
in the ADFun object *f* .
Deprecated 2014-03-18
=====================
This function has been replaced by :ref:`capacity_order-name` .
{xrst_end fun_deprecated}
================================================
FILE: appendix/deprecated/include_deprecated.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin include_deprecated app}
Deprecated Include Files
########################
Deprecated 2015-11-30
*********************
The :ref:`utility-name` individual include files have been deprecated; e.g.,
::
# include <cppad/runge_45.hpp>
You must instead use
::
# include <cppad/utility.hpp>
or you can include individual utility files; e.g.,
::
# include <cppad/utility/runge_45.hpp>
Deprecated 2006-12-17
*********************
The following is a list of deprecated include file names
and the corresponding names that should be used.
For example, if your program uses the deprecated preprocessor command
::
# include <CppAD/CppAD.h>
you must change it to the command
::
# include <cppad/cppad.hpp>
The before 2015-11-30 column contains name used for the include file
between 2006-12-17 and 2015-11-30 (see discussion above).
.. csv-table::
:widths: auto
**Deprecated**,**Before 2015-11-30**,**Documentation**
CppAD/CheckNumericType.h,cppad/check_numeric_type.hpp,:ref:`CheckNumericType-name`
CppAD/CheckSimpleVector.h,cppad/check_simple_vector.hpp,:ref:`CheckSimpleVector-name`
CppAD/CppAD.h,cppad/cppad.hpp,:ref:`user_guide-name`
CppAD/CppAD_vector.h,cppad/vector.hpp,:ref:`CppAD_vector-name`
CppAD/ErrorHandler.h,cppad/error_handler.hpp,:ref:`ErrorHandler-name`
CppAD/LuFactor.h,cppad/lu_factor.hpp,:ref:`LuFactor-name`
CppAD/LuInvert.h,cppad/lu_invert.hpp,:ref:`LuInvert-name`
CppAD/LuSolve.h,cppad/lu_solve.hpp,:ref:`LuSolve-name`
CppAD/NearEqual.h,cppad/near_equal.hpp,:ref:`NearEqual-name`
CppAD/OdeErrControl.h,cppad/ode_err_control.hpp,:ref:`OdeErrControl-name`
CppAD/OdeGear.h,cppad/ode_gear.hpp,:ref:`OdeGear-name`
CppAD/OdeGearControl.h,cppad/ode_gear_control.hpp,:ref:`OdeGearControl-name`
CppAD/Poly.h,cppad/poly.hpp,:ref:`Poly-name`
CppAD/PowInt.h,cppad/pow_int.hpp,:ref:`pow_int-name`
CppAD/RombergMul.h,cppad/romberg_mul.hpp,:ref:`RombergMul-name`
CppAD/RombergOne.h,cppad/romberg_one.hpp,:ref:`RombergOne-name`
CppAD/Rosen34.h,cppad/rosen_34.hpp,:ref:`Rosen34-name`
CppAD/Runge45.h,cppad/runge_45.hpp,:ref:`Runge45-name`
CppAD/SpeedTest.h,cppad/speed_test.hpp,:ref:`SpeedTest-name`
CppAD/TrackNewDel.h,cppad/track_new_del.hpp,:ref:`track_new_del-name`
{xrst_end include_deprecated}
================================================
FILE: appendix/deprecated/omp_alloc.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin omp_alloc app}
A Quick OpenMP Memory Allocator Used by CppAD
#############################################
Syntax
******
| ``# include <cppad/omp_alloc.hpp>``
Purpose
*******
The C++ ``new`` and ``delete`` operators are thread safe,
but this means that a thread may have to wait for a lock on these operations.
Once memory is obtained for a thread, the ``omp_alloc`` memory
allocator keeps that memory :ref:`omp_available-name` for the thread so that
it can be re-used without waiting for a lock.
All the CppAD memory allocations use this utility.
The :ref:`omp_free_available-name` function should be used to return memory
to the system (once it is no longer required by a thread).
Include
*******
The routines in sections below are defined by ``cppad/omp_alloc.hpp`` .
This file is included by
``cppad/cppad.hpp`` , but it can also be included separately with out
the rest of the ``CppAD`` .
Deprecated 2011-08-23
*********************
Use :ref:`thread_alloc-name` instead.
Contents
********
{xrst_toc_table
include/cppad/utility/omp_alloc.hpp
}
{xrst_end omp_alloc}
*/
================================================
FILE: appendix/directory.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin directory app}
{xrst_spell
chkpoint
ipopt
jit
json
omh
pkgconfig
}
Directory Structure
###################
A brief description of each of the CppAD directories is provided below:
Distribution Directory
**********************
The following table lists the sub-directories of the
:ref:`download@Distribution Directory` :
.. list-table::
:widths: auto
* - ``bin``
- Scripts used for CppAD development.
* - ``bug``
- Used to create a simple CppAD bug report or test.
* - ``build``
- Used to build the libraries, examples, and tests.
* - ``cmake``
- cmake macro files.
* - ``cppad_ipopt``
- Example and tests for the deprecated cppad_ipopt library.
* - ``cppad_lib``
- Source code corresponding to the CppAD library.
* - ``example``
- Source code for the CppAD examples.
* - ``external``
- Used to build optional packages; see :ref:`get_optional.sh-name`
* - ``include``
- The CppAD include directory.
* - ``introduction``
- Source code for the CppAD introduction.
* - ``omh``
- Contains files that are only used for documentation.
* - ``pkgconfig``
- Contains the CppAD pkg-config information.
* - ``speed``
- The CppAD speed tests.
* - ``test_more``
- Tests that are not part of the documentation.
Example Directory
*****************
The following table lists the sub-directories of the ``example``
directory.
.. list-table::
:widths: auto
* - ``abs_normal``
- examples using :ref:`abs_normal<example_abs_normal-name>` representation of non-smooth functions.
* - ``atomic_four``
- :ref:`atomic_four-title` function examples.
* - ``atomic_three``
- :ref:`atomic_three-title` function examples.
* - ``atomic_two``
- :ref:`atomic_two-title` examples not yet converted to use ``atomic_four`` .
* - ``chkpoint_two``
- :ref:`chkpoint_two-title` examples
* - ``code_gen_fun``
- :ref:`code_gen_fun-title` examples
* - ``general``
- general purpose examples.
* - ``get_started``
- a good place to get started using CppAD.
* - ``ipopt_solve``
- :ref:`ipopt_solve-title` examples.
* - ``jit``
- :ref:`example_jit-title`
* - ``json``
- :ref:`json_ad_graph-title` examples
* - ``multi_thread``
- CppAD :ref:`multi_threading<multi_thread-name>` examples.
* - ``optimize``
- examples using the :ref:`optimize-name` operation.
* - ``print_for``
- examples that used the :ref:`PrintFor-name` operation.
* - ``sparse``
- examples using :ref:`sparsity_patterns<sparsity_pattern-name>` and
:ref:`sparse_derivatives<sparse_derivative-name>` .
* - ``utility``
- example using the CppAD :ref:`utilities<utility-name>` .
{xrst_end directory}
================================================
FILE: appendix/faq.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin Faq app}
{xrst_spell
github
}
Frequently Asked Questions and Answers
######################################
Assignment and Independent
**************************
Why does the code sequence
| |tab| ``Independent`` ( *u* );
| |tab| *v* = *u* [0];
behave differently from the code sequence
| |tab| *v* = *u* [0];
| |tab| ``Independent`` ( *u* );
Before the call to :ref:`Independent-name` ,
*u* [0] is a :ref:`glossary@Parameter`
and after the call it is a variable.
Thus in the first case, *v* is a variable
and in the second case it is a parameter.
Bugs
****
What should I do if I suspect that there is a bug in CppAD ?
#. The first step is to check currently open
`issues <https://github.com/coin-or/CppAD/issues>`_ on github.
If it is an open issue, and you want to hurry it along, you can add
a comment to the effect that it is holding you up.
#. The next step is to search the
:ref:`whats_new-name` sections for mention of a related bug fix
between the date of the version you are using and the current date.
It the bug has been fixed, obtain a more recent release that has the fix
and see if that works for you.
#. The next step is to
create a simple demonstration of the bug;
see the file ``bug/template.sh`` for a template that you can
edit for that purpose.
The smaller the program, the better the bug report.
#. The next step is open a new issue on github and provide your simple
example so that the problem can be reproduced.
CompareChange
*************
If you attempt to use the
:ref:`CompareChange-name`
function when ``NDEBUG`` is true,
you will get an error message stating that
``CompareChange`` is not a member of the
:ref:`ADFun-name` template class.
Complex Types
*************
Which of the following complex types is better:
| |tab| ``AD< std::complex<`` *Base* > >
| |tab| ``std::complex< AD<`` *Base* > >
The :ref:`complex abs function<abs@Complex Types>` is differentiable
with respect to its real and imaginary parts,
but it is not complex differentiable.
Thus one would prefer to use
``std::complex< AD<`` *Base* > >
On the other hand, the C++ standard only specifies
``std::complex<`` *Type* > where *Type* is
``float`` , ``double`` , or ``lone double`` .
The effect of instantiating the template complex for any other type
is unspecified.
Exceptions
**********
Why, in all the examples, do you pass back a boolean variable instead
of throwing an exception ?
The examples are also used to test the correctness of CppAD
and to check your installation.
For these two uses, it is helpful to run all the tests
and to know which ones failed.
The actual code in CppAD uses the :ref:`ErrorHandler-name` utility
to signal exceptions.
Specifications for redefining this action are provided.
Independent Variables
*********************
Is it possible to evaluate the same tape recording with different values
for the independent variables ?
Yes (see :ref:`forward_zero-name` ).
Matrix Inverse
**************
Is it possible to differentiate (with respect to the matrix elements)
the computation of the inverse of a matrix
where the computation of the inverse uses pivoting ?
LuSolve
=======
The example routine :ref:`LuSolve-name` can be used to do this
because the inverse is a special case of the solution of linear equations.
The examples
:ref:`jac_lu_det.cpp-name` and :ref:`hes_lu_det.cpp-name`
use LuSolve to compute derivatives of the
determinant with respect to the components of the matrix.
Atomic Operation
================
One can also do this by making the inversion of the matrix an atomic operation;
e.g., see :ref:`atomic_two_eigen_mat_inv.cpp-name` .
Mode: Forward or Reverse
************************
When evaluating derivatives,
one always has a choice between
forward and reverse mode.
How does one decide which mode to use ?
In general, the best mode depends on the number of domain and range
components in the function that your are differentiating.
Each call to :ref:`Forward-name` computes the derivative of all
the range directions with respect to one domain direction.
Each call to :ref:`Reverse-name` computes the derivative of one
range direction with respect to all the domain directions.
The times required for (speed of)
calls ``Forward`` and ``Reverse`` are about equal.
The :ref:`fun_property@Parameter`
function can be used to quickly determine that
some range directions have derivative zero.
Namespace
*********
Test Vector Preprocessor Symbol
===============================
Why do you use ``CPPAD_TESTVECTOR`` instead of a namespace for
the CppAD :ref:`testvector-name` class ?
The preprocessor symbol ``CPPAD_TESTVECTOR`` ( see :ref:`testvector-name` )
determines which
:ref:`SimpleVector-name` template class is used for extensive testing.
The default definition for ``CPPAD_TESTVECTOR`` is the
:ref:`CppAD::vector<CppAD_vector-name>` template class, but it can be changed.
Note that all the preprocessor symbols that are defined or used
by CppAD begin with either ``CPPAD``
(some old deprecated symbols begin with ``CppAD`` ).
Speed
*****
How do I get the best speed performance out of CppAD ?
NDEBUG
======
You should compile your code with optimization, without debugging,
and with the preprocessor symbol ``NDEBUG`` defined.
(The :ref:`speed_cppad-name` tests do this.)
Note that defining ``NDEBUG``
will turn off all of the error checking and reporting that
is done using :ref:`ErrorHandler-name` .
Optimize
========
It is also possible that preforming a tape
:ref:`optimization<optimize-name>` will improve the speed of evaluation
more than the time required for the optimization.
Memory Allocation
=================
You may also increase execution speed
by calling ``hold_memory`` with
:ref:`ta_hold_memory@value` equal to true.
Tape Storage: Disk or Memory
****************************
Does CppAD store the tape on disk or in memory ?
CppAD uses memory to store a different tape for recording operations
for each ``AD`` < *Base* > type that is used.
If you have a very large number calculations that are recorded
on a tape, the tape will keep growing to hold the necessary information.
Eventually, virtual memory may be used to store the tape
and the calculations may slow down because of necessary disk access.
{xrst_end Faq}
================================================
FILE: appendix/glossary.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin glossary app}
{xrst_spell
is is
}
Glossary
########
AD Function
***********
Given an :ref:`ADFun-name` object *f*
there is a corresponding
AD of *Base* :ref:`operation sequence<glossary@Operation@Sequence>` .
This operation sequence
defines a function
:math:`F : \B{R}^n \rightarrow \B{R}^m`
where :math:`\B{R}` is the space corresponding to objects of type
*Base* (usually the real numbers),
*n* is the size of the :ref:`fun_property@Domain` space, and
*m* is the size of the :ref:`fun_property@Range` space.
We refer to :math:`F` as the AD function corresponding to
the operation sequence stored in the object *f* .
(See the :ref:`FunCheck discussion<FunCheck@Discussion>` for
possible differences between :math:`F(x)` and the algorithm that defined
the operation sequence.)
AD of Base
**********
An object is called an AD of *Base* object its type is
either ``AD`` < *Base* >
(see the default and copy :ref:`constructors<ad_ctor-name>`
or ``VecAD`` < *Base* >:: ``reference`` (see :ref:`VecAD-name` )
for some *Base* type.
AD Type Above Base
******************
If *Base* is a type,
an AD type above *Base*
is the following sequence of types:
``AD`` < *Base* > , ``AD< AD<`` *Base* > > , ``AD< AD< AD<`` *Base* > > > , ...
Base Function
*************
A function :math:`f : \B{R} \rightarrow \B{R}`
is referred to as a *Base* function,
if *Base* is a C++ type that represent elements of
the domain and range space of *f* .
Base Type
*********
If *x* is an ``AD`` < *Base* > object,
*Base* is referred to as the base type for *x* .
Elementary Vector
*****************
The *j*-th elementary vector :math:`e^j \in \B{R}^m` is defined by
.. math::
e_i^j = \left\{ \begin{array}{ll}
1 & {\rm if} \; i = j \\
0 & {\rm otherwise}
\end{array} \right.
Operation
*********
Atomic
======
An atomic *Type* operation is an operation that
has a *Type* result and is not made up of other
more basic operations.
Sequence
========
A sequence of atomic *Type* operations
is called a *Type* operation sequence.
A sequence of atomic :ref:`glossary@AD of Base` operations
is referred to as an AD of *Base* operation sequence.
The abbreviated notation operation sequence is often used
when it is not necessary to specify the type.
Dependent
=========
Suppose that *x* and *y* are *Type* objects and
the result of
*x* < *y*
has type ``bool`` (where *Type* is not the same as ``bool`` ).
If one executes the following code
| |tab| ``if`` ( *x* < *y* )
| |tab| |tab| *y* = ``cos`` ( *x* );
| |tab| ``else``
| |tab| |tab| *y* = ``sin`` ( *x* );
the choice above depends on the value of *x* and *y*
and the two choices result in a different *Type* operation sequence.
In this case, we say that the *Type* operation sequence depends
on *x* and *y* .
Independent
===========
Suppose that *i* and *n* are ``size_t`` objects,
and *x* [ *i* ] , *y* are *Type* objects,
where *Type* is different from ``size_t`` .
The *Type* sequence of operations corresponding to
| |tab| *y* = *Type* (0);
| |tab| ``for`` ( *i* = 0; *i* < *n* ; *i* ++)
| |tab| |tab| *y* += *x* [ *i* ];
does not depend on the value of *x* or *y* .
In this case, we say that the *Type* operation sequence
is independent of *y* and the elements of *x* .
Parameter
*********
Constant
========
An ``AD`` < *Base* > object *u* is a constant parameter if
its value does not depend on the value of
the :ref:`Independent-name` variable vector
or the :ref:`Independent@dynamic` parameter vector
for an :ref:`active tape<glossary@Tape@Active>` .
If *u* is a constant parameter,
:ref:`Constant(u)<con_dyn_var@Constant>` returns true,
:ref:`Parameter(u)<con_dyn_var@Parameter>` returns true,
:ref:`Dynamic(u)<con_dyn_var@Dynamic>` returns false, and
:ref:`Variable(u)<con_dyn_var@Variable>` returns false.
Dynamic
=======
An ``AD`` < *Base* > object *u* is a dynamic parameter if
its value does not depend on the value of
the :ref:`Independent-name` variable vector, but its value does depend
on the :ref:`Independent@dynamic` parameter vector,
for an :ref:`active tape<glossary@Tape@Active>` .
If *u* is a dynamic parameter, the function
:ref:`Dynamic(u)<con_dyn_var@Dynamic>` returns true
:ref:`Parameter(u)<con_dyn_var@Parameter>` returns true,
:ref:`Constant(u)<con_dyn_var@Constant>` returns false, and
:ref:`Variable(u)<con_dyn_var@Variable>` returns false.
Row-major Representation
************************
A :ref:`SimpleVector-name` *v* is a row-major representation of a matrix
:math:`M \in \B{R}^{m \times n}` if *v* . ``size`` () == *m* * *n* and
for :math:`i = 0 , \ldots , m-1`, :math:`j = 0 , \ldots , n-1`
.. math::
M_{i,j} = v[ i \times n + j ]
Sparsity Pattern
****************
Suppose that :math:`A \in \B{R}^{m \times n}` is a sparse matrix.
CppAD has several ways to specify the elements of :math:`A`
that are possible non-zero.
Row and Column Index Vectors
============================
A pair of non-negative integer vectors :math:`r`, :math:`c`
are a sparsity pattern for :math:`A`
if for every non-zero element :math:`A_{i,j}`,
there is a :math:`k` such that :math:`i = r_k` and :math:`j = c_k`.
Furthermore, for every :math:`\ell \neq k`,
either :math:`r_\ell \neq r_k` or :math:`c_\ell \neq c_k`.
Boolean Vector
==============
A boolean vector :math:`b`, of length :math:`m \times n`,
is a sparsity pattern for :math:`A`
if for every non-zero element :math:`A_{i,j}`,
:math:`b_{i \times n + j}` is true.
Vector of Sets
==============
A vector of sets :math:`s` of positive integers, of length :math:`m`,
is a sparsity pattern for :math:`A`
if for every non-zero element :math:`A_{i,j}`, :math:`j \in s_i`.
Tape
****
Active
======
A new tape is created and becomes active
after each call of the form (see :ref:`Independent-name` )
``Independent`` ( *x* )
All operations that depend on the elements of *x* are
recorded on this active tape.
Inactive
========
The :ref:`operation sequence<glossary@Operation@Sequence>`
stored in a tape can be transferred to a function object using the syntax
| |tab| ``ADFun`` < *Base* > *f* ( *x* , *y* )
| |tab| *f* . ``Dependent`` ( *x* , *y* )
see :ref:`fun_construct-name` .
After such a transfer, the tape becomes inactive.
The tape becomes inactive, without storing the operation sequence,
after a call to :ref:`abort_recording-name` .
Independent Variable
====================
While the tape is active, we refer to the elements of *x*
as the independent variables for the tape.
When the tape becomes inactive,
the corresponding objects become
:ref:`constants<glossary@Parameter@Constant>` .
Variables
=========
While the tape is active, we use the term variables for any scalar
whose value depends on the independent variables for the tape.
When the tape becomes inactive,
the corresponding objects become
:ref:`constants<glossary@Parameter@Constant>` .
Taylor Coefficient
******************
Suppose :math:`X : \B{R} \rightarrow \B{R}^n` is a
is :math:`p` times continuously differentiable function
in some neighborhood of zero.
For :math:`k = 0 , \ldots , p`,
we use the column vector :math:`x^{(k)} \in \B{R}^n` for the *k*-th order
Taylor coefficient corresponding to :math:`X`
which is defined by
.. math::
x^{(k)} = \frac{1}{k !} \Dpow{k}{t} X(0)
It follows that
.. math::
X(t) = x^{(0)} + x^{(1)} t + \cdots + x^{(p)} t^p + R(t)
where the remainder :math:`R(t)` divided by :math:`t^p`
converges to zero and :math:`t` goes to zero.
Variable
********
An ``AD`` < *Base* > object *u* is a variable if
its value depends on an independent variable vector for
a currently :ref:`active tape<glossary@Tape@Active>` .
If *u* is a variable,
:ref:`Variable(u)<con_dyn_var@Variable>` returns true,
:ref:`Constant(u)<con_dyn_var@Constant>` returns false,
:ref:`Dynamic(u)<con_dyn_var@Dynamic>` returns false, and
:ref:`Parameter(u)<con_dyn_var@Parameter>` returns false.
For example,
directly after the code sequence
| |tab| ``Independent`` ( *x* );
| |tab| ``AD<double>`` *u* = *x* [0];
the ``AD<double>`` object *u* is currently a variable.
Directly after the code sequence
| |tab| ``Independent`` ( *x* );
| |tab| ``AD<double>`` *u* = *x* [0];
| |tab| *u* = 5;
*u* is currently a
:ref:`glossary@Parameter@Constant` parameter,
not a dynamic parameter or a variable.
Note that we often drop the word currently and
just refer to an ``AD`` < *Base* > object as a variable
or parameter.
{xrst_end glossary}
================================================
FILE: appendix/license.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-22 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin License app}
Your License for the CppAD Software
###################################
Your License
************
{xrst_literal
COPYING
}
Eclipse Public License Version 2.0
**********************************
{xrst_literal
epl-2.0.txt
}
{xrst_end License}
================================================
FILE: appendix/numeric_ad.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-22 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin numeric_ad app}
Some Numerical AD Utilities
###########################
The routines listed below are numerical utilities that are
designed to work with CppAD in particular.
Contents
********
{xrst_toc_table
include/cppad/core/bender_quad.hpp
include/cppad/core/opt_val_hes.hpp
include/cppad/core/lu_ratio.hpp
}
{xrst_end numeric_ad}
================================================
FILE: appendix/whats_new/2003.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin 2003 app}
{xrst_spell
ddouble
def
dodds
faq
geq
hess
indvar
ini
leq
mak
valarray
}
Release Notes for 2003
######################
mm-dd
*****
12-24
=====
Some references to ``double`` should have been references
to the :ref:`glossary@Base Type`
(in reverse mode and in the ``Grad/`` and ``Hess`` functions).
This has been fixed.
12-22
=====
The preprocessor symbol ``WIN32`` was being used to determine
if one was using Microsoft's C++ compiler.
This symbol is predefined by the
`MinGW <http://www.mingw.org>`_ version of the GNU C++ compiler
and hence CppAD had errors during installation using MinGW.
This has been fixed by using the preprocessor symbol
``_MSC_VER`` to determine if
one is using the Microsoft C++ compiler.
12-14
=====
The extended system solvers ``OdeOne`` and ``OdeTwo`` have
been removed from the distribution.
In addition, the interface to the ODE solvers have been simplified.
12-13
=====
Remove the ``CppADCreateTape`` macro
and have the tapes created and grow automatically.
12-12
=====
The old method where one directly accesses the tape has been removed and the
following functions are no longer available:
| |tab| |tab| ``size_t`` *TapeName* . ``Independent`` ( ``AD`` < *Base* > & *indvar* )
| |tab| |tab| ``size_t`` *TapeName* . ``Record`` ( ``size_t`` *order* )
| |tab| |tab| ``size_t`` *TapeName* . ``Stop`` ( ``void`` )
| |tab| |tab| ``bool Dependent`` ( ``const AD`` < *Base* > & *var* ) ``const``
| |tab| |tab| ``bool`` *TapeName* . ``Dependent`` ( ``const AD`` < *Base* > & *var* ) ``const``
| |tab| |tab| ``size_t`` *TapeName* . ``Total`` ( ``void`` ) ``const``
| |tab| |tab| ``size_t`` *TapeName* . ``Required`` ( ``void`` ) ``const``
| |tab| |tab| ``size_t`` *TapeName* . ``Erase`` ( ``void`` )
| |tab| |tab| ``TapeState`` *TapeName* . ``State`` ( ``void`` ) ``const``
| |tab| |tab| ``size_t`` *TapeName* . ``Order`` ( ``void`` ) ``const``
| |tab| |tab| ``size_t`` *TapeName* . ``Required`` ( ``void`` ) ``const``
| |tab| |tab| ``bool Parameter`` ( ``CppADvector< AD<`` *Base* > > & *u* )
| |tab| |tab| *TapeName* . ``Forward`` ( *indvar* )
| |tab| |tab| *TapeName* . ``Reverse`` ( *var* )
| |tab| |tab| *TapeName* . ``Partial`` ( *var* )
| |tab| |tab| *TapeName* . ``ForwardTwo`` ( *indvar* )
| |tab| |tab| *TapeName* . ``ReverseTwo`` ( *var* )
| |tab| |tab| *TapeName* . ``PartialTwo`` ( *var* )
12-10
=====
The change on :ref:`2003@mm-dd@12-01` make the taping process simpler
if one does not directly access
``CppADCreateTape`` .
The :ref:`examples<example-name>` were changed to not use
*TapeName* .
The following examples were skipped because
they document the functions that access *TapeName* :
``DefFun.cpp`` ,
``For.cpp`` ,
``for_two.cpp`` ,
``Rev.cpp`` , and
``rev_two.cpp`` .
12-05
=====
There was a bug in
*f* . ``Rev`` and
*f* . ``RevTwo`` and
when two dependent variables were always equal and shared
the same location in the tape.
This has been fixed.
The ODE Example was changed to tape the solution
(and not use ``OdeOne`` or ``OdeTwo`` ).
This is simpler to use and
the resulting speed tests gave much faster results.
12-01
=====
The following function has been added:
``void Independent`` ( ``const CppADvector`` < *Base* > & *x* )
which will declare the independent variables and begin recording
``AD`` < *Base* > operations
(see :ref:`Independent-name` ).
The :ref:`ADFun-name` constructor was modified so that it
stops the recording and erases that tape as well as creates the
:ref:`ADFun-name` object.
In addition, the tape no longer needs to be specified in the constructor.
11-21
=====
Add ``StiffZero`` to set of ODE solvers.
11-20
=====
The ``AbsGeq`` and ``LeqZero`` in
:ref:`LuSolve-name` were changed to template functions so they could have
default definitions in the case where the ``<=`` and ``>=``
operators are defined.
This made the ``double`` and ``AD<double>`` use of
``LuSolve`` simpler because the user need not worry about these functions.
On the other hand, it made the ``std::complex``
and ``AD<std::complex>`` use of
``LuSolve`` more complex.
The member function names for the
*fun* argument to ODE were changed from
*fun* . ``f`` to
*fun* . ``Ode``
and from
*fun* . ``g`` to
*fun* . ``Ode_ini`` .
11-16
=====
The table of contents was reorganized
to provide a better grouping of the documentation.
The :ref:`LuSolve-name` utility is now part of the distribution
and not just an example; i.e.,
it is automatically included by
``cppad.hpp`` .
11-15
=====
The
ODE solver was modified so that it can
be used with any type (not just an AD type.
This was useful for the speed testing.
It is also useful for determining how the integrator
steps should be before starting the tape.
The template argument *Type* was changed to
*Base* where ever it was the
:ref:`glossary@Base Type` of an AD class.
11-14
=====
An
``speed_cppad/OdeSpeed.cpp/`` test was added
and some changes were made to the
ODE interface in order to make it faster.
The most significant change was in the specifications for
the ODE function object *fun* .
11-12
=====
The user defined unary function example
``example/UnaryFun.cpp`` was incorrect.
It has been corrected and extended.
11-11
=====
The :ref:`CppAD::vector<CppAD_vector-name>` template class is now
used where the ``std::vector`` template class was previously used.
You can replace the ``CppAD::vector`` class
with a vector template class of your choosing during the
:ref:`Install-name` procedure.
11-06
=====
The documentation for
:ref:`taping derivative calculations<mul_level-name>` was improved
as well as the corresponding example.
In order to make this simpler,
the example tape name ``DoubleTape`` was changed to ``ADdoubleTape``
(and the other example tape names were also changed).
11-04
=====
The ODE utility was changed from an example to
part of the distribution.
In addition, it was extended so that it now supports taping the
solution of the differential equations (case *order* equal zero)
or solving the extended set of differential equations
for both first and second derivatives (cases *order* equal
one and two).
In addition, an initial condition that depends on the parameter
values is also allowed.
11-02
=====
It is now legal to differentiate a
:ref:`glossary@Parameter`
with respect to an
:ref:`glossary@Tape@Independent Variable`
(parameter derivatives are always equal to zero).
This is an extension of the
``Reverse`` ,
``Partial`` ,
``ReverseTwo`` , and
``PartialTwo``
functions.
10-21
=====
All the ``CppAD`` include files,
except ``cppad.hpp`` were moved into an ``include`` subdirectory.
10-16
=====
The :ref:`ADFun-name` template class was added so that one can save
a tape recording and use it as a differentiable function.
The ``ADFun`` functions supports directional derivatives in both
:ref:`Forward-name` and :ref:`Reverse-name` mode where as the
tape only supports partial derivatives.
10-14
=====
The ``sqrt`` function was added to the
:ref:`unary_standard_math-name` functions.
In addition, a definition of the power function for the types
``float`` and ``double``
was automatically included in the ``CppAD`` namespace.
The :ref:`Value-name` function was changed so that it can
be called when the tape is in the Empty state.
10-10
=====
The ``atan`` function was added to the
:ref:`unary_standard_math-name` functions.
10-06
=====
In the notation below, *zero* and *one*
are parameters that are exactly equal to zero and one.
If the variables *z* and *x*
were related in any of the following ways,
they share can share the same record on the tape
because they will have the same derivatives.
| |tab| *z* = *x* + *zero* *z* = *x* * *one*
| |tab| *z* = *zero* + *x* *z* = *one* * *x*
| |tab| *z* = *x* ``-`` *zero* *z* = *x* / *one*
Furthermore, in the following cases, the result
*z* is a parameter (equal to zero)
and need not be recorded in the tape:
| |tab| *z* = *x* * *zero* *z* = *zero* / *x*
| |tab| *z* = *zero* * *x*
The
:ref:`arithmetic operators<Arithmetic-name>` were
all checked to make sure they did not add to the tape
in these special cases.
The total record count for the program in the Example directory
was 552 before this change
and 458 after.
10-05
=====
The process of converting the tape to operators was completed.
In order to make this conversion, the binary user defined
functions were removed.
(Bob Goddard
suggested a very nice way to keep the unary functions.)
Another significant change was made to the user interface during this procedure,
the standard math library functions
are now part of the CppAD distribution and not defined by the user.
The function *TapeName* . ``Total`` was added
to make it easy to track how many tape records are used by
the test suite.
This will help with future optimization of the CppAD recording process.
There was a bug
(found by `Mike Dodds <mailto:magister@u.washington.edu>`_)
in the error checking of the
*TapeName.Erase* function.
If ``Erase`` was called twice in a row,
and ``NDEBUG`` was false during compilation,
the program would abort.
This has been fixed.
09-30
=====
A process of changing the tape from storing partial derivatives to
storing operators has been started.
This will make the tape smaller and it will enable the computation
of higher derivatives with out having to tape the tape
(see :ref:`mul_level-name` ).
The Add, Subtract, Multiply and Divide operators have been converted.
The user defined functions are presenting some difficulties,
so this process has not yet been completed.
There was a bug in reverse mode when an dependent variable
was exactly equal to an independent variable.
In this case, it was possible for it to be located
before other of the independent variables on the tape.
These other independent variable partials were not initialized
to zero before the reverse calculation and hence had what ever
value was left by the previous mode calculation.
This has been fixed and the
``Eq.cpp`` example has been changed to test for this case.
The following tape functions were changed to be declared
``const`` because they do not modify the tape in any way:
``State`` ,
``Order`` ,
``Required`` ,
``Dependent`` , and
:ref:`con_dyn_var@Parameter` .
09-20
=====
The functions ``Grad`` and ``Hess`` were
changed to use function objects
instead of function pointers.
09-19
=====
The higher order constructors (in standard valarray) were removed from the
ODE example in order to avoid memory allocation of temporaries
(and hence increase speed).
In addition, the function objects in the
ODE examples were changed to be ``const`` .
09-18
=====
An ordinary differential equation solver was added.
In addition,
the extended system to differentiate the solution was included.
09-15
=====
The linked list of AD variables was not being maintained correctly
by the AD destructor.
This was fixed by have the destructor use ``RemoveFromVarList``
to remove variables from the list.
(``RemoveFromVarList`` is a private AD member function
not visible to the user.)
09-14
=====
There is a new Faq question about evaluating derivatives at multiple
values for the
:ref:`Faq@Independent Variables` .
09-13
=====
An example that uses
``AD< AD<double> >``
to compute higher derivatives was added.
The name ``GaussEliminate`` was changed to
:ref:`LuSolve-name` to better reflect the solution method.
09-06
=====
Changed the
:ref:`get_started.cpp-name` and :ref:`complex_poly.cpp-name` examples
so they use a template function with both base type and AD type arguments.
(The resulting code is simpler and a good use of templates.)
09-05
=====
A :ref:`getting started<get_started.cpp-name>`
example was added and the organization
of the :ref:`Examples<example-name>` was changed.
09-04
=====
The ``AbsOfDoubleNotDefine`` flag is no longer used
and it was removed from the Windows
:ref:`Install-name` instructions.
The 03-09-03 distribution did not have the proper date
attached to it.
The distribution script has been changed so that attaching
the proper date is automated
(i.e., this should not happen again).
A :ref:`faq-title` section was started.
09-03
=====
Added the
:ref:`Value-name` function which returns
the :ref:`glossary@Base Type` value
corresponding to an AD object.
08-23
=====
A new version of Cygwin was installed on the development system
(this may affect the timing tests reported in this document).
In addition, :ref:`LuSolve-name` was changed to use back substitution
instead of reduction to an identity matrix. This reduced the number
of floating point operations corresponding to evaluation of the determinant.
The following results correspond to the speed test
of DetLu on a 9 by 9 matrix:
.. list-table::
:widths: auto
* - **Version**
- **double Rate**
- **AD<double> Rate**
- **Gradient Rate**
- **Hessian Rate**
- **Tape Length**
* - 03-08-20
- 8,524
- 5,278
- 4,260
- 2,450
- 532
* - 03-08-23
- 7,869
- 4,989
- 4,870
- 2,637
- 464
08-22
=====
The
:ref:`unary minus<unary_minus-name>` operator was added to the AD operations.
08-19
=====
The standard math function
examples were extended to include the complex case.
The
:ref:`LuSolve-name`
routine what changed to use
``std::vector<`` *Base* > & arguments in place of
*Base* * arguments.
This removes the need to use ``new`` and ``delete``
with ``LuSolve`` .
When testing the speed of the change to using standard vector,
it was noticed that the LuSolve routine
was much slower. (see times for 03-08-16 below).
This was do to computing the determinant instead of the log
of the determinant.
Converting back to the log of the determinant regained
the high speeds.
The following results correspond to the speed test
of DetLu on a 9 by 9 matrix:
.. list-table::
:widths: auto
* - **Version**
- **double Rate**
- **AD<double> Rate**
- **Gradient Rate**
- **Hessian Rate**
- **Tape Length**
* - 03-08-16
- 9,509
- 5,565
- 3,587
- 54
- 537
* - 03-08-19
- 8,655
- 5,313
- 4,307
- 2,495
- 532
08-17
=====
The macro
``CppADTapeOverflow`` was added
so that CppAD can check for tape overflow
even in the ``NDEBUG`` preprocessor flag is defined.
08-16
=====
The
:ref:`LuSolve-name` routine was extended to
handle complex arguments.
Because the complex absolute value function is nowhere differentiable,
this required the allowing for user defined
:ref:`boolean valued functions with AD arguments<bool_fun-name>` .
The examples
:ref:`lu_solve.cpp-name`
and
``GradLu.cpp``
were converted to a complex case.
08-11
=====
The routine :ref:`LuSolve-name` was made more efficient
so that it is more useful as a tool for
differentiating linear algebra calculations.
The following results correspond to the speed test
of DetLu on a 9 by 9 matrix:
.. list-table::
:widths: auto
* - **Version**
- **double Rate**
- **AD<double> Rate**
- **Gradient Rate**
- **Hessian Rate**
- **Tape Length**
* - 03-08-10
- 49,201
- 7,787
- 2,655
- 1,809
- 824
* - 03-08-11
- 35,178
- 12,681
- 4,521
- 2,541
- 540
In addition the corresponding test case
:ref:`lu_solve.cpp-name` was changed to a Hilbert matrix case.
08-10
=====
A :ref:`complex polynomial<complex_poly.cpp-name>`
example was added.
The documentation and type conversion in
:ref:`LuSolve-name` was improved.
The absolute value function was removed from the examples because
some systems do not yet properly support ``double abs`` ( ``double`` *x* ) ,
08-07
=====
Because the change to the multiplication operator had such
a large positive effect,
all of the
:ref:`arithmetic operators<Arithmetic-name>`
were modified to reduce the amount of information
in the tape (where possible).
08-06
=====
During Lu factorization, certain elements of the matrix
are know to be zero or one and do not depend on the variables.
The :ref:`multiplication<ad_binary-name>` operator was modified to take
advantage of this fact.
This reduced the size of the tape and increased the speed
for the calculation of the gradient and Hessian for
the Lu determinant test of a 5 by 5 matrix as follows:
.. list-table::
:widths: auto
* - **Version**
- **Tape Length**
- **Gradient Rate**
- **Hessian Rate**
* - 03-08-05
- 176
- 11,362
- 1,149
* - 03-08-06
- 167
- 12,780
- 10,625
08-05
=====
Fixed a mistake in the calculation of the sign of the determinant in
the :ref:`LuSolve-name` example.
08-04
=====
Added a the compiler flag
::
AbsOfDoubleNotDefined
to the make files so that it could be removed on systems where the
function
``double abs`` ( ``double`` *x* )
was defined in ``math.h`` .
08-03
=====
The
``Grad`` and ``Hess`` functions were modified
to handle the case where the function does not depend on
the independent variables.
The
:ref:`LuSolve-name` example was added to show how
on can differentiate linear algebra calculations.
In addition, it was used to add another set of
:ref:`speed tests<speed_cppad-name>` .
The standard Math functions were added both
as examples of defining atomic operations and to support
mathematical operations for the ``AD<double>`` case.
The :ref:`\<\<<ad_output-name>` operator was added to the ``AD``
template class for output to streams.
08-01
=====
The
:ref:`compound assignment<Arithmetic-name>` operators were added
to the ``AD`` template class.
The name of the ``Speed/SpeedTest`` program was changed to
:ref:`Speed/Speed<speed_cppad-name>` .
In addition, ``Speed/SpeedRun`` was changed to
``Speed/SpeedTest`` .
07-30
=====
The
:ref:`assignment<ad_assign-name>`
operator was changed so the it returns a reference to
the target.
This allows for statements of the form
*x* = *y* = *z* ;
i.e., multiple assignments.
07-29
=====
If the
:ref:`AD copy constructor<ad_ctor-name>` or
:ref:`assignment<ad_assign-name>` operator
used an
:ref:`glossary@Tape@Independent Variable`
for its source value,
the result was also an independent variable.
This has been fixed so that the result is
a dependent variable in these cases.
07-26
=====
The ``AD`` < *Base* > data structure
was changed to include a doubly linked list of variables.
This enabled the
:ref:`AD copy constructor<ad_ctor-name>` and
:ref:`assignment<ad_assign-name>` operator
to create multiple references to
the same place in the tape.
This reduced the size of the tape and increased the speed
for the calculation of the gradient and Hessian for
the determinant of a 5 by 5 matrix as follows:
.. list-table::
:widths: auto
* - **Version**
- **Tape Length**
- **Gradient Rate**
- **Hessian Rate**
* - 03-07-22
- 1668
- 1,363
- 53
* - 03-07-26
- 436
- 3,436
- 213
07-22
=====
The facility was added so that the user can define
binary functions
together with their derivatives.
(This facility has been removed because it is better to define
binary functions using AD variables.)
The Windows version make file directive ``/I ..\..``
in ``example\Example.mak`` and ``Speed\Speed.mak``
was changed to ``/I ..`` (as it should have been).
07-20
=====
The facility was added so that the user can define
unary functions,
together with their derivatives.
For example, the standard math functions such as
:ref:`exp<exp.cpp-name>`
are good candidates for such definitions.
(This feature has been replaced by and the standard math functions
are now part of the AD types, see :ref:`AD-name` .)
The first Alpha for the Windows
:ref:`installation<Install-name>` was released.
07-18
=====
Computing the determinant of a minor of a matrix
:ref:`det_of_minor-name`
was documented as a realistic example using CppAD.
07-16
=====
Fixed some non-standard constructions that caused problems
with the installation on other machines.
Compiled and ran the tests under Microsoft Windows.
(The Windows release should not take much more work.)
07-14
=====
First Alpha release of CppAD
and is being released under the
:ref:`Gnu Public License<License-name>` .
It is intended for use by a Unix system.
A Microsoft release is intended in the near future.
{xrst_end 2003}
================================================
FILE: appendix/whats_new/2004.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin 2004 app}
{xrst_spell
aclocal
autoconf
automake
dep
deps
dodds
dsp
executables
ext
faq
filename
hess
mak
makefile
nmake
retape
ublas
usr
yy
}
Release Notes for 2004
######################
mm-dd
*****
12-11
=====
The documentation for the CppAD error macros was improved.
The package title in :ref:`user_guide-name` was changed.
The documentation for :ref:`CppAD::vector<CppAD_vector-name>`
was improved and the corresponding source code
``cppad/vector.hpp`` was included.
12-09
=====
The :ref:`LuSolve-name` and ``OdeRunge`` source code
was modified to make the more in line with the introduction
to C++ AD book
(``OdeRunge`` has been replaced by :ref:`Runge45-name` ).
In addition, the examples ``OdeRunge.cpp`` and
:ref:`lu_solve.cpp-name` were modified to make the simpler.
(The more complex version of ``OdeRunge.cpp``
was moved to the ``TestMore`` directory.)
12-03
=====
The :ref:`Poly-name` documentation and source code were modified to
make them more in line with the introduction to C++ AD book.
11-17
=====
Changing to Autoconf and Automake on
:ref:`2004@mm-dd@08-24` mistakenly forgot
the ``-Wall`` compiler switch (all warnings).
This has been added and the corresponding warnings
have been fixed.
11-16
=====
The 11-15 Debug version would not compile under Visual C++ version 7.0
because a declaration of ``LessThanOrZero`` was missing.
This has been fixed.
11-15
=====
The :ref:`ForOne-name` and :ref:`RevOne-name`
easy to use :ref:`Drivers-name` were added.
11-14
=====
The notation in the :ref:`ADFun-name` sections was changed
to make the :ref:`Forward-name` and :ref:`Reverse-name` routines
easier to use.
11-13
=====
The Taylor coefficient vector and matrix notation was folded into
just :ref:`Taylor coefficients<glossary@Taylor Coefficient>` .
11-12
=====
If ``NDEBUG`` is not defined during compile time,
all ``AD`` < *Base* >
:ref:`comparison<Compare-name>` operations are checked during
:ref:`zero order<forward_zero-name>` forward mode calculations.
The
:ref:`CompareChange-name` function
returns the number of comparison operations that have changed.
11-10
=====
The :ref:`get_started.cpp-name` example was changed to use the
:ref:`Jacobian-name` driver.
In addition, more index entries,
that point to the :ref:`easy to use drivers<Drivers-name>` ,
were added.
11-04
=====
The Microsoft Visual Studio
project file ``example/Example.dsp/`` was missing some
new examples that needed to be linked in
the install windows procedure.
This has been fixed.
11-02
=====
The :ref:`unix installation<configure-name>` required the user
to touch the files to get the dates in proper order.
This is no longer necessary.
11-01
=====
Some of the dependency directories and files, for example
``PrintFor/.deps`` and
``PrintFor/.deps/PrintFor.Po`` had an extra ``?``
at the end of their names.
This seems to have been fixed by using a newer version of the autoconf
and automake tools.
10-29
=====
Add the example and test :ref:`simple_vector.cpp-name`
to the :ref:`SimpleVector-name` documentation.
The specifications for
:ref:`preprocessor symbols<preprocessor-name>`
state that all the CppAD preprocessor symbols
begin with ``CppAD``
(so they do not conflict with other packages).
Some preprocessor symbols in the file ``cppad/config.h`` did
began with ``WITH_`` .
This has been fixed.
10-28
=====
The examples
:ref:`hes_lu_det.cpp-name` ,
:ref:`hes_minor_det.cpp-name` ,
:ref:`jac_lu_det.cpp-name` ,
and
:ref:`jac_minor_det.cpp-name` used the negative of a ``size_t`` value.
The value has been changed to an ``int`` .
The :ref:`CppAD::vector<CppAD_vector-name>` template class
was converted into a library routine so it can be used
separately from the rest of CppAD.
10-27
=====
The :ref:`PrintFor-name` example was moved to its own directory
because the conversion from VC 6.0 to VC 7.0 projects
did not work when there were multiple executables in one project file.
The :ref:`install-name` instructions were modified to reflect this change.
10-21
=====
One declaration (for the :ref:`Value-name` function) was missing
from the file ``cppad/local/Declare.h`` .
This has been added and CppAD should now compile and run
under both Microsoft VC 6.0 and 7.0.
10-19
=====
The current version of CppAD has a problem compiling under Microsoft
Visual C++ version 7.0 (it compiles and works under version 6.0).
The problem appears to be due to a closer agreement between VC 7.0 and the
C++ standard for declaring templates functions as friends.
Some friend declarations were removed and others were made more specific
in order to migrate the a version that will compile and run using VC 7.0.
10-16
=====
The example :ref:`compare.cpp-name` displayed the text from
:ref:`bool_fun.cpp-name` by mistake.
This has been fixed.
The :ref:`Compare-name` operators have been extended to work with
``int`` operands.
10-06
=====
The test
``TapeDetLu`` was added to ``speed_cppad/DetLuSpeed.cpp``
and
``TapeDetMinor`` was added to ``speed_cppad/DetMinorSpeed.cpp`` .
These tests just tape the calculations without computing any derivatives.
Using this, and the other tests, one can to separate the taping time
from the derivative calculation time.
The
windows installation steps
do not build a ``config.h`` file.
Hence a default ``config.h`` file was added to the
distribution for use with Microsoft Visual Studio.
The ``Distribute`` section of the
developer documentation was brought up to date.
Links to the ADOLC and FADBAD download pages were added
to the :ref:`unix installation<configure-name>` instructions.
09-29
=====
The include files for the :ref:`utilities<utility-name>` are now included
by the root file ``cppad/cppad.hpp`` .
They can still be included individually with out the rest of
the CppAD package.
09-26
=====
The routine ``OdeRunge`` was modified
so that it will now integrate functions of a complex arguments.
This was done by removing
all uses of greater than and less than comparisons were removed.
(``OdeRunge`` has been replaced by :ref:`Runge45-name` ).
The changes on :ref:`2004@mm-dd@09-21` did not fix all
the file date and time problems; i.e., automake was still running
in response to the :ref:`unix installation<configure-name>`
``make`` command.
09-23
=====
There was a reference to *B* that should have been *X*
in the description of the
:ref:`LuSolve@X` argument of ``LuSolve`` .
This has been fixed.
09-21
=====
The :ref:`CondExp-name` function has been modified so that it works properly
for ``AD< AD<`` *Base* > > types; i.e.,
it now works for multiple levels of taping.
The date of the files ``aclocal.m4`` and ``config.h.in``
were later than the date of top level ``Makefile.am`` .
This caused the ``make`` command during the
:ref:`unix installation<configure-name>`
to try to run ``autoconf``
and this did not work on systems with very old versions of ``autoconf`` .
This has been fixed.
09-13
=====
The examples that are specific to an operation were moved
to be below that operation in the documentation tree.
For example
:ref:`add.cpp-name` is below :ref:`ad_binary-name`
in the documentation tree.
09-10
=====
The version released on 04-09-09 did not have the
new file ``PrintFor.h`` in ``cppad/local`` .
This has been fixed.
The *Base* type requirements were simplified.
The :ref:`Unix installation<configure-name>` instructions
were modified so just one make command was executed at the top level.
This was necessary because the order of the makes is now important
(as previously suggested, the makes did not work properly).
09-09
=====
The :ref:`PrintFor-name` function was added so that
users can debug the computation of function values
at arguments that are different from those used when taping.
09-07
=====
In the :ref:`Unix installation<configure-name>` instructions
place ``./`` in front of current directory program names; for example,
``./GetStarted`` instead of ``GetStarted``
(because some unix systems do not have the current directory
in the default executable path).
09-04
=====
A library containing the
:ref:`SpeedTest-name` and :ref:`NearEqual-name` object files
was added to the distribution.
All of the include files of the form
< ``cppad/library/`` *name* . ``h>`` were moved to
< ``cppad/`` *name* . ``h>`` .
09-02
=====
Some more messages were added to the output of ``configure``
during the :ref:`Unix installation<configure-name>` .
The suggested compression program during
Windows installation
was changed from
`7-zip <https://7-zip.org/>`_
to
`WinZip <https://www.winzip.com/en/>`_.
08-27
=====
The error messages printed by the default version of
the CppAD error macros had ``YY-MM-DD`` in place of the
date for the current version.
This has been fixed.
All the correctness tests are now compiled with the ``-g``
command line option
(the speed tests are still compiled with ``-O2 -DNDEBUG`` ).
The :ref:`installation instructions<Install-name>` for
Unix and Windows were split into separate pages.
08-25
=====
The :ref:`installation<Install-name>` now automates the replacement
of :ref:`CppAD::vector<CppAD_vector-name>` by
either the ``std::vector``
or ``boost::numeric::ublas::vector`` .
08-24
=====
This date marks the first release that uses
the Gnu tools Autoconf and Automake.
This automates the building of the make files for the
:ref:`installation<Install-name>` and is the standard
way to distribute open source software.
This caused some organizational changes,
for example, the :ref:`GetStarted<get_started.cpp-name>` example now
has its own directory and
the distribution directory is named
``cppad-`` *yy* ``-`` *mm* ``-`` *dd*
where *yy* ``-`` *mm* ``-`` *dd* is the year, month and date
of the distribution.
(Note the distribution directory is different from the directory
where CppAD is finally installed.)
08-12
=====
Move ``OdeExplicit`` into the ``cppad/library/`` directory.
In addition, change it so that the vector type was a template argument; i.e.,
works for any type of vector (not just ``CppADvector`` ).
07-31
=====
Move :ref:`LuSolve-name` into the ``cppad/library/`` directory.
In addition, change it so that the vector type was a template argument; i.e.,
works for any type of vector (not just ``CppADvector`` ).
07-08
=====
The file ``cppad/example/NearEqual.h`` has been moved
to ``cppad/example/NearEqualExt.h`` because it contains
extensions of the :ref:`NearEqual-name` routine to ``AD`` types.
07-07
=====
The ``double`` and ``std::complex<double>``
cases for the :ref:`NearEqual-name` routine arguments
has been moved to the general purpose :ref:`utilities<utility-name>` .
07-03
=====
The CppAD error macros names
``CppADExternalAssert`` and ``CppADInternalAssert``
were changed to
``CppADUsageError`` and ``CppADUnknownError`` .
The :ref:`SpeedTest-name` routine was changed to use ``CppADUsageError``
instead of a C assert.
07-02
=====
The :ref:`SpeedTest-name` output was improved so that the columns of
values line up. Previously, this was not the case when
the number of digits in the size changed.
06-29
=====
Added code to trap and report memory allocation errors during
``new`` operations.
06-25
=====
A discussion of the order dependence of the
:ref:`assignment<ad_assign-name>` operator
and the
:ref:`independent function<Independent-name>`
was added to the
:ref:`Faq<Faq@Assignment and Independent>` .
In addition,
a similar discussion
was added to the documentation for the
:ref:`Independent-name` function.
The definition of a
:ref:`glossary@Parameter`
and
:ref:`glossary@Variable`
were changed to reflect that fact that
these are time dependent (current) properties
of an ``AD`` < *Base* > object.
06-12
=====
All of the
:ref:`arithmetic operators<Arithmetic-name>`
(except for the unary operators)
can now accept ``int`` arguments.
The documentation for these arguments has been changed to reflect this.
In addition,
the corresponding test cases have been changed to test this and to
test high order derivative cases.
The old versions of these tests were moved into the
``cppad/Test`` directory.
06-04
=====
The :ref:`atan2-name` function was added.
06-03
=====
The ``asin`` and ``acos``
:ref:`unary_standard_math-name` functions were added.
There was a bug the reverse mode theory and calculation of
derivatives of :ref:`sqrt-name` for fourth and higher orders.
This has been fixed.
In addition,
the following examples have been changed
so that they test derivative up to fifth order:
:ref:`asin<Asin.cpp-name>` ,
:ref:`atan<atan.cpp-name>` ,
:ref:`cos<cos.cpp-name>` ,
:ref:`exp<exp.cpp-name>` ,
:ref:`log<log.cpp-name>` ,
:ref:`sin<sin.cpp-name>` ,
:ref:`sqrt<sqrt.cpp-name>` .
06-01
=====
There was a bug in the :ref:`atan-name` function
:ref:`forward mode<Forward-name>` calculations for Taylor coefficient
orders greater than two.
This has been fixed.
05-30
=====
The :ref:`sin<sin.cpp-name>` and :ref:`cos<cos.cpp-name>` examples were
changed so that they tested higher order derivatives.
05-29
=====
The forward mode recursion formulas for each of the
:ref:`standard math functions<forward_theory@Standard Math Functions@Cases that Apply Recursion Above>`
has been split into separate sections.
A roman (instead of italic) font was used for the name of
for the name of each of the standard math functions
in the assumption statements below the section
for the standard math functions.
For example, :math:`\sin(x)` instead of :math:`sin(x)`.
05-26
=====
In the documentation for :ref:`Poly-name` ,
the reference to ``example/Poly.h``
was corrected to ``cppad/library/Poly.h`` .
In the documentation for :ref:`SpeedTest-name` ,
the reference to ``Lib/SpeedTest.h``
was corrected to ``cppad/library/SpeedTest.h`` .
In addition, the example case was corrected.
In :ref:`Reverse-name` , the definition for :math:`U(t, u)` had
:math:`t^p-1` where it should have had :math:`t^{p-1}`.
This has been fixed.
05-25
=====
The special case where the second argument to the :ref:`pow-name` function is an
``int`` has been added.
05-14
=====
Change all of the include syntax
# ``include`` " *filename* "
to the syntax
# ``include`` < *filename* >
so that examples and other use better reflect how one would use CppAD after
it was installed in a standard include directory; for example
``/usr/local/include/cppad`` .
The user documentation was moved from the directory
``cppad/User`` to the directory ``cppad/Doc`` .
The directory ``cppad/Lib`` was moved to ``cppad/library``
to reflect that fact that it is not what one expects in a standard
``lib`` directory or a standard ``include`` directory.
05-12
=====
The string ``YY-MM-DD`` in the preprocessor symbol ``CppADVersion``
was not being replaced by the current date during distribution.
This resulted in the ``CppADExternalAssert`` macro printing
``YY-MM-DD`` where is should have printed the date of distribution.
This has been fixed.
All of the include commands of the form
| |tab| # ``include`` " ``include/`` *name* . ``h`` "
| |tab| # ``include`` " ``lib/`` *name* . ``h`` "
have been changed to the form
| |tab| # ``include`` " ``cppad/include/`` *name* . ``h`` "
| |tab| # ``include`` " ``cppad/lib/`` *name* . ``h`` "
This will avoid mistakenly loading a file from another package
that is in the set of directories being searched by the compiler.
It is therefore necessary to specify that the directory above the
``CppAD`` directory be searched by the compiler.
For example,
if ``CppAD`` is in ``/usr/local/cppad`` ,
you must specify that ``/usr/local`` be searched by the compiler.
Note that if ``/usr/local/cppad/`` is no longer searched,
you will have to change
::
# include "cppad.hpp"
to::
# include "cppad/cppad.hpp"
The window ``nmake`` file ``Speed/Speed.mak`` was out of date.
This has been fixed.
05-09
=====
Move :ref:`Poly-name` and :ref:`SpeedTest-name` into the
``cppad/Lib`` directory and the ``CppAD`` namespace.
05-07
=====
The :ref:`divide operator tests<div.cpp-name>` were extended to
include a second order derivative calculation using reverse mode.
The :ref:`Poly-name` routine was modified to be more efficient in the
derivative case. In addition, it was changed to use an arbitrary
vector for the coefficients (not just a ``CppADvector`` ).
05-04
=====
A reloading of the data base
caused the files ``include/atan.h`` and ``include/cos.h`` to be
mistakenly started with lower case letters.
These have been moved to ``include/Atan.h`` and ``include/Cos.h``
respectively.
05-03
=====
The :ref:`Reverse-name` mode calculations for
:ref:`conditional expressions<CondExp-name>` were mistakenly left out.
This has been fixed.
04-29
=====
The unary functions, such as :ref:`sin-name` and :ref:`cos-name` ,
were not defined for elements of an :ref:`VecAD-name` vector.
This has been fixed.
04-28
=====
The operator :ref:`\<\<<CppAD_vector@Output>` was added to the
default ``test_vector`` template class.
A FADBAD correctness and speed comparison with CppAD
was added.
04-25
=====
Factor out common sub-expressions in order to make
:ref:`lu_vec_ad.cpp-name` faster.
Convert description
from C++ Automatic Differentiation to C++ Algorithmic Differentiation.
04-24
=====
The :ref:`VecAD-name` element class is no longer
a derived class of the :ref:`AD-name` class.
This enabled a decrease in tape memory
and an increase in the speed for :ref:`VecAD-name` operations.
The :ref:`log10-name` function was added.
04-22
=====
Add :ref:`CondExp-name` and use it to speed up :ref:`lu_vec_ad.cpp-name` .
04-21
=====
Use :ref:`abs-name` to speed up :ref:`lu_vec_ad.cpp-name` .
04-20
=====
The :ref:`absolute value<abs-name>` function was added.
The value *n* for
``OdeExplicit`` and ``OdeImplicit``
is deduced from the argument *x0* and is not passed
as a separate argument.
This documentation has been fixed to this effect.
04-19
=====
The :ref:`+=<compound_assign-name>` operator did not function correctly
when the left hand operand was a
:ref:`glossary@Parameter`
and the right hand operand was a variable
(found by `Mike Dodds <mailto:magister@u.washington.edu>`_).
This has been fixed.
04-09
=====
Adding special operators for using parameters to index ``VecAD`` objects
increased the speed and reduced the memory requirements (by about 20%) for
the :ref:`VecAD-name` case in the ``speed_cppad/LuSolveSpeed.cpp/`` test.
The :ref:`VecAD-name` objects are not being handled correctly by the
:ref:`Reverse-name` function.
The ``VecAD`` test was extended to demonstrate the problem
and the problem was fixed
(it is now part of ``TestMore/VecAD`` ).
04-08
=====
The example :ref:`lu_vec_ad_ok.cpp-name`
uses :ref:`VecAD-name` to executes different pivoting operations
during the solution of linear equations with out having to retape.
The speed test ``speed_cppad/LuSolveSpeed.cpp/`` has been added.
It shows that the initial implementation of :ref:`VecAD-name` is slow
(and uses a lot of memory.)
In fact,
it is faster to use :ref:`LuSolve-name` and retape for each set of equations
than it is to use :ref:`lu_vec_ad.cpp-name` and not have to retape.
This test will help us improve the speed of :ref:`lu_vec_ad.cpp-name` .
04-07
=====
There were bugs in the assignment to :ref:`VecAD-name` elements
during taping that have been fixed.
In addition, an example of tapping the pivoting operations in
an :ref:`Lu factorization<lu_vec_ad.cpp-name>` has been added.
04-03
=====
Added ``size_t`` indexing to the :ref:`VecAD-name` class.
Fixed a bug connected to the :ref:`VecAD-name` class and erasing the tape.
04-02
=====
Some memory savings is done with regard to equal parameter values
being stored in the tape. There was a bug in this logic when parameter
in an ``AD< AD<`` *Base* > > class had values that were variables in the
``AD`` < *Base* > class.
This has been fixed.
04-01
=====
The name of the class that tapes indexing operations
was changed from ``ADVec`` to :ref:`VecAD-name` .
This class was extended so that
the value of elements in these vectors can be variables
(need not be :ref:`parameters<glossary@Parameter>` ).
03-30
=====
Do some simple searching of the parameter table during taping
avoid multiple copies of parameters on tape (use less tape memory).
03-28
=====
The version :ref:`ADVec<VecAD-name>` ,
a vector class that tapes indexing operations,
is now available.
It is currently restricted by the fact that all the
values in the vector must be
:ref:`parameters<Glossary@Parameter>` .
03-25
=====
The internal taping structure has been changed to have variable length
instructions.
This is to save memory on the tape.
In addition, it may help in the implementation of the
vector class that tracks indexing.
(A now functioning version of this class is described in
:ref:`VecAD-name` .)
03-18
=====
A change was made to the way parameter values are stored on the tape.
This resulted in a significant savings in the amount of memory required.
03-17
=====
Change the return type for :ref:`SpeedTest-name` from ``const char *``
to ``std::string`` .
The memory required for the largest test cases was added to the
:ref:`speed_cppad-name` tests output.
03-15
=====
The comparison between ADOLC and CppAD for
the ``DetLuADOLC.cpp/`` example was returning an error
(because it was checking for exact equality of calculated derivatives
instead of nearly equal).
This has been fixed.
03-12
=====
The user defined unary functions were removed and
the user defined :ref:`discrete functions<Discrete-name>` were
added.
These discrete functions add the capability of conditional expressions
(alternate calculations)
being included in an :ref:`ADFun-name` object.
03-11
=====
The classes :ref:`det_by_minor-name` and :ref:`det_by_lu-name` were added
and used these to simplify the
examples that compute determinants.
03-09
=====
The routines ``Grad`` and ``Hess`` have been removed.
You should use :ref:`Jacobian-name` and :ref:`Hessian-name` instead.
03-07
=====
The driver routines :ref:`Hessian-name` and :ref:`RevTwo-name` has been added.
These to compute specialized subsets of the second order partials.
Documentation errors in :ref:`ForTwo-name` and :ref:`Reverse-name` were fixed.
The :ref:`example-name` documentation was reorganized.
03-06
=====
The driver :ref:`ForTwo-name` has been added.
It uses forward mode to compute a subset of the second order partials.
Split all of the "example" and "test" index entries that come from
``include/cppad/example/`` * . ``cpp``
into sorted subheadings.
03-05
=====
The ``Grad`` routine,
which only computed first derivatives of scalar valued functions,
has been replaced by the :ref:`Jacobian-name` routine which
computes the derivative of vector valued functions.
03-04
=====
The bug reported on :ref:`2004@mm-dd@02-17` was present in all
the operators. These have all been fixed and tests for all the operators
have been added to the ``cppad/Test`` directory.
The :ref:`f.Parameter()<fun_property@Parameter>` function was added so that
one can count how many components of the range space depend
on the value of the domain space components.
This helps when deciding whether to use forward or reverse mode.
03-03
=====
Special operators were added to distinguish the cases where
one of the operands is a
:ref:`glossary@Parameter` .
This reduced the amount of branching that is necessary
when executing :ref:`Forward-name` and :ref:`Reverse-name` calculations.
The :ref:`Independent-name` and :ref:`fun_property@Parameter` functions
were moved below :ref:`ADFun-name` in the documentation.
03-01
=====
The DetLuADOLC.cpp, DetLu case was added to the ADOLC
comparison tests.
02-29
=====
Under certain optimization flag values,
and on certain systems,
an error was reported by the
ADOLC correctness comparison.
It turned out that CppAD was not initializing a particular index
when debugging was turned off. This has been fixed.
02-28
=====
A set of routines for comparing CppAD with
ADOLC has been added to the distribution.
In addition, documentation for compiling and linking the
:ref:`Examples<example-name>` and :ref:`Speed Tests<speed_cppad-name>`
has been added.
02-21
=====
If you use the user defined unary atomic functions
there is a restriction on the order of the derivatives that can be calculated.
This restriction was documented in the user defined unary function
:ref:`Forward-name`
and :ref:`Reverse-name` .
(These unary functions were removed on :ref:`2004@mm-dd@03-12` .)
02-20
=====
A user interface to arbitrary order
:ref:`reverse mode<Reverse-name>` calculations was implemented.
In addition, the :ref:`ADFun-name` member functions
``Rev`` and ``RevTwo`` were removed
because it is easier to use the uniform syntax below:
.. list-table::
:widths: auto
* - **Old Syntax**
- **Uniform Syntax**
* - *r1* = *f* . ``Rev`` ( *v* )
- *r1* = *f* . ``Reverse`` (1, *v* )
* - *q1* = *f* . ``RevTwo`` ( *v* )
- *r2* = *f* . ``Reverse`` (2, *v* )
* -
- *q1* [ *i* ] == *r2* [2 * *i* + 1]
The :ref:`Theory-name` section has been completely changed so that
it corresponds to the arbitrary order calculations.
(Some of this change was made when the arbitrary forward mode
interface was added on
:ref:`04-02-15<2004@mm-dd@02-15>` .
The directory ``cppad/Test`` has been added.
It contains tests cases that are not intended as examples.
02-17
=====
There was a bug in the way CppAD handled the parameters zero and one
when they were variables on a lower level tape; i.e. x might be a
parameter on an ``AD< AD<`` *Base* > > tape and a its value
might be a variable on the
``AD`` < *Base* > tape.
This bug in the multiply and divide routines has been fixed.
There was a bug that is some cases reported a divide by zero error
when the numerator was zero. This has been fixed.
02-16
=====
A bug in :ref:`Forward-name` prevented the calculation of derivatives
with higher order than two.
In addition, this checking for user errors in the use of ``Forward``
was also faulty.
This has been fixed.
The Microsoft project file ``example\Example.dsp``
was out of date. This has been fixed.
The example that :ref:`tapes derivative calculations<mul_level-name>`
has been changed to an application of
:ref:`Taylor's method<mul_level_ode.cpp-name>` for solving ordinary differential
equations.
02-15
=====
A user interface to arbitrary order
:ref:`forward mode<Forward-name>` calculations was implemented.
In addition, the :ref:`ADFun-name` member functions
``Arg`` , ``For`` and ``ForTwo`` were removed
because it is easier to use the uniform syntax below:
.. list-table::
:widths: auto
* - **Old Syntax**
- **Uniform Syntax**
* - *v0* = *f* . ``Arg`` ( *u0* )
- *v0* = *f* . ``Forward`` (0, *u0* )
* - *v1* = *f* . ``For`` ( *u1* )
- *v1* = *f* . ``Forward`` (1, *u1* )
* - *v2* = *f* . ``For`` ( *u2* )
- *v2* = *f* . ``Forward`` (1, *u2* )
02-12
=====
All of the derivative calculations are now done using arbitrary
order Taylor arithmetic routines.
The :ref:`Theory-name` section was changed to document this method
of calculation.
02-01
=====
The definition of a
:ref:`glossary@Taylor Coefficient`
was changed to include the factorial factor.
This change was also made to the output specifications for the
``FunForTwo`` routine.
01-29
=====
There were some bugs in the ``FunArg`` function
that were fixed.
#. If one of the dependent variables was a
:ref:`glossary@Parameter`
``FunArg`` did not set it's value properly.
(All its derivatives are zero and this was handled properly.)
#. The user defined unary functions were not
computed correctly.
The specifications for the usage and unknown CppAD error macros
were modified so that they could be used with out side effects.
01-28
=====
Some corrections and improvements were made to the documentation including:
``CppADvector`` was placed before its use,
a reference to ``Ode_ind`` and ``Ode_dep`` was fixed in
``OdeImplicit`` .
01-22
=====
The specifications for the routine ``FunForTwo``
was changed to use
:ref:`Taylor coefficients<glossary@Taylor Coefficient>` .
This makes the interface to CppAD closer to the interface for
`ADOLC <https://github.com/coin-or/ADOL-C>`_.
{xrst_end 2004}
================================================
FILE: appendix/whats_new/2005.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin 2005 app}
{xrst_spell
dlib
dsp
dsw
dussault
etc
gz
kutta
maxabs
neg
pearce
pkzip
scur
sln
typedef
valarray
vcproj
yy
}
Release Notes for 2005
######################
mm-dd
*****
12-24
=====
Fix a memory leak that could occur during the :ref:`ForSparseJac-name`
calculations.
12-23
=====
The buffers that are used to do
:ref:`RevSparseJac-name` and :ref:`RevSparseHes-name`
calculations are now freed directly after use.
The TrackNewDel.cpp example was missing from the Windows install
examples and testing
project file.
This has been fixed.
12-22
=====
The buffer that is are used to do
:ref:`Reverse-name` mode
calculations is now freed directly after use.
This reduces the memory requirements attached to an :ref:`ADFun-name` object.
12-20
=====
Buffers that are used to store the tape information corresponding to
the ``AD`` < *Base* > type are now freed when the corresponding
:ref:`ADFun-name` object is constructed.
This reduces memory requirements and actually had better results
with the :ref:`speed_cppad-name` tests.
The :ref:`speed_cppad-name` test program now outputs the version of CppAD
at the top (to help when comparing output between different versions).
12-19
=====
The :ref:`track_new_del-name` routines were added for track memory allocation
and deletion with ``new[]`` and ``delete[]`` .
This is in preparation for making CppAD more efficient in it's use of
memory.
The bug mentioned on :ref:`2005@mm-dd@12-01` resurfaced
and the corresponding routine was changed as follows:
::
static local::ADTape<Base> *Tape(void)
{ // If we return &tape, instead of creating and returning ptr,
// there seems to be a bug in g++ with -O2 option.
static local::ADTape<Base> tape;
static local::ADTape<Base> *ptr = &tape;
return ptr;
}
12-16
=====
The :ref:`NearEqual-name` function documentation for the relative error case
was changed to
| *x* ``-`` *y* | <= *r* * ( | *x* | + | *y* | )
so that there is no problem with division by zero when
*x* and *y* are zero
(the code was changed to that form also).
The ``std::abs`` function replaced the
direct computation of the complex norms
(for the complex case in ``NearEqual`` ).
In addition, more extensive testing was done in :ref:`near_equal.cpp-name` .
12-15
=====
Extend :ref:`NearEqual-name` and :ref:`near_equal_ext-name`
to cover more cases while converting them from,
a library function in ``lib/CppADlib.a``
and an utility in ``example/NearEqualExt.h`` ,
to a template functions in
``cppad/near_equal.hpp`` and
``cppad/local/NearEqualExt.h`` .
This is another step along the way of removing
the entire ``CppADlib.a`` library.
The change on :ref:`2005@mm-dd@12-14` broke the
Microsoft project files ``example/Example.sln``
and ``TestMore/TestMore.sln`` used during CppAD
installation on Windows.
This has been fixed.
Move ``lib/SpeedTest.cpp`` to ``cppad/speed_test.hpp`` .
This was the last change necessary in order to remove the CppAD library,
so remove all commands related to building and linking ``CppADlib.a`` .
The corresponding entry has been removed from the :ref:`wish_list-name` .
One of the entries in the :ref:`wish_list-name` corresponded to the
:ref:`Integer-name` function.
It has also been removed (because it is already implemented).
12-14
=====
Extend :ref:`erf-name` to cover more cases while converting it
from a function in ``lib/CppADlib.a``
to a template function in ``cppad/local/Erf.h`` .
This is one step along the way of removing
the entire ``CppADlib.a`` library.
12-11
=====
Group routines that extend the domain for which an :ref:`ADFun-name`
object is useful into the ExtendDomain section.
Add an example of a C callable routine that computes
derivatives using CppAD (see :ref:`interface2c.cpp-name` ).
12-08
=====
Split out :ref:`LuFactor-name` with the *ratio* argument
to a separate function called :ref:`LuRatio-name` .
This needed to be done because :ref:`LuRatio-name` is more restrictive
and should not be part of the general template :ref:`utilities<utility-name>` .
12-07
=====
Improve :ref:`CheckSimpleVector-name` so that it tests element assignment.
Change :ref:`check_simple_vector.cpp-name` so that it provides
and example and test of a case where a simple vector returns a type
different from the element type and the element assignment returns
``void`` .
12-06
=====
The specifications for a :ref:`SimpleVector-name` template class
were extended so that the return type of an element access is
not necessarily the same as the type of the elements.
This enables us to include ``std::vector<bool>``
which packs multiple elements into a single storage location
and returns a special type on element access (not the same as ``bool`` ).
To be more specific,
if *x* is a ``std::vector<bool>`` object
and *i* has type ``size_t`` ,
*x* [ *i* ] does not have type ``bool`` .
Add a Home icon,
that links to the
`CppAD home page <https://www.coin-or.org/CppAD/>`_,
to the top left of the navigation frame
(left frame) for each documentation section.
12-05
=====
The :ref:`RevSparseHes-name` reverse mode Hessian sparsity calculation
has been added.
The definition of a :ref:`glossary@Sparsity Pattern`
has been corrected to properly correspond to the more efficient form
mentioned under :ref:`2005<2005@mm-dd@11-20>` below.
The dates in this file used to correspond to
local time for when the change was checked
into the subversion repository.
From now on the dates in this file will correspond to the first
version of CppAD where the change appears; i.e., the date in the
unix and windows
download file names ``CppAD-`` *yy* ``-`` *mm* ``-`` *dd* .
12-03
=====
There was a bug in the :ref:`RevSparseJac-name`
reverse mode sparsity patterns when used with :ref:`VecAD-name` calculations.
This bug was fixed and the calculations were made more efficient
(fewer true entries).
12-02
=====
There was a bug in the :ref:`ForSparseJac-name`
forward mode sparsity patterns when used with :ref:`VecAD-name` calculations.
This bug was fixed and the calculations were made more efficient
(fewer true entries).
12-01
=====
The speed test of :ref:`lu_vec_ad.cpp-name` has been reinstated.
It appears that there is some sort of bug in the gcc compiler with
the -O2 option whereby the following member function
::
static local::ADTape<Base> *Tape(void)
{ static local::ADTape<Base> tape;
return &tape;
}
(in ``cppad/local/AD.h`` )
would sometimes return a null value (during :ref:`VecAD-name` operations).
A speed improvement in
``cppad/local/ExtendBuffer.h`` seems to prevent
this problem.
This fix is not well understood; i.e., we should watch to see
if this problem reoccurs.
The source code for
:ref:`lu_vec_ad_ok.cpp-name` was mistakenly used for
``speed_cppad/LuSolveSpeed.cpp`` .
This has been fixed.
11-23
=====
The speed test of :ref:`lu_vec_ad.cpp-name` has been commented out
because it sometimes generates a segmentation fault.
Here is an explanation:
If *X* is a ``AD`` < *Base* > object,
*y* is a *Base* object,
*X* [ *y* ] uses pointer from the element
back to the original vector.
Optimizing compilers might reorder operations so that
the vector is destroyed before the object is used.
This can be avoided by changing the syntax for :ref:`VecAD-name` objects
to use ``set`` and ``get`` member functions.
11-22
=====
A much better :ref:`example<vec_ad.cpp-name>` for using :ref:`VecAD-name`
vectors has been provided. In addition, a bug
in the computation of derivatives using ``VecAD`` vectors
has been fixed.
CppAD now checks that the domain dimension during
:ref:`Independent-name` and
the range dimension during :ref:`ADFun-name`
(provided that ``-DNDEBUG`` is not defined).
If either of these is zero,
the ``CppADUsageError`` macro is invoked.
11-20
=====
The sparsity pattern routines
:ref:`ForSparseJac-name` and :ref:`RevSparseJac-name`
have been modified so that they are relative
to the Jacobian at a single argument value.
This enables us to return more efficient
:ref:`sparsity patterns<glossary@Sparsity Pattern>` .
An extra :ref:`exception<VecAD@VecAD<Base\>::reference@Exceptions>` has been
added to the use of :ref:`VecAD-name` elements.
This makes ``VecAD`` some what more efficient.
11-19
=====
Improve the output messages generated during execution of the
:ref:`configure@Configure` command.
Put a try and catch block around all of the uses of
``new`` so that if a memory allocation error occurs,
it will generate a ``CppADUsageError/`` message.
The :ref:`get_started.cpp-name` example has been simplified
so that it is easier to understand.
11-15
=====
Fix a memory leak in both the :ref:`ForSparseJac-name` and
:ref:`RevSparseJac-name` calculations.
11-12
=====
Add reverse mode :ref:`Jacobian sparsity<RevSparseJac-name>` calculation.
11-09
=====
Add prototype documentation for :ref:`LuSolve@logdet` in
the :ref:`LuSolve-name` function.
Add the optional *ratio* argument to the
:ref:`LuFactor-name` routine.
(This has since been moved to a separate routine called :ref:`LuRatio-name` .)
11-07
=====
Remove some blank lines from the example files listed
directly below (under 11-06).
Comments for computing the entire Jacobian
:ref:`ForSparseJac@Entire Sparsity Pattern`
was added.
11-06
=====
The cases of ``std::vector`` , ``std::valarray`` , and
``CppAD::vector`` were folded into the standard example and tests
format for the following cases:
:ref:`rev_two.cpp-name` ,
:ref:`rev_one.cpp-name` ,
``Reverse.cpp`` ,
:ref:`hessian.cpp-name` ,
:ref:`jacobian.cpp-name` ,
:ref:`forward.cpp-name` ,
:ref:`for_two.cpp-name` ,
:ref:`for_one.cpp-name` ,
``Fun.cpp``
(``Fun.cpp`` has since been replaced by :ref:`independent.cpp-name` ,
``Reverse.cpp`` has since been replaced by
:ref:`reverse_one.cpp-name` and ``rev_checkpoint.cpp`` ).
11-01
=====
Add forward mode :ref:`Jacobian sparsity<ForSparseJac-name>` calculation.
10-20
=====
Add :ref:`sparsity patterns<glossary@Sparsity Pattern>` to
the wish list.
10-18
=====
The Unix install :ref:`configure@Configure` command
was missing the ``--`` before of the ``prefix`` command line
argument.
10-14
=====
The template class :ref:`CppAD_vector-name` uses a try/catch block
during the allocation of memory (for error reporting).
This may be slow down memory allocation and hence it
is now replaced by simple memory allocation when
the preprocessor variable ``NDEBUG`` is defined.
The specialization of ``CppAD::vector<bool>``
was moved to :ref:`CppAD_vector@vectorBool`
so that ``CppAD::vector<bool>`` does not pack one bit per value
(which can be slow to access).
10-12
=====
Change the
:ref:`configure@Configure` script so that compilation of the
:ref:`get_started.cpp-name` and :ref:`print_for_cout.cpp-name` examples are optional.
One of the dates in the Unix installation
extraction discussion was
out of date. This has been fixed.
10-06
=====
Change the Unix install ``configure`` script
so that is reports information using the same order and notation as its
:ref:`documentation<configure@Configure>` .
Some compiler errors in the :ref:`ode_gear_control.cpp-name` and
:ref:`ode_stiff.cpp-name` examples were fixed.
09-29
=====
Add a specialization to :ref:`CppAD_vector-name` for the
``CppAD::vector<bool>`` case.
A test for the ``push_back`` member function as well as a
:ref:`CheckSimpleVector-name` test has been added to :ref:`cppad_vector.cpp-name` .
The source code for this template vector class,
``cppad/vector.hpp`` ,
has been removed from the documentation.
09-27
=====
Add the
:ref:`configure@prefix_dir` and
*postfix_dir* ( *postfix_dir* has since been removed)
options to the ``configure`` command line.
This gives the user more control over the location where CppAD is installed.
09-24
=====
The stiff Ode routines,
:ref:`OdeGear-name` and :ref:`OdeGearControl-name` ,
were added to the :ref:`utilities<utility-name>` .
A comparison various Ode solvers on a stiff problem
:ref:`ode_stiff.cpp-name` was added.
In addition, ``OdeGear`` and ``OdeGearControl``
were added to the :ref:`utilities<utility-name>` and the library was
reorganized.
09-20
=====
The Microsoft compiler project files
``example/Example.vcproj`` and ``TestMore/TestMore.vcproj``
were not up to date.
This has been fixed.
In addition, the example :ref:`numeric_type.cpp-name` has been added.
Make the building of the
``Example`` , ``TestMore`` , and ``Speed`` , directories
optional during the :ref:`configure@Configure` command.
The :ref:`Unix installation instructions<configure-name>` were
overhauled to make the larger set of options easy to understand.
09-14
=====
Added the :ref:`NumericType-name` concept and made the following
library routines require this
concept for their floating point template parameter type:
:ref:`LuSolve-name` ,
:ref:`LuFactor-name` ,
:ref:`RombergOne-name` ,
:ref:`RombergMul-name` ,
:ref:`Runge45-name` ,
:ref:`Rosen34-name` , and
:ref:`OdeErrControl-name` .
This is more restrictive than the previous requirements
for these routines but it
enables future changes to the implementation of these routines
(for optimization purposes) with out affecting their specifications.
09-09
=====
Add the :ref:`unary_plus-name` operator and move the ``Neg``
examples and tests to :ref:`unary_minus-name` .
09-07
=====
Change name of distribution files from
``CppAD.unix.tar.gz`` and ``CppAD.dos.tar.gz``
to
``CppAD-`` *yy* ``-`` *mm* ``-`` *dd* . ``tar.gz`` and ``CppAD-`` *yy* ``-`` *mm* ``-`` *dd* . ``zip``
(the * . ``zip`` file
uses pkzip compression).
08-30
=====
The *maxabs* argument has been added to the
:ref:`OdeErrControl-name` function so that it can be used
with relative errors where components of the ODE solution may be zero
(some of the time).
In addition, some of the rest of the OdeErrControl documentation
has been improved.
The documentation for
replacing defaults
in CppAD error macros has been improved.
08-24
=====
Changed ``Romberg`` to :ref:`RombergOne-name` and added :ref:`RombergMul-name` .
In addition, added missing entries to :ref:`list_all_examples-name`
and reorganized :ref:`utilities<utility-name>` .
08-20
=====
Backed out addition of ``Romberg`` integration routine
(at this point uncertain of the interface that is most useful in
the context of AD.)
08-19
=====
Added a ``Romberg`` integration routine for
where the argument types are template parameters
(for use with AD types).
08-15
=====
The Microsoft project files ``example/Example.vcproj`` and
``TestMore/TestMore.vcproj`` were missing some necessary routines.
In addition, ``Speed/Speed.vcproj`` was generating a warning.
This has been fixed.
08-14
=====
An :ref:`Integer-name` conversion function as been added.
The :ref:`value.cpp-name` example has been improved and the old example
has been moved into the ``TestMore`` directory.
08-13
=====
The :ref:`unary_standard_math-name` functions
``sinh`` , and ``cosh`` have been added.
In addition, more correctness testing
has been added for the ``sin`` and ``cos`` functions.
The :ref:`OdeErrControl-name` routine could lock in an infinite loop.
This has been fixed and a test case has been added to check for this problem.
08-07
=====
The :ref:`conditional expression<CondExp-name>` function has been changed
from just ``CondExp`` to
``CondExpLt`` ,
``CondExpLe`` ,
``CondExpEq`` ,
``CondExpGe`` ,
``CondExpGt`` .
This should make code with conditional expressions easier to understand.
In addition, it should reduce the number of tape operations because
one need not create as many temporaries to do comparisons with.
The old ``CondExp`` function has been deprecated.
07-21
=====
Remove unnecessary no-op that was left in tape for the
:ref:`unary_standard_math-name` functions
``acos`` , ``asin`` , ``atan`` , ``cos`` .
Improve the index entries in the documentation that corresponds
to the ``cppad/local`` directory source code.
07-19
=====
The :ref:`wish_list-name` and ``Bugs`` information
were moved out of this section and into their own separate sections
(the Bugs section has been removed; see the ``bug`` subdirectory
instead).
A discussion of
:ref:`VecAD speed and memory<VecAD@Speed and Memory>` was added
as well as an entry in the
:ref:`wish_list-name` to make it more efficient.
07-15
=====
The ``BOOST_DIR`` and ``CPP_ERROR_WARN``
:ref:`configure@Configure` options
were not properly implemented for compiling the
``lib`` sub-directory.
This has been fixed.
Some compiler warnings in the file ``lib/ErrFun.cpp`` ,
which computes the :ref:`erf-name` function,
have been fixed.
07-11
=====
The :ref:`CppAD_vector@push_back` function has
been added to the ``CppAD::vector`` template class.
It appears that the ``TestMore/Runge45.cpp`` file was missing
an include of ``example/NearEqualExt.h`` . This has been fixed.
07-08
=====
The documentation for :ref:`Forward-name` and :ref:`Reverse-name` has been
improved.
07-05
=====
The :ref:`rosen_34.cpp-name` example mixed the
:ref:`CppAD::vector<CppAD_vector-name>` and
``CppADvector`` vector types.
This caused the compilation of the examples to fail when
``CppADvector`` was defined as something other than
``CppAD::vector`` (found by Jon Pearce).
This has been fixed.
The :ref:`CheckSimpleVector-name` run time code has been improved so that it is
only run once per case that is being checked.
Simple Vector concept checking (:ref:`CheckSimpleVector-name` ) was
added to the routines:
:ref:`ForOne-name` ,
:ref:`ForTwo-name` ,
:ref:`Forward-name` ,
:ref:`ADFun-name` ,
:ref:`Hessian-name` ,
:ref:`Independent-name` ,
:ref:`Jacobian-name` ,
:ref:`RevOne-name` ,
:ref:`RevTwo-name` , and
:ref:`Reverse-name` .
07-04
=====
Simple Vector concept checking (:ref:`CheckSimpleVector-name` ) was
added to the routines:
:ref:`LuFactor-name` ,
:ref:`LuSolve-name` ,
:ref:`LuInvert-name` ,
:ref:`OdeErrControl-name` ,
:ref:`Runge45-name` , and
:ref:`Rosen34-name` .
The previous version of the
routine :ref:`OdeErrControl-name` was mistakenly in the global namespace.
It has been moved to the ``CppAD`` namespace
(where all the other :ref:`utilities<utility-name>` routines are).
The previous distribution (version 05-07-02) was missing the file
``cppad/local/Default.h`` .
This has been fixed.
07-03
=====
Added :ref:`CheckSimpleVector-name` , a C++ concept checking utility
that checks if a vector type has all the necessary conditions
to be a :ref:`SimpleVector-name` class with a specific element type.
07-02
=====
Version 7 of Microsoft's C++ compiler
supports the standard declaration for a friend template function.
Version 6 did not and
CppAD used macros to substitute the empty string for
``<Base>`` , ``< AD<Base> >`` , and ``< VecAD<Base> >``
in these declarations.
These macro substitutions have been removed
because Version 6 of Microsoft's C++ compiler
is no longer supported by CppAD.
The copy base section was split into the default
constructor and the
construction for the base type.
The construction from base type has been
extended to include any type that is convertible to the base type.
As a special case, this provides the previous wish list item of
a constructor from an arbitrary *Base* to a
``AD< AD<`` *Base* > > , ``AD< AD< AD<`` *Base* > > > etc.
07-01
=====
The permissions were set as executable for many of the no-executable files
in the distribution; for example, the ``README`` , file.
This has been fixed.
06-25
=====
Some improvements were made to the
README, AUTHORS, COPYING, and INSTALL files.
In addition, the file
``UWCopy040507.html``
which contains the University of Washington's copyright
policy (see Section 2) was added to the distribution.
06-24
=====
The ``List2Vector``
example utility is no longer used and has
been removed.
06-18
=====
CppAD is now supported by Microsoft Visual C++ version 7 or higher.
The version 6 project files
* . ``dsw`` and * . ``dsp``
have been replaced by the version 7 project files
* . ``sln`` and * . ``vcproj`` .
06-14
=====
A new :ref:`CondExp example<cond_exp.cpp-name>` has been added and
the old :ref:`CondExp-name` example has been moved to the
``TestMore`` directory (it is now only a test).
06-13
=====
The changes made on 06-06 do not run under Microsoft Visual C++ version 6.0
(even though they are within the C++ standard).
Preliminary testing under version 7 indicates that Microsoft
has fixed this problem in later versions of their C++ compiler.
06-06
=====
Converted the routines
:ref:`Forward-name` and :ref:`Reverse-name` to allow for any
:ref:`SimpleVector-name` instead of just ``CppADvector`` .
In addition, separated the syntax of the function call
from the prototype for each of the arguments.
This was also done for all the easy to use :ref:`Drivers-name`
as well as the :ref:`Independent-name` function and
the :ref:`ADFun-name` constructor.
Add a section containing a list of
:ref:`all the examples<list_all_examples-name>` .
05-19
=====
A significant improvement in speed was obtained by moving
the buffer extension to a separate function and then
inline the rest of putting operators in the tape.
For example,
here is part of the speed test output before this change:
::
Tape of Expansion by Minors Determinant: Length = 350, Memory = 6792
size = 5 rate = 230
size = 4 rate = 1,055
size = 3 rate = 3,408
size = 2 rate = 7,571
size = 1 rate = 13,642
and here is the same output after this change:
::
Tape of Expansion by Minors Determinant: Length = 350, Memory = 6792
size = 5 rate = 448
size = 4 rate = 2,004
size = 3 rate = 5,761
size = 2 rate = 10,221
size = 1 rate = 14,734
Note that your results will vary depending on operating system and machine.
05-18
=====
Change name of ``OdeControl`` to :ref:`OdeErrControl-name`
and improve its documentation.
Correct the syntax for the :ref:`con_dyn_var@Parameter`
and :ref:`con_dyn_var@Variable`
functions.
05-16
=====
Change :ref:`OdeErrControl-name` to have method return its order instead
of having a separate argument to ``OdeErrControl`` .
Add the argument *scur* to ``OdeErrControl`` ,
improve ``OdeErrControl`` choice of step size and documentation.
05-12
=====
Using profiling, the
:ref:`multiplication operator<ad_binary-name>` was show to take a significant
amount of time. It was reorganized in order to make it faster.
The profiling indicated an improvement so that same change was made
to the :ref:`ad_binary-name` and :ref:`compound_assign-name` operators.
05-06
=====
The documentation for
:ref:`SimpleVector-name` and :ref:`NearEqual-name`
were changed to use more syntax (what the user enters)
and simpler prototypes
(the compiler oriented description of the arguments).
In addition, exercises were added at the end of the
:ref:`SimpleVector-name` , :ref:`CppAD_vector-name` , and :ref:`NearEqual-name`
documentation.
There was a undesired divide by zero case in the file
``TestMore/VecUnary.cpp`` that just happened to work
in corresponding :ref:`NearEqual-name` check.
The ``NearEqual`` routine has been changed
to return false if either of the values being compared
is infinite or not a number.
In addition, the divide by zero has been removed from
the ``TestMore/VecUnary.cpp`` test.
05-01
=====
The doubly linked list was also removed from the :ref:`VecAD-name`
internal data structure because this method of coding is simpler
and it makes it more like the rest of CppAD.
04-21
=====
The profiling indicated that the destructor for an AD object was using a
significant amount of time.
The internal data structure of an AD object had a doubly linked list
that pointed to the current variables and this was modified when
an AD object was destroyed.
In order to speed AD operations in general,
the internal data structure of an AD object has been changed so that
this list is no longer necessary (a tape id number is used in its place)
During the process above, the function :ref:`con_dyn_var@Variable` was added.
04-20
=====
Add profiling
to the speed tests.
04-19
=====
Remove an extra (not necessary)
semi-colon from the file ``cppad/local/Operator.h`` .
03-26
=====
The new routine :ref:`OdeErrControl-name` does
automatic step size control for the ODE solvers.
03-23
=====
The routine :ref:`Rosen34-name` is an improved stiff integration method
that has an optional error estimate in the calling sequence.
You must change all your calls to ``OdeImplicit``
to use ``Rosen34`` (but do not need to change other arguments
because error estimate is optional).
03-22
=====
The routine :ref:`Runge45-name` is an improved Runge-Kutta method
that has an optional error estimate in the calling sequence.
You must change all your calls to ``OdeRunge``
to use ``Runge45`` (but do not need to change other arguments
because error estimate is optional).
03-09
=====
Some extra semi-colons (empty statements)
were generating warnings on some compilers.
The ones that occurred after the macros
``CppADStandardMathBinaryFun`` ,
``CppADCompareMember`` ,
``CppADBinaryMember`` , and
``CppADFoldBinaryOperator`` have been removed.
03-04
=====
An new multiple level of AD example :ref:`mul_level-name` was added.
03-01
=====
An option that specifies error and warning
:ref:`flags<configure@cxx_flags>`
for all the C++ compile commands,
was added to the
:ref:`Unix installation instructions<configure-name>` .
02-24
=====
The routine :ref:`LuSolve-name` was split into :ref:`LuFactor-name`
and :ref:`LuInvert-name` . This enables one to efficiently
solve equations where the matrix does not change
and the right hand side for one equation depends on the
left hand side for a previous equation.
An extra requirement was added to the
:ref:`SimpleVector-name` template class.
There must be a typedef for ``value_type``
which is the type of elements in the vector
Under Mandrake Linux 10.1,
some template friend declarations were failing because the corresponding
operations were not declared before being indicated as friends
(found by
`Jean-Pierre Dussault <mailto:Jean-Pierre.Dussault@Usherbrooke.ca>`_).
This has been fixed.
01-08
=====
The :ref:`erf-name` function was added.
The implementation of this function used conditional expressions
(:ref:`CondExp-name` ) and some times the expression that was not
valid in a region caused division by zero.
For this reason, the check and abort on division by zero
has been removed.
{xrst_end 2005}
================================================
FILE: appendix/whats_new/2006.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin 2006 app}
{xrst_spell
aclocal
autoconf
automake
avector
delem
div
dw
fy
gprof
kasper
kristensen
makefile
memcheck
of of
omh
rpm
sed
speedtest
tautschnig
usr
valgrind
yy
yyyymmdd
}
Release Notes for 2006
######################
mm-dd
*****
12-24
=====
Move ``exp_eps_ad`` to ``exp_eps_cppad`` and
add exercises to the following sections:
:ref:`exp_eps_rev1-name` ,
:ref:`exp_eps_cppad-name` .
Add operation sequence indices to help track operations in
:ref:`exp_eps_for0-name` ,
:ref:`exp_eps_for1-name` ,
:ref:`exp_eps_rev1-name` .
12-23
=====
Add exercises to the following sections:
:ref:`get_started.cpp-name` ,
:ref:`exp_eps-name` ,
:ref:`exp_eps_for0-name` , and
:ref:`exp_eps_for1-name` .
12-22
=====
Move :ref:`get_started.cpp-name` below the :ref:`introduction-name` directory.
Move the exponential example to the subdirectory
``introduction/exp_apx`` and change the
``--with-Introduction``
unix configure option
to build both the :ref:`get_started.cpp-name` and :ref:`exp_apx.cpp-name`
example programs.
(The ``--with-GetStarted`` configure command line option has been removed.)
12-21
=====
Add the :ref:`source code for Poly<poly.hpp-name>` to the documentation
and include :ref:`Poly-name` in the in the :ref:`speed_utility-name` section.
The :ref:`get_started.cpp-name` section has been moved
into the :ref:`Introduction-name` and
:ref:`get_started.cpp@Exercises` were added to that section.
In addition some sections has switched position between
the top level :ref:`user_guide-name` and the :ref:`appendix-name` .
12-19
=====
Reorganize so that the source code is below the corresponding routine
in the documentation tree (instead of at the same level) for the
following routines:
:ref:`det_by_minor-name` ,
:ref:`det_grad_33-name` ,
:ref:`uniform_01-name` ,
:ref:`det_of_minor-name` ,
:ref:`det_by_lu-name` ,
:ref:`LuInvert-name` ,
:ref:`LuFactor-name` ,
:ref:`LuSolve-name` .
Separate the specifications for the source in
:ref:`speed_utility-name` and add cross reference to the following routine
specification and implementations:
:ref:`det_by_minor-name` ,
:ref:`det_grad_33-name` ,
:ref:`uniform_01-name` ,
:ref:`det_of_minor-name` ,
:ref:`det_by_lu-name` ,
:ref:`LuInvert-name` ,
:ref:`LuFactor-name` ,
:ref:`LuSolve-name` .
12-18
=====
Make the :ref:`speed-name` source code easier to read.
Change the speed test output name ``det_poly`` to ``poly``
(as it should have been).
12-17
=====
The speed test :ref:`det_grad_33-name` was missing its documentation
(this has been fixed).
In addition, the titles and indexing for the speed test documentation
has been improved.
Add to the specifications that each repeated test corresponds to a
different matrix in
:ref:`det_lu<link_det_lu-name>` and
:ref:`det_minor<link_det_minor-name>` .
In addition, modify all the speed tests so that they abide by this rule.
Change some references from the deprecated name ``CppAD.h`` to
new name ``cppad.hpp`` .
Change :ref:`adolc_det_minor.cpp-name` and :ref:`cppad_det_minor.cpp-name`
to tape once and reuse operation sequence for each repeated
matrix in the test.
Add the :ref:`poly<link_poly-name>` speed test for all three packages.
In addition, correct a missing include in :ref:`poly-name` routine.
12-15
=====
The wish list item
to simplify and better organize the speed tests been completed:
.. csv-table::
:widths: auto
:ref:`speed/<speed-name>`,template functions that are speed tested
``speed/example``,example usage of speed template functions
:ref:`speed/adolc<speed_adolc-name>`,Adolc drivers for the template functions
:ref:`speed/cppad<speed_cppad-name>`,CppAD drivers for the template functions
:ref:`speed/fadbad<speed_fadbad-name>`,Fadbad drivers for the template functions
speed/profile,profiling version of CppAD drivers
12-13
=====
Next step for the speed wish list item:
remove ``speed_cppad`` from the documentation and replace it by
``speed/cppad`` , see :ref:`speed_cppad-name` for the new CppAD speed
test routines.
12-12
=====
Started the speed wish list item by
move the ``adolc`` director to ``speed/adolc`` and
``fadbad`` to ``speed/fadbad`` .
12-11
=====
Started the speed wish list item by
creating the ``speed/example`` directory and moving the relevant
examples from
``example/`` * . ``cpp`` and
``speed_example/`` * . ``cpp`` to
``speed/example/`` * . ``cpp`` .
In addition, the relevant include files have been moved from
``example/`` * . ``hpp`` to
``speed/`` * . ``hpp`` .
A new :ref:`speed_test-name` routine was added to the library.
12-10
=====
The :ref:`pow-name` function was changed to be a an ``AD`` < *Base* >
:ref:`atomic_base<glossary@Operation@Atomic>` operation.
This function used to return a ``nan`` if
*x* is negative because it was implemented as
``pow`` ( *x* , *y* ) = ``exp`` ( ``log`` ( *x* ) * *y* )
This has been fixed so that the function and its derivatives are now
calculated properly when *x* is less than zero.
The :ref:`pow-name` documentation was improved
and the :ref:`pow.cpp-name` example was changed to
test more cases and to use the same variable
names as in the documentation.
12-09
=====
A speed wish list item was added to the wish list.
The prototype for ``int`` arguments in binary operations
(for example :ref:`addition<ad_binary-name>` ) was documented as
``const int &`` but was actually just plain ``int`` .
This has been fixed.
(Later changed to ``double`` .)
12-07
=====
Fix bug in the
subversion installation instructions; see
`bug report <https://list.coin-or.org/pipermail/cppad/2006q4/000076.html>`_.
The some of the automatically generated ``makefile.in`` files
had an improper license statement in the GPL license version.
This has been fixed.
12-05
=====
Add the unix installation
--with_Documentation option
and remove the
*postfix_dir* option.
Create a fixed
:ref:`whats_new-name` section above the section for each particular year.
Also improve the CppAD distribution ``README`` file.
12-03
=====
The include file directory ``CppAD`` was changed to be all
lower case; i.e., ``cppad`` .
If you are using a Unix system, see :ref:`include_deprecated-name` .
This completes the following :ref:`wish_list-name` items (which were removed):
#. File and directory names should only contain lowercase letters,
numbers underscores and possibly one period.
The leading character must be alphabetic.
#. C++ header files should have the ``.hpp`` extension.
12-02
=====
Put explanation of version numbering in the
download instructions.
Correct some file name references under the Windows heading in
:ref:`speed_cppad-name` .
12-01
=====
All of the ``Makefile.am`` and ``Makefile`` files were changed
to lower case; i.e., ``makefile.am`` and ``makefile`` .
Fix compiler warning while compiling ``cppad/RombergOne/``
(mistake occurred during :ref:`11-20<2006@mm-dd@11-29>` change).
11-30
=====
Cygwin packages, and other system packages,
should not have a dash in the version number.
See
`cygwin package file naming <https://cygwin.com/packaging-package-files.html>`_ .
or, to quote the
`rpm file naming convention <http://ftp.rpm.org/max-rpm/ch-rpm-file-format.html>`_
*The only restriction placed on the version is that*
*it cannot contain a dash "-".*
As per the acceptable package naming conventions for cygwin,
CppAD version numbering has be changed from
*yy* ``-`` *mm* ``-`` *dd* format to *yyyymmdd* ; i.e.
``cppad-06-11-30`` was changed to ``cppad-20061130`` .
11-29
=====
There was a problem using :ref:`RombergOne-name` with floating point
types other than ``double`` . This has been fixed.
11-28
=====
The :ref:`installation<Install-name>` download files were not being built
because ``Makefile.am`` referenced ``Doc`` when it should have
referenced ``doc`` . This has been fixed.
11-23
=====
A Version Numbering entry was added to the
:ref:`wish_list-name` (this was completed on :ref:`2006@mm-dd@11-30` ).
11-18
=====
The example routine that computes determinants using expansion
by minors ``DetOfMinor`` was changed to :ref:`det_of_minor-name` ,
in preparation for
more formal speed comparisons with other packages.
To be specific, its documentation was improved,
its dependence on the rest of CppAD was removed
(it no longer includes CppAD.h ).
11-12
=====
The
:ref:`general.cpp-name` and
``test_more/test_more.cpp``
programs were
changed to print out the number of tests that passed or failed instead
of just "All the tests passed" or "At least one of the tests failed".
The windows project files for
examples and testing
should have been changes to use lower case file names on
as part of the 11-08 change below. This has been fixed.
11-08
=====
Move the ``Example`` directory to ``example``
and change all its files to use lower case names.
11-06
=====
Move the ``TestMore`` directory to ``test_more``
and change all its files to use lower case names.
11-05
=====
Remove references in the :ref:`speed_cppad-name` tests to the
``Memory`` and ``Size`` functions because they
have been :ref:`deprecated<fun_deprecated-name>` .
Correct some references to ``var_size`` that should have been
:ref:`fun_property@size_var` .
11-04
=====
Put text written to standard output in the documentation for the
:ref:`get_started.cpp<get_started.cpp@Output>` and
``print_for.cpp`` examples.
(Now documentation can be built from a subversion checkout with out
needing to execute automake.)
The ``PrintFor.cpp`` and
``speedtest.cpp`` examples were missing in :ref:`list_all_examples-name`
(which has been fixed).
Move the ``Speed`` directory to ``speed``
and change all its files to use lower case names.
11-02
=====
The ``print_for`` directory was referenced as ``PrintFor``
in the root CppAD ``Makefile.am`` this has been fixed.
The documentation for the Adolc helper routines
``AllocVec`` and ``AllocMat`` were not being included.
This has been fixed.
Move the ``GetStarted`` directory to ``get_started``
and change all its files to use lower case names.
11-01
=====
Move the ``PrintFor`` directory to ``print_for``
and change all its files to use lower case names.
10-31
=====
Move the ``SpeedExample`` directory to ``speed_cppad_example``
and change all its files to use lower case names.
10-29
=====
Move the ``Adolc`` directory to ``adolc``
and change all its files to use lower case names.
Change all the file in the ``omh`` directory to
use lower case names.
The file ``Makefile.am`` in the distribution directory had the
CPL copyright message in the GPL version. This has been fixed.
10-28
=====
The copyright message in the script files
``example/OneTest`` and ``TestMore/OneTest`` were GPL
(in the CPL distribution).
This has been fixed by moving them to
``example/OneTest.sh`` and ``TestMore/OneTest.sh`` so that
the distribution automatically edits the copyright message.
10-27
=====
Change :ref:`hes_lagrangian.cpp-name` example so that it computes the
Lagrangian two ways. One is simpler and the other can be used
to avoid re-taping operation sequence.
10-26
=====
Change :ref:`hes_lagrangian.cpp-name` example so that it modifies
the independent variable vector between the call to
:ref:`Independent-name` and the ``ADFun`` < *Base* >
:ref:`constructor<fun_construct-name>` .
10-25
=====
A subversion install procedure was
added to the documentation.
Fix definition of preprocessor symbol
``PACKAGE_STRING`` in ``Speed/Speed.cpp``
(broken by change on 10-18).
Added the example
:ref:`hes_lagrangian.cpp-name` which computes the Hessian
of a Lagrangian.
10-18
=====
Document and fix possible conflicts for
:ref:`preprocessor symbols<preprocessor-name>`
that do not begin with ``CppAD`` or ``CPPAD_`` .
Include a default value for the file ``cppad/config.h``
in the subversion repository.
10-16
=====
Fix bug when using :ref:`OdeErrControl-name` with the type
``AD< AD<double> >`` .
10-10
=====
Add the :ref:`Var2Par-name` function so it is possible
to obtain the :ref:`Value-name` of a variable.
Move the ``Discrete.cpp`` example to :ref:`tape_index.cpp-name` .
Fix the Microsoft project file so that the Windows install
examples and testing works properly
(it was missing the :ref:`stack_machine.cpp-name` example).
09-30
=====
These changes were grouped together because it took a while for Coin-Or
to review the dual licensing version and because it was not possible to
get the nightly build changed:
#. Change shell scripts to use \*.sh extension.
#. Two versions, one with CPL and other with GPL license.
#. Change subversion version of CppAD from GPL to CPL copyright.
#. Change all files in cppad/local to use lower case and \*.hpp extension.
#. CppAD_vector.h was generating a warning on version 4 of gcc.
This have been fixed.
#. Change the preprocessor ``# define`` commands
in ``cppad/local/\*.hpp`` to use upper case names.
#. Add the :ref:`stack_machine.cpp-name` example.
08-17
=====
Some error message occurred while executing
::
valgrind --tool=memcheck example/example
valgrind --tool=memcheck TestMore/TestMore
These were not really bugs, but they have been fixed to avoid
this conflict between CppAD and `valgrind <https://valgrind.org/>`_.
07-14
=====
Make some improvements were made to the :ref:`Introduction-name` ,
:ref:`exp_eps.hpp-name` and :ref:`exp_eps_rev1-name` sections.
07-12
=====
Use a drop down menu for the navigation links, instead of a separate frame
for the navigation links, for each section in the documentation.
06-29
=====
Newer versions of the gcc compiler generated an error because
:ref:`erf-name` was using :ref:`CondExp-name` before it was defined.
This was found by Kasper Kristensen and his fix has been
included in the CppAD distribution.
06-22
=====
The :ref:`ADFun-name` operation
*f* ( *x* , *y* ) no longer executes a zero order
:ref:`Forward-name` operation when a new operation sequence is stored in
*f* .
In addition, the syntax for this operation was changed to
*f* . ``Dependent`` ( *y* ) (see :ref:`Dependent-name` ).
{xrst_comment ------------------------------------------------------ }
06-19
=====
The changes listed under 06-17 and 06-18 were made in the branches/ADFun branch
of the CppAD subversion repository. They did not get merged into the trunk
and become part of the distribution until 06-19. This accomplished the
following goal, which was removed from the :ref:`wish_list-name` :
"We would like to be able to erase the function
values so that :ref:`ADFun-name` objects use less memory.
We may even want to erase the AD operation sequence so that
:ref:`ADFun-name` objects use even less memory and can be used
for a subsequent AD operation sequence."
#. 06-17:
Added :ref:`capacity_order-name` which can be used to control
the amount of memory used to store :ref:`Forward-name` results.
Also :ref:`deprecated<fun_deprecated-name>` ``taylor_size`` , and defined
:ref:`size_order-name` in its place.
#. 06-18:
Added the :ref:`ADFun default constructor<fun_construct-name>`
and the ability to
:ref:`store a new operation sequence<Dependent-name>`
in an ``ADFun`` object with out having to use
``ADFun`` pointers together with ``new``
and ``delete`` .
{xrst_comment ------------------------------------------------------ }
06-17
=====
The location where the distribution files are stored has changed
and this broke the Download Current Version links for the
unix and windows installation.
This has been fixed.
The compiling instructions for the :ref:`speed_cppad-name` routines have been improved.
The :ref:`Value-name` function has been extended to allow for
:ref:`glossary@Parameter` arguments even if the corresponding
tape is in the Recording state.
The :ref:`BenderQuad-name` documentation and example have been improved
by changing *Vector* to *BAvector* to emphasize that
it corresponds to a vector of *Base* objects.
06-15
=====
Change :ref:`BenderQuad-name` to use *Base* instead of
``AD`` < *Base* > where every possible.
This allows for more calculations to be done in the base type; i.e.,
is more efficient.
06-09
=====
Add a size check (size one) for the
:ref:`function value argument, g<BenderQuad@g>` in ``BenderQuad`` .
06-07
=====
Some major changes were made to the notation in
:ref:`get_started.cpp-name` (to make it easier to start using CppAD).
In the :ref:`Introduction-name` example,
:math:`exp_eps` was changed to :math:`{\rm exp\_eps}`.
06-05
=====
Change :ref:`BenderQuad-name`
:math:`F_y (x, y)` to :math:`H(x,y)` so applies in a more
general setting.
This was another change to the ``BenderQuad`` interface,
*fun* . ``fy`` was changed to *fun* . ``h`` .
06-02
=====
Newer versions of the gcc compiler generated a warning for possible
use of an uninitialized pointer.
This was found by Michael Tautschnig and his fix has been
included in the CppAD distribution.
05-31
=====
The interface to :ref:`BenderQuad-name` has been changed.
Now all the function evaluation routines
are member functions of one class object.
This makes it easy for them to share common data.
05-29
=====
Change statement of command syntax to
be in the same browser frame as the command documentation
(for all the commands with a syntax statement).
Now when a user links to a specific heading in
a command's documentation,
the syntax for that command is automatically included.
Before the user needed to
follow another link to see to the command syntax.
05-27
=====
Added :ref:`BenderQuad-name` for computing the Hessian of
Bender's reduced objective function.
Added special specifications for ``resize(0)``
to :ref:`CppAD_vector-name` .
05-03
=====
The g++ (GCC) 4.1.0 (Red Hat 4.1.0-3) compiler reported an error
because certain functions were used before being defined
(version 3.4.4 did not complain about this).
This has been fixed.
04-29
=====
Change all of the example and test driver programs so that they return
error codes; i.e., zero for no error and one for an error.
Add more discussion and a reference for a
``gcc 3.4.4 -O2`` bug (since been removed).
04-28
=====
Improve the :ref:`get_started.cpp-name` example and move
it so that it is visible at the too level of the documentation.
04-26
=====
The programs in :ref:`Introduction-name` have been converted to automated
test that return true or false with the driver program
:ref:`Introduction<exp_apx.cpp-name>` .
04-25
=====
Add an :ref:`Introduction-name` section to the documentation
(replaces old example that was part of the :ref:`Theory-name` section).
04-19
=====
A discussion was added near the end of the :ref:`FunCheck-name` documentation.
And the cross references to the :ref:`CompareChange-name` discussion
were changed to the FunCheck discussion.
An operation sequence entry was added to the :ref:`wish_list-name` .
04-18
=====
The new definitions for
:ref:`glossary@AD of Base`
and
:ref:`operation sequence<glossary@Operation@Sequence>`
have been used throughout the documentation.
Add the :ref:`FunCheck-name` section for checking that a sequence of
operations is as intended.
04-17
=====
The documentation for :ref:`SpeedTest-name` and :ref:`Poly-name` was improved.
Definitions were added for an atomic :ref:`glossary@Operation`
and for an operation sequence being
dependent and independent of the values of specific operands.
The definition of AD sequence of operations was made abstract
and moved to the glossary as
:ref:`Type operation sequence<glossary@Operation@Sequence>` .
04-15
=====
The :ref:`mul_level-name` example was moved from
:ref:`ADFun-name` to :ref:`General-name` .
The documentation for :ref:`SpeedTest-name` was improved.
04-14
=====
Documentation and examples were improved for the following routines:
:ref:`ForTwo-name` ,
:ref:`RevTwo-name` .
In addition, the computation in ``RevTwo`` was made more efficient
(it used to possibly calculate some first order partials that were not used).
04-13
=====
Documentation and examples were improved for the following routines:
:ref:`Jacobian-name` ,
:ref:`ForOne-name` ,
:ref:`RevOne-name` ,
and :ref:`Hessian-name` .
04-08
=====
In the case where :ref:`fun_deprecated@use_VecAD` is true,
the :ref:`ForSparseJac-name` calculation in only for the current
independent variable values.
In this case, the sparsity pattern can be (and has been)
made more efficient; i.e., fewer true values
(because it only applies to the current :ref:`forward_zero-name` ).
The conversion from
:ref:`VecAD@VecAD\<Base>::reference`
to :ref:`AD-name` gave a compile error (this has been fixed).
Code example for this fix
::
VecAD<double> V(1);
AD<double> zero = 0;
V[zero] = 1.;
static_cast< AD<double> > ( V[zero] );
04-06
=====
The :ref:`ForSparseJac-name` , :ref:`RevSparseJac-name` , :ref:`RevSparseHes-name`
sparsity results are now valid for
all independent variable values
(if the AD operation sequence does no use any
``VecAD`` < *Base* > operands).
In addition, the
``ForSparseJac`` , :ref:`RevSparseJac-name` and :ref:`RevSparseHes-name`
documentation and examples were improved.
The :ref:`useVecAD<fun_deprecated@use_VecAD>`
member function was added to :ref:`ADFun-name` objects.
The ``var_size`` member function was changed to
:ref:`fun_property@size_var`
(this is not backward compatible, but ``var_size`` was just added on
:ref:`2006@mm-dd@04-03` ).
04-05
=====
The documentation and example for :ref:`CompareChange-name` were
improved and moved to be part of the :ref:`Forward-name` section.
04-04
=====
The documentation and examples for :ref:`Reverse-name` were
improved and split into :ref:`reverse_one-name` and :ref:`reverse_any-name` .
04-03
=====
Create separate sections for the
:ref:`zero<forward_zero-name>` and :ref:`forward_one-name` first order case
of :ref:`Forward-name` mode.
The ADFun :ref:`fun_deprecated@Size` member function
has been deprecated (use :ref:`size_order-name` instead).
The :ref:`Reverse-name` member function is now declared,
and documented as, ``const`` ; i.e.,
it does not effect the state of the ADFun object.
Change the examples that use :ref:`Reverse-name` to use the same
return value notation as the documentation; i.e., ``dw`` .
04-02
=====
The member functions of :ref:`ADFun-name` that return properties of
AD of *Base*
:ref:`operation sequence<glossary@Operation@Sequence>`
have been grouped into the :ref:`fun_property-name` section.
In addition, the :ref:`fun_property.cpp-name` example has been added.
The :ref:`CompareChange-name` function documentation was improved
and moved to a separate section.
Group the documentation for the :ref:`ADFun-name` member functions that
evaluate functions and derivative values.
This organization has since been changed.
Remove the old ``Fun.cpp`` example and extend
:ref:`independent.cpp-name` so that it demonstrates using different
choices for the :ref:`SimpleVector-name` type.
04-01
=====
Move the :ref:`ADFun Constructor<fun_construct-name>` to its own separate
section, improve its documentation, and use :ref:`independent.cpp-name`
for its example.
The following member functions of :ref:`ADFun-name` have been
:ref:`deprecated<fun_deprecated-name>` :
``Order`` , ``Memory`` .
The wish list entry for Memory usage
was updated on 04-01.
The request was implemented on :ref:`2006@mm-dd@06-19`
and the entry was removed from the wish list.
03-31
=====
Add examples for the :ref:`Parameter, Variable<con_dyn_var-name>` and
:ref:`Independent-name` functions.
Move the :ref:`con_dyn_var@Parameter`
and :ref:`con_dyn_var@Variable` functions from
the :ref:`ADFun-name` section to the :ref:`AD-name` section.
In the examples for the :ref:`AD-name` sections,
refer to the range space vector instead of the dependent variable vector
because some of the components may not be
:ref:`variables<glossary@Variable>` .
03-30
=====
Move the :ref:`LuRatio-name` section below :ref:`lu_det_and_solve-name` .
Move the definition of an
AD of *Base*
:ref:`operation sequence<glossary@Operation@Sequence>`
from the glossary to the :ref:`AD-name` section.
Improve the definition of tape state.
Add mention of taping to
:ref:`Erf-name` , :ref:`bool_fun-name` , :ref:`near_equal_ext-name` ,and :ref:`Pow-name` .
Change the definition for
:ref:`VecAD@VecAD\<Base>::reference`
so that it stands out of the text better.
03-29
=====
Mention the :ref:`VecAD@VecAD\<Base>::reference` case in
documentation and examples for
:ref:`abs-name` , :ref:`atan2-name` , :ref:`erf-name` , and :ref:`pow-name` .
Fix a bug derivative computation for ``abs`` ( *x* )
when *x* had type ``AD< AD<double> >`` and *x*
had value zero.
Fix a bug using non-zero AD indices for :ref:`VecAD-name` vectors
while the tape is in the empty state.
Extend :ref:`erf-name` to include ``float`` , ``double`` ,
and ``VecAD`` < *Base* >:: ``reference`` .
03-28
=====
Mention the
:ref:`VecAD@VecAD\<Base>::reference` case in
documentation and examples for
:ref:`unary_plus-name` ,
:ref:`unary_minus-name` ,
:ref:`ad_binary-name` ,
:ref:`compound_assign-name` , and
:ref:`unary_standard_math-name`
03-27
=====
Extend and improve the
:ref:`VecAD exceptions<VecAD@VecAD<Base\>::reference@Exceptions>` .
Mention the :ref:`VecAD@VecAD\<Base>::reference` case
and generally improve
:ref:`addition<ad_binary-name>` documentation and examples.
03-26
=====
Improve documentation and examples for :ref:`VecAD-name` and change
its element type from
``VecADelem`` < *Base* > to ``VecAD_reference`` < *Base* >
(so that it looks more like
:ref:`VecAD@VecAD\<Base>::reference` ).
Mention the :ref:`VecAD@VecAD\<Base>::reference` case
and generally improve
:ref:`Value-name` , :ref:`ad_output-name` and :ref:`assignment<ad_assign-name>` documentation
and examples.
Extend :ref:`Integer-name` and :ref:`PrintFor-name` to include the
:ref:`VecAD@VecAD\<Base>::reference` case
(and mention in documentation and examples).
03-24
=====
Move :ref:`VecAD-name` and :ref:`LuRatio-name` from the old ExtendDomain section
to :ref:`AD-name` .
03-23
=====
Improve documentation and examples for
:ref:`CondExp-name` and :ref:`Discrete-name` .
Move both of these sections from ExtendDomain to :ref:`ADValued-name` .
03-22
=====
The documentation sections under :ref:`AD-name`
have been organized into a new set of sub-groups.
03-18
=====
The documentation and example for :ref:`PrintFor-name` have been improved.
The sections below :ref:`AD-name`
in the documentation have been organized into subgroups.
03-17
=====
The documentation and examples have been improved for the
following functions:
:ref:`bool_fun-name` , and
:ref:`near_equal_ext-name` .
03-16
=====
Improve the documentation and example for the :ref:`pow-name` function.
This includes splitting out and generalizing the integer case
:ref:`pow_int-name` .
The copies of the ``atan2`` function were included
in the CppAD namespace for the
``float`` and ``double`` types.
03-15
=====
Improve the introduction to CppAD on the top level page
of the documentation.
03-11
=====
The file ``cppad/local/MathOther.h`` had a file name case error
that prevented the documentation from building and tests from running
(except under Cygwin which is not really case sensitive).
This has been fixed.
The term AD of *Base*
:ref:`operation sequence<glossary@Operation@Sequence>`
has been defined.
It will be used to improve the user's understanding of exactly
how an :ref:`ADFun-name` object is related to the C++ algorithm.
03-10
=====
The math functions that are not under :ref:`unary_standard_math-name` have
been grouped under ``MathOther`` .
The documentation and examples have been improved for the
following functions:
:ref:`abs-name` , :ref:`atan2-name` .
03-09
=====
The examples
:ref:`cos.cpp-name` ,
:ref:`cosh.cpp-name` ,
:ref:`exp.cpp-name` ,
:ref:`log.cpp-name` ,
:ref:`log10.cpp-name` ,
:ref:`sin.cpp-name` ,
:ref:`sinh.cpp-name` ,
:ref:`sqrt.cpp-name`
have been improved.
03-07
=====
The ``tan`` function has been added to CppAD.
The examples :ref:`Acos.cpp-name` , :ref:`Asin.cpp-name` and
:ref:`atan.cpp-name` have been improved.
03-05
=====
The AD standard math unary functions documentation
has been grouped together with improved documentation
in :ref:`unary_standard_math-name` .
02-28
=====
The :ref:`ad_output-name` and :ref:`Abs-name`
documentation and example have been improved.
Minor improvements were also made to the :ref:`lu_vec_ad.cpp-name` documentation.
02-25
=====
The :ref:`Compare-name` documentation and example have been improved.
02-24
=====
The documentation and examples have been improved for the following sections:
:ref:`division<ad_binary-name>` , :ref:`-=<compound_assign-name>` , :ref:`\*=<compound_assign-name>` , and :ref:`/=<compound_assign-name>` .
02-23
=====
The :ref:`multiplication<ad_binary-name>` documentation and example have been improved.
02-21
=====
The :ref:`subtraction<ad_binary-name>` documentation and example have been improved.
There was a bug :ref:`RevTwo-name` that was not detected by the
:ref:`rev_two.cpp-name` test. This bug was reported by
`Kasper Kristensen <https://list.coin-or.org/pipermail/cppad/2006-February/000020.html>`_
A test was added ``TestMore/rev_two.cpp`` that detects this problem
and the problem has been fixed.
02-15
=====
The :ref:`+=<compound_assign-name>` documentation and example have been improved.
02-14
=====
The :ref:`addition<ad_binary-name>` documentation and example have been improved.
02-13
=====
Combine the old binary operator and compound assignment documentation
into :ref:`Arithmetic-name` documentation.
The documentation and examples have been improved for the following sections:
:ref:`assignment<ad_assign-name>` , :ref:`unary_plus-name` , :ref:`unary_minus-name` .
02-11
=====
The documentation and examples have been improved for the following sections:
:ref:`ad_ctor-name` ,
:ref:`ad_ctor-name` and :ref:`ad_assign-name` , and
:ref:`Value-name` .
02-10
=====
This is the beginning of a pass to improve the documentation:
The documentation sections
The CopyBase (formerly FromBase and now part of :ref:`ad_ctor-name` and :ref:`ad_assign-name` ) and
:ref:`AD copy constructor<ad_ctor-name>`
(formerly Copy) documentation has been modified.
Some of the error messaging during :ref:`ADFun-name` construction
has been improved.
02-04
=====
There was a read memory access past the end of an array in
:ref:`CppAD::vector::push_back<CppAD_vector@push_back>` .
This has been fixed and in addition
:ref:`track_new_del-name` is now used to do and check the allocation in
``CppAD::vector`` .
The routines :ref:`Runge45-name` and :ref:`Rosen34-name`
had static vectors to avoid recalculation on each call.
These have been changed to be plain vectors to avoid memory
leak detection by :ref:`track_new_del@TrackCount` .
01-20
=====
Add software guidelines
to the wish list.
01-18
=====
Improve the definition for
:ref:`parameters<glossary@Parameter>` and
:ref:`variables<glossary@Variable>` .
Remove unnecessary reference to parameter and variable
in documentation for :ref:`Independent-name` .
01-08
=====
The aclocal program is part of the automake and autoconf system.
It often generates warnings of the form:
| |tab| / ``usr/share/aclocal/`` ...: ``warning: underquoted definition of``
| |tab| ...
The shell script file ``FixAclocal`` ,
which attempts to fix these warnings,
was added to the distribution.
01-07
=====
Change CppAD error handler from using the macros defined in
``cppad/CppADError.h`` to using a class defined in
:ref:`include/cppad/utility/error_handler.hpp<ErrorHandler-name>` .
The macros ``CppADUnknownError`` and ``CppADUsageError``
have been deprecated (they are temporarily still available in the
file ``cppad/local/CppADError.h`` ).
01-02
=====
Add the sed script ``Speed/gprof.sed`` to aid in the display of the
profiling output.
Make the following source code files easier to understand:
``Add.h`` , ``Sub.h`` , ``Mul.h`` , ``Div.h``
(in the directory ``cppad/local`` ).
01-05
=====
Make the following source code files easier to understand:
``RevSparseHes.h`` ,
``Reverse.h`` ,
``Fun.h`` ,
``Forward.h`` ,
``ForSparseJac.h`` ,
``RevSparseJac.h``
(in the directory ``cppad/local`` ).
{xrst_end 2006}
================================================
FILE: appendix/whats_new/2007.xrst
================================================
# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>
# SPDX-FileContributor: 2003-24 Bradley M. Bell
# ----------------------------------------------------------------------------
{xrst_begin 2007 app}
{xrst_spell
adouble
apx
autoconf
automake
executables
gettimeofday
ginac
intro
inv
isnan
kipp
makefile
makefiles
omh
openmp
rpm
tarballs
tay
tgz
threadprivate
valgrind
vcproj
yyyymmdd
}
Release Notes for 2007
######################
mm-dd
*****
12-29
=====
License conversions missed the copyright message at the top
in the following special cases:
``makefile.am`` , ``makefile.in`` , and
``omh/appendix/license.omh`` .
12-25
=====
The :ref:`install-name` instructions have been improved.
12-21
=====
The --with_Documentation
option on the ``configure`` command line caused an error on some
systems because it attempted to copy to many files.
This has been fixed by copying the directory instead of the individual files.
12-08
=====
By mistake, the documentation :ref:`License-name` statement
for the GPL distribution was the same as for the CPL distribution.
This has been fixed.
12-05
=====
Change the name of the spec file from
``cppad-`` *yyyymmdd* . ``spec`` to ``cppad.spec`` .
12-04
=====
Add the capability for the RPM spec file to use a different
prefix directory.
12-03
=====
This is the first version with the rpm spec file
``cppad.spec`` .
12-02
=====
Add the ``DESTDIR`` = *directory* option on the
:ref:`configure@make install` command line.
11-29
=====
The :ref:`unary_standard_math-name` function ``sqrt`` did not link properly
when *Base* was ``AD<double>`` .
This has been fixed.
11-23
=====
The routines ``nan`` and ``isnan`` were failing
for some systems because they use ``nan`` and or ``isnan``
as preprocessor symbols.
This has been fixed; see :ref:`nan@Include@Macros` .
In addition, the example and test :ref:`nan.cpp-name` has been added.
11-18
=====
Speed tests for ``tape_values`` branch were not better than trunk,
so the good parts of that branch (but not all) were merged into the trunk.
The interface specifications for
:ref:`base type requirements<base_require-name>` have been changed so that
CppAD would compile with ``gcc 4.1.1``
(which requires more definitions before use in template functions).
This changed of requirements is demonstrated by the
:ref:`base_complex.hpp-name` and :ref:`base_adolc.hpp-name` examples.
The problem with newer C++ compilers requiring more definitions before use
also required the user to know about ``float`` and ``double``
definitions for the standard math
functions in the CppAD namespace;
see :ref:`base_std_math-name` .
The ``example/test_one.sh`` and ``test_more/test_one.sh``
scripts were modified so that one only need specify the test file name
(does not also need the test routine name). Some of the test routine
declarations were changed from *name* () to
*name* ( ``void`` ) to make this possible.
The program ``test_more/test_more`` was changed to always
report the memory leak test results (same as ``example/example`` ).
The :ref:`PrintFor-name` function was putting an unused variable in the tape.
This has been fixed.
11-06
=====
Added the ``-DRAD_EQ_ALIAS`` compiler flag to the
:ref:`Sacado speed tests<speed_sacado-name>` .
In addition, compiler flag documentation was included for
Sacado and all the other speed tests.
11-05
=====
MS project files have been added for running the
:ref:`cppad<speed_cppad-name>` and
:ref:`double<speed_double-name>`
speed tests.
11-04
=====
The ``cppad/config.h`` file was not compatible with the
Windows install procedure and
the Windows project's could not find a certain include file.
This has been fixed.
The :ref:`unix install<configure-name>` procedure has been modified
so that the one configure flag
``--with-Speed``
builds all the possible executables related to the speed testing.
11-03
=====
Improve the :ref:`speed_main-name` documentation and output
(as well as the title for other sections under :ref:`speed-name` ).
The subversion copy of the :ref:`configure@Configure` script
was not executable.
This has been fixed.
11-02
=====
The instructions for downloading the current version using
``subversion`` have changed.
The user should now directly edit the file
::
trunk/configure
in order to set the correct date for the installation
and to build the corresponding documentation.
The :ref:`speed-name` section has been slightly reorganized
(the main program and utilities have been separated).
Add :ref:`speed_double-name` for testing the speed of evaluating
functions in ``double`` as apposed to gradients using AD types.
11-01
=====
The instructions for downloading the current version using subversion
have changed.
The user must now execute the command
::
./build.sh version
in order to set the correct version number for her (or his) installation.
Add the return status for all the correctness tests
to the documentation; see ``make test`` .
10-30
=====
The download instructions did not update current version number
and this broke the links to the current tarballs.
This has been fixed.
The documentation for :ref:`det_by_minor-name` and :ref:`det_by_lu-name`
has been improved.
The order of the elements in :ref:`det_of_minor-name` has been
corrected (they were transposed but this did not really matter
because determinants of transposes are equal).
The makefiles in the distribution have been changed so that
one can run configure from a directory other than the distribution directory.
10-27
=====
A ``subversion`` method
for downloading CppAD has been added.
The installation was broken on some systems because the
:ref:`configure@Configure` command tried to run
the ``autoconf`` and ``automake`` programs.
This has been fixed by adding
``AM_MAINTAINER_MODE`` to the ``autoconf`` input file.
Extend the
``subversion``
methods to include a full installation and old versions.
10-23
=====
The :ref:`configure@cxx_flags` environment variable
has been changed from ``CPP_ERROR_WARN`` to ``CXX_FLAGS`` .
The command ``configure --help`` now prints a description
of the environment variables
``ADOLC_DIR`` ,
``FADBAD_DIR`` ,
``SACADO_DIR`` ,
``BOOST_DIR`` ,
and
``CXX_FLAGS`` .
In addition, if the environment variables
``POSTFIX_DIR`` or ``CPP_ERROR_WARN`` are used,
an message is printed saying that are not longer valid.
10-22
=====
The correctness checks and speed test wrappers were moved
from the individual package directories to :ref:`speed_main-name` .
This way they do not have to be reproduced for each package.
This makes it easier to add a new package,
but it requires the prototype for
``compute_`` *test_name* to be the same for all packages.
The `Sacado <https://trilinos.github.io/sacado.html>`_
package was added to the list of :ref:`speed-name` tests.
In addition, the discussion about how to run each of the
speed tests was corrected to include the *seed* argument.
The *postfix_dir* option
was removed on :ref:`2006-12-05<2006@mm-dd@12-05>` but
it was not removed from the
:ref:`configure@Configure`
documentation.
This has been fixed.
The routine :ref:`CheckSimpleVector-name` was changed.
It used to require conversion of the form
*Scalar* ( *i* )
where *i* was ``0`` or ``1`` .
This does not work with when *Scalar* is
``Sacado::Tay::Taylor<double>`` .
This requirement has been changed
(see :ref:`CheckSimpleVector@Restrictions` )
to support of
*x* = *i*
where *x* has type *Scalar*
and *i* has type ``int`` .
Fix include directives in :ref:`speed_fadbad-name` programs
``det_lu`` , ``det_minor`` , and ``poly`` ,
to use ``FADBAD++`` instead of ``Fadbad++`` directory.
Add ``ADOLC_DIR`` , ``FADBAD_DIR`` , ``SACADO_DIR`` ,
and ``BOOST_DIR``
to the :ref:`configure@Configure` help string.
10-16
=====
Add *seed* argument and
improve :ref:`speed_main-name` documentation.
10-13
=====
Fix the title in :ref:`adolc_det_lu.cpp-name` .
Add the package name to each test case result printed by
:ref:`speed_main-name` .
10-05
=====
Added and example using complex calculations for a
function that is not complex differentiable ``not_complex_ad.cpp`` .
(This example has been removed; see :ref:`complex FAQ<Faq@Complex Types>` .)
10-02
=====
Extend the :ref:`pow-name` function to work for any case where one argument
is ``AD`` < *Base* > and the other is ``double``
(as do the binary operators).
09-06
=====
If the :ref:`method.step<OdeErrControl@Method@step>` function returned
``nan`` (not a number),
it was possible for :ref:`OdeErrControl-name` to drop into an infinite loop.
This has been fixed.
08-09
=====
Let user detect and handle the case where an ODE initial vector *xi*
contains not a number ``nan``
(see :ref:`Runge45-name` , :ref:`Rosen34-name` , and :ref:`OdeErrControl-name` ).
Use the ``||`` operation instead of ``|``
operator in the ``nan`` function
(The Ginac library seems to use an alias for the type ``bool`` and
does not have ``|`` defined for this alias).
The file ``test_more/ode_err_control.cpp`` was using the
wrong include file name since the change on 08/07.
This has been fixed.
08-07
=====
Sometimes an ODE solver takes to large a step and this results
in invalid values for the variables being integrated.
The ODE solvers :ref:`Runge45-name` and :ref:`Rosen34-name` have been
modified to abort
and return :ref:`nan-name` when it is returned by the differential
equation evaluation.
The solver :ref:`OdeErrControl-name` have been modified to try smaller steps
when this happens.
Fix an :ref:`fun_construct@Sequence Constructor`
referenced to ``Dependent`` in documentation
(was using the :ref:`fun_deprecated-name` one argument syntax).
Add comment about mixing debug and non-debug versions of
CppAD in :ref:`track_new_del@TrackDelVec` error message.
07-30
=====
``CppADCreateBinaryBool`` and ``CppADCreateUnaryBool``
have been replaced by ``CPPAD_BOOL_BINARY`` and
``CPPAD_BOOL_UNARY`` respectively.
In addition, the :ref:`wish_list-name` item for conversion
of all preprocessor macros to upper case been completed and removed.
07-29
=====
The preprocessor macros
``CppADUsageError`` and ``CppADUnknownError``
have been replaced by ``CPPAD_ASSERT_KNOWN`` and
``CPPAD_ASSERT_UNKNOWN`` respectively.
The meaning for these macros
has been included in the :ref:`cppad_assert-name` section.
In addition, the *known* argument to :ref:`ErrorHandler-name`
was wrong for the unknown case.
The :ref:`wish_list-name` item
for conversion of all preprocessor macros to upper case
has been changes (to an item that was previous missing).
07-28
=====
The preprocessor macro ``CPPAD_DISCRETE_FUNCTION`` was defined
as a replacement for ``CppADCreateDiscrete``
which has been deprecated.
07-26
=====
Merge in changes made in ``branches/test_vector`` .
#. 07-26:
Change all occurrences of ``CppADvector`` ,
in the files ``test_more/`` * . ``cpp`` and ``speed/`` * /* . ``cpp`` ,
where changed to ``CPPAD_TEST_VECTOR`` .
All occurrences of the ``CppADvector`` in the documentation
were edited to reflect that fact that it has been deprecated.
The documentation index and search for
deprecated items has been improved.
#. 07-25:
Deprecate the preprocessor symbol ``CppADvector``
and start changing it to
``CPPAD_TEST_VECTOR`` .
Change all occurrences of ``CppADvector`` ,
in the ``example/`` * . ``cpp`` files,
to ``CPPAD_TEST_VECTOR`` .
07-23
=====
The :ref:`track_new_del-name` macros
``CppADTrackNewVec`` ,
``CppADTrackDelVec`` , and
``CppADTrackExtend`` have been deprecated.
The new macros names to use are
``CPPAD_TRACK_NEW_VEC`` ,
``CPPAD_TRACK_DEL_VEC`` , and
``CPPAD_TRACK_EXTEND`` respectively.
This item has been removed from the
software guidelines section of the wish list.
The member variable entry in the software guideline
wish list item has be brought up to date.
07-22
=====
Minor improvements to the :ref:`mul_level_adolc_ode.cpp-name` example.
07-21
=====
#. The ``openmp/run.sh`` example programs
``example_a11c.cpp`` ,
``openmp_newton_example.cpp`` , and
``sum_i_inv.cpp``
have been changed so that they run on more systems
(are C++ standard compliant).
#. :ref:`base_require-name` :
The ``IdenticalEqual`` function,
in the :ref:`base_require-name` specification,
was changed to ``IdenticalEqualCon``
(note the :ref:`base_require@API Warning` in the
*Base* requirement specifications).
#. Implementation of the :ref:`base requirements<base_require-name>` for complex types
were moved into the :ref:`base_complex.hpp-name` example.
07-20
=====
The download for CppAD was still broken.
It turned out that the copyright message was missing from the file
:ref:`base_adolc.hpp-name` and this stopped the creation of the download files.
This has been fixed.
In addition, the automated testing procedure has been modified so
that missing copyright messages and test program failures will
be more obvious in the test log.
07-19
=====
The download for CppAD has been broken since the example
``mul_level_adolc_ode.cpp`` was added because the
``example/example`` program was failing.
This has been fixed.
07-18
=====
A realistic example using Adolc with CppAD
:ref:`mul_level_adolc_ode.cpp-name` was added.
The documentation for :ref:`track_new_del-name` was improved.
07-14
=====
Add a discussion at the beginning of
:ref:`mul_level_ode.cpp-name` example
(and improve the notation used in the example).
07-13
=====
Separate the include file
:ref:`base_adolc.hpp-name`
from the :ref:`mul_level_adolc.cpp-name` example
so that it can be used by other examples.
06-22
=====
Add :ref:`mul_level_adolc.cpp-name` , an example that demonstrates using
``adouble`` and for the :ref:`Base<base_require-name>` type.
The :ref:`get_started.cpp-name`
example did not build when
the ``--with-Introduction`` and
``BOOST_DIR`` options were included on the
:ref:`configure@Configure` command line.
In fact, some of the :ref:`speed-name` tests also had compilation errors
when ``BOOST_DIR`` was include in the configure command.
This has been fixed.
There was a namespace reference missing in the files
that
gitextract_tk_667wh/ ├── .circleci/ │ └── config.yml ├── .github/ │ └── workflows/ │ ├── conda/ │ │ └── conda-env.yml │ ├── conda-bash.yml │ ├── conda-windows-clang.yml │ ├── conda-windows-eigen.yml │ ├── conda-windows-v142.yml │ ├── ubuntu-macos.yml │ └── windows-msys2.yml ├── .gitignore ├── .readthedocs.yaml ├── .travis.yml ├── CMakeLists.txt ├── COPYING ├── appendix/ │ ├── addon.xrst │ ├── appendix.xrst │ ├── bib.xrst │ ├── deprecated/ │ │ ├── compare_change.xrst │ │ ├── deprecated.xrst │ │ ├── fun_deprecated.xrst │ │ ├── include_deprecated.xrst │ │ └── omp_alloc.xrst │ ├── directory.xrst │ ├── faq.xrst │ ├── glossary.xrst │ ├── license.xrst │ ├── numeric_ad.xrst │ ├── whats_new/ │ │ ├── 2003.xrst │ │ ├── 2004.xrst │ │ ├── 2005.xrst │ │ ├── 2006.xrst │ │ ├── 2007.xrst │ │ ├── 2008.xrst │ │ ├── 2009.xrst │ │ ├── 2010.xrst │ │ ├── 2011.xrst │ │ ├── 2012.xrst │ │ ├── 2013.xrst │ │ ├── 2014.xrst │ │ ├── 2015.xrst │ │ ├── 2016.xrst │ │ ├── 2017.xrst │ │ ├── 2018.xrst │ │ ├── 2019.xrst │ │ ├── 2020.xrst │ │ ├── 2021.xrst │ │ ├── 2022.xrst │ │ ├── 2023.xrst │ │ ├── 2024.xrst │ │ ├── 2025.xrst │ │ ├── 2026.xrst │ │ └── whats_new.xrst │ └── wish_list.xrst ├── appveyor.yml ├── authors ├── batch_edit.sed ├── bin/ │ ├── appveyor.sh │ ├── build.bat │ ├── check_addon.sh │ ├── check_all.sh │ ├── check_copy.sh │ ├── check_define.sh │ ├── check_deprecated.sh │ ├── check_doxygen.sh │ ├── check_example.sh │ ├── check_if.sh │ ├── check_include_def.sh │ ├── check_include_file.sh │ ├── check_include_xrst.sh │ ├── check_invisible.sh │ ├── check_nominmax.sh │ ├── check_op_code.sh │ ├── check_sort.sh │ ├── check_tab.sh │ ├── check_tempfile.sh │ ├── check_trace.sh │ ├── check_user_def.py │ ├── check_version.sh │ ├── colpack.sh │ ├── deprecate_xam.sh │ ├── dev_settings.sh │ ├── dos_build.bat │ ├── doxyfile.sh │ ├── get_adolc.sh │ ├── get_colpack.sh │ ├── get_cppadcg.sh │ ├── get_fadbad.sh │ ├── get_ipopt.sh │ ├── get_optional.sh │ ├── get_sacado.sh │ ├── git_commit.sh │ ├── grep_and_sed.sh │ ├── group_list.sh │ ├── master_revert.sh │ ├── new_release.sh │ ├── no_bitwise.sh │ ├── package.sh │ ├── run_cmake.sh │ ├── run_configure.sh │ ├── run_doxygen.sh │ ├── run_xrst.sh │ ├── sort.sh │ ├── speed_branch.sh │ ├── speed_diff.sh │ ├── speed_new.sh │ ├── speed_package.sh │ ├── tag_month.sh │ ├── test_install.sh │ ├── test_multi_thread.sh │ ├── test_one.sh.in │ ├── trace.sh │ ├── travis.sh │ ├── twine.sh │ └── valgrind.sh ├── bug/ │ ├── boost_lu.sh │ ├── clang_simple.sh │ ├── cmake_target.sh │ ├── cppad_cg.sh │ ├── doxy_member.sh │ ├── eigen_shadow.sh │ ├── gcc_complex.sh │ ├── numeric_limit.sh │ ├── pow.sh │ ├── sparsity.sh │ ├── std_vector.sh │ ├── subgraph.sh │ ├── template.sh │ ├── test_install.sh │ └── vec_itr_speed.sh ├── cmake/ │ ├── add_check_executable.cmake │ ├── add_to_list.cmake │ ├── assert.cmake │ ├── assert_value_in_set.cmake │ ├── command_line_arg.cmake │ ├── compile_source_test.cmake │ ├── cppad_uninstall.cmake │ ├── dos_path_to_unix.cmake │ ├── eigen_info.cmake │ ├── pkgconfig_info.cmake │ ├── prefix_info.cmake │ ├── print_variable.cmake │ ├── run_source_test.cmake │ └── set_compile_flags.cmake ├── configure ├── cppad_ipopt/ │ ├── CMakeLists.txt │ ├── example/ │ │ ├── CMakeLists.txt │ │ ├── example.cpp │ │ ├── get_started.cpp │ │ ├── ode1.xrst │ │ ├── ode2.xrst │ │ ├── ode_check.cpp │ │ ├── ode_check.hpp │ │ ├── ode_fast.hpp │ │ ├── ode_fast_check.cpp │ │ ├── ode_problem.hpp │ │ ├── ode_run.hpp │ │ ├── ode_simple.hpp │ │ ├── ode_simple_check.cpp │ │ └── test.sh.in │ ├── speed/ │ │ ├── CMakeLists.txt │ │ ├── ode_speed.cpp │ │ ├── speed.cpp │ │ └── test.sh.in │ ├── src/ │ │ ├── CMakeLists.txt │ │ ├── cppad_ipopt_nlp.cpp │ │ ├── cppad_ipopt_nlp.hpp │ │ ├── fun_record.hpp │ │ ├── hes_fg_map.cpp │ │ ├── hes_fg_map.hpp │ │ ├── jac_g_map.cpp │ │ ├── jac_g_map.hpp │ │ ├── sparse_map2vec.cpp │ │ ├── sparse_map2vec.hpp │ │ ├── vec_fun_pattern.cpp │ │ └── vec_fun_pattern.hpp │ └── test/ │ ├── CMakeLists.txt │ ├── k_gt_one.cpp │ ├── multiple_solution.cpp │ ├── retape_k1_l1.cpp │ ├── retape_k1_l2.cpp │ ├── test.sh.in │ └── test_more.cpp ├── cppad_lib/ │ ├── CMakeLists.txt │ ├── code_gen_fun.cpp │ ├── cpp_graph_op.cpp │ ├── cppad_colpack.cpp │ ├── csrc_writer.cpp │ ├── json_lexer.cpp │ ├── json_parser.cpp │ ├── json_writer.cpp │ ├── link_dll_lib.cpp │ └── temp_file.cpp ├── epl-2.0.txt ├── example/ │ ├── CMakeLists.txt │ ├── abs_normal/ │ │ ├── CMakeLists.txt │ │ ├── abs_eval.cpp │ │ ├── abs_eval.hpp │ │ ├── abs_eval.xrst │ │ ├── abs_min_linear.cpp │ │ ├── abs_min_linear.hpp │ │ ├── abs_min_linear.xrst │ │ ├── abs_min_quad.cpp │ │ ├── abs_min_quad.hpp │ │ ├── abs_min_quad.xrst │ │ ├── abs_normal.cpp │ │ ├── abs_normal.xrst │ │ ├── abs_print_mat.hpp │ │ ├── get_started.cpp │ │ ├── lp_box.cpp │ │ ├── lp_box.hpp │ │ ├── lp_box.xrst │ │ ├── min_nso_linear.cpp │ │ ├── min_nso_linear.hpp │ │ ├── min_nso_linear.xrst │ │ ├── min_nso_quad.cpp │ │ ├── min_nso_quad.hpp │ │ ├── min_nso_quad.xrst │ │ ├── qp_box.cpp │ │ ├── qp_box.hpp │ │ ├── qp_box.xrst │ │ ├── qp_interior.cpp │ │ ├── qp_interior.hpp │ │ ├── qp_interior.xrst │ │ ├── simplex_method.cpp │ │ ├── simplex_method.hpp │ │ ├── simplex_method.xrst │ │ └── talk.tex │ ├── atomic_four/ │ │ ├── CMakeLists.txt │ │ ├── atomic_four.cpp │ │ ├── atomic_four.xrst │ │ ├── bilinear.cpp │ │ ├── dynamic.cpp │ │ ├── forward.cpp │ │ ├── get_started.cpp │ │ ├── lin_ode/ │ │ │ ├── CMakeLists.txt │ │ │ ├── forward.cpp │ │ │ ├── lin_ode.cpp │ │ │ ├── rev_depend.cpp │ │ │ ├── reverse.cpp │ │ │ └── sparsity.cpp │ │ ├── mat_mul/ │ │ │ ├── CMakeLists.txt │ │ │ ├── forward.cpp │ │ │ ├── identical_zero.cpp │ │ │ ├── mat_mul.cpp │ │ │ ├── rev_depend.cpp │ │ │ ├── reverse.cpp │ │ │ └── sparsity.cpp │ │ ├── norm_sq.cpp │ │ └── vector/ │ │ ├── CMakeLists.txt │ │ ├── add.cpp │ │ ├── div.cpp │ │ ├── hes_sparsity.cpp │ │ ├── jac_sparsity.cpp │ │ ├── mul.cpp │ │ ├── neg.cpp │ │ ├── rev_depend.cpp │ │ ├── sub.cpp │ │ └── vector.cpp │ ├── atomic_three/ │ │ ├── CMakeLists.txt │ │ ├── atomic_three.cpp │ │ ├── atomic_three.xrst │ │ ├── base2ad.cpp │ │ ├── dynamic.cpp │ │ ├── forward.cpp │ │ ├── get_started.cpp │ │ ├── hes_sparsity.cpp │ │ ├── jac_sparsity.cpp │ │ ├── mat_mul.cpp │ │ ├── norm_sq.cpp │ │ ├── reciprocal.cpp │ │ ├── rev_depend.cpp │ │ ├── reverse.cpp │ │ └── tangent.cpp │ ├── atomic_two/ │ │ ├── CMakeLists.txt │ │ ├── atomic_two.cpp │ │ ├── eigen_cholesky.cpp │ │ ├── eigen_mat_inv.cpp │ │ └── eigen_mat_mul.cpp │ ├── chkpoint_two/ │ │ ├── CMakeLists.txt │ │ ├── base2ad.cpp │ │ ├── chkpoint_two.cpp │ │ ├── compare.cpp │ │ ├── dynamic.cpp │ │ ├── get_started.cpp │ │ └── ode.cpp │ ├── compare_change/ │ │ ├── CMakeLists.txt │ │ └── compare_change.cpp │ ├── cppad_code_gen/ │ │ ├── CMakeLists.txt │ │ ├── cppad_code_gen.cpp │ │ ├── file.cpp │ │ ├── function.cpp │ │ ├── jac_as_fun.cpp │ │ ├── jacobian.cpp │ │ ├── sparse_jac_as_fun.cpp │ │ └── sparse_jacobian.cpp │ ├── general/ │ │ ├── CMakeLists.txt │ │ ├── abort_recording.cpp │ │ ├── acos.cpp │ │ ├── acosh.cpp │ │ ├── ad_assign.cpp │ │ ├── ad_ctor.cpp │ │ ├── ad_fun.cpp │ │ ├── ad_in_c.cpp │ │ ├── ad_input.cpp │ │ ├── ad_output.cpp │ │ ├── add.cpp │ │ ├── add_eq.cpp │ │ ├── asin.cpp │ │ ├── asinh.cpp │ │ ├── atan.cpp │ │ ├── atan2.cpp │ │ ├── atanh.cpp │ │ ├── azmul.cpp │ │ ├── base2ad.cpp │ │ ├── base2vec_ad.cpp │ │ ├── base_alloc.hpp │ │ ├── base_require.cpp │ │ ├── bender_quad.cpp │ │ ├── bool_fun.cpp │ │ ├── capacity_order.cpp │ │ ├── change_param.cpp │ │ ├── check_for_nan.cpp │ │ ├── compare.cpp │ │ ├── complex_poly.cpp │ │ ├── con_dyn_var.cpp │ │ ├── cond_exp.cpp │ │ ├── cos.cpp │ │ ├── cosh.cpp │ │ ├── div.cpp │ │ ├── div_eq.cpp │ │ ├── eigen_array.cpp │ │ ├── eigen_det.cpp │ │ ├── equal_op_seq.cpp │ │ ├── erf.cpp │ │ ├── erfc.cpp │ │ ├── exp.cpp │ │ ├── expm1.cpp │ │ ├── fabs.cpp │ │ ├── for_one.cpp │ │ ├── for_two.cpp │ │ ├── forward.cpp │ │ ├── forward_dir.cpp │ │ ├── forward_order.cpp │ │ ├── fun_assign.cpp │ │ ├── fun_check.cpp │ │ ├── fun_property.cpp │ │ ├── function_name.cpp │ │ ├── general.cpp │ │ ├── hes_lagrangian.cpp │ │ ├── hes_lu_det.cpp │ │ ├── hes_minor_det.cpp │ │ ├── hes_times_dir.cpp │ │ ├── hessian.cpp │ │ ├── independent.cpp │ │ ├── integer.cpp │ │ ├── interface2c.cpp │ │ ├── interp_onetape.cpp │ │ ├── interp_retape.cpp │ │ ├── jac_lu_det.cpp │ │ ├── jac_minor_det.cpp │ │ ├── jacobian.cpp │ │ ├── log.cpp │ │ ├── log10.cpp │ │ ├── log1p.cpp │ │ ├── lu_ratio.cpp │ │ ├── lu_vec_ad.cpp │ │ ├── lu_vec_ad.hpp │ │ ├── lu_vec_ad_ok.cpp │ │ ├── mul.cpp │ │ ├── mul_eq.cpp │ │ ├── mul_level.cpp │ │ ├── mul_level_adolc.cpp │ │ ├── mul_level_adolc_ode.cpp │ │ ├── mul_level_ode.cpp │ │ ├── near_equal_ext.cpp │ │ ├── new_dynamic.cpp │ │ ├── num_limits.cpp │ │ ├── number_skip.cpp │ │ ├── numeric_type.cpp │ │ ├── ode_stiff.cpp │ │ ├── opt_val_hes.cpp │ │ ├── pow.cpp │ │ ├── pow_nan.cpp │ │ ├── print_for.cpp │ │ ├── rev_checkpoint.cpp │ │ ├── rev_one.cpp │ │ ├── rev_two.cpp │ │ ├── reverse_one.cpp │ │ ├── reverse_three.cpp │ │ ├── reverse_two.cpp │ │ ├── sign.cpp │ │ ├── sin.cpp │ │ ├── sinh.cpp │ │ ├── sqrt.cpp │ │ ├── stack_machine.cpp │ │ ├── sub.cpp │ │ ├── sub_eq.cpp │ │ ├── tan.cpp │ │ ├── tanh.cpp │ │ ├── tape_index.cpp │ │ ├── taylor_ode.cpp │ │ ├── unary_minus.cpp │ │ ├── unary_plus.cpp │ │ ├── value.cpp │ │ ├── var2par.cpp │ │ └── vec_ad.cpp │ ├── get_started/ │ │ ├── CMakeLists.txt │ │ └── get_started.cpp │ ├── graph/ │ │ ├── CMakeLists.txt │ │ ├── add_op.cpp │ │ ├── atom4_op.cpp │ │ ├── atom_op.cpp │ │ ├── azmul_op.cpp │ │ ├── cexp_op.cpp │ │ ├── comp_op.cpp │ │ ├── discrete_op.cpp │ │ ├── div_op.cpp │ │ ├── graph.cpp │ │ ├── mul_op.cpp │ │ ├── pow_op.cpp │ │ ├── print_graph.cpp │ │ ├── print_op.cpp │ │ ├── sub_op.cpp │ │ ├── sum_op.cpp │ │ ├── switch_var_dyn.cpp │ │ └── unary_op.cpp │ ├── ipopt_solve/ │ │ ├── CMakeLists.txt │ │ ├── get_started.cpp │ │ ├── ipopt_solve.cpp │ │ ├── ode_inverse.cpp │ │ ├── retape.cpp │ │ └── test.sh.in │ ├── jit/ │ │ ├── CMakeLists.txt │ │ ├── atomic.cpp │ │ ├── compare_change.cpp │ │ ├── compile.cpp │ │ ├── dynamic.cpp │ │ ├── get_started.cpp │ │ ├── jit.cpp │ │ └── jit.xrst │ ├── json/ │ │ ├── CMakeLists.txt │ │ ├── add_op.cpp │ │ ├── atom4_op.cpp │ │ ├── atom_op.cpp │ │ ├── azmul_op.cpp │ │ ├── cexp_op.cpp │ │ ├── comp_op.cpp │ │ ├── discrete_op.cpp │ │ ├── div_op.cpp │ │ ├── from_json.cpp │ │ ├── get_started.cpp │ │ ├── json.cpp │ │ ├── mul_op.cpp │ │ ├── pow_op.cpp │ │ ├── print_op.cpp │ │ ├── sparse.cpp │ │ ├── sub_op.cpp │ │ ├── sum_op.cpp │ │ ├── to_json.cpp │ │ └── unary_op.cpp │ ├── multi_thread/ │ │ ├── CMakeLists.txt │ │ ├── bthread/ │ │ │ ├── CMakeLists.txt │ │ │ ├── a11c_bthread.cpp │ │ │ ├── get_started.cpp │ │ │ └── team_bthread.cpp │ │ ├── harmonic.cpp │ │ ├── harmonic.hpp │ │ ├── harmonic.xrst │ │ ├── multi_atomic_three.cpp │ │ ├── multi_atomic_three.hpp │ │ ├── multi_atomic_three.xrst │ │ ├── multi_atomic_two.cpp │ │ ├── multi_atomic_two.hpp │ │ ├── multi_atomic_two.xrst │ │ ├── multi_chkpoint_one.cpp │ │ ├── multi_chkpoint_one.hpp │ │ ├── multi_chkpoint_one.xrst │ │ ├── multi_chkpoint_two.cpp │ │ ├── multi_chkpoint_two.hpp │ │ ├── multi_chkpoint_two.xrst │ │ ├── multi_newton.cpp │ │ ├── multi_newton.hpp │ │ ├── multi_newton.xrst │ │ ├── openmp/ │ │ │ ├── CMakeLists.txt │ │ │ ├── a11c_openmp.cpp │ │ │ ├── get_started.cpp │ │ │ └── team_openmp.cpp │ │ ├── pthread/ │ │ │ ├── CMakeLists.txt │ │ │ ├── a11c_pthread.cpp │ │ │ ├── get_started.cpp │ │ │ └── team_pthread.cpp │ │ ├── sthread/ │ │ │ ├── CMakeLists.txt │ │ │ ├── a11c_sthread.cpp │ │ │ ├── get_started.cpp │ │ │ └── team_sthread.cpp │ │ ├── team_example.cpp │ │ ├── team_example.hpp │ │ ├── team_thread.hpp │ │ ├── template/ │ │ │ └── get_started.xrst │ │ └── thread_test.cpp │ ├── optimize/ │ │ ├── CMakeLists.txt │ │ ├── compare_op.cpp │ │ ├── conditional_skip.cpp │ │ ├── cumulative_sum.cpp │ │ ├── forward_active.cpp │ │ ├── nest_conditional.cpp │ │ ├── optimize.cpp │ │ ├── optimize_twice.cpp │ │ ├── print_for.cpp │ │ └── reverse_active.cpp │ ├── print_for/ │ │ ├── CMakeLists.txt │ │ ├── print_for.cpp │ │ └── test.sh │ ├── sparse/ │ │ ├── CMakeLists.txt │ │ ├── colpack_hes.cpp │ │ ├── colpack_hessian.cpp │ │ ├── colpack_jac.cpp │ │ ├── colpack_jacobian.cpp │ │ ├── conj_grad.cpp │ │ ├── dependency.cpp │ │ ├── for_hes_sparsity.cpp │ │ ├── for_jac_sparsity.cpp │ │ ├── for_sparse_hes.cpp │ │ ├── for_sparse_jac.cpp │ │ ├── rc_sparsity.cpp │ │ ├── rev_hes_sparsity.cpp │ │ ├── rev_jac_sparsity.cpp │ │ ├── rev_sparse_hes.cpp │ │ ├── rev_sparse_jac.cpp │ │ ├── sparse.cpp │ │ ├── sparse2eigen.cpp │ │ ├── sparse_hes.cpp │ │ ├── sparse_hessian.cpp │ │ ├── sparse_jac_for.cpp │ │ ├── sparse_jac_rev.cpp │ │ ├── sparse_jacobian.cpp │ │ ├── sparse_sub_hes.cpp │ │ ├── sparsity_sub.cpp │ │ ├── sub_sparse_hes.cpp │ │ ├── subgraph_hes2jac.cpp │ │ ├── subgraph_jac_rev.cpp │ │ ├── subgraph_reverse.cpp │ │ └── subgraph_sparsity.cpp │ ├── utility/ │ │ ├── CMakeLists.txt │ │ ├── check_numeric_type.cpp │ │ ├── check_simple_vector.cpp │ │ ├── cppad_vector.cpp │ │ ├── dll_lib.cpp │ │ ├── error_handler.cpp │ │ ├── index_sort.cpp │ │ ├── lu_factor.cpp │ │ ├── lu_invert.cpp │ │ ├── lu_solve.cpp │ │ ├── nan.cpp │ │ ├── near_equal.cpp │ │ ├── ode_err_control.cpp │ │ ├── ode_err_maxabs.cpp │ │ ├── ode_gear.cpp │ │ ├── ode_gear_control.cpp │ │ ├── poly.cpp │ │ ├── pow_int.cpp │ │ ├── romberg_mul.cpp │ │ ├── romberg_one.cpp │ │ ├── rosen_34.cpp │ │ ├── runge45_1.cpp │ │ ├── runge_45.cpp │ │ ├── set_union.cpp │ │ ├── simple_vector.cpp │ │ ├── sparse_rc.cpp │ │ ├── sparse_rcv.cpp │ │ ├── thread_alloc.cpp │ │ ├── to_string.cpp │ │ ├── utility.cpp │ │ └── vector_bool.cpp │ └── valvector/ │ ├── CMakeLists.txt │ ├── ad_join.cpp │ ├── ad_split.cpp │ ├── ad_sum.cpp │ ├── assign.cpp │ ├── azmul.cpp │ ├── base_require.cpp │ ├── binary_op.cpp │ ├── compare_op.cpp │ ├── compound_op.cpp │ ├── condexp.cpp │ ├── ctor.cpp │ ├── element.cpp │ ├── get_started.cpp │ ├── llsq_obj.cpp │ ├── output.cpp │ ├── pow.cpp │ ├── resize.cpp │ ├── size.cpp │ ├── sum.cpp │ ├── unary_math.cpp │ ├── unary_op.cpp │ └── valvector.cpp ├── include/ │ └── cppad/ │ ├── CMakeLists.txt │ ├── base_require.hpp │ ├── configure.hpp.in │ ├── core/ │ │ ├── abort_recording.hpp │ │ ├── abs.hpp │ │ ├── abs_normal_fun.hpp │ │ ├── ad.hpp │ │ ├── ad_assign.hpp │ │ ├── ad_binary.hpp │ │ ├── ad_ctor.hpp │ │ ├── ad_fun.hpp │ │ ├── ad_fun.xrst │ │ ├── ad_io.hpp │ │ ├── ad_to_string.hpp │ │ ├── ad_type.hpp │ │ ├── ad_valued.hpp │ │ ├── add.hpp │ │ ├── add_eq.hpp │ │ ├── arithmetic.hpp │ │ ├── atan2.hpp │ │ ├── atomic/ │ │ │ ├── atomic.xrst │ │ │ ├── four/ │ │ │ │ ├── atomic.hpp │ │ │ │ ├── atomic.xrst │ │ │ │ ├── call.hpp │ │ │ │ ├── ctor.hpp │ │ │ │ ├── devel/ │ │ │ │ │ ├── devel.xrst │ │ │ │ │ ├── hes_sparsity.hpp │ │ │ │ │ └── jac_sparsity.hpp │ │ │ │ ├── for_type.hpp │ │ │ │ ├── forward.hpp │ │ │ │ ├── hes_sparsity.hpp │ │ │ │ ├── jac_sparsity.hpp │ │ │ │ ├── rev_depend.hpp │ │ │ │ └── reverse.hpp │ │ │ ├── one/ │ │ │ │ └── atomic.hpp │ │ │ ├── three/ │ │ │ │ ├── afun.hpp │ │ │ │ ├── atomic.hpp │ │ │ │ ├── atomic.xrst │ │ │ │ ├── ctor.hpp │ │ │ │ ├── for_type.hpp │ │ │ │ ├── forward.hpp │ │ │ │ ├── hes_sparsity.hpp │ │ │ │ ├── jac_sparsity.hpp │ │ │ │ ├── rev_depend.hpp │ │ │ │ └── reverse.hpp │ │ │ └── two/ │ │ │ ├── afun.hpp │ │ │ ├── atomic.hpp │ │ │ ├── clear.hpp │ │ │ ├── ctor.hpp │ │ │ ├── for_sparse_hes.hpp │ │ │ ├── for_sparse_jac.hpp │ │ │ ├── forward.hpp │ │ │ ├── option.hpp │ │ │ ├── rev_depend.hpp │ │ │ ├── rev_sparse_hes.hpp │ │ │ ├── rev_sparse_jac.hpp │ │ │ └── reverse.hpp │ │ ├── azmul.hpp │ │ ├── base2ad.hpp │ │ ├── base_complex.hpp │ │ ├── base_cond_exp.hpp │ │ ├── base_double.hpp │ │ ├── base_float.hpp │ │ ├── base_hash.hpp │ │ ├── base_limits.hpp │ │ ├── base_std_math.hpp │ │ ├── base_to_string.hpp │ │ ├── bender_quad.hpp │ │ ├── bool_fun.hpp │ │ ├── bool_valued.hpp │ │ ├── capacity_order.hpp │ │ ├── check_for_nan.hpp │ │ ├── chkpoint_one/ │ │ │ ├── chkpoint_one.hpp │ │ │ ├── ctor.hpp │ │ │ ├── for_sparse_jac.hpp │ │ │ ├── forward.hpp │ │ │ ├── rev_sparse_hes.hpp │ │ │ ├── rev_sparse_jac.hpp │ │ │ ├── reverse.hpp │ │ │ ├── set_hes_sparse_bool.hpp │ │ │ ├── set_hes_sparse_set.hpp │ │ │ ├── set_jac_sparse_bool.hpp │ │ │ └── set_jac_sparse_set.hpp │ │ ├── chkpoint_two/ │ │ │ ├── chk_fun.xrst │ │ │ ├── chkpoint_two.hpp │ │ │ ├── ctor.hpp │ │ │ ├── dynamic.hpp │ │ │ ├── for_type.hpp │ │ │ ├── forward.hpp │ │ │ ├── hes_sparsity.hpp │ │ │ ├── jac_sparsity.hpp │ │ │ ├── rev_depend.hpp │ │ │ └── reverse.hpp │ │ ├── compare.hpp │ │ ├── compound_assign.hpp │ │ ├── con_dyn_var.hpp │ │ ├── cond_exp.hpp │ │ ├── convert.hpp │ │ ├── cppad_assert.hpp │ │ ├── dependent.hpp │ │ ├── discrete/ │ │ │ ├── devel.xrst │ │ │ ├── discrete.hpp │ │ │ └── user.xrst │ │ ├── div.hpp │ │ ├── div_eq.hpp │ │ ├── drivers.hpp │ │ ├── epsilon.hpp │ │ ├── equal_op_seq.hpp │ │ ├── for_hes_sparsity.hpp │ │ ├── for_jac_sparsity.hpp │ │ ├── for_one.hpp │ │ ├── for_sparse_hes.hpp │ │ ├── for_sparse_jac.hpp │ │ ├── for_two.hpp │ │ ├── forward/ │ │ │ ├── compare_change.xrst │ │ │ ├── devel.xrst │ │ │ ├── forward.hpp │ │ │ ├── forward_dir.xrst │ │ │ ├── forward_one.xrst │ │ │ ├── forward_order.xrst │ │ │ ├── forward_two.xrst │ │ │ ├── forward_zero.xrst │ │ │ └── size_order.xrst │ │ ├── fun_check.hpp │ │ ├── fun_construct.hpp │ │ ├── fun_eval.hpp │ │ ├── fun_property.xrst │ │ ├── function_name.xrst │ │ ├── graph/ │ │ │ ├── cpp_ad_graph.xrst │ │ │ ├── cpp_graph.hpp │ │ │ ├── cpp_graph.xrst │ │ │ ├── from_graph.hpp │ │ │ ├── from_json.hpp │ │ │ ├── graph_op_enum.hpp │ │ │ ├── json_ad_graph.xrst │ │ │ ├── json_graph_op.xrst │ │ │ ├── to_graph.hpp │ │ │ └── to_json.hpp │ │ ├── hash_code.hpp │ │ ├── hessian.hpp │ │ ├── identical.hpp │ │ ├── independent/ │ │ │ ├── devel.xrst │ │ │ ├── independent.hpp │ │ │ └── user.xrst │ │ ├── integer.hpp │ │ ├── jacobian.hpp │ │ ├── lu_ratio.hpp │ │ ├── mul.hpp │ │ ├── mul_eq.hpp │ │ ├── near_equal_ext.hpp │ │ ├── new_dynamic.hpp │ │ ├── num_skip.hpp │ │ ├── numeric_limits.hpp │ │ ├── omp_max_thread.hpp │ │ ├── opt_val_hes.hpp │ │ ├── optimize.hpp │ │ ├── ordered.hpp │ │ ├── parallel_ad.hpp │ │ ├── pow.hpp │ │ ├── print_for.hpp │ │ ├── rev_hes_sparsity.hpp │ │ ├── rev_jac_sparsity.hpp │ │ ├── rev_one.hpp │ │ ├── rev_sparse_hes.hpp │ │ ├── rev_sparse_jac.hpp │ │ ├── rev_two.hpp │ │ ├── reverse.hpp │ │ ├── sign.hpp │ │ ├── sparse.hpp │ │ ├── sparse_hes.hpp │ │ ├── sparse_hessian.hpp │ │ ├── sparse_jac.hpp │ │ ├── sparse_jacobian.hpp │ │ ├── standard_math.hpp │ │ ├── std_math_11.hpp │ │ ├── sub.hpp │ │ ├── sub_eq.hpp │ │ ├── subgraph_jac_rev.hpp │ │ ├── subgraph_reverse.hpp │ │ ├── subgraph_sparsity.hpp │ │ ├── tape_link.hpp │ │ ├── testvector.hpp │ │ ├── to_csrc.hpp │ │ ├── unary_minus.hpp │ │ ├── unary_plus.hpp │ │ ├── undef.hpp │ │ ├── user_ad.hpp │ │ ├── value.hpp │ │ ├── var2par.hpp │ │ ├── vec_ad/ │ │ │ ├── user.xrst │ │ │ └── vec_ad.hpp │ │ └── zdouble.hpp │ ├── cppad.hpp │ ├── example/ │ │ ├── atomic_four/ │ │ │ ├── lin_ode/ │ │ │ │ ├── base_solver.hpp │ │ │ │ ├── for_type.hpp │ │ │ │ ├── forward.hpp │ │ │ │ ├── get.hpp │ │ │ │ ├── hes_sparsity.hpp │ │ │ │ ├── implement.xrst │ │ │ │ ├── jac_sparsity.hpp │ │ │ │ ├── lin_ode.hpp │ │ │ │ ├── lin_ode.xrst │ │ │ │ ├── rev_depend.hpp │ │ │ │ ├── reverse.hpp │ │ │ │ ├── reverse_2.xrst │ │ │ │ └── set.hpp │ │ │ ├── mat_mul/ │ │ │ │ ├── base_mat_mul.hpp │ │ │ │ ├── for_type.hpp │ │ │ │ ├── forward.hpp │ │ │ │ ├── get.hpp │ │ │ │ ├── hes_sparsity.hpp │ │ │ │ ├── implement.xrst │ │ │ │ ├── jac_sparsity.hpp │ │ │ │ ├── mat_mul.hpp │ │ │ │ ├── mat_mul.xrst │ │ │ │ ├── rev_depend.hpp │ │ │ │ ├── reverse.hpp │ │ │ │ └── set.hpp │ │ │ └── vector/ │ │ │ ├── add_op.hpp │ │ │ ├── div_op.hpp │ │ │ ├── for_type.hpp │ │ │ ├── forward_op.hpp │ │ │ ├── hes_sparsity.hpp │ │ │ ├── implement.xrst │ │ │ ├── jac_sparsity.hpp │ │ │ ├── mul_op.hpp │ │ │ ├── neg_op.hpp │ │ │ ├── rev_depend.hpp │ │ │ ├── reverse_op.hpp │ │ │ ├── sub_op.hpp │ │ │ ├── vector.hpp │ │ │ └── vector.xrst │ │ ├── atomic_three/ │ │ │ └── mat_mul.hpp │ │ ├── atomic_two/ │ │ │ ├── eigen_cholesky.hpp │ │ │ ├── eigen_mat_inv.hpp │ │ │ └── eigen_mat_mul.hpp │ │ ├── base_adolc.hpp │ │ ├── code_gen_fun.hpp │ │ ├── cppad_eigen.hpp │ │ ├── eigen_plugin.hpp │ │ └── valvector/ │ │ ├── class.hpp │ │ ├── split_join.hpp │ │ └── sum.hpp │ ├── ipopt/ │ │ ├── solve.hpp │ │ ├── solve_callback.hpp │ │ └── solve_result.hpp │ ├── local/ │ │ ├── ad_tape.hpp │ │ ├── atom_state.hpp │ │ ├── atomic_index.hpp │ │ ├── color_general.hpp │ │ ├── color_symmetric.hpp │ │ ├── cppad_colpack.hpp │ │ ├── declare_ad.hpp │ │ ├── define.hpp │ │ ├── graph/ │ │ │ ├── cpp_graph_itr.hpp │ │ │ ├── cpp_graph_itr.xrst │ │ │ ├── cpp_graph_op.hpp │ │ │ ├── csrc_writer.hpp │ │ │ ├── json_lexer.hpp │ │ │ ├── json_lexer.xrst │ │ │ ├── json_parser.hpp │ │ │ └── json_writer.hpp │ │ ├── hash_code.hpp │ │ ├── independent.hpp │ │ ├── is_pod.hpp │ │ ├── is_pod.hpp.in │ │ ├── op_code_dyn.hpp │ │ ├── op_code_var.hpp │ │ ├── optimize/ │ │ │ ├── cexp_info.hpp │ │ │ ├── csum_op_info.hpp │ │ │ ├── csum_stacks.hpp │ │ │ ├── extract_option.hpp │ │ │ ├── get_cexp_info.hpp │ │ │ ├── get_dyn_previous.hpp │ │ │ ├── get_op_previous.hpp │ │ │ ├── get_op_usage.hpp │ │ │ ├── get_par_usage.hpp │ │ │ ├── hash_code.hpp │ │ │ ├── match_op.hpp │ │ │ ├── optimize_run.hpp │ │ │ ├── record_csum.hpp │ │ │ ├── record_pv.hpp │ │ │ ├── record_vp.hpp │ │ │ ├── record_vv.hpp │ │ │ ├── size_pair.hpp │ │ │ └── usage.hpp │ │ ├── play/ │ │ │ ├── addr_enum.hpp │ │ │ ├── atom_op_info.hpp │ │ │ ├── dyn_player.hpp │ │ │ ├── player.hpp │ │ │ ├── random_iterator.hpp │ │ │ ├── random_setup.hpp │ │ │ ├── sequential_iterator.hpp │ │ │ └── subgraph_iterator.hpp │ │ ├── pod_vector.hpp │ │ ├── record/ │ │ │ ├── comp_op.hpp │ │ │ ├── cond_exp.hpp │ │ │ ├── dyn_recorder.hpp │ │ │ ├── put_dyn_atomic.hpp │ │ │ ├── put_var_atomic.hpp │ │ │ ├── put_var_vecad.hpp │ │ │ └── recorder.hpp │ │ ├── set_get_in_parallel.hpp │ │ ├── sparse/ │ │ │ ├── dev_sparse.xrst │ │ │ ├── internal.hpp │ │ │ ├── list_setvec.hpp │ │ │ ├── pack_setvec.hpp │ │ │ ├── pack_setvec.xrst │ │ │ ├── setvector.xrst │ │ │ ├── size_setvec.hpp │ │ │ └── svec_setvec.hpp │ │ ├── std_set.hpp │ │ ├── subgraph/ │ │ │ ├── arg_variable.hpp │ │ │ ├── entire_call.hpp │ │ │ ├── get_rev.hpp │ │ │ ├── info.hpp │ │ │ ├── init_rev.hpp │ │ │ └── sparsity.hpp │ │ ├── sweep/ │ │ │ ├── call_atomic.hpp │ │ │ ├── dev_sweep.xrst │ │ │ ├── dynamic.hpp │ │ │ ├── for_hes.hpp │ │ │ ├── for_jac.hpp │ │ │ ├── forward_0.hpp │ │ │ ├── forward_any.hpp │ │ │ ├── forward_dir.hpp │ │ │ ├── rev_hes.hpp │ │ │ ├── rev_jac.hpp │ │ │ ├── reverse.hpp │ │ │ └── template/ │ │ │ └── forward_sweep.xrst │ │ ├── temp_file.hpp │ │ ├── utility/ │ │ │ ├── cppad_vector_itr.hpp │ │ │ └── vector_bool.hpp │ │ ├── val_graph/ │ │ │ ├── base_op.hpp │ │ │ ├── binary_op.hpp │ │ │ ├── call_atomic.hpp │ │ │ ├── call_op.hpp │ │ │ ├── cexp_op.hpp │ │ │ ├── comp_op.hpp │ │ │ ├── compress.hpp │ │ │ ├── con_op.hpp │ │ │ ├── csum_op.hpp │ │ │ ├── cumulative.hpp │ │ │ ├── dead_code.hpp │ │ │ ├── dis_op.hpp │ │ │ ├── dyn_type.hpp │ │ │ ├── enable_parallel.hpp │ │ │ ├── fold_con.hpp │ │ │ ├── fun2val.hpp │ │ │ ├── op2arg_index.hpp │ │ │ ├── op_enum2class.hpp │ │ │ ├── op_hash_table.hpp │ │ │ ├── op_iterator.hpp │ │ │ ├── option.hpp │ │ │ ├── pri_op.hpp │ │ │ ├── print_op.hpp │ │ │ ├── record.hpp │ │ │ ├── record_new.hpp │ │ │ ├── renumber.hpp │ │ │ ├── rev_depend.hpp │ │ │ ├── summation.hpp │ │ │ ├── tape.hpp │ │ │ ├── unary_op.hpp │ │ │ ├── val2fun.hpp │ │ │ ├── val_graph.xrst │ │ │ ├── val_optimize.hpp │ │ │ ├── val_type.hpp │ │ │ ├── var_type.hpp │ │ │ └── vector_op.hpp │ │ └── var_op/ │ │ ├── abs_op.hpp │ │ ├── acos_op.hpp │ │ ├── acosh_op.hpp │ │ ├── add_op.hpp │ │ ├── asin_op.hpp │ │ ├── asinh_op.hpp │ │ ├── atan_op.hpp │ │ ├── atanh_op.hpp │ │ ├── atomic_op.hpp │ │ ├── binary_op.xrst │ │ ├── cexp_op.hpp │ │ ├── compare_op.hpp │ │ ├── cos_op.hpp │ │ ├── cosh_op.hpp │ │ ├── cskip_op.hpp │ │ ├── csum_op.hpp │ │ ├── dis_op.hpp │ │ ├── div_op.hpp │ │ ├── erf_op.hpp │ │ ├── exp_op.hpp │ │ ├── expm1_op.hpp │ │ ├── load_op.hpp │ │ ├── log1p_op.hpp │ │ ├── log_op.hpp │ │ ├── mul_op.hpp │ │ ├── neg_op.hpp │ │ ├── one_var.hpp │ │ ├── par_op.hpp │ │ ├── pow_op.hpp │ │ ├── pri_op.hpp │ │ ├── prototype_op.hpp │ │ ├── sign_op.hpp │ │ ├── sin_op.hpp │ │ ├── sinh_op.hpp │ │ ├── sqrt_op.hpp │ │ ├── store_op.hpp │ │ ├── sub_op.hpp │ │ ├── tan_op.hpp │ │ ├── tanh_op.hpp │ │ ├── template/ │ │ │ ├── atomic_op.xrst │ │ │ ├── forward_dir.xrst │ │ │ ├── forward_op.xrst │ │ │ └── reverse_op.xrst │ │ ├── two_var.hpp │ │ ├── unary_op.xrst │ │ ├── var_op.hpp │ │ └── zmul_op.hpp │ ├── speed/ │ │ ├── det_33.hpp │ │ ├── det_by_lu.hpp │ │ ├── det_by_minor.hpp │ │ ├── det_grad_33.hpp │ │ ├── det_of_minor.hpp │ │ ├── mat_sum_sq.hpp │ │ ├── ode_evaluate.hpp │ │ ├── sparse_hes_fun.hpp │ │ ├── sparse_jac_fun.hpp │ │ └── uniform_01.hpp │ ├── utility/ │ │ ├── check_numeric_type.hpp │ │ ├── check_simple_vector.hpp │ │ ├── create_dll_lib.hpp │ │ ├── elapsed_seconds.hpp │ │ ├── error_handler.hpp │ │ ├── index_sort.hpp │ │ ├── link_dll_lib.hpp │ │ ├── lu_factor.hpp │ │ ├── lu_invert.hpp │ │ ├── lu_solve.hpp │ │ ├── memory_leak.hpp │ │ ├── nan.hpp │ │ ├── near_equal.hpp │ │ ├── ode_err_control.hpp │ │ ├── ode_gear.hpp │ │ ├── ode_gear_control.hpp │ │ ├── omp_alloc.hpp │ │ ├── poly.hpp │ │ ├── pow_int.hpp │ │ ├── romberg_mul.hpp │ │ ├── romberg_one.hpp │ │ ├── rosen_34.hpp │ │ ├── runge_45.hpp │ │ ├── set_union.hpp │ │ ├── sparse2eigen.hpp │ │ ├── sparse_rc.hpp │ │ ├── sparse_rcv.hpp │ │ ├── speed_test.hpp │ │ ├── test_boolofvoid.hpp │ │ ├── thread_alloc.hpp │ │ ├── time_test.hpp │ │ ├── to_string.hpp │ │ ├── track_new_del.hpp │ │ ├── vector.hpp │ │ ├── vector_bool.hpp │ │ └── xrst/ │ │ ├── cppad_vector.xrst │ │ ├── dev_cppad_vector.xrst │ │ ├── dev_utility.xrst │ │ ├── dev_vector_bool.xrst │ │ └── utility.xrst │ ├── utility.hpp │ └── wno_conversion.hpp ├── introduction/ │ ├── CMakeLists.txt │ ├── exp_2.cpp │ ├── exp_2.hpp │ ├── exp_2.xrst │ ├── exp_2_cppad.cpp │ ├── exp_2_for0.cpp │ ├── exp_2_for1.cpp │ ├── exp_2_for2.cpp │ ├── exp_2_rev1.cpp │ ├── exp_2_rev2.cpp │ ├── exp_eps.cpp │ ├── exp_eps.hpp │ ├── exp_eps.xrst │ ├── exp_eps_cppad.cpp │ ├── exp_eps_for0.cpp │ ├── exp_eps_for1.cpp │ ├── exp_eps_for2.cpp │ ├── exp_eps_rev1.cpp │ ├── exp_eps_rev2.cpp │ └── introduction.cpp ├── pkgconfig/ │ ├── CMakeLists.txt │ ├── cppad-uninstalled.pc.in │ └── cppad.pc.in ├── readme.md ├── speed/ │ ├── CMakeLists.txt │ ├── add_test.sh │ ├── adolc/ │ │ ├── CMakeLists.txt │ │ ├── adolc_alloc_mat.hpp │ │ ├── adolc_usrparms.sh │ │ ├── alloc_mat.cpp │ │ ├── det_lu.cpp │ │ ├── det_minor.cpp │ │ ├── mat_mul.cpp │ │ ├── ode.cpp │ │ ├── poly.cpp │ │ ├── sparse_hessian.cpp │ │ ├── sparse_jacobian.cpp │ │ └── speed_adolc.xrst │ ├── cppad/ │ │ ├── CMakeLists.txt │ │ ├── det_lu.cpp │ │ ├── det_minor.cpp │ │ ├── mat_mul.cpp │ │ ├── ode.cpp │ │ ├── poly.cpp │ │ ├── sparse_hessian.cpp │ │ ├── sparse_jacobian.cpp │ │ └── speed_cppad.xrst │ ├── cppad_jit/ │ │ ├── CMakeLists.txt │ │ ├── det_lu.cpp │ │ ├── det_minor.cpp │ │ ├── mat_mul.cpp │ │ ├── ode.cpp │ │ ├── poly.cpp │ │ ├── sparse_hessian.cpp │ │ ├── sparse_jacobian.cpp │ │ └── speed_cppad_jit.xrst │ ├── cppadcg/ │ │ ├── CMakeLists.txt │ │ ├── det_lu.cpp │ │ ├── det_minor.cpp │ │ ├── mat_mul.cpp │ │ ├── ode.cpp │ │ ├── poly.cpp │ │ ├── sparse_hessian.cpp │ │ ├── sparse_jacobian.cpp │ │ └── speed_cppadcg.xrst │ ├── dev_speed.xrst │ ├── double/ │ │ ├── CMakeLists.txt │ │ ├── det_lu.cpp │ │ ├── det_minor.cpp │ │ ├── mat_mul.cpp │ │ ├── ode.cpp │ │ ├── poly.cpp │ │ ├── sparse_hessian.cpp │ │ ├── sparse_jacobian.cpp │ │ └── speed_double.xrst │ ├── example/ │ │ ├── CMakeLists.txt │ │ ├── det_by_lu.cpp │ │ ├── det_by_minor.cpp │ │ ├── det_of_minor.cpp │ │ ├── elapsed_seconds.cpp │ │ ├── example.cpp │ │ ├── mat_sum_sq.cpp │ │ ├── ode_evaluate.cpp │ │ ├── sparse_hes_fun.cpp │ │ ├── sparse_jac_fun.cpp │ │ ├── speed_program.cpp │ │ ├── speed_test.cpp │ │ └── time_test.cpp │ ├── fadbad/ │ │ ├── CMakeLists.txt │ │ ├── det_lu.cpp │ │ ├── det_minor.cpp │ │ ├── mat_mul.cpp │ │ ├── ode.cpp │ │ ├── poly.cpp │ │ ├── sparse_hessian.cpp │ │ ├── sparse_jacobian.cpp │ │ └── speed_fadbad.xrst │ ├── main.cpp │ ├── profile/ │ │ ├── CMakeLists.txt │ │ └── gprof.sed.in │ ├── sacado/ │ │ ├── CMakeLists.txt │ │ ├── det_lu.cpp │ │ ├── det_minor.cpp │ │ ├── mat_mul.cpp │ │ ├── ode.cpp │ │ ├── poly.cpp │ │ ├── sparse_hessian.cpp │ │ ├── sparse_jacobian.cpp │ │ └── speed_sacado.xrst │ ├── speed.xrst │ ├── speed_utility.xrst │ ├── src/ │ │ ├── CMakeLists.txt │ │ ├── dev_link.xrst │ │ ├── dev_sparse_hessian.xrst │ │ ├── link.xrst │ │ ├── link_det_lu.cpp │ │ ├── link_det_minor.cpp │ │ ├── link_mat_mul.cpp │ │ ├── link_ode.cpp │ │ ├── link_poly.cpp │ │ ├── link_sparse_hessian.cpp │ │ ├── link_sparse_hessian.hpp │ │ ├── link_sparse_jacobian.cpp │ │ └── link_sparse_jacobian.hpp │ └── xpackage/ │ ├── CMakeLists.txt │ ├── det_lu.cpp │ ├── det_minor.cpp │ ├── mat_mul.cpp │ ├── ode.cpp │ ├── poly.cpp │ ├── sparse_hessian.cpp │ ├── sparse_jacobian.cpp │ └── speed_xpackage.xrst ├── test_more/ │ ├── CMakeLists.txt │ ├── compare_c/ │ │ ├── CMakeLists.txt │ │ ├── c/ │ │ │ └── CMakeLists.txt │ │ ├── cpp/ │ │ │ └── CMakeLists.txt │ │ └── det_by_minor.c │ ├── cppad_for_tmb/ │ │ ├── CMakeLists.txt │ │ ├── cppad_for_tmb.cpp │ │ ├── implicit_ctor.cpp │ │ ├── multi_atomic_three.cpp │ │ ├── multi_atomic_two.cpp │ │ ├── multi_chkpoint_one.cpp │ │ ├── multi_chkpoint_two.cpp │ │ └── prefer_reverse.cpp │ ├── debug_rel/ │ │ ├── CMakeLists.txt │ │ ├── debug.cpp │ │ ├── debug_rel.cpp │ │ └── release.cpp │ ├── deprecated/ │ │ ├── CMakeLists.txt │ │ ├── atomic_two/ │ │ │ ├── CMakeLists.txt │ │ │ ├── atomic_sparsity.cpp │ │ │ ├── atomic_two.cpp │ │ │ ├── base2ad.cpp │ │ │ ├── for_sparse_hes.cpp │ │ │ ├── for_sparse_jac.cpp │ │ │ ├── forward.cpp │ │ │ ├── get_started.cpp │ │ │ ├── mat_mul.cpp │ │ │ ├── mat_mul.hpp │ │ │ ├── norm_sq.cpp │ │ │ ├── reciprocal.cpp │ │ │ ├── rev_sparse_hes.cpp │ │ │ ├── rev_sparse_jac.cpp │ │ │ ├── reverse.cpp │ │ │ ├── set_sparsity.cpp │ │ │ └── tangent.cpp │ │ ├── chkpoint_one/ │ │ │ ├── CMakeLists.txt │ │ │ ├── chkpoint_one.cpp │ │ │ ├── extended_ode.cpp │ │ │ ├── get_started.cpp │ │ │ ├── mul_level.cpp │ │ │ └── ode.cpp │ │ ├── deprecated.cpp │ │ ├── old_mat_mul.cpp │ │ ├── old_mat_mul.hpp │ │ ├── old_reciprocal.cpp │ │ ├── old_tan.cpp │ │ ├── old_usead_1.cpp │ │ ├── old_usead_2.cpp │ │ ├── omp_alloc.cpp │ │ ├── track_new_del.cpp │ │ └── zdouble.cpp │ └── general/ │ ├── CMakeLists.txt │ ├── abs_normal.cpp │ ├── acos.cpp │ ├── acosh.cpp │ ├── add.cpp │ ├── add_eq.cpp │ ├── add_zero.cpp │ ├── adfun.cpp │ ├── alloc_openmp.cpp │ ├── asin.cpp │ ├── asinh.cpp │ ├── assign.cpp │ ├── atan.cpp │ ├── atan2.cpp │ ├── atanh.cpp │ ├── atomic_four.cpp │ ├── atomic_three.cpp │ ├── azmul.cpp │ ├── base2ad.cpp │ ├── base_adolc.cpp │ ├── base_alloc.cpp │ ├── base_complex.cpp │ ├── bool_sparsity.cpp │ ├── check_simple_vector.cpp │ ├── chkpoint_one.cpp │ ├── chkpoint_two.cpp │ ├── compare.cpp │ ├── compare_change.cpp │ ├── cond_exp.cpp │ ├── cond_exp_ad.cpp │ ├── cond_exp_rev.cpp │ ├── copy.cpp │ ├── cos.cpp │ ├── cosh.cpp │ ├── cpp_graph.cpp │ ├── cppad_eigen.cpp │ ├── cppad_vector.cpp │ ├── dbl_epsilon.cpp │ ├── dependency.cpp │ ├── div.cpp │ ├── div_eq.cpp │ ├── div_zero_one.cpp │ ├── eigen_mat_inv.cpp │ ├── erf.cpp │ ├── exp.cpp │ ├── expm1.cpp │ ├── extern_value.cpp │ ├── extern_value.hpp │ ├── fabs.cpp │ ├── for_hes_sparsity.cpp │ ├── for_hess.cpp │ ├── for_jac_sparsity.cpp │ ├── forward.cpp │ ├── forward_dir.cpp │ ├── forward_order.cpp │ ├── from_base.cpp │ ├── fun_check.cpp │ ├── general.cpp │ ├── hes_sparsity.cpp │ ├── ipopt_solve.cpp │ ├── jacobian.cpp │ ├── json_graph.cpp │ ├── local/ │ │ ├── is_pod.cpp │ │ ├── json_lexer.cpp │ │ ├── json_parser.cpp │ │ ├── temp_file.cpp │ │ └── vector_set.cpp │ ├── log.cpp │ ├── log10.cpp │ ├── log1p.cpp │ ├── mul.cpp │ ├── mul_cond_rev.cpp │ ├── mul_cskip.cpp │ ├── mul_eq.cpp │ ├── mul_level.cpp │ ├── mul_zdouble.cpp │ ├── mul_zero_one.cpp │ ├── near_equal_ext.cpp │ ├── neg.cpp │ ├── new_dynamic.cpp │ ├── num_limits.cpp │ ├── ode_err_control.cpp │ ├── optimize.cpp │ ├── parameter.cpp │ ├── poly.cpp │ ├── pow.cpp │ ├── pow_int.cpp │ ├── print_for.cpp │ ├── rev_sparse_jac.cpp │ ├── rev_two.cpp │ ├── reverse.cpp │ ├── romberg_one.cpp │ ├── rosen_34.cpp │ ├── runge_45.cpp │ ├── simple_vector.cpp │ ├── sin.cpp │ ├── sin_cos.cpp │ ├── sinh.cpp │ ├── sparse_hessian.cpp │ ├── sparse_jac_work.cpp │ ├── sparse_jacobian.cpp │ ├── sparse_sub_hes.cpp │ ├── sparse_vec_ad.cpp │ ├── sqrt.cpp │ ├── std_math.cpp │ ├── sub.cpp │ ├── sub_eq.cpp │ ├── sub_zero.cpp │ ├── subgraph_1.cpp │ ├── subgraph_2.cpp │ ├── subgraph_hes2jac.cpp │ ├── tan.cpp │ ├── to_csrc.cpp │ ├── to_string.cpp │ ├── value.cpp │ ├── vec_ad.cpp │ ├── vec_ad_par.cpp │ └── vec_unary.cpp ├── typos.toml ├── user_guide.xrst ├── uw_copy_040507.html ├── val_graph/ │ ├── CMakeLists.txt │ ├── atomic_xam.hpp │ ├── binary_xam.cpp │ ├── call_xam.cpp │ ├── cexp_xam.cpp │ ├── comp_xam.cpp │ ├── compress_xam.cpp │ ├── con_xam.cpp │ ├── csum_xam.cpp │ ├── cumulative_xam.cpp │ ├── dead_xam.cpp │ ├── dis_xam.cpp │ ├── fold_con_xam.cpp │ ├── fun2val_xam.cpp │ ├── pri_xam.cpp │ ├── renumber_xam.cpp │ ├── summation_xam.cpp │ ├── test/ │ │ ├── ad_double.cpp │ │ ├── fold.cpp │ │ ├── fun2val.cpp │ │ ├── nan.cpp │ │ ├── opt_call.cpp │ │ ├── optimize.cpp │ │ ├── val2fun.cpp │ │ └── val_optimize.cpp │ ├── unary_xam.cpp │ ├── val2fun_xam.cpp │ ├── val_graph.cpp │ └── vec_xam.cpp ├── xrst/ │ ├── base_require/ │ │ ├── base_example.xrst │ │ ├── base_identical.xrst │ │ ├── base_member.xrst │ │ └── base_ordered.xrst │ ├── det_33_hpp.xrst │ ├── det_by_lu_hpp.xrst │ ├── det_by_minor_hpp.xrst │ ├── det_grad_33_hpp.xrst │ ├── det_of_minor_hpp.xrst │ ├── devel/ │ │ ├── devel.xrst │ │ ├── dynamic.xrst │ │ └── whats_new/ │ │ └── 2024.xrst │ ├── example.xrst │ ├── example_list.xrst │ ├── install/ │ │ ├── adolc.xrst │ │ ├── cmake.xrst │ │ ├── cmake_check.xrst │ │ ├── colpack_prefix.xrst │ │ ├── cppadcg.xrst │ │ ├── download.xrst │ │ ├── eigen.xrst │ │ ├── fadbad_prefix.xrst │ │ ├── install.xrst │ │ ├── ipopt.xrst │ │ ├── sacado_prefix.xrst │ │ └── testvector.xrst │ ├── introduction.xrst │ ├── lu_det_and_solve.xrst │ ├── lu_factor_hpp.xrst │ ├── lu_invert_hpp.xrst │ ├── lu_solve_hpp.xrst │ ├── mat_sum_sq_hpp.xrst │ ├── mul_level.xrst │ ├── multi_thread.xrst │ ├── numeric_type.xrst │ ├── ode_evaluate.xrst │ ├── poly_hpp.xrst │ ├── preprocessor.xrst │ ├── reverse/ │ │ ├── reverse_any.xrst │ │ ├── reverse_one.xrst │ │ └── reverse_two.xrst │ ├── simple_vector.xrst │ ├── sparse_hes_fun.xrst │ ├── sparse_jac_fun.xrst │ ├── theory/ │ │ ├── acos_forward.xrst │ │ ├── acos_reverse.xrst │ │ ├── asin_forward.xrst │ │ ├── asin_reverse.xrst │ │ ├── atan_forward.xrst │ │ ├── atan_reverse.xrst │ │ ├── cholesky.xrst │ │ ├── erf_forward.xrst │ │ ├── erf_reverse.xrst │ │ ├── exp_forward.xrst │ │ ├── exp_reverse.xrst │ │ ├── forward_theory.xrst │ │ ├── log_forward.xrst │ │ ├── log_reverse.xrst │ │ ├── pow_forward.xrst │ │ ├── pow_reverse.xrst │ │ ├── research.xrst │ │ ├── reverse_identity.xrst │ │ ├── reverse_theory.xrst │ │ ├── sin_cos_forward.xrst │ │ ├── sin_cos_reverse.xrst │ │ ├── sqrt_forward.xrst │ │ ├── sqrt_reverse.xrst │ │ ├── tan_forward.xrst │ │ ├── tan_reverse.xrst │ │ ├── taylor_ode.xrst │ │ └── theory.xrst │ ├── thread_alloc.xrst │ └── uniform_01_hpp.xrst └── xrst.toml
Showing preview only (426K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4297 symbols across 1047 files)
FILE: bin/check_user_def.py
function main (line 16) | def main() :
FILE: cppad_ipopt/example/example.cpp
function main (line 24) | int main(void)
FILE: cppad_ipopt/example/get_started.cpp
class FG_info (line 53) | class FG_info : public cppad_ipopt_fg_info
method FG_info (line 59) | FG_info(bool retape_in)
method ADVector (line 64) | ADVector eval_r(size_t k, const ADVector& x)
method retape (line 80) | bool retape(size_t k)
function ipopt_get_started (line 85) | bool ipopt_get_started(void)
FILE: cppad_ipopt/example/ode_check.cpp
function ode_check (line 21) | bool ode_check(const SizeVector& N, const NumberVector& x)
FILE: cppad_ipopt/example/ode_fast.hpp
class FG_fast (line 27) | class FG_fast : public cppad_ipopt_fg_info
method FG_fast (line 35) | FG_fast(bool retape_in, const SizeVector& N)
method number_functions (line 46) | size_t number_functions(void)
method ADVector (line 48) | ADVector eval_r(size_t k, const ADVector &u)
method retape (line 100) | bool retape(size_t k)
method domain_size (line 103) | size_t domain_size(size_t k)
method range_size (line 111) | size_t range_size(size_t k)
method number_terms (line 117) | size_t number_terms(size_t k)
method index (line 123) | void index(size_t k, size_t ell, SizeVector& I, SizeVector& J)
FILE: cppad_ipopt/example/ode_fast_check.cpp
function ode_fast_check (line 9) | bool ode_fast_check(void)
FILE: cppad_ipopt/example/ode_problem.hpp
function Number (line 32) | Number y_one(Number t)
function Vector (line 51) | Vector eval_F(const Vector &a)
function Vector (line 63) | Vector eval_G(const Vector &y , const Vector &a)
function Scalar (line 75) | Scalar eval_H(size_t i, const Vector &y, const Vector &a)
function count_eval_r (line 81) | size_t count_eval_r(void)
FILE: cppad_ipopt/example/ode_run.hpp
function ipopt_ode_case (line 29) | void ipopt_ode_case(
FILE: cppad_ipopt/example/ode_simple.hpp
class FG_simple (line 28) | class FG_simple : public cppad_ipopt_fg_info
method FG_simple (line 36) | FG_simple(bool retape_in, const SizeVector& N)
method ADVector (line 46) | ADVector eval_r(size_t not_used, const ADVector& x)
method retape (line 110) | bool retape(size_t k)
FILE: cppad_ipopt/example/ode_simple_check.cpp
function ode_simple_check (line 9) | bool ode_simple_check(void)
FILE: cppad_ipopt/speed/ode_speed.cpp
function current_second (line 33) | double current_second(void)
function ode_speed (line 45) | double ode_speed(const char* name, size_t& count)
FILE: cppad_ipopt/speed/speed.cpp
function main (line 13) | int main(void)
FILE: cppad_ipopt/src/cppad_ipopt_nlp.cpp
type cppad_ipopt (line 23) | namespace cppad_ipopt {
FILE: cppad_ipopt/src/cppad_ipopt_nlp.hpp
type cppad_ipopt (line 576) | namespace cppad_ipopt {
class cppad_ipopt_fg_info (line 591) | class cppad_ipopt_fg_info
method set_n (line 601) | void set_n(size_t n)
method set_m (line 604) | void set_m(size_t m)
method number_functions (line 612) | virtual size_t number_functions(void)
method retape (line 619) | virtual bool retape(size_t k)
method domain_size (line 622) | virtual size_t domain_size(size_t k)
method range_size (line 625) | virtual size_t range_size(size_t k)
method number_terms (line 628) | virtual size_t number_terms(size_t k)
method index (line 632) | virtual void index(size_t k, size_t ell, SizeVector& I, SizeVector& J)
class cppad_ipopt_solution (line 687) | class cppad_ipopt_solution
type solution_status (line 691) | enum solution_status {
method cppad_ipopt_solution (line 721) | cppad_ipopt_solution(void)
class cppad_ipopt_nlp (line 728) | class cppad_ipopt_nlp : public Ipopt::TNLP
FILE: cppad_ipopt/src/fun_record.hpp
type cppad_ipopt (line 10) | namespace cppad_ipopt {
function fun_record (line 73) | void fun_record(
FILE: cppad_ipopt/src/hes_fg_map.cpp
type cppad_ipopt (line 9) | namespace cppad_ipopt {
function hes_fg_map (line 110) | void hes_fg_map(
FILE: cppad_ipopt/src/hes_fg_map.hpp
type cppad_ipopt (line 15) | namespace cppad_ipopt {
FILE: cppad_ipopt/src/jac_g_map.cpp
type cppad_ipopt (line 8) | namespace cppad_ipopt {
function jac_g_map (line 102) | void jac_g_map(
FILE: cppad_ipopt/src/jac_g_map.hpp
type cppad_ipopt (line 15) | namespace cppad_ipopt {
FILE: cppad_ipopt/src/sparse_map2vec.cpp
type cppad_ipopt (line 9) | namespace cppad_ipopt {
function sparse_map2vec (line 50) | void sparse_map2vec(
FILE: cppad_ipopt/src/sparse_map2vec.hpp
type cppad_ipopt (line 8) | namespace cppad_ipopt {
FILE: cppad_ipopt/src/vec_fun_pattern.cpp
type cppad_ipopt (line 8) | namespace cppad_ipopt {
function vec_fun_pattern (line 77) | void vec_fun_pattern(
FILE: cppad_ipopt/src/vec_fun_pattern.hpp
type cppad_ipopt (line 9) | namespace cppad_ipopt {
FILE: cppad_ipopt/test/k_gt_one.cpp
class FG_K_gt_one (line 17) | class FG_K_gt_one : public cppad_ipopt_fg_info
method FG_K_gt_one (line 23) | FG_K_gt_one(bool retape_in)
method ADVector (line 28) | ADVector eval_r(size_t k, const ADVector& u)
method retape (line 49) | bool retape(size_t k)
method number_functions (line 51) | size_t number_functions(void)
method domain_size (line 53) | size_t domain_size(size_t k)
method range_size (line 55) | size_t range_size(size_t k)
method number_terms (line 60) | size_t number_terms(size_t k)
method index (line 62) | void index(size_t k, size_t ell, SizeVector& I, SizeVector& J)
function k_gt_one (line 77) | bool k_gt_one(void)
FILE: cppad_ipopt/test/multiple_solution.cpp
class FG_J_changes (line 24) | class FG_J_changes : public cppad_ipopt_fg_info
method FG_J_changes (line 30) | FG_J_changes(bool retape_in)
method number_functions (line 33) | size_t number_functions(void)
method domain_size (line 35) | size_t domain_size(size_t k)
method range_size (line 40) | size_t range_size(size_t k)
method number_terms (line 45) | size_t number_terms(size_t k)
method index (line 50) | void index(size_t k, size_t ell, SizeVector&I, SizeVector& J)
method retape (line 62) | bool retape(size_t k)
method ADVector (line 64) | ADVector eval_r(size_t k, const ADVector& u)
function multiple_solution (line 74) | bool multiple_solution(void)
FILE: cppad_ipopt/test/retape_k1_l1.cpp
class FG_retape (line 12) | class FG_retape : public cppad_ipopt_fg_info
method FG_retape (line 16) | FG_retape(void)
method ADVector (line 20) | ADVector eval_r(size_t k, const ADVector& x)
method retape (line 33) | bool retape(size_t k)
function retape_k1_l1 (line 38) | bool retape_k1_l1(void)
FILE: cppad_ipopt/test/retape_k1_l2.cpp
class FG_info (line 15) | class FG_info : public cppad_ipopt_fg_info
method FG_info (line 19) | FG_info (void)
method ADVector (line 22) | ADVector eval_r(size_t k, const ADVector& u)
method retape (line 31) | bool retape(size_t k)
method number_functions (line 34) | size_t number_functions(void)
method domain_size (line 37) | size_t domain_size(size_t k)
method range_size (line 40) | size_t range_size(size_t k)
method number_terms (line 43) | size_t number_terms(size_t k)
method index (line 47) | void index(size_t k, size_t ell, SizeVector& I, SizeVector& J)
function retape_k1_l2 (line 54) | bool retape_k1_l2(void)
FILE: cppad_ipopt/test/test_more.cpp
function main (line 25) | int main(void)
FILE: cppad_lib/cpp_graph_op.cpp
type CppAD (line 12) | namespace CppAD { namespace local { namespace graph {
type local (line 12) | namespace local { namespace graph {
type graph (line 12) | namespace graph {
function set_operator_info (line 25) | void set_operator_info(void)
FILE: cppad_lib/cppad_colpack.cpp
type CppAD (line 12) | namespace CppAD { namespace local {
type local (line 12) | namespace local {
function this_routine_should_never_get_called (line 13) | void this_routine_should_never_get_called(void)
function cppad_colpack_general (line 48) | void cppad_colpack_general(
function cppad_colpack_symmetric (line 160) | void cppad_colpack_symmetric(
type local (line 19) | namespace local { // BEGIN_CPPAD_LOCAL_NAMESPACE
function this_routine_should_never_get_called (line 13) | void this_routine_should_never_get_called(void)
function cppad_colpack_general (line 48) | void cppad_colpack_general(
function cppad_colpack_symmetric (line 160) | void cppad_colpack_symmetric(
type CppAD (line 19) | namespace CppAD { namespace local { // BEGIN_CPPAD_LOCAL_NAMESPACE
type local (line 12) | namespace local {
function this_routine_should_never_get_called (line 13) | void this_routine_should_never_get_called(void)
function cppad_colpack_general (line 48) | void cppad_colpack_general(
function cppad_colpack_symmetric (line 160) | void cppad_colpack_symmetric(
type local (line 19) | namespace local { // BEGIN_CPPAD_LOCAL_NAMESPACE
function this_routine_should_never_get_called (line 13) | void this_routine_should_never_get_called(void)
function cppad_colpack_general (line 48) | void cppad_colpack_general(
function cppad_colpack_symmetric (line 160) | void cppad_colpack_symmetric(
FILE: cppad_lib/csrc_writer.cpp
function element (line 56) | std::string element(const std::string& array_name, size_t array_index)
function binary_function (line 60) | void binary_function(
function binary_operator (line 73) | void binary_operator(
function compare_operator (line 85) | void compare_operator(
function unary_function (line 96) | void unary_function(
function sum_operator (line 107) | void sum_operator(
function atomic_function (line 132) | void atomic_function(
function discrete_function (line 164) | void discrete_function(
FILE: cppad_lib/json_lexer.cpp
type CppAD (line 14) | namespace CppAD { namespace local { namespace graph {
type local (line 14) | namespace local { namespace graph {
type graph (line 14) | namespace graph {
FILE: cppad_lib/link_dll_lib.cpp
type CppAD (line 20) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: cppad_lib/temp_file.cpp
type CppAD (line 58) | namespace CppAD { namespace local { // BEGIN_CPPAD_LOCAL_NAMESPACE
type local (line 58) | namespace local { // BEGIN_CPPAD_LOCAL_NAMESPACE
FILE: example/abs_normal/abs_eval.cpp
function join (line 40) | join(
function abs_eval (line 53) | bool abs_eval(void)
FILE: example/abs_normal/abs_eval.hpp
type CppAD (line 103) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function Vector (line 106) | Vector abs_eval(
FILE: example/abs_normal/abs_min_linear.cpp
function join (line 55) | join(
function abs_min_linear (line 68) | bool abs_min_linear(void)
FILE: example/abs_normal/abs_min_linear.hpp
type CppAD (line 211) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function abs_min_linear (line 215) | bool abs_min_linear(
FILE: example/abs_normal/abs_min_quad.cpp
function join (line 45) | join(
function abs_min_quad (line 58) | bool abs_min_quad(void)
FILE: example/abs_normal/abs_min_quad.hpp
type CppAD (line 217) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function abs_min_quad (line 221) | bool abs_min_quad(
FILE: example/abs_normal/abs_normal.cpp
function main (line 55) | int main(void)
FILE: example/abs_normal/abs_print_mat.hpp
type CppAD (line 63) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function abs_print_mat (line 67) | void abs_print_mat(
FILE: example/abs_normal/get_started.cpp
function join (line 52) | join(
function get_started (line 65) | bool get_started(void)
FILE: example/abs_normal/lp_box.cpp
function lp_box (line 39) | bool lp_box(void)
FILE: example/abs_normal/lp_box.hpp
type CppAD (line 120) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function lp_box (line 124) | bool lp_box(
FILE: example/abs_normal/min_nso_linear.cpp
function min_nso_linear (line 46) | bool min_nso_linear(void)
FILE: example/abs_normal/min_nso_linear.hpp
function min_nso_linear_join (line 164) | min_nso_linear_join(
type CppAD (line 178) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function min_nso_linear (line 182) | bool min_nso_linear(
FILE: example/abs_normal/min_nso_quad.cpp
function min_nso_quad (line 46) | bool min_nso_quad(void)
FILE: example/abs_normal/min_nso_quad.hpp
function min_nso_quad_join (line 161) | min_nso_quad_join(
type CppAD (line 175) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function min_nso_quad (line 179) | bool min_nso_quad(
FILE: example/abs_normal/qp_box.cpp
function qp_box (line 39) | bool qp_box(void)
FILE: example/abs_normal/qp_box.hpp
type CppAD (line 204) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function qp_box (line 208) | bool qp_box(
FILE: example/abs_normal/qp_interior.cpp
function qp_interior (line 65) | bool qp_interior(void)
FILE: example/abs_normal/qp_interior.hpp
function qp_interior_max_abs (line 324) | double qp_interior_max_abs(const Vector& v)
function qp_interior_split (line 332) | void qp_interior_split(
function qp_interior_join (line 349) | void qp_interior_join(
function Vector (line 366) | Vector qp_interior_F_0(
type CppAD (line 406) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function qp_interior (line 410) | bool qp_interior(
FILE: example/abs_normal/simplex_method.cpp
function simplex_method (line 79) | bool simplex_method(void)
FILE: example/abs_normal/simplex_method.hpp
type CppAD (line 111) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function simplex_method (line 115) | bool simplex_method(
FILE: example/atomic_four/atomic_four.cpp
function main (line 51) | int main(void)
FILE: example/atomic_four/bilinear.cpp
class atomic_bilinear (line 38) | class atomic_bilinear : public CppAD::atomic_four<double> {
method set_index (line 50) | void set_index(double u, double v)
method atomic_bilinear (line 66) | atomic_bilinear(
method for_type (line 83) | bool for_type(
method forward (line 96) | bool forward(
function bilinear (line 178) | bool bilinear(void)
FILE: example/atomic_four/dynamic.cpp
class atomic_dynamic (line 48) | class atomic_dynamic : public CppAD::atomic_four<double> {
method atomic_dynamic (line 50) | atomic_dynamic(const std::string& name) :
method for_type (line 55) | bool for_type(
method forward (line 70) | bool forward(
function dynamic (line 109) | bool dynamic(void)
FILE: example/atomic_four/forward.cpp
class atomic_forward (line 79) | class atomic_forward : public CppAD::atomic_four<double> {
method atomic_forward (line 81) | atomic_forward(const std::string& name) :
method for_type (line 86) | bool for_type(
method forward (line 100) | bool forward(
function forward (line 181) | bool forward(void)
FILE: example/atomic_four/get_started.cpp
class atomic_get_started (line 39) | class atomic_get_started : public CppAD::atomic_four<double> {
method atomic_get_started (line 42) | atomic_get_started(const std::string& name) :
method for_type (line 47) | bool for_type(
method forward (line 60) | bool forward(
function get_started (line 95) | bool get_started(void)
FILE: example/atomic_four/lin_ode/forward.cpp
function Vector (line 88) | Vector Z(Scalar t, const Vector& u)
function Vector (line 102) | Vector G(Scalar t, const Vector& u)
function forward (line 116) | bool forward(void)
FILE: example/atomic_four/lin_ode/lin_ode.cpp
function main (line 29) | int main(void)
FILE: example/atomic_four/lin_ode/rev_depend.cpp
function Vector (line 81) | Vector Y(Scalar t, const Vector& x)
function rev_depend (line 95) | bool rev_depend(void)
FILE: example/atomic_four/lin_ode/reverse.cpp
function Vector (line 97) | Vector Z(Scalar t, const Vector& u)
function Vector (line 111) | Vector G(Scalar t, const Vector& u)
function reverse (line 128) | bool reverse(void)
FILE: example/atomic_four/lin_ode/sparsity.cpp
function Vector (line 73) | Vector Z(Scalar t, const Vector& u)
function sparsity (line 88) | bool sparsity(void)
FILE: example/atomic_four/mat_mul/forward.cpp
function forward (line 97) | bool forward(void)
FILE: example/atomic_four/mat_mul/identical_zero.cpp
function identical_zero (line 83) | bool identical_zero(void)
FILE: example/atomic_four/mat_mul/mat_mul.cpp
function main (line 30) | int main(void)
FILE: example/atomic_four/mat_mul/rev_depend.cpp
function rev_depend (line 77) | bool rev_depend(void)
FILE: example/atomic_four/mat_mul/reverse.cpp
function reverse (line 98) | bool reverse(void)
FILE: example/atomic_four/mat_mul/sparsity.cpp
function sparsity (line 116) | bool sparsity(void)
FILE: example/atomic_four/norm_sq.cpp
class atomic_norm_sq (line 52) | class atomic_norm_sq : public CppAD::atomic_four<double> {
method atomic_norm_sq (line 54) | atomic_norm_sq(const std::string& name) :
method for_type (line 60) | bool for_type(
method forward (line 76) | bool forward(
method reverse (line 124) | bool reverse(
method jac_sparsity (line 167) | bool jac_sparsity(
method hes_sparsity (line 204) | bool hes_sparsity(
method rev_depend (line 237) | bool rev_depend(
function norm_sq (line 258) | bool norm_sq(void)
FILE: example/atomic_four/vector/add.cpp
function add (line 35) | bool add(void)
FILE: example/atomic_four/vector/div.cpp
function div (line 35) | bool div(void)
FILE: example/atomic_four/vector/hes_sparsity.cpp
function hes_sparsity (line 30) | bool hes_sparsity(void)
FILE: example/atomic_four/vector/jac_sparsity.cpp
function jac_sparsity (line 30) | bool jac_sparsity(void)
FILE: example/atomic_four/vector/mul.cpp
function mul (line 35) | bool mul(void)
FILE: example/atomic_four/vector/neg.cpp
function neg (line 35) | bool neg(void)
FILE: example/atomic_four/vector/rev_depend.cpp
function rev_depend (line 30) | bool rev_depend(void)
FILE: example/atomic_four/vector/sub.cpp
function sub (line 35) | bool sub(void)
FILE: example/atomic_four/vector/vector.cpp
function main (line 33) | int main(void)
FILE: example/atomic_three/atomic_three.cpp
function main (line 58) | int main(void)
FILE: example/atomic_three/base2ad.cpp
class atomic_base2ad (line 29) | class atomic_base2ad : public CppAD::atomic_three<double> {
method atomic_base2ad (line 32) | atomic_base2ad(const std::string& name) :
method for_type (line 38) | bool for_type(
method template_forward (line 54) | bool template_forward(
method forward (line 81) | bool forward(
method forward (line 92) | bool forward(
method template_reverse (line 106) | bool template_reverse(
method reverse (line 132) | bool reverse(
method reverse (line 143) | bool reverse(
function base2ad (line 156) | bool base2ad(void)
FILE: example/atomic_three/dynamic.cpp
class atomic_dynamic (line 33) | class atomic_dynamic : public CppAD::atomic_three<double> {
method atomic_dynamic (line 42) | atomic_dynamic(const std::string& name) : // can have more arguments
method for_type (line 54) | bool for_type(
method forward (line 75) | bool forward(
function dynamic (line 140) | bool dynamic(void)
FILE: example/atomic_three/forward.cpp
class atomic_forward (line 65) | class atomic_forward : public CppAD::atomic_three<double> {
method atomic_forward (line 73) | atomic_forward(const std::string& name) :
method for_type (line 84) | bool for_type(
method forward (line 104) | bool forward(
function forward (line 189) | bool forward(void)
FILE: example/atomic_three/get_started.cpp
class atomic_get_started (line 25) | class atomic_get_started : public CppAD::atomic_three<double> {
method atomic_get_started (line 34) | atomic_get_started(const std::string& name) : // can have more arguments
method for_type (line 46) | bool for_type(
method forward (line 65) | bool forward(
function get_started (line 109) | bool get_started(void)
FILE: example/atomic_three/hes_sparsity.cpp
class atomic_hes_sparsity (line 65) | class atomic_hes_sparsity : public CppAD::atomic_three<double> {
method atomic_hes_sparsity (line 73) | atomic_hes_sparsity(const std::string& name) :
method for_type (line 84) | bool for_type(
method forward (line 105) | bool forward(
method jac_sparsity (line 140) | bool jac_sparsity(
method hes_sparsity (line 199) | bool hes_sparsity(
function use_hes_sparsity (line 257) | bool use_hes_sparsity(bool u_1_variable, bool forward)
function hes_sparsity (line 395) | bool hes_sparsity(void)
FILE: example/atomic_three/jac_sparsity.cpp
class atomic_jac_sparsity (line 47) | class atomic_jac_sparsity : public CppAD::atomic_three<double> {
method atomic_jac_sparsity (line 55) | atomic_jac_sparsity(const std::string& name) :
method for_type (line 66) | bool for_type(
method forward (line 87) | bool forward(
method jac_sparsity (line 122) | bool jac_sparsity(
function jac_sparsity (line 276) | const CPPAD_TESTVECTOR(size_t)& row = pattern_out.row();
FILE: example/atomic_three/norm_sq.cpp
class atomic_norm_sq (line 31) | class atomic_norm_sq : public CppAD::atomic_three<double> {
method atomic_norm_sq (line 39) | atomic_norm_sq(const std::string& name) :
method for_type (line 50) | bool for_type(
method forward (line 69) | bool forward(
method reverse (line 123) | bool reverse(
method jac_sparsity (line 167) | bool jac_sparsity(
method hes_sparsity (line 206) | bool hes_sparsity(
function norm_sq (line 251) | bool norm_sq(void)
FILE: example/atomic_three/reciprocal.cpp
class atomic_reciprocal (line 27) | class atomic_reciprocal : public CppAD::atomic_three<double> {
method atomic_reciprocal (line 35) | atomic_reciprocal(const std::string& name) :
method for_type (line 46) | bool for_type(
method forward (line 65) | bool forward(
method reverse (line 124) | bool reverse(
method jac_sparsity (line 198) | bool jac_sparsity(
method hes_sparsity (line 235) | bool hes_sparsity(
function reciprocal (line 278) | bool reciprocal(void)
FILE: example/atomic_three/rev_depend.cpp
class atomic_optimize (line 33) | class atomic_optimize : public CppAD::atomic_three<double> {
method atomic_optimize (line 42) | atomic_optimize(const std::string& name) : // can have more arguments
method for_type (line 54) | bool for_type(
method rev_depend (line 75) | bool rev_depend(
method forward (line 97) | bool forward(
function rev_depend (line 163) | bool rev_depend(void)
FILE: example/atomic_three/reverse.cpp
class atomic_reverse (line 65) | class atomic_reverse : public CppAD::atomic_three<double> {
method atomic_reverse (line 73) | atomic_reverse(const std::string& name) :
method for_type (line 84) | bool for_type(
method forward (line 104) | bool forward(
method reverse (line 164) | bool reverse(
function reverse (line 262) | bool reverse(void)
FILE: example/atomic_three/tangent.cpp
class atomic_tangent (line 28) | class atomic_tangent : public CppAD::atomic_three<float> {
method atomic_tangent (line 39) | atomic_tangent(const char* name, bool hyperbolic)
method for_type (line 51) | bool for_type(
method forward (line 71) | bool forward(
method reverse (line 128) | bool reverse(
method jac_sparsity (line 190) | bool jac_sparsity(
method hes_sparsity (line 233) | bool hes_sparsity(
function tangent (line 271) | bool tangent(void)
FILE: example/atomic_two/atomic_two.cpp
function main (line 48) | int main(void)
FILE: example/atomic_two/eigen_cholesky.cpp
function eigen_cholesky (line 52) | bool eigen_cholesky(void)
FILE: example/atomic_two/eigen_mat_inv.cpp
function eigen_mat_inv (line 50) | bool eigen_mat_inv(void)
FILE: example/atomic_two/eigen_mat_mul.cpp
function eigen_mat_mul (line 51) | bool eigen_mat_mul(void)
FILE: example/chkpoint_two/base2ad.cpp
function f_algo (line 29) | void f_algo(const ADVector& y, ADVector& z)
function g_algo (line 39) | void g_algo(const ADVector& x, ADVector& y)
function base2ad (line 49) | bool base2ad(void)
FILE: example/chkpoint_two/chkpoint_two.cpp
function main (line 50) | int main(void)
FILE: example/chkpoint_two/compare.cpp
function f_algo (line 28) | void f_algo(const ADVector& y, ADVector& z)
function g_algo (line 37) | void g_algo(const ADVector& x, ADVector& y)
function equal (line 46) | bool equal(
function compare (line 65) | bool compare(void)
FILE: example/chkpoint_two/dynamic.cpp
function dynamic (line 51) | bool dynamic(void)
FILE: example/chkpoint_two/get_started.cpp
function f_algo (line 80) | void f_algo(const ADVector& y, ADVector& z)
function g_algo (line 89) | void g_algo(const ADVector& x, ADVector& y)
function get_started (line 99) | bool get_started(void)
FILE: example/chkpoint_two/ode.cpp
function FloatVector (line 129) | FloatVector h(const FloatVector& x, const FloatVector& y)
function FloatVector (line 141) | FloatVector Runge4(const FloatVector& x, const FloatVector& z0
function pack (line 175) | void pack(
function unpack (line 193) | void unpack(
function ode_algo (line 210) | void ode_algo(const a1vector& axz_in, a1vector& axz_out)
function ode (line 228) | bool ode(void)
FILE: example/compare_change/compare_change.cpp
function Type (line 30) | Type Minimum(const Type &x, const Type &y)
type error_info (line 39) | struct error_info {
function error_handler (line 48) | void error_handler(
function compare_change (line 67) | bool compare_change(void)
function main (line 178) | int main(void)
FILE: example/cppad_code_gen/cppad_code_gen.cpp
function main (line 53) | int main(void)
FILE: example/cppad_code_gen/file.cpp
function store (line 23) | void store(const std::string& file_name)
function file (line 53) | bool file(void)
FILE: example/cppad_code_gen/function.cpp
function function (line 22) | bool function(void)
FILE: example/cppad_code_gen/jac_as_fun.cpp
function jac_as_fun (line 22) | bool jac_as_fun(void)
FILE: example/cppad_code_gen/jacobian.cpp
function jacobian (line 22) | bool jacobian(void)
FILE: example/cppad_code_gen/sparse_jac_as_fun.cpp
function sparse_jac_as_fun (line 22) | bool sparse_jac_as_fun(void)
FILE: example/cppad_code_gen/sparse_jacobian.cpp
function sparse_jacobian (line 22) | bool sparse_jacobian(void)
FILE: example/general/abort_recording.cpp
function abort_recording (line 24) | bool abort_recording(void)
FILE: example/general/acos.cpp
function acos (line 23) | bool acos(void)
FILE: example/general/acosh.cpp
function acosh (line 23) | bool acosh(void)
FILE: example/general/ad_assign.cpp
function ad_assign (line 23) | bool ad_assign(void)
FILE: example/general/ad_ctor.cpp
function ad_ctor (line 23) | bool ad_ctor(void)
FILE: example/general/ad_fun.cpp
class my_ad_fun (line 27) | class my_ad_fun {
method my_ad_fun (line 34) | my_ad_fun(void)
method my_ad_fun (line 46) | my_ad_fun(const ADvector& x, const ADvector& y)
method BaseVector (line 51) | BaseVector jacobian(const BaseVector& x)
method BaseVector (line 56) | BaseVector hessian(const BaseVector &x, const BaseVector &w)
function ad_fun (line 62) | bool ad_fun(void)
FILE: example/general/ad_in_c.cpp
function cad2vector (line 61) | void cad2vector(size_t n, cad* p_cad, vector< AD<double> >& v)
function vector2cad (line 70) | void vector2cad(size_t n, vector< AD<double> >& v, cad* p_cad)
function double2vector (line 79) | void double2vector(size_t n, double* p_dbl, vector<double>& v)
function vector2double (line 85) | void vector2double(size_t n, vector<double>& v, double *p_dbl)
function push_allocated (line 93) | inline void push_allocated(void *p)
function pop_allocated (line 95) | inline void pop_allocated(void *p)
function push_allocated (line 98) | inline void push_allocated(void *p)
function pop_allocated (line 102) | inline void pop_allocated(void *p)
function cad_near_equal (line 119) | bool cad_near_equal(double x, double y)
function cad_new_ad (line 128) | void cad_new_ad(cad *p_cad, double value)
function cad_del_ad (line 143) | void cad_del_ad(cad* p_cad)
function cad_value (line 156) | double cad_value(cad* p_cad)
function cad_unary (line 163) | void cad_unary(cad_unary_op op, cad* p_operand, cad* p_result)
function cad_binary (line 224) | void cad_binary(cad_binary_op op, cad* p_left, cad* p_right, cad* p_result)
function cad_independent (line 259) | void cad_independent(size_t n, cad* px_cad)
function cad_fun (line 268) | cad_fun cad_new_fun(size_t n, size_t m, cad* px_cad, cad* py_cad)
function cad_del_fun (line 288) | void cad_del_fun(cad_fun *fun)
function cad_jacobian (line 302) | void cad_jacobian(cad_fun fun,
function cad_forward (line 317) | void cad_forward(cad_fun fun,
function cad_allocated_empty (line 332) | bool cad_allocated_empty(void)
function ad_in_c (line 345) | bool ad_in_c(void)
FILE: example/general/ad_input.cpp
function ad_input (line 26) | bool ad_input(void)
FILE: example/general/ad_output.cpp
function set_ostream (line 29) | void set_ostream(S &os)
function ad_output (line 38) | bool ad_output(void)
FILE: example/general/add.cpp
function Add (line 22) | bool Add(void)
FILE: example/general/add_eq.cpp
function AddEq (line 22) | bool AddEq(void)
FILE: example/general/asin.cpp
function asin (line 23) | bool asin(void)
FILE: example/general/asinh.cpp
function asinh (line 23) | bool asinh(void)
FILE: example/general/atan.cpp
function atan (line 23) | bool atan(void)
FILE: example/general/atan2.cpp
function atan2 (line 24) | bool atan2(void)
FILE: example/general/atanh.cpp
function atanh (line 23) | bool atanh(void)
FILE: example/general/azmul.cpp
function azmul (line 24) | bool azmul(void)
FILE: example/general/base2ad.cpp
class Ode (line 119) | class Ode {
method Ode (line 125) | Ode(const a_vector& x) : x_(x)
method a_vector (line 128) | a_vector operator() (const a_vector& y) const
function a_vector (line 141) | a_vector taylor_ode(
function base2ad (line 191) | bool base2ad(void)
FILE: example/general/base2vec_ad.cpp
function base2vec_ad (line 30) | bool base2vec_ad(void)
FILE: example/general/base_alloc.hpp
class base_alloc (line 107) | class base_alloc {
method base_alloc (line 111) | base_alloc(void)
method base_alloc (line 119) | base_alloc(double dbl)
method base_alloc (line 125) | base_alloc(const base_alloc& x)
method base_alloc (line 135) | base_alloc operator-(void) const
method base_alloc (line 140) | base_alloc operator+(void) const
type CppAD (line 167) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 189) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 204) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 216) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 233) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 246) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 257) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 268) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 301) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 330) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 339) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 352) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 370) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 383) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 395) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
type CppAD (line 408) | namespace CppAD {
function base_alloc (line 168) | inline base_alloc CondExpOp(
function EqualOpSeq (line 205) | inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
function IdenticalCon (line 217) | inline bool IdenticalCon(const base_alloc& x)
function IdenticalZero (line 219) | inline bool IdenticalZero(const base_alloc& x)
function IdenticalOne (line 221) | inline bool IdenticalOne(const base_alloc& x)
function IdenticalEqualCon (line 223) | inline bool IdenticalEqualCon(const base_alloc& x, const base_alloc& y)
function Integer (line 247) | inline int Integer(const base_alloc& x)
function GreaterThanZero (line 269) | inline bool GreaterThanZero(const base_alloc& x)
function GreaterThanOrZero (line 271) | inline bool GreaterThanOrZero(const base_alloc& x)
function LessThanZero (line 273) | inline bool LessThanZero(const base_alloc& x)
function LessThanOrZero (line 275) | inline bool LessThanOrZero(const base_alloc& x)
function abs_geq (line 277) | inline bool abs_geq(const base_alloc& x, const base_alloc& y)
function base_alloc (line 331) | inline base_alloc abs(const base_alloc& x)
function isnan (line 340) | inline bool isnan(const base_alloc& x)
function base_alloc (line 353) | inline base_alloc sign(const base_alloc& x)
function base_alloc (line 371) | inline base_alloc pow(const base_alloc& x, const base_alloc& y)
function hash_code (line 409) | inline unsigned short hash_code(const base_alloc& x)
FILE: example/general/base_require.cpp
function base_require (line 32) | bool base_require(void)
FILE: example/general/bender_quad.cpp
class Fun (line 74) | class Fun {
method Fun (line 80) | Fun(const BAvector &t, const BAvector &z)
method ADvector (line 84) | ADvector f(const ADvector &x, const ADvector &y)
method ADvector (line 99) | ADvector h(const ADvector &x, const BAvector &y)
method ADvector (line 115) | ADvector dy(
function G (line 135) | AD<double> G(const ADvector& x, const BAvector& t, const BAvector& z)
function BenderQuad (line 156) | bool BenderQuad(void)
FILE: example/general/bool_fun.cpp
function IsReal (line 30) | static bool IsReal(const Complex &x)
function AbsGeq (line 34) | static bool AbsGeq(const Complex &x, const Complex &y)
function BoolFun (line 50) | bool BoolFun(void)
FILE: example/general/capacity_order.cpp
function test (line 23) | bool test(void)
function capacity_order (line 90) | bool capacity_order(void)
FILE: example/general/change_param.cpp
function change_param (line 46) | bool change_param(void)
FILE: example/general/check_for_nan.cpp
function myhandler (line 24) | void myhandler(
function check_for_nan (line 36) | bool check_for_nan(void)
FILE: example/general/compare.cpp
function Compare (line 22) | bool Compare(void)
FILE: example/general/complex_poly.cpp
function complex_poly (line 30) | bool complex_poly(void)
FILE: example/general/con_dyn_var.cpp
function con_dyn_var (line 23) | bool con_dyn_var(void)
FILE: example/general/cond_exp.cpp
function CondExp (line 45) | bool CondExp(void)
FILE: example/general/cos.cpp
function Cos (line 24) | bool Cos(void)
FILE: example/general/cosh.cpp
function Cosh (line 24) | bool Cosh(void)
FILE: example/general/div.cpp
function Div (line 22) | bool Div(void)
FILE: example/general/div_eq.cpp
function DivEq (line 22) | bool DivEq(void)
FILE: example/general/eigen_array.cpp
function eigen_array (line 23) | bool eigen_array(void)
FILE: example/general/eigen_det.cpp
function eigen_det (line 24) | bool eigen_det(void)
FILE: example/general/equal_op_seq.cpp
function EqualOpSeq (line 22) | bool EqualOpSeq(void)
FILE: example/general/erf.cpp
function erf (line 25) | bool erf(void)
FILE: example/general/erfc.cpp
function erfc (line 25) | bool erfc(void)
FILE: example/general/exp.cpp
function exp (line 24) | bool exp(void)
FILE: example/general/expm1.cpp
function expm1 (line 24) | bool expm1(void)
FILE: example/general/fabs.cpp
function fabs (line 23) | bool fabs(void)
FILE: example/general/for_one.cpp
function ForOneCases (line 24) | bool ForOneCases()
function ForOne (line 75) | bool ForOne(void)
FILE: example/general/for_two.cpp
function ForTwoCases (line 25) | bool ForTwoCases()
function ForTwo (line 92) | bool ForTwo(void)
FILE: example/general/forward.cpp
function ForwardCases (line 25) | bool ForwardCases(void)
function Forward (line 86) | bool Forward(void)
FILE: example/general/forward_dir.cpp
function forward_dir (line 22) | bool forward_dir(void)
FILE: example/general/forward_order.cpp
function forward_order (line 22) | bool forward_order(void)
FILE: example/general/fun_assign.cpp
function fun_assign (line 23) | bool fun_assign(void)
FILE: example/general/fun_check.cpp
class Fun (line 26) | class Fun {
method Fun (line 31) | Fun(size_t n_) : n(n_)
method Vector (line 34) | Vector operator() (const Vector &x)
function FunCheckCases (line 49) | bool FunCheckCases(void)
function FunCheck (line 117) | bool FunCheck(void)
FILE: example/general/fun_property.cpp
function fun_property (line 26) | bool fun_property(void)
FILE: example/general/function_name.cpp
function function_name (line 23) | bool function_name(void)
FILE: example/general/general.cpp
function main (line 155) | int main(void)
FILE: example/general/hes_lagrangian.cpp
function Lagragian (line 26) | CppAD::AD<double> Lagragian(
function fg (line 49) | CppAD::vector< CppAD::AD<double> > fg(
function CheckHessian (line 62) | bool CheckHessian(
function UseL (line 97) | bool UseL()
function Usefg (line 151) | bool Usefg()
function HesLagrangian (line 219) | bool HesLagrangian(void)
FILE: example/general/hes_lu_det.cpp
type CppAD (line 28) | namespace CppAD {
function HesLuDet (line 34) | bool HesLuDet(void)
FILE: example/general/hes_minor_det.cpp
function HesMinorDet (line 33) | bool HesMinorDet(void)
FILE: example/general/hes_times_dir.cpp
function HesTimesDir (line 37) | bool HesTimesDir(void)
FILE: example/general/hessian.cpp
function HessianCases (line 25) | bool HessianCases()
function Hessian (line 82) | bool Hessian(void)
FILE: example/general/independent.cpp
function Test (line 27) | bool Test(void)
function Independent (line 91) | bool Independent(void)
FILE: example/general/integer.cpp
function Integer (line 23) | bool Integer(void)
FILE: example/general/interface2c.cpp
function Float (line 29) | Float sumGauss(const Float &x, const CppAD::vector<Float> &a)
function sumGauss (line 62) | void sumGauss(float x, float a[], float *y, float dyda[], size_t na)
function NearEqual (line 113) | bool NearEqual(float x, float y, float r, float a)
function Interface2C (line 119) | bool Interface2C(void)
FILE: example/general/interp_onetape.cpp
function Index (line 48) | size_t Index(const double &x)
function Argument (line 61) | double Argument(const double &x)
function Function (line 65) | double Function(const double &x)
function Slope (line 70) | double Slope(const double &x)
function interp_onetape (line 82) | bool interp_onetape(void)
FILE: example/general/interp_retape.cpp
function Index (line 48) | size_t Index(const CppAD::AD<double> &x)
function Argument (line 60) | double Argument(const CppAD::AD<double> &x)
function Function (line 64) | double Function(const CppAD::AD<double> &x)
function Slope (line 68) | double Slope(const CppAD::AD<double> &x)
function interp_retape (line 76) | bool interp_retape(void)
FILE: example/general/jac_lu_det.cpp
type CppAD (line 28) | namespace CppAD {
function JacLuDet (line 33) | bool JacLuDet(void)
FILE: example/general/jac_minor_det.cpp
function JacMinorDet (line 34) | bool JacMinorDet(void)
FILE: example/general/jacobian.cpp
function JacobianCases (line 25) | bool JacobianCases()
function Jacobian (line 83) | bool Jacobian(void)
FILE: example/general/log.cpp
function log (line 23) | bool log(void)
FILE: example/general/log10.cpp
function log10 (line 23) | bool log10(void)
FILE: example/general/log1p.cpp
function log1p (line 23) | bool log1p(void)
FILE: example/general/lu_ratio.cpp
function CheckLuFactor (line 74) | bool CheckLuFactor(
function LuRatio (line 132) | bool LuRatio(void)
FILE: example/general/lu_vec_ad.cpp
type CppAD (line 140) | namespace CppAD {
function lu_vec_ad (line 142) | AD<double> lu_vec_ad(
FILE: example/general/lu_vec_ad.hpp
type CppAD (line 10) | namespace CppAD {
FILE: example/general/lu_vec_ad_ok.cpp
function lu_vec_ad_ok (line 26) | bool lu_vec_ad_ok(void)
FILE: example/general/mul.cpp
function Mul (line 21) | bool Mul(void)
FILE: example/general/mul_eq.cpp
function MulEq (line 22) | bool MulEq(void)
FILE: example/general/mul_level.cpp
function Type (line 70) | Type f(const CPPAD_TESTVECTOR(Type)& x)
function mul_level (line 82) | bool mul_level(void)
FILE: example/general/mul_level_adolc.cpp
function Type (line 88) | Type f(const CPPAD_TESTVECTOR(Type)& x)
function mul_level_adolc (line 100) | bool mul_level_adolc(void)
FILE: example/general/mul_level_adolc_ode.cpp
class Ode (line 146) | class Ode {
method Ode (line 152) | Ode(const CPPAD_TESTVECTOR(a1type)& a1x) : a1x_(a1x)
method CPPAD_TESTVECTOR (line 155) | CPPAD_TESTVECTOR(a2type) operator()
function taylor_ode_adolc (line 171) | taylor_ode_adolc(
function mul_level_adolc_ode (line 235) | bool mul_level_adolc_ode(void)
FILE: example/general/mul_level_ode.cpp
class Ode (line 120) | class Ode {
method Ode (line 126) | Ode(const a1vector& a1x) : a1x_(a1x)
method a2vector (line 129) | a2vector operator()
function a1vector (line 145) | a1vector taylor_ode(
function mul_level_ode (line 209) | bool mul_level_ode(void)
FILE: example/general/near_equal_ext.cpp
function near_equal_ext (line 24) | bool near_equal_ext(void)
FILE: example/general/new_dynamic.cpp
function new_dynamic (line 23) | bool new_dynamic(void)
FILE: example/general/num_limits.cpp
function check_epsilon (line 37) | bool check_epsilon(void)
function check_min (line 48) | bool check_min(void)
function check_max (line 61) | bool check_max(void)
function check_nan (line 74) | bool check_nan(void)
function check_infinity (line 81) | bool check_infinity(void)
function check_digits10 (line 93) | bool check_digits10(void)
function check_max_digits10 (line 103) | bool check_max_digits10(void)
function num_limits (line 117) | bool num_limits(void)
FILE: example/general/number_skip.cpp
function number_skip (line 21) | bool number_skip(void)
FILE: example/general/numeric_type.cpp
class MyType (line 26) | class MyType {
method MyType (line 31) | MyType(void) : d(0.)
method MyType (line 34) | MyType(int d_) : d(d_)
method MyType (line 37) | MyType(const MyType &x)
method Double (line 43) | double Double(void) const
method MyType (line 46) | MyType operator + (void) const
method MyType (line 52) | MyType operator - (void) const
method MyType (line 58) | MyType operator + (const MyType &x) const
method MyType (line 64) | MyType operator - (const MyType &x) const
method MyType (line 70) | MyType operator * (const MyType &x) const
method MyType (line 76) | MyType operator / (const MyType &x) const
function NumericType (line 95) | bool NumericType(void)
FILE: example/general/ode_stiff.cpp
class Fun (line 57) | class Fun {
method Fun (line 62) | Fun(const CPPAD_TESTVECTOR(double)& a_) : a(a_)
method Ode (line 65) | void Ode(
method Ode_ind (line 73) | void Ode_ind(
method Ode_dep (line 81) | void Ode_dep(
class RungeMethod (line 92) | class RungeMethod {
method RungeMethod (line 97) | RungeMethod(const CPPAD_TESTVECTOR(double) &a_) : F(a_)
method step (line 99) | void step(
method order (line 107) | size_t order(void)
class RosenMethod (line 110) | class RosenMethod {
method RosenMethod (line 115) | RosenMethod(const CPPAD_TESTVECTOR(double) &a_) : F(a_)
method step (line 117) | void step(
method order (line 125) | size_t order(void)
function OdeStiff (line 130) | bool OdeStiff(void)
FILE: example/general/opt_val_hes.cpp
class Fun (line 77) | class Fun {
method Fun (line 84) | Fun(const BaseVector &t, const BaseVector &z)
method ell (line 88) | size_t ell(void) const
method s (line 91) | AD<double> s(size_t k, const ad_vector& x, const ad_vector& y) const
method ad_vector (line 99) | ad_vector sy(size_t k, const ad_vector& x, const ad_vector& y) const
function V (line 110) | AD<double> V(const ADVector& x, const BaseVector& t, const BaseVector& z)
function opt_val_hes (line 131) | bool opt_val_hes(void)
FILE: example/general/pow.cpp
function pow (line 24) | bool pow(void)
FILE: example/general/pow_nan.cpp
function pow_nan (line 43) | bool pow_nan(void)
FILE: example/general/print_for.cpp
function check_log (line 27) | AD<double> check_log(const AD<double>& u, std::ostream& s_out)
function print_for (line 39) | bool print_for(void)
FILE: example/general/rev_checkpoint.cpp
function Vector (line 128) | Vector F(const Vector& x)
function Vector (line 135) | Vector G(const Vector& y)
function rev_checkpoint_case (line 144) | bool rev_checkpoint_case(bool free_all)
function rev_checkpoint (line 258) | bool rev_checkpoint(void)
FILE: example/general/rev_one.cpp
function RevOneCases (line 24) | bool RevOneCases()
function RevOne (line 78) | bool RevOne(void)
FILE: example/general/rev_two.cpp
function RevTwoCases (line 25) | bool RevTwoCases()
function RevTwo (line 87) | bool RevTwo(void)
FILE: example/general/reverse_one.cpp
function reverse_one_cases (line 24) | bool reverse_one_cases(void)
function reverse_one (line 75) | bool reverse_one(void)
FILE: example/general/reverse_three.cpp
function cases (line 42) | bool cases(void)
function reverse_three (line 135) | bool reverse_three(void)
FILE: example/general/reverse_two.cpp
function reverse_two_cases (line 24) | bool reverse_two_cases(void)
function reverse_two (line 85) | bool reverse_two(void)
FILE: example/general/sign.cpp
function sign (line 23) | bool sign(void)
FILE: example/general/sin.cpp
function Sin (line 24) | bool Sin(void)
FILE: example/general/sinh.cpp
function Sinh (line 24) | bool Sinh(void)
FILE: example/general/sqrt.cpp
function Sqrt (line 24) | bool Sqrt(void)
FILE: example/general/stack_machine.cpp
function is_number (line 32) | bool is_number( const std::string &s )
function is_binary (line 37) | bool is_binary( const std::string &s )
function is_variable (line 42) | bool is_variable( const std::string &s )
function StackMachine (line 48) | void StackMachine(
function StackMachine (line 123) | bool StackMachine(void)
FILE: example/general/sub.cpp
function Sub (line 22) | bool Sub(void)
FILE: example/general/sub_eq.cpp
function SubEq (line 22) | bool SubEq(void)
FILE: example/general/tan.cpp
function Tan (line 25) | bool Tan(void)
FILE: example/general/tanh.cpp
function Tanh (line 25) | bool Tanh(void)
FILE: example/general/tape_index.cpp
function Array (line 23) | double Array(const double &index)
function TapeIndex (line 45) | bool TapeIndex(void)
FILE: example/general/taylor_ode.cpp
function a_vector (line 74) | a_vector ode(const a_vector y)
function taylor_ode (line 87) | bool taylor_ode(void)
FILE: example/general/unary_minus.cpp
function unary_minus (line 23) | bool unary_minus(void)
FILE: example/general/unary_plus.cpp
function unary_plus (line 23) | bool unary_plus(void)
FILE: example/general/value.cpp
function Value (line 23) | bool Value(void)
FILE: example/general/var2par.cpp
function Var2Par (line 24) | bool Var2Par(void)
FILE: example/general/vec_ad.cpp
function Vector (line 30) | Vector Solve(const Vector &a , const Vector &b)
function vec_ad (line 74) | bool vec_ad(void)
FILE: example/get_started/get_started.cpp
function Type (line 86) | Type Poly(const CPPAD_TESTVECTOR(double) &a, const Type &x)
function main (line 98) | int main(void)
FILE: example/graph/add_op.cpp
function add_op (line 23) | bool add_op(void)
FILE: example/graph/atom4_op.cpp
class atomic_int_pow (line 24) | class atomic_int_pow : public CppAD::atomic_four<double> {
method atomic_int_pow (line 26) | atomic_int_pow(void) : CppAD::atomic_four<double>("int_pow")
method for_type (line 30) | bool for_type(
method forward (line 38) | bool forward(
function atom4_op (line 60) | bool atom4_op(void)
FILE: example/graph/atom_op.cpp
function atom_op (line 23) | bool atom_op(void)
FILE: example/graph/azmul_op.cpp
function azmul_op (line 23) | bool azmul_op(void)
FILE: example/graph/cexp_op.cpp
function cexp_op (line 23) | bool cexp_op(void)
FILE: example/graph/comp_op.cpp
function comp_op (line 23) | bool comp_op(void)
FILE: example/graph/discrete_op.cpp
function heaviside (line 24) | double heaviside(const double &x)
function discrete_op (line 34) | bool discrete_op(void)
FILE: example/graph/div_op.cpp
function div_op (line 23) | bool div_op(void)
FILE: example/graph/graph.cpp
function main (line 63) | int main(void)
FILE: example/graph/mul_op.cpp
function mul_op (line 23) | bool mul_op(void)
FILE: example/graph/pow_op.cpp
function pow_op (line 23) | bool pow_op(void)
FILE: example/graph/print_graph.cpp
function print_graph (line 23) | bool print_graph(void)
FILE: example/graph/print_op.cpp
function print_op (line 23) | bool print_op(void)
FILE: example/graph/sub_op.cpp
function sub_op (line 23) | bool sub_op(void)
FILE: example/graph/sum_op.cpp
function sum_op (line 23) | bool sum_op(void)
FILE: example/graph/switch_var_dyn.cpp
function switch_var_dyn (line 46) | bool switch_var_dyn(void)
FILE: example/graph/unary_op.cpp
function unary_op (line 23) | bool unary_op(void)
FILE: example/ipopt_solve/get_started.cpp
class FG_eval (line 51) | class FG_eval {
function get_started (line 75) | bool get_started(void)
FILE: example/ipopt_solve/ipopt_solve.cpp
function main (line 45) | int main(void)
FILE: example/ipopt_solve/ode_inverse.cpp
function yone (line 218) | double yone(double t)
class FG_eval (line 234) | class FG_eval
function ode_inverse (line 294) | bool ode_inverse(void)
FILE: example/ipopt_solve/retape.cpp
class FG_eval (line 34) | class FG_eval {
function retape (line 54) | bool retape(void)
FILE: example/jit/atomic.cpp
function write_c_file (line 41) | std::string write_c_file(size_t index, const std::string& csrc)
class atomic_fun (line 55) | class atomic_fun : public CppAD::atomic_four<double> {
method atomic_fun (line 59) | atomic_fun(const std::string& name) :
method for_type (line 64) | bool for_type(
method forward (line 72) | bool forward(
method forward_zero (line 86) | std::string forward_zero(void)
function atomic (line 108) | bool atomic(void)
FILE: example/jit/compare_change.cpp
function compare_change (line 37) | bool compare_change(void)
FILE: example/jit/compile.cpp
function compile (line 42) | bool compile(void)
FILE: example/jit/dynamic.cpp
function dynamic (line 37) | bool dynamic(void)
FILE: example/jit/get_started.cpp
function get_started (line 47) | bool get_started(void)
FILE: example/jit/jit.cpp
function main (line 54) | int main(void)
FILE: example/json/add_op.cpp
function add_op (line 23) | bool add_op(void)
FILE: example/json/atom4_op.cpp
class atomic_avg (line 24) | class atomic_avg : public CppAD::atomic_four<double> {
method atomic_avg (line 26) | atomic_avg(void) : CppAD::atomic_four<double>("avg")
method for_type (line 30) | bool for_type(
method forward (line 38) | bool forward(
function atom4_op (line 66) | bool atom4_op(void)
FILE: example/json/atom_op.cpp
function atom_op (line 23) | bool atom_op(void)
FILE: example/json/azmul_op.cpp
function azmul_op (line 23) | bool azmul_op(void)
FILE: example/json/cexp_op.cpp
function cexp_op (line 23) | bool cexp_op(void)
FILE: example/json/comp_op.cpp
function comp_op (line 23) | bool comp_op(void)
FILE: example/json/discrete_op.cpp
function heaviside (line 24) | double heaviside(const double &x)
function discrete_op (line 34) | bool discrete_op(void)
FILE: example/json/div_op.cpp
function div_op (line 23) | bool div_op(void)
FILE: example/json/from_json.cpp
function from_json (line 23) | bool from_json(void)
FILE: example/json/get_started.cpp
function get_started (line 56) | bool get_started(void)
FILE: example/json/json.cpp
function main (line 65) | int main(void)
FILE: example/json/mul_op.cpp
function mul_op (line 23) | bool mul_op(void)
FILE: example/json/pow_op.cpp
function pow_op (line 23) | bool pow_op(void)
FILE: example/json/print_op.cpp
function print_op (line 23) | bool print_op(void)
FILE: example/json/sparse.cpp
function sparse (line 37) | bool sparse(void)
FILE: example/json/sub_op.cpp
function sub_op (line 23) | bool sub_op(void)
FILE: example/json/sum_op.cpp
function sum_op (line 23) | bool sum_op(void)
FILE: example/json/to_json.cpp
function to_json (line 23) | bool to_json(void)
FILE: example/json/unary_op.cpp
function unary_op (line 23) | bool unary_op(void)
FILE: example/multi_thread/bthread/a11c_bthread.cpp
class worker_t (line 37) | class worker_t
method setup (line 44) | void setup(size_t n, float* a, float* b)
method a1 (line 50) | void a1(int n, float *a, float *b)
function a11c (line 62) | bool a11c(void)
FILE: example/multi_thread/bthread/get_started.cpp
function cleanup (line 43) | void cleanup(size_t* thread_num)
function in_parallel (line 53) | bool in_parallel(void)
function thread_number (line 57) | size_t thread_number(void)
function partial (line 63) | double partial(
function run_one_thread (line 77) | void run_one_thread(
function get_started (line 109) | bool get_started(void)
FILE: example/multi_thread/bthread/team_bthread.cpp
function cleanup (line 32) | void cleanup(size_t*)
type thread_job_t (line 39) | enum thread_job_t { init_enum, work_enum, join_enum }
function in_parallel (line 69) | bool in_parallel(void)
function thread_number (line 74) | size_t thread_number(void)
function thread_work (line 80) | void thread_work(size_t thread_num)
function team_create (line 113) | bool team_create(size_t num_threads)
function team_work (line 173) | bool team_work(void worker(void))
function team_destroy (line 208) | bool team_destroy(void)
FILE: example/multi_thread/harmonic.cpp
function harmonic_setup (line 115) | bool harmonic_setup(size_t num_sum)
function harmonic_worker (line 191) | void harmonic_worker(void)
function harmonic_takedown (line 260) | bool harmonic_takedown(double& sum)
function harmonic_sum (line 351) | bool harmonic_sum(double& sum, size_t num_sum)
function test_once (line 480) | void test_once(void)
function test_repeat (line 494) | void test_repeat(size_t repeat)
function harmonic_time (line 503) | bool harmonic_time(
FILE: example/multi_thread/multi_atomic_three.cpp
class atomic_user (line 93) | class atomic_user : public CppAD::atomic_three<double> {
method atomic_user (line 96) | atomic_user(void)
method for_type (line 101) | bool for_type(
method forward (line 119) | bool forward(
function multi_atomic_three_setup (line 264) | bool multi_atomic_three_setup(const vector<double>& y_squared)
function multi_atomic_three_worker (line 344) | void multi_atomic_three_worker(void)
function multi_atomic_three_takedown (line 414) | bool multi_atomic_three_takedown(vector<double>& square_root)
function multi_atomic_three_run (line 513) | bool multi_atomic_three_run(
function test_once (line 618) | void test_once(void)
function test_repeat (line 627) | void test_repeat(size_t repeat)
function multi_atomic_three_time (line 635) | bool multi_atomic_three_time(
FILE: example/multi_thread/multi_atomic_two.cpp
class atomic_user (line 92) | class atomic_user : public CppAD::atomic_base<double> {
method atomic_user (line 95) | atomic_user(void)
method forward (line 100) | bool forward(
function multi_atomic_two_setup (line 251) | bool multi_atomic_two_setup(const vector<double>& y_squared)
function multi_atomic_two_worker (line 331) | void multi_atomic_two_worker(void)
function multi_atomic_two_takedown (line 401) | bool multi_atomic_two_takedown(vector<double>& square_root)
function multi_atomic_two_run (line 500) | bool multi_atomic_two_run(
function test_once (line 605) | void test_once(void)
function test_repeat (line 614) | void test_repeat(size_t repeat)
function multi_atomic_two_time (line 622) | bool multi_atomic_two_time(
FILE: example/multi_thread/multi_chkpoint_one.cpp
function checkpoint_algo (line 78) | void checkpoint_algo(const vector<a_double>& au , vector<a_double>& ay)
function multi_chkpoint_one_setup (line 202) | bool multi_chkpoint_one_setup(const vector<double>& y_squared)
function multi_chkpoint_one_worker (line 281) | void multi_chkpoint_one_worker(void)
function multi_chkpoint_one_takedown (line 351) | bool multi_chkpoint_one_takedown(vector<double>& square_root)
function multi_chkpoint_one_run (line 452) | bool multi_chkpoint_one_run(
function test_once (line 557) | void test_once(void)
function test_repeat (line 566) | void test_repeat(size_t repeat)
function multi_chkpoint_one_time (line 574) | bool multi_chkpoint_one_time(
FILE: example/multi_thread/multi_chkpoint_two.cpp
function checkpoint_algo (line 78) | void checkpoint_algo(const vector<a_double>& au , vector<a_double>& ay)
function multi_chkpoint_two_setup (line 202) | bool multi_chkpoint_two_setup(const vector<double>& y_squared)
function multi_chkpoint_two_worker (line 281) | void multi_chkpoint_two_worker(void)
function multi_chkpoint_two_takedown (line 351) | bool multi_chkpoint_two_takedown(vector<double>& square_root)
function multi_chkpoint_two_run (line 452) | bool multi_chkpoint_two_run(
function test_once (line 557) | void test_once(void)
function test_repeat (line 566) | void test_repeat(size_t repeat)
function multi_chkpoint_two_time (line 574) | bool multi_chkpoint_two_time(
FILE: example/multi_thread/multi_newton.cpp
function multi_newton_setup (line 140) | bool multi_newton_setup(
function multi_newton_worker (line 263) | void multi_newton_worker(void)
function multi_newton_takedown (line 387) | bool multi_newton_takedown(vector<double>& xout)
function multi_newton_run (line 618) | bool multi_newton_run(
function Float (line 808) | Float f_eval(Float x)
function df_direct (line 819) | double df_direct(double x)
function fun_ad (line 829) | void fun_ad(double x, double& f, double& df)
function fun_no (line 847) | void fun_no(double x, double& f, double& df)
function test_once (line 855) | void test_once(void)
function test_repeat (line 886) | void test_repeat(size_t repeat)
function multi_newton_time (line 896) | bool multi_newton_time(
FILE: example/multi_thread/openmp/a11c_openmp.cpp
function a1 (line 38) | void a1(int n, float *a, float *b)
function a11c (line 50) | bool a11c(void)
FILE: example/multi_thread/openmp/get_started.cpp
function in_parallel (line 38) | bool in_parallel(void)
function thread_number (line 43) | size_t thread_number(void)
function partial (line 48) | double partial(
function get_started (line 66) | bool get_started(void)
FILE: example/multi_thread/openmp/team_openmp.cpp
function in_parallel (line 31) | bool in_parallel(void)
function thread_num (line 35) | size_t thread_num(void)
function team_create (line 39) | bool team_create(size_t num_threads)
function team_work (line 62) | bool team_work(void worker(void))
function team_destroy (line 77) | bool team_destroy(void)
FILE: example/multi_thread/pthread/a11c_pthread.cpp
function a1 (line 46) | void a1(int n, float *a, float *b)
type start_arg (line 53) | struct start_arg { int n; float* a; float* b; }
function a11c (line 65) | bool a11c(void)
FILE: example/multi_thread/pthread/get_started.cpp
function thread_specific_destructor (line 56) | void thread_specific_destructor(void* thread_num_vptr)
function in_parallel (line 63) | bool in_parallel(void)
function thread_number (line 67) | size_t thread_number(void)
function partial (line 76) | double partial(
function get_started (line 130) | bool get_started(void)
FILE: example/multi_thread/pthread/team_pthread.cpp
function thread_specific_destructor (line 56) | void thread_specific_destructor(void* thread_num_vptr)
type thread_job_t (line 60) | enum thread_job_t { init_enum, work_enum, join_enum }
function in_parallel (line 90) | bool in_parallel(void)
function thread_number (line 95) | size_t thread_number(void)
function team_create (line 153) | bool team_create(size_t num_threads)
function team_work (line 243) | bool team_work(void worker(void))
function team_destroy (line 282) | bool team_destroy(void)
FILE: example/multi_thread/sthread/a11c_sthread.cpp
class worker_t (line 37) | class worker_t
method setup (line 44) | void setup(size_t n, float* a, float* b)
method a1 (line 50) | void a1(int n, float *a, float *b)
function a11c (line 62) | bool a11c(void)
FILE: example/multi_thread/sthread/get_started.cpp
function in_parallel (line 53) | bool in_parallel(void)
function thread_number (line 57) | size_t thread_number(void)
function partial (line 63) | double partial(
function run_one_thread (line 77) | void run_one_thread(
function get_started (line 109) | bool get_started(void)
FILE: example/multi_thread/sthread/team_sthread.cpp
function in_parallel (line 44) | bool in_parallel(void)
function thread_number (line 49) | size_t thread_number(void)
function team_create (line 53) | bool team_create(size_t num_threads)
function work_wrapper (line 76) | void work_wrapper(void worker(void))
function team_work (line 86) | bool team_work( void worker(void) )
function team_destroy (line 132) | bool team_destroy(void)
FILE: example/multi_thread/team_example.cpp
function worker (line 63) | void worker(void)
function team_example (line 92) | bool team_example(void)
FILE: example/multi_thread/thread_test.cpp
function arg2size_t (line 250) | size_t arg2size_t(
function arg2double (line 261) | double arg2double(
function main (line 274) | int main(int argc, char *argv[])
FILE: example/optimize/compare_op.cpp
type tape_size (line 25) | struct tape_size { size_t n_var; size_t n_op; }
function fun (line 27) | void fun(
function compare_op (line 75) | bool compare_op(void)
FILE: example/optimize/conditional_skip.cpp
type tape_size (line 25) | struct tape_size { size_t n_var; size_t n_op; }
function fun (line 27) | void fun(
function conditional_skip (line 82) | bool conditional_skip(void)
FILE: example/optimize/cumulative_sum.cpp
type tape_size (line 22) | struct tape_size { size_t n_var; size_t n_op; }
function fun (line 24) | void fun(
function cumulative_sum (line 60) | bool cumulative_sum(void)
FILE: example/optimize/forward_active.cpp
type tape_size (line 21) | struct tape_size { size_t n_var; size_t n_op; }
function fun (line 23) | void fun(
function forward_active (line 87) | bool forward_active(void)
FILE: example/optimize/nest_conditional.cpp
type tape_size (line 25) | struct tape_size { size_t n_var; size_t n_op; }
function fun (line 27) | void fun(
function nest_conditional (line 88) | bool nest_conditional(void)
FILE: example/optimize/optimize.cpp
function main (line 49) | int main(void)
FILE: example/optimize/optimize_twice.cpp
function optimize_twice (line 28) | bool optimize_twice(void)
FILE: example/optimize/print_for.cpp
type tape_size (line 23) | struct tape_size { size_t n_var; size_t n_op; }
function PrintFor (line 25) | void PrintFor(
function fun (line 32) | void fun(
function print_for (line 65) | bool print_for(void)
FILE: example/optimize/reverse_active.cpp
type tape_size (line 21) | struct tape_size { size_t n_var; size_t n_op; }
function fun (line 23) | void fun(
function reverse_active (line 62) | bool reverse_active(void)
FILE: example/print_for/print_for.cpp
function check_log (line 28) | AD<double> check_log(const AD<double>& y)
function print_for (line 40) | void print_for(void)
function main (line 91) | int main(void)
FILE: example/sparse/colpack_hes.cpp
function colpack_hes (line 22) | bool colpack_hes(void)
FILE: example/sparse/colpack_hessian.cpp
function colpack_hessian (line 22) | bool colpack_hessian(void)
FILE: example/sparse/colpack_jac.cpp
function colpack_jac (line 22) | bool colpack_jac(void)
FILE: example/sparse/colpack_jacobian.cpp
function colpack_jacobian (line 22) | bool colpack_jacobian(void)
FILE: example/sparse/conj_grad.cpp
function mat_mul (line 91) | void mat_mul(size_t n, const Vector& a, const Vector& b, Vector& c)
function conjugate_gradient (line 116) | size_t conjugate_gradient(
function conj_grad (line 176) | bool conj_grad(void)
FILE: example/sparse/dependency.cpp
function heavyside (line 59) | double heavyside(const double& x)
function dependency (line 67) | bool dependency(void)
FILE: example/sparse/for_hes_sparsity.cpp
function for_hes_sparsity (line 22) | bool for_hes_sparsity(void)
FILE: example/sparse/for_jac_sparsity.cpp
function for_jac_sparsity (line 22) | bool for_jac_sparsity(void)
FILE: example/sparse/for_sparse_hes.cpp
function BoolCases (line 38) | bool BoolCases(bool optimize)
function SetCases (line 97) | bool SetCases(bool optimize)
function for_sparse_hes (line 165) | bool for_sparse_hes(void)
FILE: example/sparse/for_sparse_jac.cpp
function BoolCases (line 27) | bool BoolCases(void)
function SetCases (line 99) | bool SetCases(void)
function ForSparseJac (line 183) | bool ForSparseJac(void)
FILE: example/sparse/rc_sparsity.cpp
function a_vector (line 42) | a_vector fun(const a_vector& x)
function check_jac (line 55) | bool check_jac(
function forward_jac (line 93) | bool forward_jac(CppAD::ADFun<double>& f)
function reverse_jac (line 130) | bool reverse_jac(CppAD::ADFun<double>& f)
function check_hes (line 169) | bool check_hes(
function forward_hes (line 215) | bool forward_hes(CppAD::ADFun<double>& f)
function reverse_hes (line 263) | bool reverse_hes(CppAD::ADFun<double>& f)
function rc_sparsity (line 320) | bool rc_sparsity(void)
FILE: example/sparse/rev_hes_sparsity.cpp
function rev_hes_sparsity (line 22) | bool rev_hes_sparsity(void)
FILE: example/sparse/rev_jac_sparsity.cpp
function rev_jac_sparsity (line 22) | bool rev_jac_sparsity(void)
FILE: example/sparse/rev_sparse_hes.cpp
function BoolCases (line 38) | bool BoolCases(void)
function SetCases (line 109) | bool SetCases(void)
function rev_sparse_hes (line 192) | bool rev_sparse_hes(void)
FILE: example/sparse/rev_sparse_jac.cpp
function BoolCases (line 25) | bool BoolCases(void)
function SetCases (line 85) | bool SetCases(void)
function RevSparseJac (line 159) | bool RevSparseJac(void)
FILE: example/sparse/sparse.cpp
function main (line 75) | int main(void)
FILE: example/sparse/sparse2eigen.cpp
function sparse2eigen (line 21) | bool sparse2eigen(void)
FILE: example/sparse/sparse_hes.cpp
function sparse_hes (line 21) | bool sparse_hes(void)
FILE: example/sparse/sparse_hessian.cpp
function sparse_hessian (line 21) | bool sparse_hessian(void)
FILE: example/sparse/sparse_jac_for.cpp
function sparse_jac_for (line 21) | bool sparse_jac_for(void)
FILE: example/sparse/sparse_jac_rev.cpp
function sparse_jac_rev (line 21) | bool sparse_jac_rev(void)
FILE: example/sparse/sparse_jacobian.cpp
function reverse (line 23) | bool reverse()
function forward (line 135) | bool forward()
function sparse_jacobian (line 250) | bool sparse_jacobian(void)
FILE: example/sparse/sparse_sub_hes.cpp
function sparse_sub_hes (line 31) | bool sparse_sub_hes(void)
FILE: example/sparse/sparsity_sub.cpp
function sparsity_sub (line 37) | bool sparsity_sub(void)
FILE: example/sparse/sub_sparse_hes.cpp
function Scalar (line 64) | Scalar f(const vector<Scalar>& u,const vector<Scalar>& v)
function sub_sparse_hes (line 76) | bool sub_sparse_hes(void)
FILE: example/sparse/subgraph_hes2jac.cpp
function subgraph_hes2jac (line 24) | bool subgraph_hes2jac(void)
FILE: example/sparse/subgraph_jac_rev.cpp
function subgraph_jac_rev (line 21) | bool subgraph_jac_rev(void)
FILE: example/sparse/subgraph_reverse.cpp
function subgraph_reverse (line 24) | bool subgraph_reverse(void)
FILE: example/sparse/subgraph_sparsity.cpp
function subgraph_sparsity (line 22) | bool subgraph_sparsity(void)
FILE: example/utility/check_numeric_type.cpp
class MyType (line 32) | class MyType {
method MyType (line 37) | MyType(void) : d(0.)
method MyType (line 40) | MyType(int d_) : d(d_)
method MyType (line 43) | MyType(const MyType &x)
method Double (line 49) | double Double(void) const
method MyType (line 53) | MyType operator + (void) const
method MyType (line 61) | MyType operator - (void) const
method MyType (line 69) | MyType operator + (const MyType &x) const
method MyType (line 77) | MyType operator - (const MyType &x) const
method MyType (line 85) | MyType operator * (const MyType &x) const
method MyType (line 93) | MyType operator / (const MyType &x) const
function Solve (line 126) | void Solve(NumericType *A, NumericType *x, NumericType *b)
function CheckNumericType (line 161) | bool CheckNumericType(void)
FILE: example/utility/check_simple_vector.cpp
class MyElement (line 34) | class MyElement {
method MyElement (line 39) | MyElement(Scalar *e)
class MyVector (line 52) | class MyVector {
method MyVector (line 64) | MyVector(void) : length(0) , data(0)
method MyVector (line 69) | MyVector(size_t n) : length(n)
method MyVector (line 78) | MyVector(const MyVector &x) : length(x.length)
method size (line 98) | size_t size(void) const
method resize (line 103) | void resize(size_t n)
method MyVector (line 115) | MyVector & operator=(const MyVector &x)
method Scalar (line 129) | const Scalar & operator[](size_t i) const
function Vector (line 142) | Vector Sscal(const Scalar &a, const Vector &v)
function CheckSimpleVector (line 158) | bool CheckSimpleVector(void)
FILE: example/utility/cppad_vector.cpp
function myhandler (line 35) | void myhandler(
function CppAD_vector (line 46) | bool CppAD_vector(void)
FILE: example/utility/dll_lib.cpp
function dll_lib (line 79) | bool dll_lib(void)
FILE: example/utility/error_handler.cpp
function myhandler (line 25) | void myhandler(
function ErrorHandler (line 37) | bool ErrorHandler(void)
FILE: example/utility/index_sort.cpp
class Key (line 28) | class Key {
method Key (line 33) | Key(void)
method Key (line 36) | Key(size_t first, size_t second)
function vector_case (line 48) | bool vector_case(void)
function index_sort (line 80) | bool index_sort(void)
FILE: example/utility/lu_factor.cpp
function LuFactor (line 26) | bool LuFactor(void)
FILE: example/utility/lu_invert.cpp
function LuInvert (line 27) | bool LuInvert(void)
FILE: example/utility/lu_solve.cpp
function LuSolve (line 28) | bool LuSolve(void)
FILE: example/utility/nan.cpp
function nan (line 25) | bool nan(void)
FILE: example/utility/near_equal.cpp
function Near_Equal (line 32) | bool Near_Equal(void)
FILE: example/utility/ode_err_control.cpp
class Fun (line 65) | class Fun {
method Fun (line 70) | Fun(double alpha) : alpha_(alpha)
method Ode (line 74) | void Ode(
class Method (line 88) | class Method {
method Method (line 93) | Method(double alpha) : F(alpha)
method step (line 95) | void step(
method order (line 103) | size_t order(void)
function OdeErrControl (line 108) | bool OdeErrControl(void)
FILE: example/utility/ode_err_maxabs.cpp
class Fun (line 55) | class Fun {
method Fun (line 60) | Fun(const CppAD::vector<double> &w_) : w(w_)
method Ode (line 64) | void Ode(
class Method (line 74) | class Method {
method Method (line 79) | Method(const CppAD::vector<double> &w_) : F(w_)
method step (line 81) | void step(
method order (line 89) | size_t order(void)
function OdeErrMaxabs (line 94) | bool OdeErrMaxabs(void)
FILE: example/utility/ode_gear.cpp
class Fun (line 48) | class Fun {
method Fun (line 51) | Fun(bool use_x_) : use_x(use_x_)
method Ode (line 56) | void Ode(
method Ode_dep (line 75) | void Ode_dep(
function OdeGear (line 121) | bool OdeGear(void)
FILE: example/utility/ode_gear_control.cpp
class Fun (line 49) | class Fun {
method Fun (line 54) | Fun(const CPPAD_TESTVECTOR(double) &w_) : w(w_)
method Ode (line 59) | void Ode(
method Ode_dep (line 67) | void Ode_dep(
function OdeGearControl (line 109) | bool OdeGearControl(void)
FILE: example/utility/poly.cpp
function poly (line 24) | bool poly(void)
FILE: example/utility/pow_int.cpp
function pow_int (line 24) | bool pow_int(void)
FILE: example/utility/romberg_mul.cpp
class TestFun (line 28) | class TestFun {
method TestFun (line 33) | TestFun(const CppAD::vector<size_t> deg_)
function RombergMul (line 51) | bool RombergMul(void)
FILE: example/utility/romberg_one.cpp
class Fun (line 26) | class Fun {
method Fun (line 31) | Fun(size_t degree_) : degree(degree_)
method Type (line 36) | Type operator () (const Type &x)
function RombergOne (line 46) | bool RombergOne(void)
FILE: example/utility/rosen_34.cpp
class Fun (line 62) | class Fun {
method Fun (line 69) | Fun(bool use_x) : use_x_(use_x)
method Ode (line 74) | void Ode(
method Ode_ind (line 91) | void Ode_ind(
method Ode_dep (line 145) | void Ode_dep(
function rosen_34 (line 201) | bool rosen_34(void)
FILE: example/utility/runge45_1.cpp
class Fun (line 54) | class Fun {
method Fun (line 57) | Fun(bool use_x_) : use_x(use_x_)
method Ode (line 61) | void Ode(
function runge_45_1 (line 83) | bool runge_45_1(void)
FILE: example/utility/runge_45.cpp
class Fun (line 60) | class Fun {
method Fun (line 63) | Fun(void)
method Ode (line 67) | void Ode(
function runge_45 (line 79) | bool runge_45(void)
FILE: example/utility/set_union.cpp
function set_union (line 22) | bool set_union(void)
FILE: example/utility/simple_vector.cpp
function Ok (line 28) | bool Ok(void)
function SimpleVector (line 58) | bool SimpleVector (void)
FILE: example/utility/sparse_rc.cpp
function sparse_rc (line 24) | bool sparse_rc(void)
FILE: example/utility/sparse_rcv.cpp
function sparse_rcv (line 24) | bool sparse_rcv(void)
FILE: example/utility/thread_alloc.cpp
function raw_allocate (line 29) | bool raw_allocate(void)
class my_char (line 85) | class my_char {
method my_char (line 88) | my_char(void) : ch_(' ')
method my_char (line 90) | my_char(const my_char& my_ch) : ch_(my_ch.ch_)
function type_allocate (line 94) | bool type_allocate(void)
function check_alignment (line 154) | bool check_alignment(void)
function thread_alloc (line 200) | bool thread_alloc(void)
FILE: example/utility/to_string.cpp
function Integer (line 25) | Integer string2signed(const std::string& s)
function Integer (line 40) | Integer string2unsigned(const std::string& s)
function signed_integer (line 48) | bool signed_integer(void)
function unsigned_integer (line 64) | bool unsigned_integer(void)
function floating (line 76) | bool floating(void)
function ad_floating (line 93) | bool ad_floating(void)
function to_string (line 107) | bool to_string(void)
FILE: example/utility/utility.cpp
function main (line 72) | int main(void)
FILE: example/utility/vector_bool.cpp
function vectorBool (line 26) | bool vectorBool(void)
FILE: example/valvector/ad_split.cpp
function ad_split (line 22) | bool ad_split(void)
FILE: example/valvector/ad_sum.cpp
function ad_sum (line 22) | bool ad_sum(void)
FILE: example/valvector/assign.cpp
function assign (line 22) | bool assign(void)
FILE: example/valvector/azmul.cpp
function azmul (line 25) | bool azmul(void)
FILE: example/valvector/base_require.cpp
function base_require (line 30) | bool base_require(void)
FILE: example/valvector/binary_op.cpp
function binary_op (line 22) | bool binary_op(void)
FILE: example/valvector/compare_op.cpp
function compare_op (line 22) | bool compare_op(void)
FILE: example/valvector/compound_op.cpp
function compound_op (line 22) | bool compound_op(void)
FILE: example/valvector/condexp.cpp
function condexp (line 25) | bool condexp(void)
FILE: example/valvector/ctor.cpp
function ctor (line 22) | bool ctor(void)
FILE: example/valvector/element.cpp
function element (line 22) | bool element(void)
FILE: example/valvector/get_started.cpp
function get_started (line 22) | bool get_started(void)
FILE: example/valvector/llsq_obj.cpp
function llsq_obj (line 23) | bool llsq_obj(void)
FILE: example/valvector/output.cpp
function output (line 24) | bool output(void)
FILE: example/valvector/pow.cpp
function pow (line 25) | bool pow(void)
FILE: example/valvector/resize.cpp
function resize (line 22) | bool resize(void)
FILE: example/valvector/size.cpp
function size (line 22) | bool size(void)
FILE: example/valvector/sum.cpp
function sum (line 22) | bool sum(void)
FILE: example/valvector/unary_math.cpp
function math_unary (line 25) | bool math_unary(void)
FILE: example/valvector/unary_op.cpp
function unary_op (line 22) | bool unary_op(void)
FILE: example/valvector/valvector.cpp
function main (line 70) | int main(void)
FILE: include/cppad/core/abort_recording.hpp
type CppAD (line 42) | namespace CppAD {
FILE: include/cppad/core/abs.hpp
type CppAD (line 72) | namespace CppAD {
function abs (line 117) | AD<Base> abs(const AD<Base> &x)
function abs (line 121) | AD<Base> abs(const VecAD_reference<Base> &x)
FILE: include/cppad/core/abs_normal_fun.hpp
type CppAD (line 320) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/ad.hpp
type CppAD (line 20) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class AD (line 30) | class AD {
type CompareOp (line 118) | enum CompareOp
method make_variable (line 275) | void make_variable(tape_id_t id, addr_t taddr)
method make_dynamic (line 285) | void make_dynamic(tape_id_t id, addr_t taddr)
FILE: include/cppad/core/ad_assign.hpp
type CppAD (line 56) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/ad_ctor.hpp
type CppAD (line 72) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/ad_fun.hpp
type CppAD (line 38) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class ADFun (line 54) | class ADFun {
method ADFun (line 281) | ADFun(const ADFun& g) = delete;
method exceed_collision_limit (line 570) | bool exceed_collision_limit(void) const
method size_forward_bool (line 574) | size_t size_forward_bool(void) const
method size_forward_bool (line 578) | void size_forward_bool(size_t zero)
method size_forward_set (line 587) | size_t size_forward_set(void) const
method size_forward_set (line 591) | void size_forward_set(size_t zero)
method size_op (line 600) | size_t size_op(void) const
method size_op_arg (line 604) | size_t size_op_arg(void) const
method size_op_seq (line 608) | size_t size_op_seq(void) const
method size_random (line 613) | size_t size_random(void) const
method size_par (line 617) | size_t size_par(void) const
method size_dyn_ind (line 621) | size_t size_dyn_ind(void) const
method size_dyn_par (line 625) | size_t size_dyn_par(void) const
method size_dyn_arg (line 629) | size_t size_dyn_arg(void) const
method size_order (line 633) | size_t size_order(void) const
method size_direction (line 637) | size_t size_direction(void) const
method size_text (line 641) | size_t size_text(void) const
method size_var (line 645) | size_t size_var(void) const
method size_VecAD (line 649) | size_t size_VecAD(void) const
method Domain (line 662) | size_t Domain(void) const
method Range (line 666) | size_t Range(void) const
method function_name_set (line 670) | void function_name_set(const std::string& function_name)
method function_name_get (line 672) | std::string function_name_get(void)
method Parameter (line 676) | bool Parameter(size_t i)
method CompareChange (line 686) | size_t CompareChange(void) const
method compare_change_count (line 690) | void compare_change_count(size_t count)
method compare_change_number (line 697) | size_t compare_change_number(void) const
method compare_change_op_index (line 701) | size_t compare_change_op_index(void) const
method Size (line 811) | size_t Size(void) const
method Order (line 816) | size_t Order(void) const
method Memory (line 821) | size_t Memory(void) const
method taylor_size (line 834) | size_t taylor_size(void) const
method use_VecAD (line 839) | bool use_VecAD(void) const
method size_taylor (line 844) | size_t size_taylor(void) const
FILE: include/cppad/core/ad_io.hpp
type CppAD (line 153) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 174) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 196) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 214) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
FILE: include/cppad/core/ad_to_string.hpp
type CppAD (line 52) | namespace CppAD {
type to_string_struct< CppAD::AD<Base> > (line 57) | struct to_string_struct< CppAD::AD<Base> >
FILE: include/cppad/core/ad_type.hpp
type CppAD (line 34) | namespace CppAD {
type local (line 46) | namespace local {
FILE: include/cppad/core/add.hpp
type CppAD (line 9) | namespace CppAD {
FILE: include/cppad/core/add_eq.hpp
type CppAD (line 9) | namespace CppAD {
FILE: include/cppad/core/atan2.hpp
type CppAD (line 72) | namespace CppAD { // BEGIN CppAD namespace
function atan2 (line 74) | inline float atan2(float x, float y)
function atan2 (line 77) | inline double atan2(double x, double y)
function atan2 (line 83) | AD<Base> atan2 (const AD<Base> &y, const AD<Base> &x)
function atan2 (line 128) | AD<Base> atan2 (const VecAD_reference<Base> &y, const AD<Base> &x)
function atan2 (line 132) | AD<Base> atan2 (const AD<Base> &y, const VecAD_reference<Base> &x)
function atan2 (line 136) | AD<Base> atan2
FILE: include/cppad/core/atomic/four/atomic.hpp
type CppAD (line 139) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class atomic_four (line 146) | class atomic_four {
type work_struct (line 160) | struct work_struct {
method atomic_index (line 182) | size_t atomic_index(void) const
method atomic_name (line 340) | const std::string atomic_name(void) const
method allocate_work (line 365) | void allocate_work(size_t thread)
method free_work (line 379) | void free_work(size_t thread)
method atomic_four (line 393) | static atomic_four* class_object(size_t index)
method class_name (line 403) | static const std::string class_name(size_t index)
method set_old (line 419) | virtual void set_old(size_t id)
FILE: include/cppad/core/atomic/four/call.hpp
type CppAD (line 99) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/four/ctor.hpp
type CppAD (line 100) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/four/devel/hes_sparsity.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/four/devel/jac_sparsity.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/four/for_type.hpp
type CppAD (line 123) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/four/forward.hpp
type CppAD (line 266) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/four/hes_sparsity.hpp
type CppAD (line 133) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/four/jac_sparsity.hpp
type CppAD (line 150) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/four/rev_depend.hpp
type CppAD (line 120) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/four/reverse.hpp
type CppAD (line 319) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/one/atomic.hpp
type CppAD (line 770) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class user_atomic (line 846) | class user_atomic : public atomic_base<Base> {
class atomic_one (line 856) | class atomic_one : public atomic_base<Base> {
method clear (line 859) | static void clear(void)
method atomic_one (line 960) | atomic_one(const char* afun, F f, R r, FJS fjs, RJS rjs, RHS rhs) :
method set_old (line 999) | virtual void set_old(size_t id)
method forward (line 1006) | virtual bool forward(
method reverse (line 1047) | virtual bool reverse(
method for_sparse_jac (line 1065) | virtual bool for_sparse_jac(
method rev_sparse_jac (line 1081) | virtual bool rev_sparse_jac(
method rev_sparse_hes (line 1096) | virtual bool rev_sparse_hes(
FILE: include/cppad/core/atomic/three/afun.hpp
type CppAD (line 78) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/three/atomic.hpp
type CppAD (line 213) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class atomic_three (line 220) | class atomic_three {
type work_struct (line 234) | struct work_struct {
method atomic_index (line 254) | size_t atomic_index(void) const
method atomic_name (line 391) | const std::string atomic_name(void) const
method allocate_work (line 416) | void allocate_work(size_t thread)
method free_work (line 430) | void free_work(size_t thread)
method atomic_three (line 444) | static atomic_three* class_object(size_t index)
method class_name (line 454) | static const std::string class_name(size_t index)
method set_old (line 470) | virtual void set_old(size_t id)
FILE: include/cppad/core/atomic/three/ctor.hpp
type CppAD (line 104) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/three/for_type.hpp
type CppAD (line 84) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/three/forward.hpp
type CppAD (line 296) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/three/hes_sparsity.hpp
type CppAD (line 106) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/three/jac_sparsity.hpp
type CppAD (line 120) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/three/rev_depend.hpp
type CppAD (line 97) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/three/reverse.hpp
type CppAD (line 305) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/afun.hpp
type CppAD (line 65) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/atomic.hpp
type CppAD (line 152) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class atomic_base (line 159) | class atomic_base {
type option_enum (line 162) | enum option_enum {
method atomic_index (line 169) | size_t atomic_index(void) const
type work_struct (line 188) | struct work_struct {
type option_enum (line 233) | enum option_enum
method option_enum (line 519) | option_enum sparsity(void) const
method atomic_name (line 523) | const std::string atomic_name(void) const
method allocate_work (line 548) | void allocate_work(size_t thread)
method free_work (line 562) | void free_work(size_t thread)
method atomic_base (line 576) | static atomic_base* class_object(size_t index)
method class_name (line 586) | static const std::string class_name(size_t index)
method set_old (line 602) | virtual void set_old(size_t id)
FILE: include/cppad/core/atomic/two/clear.hpp
type CppAD (line 46) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/ctor.hpp
type CppAD (line 104) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/for_sparse_hes.hpp
type CppAD (line 116) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/for_sparse_jac.hpp
type CppAD (line 109) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/forward.hpp
type CppAD (line 253) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/option.hpp
type CppAD (line 76) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
type option_enum (line 89) | enum option_enum
FILE: include/cppad/core/atomic/two/rev_depend.hpp
type CppAD (line 7) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/rev_sparse_hes.hpp
type CppAD (line 196) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/rev_sparse_jac.hpp
type CppAD (line 116) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/atomic/two/reverse.hpp
type CppAD (line 269) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/azmul.hpp
type CppAD (line 84) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function azmul (line 88) | AD<Base>
function azmul (line 227) | AD<Base>
function azmul (line 231) | AD<Base>
function azmul (line 235) | AD<Base>
function azmul (line 241) | AD<Base>
function azmul (line 245) | AD<Base>
function azmul (line 249) | AD<Base>
function azmul (line 253) | AD<Base>
FILE: include/cppad/core/base2ad.hpp
type CppAD (line 67) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/base_complex.hpp
type CppAD (line 63) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 92) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 108) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 124) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 153) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 173) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 184) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 203) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 218) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 247) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 271) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 286) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 298) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
type CppAD (line 326) | namespace CppAD {
function EqualOpSeq (line 109) | inline bool EqualOpSeq(
function IdenticalCon (line 125) | inline bool IdenticalCon(const std::complex<double> &x)
function IdenticalZero (line 127) | inline bool IdenticalZero(const std::complex<double> &x)
function IdenticalOne (line 129) | inline bool IdenticalOne(const std::complex<double> &x)
function IdenticalEqualCon (line 131) | inline bool IdenticalEqualCon(
function abs_geq (line 158) | inline bool abs_geq(
function Integer (line 174) | inline int Integer(const std::complex<double> &x)
function isnan (line 204) | inline bool isnan(const std::complex<double>& z)
function pow (line 272) | inline std::complex<double> pow(
function CondExpOp (line 328) | inline std::complex<float> CondExpOp(
function EqualOpSeq (line 344) | inline bool EqualOpSeq(
function IdenticalCon (line 350) | inline bool IdenticalCon(const std::complex<float> &x)
function IdenticalZero (line 352) | inline bool IdenticalZero(const std::complex<float> &x)
function IdenticalOne (line 354) | inline bool IdenticalOne(const std::complex<float> &x)
function IdenticalEqualCon (line 356) | inline bool IdenticalEqualCon(
function abs_geq (line 364) | inline bool abs_geq(
function Integer (line 369) | inline int Integer(const std::complex<float> &x)
function isnan (line 372) | inline bool isnan(const std::complex<float>& z)
function pow (line 390) | inline std::complex<float> pow(
FILE: include/cppad/core/base_cond_exp.hpp
type CppAD (line 144) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function ResultType (line 225) | ResultType CondExpTemplate(
FILE: include/cppad/core/base_double.hpp
type CppAD (line 28) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 46) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 61) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 73) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 90) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 101) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 112) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 137) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 166) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 179) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 200) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
type CppAD (line 212) | namespace CppAD {
function CondExpOp (line 29) | inline double CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const double& x, const double& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const double& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const double& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const double& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const double& x, const double& y)
function Integer (line 91) | inline int Integer(const double& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const double& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const double& x)
function LessThanZero (line 117) | inline bool LessThanZero(const double& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const double& x)
function abs_geq (line 121) | inline bool abs_geq(const double& x, const double& y)
function abs (line 167) | inline double abs(const double& x)
function sign (line 180) | inline double sign(const double& x)
FILE: include/cppad/core/base_float.hpp
type CppAD (line 28) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 46) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 61) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 73) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 90) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 101) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 112) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 137) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 167) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 180) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 200) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
type CppAD (line 212) | namespace CppAD {
function CondExpOp (line 29) | inline float CondExpOp(
function EqualOpSeq (line 62) | inline bool EqualOpSeq(const float& x, const float& y)
function IdenticalCon (line 74) | inline bool IdenticalCon(const float& x)
function IdenticalZero (line 76) | inline bool IdenticalZero(const float& x)
function IdenticalOne (line 78) | inline bool IdenticalOne(const float& x)
function IdenticalEqualCon (line 80) | inline bool IdenticalEqualCon(const float& x, const float& y)
function Integer (line 91) | inline int Integer(const float& x)
function GreaterThanZero (line 113) | inline bool GreaterThanZero(const float& x)
function GreaterThanOrZero (line 115) | inline bool GreaterThanOrZero(const float& x)
function LessThanZero (line 117) | inline bool LessThanZero(const float& x)
function LessThanOrZero (line 119) | inline bool LessThanOrZero(const float& x)
function abs_geq (line 121) | inline bool abs_geq(const float& x, const float& y)
function abs (line 168) | inline float abs(const float& x)
function sign (line 181) | inline float sign(const float& x)
FILE: include/cppad/core/base_std_math.hpp
type CppAD (line 135) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/bender_quad.hpp
type CppAD (line 309) | namespace CppAD { // BEGIN CppAD namespace
function BenderQuad (line 312) | void BenderQuad(
FILE: include/cppad/core/bool_fun.hpp
type CppAD (line 142) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/capacity_order.hpp
type CppAD (line 112) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/check_for_nan.hpp
type CppAD (line 136) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function put_check_for_nan (line 168) | void put_check_for_nan(const CppAD::vector<Base>& vec, std::string& fi...
function get_check_for_nan (line 196) | void get_check_for_nan(CppAD::vector<Base>& vec, const std::string& fi...
FILE: include/cppad/core/chkpoint_one/chkpoint_one.hpp
type CppAD (line 10) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class checkpoint (line 255) | class checkpoint : public atomic_base<Base> {
type member_struct (line 265) | struct member_struct {
method allocate_member (line 287) | void allocate_member(size_t thread)
method free_member (line 298) | void free_member(size_t thread)
method option_enum (line 306) | option_enum sparsity(void)
method size_var (line 415) | size_t size_var(void)
FILE: include/cppad/core/chkpoint_one/ctor.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_one/for_sparse_jac.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_one/forward.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_one/rev_sparse_hes.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_one/rev_sparse_jac.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_one/reverse.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_one/set_hes_sparse_bool.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_one/set_hes_sparse_set.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_one/set_jac_sparse_bool.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_one/set_jac_sparse_set.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_two/chkpoint_two.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class chkpoint_two (line 107) | class chkpoint_two : public atomic_three<Base> {
type member_struct (line 142) | struct member_struct {
method allocate_member (line 157) | void allocate_member(size_t thread)
method free_member (line 178) | void free_member(size_t thread)
method chkpoint_two (line 284) | chkpoint_two(const chkpoint_two& other)
FILE: include/cppad/core/chkpoint_two/ctor.hpp
type CppAD (line 86) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_two/dynamic.hpp
type CppAD (line 64) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function else (line 93) | else if( thread_alloc::in_parallel() )
FILE: include/cppad/core/chkpoint_two/for_type.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_two/forward.hpp
type CppAD (line 7) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function else (line 54) | else if( thread_alloc::in_parallel() )
function else (line 110) | else if( thread_alloc::in_parallel() )
FILE: include/cppad/core/chkpoint_two/hes_sparsity.hpp
type CppAD (line 7) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_two/jac_sparsity.hpp
type CppAD (line 7) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_two/rev_depend.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/chkpoint_two/reverse.hpp
type CppAD (line 7) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function else (line 55) | else if( thread_alloc::in_parallel() )
FILE: include/cppad/core/compare.hpp
type CppAD (line 112) | namespace CppAD {
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 115) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 211) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 403) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 499) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
FILE: include/cppad/core/con_dyn_var.hpp
type CppAD (line 89) | namespace CppAD {
function Constant (line 93) | bool Constant(const AD<Base> &x)
function Constant (line 103) | bool Constant(const VecAD<Base> &x)
function Dynamic (line 114) | bool Dynamic(const AD<Base> &x)
function Dynamic (line 124) | bool Dynamic(const VecAD<Base> &x)
function Parameter (line 135) | bool Parameter(const AD<Base> &x)
function Parameter (line 145) | bool Parameter(const VecAD<Base> &x)
function Variable (line 156) | bool Variable(const AD<Base> &x)
function Variable (line 166) | bool Variable(const VecAD<Base> &x)
FILE: include/cppad/core/cond_exp.hpp
type CppAD (line 161) | namespace CppAD {
function CondExpOp (line 164) | AD<Base> CondExpOp(
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 218) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
FILE: include/cppad/core/dependent.hpp
type CppAD (line 131) | namespace CppAD {
FILE: include/cppad/core/discrete/discrete.hpp
type CppAD (line 14) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class discrete (line 95) | class discrete {
method list_size (line 169) | static size_t list_size(void)
method discrete (line 217) | discrete(const std::string& name, Fun f) :
method ad (line 250) | AD<Base> ad(const AD<Base> &ax) const
method index (line 325) | static size_t index(const std::string& name)
method Base (line 399) | static Base eval(size_t index, const Base& x)
method ad_eval (line 437) | static AD<Base> ad_eval(size_t index, const AD<Base>& ax)
FILE: include/cppad/core/div.hpp
type CppAD (line 9) | namespace CppAD {
FILE: include/cppad/core/div_eq.hpp
type CppAD (line 9) | namespace CppAD {
FILE: include/cppad/core/epsilon.hpp
type CppAD (line 47) | namespace CppAD {
function Type (line 50) | inline Type epsilon(void)
FILE: include/cppad/core/equal_op_seq.hpp
type CppAD (line 86) | namespace CppAD {
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 88) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
FILE: include/cppad/core/for_hes_sparsity.hpp
type CppAD (line 124) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/for_jac_sparsity.hpp
type CppAD (line 172) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/for_one.hpp
type CppAD (line 115) | namespace CppAD {
function Vector (line 119) | Vector ADFun<Base,RecBase>::ForOne(const Vector &x, size_t j)
FILE: include/cppad/core/for_sparse_hes.hpp
type CppAD (line 147) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function SetVector (line 433) | SetVector ADFun<Base,RecBase>::ForSparseHes(
FILE: include/cppad/core/for_sparse_jac.hpp
type CppAD (line 223) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function SetVector (line 574) | SetVector ADFun<Base,RecBase>::ForSparseJac(
FILE: include/cppad/core/for_two.hpp
type CppAD (line 140) | namespace CppAD {
function BaseVector (line 144) | BaseVector ADFun<Base,RecBase>::ForTwo(
FILE: include/cppad/core/forward/forward.hpp
type CppAD (line 13) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function BaseVector (line 97) | BaseVector ADFun<Base,RecBase>::Forward(
function BaseVector (line 407) | BaseVector ADFun<Base,RecBase>::Forward(
FILE: include/cppad/core/fun_check.hpp
type CppAD (line 194) | namespace CppAD {
function FunCheck (line 196) | bool FunCheck(
FILE: include/cppad/core/fun_construct.hpp
type CppAD (line 221) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/graph/cpp_graph.hpp
type CppAD (line 13) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class cpp_graph (line 15) | class cpp_graph { // BEGIN_CPP_GRAPH_CLASS
method const_iterator (line 33) | const_iterator begin(void) const
method const_iterator (line 37) | const_iterator end(void)
method initialize (line 91) | void initialize(void)
method cpp_graph (line 104) | cpp_graph(void)
method function_name_set (line 166) | void function_name_set(const std::string& function_name)
method n_dynamic_ind_set (line 172) | void n_dynamic_ind_set(const size_t n_dynamic_ind)
method n_variable_ind_set (line 178) | void n_variable_ind_set(const size_t n_variable_ind)
method discrete_name_vec_size (line 322) | size_t discrete_name_vec_size(void) const
method discrete_name_vec_push_back (line 324) | void discrete_name_vec_push_back(const std::string& discrete_name)
method discrete_name_vec_find (line 326) | size_t discrete_name_vec_find(const std::string& discrete_name) const
method atomic_name_vec_size (line 336) | size_t atomic_name_vec_size(void) const
method atomic_name_vec_push_back (line 338) | void atomic_name_vec_push_back(const std::string& atomic_name)
method atomic_name_vec_find (line 340) | size_t atomic_name_vec_find(const std::string& atomic_name) const
method print_text_vec_size (line 350) | size_t print_text_vec_size(void) const
method print_text_vec_push_back (line 352) | void print_text_vec_push_back(const std::string& atomic_name)
method print_text_vec_find (line 354) | size_t print_text_vec_find(const std::string& print_text) const
method constant_vec_size (line 364) | size_t constant_vec_size(void) const
method constant_vec_push_back (line 366) | void constant_vec_push_back(const double& constant)
method graph_op_enum (line 370) | const graph_op_enum& operator_vec_get(size_t index) const
method operator_vec_size (line 372) | size_t operator_vec_size(void) const
method operator_vec_push_back (line 374) | void operator_vec_push_back(const graph_op_enum op_enum)
method operator_arg_size (line 380) | size_t operator_arg_size(void) const
method operator_arg_push_back (line 382) | void operator_arg_push_back(const size_t argument)
method dependent_vec_size (line 388) | size_t dependent_vec_size(void) const
method dependent_vec_push_back (line 390) | void dependent_vec_push_back(const size_t node_index)
method print (line 428) | void print(std::ostream& os) const
FILE: include/cppad/core/graph/from_graph.hpp
type CppAD (line 12) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/graph/graph_op_enum.hpp
type CppAD (line 180) | namespace CppAD { namespace graph {
type graph (line 180) | namespace graph {
type graph_op_enum (line 181) | enum graph_op_enum {
FILE: include/cppad/core/hash_code.hpp
type CppAD (line 13) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function hash_code (line 37) | unsigned short hash_code(const Value& value)
function hash_code (line 53) | unsigned short hash_code(const AD<Base>& u)
FILE: include/cppad/core/hessian.hpp
type CppAD (line 134) | namespace CppAD {
function Vector (line 138) | Vector ADFun<Base,RecBase>::Hessian(const Vector &x, size_t l)
function Vector (line 156) | Vector ADFun<Base,RecBase>::Hessian(const Vector &x, const Vector &w)
FILE: include/cppad/core/identical.hpp
type CppAD (line 10) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function IdenticalCon (line 36) | bool IdenticalCon(const AD<Base> &x)
function IdenticalZero (line 51) | bool IdenticalZero(const AD<Base> &x)
function IdenticalOne (line 66) | bool IdenticalOne(const AD<Base> &x)
function IdenticalEqualCon (line 84) | bool IdenticalEqualCon
FILE: include/cppad/core/independent/independent.hpp
type CppAD (line 9) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function Independent (line 61) | void Independent(
function Independent (line 130) | void Independent(ADVector &x, size_t abort_op_index, bool record_compare)
function Independent (line 179) | void Independent(ADVector &x, size_t abort_op_index)
function Independent (line 228) | void Independent(ADVector& x, ADVector& dynamic)
function Independent (line 273) | void Independent(ADVector &x)
FILE: include/cppad/core/integer.hpp
type CppAD (line 89) | namespace CppAD {
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 92) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 97) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
FILE: include/cppad/core/jacobian.hpp
type CppAD (line 105) | namespace CppAD {
function JacobianFor (line 108) | void JacobianFor(ADFun<Base, RecBase> &f, const Vector &x, Vector &jac)
function JacobianRev (line 146) | void JacobianRev(ADFun<Base, RecBase> &f, const Vector &x, Vector &jac)
function Vector (line 191) | Vector ADFun<Base,RecBase>::Jacobian(const Vector &x)
FILE: include/cppad/core/lu_ratio.hpp
type CppAD (line 208) | namespace CppAD { // BEGIN CppAD namespace
function LuRatio (line 212) | int LuRatio(SizeVector &ip, SizeVector &jp, ADvector &LU, AD<Base> &ra...
FILE: include/cppad/core/mul.hpp
type CppAD (line 9) | namespace CppAD {
FILE: include/cppad/core/mul_eq.hpp
type CppAD (line 9) | namespace CppAD {
FILE: include/cppad/core/near_equal_ext.hpp
type CppAD (line 120) | namespace CppAD {
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 125) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 132) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 139) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 147) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 154) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 160) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 166) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 172) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
FILE: include/cppad/core/new_dynamic.hpp
type CppAD (line 81) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/num_skip.hpp
type CppAD (line 60) | namespace CppAD {
FILE: include/cppad/core/numeric_limits.hpp
type CppAD (line 172) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class numeric_limits (line 180) | class numeric_limits {
method Float (line 183) | static Float epsilon(void)
method Float (line 191) | static Float min(void)
method Float (line 199) | static Float max(void)
method Float (line 207) | static Float quiet_NaN(void)
method Float (line 215) | static Float infinity(void)
class numeric_limits< AD<Base> > (line 228) | class numeric_limits< AD<Base> > {
method epsilon (line 231) | static AD<Base> epsilon(void)
method min (line 234) | static AD<Base> min(void)
method max (line 237) | static AD<Base> max(void)
method quiet_NaN (line 240) | static AD<Base> quiet_NaN(void)
method infinity (line 243) | static AD<Base> infinity(void)
FILE: include/cppad/core/omp_max_thread.hpp
type CppAD (line 67) | namespace CppAD {
FILE: include/cppad/core/opt_val_hes.hpp
type CppAD (line 238) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function opt_val_hes (line 366) | int opt_val_hes(
FILE: include/cppad/core/optimize.hpp
type CppAD (line 244) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/ordered.hpp
type CppAD (line 10) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 28) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 42) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 56) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 70) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 88) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
FILE: include/cppad/core/parallel_ad.hpp
type CppAD (line 101) | namespace CppAD {
function parallel_ad (line 109) | void parallel_ad(void)
FILE: include/cppad/core/pow.hpp
type CppAD (line 104) | namespace CppAD {
function pow (line 107) | AD<Base>
function pow (line 233) | AD<Base>
function pow (line 237) | AD<Base>
function pow (line 241) | AD<Base>
function pow (line 247) | AD<Base>
function pow (line 251) | AD<Base>
function pow (line 255) | AD<Base>
function pow (line 259) | AD<Base>
function pow (line 265) | AD<Base>
function pow (line 269) | AD<Base>
function pow (line 273) | AD<Base>
function pow (line 277) | AD<Base>
function pow (line 283) | inline AD<double>
function pow (line 287) | inline AD<double>
function pow (line 291) | inline AD<double>
function pow (line 295) | inline AD<double>
function pow (line 303) | AD<Base> pow
function pow (line 307) | AD<Base> pow
FILE: include/cppad/core/print_for.hpp
type CppAD (line 132) | namespace CppAD {
function PrintFor (line 134) | void PrintFor(
function PrintFor (line 191) | void PrintFor(const char* before, const AD<Base>& value)
function PrintFor (line 195) | void PrintFor(const char* before, const VecAD_reference<Base>& value)
function PrintFor (line 199) | void PrintFor(
function PrintFor (line 207) | void PrintFor(
function PrintFor (line 215) | void PrintFor(
FILE: include/cppad/core/rev_hes_sparsity.hpp
type CppAD (line 128) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/rev_jac_sparsity.hpp
type CppAD (line 122) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/rev_one.hpp
type CppAD (line 118) | namespace CppAD {
function Vector (line 122) | Vector ADFun<Base,RecBase>::RevOne(const Vector &x, size_t i)
FILE: include/cppad/core/rev_sparse_hes.hpp
type CppAD (line 191) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function SetVector (line 503) | SetVector ADFun<Base,RecBase>::RevSparseHes(
FILE: include/cppad/core/rev_sparse_jac.hpp
type CppAD (line 169) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function SetVector (line 492) | SetVector ADFun<Base,RecBase>::RevSparseJac(
FILE: include/cppad/core/rev_two.hpp
type CppAD (line 141) | namespace CppAD {
function BaseVector (line 145) | BaseVector ADFun<Base,RecBase>::RevTwo(
FILE: include/cppad/core/reverse.hpp
type CppAD (line 12) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function BaseVector (line 85) | BaseVector ADFun<Base,RecBase>::Reverse(size_t q, const BaseVector &w)
FILE: include/cppad/core/sign.hpp
type CppAD (line 69) | namespace CppAD {
function sign (line 114) | AD<Base> sign(const AD<Base> &x)
function sign (line 118) | AD<Base> sign(const VecAD_reference<Base> &x)
FILE: include/cppad/core/sparse_hes.hpp
type CppAD (line 248) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class sparse_hes_work (line 254) | class sparse_hes_work {
method sparse_hes_work (line 266) | sparse_hes_work(void)
method clear (line 269) | void clear(void)
FILE: include/cppad/core/sparse_hessian.hpp
type CppAD (line 326) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class sparse_hessian_work (line 336) | class sparse_hessian_work {
method sparse_hessian_work (line 351) | sparse_hessian_work(void) : color_method("cppad.symmetric")
method clear (line 354) | void clear(void)
function BaseVector (line 751) | BaseVector ADFun<Base,RecBase>::SparseHessian(
function BaseVector (line 837) | BaseVector ADFun<Base,RecBase>::SparseHessian(const BaseVector &x, con...
FILE: include/cppad/core/sparse_jac.hpp
type CppAD (line 225) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class sparse_jac_work (line 230) | class sparse_jac_work {
method sparse_jac_work (line 238) | sparse_jac_work(void)
method clear (line 242) | void clear(void)
FILE: include/cppad/core/sparse_jacobian.hpp
type CppAD (line 274) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class sparse_jacobian_work (line 284) | class sparse_jacobian_work {
method sparse_jacobian_work (line 295) | sparse_jacobian_work(void) : color_method("cppad")
method clear (line 299) | void clear(void)
function BaseVector (line 929) | BaseVector ADFun<Base,RecBase>::SparseJacobian(
function BaseVector (line 1044) | BaseVector ADFun<Base,RecBase>::SparseJacobian( const BaseVector& x )
FILE: include/cppad/core/std_math_11.hpp
type CppAD (line 773) | namespace CppAD {
function erf (line 797) | inline AD<Base> erf(const AD<Base> &x)
function erfc (line 802) | inline AD<Base> erfc(const AD<Base> &x)
function erf (line 865) | inline AD<Base> erf(const VecAD_reference<Base> &x)
function erfc (line 870) | inline AD<Base> erfc(const VecAD_reference<Base> &x)
function log10 (line 889) | inline AD<Base> log10(const AD<Base> &x)
function log10 (line 892) | inline AD<Base> log10(const VecAD_reference<Base> &x)
FILE: include/cppad/core/sub.hpp
type CppAD (line 9) | namespace CppAD {
FILE: include/cppad/core/sub_eq.hpp
type CppAD (line 9) | namespace CppAD {
FILE: include/cppad/core/subgraph_jac_rev.hpp
type CppAD (line 178) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/subgraph_reverse.hpp
type CppAD (line 159) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/subgraph_sparsity.hpp
type CppAD (line 142) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/core/tape_link.hpp
type CppAD (line 15) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
function tape_id_t (line 40) | tape_id_t* AD<Base>::tape_id_ptr(size_t thread)
FILE: include/cppad/core/to_csrc.hpp
type CppAD (line 184) | namespace CppAD {
FILE: include/cppad/core/unary_minus.hpp
type CppAD (line 73) | namespace CppAD {
FILE: include/cppad/core/unary_plus.hpp
type CppAD (line 69) | namespace CppAD {
FILE: include/cppad/core/value.hpp
type CppAD (line 69) | namespace CppAD {
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 72) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
FILE: include/cppad/core/var2par.hpp
type CppAD (line 61) | namespace CppAD {
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 64) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
function CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION (line 72) | CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
FILE: include/cppad/core/vec_ad/vec_ad.hpp
type CppAD (line 8) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class VecAD_reference (line 156) | class VecAD_reference {
method VecAD_reference (line 168) | VecAD_reference(VecAD<Base>& vec, const AD<Base>& ind)
method CPPAD_VEC_AD_COMP_ASSIGN (line 179) | CPPAD_VEC_AD_COMP_ASSIGN( += )
class VecAD (line 365) | class VecAD {
method VecAD (line 390) | VecAD(void)
method VecAD (line 396) | VecAD(size_t length)
method size (line 420) | size_t size(void)
method Base (line 424) | Base& operator[](size_t i)
FILE: include/cppad/core/zdouble.hpp
type CppAD (line 209) | namespace CppAD { // CPPAD_BEGIN_NAMESPACDE
class zdouble (line 215) | class zdouble {
method zdouble (line 262) | zdouble(void)
method zdouble (line 266) | zdouble(const zdouble& z)
method zdouble (line 270) | zdouble(const double& dbl)
method zdouble (line 274) | zdouble(const size_t& i)
method zdouble (line 278) | zdouble(const long& i)
method zdouble (line 282) | zdouble(const int& i)
method zdouble (line 291) | zdouble& operator=(const zdouble& z)
method zdouble (line 296) | zdouble& operator=(const double& dbl)
method CPPAD_ZDOUBLE_NORMAL_ASSIGN_OPERATOR (line 302) | CPPAD_ZDOUBLE_NORMAL_ASSIGN_OPERATOR(+=)
method zdouble (line 333) | zdouble operator * (const double& x) const
method zdouble (line 338) | zdouble operator / (const zdouble& z) const
method zdouble (line 343) | zdouble operator / (const double& x) const
method zdouble (line 349) | zdouble& operator *= (const zdouble& z)
method zdouble (line 355) | zdouble& operator *= (const double& x)
method zdouble (line 362) | zdouble& operator /= (const zdouble& z)
method zdouble (line 368) | zdouble& operator /= (const double& x)
function zdouble (line 376) | inline
method zdouble (line 262) | zdouble(void)
method zdouble (line 266) | zdouble(const zdouble& z)
method zdouble (line 270) | zdouble(const double& dbl)
method zdouble (line 274) | zdouble(const size_t& i)
method zdouble (line 278) | zdouble(const long& i)
method zdouble (line 282) | zdouble(const int& i)
method zdouble (line 291) | zdouble& operator=(const zdouble& z)
method zdouble (line 296) | zdouble& operator=(const double& dbl)
method CPPAD_ZDOUBLE_NORMAL_ASSIGN_OPERATOR (line 302) | CPPAD_ZDOUBLE_NORMAL_ASSIGN_OPERATOR(+=)
method zdouble (line 333) | zdouble operator * (const double& x) const
method zdouble (line 338) | zdouble operator / (const zdouble& z) const
method zdouble (line 343) | zdouble operator / (const double& x) const
method zdouble (line 349) | zdouble& operator *= (const zdouble& z)
method zdouble (line 355) | zdouble& operator *= (const double& x)
method zdouble (line 362) | zdouble& operator /= (const zdouble& z)
method zdouble (line 368) | zdouble& operator /= (const double& x)
function EqualOpSeq (line 422) | inline bool EqualOpSeq(const zdouble& x, const zdouble& y)
function IdenticalCon (line 426) | inline bool IdenticalCon(const zdouble& x)
function IdenticalZero (line 428) | inline bool IdenticalZero(const zdouble& x)
function IdenticalOne (line 430) | inline bool IdenticalOne(const zdouble& x)
function IdenticalEqualCon (line 432) | inline bool IdenticalEqualCon(const zdouble& x, const zdouble& y)
function Integer (line 442) | inline int Integer(const zdouble& x)
function zdouble (line 446) | inline zdouble azmul(const zdouble& x, const zdouble& y)
function GreaterThanZero (line 450) | inline bool GreaterThanZero(const zdouble& x)
function GreaterThanOrZero (line 452) | inline bool GreaterThanOrZero(const zdouble& x)
function LessThanZero (line 454) | inline bool LessThanZero(const zdouble& x)
function LessThanOrZero (line 456) | inline bool LessThanOrZero(const zdouble& x)
function abs_geq (line 458) | inline bool abs_geq(const zdouble& x, const zdouble& y)
function zdouble (line 506) | inline zdouble abs(const zdouble& x)
function zdouble (line 510) | inline zdouble sign(const zdouble& x)
function zdouble (line 519) | inline zdouble pow(const zdouble& x, const zdouble& y)
FILE: include/cppad/example/atomic_four/lin_ode/base_solver.hpp
type CppAD (line 62) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class Fun (line 76) | class Fun {
method Fun (line 82) | Fun(
method Ode (line 88) | void Ode(
method Ode_ind (line 109) | void Ode_ind(
method Ode_dep (line 125) | void Ode_dep(
FILE: include/cppad/example/atomic_four/lin_ode/for_type.hpp
type CppAD (line 133) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/lin_ode/forward.hpp
type CppAD (line 93) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/lin_ode/get.hpp
type CppAD (line 68) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/lin_ode/hes_sparsity.hpp
type CppAD (line 80) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/lin_ode/jac_sparsity.hpp
type CppAD (line 184) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/lin_ode/lin_ode.hpp
type CppAD (line 24) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class atomic_lin_ode (line 27) | class atomic_lin_ode : public CppAD::atomic_four<Base> {
method atomic_lin_ode (line 35) | atomic_lin_ode(const std::string& name) :
method test_rev_depend (line 78) | bool test_rev_depend(
type call_struct (line 90) | struct call_struct {
type thread_struct (line 96) | struct thread_struct {
FILE: include/cppad/example/atomic_four/lin_ode/rev_depend.hpp
type CppAD (line 67) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/lin_ode/reverse.hpp
type CppAD (line 199) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/lin_ode/set.hpp
type CppAD (line 68) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/mat_mul/base_mat_mul.hpp
type CppAD (line 25) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/mat_mul/for_type.hpp
type CppAD (line 31) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/mat_mul/forward.hpp
type CppAD (line 31) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/mat_mul/get.hpp
type CppAD (line 58) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/mat_mul/hes_sparsity.hpp
type CppAD (line 36) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/mat_mul/jac_sparsity.hpp
type CppAD (line 36) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/mat_mul/mat_mul.hpp
type CppAD (line 24) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class atomic_mat_mul (line 27) | class atomic_mat_mul : public CppAD::atomic_four<Base> {
method atomic_mat_mul (line 31) | atomic_mat_mul(const std::string& name) :
type call_struct (line 56) | struct call_struct {
FILE: include/cppad/example/atomic_four/mat_mul/rev_depend.hpp
type CppAD (line 30) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/mat_mul/reverse.hpp
type CppAD (line 35) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/mat_mul/set.hpp
type CppAD (line 58) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/add_op.hpp
type CppAD (line 40) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/div_op.hpp
type CppAD (line 40) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/for_type.hpp
type CppAD (line 31) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/forward_op.hpp
type CppAD (line 35) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/hes_sparsity.hpp
type CppAD (line 36) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/jac_sparsity.hpp
type CppAD (line 36) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/mul_op.hpp
type CppAD (line 40) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/neg_op.hpp
type CppAD (line 30) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/rev_depend.hpp
type CppAD (line 36) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/reverse_op.hpp
type CppAD (line 35) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/sub_op.hpp
type CppAD (line 40) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
FILE: include/cppad/example/atomic_four/vector/vector.hpp
type CppAD (line 58) | namespace CppAD { // BEGIN_CPPAD_NAMESPACE
class atomic_vector (line 61) | class atomic_vector : public CppAD::atomic_four<Base> {
method atomic_vector (line 79) | atomic_vector(const std::string& name) :
method is_unary (line 88) | static bool is_unary(op_enum_t op)
method copy_vec_to_mat (line 106) | static void copy_vec_to_mat(
method copy_mat_to_vec (line 119) | static void copy_mat_to_vec(
FILE: include/cppad/example/atomic_three/mat_mul.hpp
class atomic_mat_mul (line 99) | class atomic_mat_mul : public CppAD::atomic_three<double> {
method atomic_mat_mul (line 109) | atomic_mat_mul(void) : CppAD::atomic_three<double>("mat_mul")
method left (line 119) | size_t left(
method right (line 138) | size_t right(
method result (line 158) | size_t result(
method forward_multiply (line 178) | void forward_multiply(
method reverse_multiply (line 224) | void reverse_multiply(
method for_type (line 275) | virtual bool for_type(
method forward (line 338) | virtual bool forward(
method reverse (line 388) | virtual bool reverse(
method jac_sparsity (line 433) | virtual bool jac_sparsity(
method hes_sparsity (line 535) | virtual bool hes_sparsity(
method rev_depend (line 623) | virtual bool rev_depend(
FILE: include/cppad/example/atomic_two/eigen_cholesky.hpp
class atomic_eigen_cholesky (line 40) | class atomic_eigen_cholesky : public CppAD::atomic_base<Base> {
method atomic_eigen_cholesky (line 64) | atomic_eigen_cholesky(void) : CppAD::atomic_base<Base>(
method ad_matrix (line 76) | ad_matrix op(const ad_matrix& arg)
method forward (line 131) | virtual bool forward(
method reverse (line 237) | virtual bool reverse(
FILE: include/cppad/example/atomic_two/eigen_mat_inv.hpp
class atomic_eigen_mat_inv (line 173) | class atomic_eigen_mat_inv : public CppAD::atomic_base<Base> {
method atomic_eigen_mat_inv (line 193) | atomic_eigen_mat_inv(void) : CppAD::atomic_base<Base>(
method ad_matrix (line 205) | ad_matrix op(const ad_matrix& arg)
method forward (line 252) | virtual bool forward(
method reverse (line 337) | virtual bool reverse(
FILE: include/cppad/example/atomic_two/eigen_mat_mul.hpp
class atomic_eigen_mat_mul (line 135) | class atomic_eigen_mat_mul : public CppAD::atomic_base<Base> {
method atomic_eigen_mat_mul (line 155) | atomic_eigen_mat_mul(void) : CppAD::atomic_base<Base>(
method ad_matrix (line 167) | ad_matrix op(
method forward (line 230) | virtual bool forward(
method reverse (line 345) | virtual bool reverse(
method for_sparse_jac (line 457) | virtual bool for_sparse_jac(
method rev_sparse_jac (line 509) | virtual bool rev_sparse_jac(
method for_sparse_hes (line 559) | virtual bool for_sparse_hes(
method rev_sparse_hes (line 615) | virtual bool rev_sparse_hes(
FILE: include/cppad/example/base_adolc.hpp
type CppAD (line 69) | namespace CppAD {
function adouble (line 70) | inline adouble CondExpOp(
function EqualOpSeq (line 132) | inline bool EqualOpSeq(const adouble &x, const adouble &y)
function IdenticalCon (line 152) | inline bool IdenticalCon(const adouble &x)
function IdenticalZero (line 154) | inline bool IdenticalZero(const adouble &x)
function IdenticalOne (line 156) | inline bool IdenticalOne(const adouble &x)
function IdenticalEqualCon (line 158) | inline bool IdenticalEqualCon(const adouble &x, const adouble &y)
function GreaterThanZero (line 188) | inline bool GreaterThanZero(const adouble &x)
function GreaterThanOrZero (line 190) | inline bool GreaterThanOrZero(const adouble &x)
function LessThanZero (line 192) | inline bool LessThanZero(const adouble &x)
function LessThanOrZero (line 194) | inline bool LessThanOrZero(const adouble &x)
function abs_geq (line 196) | inline bool abs_geq(const adouble& x, const adouble& y)
function adouble (line 257) | inline adouble sign(const adouble& x)
function adouble (line 277) | inline adouble abs(const adouble& x)
type to_string_struct<adouble> (line 307) | struct to_string_struct<adouble>
function hash_code (line 330) | inline unsigned short hash_code(const adouble& x)
type CppAD (line 118) | namespace CppAD {
function adouble (line 70) | inline adouble CondExpOp(
function EqualOpSeq (line 132) | inline bool EqualOpSeq(const adouble &x, const adouble &y)
function IdenticalCon (line 152) | inline bool IdenticalCon(const adouble &x)
function IdenticalZero (line 154) | inline bool IdenticalZero(const adouble &x)
function IdenticalOne (line 156) | inline bool IdenticalOne(const adouble &x)
function IdenticalEqualCon (line 158) | inline bool IdenticalEqualCon(const adouble &x, const adouble &y)
function GreaterThanZero (line 188) | inline bool GreaterThanZero(const adouble &x)
function GreaterThanOrZero (line 190) | inline bool GreaterThanOrZero(const adouble &x)
function LessThanZero (line 192) | inline bool LessThanZero(const adouble &x)
function LessThanOrZero (line 194) | inline bool LessThanOrZero(const adouble &x)
function abs_geq (line 196) | inline bool abs_geq(const adouble& x, const adouble& y)
function adouble (line 257) | inline adouble sign(const adouble& x)
function adouble (line 277) | inline adouble abs(const adouble& x)
type to_string_struct<adouble> (line 307) | struct to_string_struct<adouble>
function hash_code (line 330) | inline unsigned short hash_code(const adouble& x)
type CppAD (line 131) | namespace CppAD {
function adouble (line 70) | inline adouble CondExpOp(
function EqualOpSeq (line 132) | inline bool EqualOpSeq(const adouble &x, const adouble &y)
function IdenticalCon (line 152) | inline bool IdenticalCon(const adouble &x)
function IdenticalZero (line 154) | inline bool IdenticalZero(const adouble &x)
fun
Condensed preview — 1472 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (8,870K chars).
[
{
"path": ".circleci/config.yml",
"chars": 363,
"preview": "# https://circleci.com/docs/hello-world/\nversion: 2.1\n\njobs:\n hello-job:\n docker:\n - image: cimg/node:17.2.0 # "
},
{
"path": ".github/workflows/conda/conda-env.yml",
"chars": 87,
"preview": "name: cppad\nchannels:\n - conda-forge\n - nodefaults\ndependencies:\n - boost\n - python"
},
{
"path": ".github/workflows/conda-bash.yml",
"chars": 1709,
"preview": "name: conda-bash\n\non:\n pull_request:\n push:\n branches:\n - master\n - 'stable/*'\n\nenv:\n BUILD_TYPE: Releas"
},
{
"path": ".github/workflows/conda-windows-clang.yml",
"chars": 1957,
"preview": "name: conda-windows-clang\non:\n pull_request:\n push:\n branches:\n - master\n - 'stable/*'\n\nenv:\n # Customiz"
},
{
"path": ".github/workflows/conda-windows-eigen.yml",
"chars": 1881,
"preview": "name: conda-windows-eigen\non:\n push:\n branches:\n - master\n - 'stable/*'\n\njobs:\n build:\n runs-on: windo"
},
{
"path": ".github/workflows/conda-windows-v142.yml",
"chars": 1882,
"preview": "name: conda-windows-v142\non:\n pull_request:\n push:\n branches:\n - master\n - 'stable/*'\n\nenv:\n # Customize"
},
{
"path": ".github/workflows/ubuntu-macos.yml",
"chars": 1447,
"preview": "name: ubuntu-macos\non:\n pull_request:\n push:\n branches:\n - master\n - 'stable/*'\njobs:\n run_tests:\n ru"
},
{
"path": ".github/workflows/windows-msys2.yml",
"chars": 721,
"preview": "name: windows-msys2\n\non:\n pull_request:\n push:\n branches:\n - master\n - 'stable/*'\n\njobs:\n build:\n run"
},
{
"path": ".gitignore",
"chars": 892,
"preview": "# ----------------------------------------------------------------------------\n# specific files\n#\n#\n# cmake configure fi"
},
{
"path": ".readthedocs.yaml",
"chars": 1380,
"preview": "# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# {xrst_comment_ch #}\n#\n# Example Read t"
},
{
"path": ".travis.yml",
"chars": 598,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "CMakeLists.txt",
"chars": 24156,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "COPYING",
"chars": 589,
"preview": "-----------------------------------------------------------------------------\nCppAD: C++ Algorithmic Differentiation: Co"
},
{
"path": "appendix/addon.xrst",
"chars": 2416,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/appendix.xrst",
"chars": 673,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/bib.xrst",
"chars": 1261,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/deprecated/compare_change.xrst",
"chars": 2201,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/deprecated/deprecated.xrst",
"chars": 1618,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/deprecated/fun_deprecated.xrst",
"chars": 4688,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/deprecated/include_deprecated.xrst",
"chars": 2572,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/deprecated/omp_alloc.xrst",
"chars": 1341,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/directory.xrst",
"chars": 3122,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/faq.xrst",
"chars": 6522,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/glossary.xrst",
"chars": 8655,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/license.xrst",
"chars": 524,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/numeric_ad.xrst",
"chars": 608,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2003.xrst",
"chars": 20525,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2004.xrst",
"chars": 28393,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2005.xrst",
"chars": 26530,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2006.xrst",
"chars": 32332,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2007.xrst",
"chars": 26442,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2008.xrst",
"chars": 12826,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2009.xrst",
"chars": 16083,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2010.xrst",
"chars": 8796,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2011.xrst",
"chars": 28840,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2012.xrst",
"chars": 30581,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2013.xrst",
"chars": 16207,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2014.xrst",
"chars": 13311,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2015.xrst",
"chars": 28290,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2016.xrst",
"chars": 14339,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2017.xrst",
"chars": 18515,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2018.xrst",
"chars": 18493,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2019.xrst",
"chars": 24328,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2020.xrst",
"chars": 11832,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2021.xrst",
"chars": 10669,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2022.xrst",
"chars": 16316,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2023.xrst",
"chars": 7739,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/whats_new/2024.xrst",
"chars": 15342,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n"
},
{
"path": "appendix/whats_new/2025.xrst",
"chars": 4596,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n"
},
{
"path": "appendix/whats_new/2026.xrst",
"chars": 892,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n"
},
{
"path": "appendix/whats_new/whats_new.xrst",
"chars": 1880,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appendix/wish_list.xrst",
"chars": 9683,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "appveyor.yml",
"chars": 1086,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "authors",
"chars": 795,
"preview": " Statement of CppAD Authorship and Copyright\n ===========================================\n\nBradl"
},
{
"path": "batch_edit.sed",
"chars": 1630,
"preview": "# ----------------------------------------------------------------------------\n# None of the lists below can have white "
},
{
"path": "bin/appveyor.sh",
"chars": 1815,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/build.bat",
"chars": 205,
"preview": "if exist build ( rmdir /S build )\nmkdir build\ncd build\ncmake ^\n -G \"NMake Makefiles\"^\n -D cppad_cxx_flags=\"/MP /EH"
},
{
"path": "bin/check_addon.sh",
"chars": 1184,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_all.sh",
"chars": 10536,
"preview": "#! /usr/bin/env bash\nset -e -u\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley "
},
{
"path": "bin/check_copy.sh",
"chars": 4855,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/check_define.sh",
"chars": 2506,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_deprecated.sh",
"chars": 3402,
"preview": "#! /bin/bash -eu\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradb"
},
{
"path": "bin/check_doxygen.sh",
"chars": 585,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_example.sh",
"chars": 3042,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_if.sh",
"chars": 1434,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_include_def.sh",
"chars": 1843,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_include_file.sh",
"chars": 3102,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_include_xrst.sh",
"chars": 812,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_invisible.sh",
"chars": 2657,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/check_nominmax.sh",
"chars": 1005,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_op_code.sh",
"chars": 2107,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_sort.sh",
"chars": 2286,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/check_tab.sh",
"chars": 1985,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/check_tempfile.sh",
"chars": 867,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/check_trace.sh",
"chars": 1016,
"preview": "#! /usr/bin/env bash\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <b"
},
{
"path": "bin/check_user_def.py",
"chars": 3315,
"preview": "#! /usr/bin/env python3\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell"
},
{
"path": "bin/check_version.sh",
"chars": 4364,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/colpack.sh",
"chars": 5202,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/deprecate_xam.sh",
"chars": 2648,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/dev_settings.sh",
"chars": 4139,
"preview": "# ---------------------------------------------------------------------------\n# SPDX-License-Identifier: EPL-2.0 OR GPL-"
},
{
"path": "bin/dos_build.bat",
"chars": 3298,
"preview": "echo off\nrem SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\nrem SPDX-FileCopyrightText: Bradley M. Bell <bradbell@"
},
{
"path": "bin/doxyfile.sh",
"chars": 3122,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/get_adolc.sh",
"chars": 4439,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/get_colpack.sh",
"chars": 4354,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/get_cppadcg.sh",
"chars": 6249,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/get_fadbad.sh",
"chars": 2773,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/get_ipopt.sh",
"chars": 5371,
"preview": "#! /usr/bin/env bash\nset -e -u\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley "
},
{
"path": "bin/get_optional.sh",
"chars": 3633,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/get_sacado.sh",
"chars": 4589,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/git_commit.sh",
"chars": 4994,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# -------"
},
{
"path": "bin/grep_and_sed.sh",
"chars": 867,
"preview": "# ---------------------------------------------------------------------------\n# SPDX-License-Identifier: EPL-2.0 OR GPL-"
},
{
"path": "bin/group_list.sh",
"chars": 1018,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/master_revert.sh",
"chars": 1056,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/new_release.sh",
"chars": 9070,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/no_bitwise.sh",
"chars": 2631,
"preview": "#! /usr/bin/env bash\nset -e -u\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley "
},
{
"path": "bin/package.sh",
"chars": 1128,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/run_cmake.sh",
"chars": 9385,
"preview": "#! /usr/bin/env bash\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <b"
},
{
"path": "bin/run_configure.sh",
"chars": 3489,
"preview": "#! /usr/bin/env bash\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <b"
},
{
"path": "bin/run_doxygen.sh",
"chars": 1845,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/run_xrst.sh",
"chars": 3576,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/sort.sh",
"chars": 4627,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/speed_branch.sh",
"chars": 4617,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/speed_diff.sh",
"chars": 1850,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/speed_new.sh",
"chars": 2566,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/speed_package.sh",
"chars": 4787,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "bin/tag_month.sh",
"chars": 3362,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/test_install.sh",
"chars": 3534,
"preview": "#! /usr/bin/env bash\nset -e -u\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley "
},
{
"path": "bin/test_multi_thread.sh",
"chars": 2919,
"preview": "#! /usr/bin/env bash\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <b"
},
{
"path": "bin/test_one.sh.in",
"chars": 7521,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/trace.sh",
"chars": 1128,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/travis.sh",
"chars": 1557,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bin/twine.sh",
"chars": 2315,
"preview": "#! /usr/bin/env bash\nset -e -u\n# !! EDITS TO THIS FILE ARE LOST DURING UPDATES BY xrst.git/bin/dev_tools.sh !!\n# SPDX-Li"
},
{
"path": "bin/valgrind.sh",
"chars": 2017,
"preview": "#! /bin/bash -eu\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradb"
},
{
"path": "bug/boost_lu.sh",
"chars": 5016,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/clang_simple.sh",
"chars": 1316,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/cmake_target.sh",
"chars": 1159,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/cppad_cg.sh",
"chars": 4626,
"preview": "#! /bin/bash -e\n# $Id:$\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell"
},
{
"path": "bug/doxy_member.sh",
"chars": 2105,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/eigen_shadow.sh",
"chars": 1443,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/gcc_complex.sh",
"chars": 1340,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/numeric_limit.sh",
"chars": 5428,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/pow.sh",
"chars": 1988,
"preview": "#! /bin/bash -e\n# vim: set expandtab:\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: B"
},
{
"path": "bug/sparsity.sh",
"chars": 2500,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/std_vector.sh",
"chars": 1029,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/subgraph.sh",
"chars": 2338,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/template.sh",
"chars": 2182,
"preview": "#! /usr/bin/env bash\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <b"
},
{
"path": "bug/test_install.sh",
"chars": 1614,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "bug/vec_itr_speed.sh",
"chars": 5558,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "cmake/add_check_executable.cmake",
"chars": 3473,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/add_to_list.cmake",
"chars": 939,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/assert.cmake",
"chars": 684,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/assert_value_in_set.cmake",
"chars": 870,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/command_line_arg.cmake",
"chars": 1563,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/compile_source_test.cmake",
"chars": 2173,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/cppad_uninstall.cmake",
"chars": 1546,
"preview": "# Copyright (C) 2010 Olivier Stasse, JRL, CNRS, 2010\n#\n# Original source:\n# https://github.com/jrl-umi3218/jrl-cmakemodu"
},
{
"path": "cmake/dos_path_to_unix.cmake",
"chars": 661,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/eigen_info.cmake",
"chars": 1479,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/pkgconfig_info.cmake",
"chars": 2604,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/prefix_info.cmake",
"chars": 3293,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/print_variable.cmake",
"chars": 523,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/run_source_test.cmake",
"chars": 1619,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cmake/set_compile_flags.cmake",
"chars": 2805,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "configure",
"chars": 19950,
"preview": "#! /usr/bin/env bash\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <b"
},
{
"path": "cppad_ipopt/CMakeLists.txt",
"chars": 1081,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cppad_ipopt/example/CMakeLists.txt",
"chars": 1363,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cppad_ipopt/example/example.cpp",
"chars": 1170,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/example/get_started.cpp",
"chars": 5549,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/example/ode1.xrst",
"chars": 646,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cppad_ipopt/example/ode2.xrst",
"chars": 16579,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cppad_ipopt/example/ode_check.cpp",
"chars": 3156,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/example/ode_check.hpp",
"chars": 425,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_CHECK_HPP\n# define CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_CHECK_HPP\n// SPDX-License-Identi"
},
{
"path": "cppad_ipopt/example/ode_fast.hpp",
"chars": 6447,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_FAST_HPP\n# define CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_FAST_HPP\n// SPDX-License-Identifi"
},
{
"path": "cppad_ipopt/example/ode_fast_check.cpp",
"chars": 755,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/example/ode_problem.hpp",
"chars": 2990,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_PROBLEM_HPP\n# define CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_PROBLEM_HPP\n// SPDX-License-Id"
},
{
"path": "cppad_ipopt/example/ode_run.hpp",
"chars": 3878,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_RUN_HPP\n# define CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_RUN_HPP\n// SPDX-License-Identifier"
},
{
"path": "cppad_ipopt/example/ode_simple.hpp",
"chars": 3971,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_SIMPLE_HPP\n# define CPPAD_CPPAD_IPOPT_EXAMPLE_ODE_SIMPLE_HPP\n// SPDX-License-Iden"
},
{
"path": "cppad_ipopt/example/ode_simple_check.cpp",
"chars": 761,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/example/test.sh.in",
"chars": 317,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "cppad_ipopt/speed/CMakeLists.txt",
"chars": 1530,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cppad_ipopt/speed/ode_speed.cpp",
"chars": 2266,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/speed/speed.cpp",
"chars": 1295,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/speed/test.sh.in",
"chars": 315,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "cppad_ipopt/src/CMakeLists.txt",
"chars": 1379,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cppad_ipopt/src/cppad_ipopt_nlp.cpp",
"chars": 34525,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/src/cppad_ipopt_nlp.hpp",
"chars": 33225,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_SRC_CPPAD_IPOPT_NLP_HPP\n# define CPPAD_CPPAD_IPOPT_SRC_CPPAD_IPOPT_NLP_HPP\n// SPDX-License-Id"
},
{
"path": "cppad_ipopt/src/fun_record.hpp",
"chars": 3603,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_SRC_FUN_RECORD_HPP\n# define CPPAD_CPPAD_IPOPT_SRC_FUN_RECORD_HPP\n// SPDX-License-Identifier: "
},
{
"path": "cppad_ipopt/src/hes_fg_map.cpp",
"chars": 5817,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/src/hes_fg_map.hpp",
"chars": 1663,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_SRC_HES_FG_MAP_HPP\n# define CPPAD_CPPAD_IPOPT_SRC_HES_FG_MAP_HPP\n// SPDX-License-Identifier: "
},
{
"path": "cppad_ipopt/src/jac_g_map.cpp",
"chars": 5710,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/src/jac_g_map.hpp",
"chars": 1657,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_SRC_JAC_G_MAP_HPP\n# define CPPAD_CPPAD_IPOPT_SRC_JAC_G_MAP_HPP\n// SPDX-License-Identifier: EP"
},
{
"path": "cppad_ipopt/src/sparse_map2vec.cpp",
"chars": 2853,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/src/sparse_map2vec.hpp",
"chars": 1136,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_SRC_SPARSE_MAP2VEC_HPP\n# define CPPAD_CPPAD_IPOPT_SRC_SPARSE_MAP2VEC_HPP\n// SPDX-License-Iden"
},
{
"path": "cppad_ipopt/src/vec_fun_pattern.cpp",
"chars": 5174,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/src/vec_fun_pattern.hpp",
"chars": 1411,
"preview": "# ifndef CPPAD_CPPAD_IPOPT_SRC_VEC_FUN_PATTERN_HPP\n# define CPPAD_CPPAD_IPOPT_SRC_VEC_FUN_PATTERN_HPP\n// SPDX-License-Id"
},
{
"path": "cppad_ipopt/test/CMakeLists.txt",
"chars": 1238,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cppad_ipopt/test/k_gt_one.cpp",
"chars": 5561,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/test/multiple_solution.cpp",
"chars": 3734,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/test/retape_k1_l1.cpp",
"chars": 3369,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/test/retape_k1_l2.cpp",
"chars": 3799,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_ipopt/test/test.sh.in",
"chars": 319,
"preview": "#! /bin/bash -e\n# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbe"
},
{
"path": "cppad_ipopt/test/test_more.cpp",
"chars": 1243,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_lib/CMakeLists.txt",
"chars": 2243,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "cppad_lib/code_gen_fun.cpp",
"chars": 11056,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_lib/cpp_graph_op.cpp",
"chars": 4496,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_lib/cppad_colpack.cpp",
"chars": 8601,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_lib/csrc_writer.cpp",
"chars": 19238,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_lib/json_lexer.cpp",
"chars": 7449,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_lib/json_parser.cpp",
"chars": 12829,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_lib/json_writer.cpp",
"chars": 9166,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_lib/link_dll_lib.cpp",
"chars": 2636,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "cppad_lib/temp_file.cpp",
"chars": 2864,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "epl-2.0.txt",
"chars": 14193,
"preview": "Eclipse Public License - v 2.0\n\n THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE\n PUBLIC LICENS"
},
{
"path": "example/CMakeLists.txt",
"chars": 1500,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "example/abs_normal/CMakeLists.txt",
"chars": 957,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "example/abs_normal/abs_eval.cpp",
"chars": 3463,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "example/abs_normal/abs_eval.hpp",
"chars": 5687,
"preview": "# ifndef CPPAD_EXAMPLE_ABS_NORMAL_ABS_EVAL_HPP\n# define CPPAD_EXAMPLE_ABS_NORMAL_ABS_EVAL_HPP\n// SPDX-License-Identifier"
},
{
"path": "example/abs_normal/abs_eval.xrst",
"chars": 425,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
},
{
"path": "example/abs_normal/abs_min_linear.cpp",
"chars": 4807,
"preview": "// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n// SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>"
},
{
"path": "example/abs_normal/abs_min_linear.hpp",
"chars": 13227,
"preview": "# ifndef CPPAD_EXAMPLE_ABS_NORMAL_ABS_MIN_LINEAR_HPP\n# define CPPAD_EXAMPLE_ABS_NORMAL_ABS_MIN_LINEAR_HPP\n// SPDX-Licens"
},
{
"path": "example/abs_normal/abs_min_linear.xrst",
"chars": 455,
"preview": "# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later\n# SPDX-FileCopyrightText: Bradley M. Bell <bradbell@seanet.com>\n#"
}
]
// ... and 1272 more files (download for full content)
About this extraction
This page contains the full source code of the coin-or/CppAD GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1472 files (8.1 MB), approximately 2.2M tokens, and a symbol index with 4297 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.