Commit 4ea711ba446615a4d103eee8c2c50894114c81af - cppad

Imported Upstream version 2015.00.00.0 Barak A. Pearlmutter 9 years ago

1108 changed file(s) with 52194 addition(s) and 25973 deletion(s). Raw diff Collapse all Expand all

+57

-0

.gitignore less more

	0	# top directory only
	1	git_commit.sh
	2	aclocal.m4
	3	ar-lib
	4	autom4te.cache
	5	build
	6	commit.sh.old
	7	doc
	8	doxydoc
	9	cppad/configure.hpp
	10	# all directories
	11	*.err
	12	/.err
	13	//*.err
	14	*.log
	15	/.log
	16	//*.log
	17	*.swp
	18	/.swp
	19	//*.swp
	20	*.tmp
	21	/.tmp
	22	//*.tmp
	23	build
	24	*/build
	25	//build
	26	new
	27	*/new
	28	//new
	29	test_one.exe
	30	*/test_one.exe
	31	//test_one.exe
	32	test_one.sh
	33	*/test_one.sh
	34	//test_one.sh
	35	test_one.cpp
	36	*/test_one.cpp
	37	//test_one.cpp
	38	# all directions with and without extension
	39	doxyfile
	40	doxyfile.*
	41	*/doxyfile
	42	/doxyfile.
	43	//doxyfile
	44	//doxyfile.*
	45	junk
	46	junk.*
	47	*/junk
	48	/junk.
	49	//junk
	50	//junk.*
	51	temp
	52	temp.*
	53	*/temp
	54	/temp.
	55	//temp
	56	//temp.*

-1

AUTHORS less more

0	0	Statement of CppAD Authorship and Copyright
1	1	===========================================
2	2
3		To date, 2014-01-01, Bradley M. Bell is the sole author of CppAD.
	3	To date, 2015-01-01, Bradley M. Bell is the sole author of CppAD.
4	4	While Bradley M. Bell worked for the University of Washington during
5	5	the development of CppAD, the following are also true:
6	6

+56

-25

CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3099 2014-02-18 03:29:44Z bradbell $
	0	# $Id: CMakeLists.txt 3509 2014-12-27 20:38:37Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#

15	15	CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
16	16
17	17	# cppad_version is used by set_version.sh to get the version number.
18		SET(cppad_version "20140000.3" )
	18	SET(cppad_version "20150000.0" )
19	19	SET(cppad_url "http://www.coin-or.org/CppAD" )
20	20	SET(cppad_description "Differentiation of C++ Algorithms" )
21	21

59	59	#
60	60	# add_cppad_cxx_flags(target_name)
61	61	INCLUDE(cmake/add_cppad_cxx_flags.cmake)
	62	#
	63	# sources_libs_define(prefix_name sources libs define)
	64	INCLUDE(cmake/sources_libs_define.cmake)
62	65	# =============================================================================
63	66	# command line arguments
64	67	# =============================================================================

67	70	"directory, below prefix, where cmake installs cppad data files"
68	71	)
69	72	# -----------------------------------------------------------------------------
	73	# cmake_install_docdir
	74	command_line_arg(cmake_install_docdir "" STRING
	75	"directory, below prefix, where cmake installs cppad documentation files"
	76	)
	77	# -----------------------------------------------------------------------------
70	78	# cmake_install_includedirs
71	79	command_line_arg(cmake_install_includedirs include STRING
72	80	"directories, below prefix, where cmake installs include files"

96	104	)
97	105	# -----------------------------------------------------------------------------
98	106	# cppad_documentation
99		command_line_arg(cppad_documentation NO BOOL
100		"install cppad documentation"
101		)
	107	command_line_arg(cppad_documentation "" STRING
	108	"install cppad documentation: use camke_install_docdir instead"
	109	)
	110	STRING(COMPARE NOTEQUAL "${cppad_documentation}" "" cppad_documentation_error)
	111	IF( cppad_documentation_error )
	112	MESSAGE(FATAL_ERROR
	113	"cppad_documentation is no longer an option, use cmake_install_docdir instead"
	114	)
	115	ENDIF( cppad_documentation_error )
102	116	# -----------------------------------------------------------------------------
103	117	# External package prefixes
104	118	#
105	119	# adolc_prefix
106	120	optional_package(adolc_prefix "adolc install prefix")
107	121	#
	122	# colpack_prefix
	123	optional_package(colpack_prefix "colpack install prefix")
	124	#
108	125	# eigen_prefix
109	126	optional_package(eigen_prefix "eigen install prefix")
110	127	#

116	133	#
117	134	# sacado_prefix
118	135	optional_package(sacado_prefix "sacado install prefix")
	136	# -----------------------------------------------------------------------------
	137	# cppad_has_colpack
	138	#
	139	IF( colpack_prefix )
	140	SET(cppad_has_colpack 1)
	141	ELSE( colpack_prefix )
	142	SET(cppad_has_colpack 0)
	143	ENDIF( colpack_prefix )
119	144	# =============================================================================
120	145	# automated system configuration
121	146	# =============================================================================

145	170	# -----------------------------------------------------------------------------
146	171	# cppad_cxx_flags_skip_eigen
147	172	STRING(REGEX REPLACE
148		"(.)-Wshadow(.)" "\\1 \\2"
	173	"(.)-Wshadow(.)" "\\1-Wno-shadow\\2"
149	174	cppad_cxx_flags_eigen "${cppad_cxx_flags}"
150	175	)
151	176	MESSAGE(STATUS "cppad_cxx_flags_eigen = ${cppad_cxx_flags_eigen}")
152	177	# -----------------------------------------------------------------------------
153	178	# cppad_cxx_flags_skip_fadbad
154	179	STRING(REGEX REPLACE
155		"(.)-Wshadow(.)" "\\1 \\2"
	180	"(.)-Wshadow(.)" "\\1-Wno-shadow\\2"
156	181	cppad_cxx_flags_fadbad "${cppad_cxx_flags}"
157	182	)
158	183	MESSAGE(STATUS "cppad_cxx_flags_fadbad = ${cppad_cxx_flags_fadbad}")
159	184	# -----------------------------------------------------------------------------
160	185	# cppad_abs_includedir, cppad_abs_libdir, cppad_abs_datadir, cppad_abs_docdir
	186	#
	187	# cppad_abs_docdir is not used if cmake_install_docdir is ""
	188	#
161	189	IF ( cmake_install_postfix )
162	190	SET(cppad_abs_includedir
163	191	"${cmake_install_prefix}/${cppad_install_includedir}/${cmake_install_postfix}"

172	200	CACHE INTERNAL "cppad install data file directory" FORCE
173	201	)
174	202	SET(cppad_abs_docdir
175		"${cmake_install_prefix}/${cmake_install_datadir}/doc/${cmake_install_postfix}"
	203	"${cmake_install_prefix}/${cmake_install_docdir}/${cmake_install_postfix}"
176	204	CACHE INTERNAL "cppad install data file directory" FORCE
177	205	)
178	206	ELSE ( cmake_install_postfix )

189	217	CACHE INTERNAL "cppad install data file directory" FORCE
190	218	)
191	219	SET(cppad_abs_docdir
192		"${cmake_install_prefix}/${cmake_install_datadir}/doc"
	220	"${cmake_install_prefix}/${cmake_install_docdir}"
193	221	CACHE INTERNAL "cppad install data file directory" FORCE
194	222	)
195	223	ENDIF ( cmake_install_postfix )

269	297	# add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])
270	298	#
271	299	# Initialize list of tests as empty
272		SET(list_check "")
	300	SET(check_depends "")
273	301	#
274	302	ADD_SUBDIRECTORY(cppad)
275	303	ADD_SUBDIRECTORY(pkgconfig)
276	304	#
277	305	ADD_SUBDIRECTORY(compare_c)
278		add_to_list(list_check check_compare_c)
	306	add_to_list(check_depends check_compare_c)
279	307	#
280	308	ADD_SUBDIRECTORY(example)
281		add_to_list(list_check check_example)
	309	add_to_list(check_depends check_example)
282	310	#
283	311	ADD_SUBDIRECTORY(introduction)
284		add_to_list(list_check check_introduction)
	312	add_to_list(check_depends check_introduction)
285	313	#
286	314	ADD_SUBDIRECTORY(print_for)
287		add_to_list(list_check check_print_for)
	315	add_to_list(check_depends check_print_for)
288	316	#
289	317	ADD_SUBDIRECTORY(test_more)
290		add_to_list(list_check check_test_more)
	318	add_to_list(check_depends check_test_more)
291	319	#
292	320	ADD_SUBDIRECTORY(multi_thread)
293		add_to_list(list_check check_multi_thread)
	321	add_to_list(check_depends check_multi_thread)
294	322	#
295	323	ADD_SUBDIRECTORY(speed)
296		add_to_list(list_check check_speed)
	324	add_to_list(check_depends check_speed)
297	325	#
298	326	IF ( ipopt_prefix )
299	327	ADD_SUBDIRECTORY(cppad_ipopt)
300		add_to_list(list_check check_ipopt_nlp)
	328	add_to_list(check_depends check_cppad_ipopt)
301	329	ENDIF( ipopt_prefix )
302	330	#
303		ADD_CUSTOM_TARGET(check DEPENDS ${list_check})
	331	ADD_CUSTOM_TARGET(check DEPENDS ${check_depends})
304	332	#
305	333	# =============================================================================
306	334	# install procedure

317	345	# Note a trailing / in the source directory name drops the source directory
318	346	# name during the copy.
319	347	#
320		# During install copy all ithe cppad include files to
	348	# During install copy all the cppad include files to
321	349	# ${cppad_abs_includedir}/cppad
322	350	INSTALL(
323	351	DIRECTORY "cppad/"

329	357	DESTINATION ${cppad_abs_includedir}/cppad
330	358	FILES_MATCHING PATTERN "*.hpp"
331	359	)
332		#
333		# During install copy doc direcrory to cppad_abs_docdir/cppad-${cppad_version}
	360	INSTALL(
	361	FILES "cppad/local/cppad_colpack.cpp"
	362	DESTINATION ${cppad_abs_datadir}/cppad
	363	)
	364	#
	365	# During install copy doc direcrory to cppad_abs_docdir/cppad
	366	STRING( COMPARE NOTEQUAL "${cmake_install_docdir}" "" cppad_documentation )
334	367	IF ( cppad_documentation )
335		INSTALL( DIRECTORY "doc/" DESTINATION
336		${cppad_abs_docdir}/cppad-${cppad_version}
337		)
	368	INSTALL( DIRECTORY "doc/" DESTINATION ${cppad_abs_docdir}/cppad )
338	369	ENDIF ( cppad_documentation )

-6

bin/add_copyright.sh less more

0	0	#! /bin/bash -e
1		# $Id: add_copyright.sh 2770 2013-03-08 13:42:40Z bradbell $
	1	# $Id: add_copyright.sh 3505 2014-12-26 15:06:54Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

37	37	case $ext in
38	38	cpp \| hpp \| omh)
39	39	cat << EOF > bin/add_copyright.$$
40		/* \$Id:\$ */
	40	// \$Id\$
41	41	/* --------------------------------------------------------------------------
42		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	42	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
43	43
44	44	CppAD is distributed under multiple licenses. This distribution is under
45	45	the terms of the

55	55	cat << EOF > bin/add_copyright.$$
56	56	# \$Id:\$
57	57	# -----------------------------------------------------------------------------
58		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	58	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
59	59	#
60	60	# CppAD is distributed under multiple licenses. This distribution is under
61	61	# the terms of the

72	72	#! /bin/bash -e
73	73	# \$Id:\$
74	74	# -----------------------------------------------------------------------------
75		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	75	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
76	76	#
77	77	# CppAD is distributed under multiple licenses. This distribution is under
78	78	# the terms of the

+16

-34

bin/check_all.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_all.sh 3067 2013-12-29 17:35:34Z bradbell $
	1	# $Id: check_all.sh 3123 2014-02-26 21:40:18Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

58	58	bin/package.sh
59	59	# -----------------------------------------------------------------------------
60	60	# choose which tarball to use for testing
	61	skip=''
61	62	version=`bin/version.sh get`
62	63	echo_log_eval cd build
63	64	list=( `ls cppad-$version.*.tgz` )

89	90	# -----------------------------------------------------------------------------
90	91	echo_log_eval make check
91	92	# -----------------------------------------------------------------------------
92		skip=''
93		list='
94		cppad_ipopt/example/example_ipopt_nlp
95		cppad_ipopt/speed/speed_ipopt_nlp
96		cppad_ipopt/test/test_more_ipopt_nlp
97		example/example
98		example/ipopt_solve/example_ipopt_solve
99		introduction/exp_apx/introduction_exp_apx
100		introduction/get_started/introduction_get_started
101		speed/example/speed_example
102		test_more/test_more
103		'
104		#
105		# standard tests
106		for program in $list
	93	for package in adolc eigen ipopt fadbad sacado
107	94	do
108		if [ ! -e "$program" ]
	95	dir=$HOME/prefix/$package
	96	if [ ! -d "$dir" ]
109	97	then
110		skip="$skip $program"
111		else
112		echo_log_eval $program
	98	skip="$skip $package"
113	99	fi
114	100	done
115	101	#
116		# speed tests
117		for dir in adolc cppad double fadbad sacado profile
	102	# extra speed tests not run with option specified
	103	for option in onetape colpack optimize atomic memory boolsparsity
118	104	do
119		program="speed/$dir/speed_${dir}"
120		if [ ! -e "$program" ]
121		then
122		skip="$skip $program"
123		else
124		echo_log_eval $program correct 54321
125		echo_log_eval $program correct 54321 retape
126		fi
	105	echo_eval speed/cppad/speed_cppad correct 432 $option
127	106	done
	107	echo_eval speed/adolc/speed_adolc correct 432 onetape
	108	echo_eval speed/adolc/speed_adolc sparse_jacobian 432 onetape colpack
	109	echo_eval speed/adolc/speed_adolc sparse_hessian 432 onetape colpack
128	110	#
129		# multi_thread tests
130	111	# ----------------------------------------------------------------------------
	112	# extra multi_thread tests
131	113	program_list=''
132		for dir in bthread openmp pthread
	114	for threading in bthread openmp pthread
133	115	do
134		program="multi_thread/${dir}/${dir}_test"
	116	program="multi_thread/${threading}/multi_thread_${threading}"
135	117	if [ ! -e $program ]
136	118	then
137	119	skip="$skip $program"

-3

bin/check_define.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_define.sh 2941 2013-10-15 02:26:20Z bradbell $
	1	# $Id: check_define.sh 3308 2014-05-26 14:29:01Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

17	17	# -----------------------------------------------------------------------------
18	18	echo "Difference between '# define' names and '# undef' names"
19	19	echo '-----------------------------------------------------------------------'
20		list=`find cppad $ -name '.hpp' $ -or $ -name '.hpp.in' $`
	20	list=`bin/list_files.sh .hpp .hpp.in \| sed -n -e '/^cppad\//p'`
21	21	#
22	22	for cmd in define undef
23	23	do

-8

bin/check_example.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_example.sh 2683 2012-12-30 18:17:03Z bradbell $
	1	# $Id: check_example.sh 3308 2014-05-26 14:29:01Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

17	17	# -----------------------------------------------------------------------------
18	18	echo "Checking that all examples are in omh/example_list.omh"
19	19	echo "-------------------------------------------------------"
20		file_list="
21		example/*.[ch]pp
22		example//.[ch]pp
23		multi_thread/*.[ch]pp
24		multi_thread//.[ch]pp
25		"
	20	file_list=`bin/list_files.sh \| \
	21	sed -n -e '/example\//p' -e '/multi_thread\//p'`
	22	#
26	23	sed < omh/example_list.omh > bin/check_example.$$ \
27	24	-n -e '/\$begin ListAllExamples\$\$/,/\$end/p'
28	25	ok="yes"

+48

-0

bin/check_if.sh less more

	0	#! /bin/bash -e
	1	# $Id: check_if.sh 3308 2014-05-26 14:29:01Z bradbell $
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4	#
	5	# CppAD is distributed under multiple licenses. This distribution is under
	6	# the terms of the
	7	# GNU General Public License Version 3.
	8	#
	9	# A copy of this license is included in the COPYING file of this distribution.
	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	# -----------------------------------------------------------------------------
	12	if [ "$0" != 'bin/check_if.sh' ]
	13	then
	14	echo "bin/check_if: must be executed from its parent directory"
	15	exit 1
	16	fi
	17	# -----------------------------------------------------------------------------
	18	# CppAD uses preprocessor '# if 0' comment blocks for temporary changes
	19	# that will to be removed before testing for check in.
	20	echo "Checking for '# if 0' and '# if NDEBUG' commands in source code"
	21	echo "-------------------------------------------------------"
	22	ok="yes"
	23	list=`bin/list_files.sh .cpp .hpp .hpp.in`
	24	for file in $list
	25	do
	26	if grep '^# if 0 *$' $file > /dev/null
	27	then
	28	# CppAD uses /* comment */ for all its block commnets
	29	echo "$file has an '# if 0' preprocessor command"
	30	ok="no"
	31	fi
	32	if grep '^# if NDEBUG *$' $file > /dev/null
	33	then
	34	# This should probably be # ifndef NDEBUG ?
	35	echo "$file has an '# if NDEBUG' preprocessor command"
	36	ok="no"
	37	fi
	38	done
	39	echo "-------------------------------------------------------"
	40	if [ "$ok" = "no" ]
	41	then
	42	echo 'bin/check_if.sh: Error'
	43	exit 1
	44	else
	45	echo 'bin/check_if.sh: OK'
	46	exit 0
	47	fi

-53

~~bin/check_if_0.sh~~ less more

0		#! /bin/bash -e
1		# $Id: check_if_0.sh 2794 2013-05-02 08:20:30Z bradbell $
2		# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4		#
5		# CppAD is distributed under multiple licenses. This distribution is under
6		# the terms of the
7		# GNU General Public License Version 3.
8		#
9		# A copy of this license is included in the COPYING file of this distribution.
10		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		# -----------------------------------------------------------------------------
12		if [ ! -e "bin/check_if_0.sh" ]
13		then
14		echo "bin/check_if_0.sh: must be executed from its parent directory"
15		exit 1
16		fi
17		# -----------------------------------------------------------------------------
18		# CppAD uses preprocessor '# if 0' comment blocks for temporary changes
19		# that will to be removed before testing for check in.
20		echo "Checking for '# if 0' comments blocks in source code"
21		echo "-------------------------------------------------------"
22		ok="yes"
23		for ext in .cpp .hpp
24		do
25		dir_list=`find . -name "*$ext" \| sed \
26		-e '/junk\.[^.]*$/d' \
27		-e '/\/build\//d' \
28		-e '/\/new\//d' \
29		-e 's\|^\./\|\|' \
30		-e 's\|/[^/]*$\|\|' \| sort -u`
31		for dir in $dir_list
32		do
33		list=`ls $dir/*$ext`
34		for file in $list
35		do
36		if grep '^# if 0 *$' $file > /dev/null
37		then
38		echo "$file has an '# if 0' comment block"
39		ok="no"
40		fi
41		done
42		done
43		done
44		echo "-------------------------------------------------------"
45		if [ "$ok" = "no" ]
46		then
47		echo "Error: nothing should be between the two dashed lines above"
48		exit 1
49		else
50		echo "Ok: nothing is between the two dashed lines above"
51		exit 0
52		fi

-26

bin/check_include_def.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_include_def.sh 2859 2013-05-28 06:03:21Z bradbell $
	1	# $Id: check_include_def.sh 3308 2014-05-26 14:29:01Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

18	18	echo "Differences between include file names and ifndef at top directives."
19	19	echo "Also make sure same ifndef not used by two different files."
20	20	echo "-------------------------------------------------------------------"
21		grep '^# ifndef CPPAD_[0-9a-zA-Z_]*_INCLUDED$' \
22		cppad_ipopt//.hpp \
23		cppad/*.hpp \
24		cppad/example/*.hpp \
25		cppad/local/*.hpp \
26		cppad/speed/*.hpp \
27		example/*.hpp \
28		example/atomic/*.hpp \
29		multi_thread/*.hpp \
30		\| sed \
31		-e 's\|.# ifndef CPPAD_$[0-9a-zA-Z_]$_INCLUDED$\|\1.HPP\|' \
	21	list=`bin/list_files.sh .hpp`
	22	#
	23	grep '^# ifndef CPPAD_[0-9a-zA-Z_]*_INCLUDED$' $list \
	24	\| sed -e 's\|.# ifndef CPPAD_$[0-9a-zA-Z_]$_INCLUDED$\|\1.HPP\|' \
32	25	\| tr [a-zA-Z] [A-Za-z] \
33	26	\| sort \
34	27	> bin/check_include_def.1.$$
35
36		ls \
37		cppad_ipopt//.hpp \
38		cppad/*.hpp \
39		cppad/example/*.hpp \
40		cppad/local/*.hpp \
41		cppad/speed/*.hpp \
42		example/*.hpp \
43		example/atomic/*.hpp \
44		multi_thread/*.hpp \
45		\| sed -e 's\|.*/\|\|' \
46		\| sort -u \
47		> bin/check_include_def.2.$$
	28	#
	29	echo "$list" \| sed -e 's\|$[^ ]*$/\|\|g' \| sort -u > bin/check_include_def.2.$$
	30	#
48	31	if diff bin/check_include_def.1.$$ bin/check_include_def.2.$$
49	32	then
50	33	different="no"

+16

-22

bin/check_include_file.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_include_file.sh 2859 2013-05-28 06:03:21Z bradbell $
	1	# $Id: check_include_file.sh 3308 2014-05-26 14:29:01Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

24	24	echo "bin/check_include_file.sh: unexpected bin/check_include_file.1.$$"
25	25	exit 1
26	26	fi
27		for ext in .cpp .hpp
	27	list=`bin/list_files.sh .cpp .hpp`
	28	for file in $list
28	29	do
29		dir_list=`find . -name "$ext" \| sed -e '/junk\.[^.]$/d' \
30		-e 's\|^\./\|\|' -e '/^build/d' -e 's\|/[^/]*$\|\|' \| sort -u`
31		for dir in $dir_list
32		do
33		list=`ls $dir/*$ext`
34		for file in $list
35		do
36		sed -n -e '/^# include <cppad\//p' $file \
37		>> bin/check_include_file.1.$$
38		done
39		done
	30	sed -n -e '/^# include <cppad\//p' $file \
	31	>> bin/check_include_file.1.$$
40	32	done
41	33	#
42	34	cat bin/check_include_file.1.$$ \| \
43	35	sed -e 's%[^<]<%%' -e 's%>.$%%' \| \
44	36	sort -u > bin/check_include_file.2.$$
45		# The file cppad/local/prototype_op.hpp should never be included.
46		# All other files should. (The file cppad/configure.hpp may not yet be created).
47		ls cppad/*.hpp \
48		cppad/example/*.hpp \
49		cppad/ipopt/*.hpp \
50		cppad/local/*.hpp \
51		cppad/speed/*.hpp \| sed \
	37	#
	38	# The following files should never be included:
	39	# cppad/local/prototype_op.hpp
	40	# cppad/example/eigen_plugin.hpp
	41	# All other files should.
	42	# The file cppad/configure.hpp may not yet be created.
	43	bin/list_files.sh .hpp \| sed -n -e '/cppad\//p' \| \
	44	sed \
52	45	-e '1,1s\|^\|cppad/configure.hpp\n\|' \
53	46	-e '/cppad\/local\/prototype_op.hpp/d' \
54	47	-e '/cppad\/example\/eigen_plugin.hpp/d' \| \
55		sort -u > bin/check_include_file.3.$$
	48	sort -u > bin/check_include_file.3.$$
	49	#
56	50	if diff bin/check_include_file.2.$$ bin/check_include_file.3.$$
57	51	then
58	52	different="no"

-16

bin/check_include_omh.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_include_omh.sh 2792 2013-04-28 09:25:28Z bradbell $
	1	# $Id: check_include_omh.sh 3308 2014-05-26 14:29:01Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

14	14	echo "bin/check_include_omh.sh: must be executed from its parent directory"
15	15	exit 1
16	16	fi
17		sh_files_with_omhelp_documentation=`ls bin/get_*.sh`
18	17	# -----------------------------------------------------------------------------
19	18	# Make sure omhelp, under cygwin, has not matched file names with wrong case.
20	19	echo "Checking difference between OMhelp include directives and file names."
21	20	echo "----------------------------------------------------------------------"
22	21	# super list of file names that are referenced by omhelp commands
23		find . $ -name '*.c' $ -or \
24		$ -name '*.cpp' $ -or \
25		$ -name '*.hpp' $ -or \
26		$ -name '*.omh' $ -or \
27		$ -name '*.txt' $ -or \
28		$ -name '*.am' $ \| sed \
29		-e '/.\/work\//d' \
30		-e '/.\/build\//d' \
31		-e '/.\/new\//d' \
32		-e '/.\/doc\//d' \
33		-e 's\|./\|\|' \
34		> bin/check_include_omh.1.$$
35		echo $sh_files_with_omhelp_documentation >> bin/check_include_omh.1.$$
	22	bin/list_files.sh .c .cpp .hpp .omh .txt .am > bin/check_include_omh.1.$$
	23	#
	24	# add *.sh files with omhelp documentation
	25	ls bin/get_*.sh >> bin/check_include_omh.1.$$
	26	#
36	27	for file in `cat bin/check_include_omh.1.$$`
37	28	do
38	29	# assume $childtable, ... , $verbatim use % for delimiter

-10

bin/check_makefile.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_makefile.sh 2862 2013-05-29 05:58:38Z bradbell $
	1	# $Id: check_makefile.sh 3308 2014-05-26 14:29:01Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

17	17	# -----------------------------------------------------------------------------
18	18	echo "Checking include files listed in makefile.am"
19	19	echo "-------------------------------------------------------"
20		ls \
21		cppad/*.h \
22		cppad/*.hpp \
23		cppad/example/*.hpp \
24		cppad/local/*.hpp \
25		cppad/ipopt/*.hpp \
26		cppad/speed/*.hpp \| \
27		sed -e '/^cppad\/config\.h$/d' > check_makefile.1.$$
	20	bin/list_files.sh .h .hpp \| \
	21	sed -n -e '/cppad\//p' -e '/^cppad\/config\.h$/d' \
	22	> check_makefile.1.$$
28	23	echo 'cppad/configure.hpp' >> check_makefile.1.$$
29	24	sort -u check_makefile.1.$$ > check_makefile.2.$$
30	25	#

+13

-13

bin/check_op_code.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_op_code.sh 2611 2012-12-18 00:26:08Z bradbell $
	1	# $Id: check_op_code.sh 3250 2014-05-14 15:31:30Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

30	30	fi
31	31	# -----------------------------------------------------------------------------
32	32	# check NumArgTable
33		sed -n -e '/NumArgTable\[\]/,/^};/p' cppad/local/op_code.hpp \| \
	33	sed -n -e '/NumArgTable\[\]/,/^[ \t]*};/p' cppad/local/op_code.hpp \| \
34	34	sed \
35	35	-e '/NumArgTable\[\]/d' \
36		-e '/^};/d' \
37		-e 's\|^[ ][0-9], // \|\|' \
	36	-e '/^[ \t]*};/d' \
	37	-e 's\|^[ \t][0-9], // \|\|' \
38	38	-e 's\|Op.*\|\|' \
39	39	> bin/op_code.3.$$
40	40	#

46	46	fi
47	47	# -----------------------------------------------------------------------------
48	48	# check NumResTable (last line of NumResTable is not used)
49		sed -n -e '/NumResTable\[\]/,/^};/p' cppad/local/op_code.hpp \| \
	49	sed -n -e '/NumResTable\[\]/,/^[ \t]*};/p' cppad/local/op_code.hpp \| \
50	50	sed \
51	51	-e '/NumResTable\[\]/d' \
52		-e '/^};/d' \
	52	-e '/^[ \t]*};/d' \
53	53	-e '/Last entry not used/d' \
54		-e 's\|^[ ][0-9], // \|\|' \
	54	-e 's\|^[ \t][0-9], // \|\|' \
55	55	-e 's\|Op.*\|\|' \
56	56	> bin/op_code.4.$$
57	57	#

63	63	exit 1
64	64	fi
65	65	# -----------------------------------------------------------------------------
66		# check OpName
67		sed -n -e '/char \OpName\[\]/,/^[ ]};/p' cppad/local/op_code.hpp \| \
	66	# check OpNameTable
	67	sed -n -e '/const char \OpNameTable\[\]/,/^[ \t]};/p' cppad/local/op_code.hpp \| \
68	68	sed \
69		-e '/char \*OpName\[\]/d' \
70		-e '/^[ ]*};/d' \
71		-e 's\|^[ ]*"\|\|' \
	69	-e '/OpNameTable\[\]/d' \
	70	-e '/^[ \t]*};/d' \
	71	-e 's\|^[ \t]*"\|\|' \
72	72	-e 's\|".*\|\|' \
73	73	> bin/op_code.5.$$
74	74	#

+24

-20

bin/check_replace.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_replace.sh 2997 2013-10-27 12:32:25Z bradbell $
	1	# $Id: check_replace.sh 3214 2014-03-18 20:50:38Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

14	14	echo "bin/check_replace.sh: must be executed from its parent directory"
15	15	exit 1
16	16	fi
17		# -----------------------------------------------------------------------------
18		pattern='<!-- define'
19		extensions='.cpp .hpp'
20		directories='cppad cppad/local'
21		list=`find_files.sh "$pattern" "$extensions" "$directories"`
22		echo '------------------------------------------------------------------------'
23		echo 'check replacement text in following files:'
24		for file in $list
25		do
26		echo "$file"
27		bin/replace_html.py $file $file.rep
28		if ! diff $file $file.rep > /dev/null
	17	check_replace() {
	18	define_file="cppad/local/$1"
	19	replace_file="cppad/local/$2"
	20	new_file="cppad/local/$2.$$"
	21	bin/replace_html.py $define_file $replace_file $new_file
	22	if ! diff $replace_file $new_file > /dev/null
29	23	then
30	24	cat << EOF
31		check_replace.sh: Error: The replacement text in $file
32		does not match its replacement commands; see
33		diff $file $file.rep
	25	check_replace.sh: Error:
	26	The replacement text in $replace_file
	27	does not match its definition in $define_file.
	28	Execute the following command to fix this:
	29	mv $new_file $replace_file
34	30	EOF
35	31	exit 1
36	32	fi
37		rm $file.rep
38		done
39		echo '------------------------------------------------------------------------'
	33	rm $new_file
	34	}
	35	# -----------------------------------------------------------------------------
	36	# files with definitions and replacemnet in same file
	37	check_replace cond_op.hpp cond_op.hpp
	38	check_replace load_op.hpp load_op.hpp
	39	check_replace store_op.hpp store_op.hpp
	40	check_replace optimize.hpp optimize.hpp
	41	check_replace forward0sweep.hpp forward1sweep.hpp
	42	# -----------------------------------------------------------------------------
	43	echo "replace_html.sh: OK"
40	44	exit 0

+18

-35

bin/check_svn_id.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_svn_id.sh 2935 2013-10-12 19:40:01Z bradbell $
	1	# $Id: check_svn_id.sh 3495 2014-12-24 01:16:15Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

15	15	exit 1
16	16	fi
17	17	# -----------------------------------------------------------------------------
18		echo "Checking for \$Id:.*\$ in beginning of source code"
	18	echo "Checking for \$Id.*\$ in beginning of source code"
19	19	echo "-------------------------------------------------------"
20	20	ok="yes"
21		for ext in .hpp .cpp .omh .sh .in
	21	list=`bin/list_files.sh .hpp .cpp .omh .sh .in .am .txt \| sed \
	22	-e '/^gpl-3.0.txt$/d' \
	23	-e '/^epl-v10.txt$/d' \
	24	-e '/cppad\/local\/config.h.in$/d' \
	25	-e '/^makefile.in$/d' \
	26	-e '/^svn_commit.sh$/d' \
	27	-e '/^git_commit.sh$/d' \
	28	-e '/\/makefile.in$/d' `
	29	#
	30	for file in $list
22	31	do
23		dir_list=`find . -name "*$ext" \| sed \
24		-e '/\/junk$/d' \
25		-e '/\/junk\./d' \
26		-e '/\/temp$/d' \
27		-e '/\/temp\./d' \
28		-e 's\|^\./\|\|' \
29		-e 's/^[^/]*$/./' \
30		-e '/^work\//d' \
31		-e '/^build\//d' \
32		-e '/^bug\/build\//d' \
33		-e '/svn_dist\//d' \
34		-e 's\|/[^/]*$\|\|' \
35		\| sort -u`
36		for dir in $dir_list
37		do
38		list=`ls $dir/*$ext \| sed \
39		-e '/\/config.h.in/d' \
40		-e '/\/makefile\.in/d' \
41		-e '/\/junk$/d' \
42		-e '/\/junk\./d' \
43		-e '/\/temp$/d' \
44		-e '/\/temp\./d'`
45		for file in $list
46		do
47		if ! head -2 $file \| grep '$Id:.*\$' > /dev/null
48		then
49		echo "$file does not have '\$Id:.*\$' in first two lines"
50		ok="no"
51		fi
52		done
53		done
	32	if ! head -2 $file \| grep '$Id.*\$' > /dev/null
	33	then
	34	echo "$file does not have '\$Id.*\$' in first two lines"
	35	ok="no"
	36	fi
54	37	done
55	38	echo "-------------------------------------------------------"
56	39	if [ "$ok" = "no" ]

+28

-34

bin/check_verbatim.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_verbatim.sh 2778 2013-04-16 14:56:10Z bradbell $
	1	# $Id: check_verbatim.sh 3308 2014-05-26 14:29:01Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

18	18	# Make sure that OMhelp verbatim commands referr to same file as command
19	19	echo "Checking that OMhelp verbatim commands include from file they appear in."
20	20	echo "----------------------------------------------------------------------"
21		# use 2> to avoid warnings about greping directories, should fix this
22		# some other way
23		grep '$verbatim%' * / //* 2> /dev/null \| sed \
24		-e '/^bin\//d' \
25		-e 's\|:.*$verbatim%\| \|' \
26		-e 's\|%.*\|\|' \
27		-e '/^junk /d' \
28		-e '/^junk.sh /d' \
29		-e '/^doxydoc\//d' \
30		-e '/^work\//d' \
31		-e '/^build\//d' \
32		-e '/^doc\//d' \
33		-e '/\/test_one\.cpp /d' \
34		-e '/\/speed_[a-z]*\.omh /d' \
35		-e '/omh\/license.omh /d' \
36		-e '/cppad\/local\/cond_exp.hpp /d' \
37		> bin/check_verbatim.1.$$
	21	list=`bin/list_files.sh .c .cpp .hpp .omh .txt .am`
38	22	different="no"
39		file=""
40		for this in `cat bin/check_verbatim.1.$$`
	23	for file in $list
41	24	do
42
43		if [ "$file" == "" ]
	25	line=`sed -n -e '/$verbatim[^a-z]/p' $file`
	26	if [ "$line" != '' ]
44	27	then
45		file="$this"
46		else
	28	reference=`echo $line \| sed -e 's\|$verbatim%$[^%]$%.\|\1\|'`
	29	#
47	30	file_root=`echo $file \| sed \
48	31	-e 's\|./\|\|' -e 's\|_hpp\.omh\|\|' -e 's\|\.[^.]$\|\|'`
49		this_root=`echo $this \| sed \
	32	#
	33	ref_root=`echo $reference \| sed \
50	34	-e 's\|./\|\|' -e 's\|\.[^.]$\|\|'`
51		if [ "$file_root" != "$this_root" ]
	35	#
	36	if [ "$file_root" != "$ref_root" ]
52	37	then
53		echo "in $file references $this"
54		different="yes"
	38	# special cases
	39	ok='false'
	40	if [ "$file_root" == 'cond_exp' ] && [ "$ref_root" == 'atan2' ]
	41	then
	42	ok='true'
	43	fi
	44	if [ "$file_root" == 'license' ] && [ "$ref_root" == 'epl-v10' ]
	45	then
	46	ok='true'
	47	fi
	48	#
	49	if [ "$ok" == 'false' ]
	50	then
	51	echo "\$verbatim in $file references $reference"
	52	different="yes"
	53	fi
55	54	fi
56		file=""
57	55	fi
58		done
59		for index in 1
60		do
61		rm bin/check_verbatim.$index.$$
62	56	done
63	57	echo "-------------------------------------------------------------------"
64	58	if [ $different = "yes" ]

+152

-0

bin/colpack.sh less more

	0	#! /bin/bash -e
	1	# $Id: colpack.sh 3115 2014-02-23 12:24:38Z bradbell $
	2	if [ "$1" != 'forward' ] && [ "$1" != 'reverse' ]
	3	then
	4	echo 'usage: ./colpack.sh option'
	5	echo 'where option is "forward" or "reverse"'
	6	exit 1
	7	fi
	8	if [ "$1" == 'forward' ]
	9	then
	10	color_variant="COLUMN_PARTIAL_DISTANCE_TWO"
	11	else
	12	color_variant="ROW_PARTIAL_DISTANCE_TWO"
	13	fi
	14	# ----------------------------------------------------------------------------
	15	# bash function that echos and executes a command
	16	echo_eval() {
	17	echo $*
	18	eval $*
	19	}
	20	# -----------------------------------------------
	21	if [ ! -e 'build/colpack' ]
	22	then
	23	echo_eval mkdir -p build/colpack
	24	fi
	25	echo 'create: build/colpack/colpack.cpp'
	26	cat<< EOF > build/colpack/colpack.cpp
	27	// Example using BipartiteGraphPartialColoringInterface
	28	// to generate the seed matrix for Jacobian
	29
	30	#include "ColPackHeaders.h"
	31
	32	int main()
	33	{ size_t i, j, k;
	34
	35	using std::cout;
	36	using std::endl;
	37
	38	//* 32x9 matrix
	39	size_t i_RowCount = 32;
	40	size_t i_ColumnCount = 9;
	41	size_t i_MaxNonZerosInRows = 3;
	42
	43	// JP[32][9]
	44	std::vector<unsigned int *> JP(i_RowCount);
	45	unsigned int n_data = i_RowCount * (i_MaxNonZerosInRows + 1);
	46	std::vector<unsigned int> JP_memory(n_data);
	47	for(i = 0; i < i_RowCount; i++)
	48	JP[i] = JP_memory.data() + i * (i_MaxNonZerosInRows + 1);
	49	//
	50	JP[0][0] = 0;
	51	JP[1][0] = 1; JP[1][1] = 0;
	52	JP[2][0] = 1; JP[2][1] = 1;
	53	JP[3][0] = 1; JP[3][1] = 2;
	54	JP[4][0] = 1; JP[4][1] = 0;
	55	JP[5][0] = 3; JP[5][1] = 0; JP[5][2] = 1; JP[5][3] = 3;
	56	JP[6][0] = 3; JP[6][1] = 1; JP[6][2] = 2; JP[6][3] = 4;
	57	JP[7][0] = 2; JP[7][1] = 2; JP[7][2] = 5;
	58	JP[8][0] = 1; JP[8][1] = 3;
	59	JP[9][0] = 3; JP[9][1] = 3; JP[9][2] = 4; JP[9][3] = 6;
	60	JP[10][0] = 3; JP[10][1] = 4; JP[10][2] = 5; JP[10][3] = 7;
	61	JP[11][0] = 2; JP[11][1] = 5; JP[11][2] = 8;
	62	JP[12][0] = 1; JP[12][1] = 6;
	63	JP[13][0] = 2; JP[13][1] = 6; JP[13][2] = 7;
	64	JP[14][0] = 2; JP[14][1] = 7; JP[14][2] = 8;
	65	JP[15][0] = 1; JP[15][1] = 8;
	66	JP[16][0] = 1; JP[16][1] = 0;
	67	JP[17][0] = 2; JP[17][1] = 0; JP[17][2] = 1;
	68	JP[18][0] = 2; JP[18][1] = 1; JP[18][2] = 2;
	69	JP[19][0] = 1; JP[19][1] = 2;
	70	JP[20][0] = 2; JP[20][1] = 0; JP[20][2] = 3;
	71	JP[21][0] = 3; JP[21][1] = 1; JP[21][2] = 3; JP[21][3] = 4;
	72	JP[22][0] = 3; JP[22][1] = 2; JP[22][2] = 4; JP[22][3] = 5;
	73	JP[23][0] = 1; JP[23][1] = 5;
	74	JP[24][0] = 2; JP[24][1] = 3; JP[24][2] = 6;
	75	JP[25][0] = 3; JP[25][1] = 4; JP[25][2] = 6; JP[25][3] = 7;
	76	JP[26][0] = 3; JP[26][1] = 5; JP[26][2] = 7; JP[26][3] = 8;
	77	JP[27][0] = 1; JP[27][1] = 8;
	78	JP[28][0] = 1; JP[28][1] = 6;
	79	JP[29][0] = 1; JP[29][1] = 7;
	80	JP[30][0] = 1; JP[30][1] = 8;
	81	JP[31][0] = 0;
	82	cout << endl << "Sparsity pattern of Jacobian:" << endl;
	83	cout << " ";
	84	for(k = 0; k < 9; k++)
	85	cout << setw(3) << k;
	86	cout << endl;
	87	for(i = 0; i < i_RowCount; i++)
	88	{ cout << setw(3) << i << ":";
	89	k = 0;
	90	for (j = 1; j <= (int) JP[i][0]; j++)
	91	{ while(k < JP[i][j])
	92	{ cout << setw(3) << 0;
	93	k++;
	94	}
	95	cout << setw(3) << 1;
	96	k++;
	97	}
	98	while(k < 9)
	99	{ cout << setw(3) << 0;
	100	k++;
	101	}
	102	cout << endl;
	103	}
	104
	105
	106	// Step 1: Read the sparsity pattern of the given Jacobian matrix
	107	// (adolc format) and create the corresponding bipartite graph
	108	ColPack::BipartiteGraphPartialColoringInterface g(
	109	SRC_MEM_ADOLC, JP.data(), i_RowCount, i_ColumnCount
	110	);
	111	g.PrintBipartiteGraph();
	112
	113	// Step 2: Do Partial-Distance-Two-Coloring
	114	// of the bipartite graph with the specified ordering
	115	g.PartialDistanceTwoColoring(
	116	"SMALLEST_LAST", "$color_variant"
	117	);
	118	g.PrintColumnPartialColors();
	119	g.PrintColumnPartialColoringMetrics();
	120
	121	// Step 3: From the coloring information, create and return seed matrix
	122	int ip1_SeedRowCount;
	123	int ip1_SeedColumnCount;
	124	double** RSeed =
	125	g.GetSeedMatrix(&ip1_SeedRowCount, &ip1_SeedColumnCount);
	126	int rows = ip1_SeedRowCount;
	127	int cols = ip1_SeedColumnCount;
	128	cout << "Seed matrix: (" << rows << "," << cols << ")" << endl;
	129	cout << " ";
	130	for(j = 0; j < cols; j++)
	131	cout << setw(3) << j;
	132	cout << endl;
	133	for(i = 0; i < rows; i++)
	134	{ cout << setw(3) << i << ":";
	135	for(j = 0; j < cols; j++)
	136	cout << setw(3) << int(RSeed[i][j]);
	137	cout << endl;
	138	}
	139
	140	return 0;
	141	}
	142	EOF
	143	# ----------------------------------------------------------------------------
	144	echo_eval cd build/colpack
	145	echo_eval g++ colpack.cpp \
	146	-I$HOME/prefix/colpack/include/ColPack \
	147	-L$HOME/prefix/colpack/lib64 \
	148	-l ColPack \
	149	-o colpack
	150	#
	151	echo_eval valgrind --leak-check=yes ./colpack

-3

bin/commit.sh less more

0	0	#! /bin/bash -e
1		# $Id: commit.sh 3027 2013-12-24 23:23:58Z bradbell $
	1	# $Id: commit.sh 3214 2014-03-18 20:50:38Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
4	4	#

17	17	cat << EOF > bin/commit.user.$$
18	18	General comments about this commit go here (delete this line).
19	19
20		bin/new_stable.sh@
	20	dir/file.ext@ optional comment about this file.
21	21	EOF
22	22	# -----------------------------------------------------------------------------
23	23	if [ ! -e "bin/commit.sh" ]

78	78	# -----------------------------------------------------------------------
79	79	# check for abort do to unknown files
80	80	unknown=`svn status \| sed -n -e '/^[?]/p' \| \
81		sed -e 's/^[?]//' -e "/bin\/commit.*.$$/d"`
	81	sed -e 's/^[?]//' -e "/bin\/commit.*.$$/d" -e '/\/new$/d'`
82	82	msg="aborting because the following files are unknown to svn"
83	83	print_msg="no"
84	84	for file in $unknown

+14

-5

bin/doxyfile.sh less more

0	0	#! /bin/bash -e
1		# $Id: doxyfile.sh 2859 2013-05-28 06:03:21Z bradbell $
	1	# $Id: doxyfile.sh 3238 2014-04-28 13:40:39Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

30	30	ALWAYS_DETAILED_SEC = YES
31	31	BUILTIN_STL_SUPPORT = YES
32	32	EXTRACT_ALL = YES
33		EXTRACT_LOCAL_CLASSES = NO
	33	EXTRACT_LOCAL_CLASSES = YES
34	34	EXTRACT_PRIVATE = YES
35	35	EXTRACT_STATIC = YES
	36	EXTRACT_ANON_NSPACES = YES
36	37	FILE_PATTERNS = .hpp .cpp
37	38	FULL_PATH_NAMES = NO
38	39	GENERATE_LATEX = NO
39	40	GENERATE_TREEVIEW = YES
40	41	INHERIT_DOCS = NO
41	42	INLINE_INHERITED_MEMB = YES
42		INPUT = ./cppad ./cppad/local ./cppad_ipopt/src ./speed/src
	43	INPUT = \
	44	./cppad \
	45	./cppad/local \
	46	./cppad/ipopt \
	47	./cppad_ipopt/src \
	48	./speed/src
	49	LATEX_BATCHMODE = YES
43	50	MULTILINE_CPP_IS_BRIEF = YES
44	51	OUTPUT_DIRECTORY = $output_directory
45	52	PROJECT_NAME = "CppAD: A C++ Algorithmic Differentiation Package"

51	58	SHOW_DIRECTORIES = YES
52	59	SHOW_INCLUDE_FILES = NO
53	60	SORT_GROUP_NAMES = YES
54		SORT_MEMBER_DOCS = NO
	61	SORT_MEMBER_DOCS = YES
	62	SORT_BRIEF_DOCS = YES
55	63	SOURCE_BROWSER = YES
56	64	STRIP_CODE_COMMENTS = NO
57	65	SUBGROUPING = NO

61	69	WARN_NO_PARAMDOC = YES
62	70	EOF
63	71	sed \
	72	-e 's/\t/ /g' \
64	73	-e 's/^/s\|^\\(/' \
65	74	-e 's/ =/ =\\).*\|\\1/' \
66	75	-e 's/$/\|/' \

-20

bin/get_adolc.sh less more

0	0	#! /bin/bash -e
1		# $Id: get_adolc.sh 2948 2013-10-15 16:09:40Z bradbell $
	1	# $Id: get_adolc.sh 3488 2014-12-19 12:04:15Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

30	30	# $href%https://projects.coin-or.org/ADOL-C%ADOL-C%$$ in the
31	31	# CppAD $code build$$ directory.
32	32	#
33		# $children%
34		# bin/get_colpack.sh
35		# %$$
36	33	# $head Requirements$$
37	34	# You must first use $cref get_colpack.sh$$ to download and install
38	35	# $code ColPack$$ (coloring algorithms used for sparse matrix derivatives).

70	67	}
71	68	# -----------------------------------------------------------------------------
72	69	echo 'Download adolc to build/external and install it to build/prefix'
	70	# ADOL-C verison 2.5.2 results in:
	71	# adouble.h:74: error: 'badouble::badouble()' is protected
	72	# It apprears that newer versions of adolc assume some c++11 features; see
	73	# http://list.coin-or.org/pipermail/adol-c/2014-December/001023.html
73	74	version='2.4.1'
74	75	web_page="http://www.coin-or.org/download/source/ADOL-C"
75	76	prefix=`pwd`'/build/prefix'

104	105	echo_eval cd ADOL-C-$version
105	106	# -----------------------------------------------------------------------------
106	107	system=`uname \| tr [A-Z] [a-z] \| sed -e 's\|$[a-z][a-z]$.\|\1\|'`
107		if [ "$system" == 'cygwin' ] && [ "$version" == '2.3.0' ]
108		then
109		# see http://list.coin-or.org/pipermail/adol-c/2012-April/000814.html
110		echo 'changing ADOL-C/src/adouble.cpp'
111		sed \
112		-e '/^double fmin(/,/^}/s\|^\|// \|' \
113		-e '/^double fmax(/,/^}/s\|^\|// \|' \
114		-i 'ADOL-C/src/adouble.cpp'
115		echo 'changing ADOL-C/src/adouble.h'
116		sed \
117		-e '/^double [A-Z_]* fmin(/s\|^\|// \|' \
118		-e '/^double [A-Z_]* fmax(/s\|^\|// \|' \
119		-i 'ADOL-C/src/adouble.h'
120		fi
121	108	# -----------------------------------------------------------------------------
122	109	if which autoconf >& /dev/null
123	110	then
124		ac_version=`autoconf --version \| \
	111	ac_version=`autoconf --version \| sed -n -e '/^autoconf/p' \| \
125	112	sed -e 's\|[^0-9]$[0-9.]$[.]$[0-9]$.\|\1 * 100 + \2\|' \| bc`
126	113	if [ "$ac_version" -ge 267 ]
127	114	then

-2

bin/get_ipopt.sh less more

0	0	#! /bin/bash -e
1		# $Id: get_ipopt.sh 2931 2013-10-12 13:13:45Z bradbell $
	1	# $Id: get_ipopt.sh 3408 2014-11-27 15:17:20Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#

62	62	}
63	63	# -----------------------------------------------------------------------------
64	64	echo 'Download ipopt to build/external and install it to build/prefix'
65		version='3.11.4'
	65	version='3.11.9'
66	66	web_page='http://www.coin-or.org/download/source/Ipopt'
67	67	prefix=`pwd`'/build/prefix'
68	68	# -----------------------------------------------------------------------------

-3

bin/get_sacado.sh less more

0	0	#! /bin/bash -e
1		# $Id: get_sacado.sh 2931 2013-10-12 13:13:45Z bradbell $
	1	# $Id: get_sacado.sh 3407 2014-11-27 13:14:56Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#

63	63	}
64	64	# -----------------------------------------------------------------------------
65	65	echo 'Download sacado to build/external and install it to build/prefix'
66		version="trilinos-10.8.3-Source"
67		web_page="http://trilinos.sandia.gov/download/files"
	66	version="trilinos-11.12.1-Source"
	67	web_page="http://trilinos.org/oldsite/download/files"
68	68	prefix=`pwd`'/build/prefix'
69	69	# -----------------------------------------------------------------------------
70	70	# determine which version of cmake to use

+82

-0

bin/git_ignore.sh less more

	0	#! /bin/bash -e
	1	# $Id$
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	4	#
	5	# CppAD is distributed under multiple licenses. This distribution is under
	6	# the terms of the
	7	# GNU General Public License Version 3.
	8	#
	9	# A copy of this license is included in the COPYING file of this distribution.
	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	# -----------------------------------------------------------------------------
	12	if [ $0 != "bin/git_ignore.sh" ]
	13	then
	14	echo "bin/git_ignore.sh: must be executed from its parent directory"
	15	exit 1
	16	fi
	17	# -----------------------------------------------------------------------------
	18	# use @ for * so does not get replaced during echo command
	19	dir_list='
	20	.
	21	./@
	22	./@/@
	23	'
	24	top_dir_list='
	25	git_commit.sh
	26	aclocal.m4
	27	ar-lib
	28	autom4te.cache
	29	build
	30	commit.sh.old
	31	doc
	32	doxydoc
	33	cppad/configure.hpp
	34	'
	35	all_dir_list='
	36	@.err
	37	@.log
	38	@.swp
	39	@.tmp
	40
	41	build
	42	new
	43	test_one.exe
	44	test_one.sh
	45	test_one.cpp
	46	'
	47	root_name_list='
	48	doxyfile
	49	junk
	50	temp
	51	'
	52	# -----------------------------------------------------------------------------
	53	if [ -e .gitignore ]
	54	then
	55	rm .gitignore
	56	fi
	57	echo '# top directory only' >> .gitignore
	58	for name in $top_dir_list
	59	do
	60	echo "$name" \| sed -e 's\|^./\|\|' -e 's\|@\|*\|g' >> .gitignore
	61	done
	62	echo '# all directories' >> .gitignore
	63	for name in $all_dir_list
	64	do
	65	for dir in $dir_list
	66	do
	67	echo "$dir/$name" \| sed -e 's\|^./\|\|' -e 's\|@\|*\|g' >> .gitignore
	68	done
	69	done
	70	echo '# all directions with and without extension' >> .gitignore
	71	for name in $root_name_list
	72	do
	73	for dir in $dir_list
	74	do
	75	echo "$dir/$name" \| sed -e 's\|^./\|\|' -e 's\|@\|*\|g' >> .gitignore
	76	echo "$dir/$name." \| sed -e 's\|^./\|\|' -e 's\|@\|\|g' >> .gitignore
	77	done
	78	done
	79	#
	80	echo 'git_ignore.sh: OK'
	81	exit 0

+32

-19

bin/jenkins.sh less more

0	0	#! /bin/bash -e
1		# $Id: jenkins.sh 3067 2013-12-29 17:35:34Z bradbell $
	1	# $Id: jenkins.sh 3485 2014-12-18 14:33:03Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#

9	9	# A copy of this license is included in the COPYING file of this distribution.
10	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11	11	# -----------------------------------------------------------------------------
	12	if [ $0 != "bin/jenkins.sh" ]
	13	then
	14	echo "bin/jenkins.sh: must be executed from its parent directory"
	15	exit 1
	16	fi
	17	if [ "$1" != 'none' ] && [ "$1" != 'build' ] && [ "$1" != 'install' ]
	18	then
	19	echo 'bin/junk.sh: redo_external'
	20	echo 'Where redo_external is one of: build, install, none'
	21	exit 1
	22	fi
	23	redo_external="$1"
	24	# -----------------------------------------------------------------------------
12	25	# distribution directory corresponding to this version of CppAD
13	26	trunk_dir=`pwd`
14	27	# -----------------------------------------------------------------------------

17	30	echo $*
18	31	eval $*
19	32	}
20		# bash function that echos and executes a command
21		for ext in log err
22		do
23		if [ -e "../jenkins.$ext" ]
24		then
25		echo_eval rm ../jenkins.$ext
26		fi
27		done
	33	# bash function that logs stdout, stderr, and executes a command
28	34	log_eval() {
29	35	echo "------------------------------------------------" >> ../jenkins.log
30	36	echo "------------------------------------------------" >> ../jenkins.err

45	51	echo_eval rm ../jenkins.$ext
46	52	fi
47	53	done
48		# -----------------------------------------------
49		if [ $0 != "bin/jenkins.sh" ]
50		then
51		echo "bin/jenkins.sh: must be executed from its parent directory"
52		exit 1
53		fi
54	54	# --------------------------------------------------------------------------
55	55	if [ -e /usr/lib64 ]
56	56	then

59	59	libdir='lib'
60	60	fi
61	61	# -----------------------------------------------------------------------
62		# The following test can be used to skip install of other packages
63		skip='false'
64		if [ "$skip" != 'true' ]
	62	g++ --version
	63	# -----------------------------------------------------------------------
	64	# Build and install external packages
	65	if [ "$redo_external" != 'none' ]
65	66	then
	67	# -------------------------------------------------------------------
	68	# this comand cleans out the previous install for all externals
	69	echo_eval rm -rf build/prefix
	70	# -------------------------------------------------------------------
	71	if [ "$redo_extrnal" == 'build' ]
	72	then
	73	# This command causes a new download, and compile for all externals
	74	echo_eval rm -rf build/external
	75	fi
66	76	# -------------------------------------------------------------------
67	77	# Running bin/get_fadbad.sh will install include files in
68	78	# $trunk_dir/build/prefix/include/FADBAD++

85	95	# $trunk_dir/build/prefix/$libdir
86	96	log_eval bin/get_sacado.sh
87	97	# -------------------------------------------------------------------
	98	# Running bin/get_colpack.sh will install library files in
	99	# $trunk_dir/build/prefix/$libdir
	100	log_eval bin/get_colpack.sh
	101	# -------------------------------------------------------------------
88	102	# Running bin/get_acolc.sh will install include files in
89	103	# $trunk_dir/build/prefix/include/adolc
90	104	# and library files in
91	105	# $trunk_dir/build/prefix/$libdir
92		log_eval bin/get_colpack.sh
93	106	log_eval bin/get_adolc.sh
94	107	# -------------------------------------------------------------------
95	108	fi

+43

-0

bin/list_files.sh less more

	0	#! /bin/bash -e
	1	# $Id: list_files.sh 3308 2014-05-26 14:29:01Z bradbell $
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4	#
	5	# CppAD is distributed under multiple licenses. This distribution is under
	6	# the terms of the
	7	# GNU General Public License Version 3.
	8	#
	9	# A copy of this license is included in the COPYING file of this distribution.
	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	# -----------------------------------------------------------------------------
	12	if [ $0 != "bin/list_files.sh" ]
	13	then
	14	echo "bin/list_files.sh: must be executed from its parent directory"
	15	exit 1
	16	fi
	17	#
	18	if [ "$1" == '' ]
	19	then
	20	cat << EOF
	21	usage: list_files.sh ext_1 [ ext_2 ... ]
	22
	23	lists files with the specified extensions excluding those of the form:
	24	/new/, build/, doc/, doxydoc/, /test_one.cpp, /junk\$ext, */temp\$ext
	25
	26	where \$ext takes the values ext_1, ext_2, ...
	27	File and directory names do not begin with './'.
	28	EOF
	29	fi
	30	for ext in $*
	31	do
	32	# should change '.' to '[.]' before executing sed comand below
	33	find . -name "*$ext" \| sed \
	34	-e '/[/]new[/]/d' \
	35	-e '/build[/]/d' \
	36	-e '/doc[/]/d' \
	37	-e '/doxydoc[/]/d' \
	38	-e '/[/]test_one.cpp$/d' \
	39	-e "/[/]junk$ext"'$/d' \
	40	-e "/[/]temp$ext"'$/d' \
	41	-e 's\|^[.]/\|\|'
	42	done

+24

-21

bin/new_release.sh less more

0	0	#! /bin/bash -e
1		# $Id: new_release.sh 3099 2014-02-18 03:29:44Z bradbell $
	1	# $Id: new_release.sh 3512 2014-12-27 20:39:59Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

21	21	}
22	22	# -----------------------------------------------------------------------------
23	23	repository="https://projects.coin-or.org/svn/CppAD"
24		stable_version="20140000"
25		release='3'
	24	stable_version="20150000"
	25	release='0'
26	26	release_version="$stable_version.$release"
27		msg="Creating releases/$release_version"
28		# -----------------------------------------------------------------------------
29		# check initial working directory
30		dir=`pwd \| sed -e 's\|.*/[Cc][Pp][Pp][Aa][Dd]/\|\|'`
31		check="stable/$stable_version"
32		if [ "$dir" != "$check" ]
33		then
34		echo bin/"new_release.sh: must execute this script in $check"
35		exit 1
36		fi
37	27	# -----------------------------------------------------------------------------
38	28	# Check release version
39	29	if svn list $repository/releases \| grep "$release_version" > /dev/null

44	34	echo "in file bin/new_release.sh to a higher release number."
45	35	exit 1
46	36	fi
	37	# -----------------------------------------------------------------------------
	38	echo_eval git checkout $stable_version
	39	# -----------------------------------------------------------------------------
47	40	#
48	41	check_one=`bin/version.sh get`
49		echo_eval svn revert doc.omh
	42	echo_eval git checkout doc.omh
50	43	check_two=`grep "cppad-$stable_version" doc.omh \
51	44	\| sed -e 's\|cppad-$[0-9.]$:.\|\1\|'`
52	45	if [ "$check_one" != "$release_version" ] \|\| [ "$check_one" != "$check_two" ]

59	52	exit 1
60	53	fi
61	54	# -----------------------------------------------------------------------------
	55	# tag this version of the repository
	56	if git tag --list \| grep "$release_version"
	57	then
	58	git tag -d $release_version
	59	fi
	60	git tag -a \
	61	-m "corresponds $repository/releases/$release_version" \
	62	$release_version
	63	#
	64	# copy committed changes to subversion version
	65	echo_eval git svn dcommit
	66	# -----------------------------------------------------------------------------
	67	msg="Creating releases/$release_version"
62	68	rep_stable="$repository/stable/$stable_version"
63	69	rep_release="$repository/releases/$release_version"
64	70	echo_eval svn copy $rep_stable $rep_release -m \"$msg\"
65	71	# -----------------------------------------------------------------------------
66		echo "cd ../.."
67		cd ../..
68		#
69		if [ -e conf ]
	72	if [ ! -e build ]
70	73	then
71		echo_eval rm -rf conf.old
72		echo_eval mv conf conf.old
	74	echo_eval mkdir -p build
73	75	fi
	76	echo_eval cd build
74	77	echo_eval svn checkout $repository/conf conf
75	78	#
76	79	echo_eval cd conf

+43

-61

bin/new_stable.sh less more

0	0	#! /bin/bash -e
1		# $Id: new_stable.sh 3030 2013-12-25 04:31:10Z bradbell $
	1	# $Id: new_stable.sh 3510 2014-12-27 20:39:05Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#

9	9	# A copy of this license is included in the COPYING file of this distribution.
10	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11	11	# -----------------------------------------------------------------------------
12		if [ ! -e "bin/new_stable.sh" ]
	12	if [ "$0" != "bin/new_stable.sh" ]
13	13	then
14	14	echo "bin/new_stable.sh: must be executed from its parent directory"
15	15	exit 1
16	16	fi
	17	# bash function that echos and executes a command
	18	echo_eval() {
	19	echo $*
	20	eval $*
	21	}
17	22	# -----------------------------------------------------------------------------
18		copy_from_trunk='redo' # do (frist time), keep (use current), redo
19		trunk_revision='3027' # trunk revision number that stable corresponds to
20		yyyy_mm_dd='2014-00-00' # Date corresponding to this trunk revision
	23	copy_from_trunk='keep' # do (frist time), keep (use current)
	24	trunk_revision='3507' # trunk revision number that stable corresponds to
	25	yyyy_mm_dd='2015-00-00' # Date corresponding to this trunk revision
21	26	# -----------------------------------------------------------------------------
22	27	echo "copy_from_trunk=$copy_from_trunk"
23	28	echo "trunk_revision=$trunk_revision"

29	34	rep_trunk="$repository/trunk"
30	35	rep_stable="$repository/stable/$stable_version"
31	36	# -----------------------------------------------------------------------------
32		# check initial working directory
33		dir=`pwd \| sed -e 's\|.*/\|\|'`
34		if [ "$dir" != "trunk" ]
	37	if [ "$copy_from_trunk" = "redo" ]
35	38	then
36		echo bin/"new_stable.sh: must execute this script in the trunk"
37		exit 1
	39	# delete old stable copy
	40	msg="Replacing old stable/$stable_version."
	41	echo "svn delete $rep_stable -m \"$msg\""
	42	svn delete $rep_stable -m "$msg"
38	43	fi
39	44	# -----------------------------------------------------------------------------
40		echo "cd .."
41		cd ..
42		#
43		if [ "$copy_from_trunk" = "redo" ]
44		then
45		# delete old copy of branch
46		msg="Replacing old stable/$stable_version."
47		echo "svn delete $rep_stable -m \"$msg\""
48		svn delete $rep_stable -m "$msg"
49		fi
50	45	if [ "$copy_from_trunk" = "do" ] \|\| [ "$copy_from_trunk" = "redo" ]
51	46	then
52	47	#
53		# create the new stable version
	48	# create the new stable copy
54	49	temp_1="Create stable/$stable_version"
55	50	temp_2="from trunk at revision $trunk_revision."
56	51	msg="$temp_1 $temp_2"
57	52	echo "svn copy -r $trunk_revision $rep_trunk $rep_stable -m \"$msg\""
58		svn copy -r $trunk_revision $rep_trunk $rep_stable -m "$msg"
59		if [ ! -d stable ]
60		then
61		echo "mkdir stable"
62		mkdir stable
63		fi
	53	svn copy -r $trunk_revision $rep_trunk $rep_stable -m "$msg"
64	54	fi
65		if [ -e "stable/$stable_version" ]
	55	# -----------------------------------------------------------------------------
	56	echo 'Use git-svn to fetch the new stable version'
	57	fetch="stable/$stable_version:refs/remotes/svn/stable/$stable_version"
	58	if ! grep "fetch = $fetch" .git/config > /dev/null
66	59	then
67		echo "rm -rf stable/$stable_version"
68		rm -rf stable/$stable_version
	60	sed -e "s\|^\turl =.\|&\n\tfetch = $fetch\|" -i .git/config
69	61	fi
70		#
71		# retrieve stable version from repository ------------------------------------
72		#
73		echo "svn checkout -q $rep_stable stable/$stable_version"
74		svn checkout -q $rep_stable stable/$stable_version
75		#
76		# make sure that bin/new_stable.sh corresponds to this version
	62	#
	63	# fetch the branch
	64	echo_eval git svn fetch
	65	# -----------------------------------------------------------------------------
	66	# checkout the new stable version
	67	if git branch \| grep "$stable_version"
	68	then
	69	git checkout $stable_version
	70	else
	71	echo_eval git checkout -b $stable_version svn/stable/$stable_version
	72	fi
	73	# make sure that bin/new_stable.sh corresponds to current master version
77	74	# (may not be same as version in repository that was copied).
78		echo "cp trunk/bin/new_stable.sh stable/$stable_version/bin/new_stable.sh"
79		cp trunk/bin/new_stable.sh stable/$stable_version/bin/new_stable.sh
80		#
81		echo "cd stable/$stable_version"
82		cd stable/$stable_version
	75	echo_eval git show master:bin/new_stable.sh > bin/new_stable.sh
83	76	#
84	77	# set the version number in root CMakeLists.txt to $stable_version
85		echo "bin/version.sh set $release_version"
86		bin/version.sh set $release_version
	78	echo_eval bin/version.sh set $release_version
87	79	#
88	80	# copy version number to other files
89		echo "bin/version.sh copy"
90		bin/version.sh copy
	81	echo_eval bin/version.sh copy
91	82	#
92	83	# set the value of stable version in corresponding new_release.sh
93	84	echo "automatic editing: $stable_version/bin/new_release.sh"

106	97	#
107	98	# Instructions --------------------------------------------------------------
108	99	cat << EOF
109		1: In the directory stable/$stable_version, review differences using
110		bin/commit.sh list
111		All changed files should be present. Review the differences.
112		2: If you find problems, fix trunk/bin/new_stable.sh, re-run it, and goto 1.
113		3: In stable/$stable_version run the following commands:
	100	1: Review differences using git. If you find problems, fix both
	101	master and $new_stable versions of bin/new_stable.sh.
	102	3: Run the following commands:
114	103	bin/check_all.sh
115		./build.sh all test
116		4: If errors occur, fix trunk/bin/new_stable.sh, re-run it, and goto 1.
117		5: Commit changes to trunk/bin/new_stable.sh
118		6: In stable/$stable_version commit changes using
119		bin/commit.sh edit
120		then edit bin/commit.sh to change the comments and then run
121		bin/commit.sh run
122		7: Make sure commited all necessary changes in stable/$stable_version
123		bin/commit.sh list
124		8: In stable/$stable_version check first, then run the script
	104	4: If errors occur, fix both master and $new_stable version of
	105	bin/new_stable.sh and goto 3.
	106	5: Run the script
125	107	bin/new_release.sh
126	108	EOF
127	109	exit 0

-72

~~bin/only_date.sh~~ less more

0		#! /bin/bash -e
1		# $Id: only_date.sh 2506 2012-10-24 19:36:49Z bradbell $
2		# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
4		#
5		# CppAD is distributed under multiple licenses. This distribution is under
6		# the terms of the
7		# GNU General Public License Version 3.
8		#
9		# A copy of this license is included in the COPYING file of this distribution.
10		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		# -----------------------------------------------------------------------------
12		if [ ! -e "bin/only_date.sh" ]
13		then
14		echo "bin/only_date.sh: must be executed from its parent directory"
15		exit 1
16		fi
17		# -----------------------------------------------------------------------------
18		version=`cat configure.ac \| grep "^ *AC_INIT(" \|
19		sed -e 's/[^,], $[^ ,]$./\1/'`
20		yyyy_mm_dd=`echo $version \| sed -e 's/$....$$..$/\1-\2-/'`
21		# ---------------------------------------------------------------------
22		function check_difference
23		{
24		sed -e '/$Id:.*$/d' $1 > bin/only_date.2.$$
25		if diff bin/only_date.1.$$ bin/only_date.2.$$ > /dev/null
26		then
27		printf "%-20s at most the version number is different.\n" $1:
28		else
29		printf "%-20s changes not counting version number:\n" $1:
30		if ! diff bin/only_date.1.$$ bin/only_date.2.$$
31		then
32		echo "bin/only_date.1.sh: program error"
33		rm bin/only_date.1.$$
34		rm bin/only_date.2.$$
35		exit 1
36		fi
37		fi
38		rm bin/only_date.1.$$
39		rm bin/only_date.2.$$
40		}
41		# ---------------------------------------------------------------------
42		svn cat AUTHORS \| sed > bin/only_date.1.$$ \
43		-e "s/, [0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\} *,/, $yyyy_mm_dd,/" \
44		-e '/$Id:.*$/d'
45		check_difference AUTHORS
46		# ---------------------------------------------------------------------
47		svn cat configure \| sed > bin/only_date.1.$$ \
48		-e "s/CppAD [0-9]\{8\}[.0-9]*/CppAD $version/g" \
49		-e "s/VERSION='[0-9]\{8\}[.0-9]*'/VERSION='$version'/g" \
50		-e "s/configure [0-9]\{8\}[.0-9]*/configure $version/g" \
51		-e "s/config.status [0-9]\{8\}[.0-9]*/config.status $version/g" \
52		-e "s/\$as_me [0-9]\{8\}[.0-9]*/\$as_me $version/g" \
53		-e "s/Generated by GNU Autoconf.*$version/&./" \
54		-e '/$Id:.*$/d'
55		check_difference configure
56		# ---------------------------------------------------------------------
57		svn cat configure.ac \| sed > bin/only_date.1.$$ \
58		-e "s/(CppAD, [0-9]\{8\}[.0-9]* *,/(CppAD, $version,/" \
59		-e '/$Id:.*$/d'
60		check_difference configure.ac
61		# ---------------------------------------------------------------------
62		# configure.hpp is a special case beacuse it is changed by make, no configure
63		change=`svn diff cppad/configure.hpp`
64		if [ "$change" != "" ]
65		then
66		svn cat cppad/configure.hpp \| sed > bin/only_date.1.$$ \
67		-e "s/cppad-[0-9]\{8\}[.0-9]*/cppad-$version/g" \
68		-e '/$Id:.*$/d'
69		check_difference cppad/configure.hpp
70		fi
71		# ---------------------------------------------------------------------

-5

bin/package.sh less more

0	0	#! /bin/bash -e
1		# $Id: package.sh 2997 2013-10-27 12:32:25Z bradbell $
	1	# $Id: package.sh 3494 2014-12-22 14:10:44Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

63	63	list="
64	64	check_define.sh
65	65	check_example.sh
66		check_if_0.sh
	66	check_if.sh
67	67	check_include_def.sh
68	68	check_include_file.sh
69	69	check_include_omh.sh

113	113	$ -name '*.sed' $ -or \
114	114	$ -name '*.sh' $ -or \
115	115	$ -name '*.txt' $ \| sed \
	116	-e '/\/new\//d' \
116	117	-e '/\.\/build\//d' \
117	118	-e '/bug\/build\//d' \
118		-e '/\/junk.sh$/d' \
119		-e '/\/temp.sh$/d' \
	119	-e '/\/junk\.[a-z]*$/d' \
	120	-e '/\/temp\.[a-z]*$/d' \
120	121	-e 's\|^\./\|\|'`
121	122	other_files="
122	123	AUTHORS
123	124	ChangeLog
124	125	configure
	126	config.guess
	127	config.sub
125	128	COPYING
126	129	depcomp
127	130	INSTALL

+43

-34

bin/replace_html.py less more

0	0	#! /bin/python
1		# $Id: replace_html.py 2997 2013-10-27 12:32:25Z bradbell $
	1	# $Id: replace_html.py 3214 2014-03-18 20:50:38Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

17	17	msg = 'bin/replace_html.py: must be executed from its parent directory'
18	18	sys.exit(msg)
19	19	#
20		usage = '''\nusage: replace_html.py old_file new_file
21		where old_file is the path to the file with html text that is to be replaced
22		and new_file is the new_file that will be created.
	20	usage = '''\nusage: replace_html.py define_file replace_file new_file where
23	21
24		Each set of replacement text is defined in the file by
	22	define_file: contains the define commands
	23	replace_file: contains the replace commands (many be same as define_file)
	24	new_file: is a copy of replace file with the replacements.
	25
	26	The definitions are specified by:
25	27	<!-- define name -->source<!-- end name -->
26		where name is any unique name, with no spaces ' '
27		for the replacement text source and source can be any text.
	28	where name is any unique name, with no spaces ' ', for the replacement text
	29	and source is the replacement text.
28	30
29		The destination, where the replacement text is placed, is specified by
	31	The replacement positions are specified by:
30	32	<!-- replace name -->desination<!-- end name -->
31	33	where name refers to a defined replacement text and destination
32	34	is the text that is replaced.
33	35	'''
34	36	narg = len(sys.argv)
35		if narg != 3 :
36		msg = '\nExpected 1 but found ' + str(narg-1) + ' command line arguments.'
	37	if narg != 4 :
	38	msg = '\nExpected 3 but found ' + str(narg-1) + ' command line arguments.'
37	39	sys.exit(usage + msg)
38		old_file = sys.argv[1]
39		new_file = sys.argv[2]
	40	define_file = sys.argv[1]
	41	replace_file = sys.argv[2]
	42	new_file = sys.argv[3]
40	43	# -----------------------------------------------------------------------------
41		if not os.path.exists(old_file) :
42		msg = 'bin/replace_html.py: cannot find old_file = ' + old_file
	44	if not os.path.exists(define_file) :
	45	msg = 'bin/replace_html.py: cannot find define_file = ' + define_file
	46	sys.exit(msg)
	47	if not os.path.exists(replace_file) :
	48	msg = 'bin/replace_html.py: cannot find replace_file = ' + replace_file
43	49	sys.exit(msg)
44	50	if os.path.exists(new_file) :
45	51	msg = 'bin/replace_html.py: cannot overwrite new_file ' + new_file
46	52	sys.exit(msg)
47		f_in = open(old_file, 'rb')
48		data_in = f_in.read()
	53	f_in = open(define_file, 'rb')
	54	define_data = f_in.read()
	55	f_in.close()
	56	f_in = open(replace_file, 'rb')
	57	replace_data = f_in.read()
49	58	f_in.close()
50	59	# -----------------------------------------------------------------------------
51	60	# create define: a dictionary with replacement text definitions

53	62	p_define = re.compile('<!-- define ([^ ]*) -->')
54	63	p_end = re.compile('<!-- end ([^ ]*) -->')
55	64	start = 0
56		while start < len(data_in) :
57		rest = data_in[start : ]
	65	while start < len(define_data) :
	66	rest = define_data[start : ]
58	67	next_define = p_define.search(rest)
59	68	if next_define == None :
60		start = len(data_in)
	69	start = len(define_data)
61	70	else :
62	71	name = next_define.group(1)
63	72	if name in define :
64		msg = 'bin/replace_html.py: file = ' + file_path
	73	msg = 'bin/replace_html.py: file = ' + define_file
65	74	msg += '\ncontains two defintions for name = ' + name
66	75	sys.exit(msg)
67	76	rest = rest[ next_define.end() : ]

71	80	define[name] = source
72	81	start += next_define.end() + next_end.end()
73	82	if name != next_end.group(1) :
74		msg = 'bin/replace_html.py: file = ' + file_path
	83	msg = 'bin/replace_html.py: file = ' + define_file
75	84	msg += '\ndefine name = ' + name
76	85	msg += ', end name = ' + next_end.group(1)
77	86	sys.exit(msg)
78	87	# -----------------------------------------------------------------------------
79		# create data_out: a string with the replacements made
80		data_out = ''
	88	# create new_data: a string with the replacements made
	89	new_data = ''
81	90	p_replace = re.compile('<!-- replace ([^ ]*) -->')
82	91	start = 0
83		while start < len(data_in) :
84		rest = data_in[start : ]
	92	while start < len(replace_data) :
	93	rest = replace_data[start : ]
85	94	next_replace = p_replace.search(rest)
86	95	if next_replace == None :
87		data_out += rest
88		start = len(data_in)
	96	new_data += rest
	97	start = len(replace_data)
89	98	else :
90	99	name = next_replace.group(1)
91	100	if name not in define :
92		msg = 'bin/replace_html.py: file = ' + file_path
	101	msg = 'bin/replace_html.py: file = ' + define_file
93	102	msg += '\ncontains no defintions for name = ' + name
94	103	sys.exit(msg)
95		data_out += rest[0 : next_replace.end() ]
96		data_out += define[name]
	104	new_data += rest[0 : next_replace.end() ]
	105	new_data += define[name]
97	106	#
98	107	rest = rest[ next_replace.end() : ]
99	108	next_end = p_end.search(rest)
100		data_out += rest[ next_end.start() : next_end.end() ]
	109	new_data += rest[ next_end.start() : next_end.end() ]
101	110	start += next_replace.end() + next_end.end()
102	111	if name != next_end.group(1) :
103		msg = 'bin/replace_html.py: file = ' + file_path
	112	msg = 'bin/replace_html.py: file = ' + replace_file
104	113	msg += '\nreplace name = ' + name
105	114	msg += ', end name = ' + next_end.group(1)
106	115	sys.exit(msg)
107	116	# -----------------------------------------------------------------------------
108	117	f_out = open(new_file, 'wb')
109		f_out.write(data_out)
	118	f_out.write(new_data)
110	119	f_out.close()
111	120	# -----------------------------------------------------------------------------
112	121	sys.exit(0)

+39

-9

bin/run_cmake.sh less more

0	0	#! /bin/bash -e
1		# $Id: run_cmake.sh 3067 2013-12-29 17:35:34Z bradbell $
	1	# $Id: run_cmake.sh 3476 2014-12-16 17:15:01Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

22	22	}
23	23	# -----------------------------------------------
24	24	verbose='no'
	25	standard='c++11'
25	26	testvector='boost'
	27	debug_speed='no'
	28	profile_speed='no'
26	29	while [ "$1" != "" ]
27	30	do
28	31	if [ "$1" == '--verbose' ]
29	32	then
30	33	verbose='yes'
	34	elif [ "$1" == '--c++98' ]
	35	then
	36	standard='c++98'
31	37	elif [ "$1" == '--cppad_vector' ]
32	38	then
33	39	testvector='cppad'

37	43	elif [ "$1" == '--eigen_vector' ]
38	44	then
39	45	testvector='eigen'
	46	elif [ "$1" == '--debug_speed' ]
	47	then
	48	debug_speed='yes'
	49	profile_speed='no'
	50	elif [ "$1" == '--profile_speed' ]
	51	then
	52	profile_speed='yes'
	53	debug_speed='no'
40	54	else
41		options='[--verbose] [--<package>_vector]'
	55	options='[--verbose] [--c++98] [--<package>_vector]'
	56	options="$options [--debug_speed] [--profile_speed']"
42	57	echo "usage: bin/run_cmake.sh: $options"
43	58	echo 'where <package> is cppad, boost, or eigen'
44	59	exit 1
45	60	fi
46	61	shift
47	62	done
	63	# ---------------------------------------------------------------------------
	64	if [ "$debug_speed" == 'yes' ]
	65	then
	66	sed -e 's\|^SET(CMAKE_BUILD_TYPE .*\|SET(CMAKE_BUILD_TYPE DEBUG)\|' \
	67	-i speed/CMakeLists.txt
	68	elif [ "$profile_speed" == 'yes' ]
	69	then
	70	sed -e 's\|^SET(CMAKE_BUILD_TYPE .*\|SET(CMAKE_BUILD_TYPE MinSizeRel)\|' \
	71	-i speed/CMakeLists.txt
	72	else
	73	sed -e 's\|^SET(CMAKE_BUILD_TYPE .*\|SET(CMAKE_BUILD_TYPE RELEASE)\|' \
	74	-i speed/CMakeLists.txt
	75	fi
	76	# ---------------------------------------------------------------------------
48	77	if [ ! -e build ]
49	78	then
50	79	echo_eval mkdir build

73	102	if [ -d '/usr/share' ]
74	103	then
75	104	cmake_args="$cmake_args -D cmake_install_datadir=share"
	105	cmake_args="$cmake_args -D cmake_install_docdir=share/doc"
76	106	fi
77	107	#
78	108	# cmake_install_libdirs

85	115	fi
86	116	#
87	117	# {package}_prefix
88		for package in adolc eigen ipopt fadbad sacado
	118	for package in fadbad colpack adolc eigen ipopt sacado
89	119	do
90	120	dir=$HOME/prefix/$package
91	121	if [ -d "$dir" ]

95	125	done
96	126	#
97	127	# cppad_cxx_flags
98		cmake_args="$cmake_args -D cppad_cxx_flags='-Wall -pedantic-errors -std=c++11'"
	128	cppad_cxx_flags="-Wall -pedantic-errors -std=$standard"
99	129	if [ "$testvector" != 'eigen' ]
100	130	then
101		cmake_args="$cmake_args -Wshadow"
	131	cppad_cxx_flags="$cppad_cxx_flags -Wshadow"
102	132	fi
	133	cmake_args="$cmake_args -D cppad_cxx_flags='$cppad_cxx_flags'"
103	134	#
104	135	# simple options
105	136	cmake_args="$cmake_args -D cppad_implicit_ctor_from_any_type_from_any_type=NO"
106		cmake_args="$cmake_args -D cppad_documentation=YES"
107	137	cmake_args="$cmake_args -D cppad_sparse_list=YES"
108	138	cmake_args="$cmake_args -D cppad_testvector=$testvector"
109		cmake_args="$cmake_args -D cppad_tape_id_type='int'"
110		cmake_args="$cmake_args -D cppad_tape_addr_type=int"
	139	cmake_args="$cmake_args -D cppad_tape_id_type='int32_t'"
	140	cmake_args="$cmake_args -D cppad_tape_addr_type=int32_t"
111	141	cmake_args="$cmake_args -D cppad_max_num_threads=48"
112	142	#
113	143	echo_eval cmake $cmake_args ..

-5

bin/run_omhelp.sh less more

0	0	#! /bin/bash -e
1		# $Id: run_omhelp.sh 2722 2013-01-06 16:52:46Z bradbell $
	1	# $Id: run_omhelp.sh 3405 2014-11-26 14:20:55Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#

60	60	then
61	61	cmd="$cmd -printable"
62	62	fi
63		echo "$cmd > omhelp.$ext.log"
64		if ! $cmd > ../omhelp.$ext.log
	63	echo "$cmd >& omhelp.$ext.log"
	64	if ! $cmd >& ../omhelp.$ext.log
65	65	then
	66	cat ../omhelp.$ext.log
	67	echo "OMhelp could not build doc/*.$ext documentation."
66	68	grep "^OMhelp Error:" ../omhelp.$ext.log
67		echo "OMhelp could not build doc/*.$ext documentation."
68		echo "See the complete error message in omhelp.$ext.log"
69	69	exit 1
70	70	fi
71	71	if grep "^OMhelp Warning:" ../omhelp.$ext.log

-34

bin/search.sh less more

0	0	#! /bin/bash -e
1		# $Id: search.sh 2939 2013-10-14 11:06:18Z bradbell $
	1	# $Id: search.sh 3212 2014-03-18 13:05:24Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

21	21	exit 1
22	22	fi
23	23	pattern="$1"
24		extensions='.ac .am .c .cmake .cpp .h .hpp .in .omh .pc .py .sed .sh .txt'
25		directories='
26		.
	24	dir_list='
27	25	bin
28	26	cppad
29		cppad/cmake
30		cppad/example
31		cppad/ipopt
32		cppad/local
33		cppad/speed
34		cppad_ipopt/example
35		cppad_ipopt/speed
36		cppad_ipopt/src
37		cppad_ipopt/test
	27	cppad_ipopt
38	28	example
39		example/atomic
40		example/ipopt_solve
41		introduction/exp_apx
42		introduction/get_started
	29	introduction
43	30	multi_thread
44		multi_thread/bthread
45		multi_thread/openmp
46		multi_thread/pthread
47	31	omh
48		omh/deprecated
49		omh/install
50		omh/whats_new
51	32	pkgconfig
52	33	print_for
53	34	speed
54		speed/adolc
55		speed/cppad
56		speed/double
57		speed/example
58		speed/fadbad
59		speed/profile
60		speed/sacado
61		speed/src
62	35	test_more
63	36	'
64	37	#
65		find_files.sh "$pattern" "$extensions" "$directories" \| \
66		sed -e '/\/makefile.in/d'
	38	grep -l -r "$pattern" $dir_list \| \
	39	sed -e '/\/makefile.in/d' -e '/test_one.exe/d' -e '/\/new\//d'
	40	grep -l "$pattern" makefile.am CMakeLists.txt doc.omh \| \
	41	sed -e '/\/makefile.in/d' -e '/test_one.exe/d' -e '/\/new\//d'

-146

~~bin/speed_compare.sh~~ less more

0		#! /bin/bash -e
1		# $Id: speed_compare.sh 2799 2013-05-08 16:42:20Z bradbell $
2		# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4		#
5		# CppAD is distributed under multiple licenses. This distribution is under
6		# the terms of the
7		# GNU General Public License Version 3.
8		#
9		# A copy of this license is included in the COPYING file of this distribution.
10		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		# -----------------------------------------------------------------------------
12		if [ ! -e "bin/speed_compare.sh" ]
13		then
14		echo "bin/speed_compare.sh: must be executed from its parent directory"
15		exit 1
16		fi
17		options=""
18		if [ "$1" == "retape" ] \|\| [ "$1" == "optimize" ]
19		then
20		options="_$1"
21		elif [ "$1" != "none" ]
22		then
23		echo "usage: bin/speed_compare.sh option_1 option_2"
24		echo " where the option choices are: 'none', 'retape', 'optimize'"
25		exit 1
26		fi
27		if [ "$2" == "retape" ] \|\| [ "$2" == "optimize" ]
28		then
29		options="${options}_$2"
30		elif [ "$2" != "none" ]
31		then
32		echo "usage: bin/speed_compare.sh option_1 option_2"
33		echo " where the option choices are: 'none', 'retape', 'optimize'"
34		exit 1
35		fi
36		if [ ! -d cppad/new ]
37		then
38		echo "speed_comapre.sh: the directory cppad/new does not exist."
39		echo "It contains new source code for the cppad directory (can be empty)."
40		exit 1
41		fi
42		if [ ! -d cppad/local/new ]
43		then
44		echo "speed_comapre.sh: the directory cppad/local/new does not exist"
45		echo "It contains new source code for the cppad/local (can be empty)."
46		exit 1
47		fi
48		# Source code files that are changing
49		new_cppad=`cd cppad/new ; ls`
50		new_local=`cd cppad/local/new ; ls`
51		if [ "$new_cppad" == "" ] && [ "$new_local" == "" ]
52		then
53		echo "speed_compare.sh: both cppad/new and cppad/local/new are empty"
54		exit 1
55		fi
56		# -------------------------------------------------------------------------
57		#
58		if [ ! -e build/speed/cppad/cur_speed$options.out ]
59		then
60		# revert cppad source code to the current version
61		if [ "$new_cppad" != "" ]
62		then
63		for file in $new_cppad
64		do
65		echo "svn revert cppad/$file"
66		if ! svn revert cppad/$file
67		then
68		echo "assuming cppad/$file not in repository"
69		fi
70		done
71		fi
72		# revert cppad/local source code to the current version
73		if [ "$new_local" != "" ]
74		then
75		for file in $new_local
76		do
77		echo "svn revert cppad/local/$file"
78		if ! svn revert cppad/local/$file
79		then
80		echo "assuming cppad/local/$file not in repository"
81		fi
82		done
83		fi
84		#
85		# compile and link the current version
86		echo "cd build; make check_speed_cppad; cd speed/cppad"
87		cd build; make check_speed_cppad; cd speed/cppad
88		#
89		# run speed test for the current version
90		opt=`echo $options \| sed -e 's\|_\|\|g'`
91		echo "./speed_cppad speed 123 $opt > cur_speed$options.out"
92		./speed_cppad speed 123 $opt > cur_speed$options.out
93		#
94		echo "cd ../../.."
95		cd ../../..
96		fi
97		#
98		# Convert cppad source to the new version
99		for file in $new_cppad
100		do
101		echo "cp cppad/new/$file cppad/$file"
102		cp cppad/new/$file cppad/$file
103		done
104		#
105		# Convert local source to the new version
106		for file in $new_local
107		do
108		echo "cp cppad/local/new/$file cppad/local/$file"
109		cp cppad/local/new/$file cppad/local/$file
110		done
111		#
112		if [ ! -e build/speed/cppad/new_speed$options.out ]
113		then
114		# compile and link the new version
115		echo "cd build; make check_speed_cppad; cd speed/cppad"
116		cd build; make check_speed_cppad; cd speed/cppad
117		#
118		# run speed test for the new version
119		opt=`echo $options \| sed -e 's\|_\|\|g'`
120		echo "./speed_cppad speed 123 $opt > new_speed$options.out"
121		./speed_cppad speed 123 $opt > new_speed$options.out
122		#
123		echo "cd ../../.."
124		cd ../../..
125		fi
126		# compare versions
127		echo "cd build/speed/cppad"
128		cd build/speed/cppad
129		#
130		echo "sed -n -e 's\|_rate\|_rate_cur\|' -e '/_rate_/p' \\"
131		echo " -e 's\|::available\|::available_cur\|' -e '/::available/p' \\"
132		echo " cur_speed$options.out > run.out"
133		sed -n -e 's\|_rate\|_rate_cur\|' -e '/_rate_/p' \
134		-e 's\|::available\|::available_cur\|' -e '/::available/p' \
135		cur_speed$options.out > run.out
136		#
137		echo "sed -n -e 's\|_rate\|_rate_new\|' -e '/_rate_/p' \\"
138		echo " -e 's\|::available\|::available_new\|' -e '/::available/p' \\"
139		echo " new_speed$options.out >> run.out"
140		sed -n -e 's\|_rate\|_rate_new\|' -e '/_rate_/p' \
141		-e 's\|::available\|::available_new\|' -e '/::available/p' \
142		new_speed$options.out >> run.out
143		#
144		echo "cat run.out \| sort -u"
145		cat run.out \| sort -u

+53

-0

bin/speed_diff.sh less more

	0	#! /bin/bash -e
	1	# $Id: speed_diff.sh 3488 2014-12-19 12:04:15Z bradbell $
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4	#
	5	# CppAD is distributed under multiple licenses. This distribution is under
	6	# the terms of the
	7	# GNU General Public License Version 3.
	8	#
	9	# A copy of this license is included in the COPYING file of this distribution.
	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	# -----------------------------------------------------------------------------
	12	if [ "$0" != 'bin/speed_diff.sh' ]
	13	then
	14	echo 'bin/speed_diff.sh: must be executed from its parent directory'
	15	exit 1
	16	fi
	17	if [ "$2" == '' ]
	18	then
	19	cat << EOF
	20	usage: bin/speed_diff.sh speed_one.out speed_two.out
	21	where speed_one.out and speed_two.out are outputs from the speed_cppad program
	22	runing its 'speed' test.
	23	EOF
	24	exit 1
	25	fi
	26	speed_one="$1"
	27	speed_two="$2"
	28	if [ ! -f "$speed_one" ]
	29	then
	30	echo "speed_diff.sh: the file $speed_one does not exist."
	31	exit 1
	32	fi
	33	if [ ! -f "$speed_two" ]
	34	then
	35	echo "speed_diff.sh: the file $speed_two does not exist."
	36	exit 1
	37	fi
	38	#
	39	sed -n \
	40	-e 's\|^[a-z]*_\|\|' \
	41	-e 's\|_rate\|_rate_one\|' -e '/_rate_one/p' \
	42	-e 's\|available\|available_one\|' -e '/available_one/p' \
	43	$speed_one > speed_diff.$$
	44	#
	45	sed -n \
	46	-e 's\|^[a-z]*_\|\|' \
	47	-e 's\|_rate\|_rate_two\|' -e '/_rate_two/p' \
	48	-e 's\|available\|available_two\|' -e '/available_two/p' \
	49	$speed_two >> speed_diff.$$
	50	#
	51	cat speed_diff.$$ \| sort -u
	52	rm speed_diff.$$

+139

-0

bin/speed_new.sh less more

	0	#! /bin/bash -e
	1	# $Id: speed_new.sh 3463 2014-12-12 10:59:18Z bradbell $
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4	#
	5	# CppAD is distributed under multiple licenses. This distribution is under
	6	# the terms of the
	7	# GNU General Public License Version 3.
	8	#
	9	# A copy of this license is included in the COPYING file of this distribution.
	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	# -----------------------------------------------------------------------------
	12	if [ ! -e "bin/speed_new.sh" ]
	13	then
	14	echo "bin/speed_new.sh: must be executed from its parent directory"
	15	exit 1
	16	fi
	17	if [ "$1" == '' ]
	18	then
	19	cat << EOF
	20	usage: bin/speed_new.sh option_1 option_2 ...
	21	where the possible options are:
	22	onetape, colpack, optimize, atomic, memory, boolsparsity
	23	Use the special value 'none' for no options
	24	EOF
	25	exit 1
	26	fi
	27	if [ "$1" == 'none' ]
	28	then
	29	shift
	30	fi
	31	if [ ! -d cppad/new ]
	32	then
	33	echo "speed_new.sh: the directory cppad/new does not exist."
	34	echo "It contains new source code for the cppad directory (can be empty)."
	35	exit 1
	36	fi
	37	if [ ! -d cppad/local/new ]
	38	then
	39	echo "speed_new.sh: the directory cppad/local/new does not exist"
	40	echo "It contains new source code for the cppad/local (can be empty)."
	41	exit 1
	42	fi
	43	# Source code files that are changing
	44	new_cppad=`cd cppad/new ; ls`
	45	new_local=`cd cppad/local/new ; ls`
	46	if [ "$new_cppad" == "" ] && [ "$new_local" == "" ]
	47	then
	48	echo "speed_new.sh: both cppad/new and cppad/local/new are empty"
	49	exit 1
	50	fi
	51	# -------------------------------------------------------------------------
	52	#
	53	if [ ! -e build/speed/cppad/cur_speed.out ]
	54	then
	55	# revert cppad source code to the current version
	56	if [ "$new_cppad" != "" ]
	57	then
	58	for file in $new_cppad
	59	do
	60	echo "svn revert cppad/$file"
	61	if ! svn revert cppad/$file
	62	then
	63	echo "assuming cppad/$file not in repository"
	64	fi
	65	done
	66	fi
	67	# revert cppad/local source code to the current version
	68	if [ "$new_local" != "" ]
	69	then
	70	for file in $new_local
	71	do
	72	echo "svn revert cppad/local/$file"
	73	if ! svn revert cppad/local/$file
	74	then
	75	echo "assuming cppad/local/$file not in repository"
	76	fi
	77	done
	78	fi
	79	#
	80	# compile and link the current version
	81	echo "cd build; make check_speed_cppad; cd speed/cppad"
	82	cd build; make check_speed_cppad; cd speed/cppad
	83	#
	84	# run speed test for the current version
	85	echo "./speed_cppad speed 123 $tmp $* > cur_speed.out"
	86	./speed_cppad speed 123 $* > cur_speed.out
	87	#
	88	echo "cd ../../.."
	89	cd ../../..
	90	fi
	91	#
	92	# Convert cppad source to the new version
	93	for file in $new_cppad
	94	do
	95	echo "cp cppad/new/$file cppad/$file"
	96	cp cppad/new/$file cppad/$file
	97	done
	98	#
	99	# Convert local source to the new version
	100	for file in $new_local
	101	do
	102	echo "cp cppad/local/new/$file cppad/local/$file"
	103	cp cppad/local/new/$file cppad/local/$file
	104	done
	105	#
	106	if [ ! -e build/speed/cppad/new_speed.out ]
	107	then
	108	# compile and link the new version
	109	echo "cd build; make check_speed_cppad; cd speed/cppad"
	110	cd build; make check_speed_cppad; cd speed/cppad
	111	#
	112	# run speed test for the new version
	113	echo "./speed_cppad speed 123 $* > new_speed.out"
	114	./speed_cppad speed 123 $* > new_speed.out
	115	#
	116	echo "cd ../../.."
	117	cd ../../..
	118	fi
	119	# compare versions
	120	echo "cd build/speed/cppad"
	121	cd build/speed/cppad
	122	#
	123	echo "sed -n -e 's\|_rate\|_rate_cur\|' -e '/_rate_/p' \\"
	124	echo " -e 's\|available\|available_cur\|' -e '/available_cur/p' \\"
	125	echo " cur_speed.out > run.out"
	126	sed -n -e 's\|_rate\|_rate_cur\|' -e '/_rate_/p' \
	127	-e 's\|available\|available_cur\|' -e '/available_cur/p' \
	128	cur_speed.out > run.out
	129	#
	130	echo "sed -n -e 's\|_rate\|_rate_new\|' -e '/_rate_/p' \\"
	131	echo " -e 's\|available\|available_new\|' -e '/available_new/p' \\"
	132	echo " new_speed.out >> run.out"
	133	sed -n -e 's\|_rate\|_rate_new\|' -e '/_rate_/p' \
	134	-e 's\|available\|available_new\|' -e '/available_new/p' \
	135	new_speed.out >> run.out
	136	#
	137	echo "cat run.out \| sort -u"
	138	cat run.out \| sort -u

-1

bin/svn_ignore.sh less more

0	0	#! /bin/bash -e
1		# $Id: svn_ignore.sh 2875 2013-07-29 11:56:01Z bradbell $
	1	# $Id: svn_ignore.sh 3492 2014-12-21 16:23:41Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#

17	17	# -----------------------------------------------------------------------------
18	18	cat << EOF > bin/svn_ignore.$$
19	19	aclocal.m4
	20	ar-lib
20	21	autom4te.cache
21	22	build
22	23	check_all.err

+27

-16

bin/svn_merge.sh less more

0	0	#! /bin/bash -e
1		# $Id: svn_merge.sh 3073 2014-01-01 11:48:13Z bradbell $
	1	# $Id: svn_merge.sh 3301 2014-05-24 05:20:21Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

9	9	# A copy of this license is included in the COPYING file of this distribution.
10	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11	11	# -----------------------------------------------------------------------------
12		if [ ! -e "bin/svn_merge.sh" ]
	12	if [ "$0" != "bin/svn_merge.sh" ]
13	13	then
14	14	echo "bin/svn_merge.sh: must be executed from its parent directory"
15	15	exit 1
16	16	fi
17	17	# -----------------------------------------------------------------------------
18		#
19	18	# Merge the changes that occurred in from_branch into the current directory
20	19	#
21		DryRun="--dry-run"
22		if [ "$1" == "not-dry-run" ]
23		then
24		DryRun=""
25		fi
26		echo "DryRun = $DryRun"
	20	# backup this file (incase it gets overwritten by merge)
	21	cp bin/svn_merge.sh bin/svn_merge.sh.$$
27	22	#
28		# script to help in execution of svn merge command
	23	# make sure current direction is up to date
	24	svn update
	25	#
	26	# dry_run='--dry-run'
	27	# dry_run=''
	28	dry_run=''
	29	#
	30	# accept='--accept theirs-full'
	31	# accept=''
	32	accept='--accept theirs-full'
29	33	#
30	34	# Location of the repository
31	35	repository='https://projects.coin-or.org/svn/CppAD'
32	36	#
33	37	# Name of the directory where the changes have been committed
34		from_branch='trunk'
	38	from_branch='branches/forward_dir'
35	39	#
36	40	# Version of the repository corresponding to from_branch just before changes
37		Start=3067
	41	Start=3219
38	42	#
39	43	# Version of the repository corresponding to from_branch after the changes
40		End=3071
	44	End=3300
41	45	#
42	46	# the svn merge command
43		cmd="svn merge $DryRun -r $Start:$End $repository/$from_branch"
	47	cmd="svn merge $accept $dry_run -r $Start:$End $repository/$from_branch"
44	48	echo "$cmd"
45		$cmd
	49	eval $cmd
	50	#
	51	# restore original version of this file
	52	mv bin/svn_merge.sh.$$ bin/svn_merge.sh
	53	#
	54	# get the current status
	55	echo "svn status > svn_merge.log"
	56	svn status > svn_merge.log

+45

-0

bin/trace.sh less more

	0	#! /bin/bash -e
	1	# $Id: trace.sh 3392 2014-10-06 12:46:42Z bradbell $
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4	#
	5	# CppAD is distributed under multiple licenses. This distribution is under
	6	# the terms of the
	7	# GNU General Public License Version 3.
	8	#
	9	# A copy of this license is included in the COPYING file of this distribution.
	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	# -----------------------------------------------------------------------------
	12	if [ $0 != "bin/trace.sh" ]
	13	then
	14	echo "bin/trace.sh: must be executed from its parent directory"
	15	exit 1
	16	fi
	17	name="$1"
	18	option="$2"
	19	file="cppad/local/$name.hpp"
	20	#
	21	ok='yes'
	22	if [ "$option" != '0' ] && [ "$option" != '1' ]
	23	then
	24	ok='no'
	25	fi
	26	echo "grep '_TRACE [01]' $file"
	27	if ! grep '_TRACE [01]' $file > /dev/null
	28	then
	29	ok='no'
	30	fi
	31	if [ "$ok" == 'no' ]
	32	then
	33	echo 'usage: bin/trace.sh name (0\|1)'
	34	echo ' where the file cppad/local/name.hpp has a defined TRACE option'
	35	exit 1
	36	fi
	37	old=`grep '_TRACE [01]' $file`
	38	sed -e "s\|TRACE [01]\|TRACE $option\|" -i $file
	39	new=`grep '_TRACE [01]' $file`
	40	#
	41	echo "old: $old"
	42	echo "new: $new"
	43	#
	44	exit 0

-2

bin/version.sh less more

0	0	#! /bin/bash -e
1		# $Id: version.sh 2725 2013-01-07 03:52:36Z bradbell $
	1	# $Id: version.sh 3479 2014-12-17 14:03:11Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#

74	74	#
75	75	echo 'sed -i.old configure.ac ...'
76	76	sed \
77		-e "s/(cppad, [0-9]\{8\}[.0-9]* *,/(cppad, $version,/" \
	77	-e "s/(\[cppad\], \[[0-9]\{8\}[.0-9]\] *,/([cppad], [$version],/" \
78	78	-i.old configure.ac
79	79	#
80	80	echo 'sed -i.old configure ...'

-112

~~bug/atomic_atomic.sh~~ less more

0		#! /bin/bash -e
1		# $Id: atomic_atomic.sh 3022 2013-12-24 14:25:43Z bradbell $
2		# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4		#
5		# CppAD is distributed under multiple licenses. This distribution is under
6		# the terms of the
7		# GNU General Public License Version 3.
8		#
9		# A copy of this license is included in the COPYING file of this distribution.
10		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		# -----------------------------------------------------------------------------
12		# Missing error message when result of an atomic fucntion is used as
13		# argument to another atomic function (and the tape is optimized)
14		# -----------------------------------------------------------------------------
15		if [ ! -e build ]
16		then
17		mkdir build
18		fi
19		cd build
20		echo "$0"
21		name=`echo $0 \| sed -e 's\|./\|\|' -e 's\|\..\|\|'`
22		cat << EOF > $name.cpp
23		# include <cppad/cppad.hpp>
24		# define DEFINE_REVERSE_SPARSE_JACOBIAN 0 // change to 1 and program will work
25
26		namespace {
27		using CppAD::vector;
28		using CppAD::AD;
29
30		class atomic_user : public CppAD::atomic_base<double> {
31		public:
32		atomic_user(const std::string& name) :
33		CppAD::atomic_base<double>(name) {}
34		private:
35		virtual bool forward(
36		size_t q , // lowest order Taylor coeff
37		size_t p , // highest order Taylor coeff
38		const vector<bool>& vx , // which x elements are variables
39		vector<bool>& vy , // which y elements are variables
40		const vector<double>& tx , // input vector of x
41		vector<double>& ty ) // output vector of y
42		{
43		if( vx.size() > 0 )
44		vy[0] = vx[0];
45
46		if ((q <= 0) && (p == 0))
47		{ ty[0] = tx[0];
48		return true;
49		}
50		return false;
51		}
52
53		# if DEFINE_REVERSE_SPARSE_JACOBIAN
54		// reverse Jacobian set sparsity routine called by CppAD
55		// This function needed because using optimize.
56		virtual bool rev_sparse_jac(
57		size_t q ,
58		const vector< std::set<size_t> >& rt ,
59		vector< std::set<size_t> >& st )
60		{ // This function needed if using RevSparseJac (or optimize)
61		size_t n = st.size();
62		size_t m = rt.size();
63		assert( n == 1 );
64		assert( m == 1 );
65
66		// sparsity for S(x)^T = f'(x)^T * R^T is same as for R^T
67		st[0] = rt[0];
68
69		return true;
70		}
71		# endif
72
73		}; // end class
74		}
75		int main() {
76		atomic_user func("atomic_user");
77		size_t n = 1;
78		vector< AD<double> > ax(n), ay(1), au(1), av(1);
79		vector<double> x(n), y_before(1), y_after(1);
80
81		ax[0] = x[0] = 3.0;
82		CppAD::Independent(ax);
83		//
84		au[0] = ax[0];
85		func(au, av);
86		//
87		au[0] = av[0];
88		func(au, av);
89		//
90		ay[0] = av[0];
91
92		CppAD::ADFun<double> f;
93		f.Dependent(ax,ay);
94
95		std::cout << "-----------------------------------------------------\n";
96		std::cout << "Expect an erorr message about missing rev_sparse_jac:\n";
97		std::cout << "-----------------------------------------------------\n";
98		f.optimize();
99		y_after = f.Forward(0,x);
100
101		return(0);
102		}
103		EOF
104		echo "g++ -I../.. --std=c++11 -g $name.cpp -o $name"
105		g++ -I../.. --std=c++11 -g $name.cpp -o $name
106		#
107		echo "./$name"
108		./$name
109		#
110		echo "rm $name $name.cpp"
111		rm $name $name.cpp

+55

-0

bug/cmake_target.sh less more

	0	#! /bin/bash -e
	1	# $Id: cmake_target.sh 3090 2014-01-31 11:31:54Z bradbell $
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4	#
	5	# CppAD is distributed under multiple licenses. This distribution is under
	6	# the terms of the
	7	# GNU General Public License Version 3.
	8	#
	9	# A copy of this license is included in the COPYING file of this distribution.
	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	# -----------------------------------------------------------------------------
	12	#! /bin/bash -e
	13	echo 'This script does not work properly on el6; see'
	14	echo 'https://bugzilla.redhat.com/show_bug.cgi?id=896116'
	15	echo
	16	#
	17	if [ -e build ]
	18	then
	19	rm -r build
	20	fi
	21	mkdir build
	22	cd build
	23	cat << EOF > hello_one.cpp
	24	# include <iostream>
	25	int main(void)
	26	{ std::cout << "hello_one" << std::endl << std::endl;
	27	return 0;
	28	}
	29	EOF
	30	cat << EOF > hello_two.cpp
	31	# include <iostream>
	32	int main(void)
	33	{ std::cout << "hello_two" << std::endl << std::endl;
	34	return 0;
	35	}
	36	EOF
	37	cat << EOF > CMakeLists.txt
	38	CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
	39	#
	40	PROJECT(hello)
	41	#
	42	ADD_EXECUTABLE(hello_one EXCLUDE_FROM_ALL hello_one.cpp )
	43	ADD_EXECUTABLE(hello_two EXCLUDE_FROM_ALL hello_two.cpp )
	44	#
	45	ADD_CUSTOM_TARGET(check_one hello_one DEPENDS hello_one)
	46	ADD_CUSTOM_TARGET(check_two hello_two DEPENDS hello_two)
	47	#
	48	ADD_CUSTOM_TARGET(check DEPENDS check_one check_two)
	49	EOF
	50	#
	51	uname -a
	52	cmake --version
	53	cmake .
	54	make check

+94

-0

bug/doxy_member.sh less more

	0	#! /bin/bash -e
	1	# $Id: doxy_member.sh 3237 2014-04-28 13:28:43Z bradbell $
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4	#
	5	# CppAD is distributed under multiple licenses. This distribution is under
	6	# the terms of the
	7	# GNU General Public License Version 3.
	8	#
	9	# A copy of this license is included in the COPYING file of this distribution.
	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	# -----------------------------------------------------------------------------
	12	# Trying to figure out why ADFun::Forward appers twice where there is only
	13	# one implementation.
	14	#
	15	# ------------------------------------------------------------------------------
	16	# bash function that echos and executes a command
	17	echo_eval() {
	18	echo $*
	19	eval $*
	20	}
	21	# -----------------------------------------------
	22	echo "$0"
	23	name=`echo $0 \| sed -e 's\|./\|\|' -e 's\|\..\|\|'`
	24	# -----------------------------------------------
	25	for dir in build doxy_member
	26	do
	27	if [ ! -e $dir ]
	28	then
	29	mkdir $dir
	30	fi
	31	cd $dir
	32	done
	33	# -------------------------------------------------------------------------
	34	cat << EOF > $name.hpp
	35
	36	template<class T>
	37	class my_class {
	38	private:
	39	T value_;
	40	public:
	41	void set_value(T value = 0);
	42	T get_value(void);
	43	};
	44	EOF
	45	cat << EOF > implement.hpp
	46	/*!
	47	\\file implement.hpp
	48	Implementation of member functions
	49	*/
	50
	51	/*!
	52	Member function that sets the value.
	53
	54	\\param value [in]
	55	New value.
	56	*/
	57	template<class T>
	58	void my_class<T>::set_value(T value)
	59	{ value_ = value; }
	60
	61	/*!
	62	Member function that gets the value.
	63
	64	\\return
	65	Current value.
	66	*/
	67	template<class T>
	68	T my_class<T>::get_value(void)
	69	{ return value_; }
	70	EOF
	71	cat << EOF > $name.cpp
	72	# include <iostream>
	73	# include "$name.hpp"
	74	# include "implement.hpp"
	75	int main(void)
	76	{ my_class<int> x;
	77	x.set_value(2);
	78	std::cout << "x.value = " << x.get_value() << std::endl;
	79	return 0;
	80	}
	81	EOF
	82	# -------------------------------------------------------------------------
	83	# echo_eval doxygen -g doxyfile
	84	cp ../../../doxyfile .
	85	sed \
	86	-e 's\|^$INPUT *=$\|& .\|' \
	87	-e 's\|^$FILE_PATTERNS =$\|& .hpp *.cpp\|' \
	88	-i doxyfile
	89	# -------------------------------------------------------------------------
	90	echo_eval doxygen doxyfile
	91	# -------------------------------------------------------------------------
	92	echo_eval g++ $name.cpp -o name
	93	echo_eval ./name

-1

bug/eigen_shadow.sh less more

0	0	#! /bin/bash -e
1		# $Id: eigen_shadow.sh 3067 2013-12-29 17:35:34Z bradbell $
	1	# $Id: eigen_shadow.sh 3066 2013-12-29 17:27:20Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#

+48

-0

bug/template.sh less more

	0	#! /bin/bash -e
	1	# $Id: template.sh 3370 2014-09-28 10:52:36Z bradbell $
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	4	#
	5	# CppAD is distributed under multiple licenses. This distribution is under
	6	# the terms of the
	7	# GNU General Public License Version 3.
	8	#
	9	# A copy of this license is included in the COPYING file of this distribution.
	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	# -----------------------------------------------------------------------------
	12	cat << EOF
	13	Description
	14	EOF
	15	cat << EOF > bug.$$
	16	# include <iostream>
	17	int main(void)
	18	{ // C++ source code
	19	using std::cout;
	20
	21	cout << "1. svn copy template.sh <name>.sh\n";
	22	cout << "2. Edit <name>.sh replacing description and C++ source code\n";
	23	cout << "3. Run ./<name>.sh\n";
	24	cout << "where <name> is a name that describes the bug\n";
	25
	26	return 0;
	27	}
	28	EOF
	29	# -----------------------------------------------------------------------------
	30	if [ ! -e build ]
	31	then
	32	mkdir build
	33	fi
	34	cd build
	35	echo "$0"
	36	name=`echo $0 \| sed -e 's\|./\|\|' -e 's\|\..\|\|'`
	37	mv ../bug.$$ $name.cpp
	38	echo "g++ -I../.. --std=c++11 -g $name.cpp -o $name"
	39	g++ -I../.. --std=c++11 -g $name.cpp -o $name
	40	#
	41	echo "./$name"
	42	if ./$name
	43	then
	44	echo "OK"
	45	else
	46	echo "Error"
	47	fi

-5

build.sh less more

0	0	#! /bin/bash -e
1		# $Id: build.sh 3067 2013-12-29 17:35:34Z bradbell $
2		# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	1	# $Id: build.sh 3509 2014-12-27 20:38:37Z bradbell $
	2	# -----------------------------------------------------------------------------
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

218	218	cxx_flags="-Wall -ansi -pedantic-errors -std=c++98 -Wshadow"
219	219	#_build_test_only: if [ -e $EIGEN_DIR/include/Eigen ]
220	220	#_build_test_only: then
221		#_build_test_only: cxx_flags="-Wall -ansi -pedantic-errors -std=c++98 -Wno-long-long"
	221	#_build_test_only: cxx_flags="-Wall -ansi -pedantic-errors -std=c++98 -Wno-long-long -Wno-sign-compare"
222	222	#_build_test_only: fi
223	223	cat << EOF
224	224	../configure > $log_file \\

281	281	#
282	282	# Run automated checking of file names in original source directory
283	283	list="
	284	check_define.sh
284	285	check_example.sh
285		check_if_0.sh
	286	check_if.sh
286	287	check_include_def.sh
287	288	check_include_file.sh
288	289	check_include_omh.sh

+10

-1

cmake/add_cppad_cxx_flags.cmake less more

0		# $Id: add_cppad_cxx_flags.cmake 2859 2013-05-28 06:03:21Z bradbell $
	0	# $Id: add_cppad_cxx_flags.cmake 3320 2014-09-11 23:06:21Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3	#

28	28	FOREACH(package eigen fadbad sacado)
29	29	IF( ${target_name} MATCHES ".*_${package}$" )
30	30	SET(flags "${cppad_cxx_flags_${package}}")
	31	MESSAGE(STATUS
	32	"${target_name} cxx_flags = ${cppad_cxx_flags_${package}}"
	33	)
31	34	ENDIF( ${target_name} MATCHES ".*_${package}$" )
	35	IF( ${target_name} MATCHES ".*_${package}_lib$" )
	36	SET(flags "${cppad_cxx_flags_${package}}")
	37	MESSAGE(STATUS
	38	"${target_name} cxx_flags = ${cppad_cxx_flags_${package}}"
	39	)
	40	ENDIF( ${target_name} MATCHES ".*_${package}_lib$" )
32	41	ENDFOREACH(package)
33	42	IF( flags )
34	43	SET_TARGET_PROPERTIES(

+35

-0

cmake/sources_libs_define.cmake less more

	0	# $Id: sources_libs_define.cmake 3119 2014-02-25 11:52:41Z bradbell $
	1	# -----------------------------------------------------------------------------
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3	#
	4	# CppAD is distributed under multiple licenses. This distribution is under
	5	# the terms of the
	6	# Eclipse Public License Version 1.0.
	7	#
	8	# A copy of this license is included in the COPYING file of this distribution.
	9	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	# -----------------------------------------------------------------------------
	11	# sources_libs_define(prefix_name sources libs define)
	12	#
	13	# prefix_name: (in)
	14	# If the variable ${prefix_name}_prefix is NOTFOUND,
	15	# sources and libs are set to the empty string "" and no definition is added.
	16	#
	17	# Otherwise ${prefix_name}_sources is set to ${sources},
	18	# ${prefix_name}_libs is set to ${libs}. If ${define} is not empty "",
	19	# the defintion -DCPPAD_${define} is added; i.e.,
	20	# ADD_DEFINITIONS("-DCPPAD_${define}")
	21	#
	22	MACRO(sources_libs_define prefix_name soruces libs define)
	23	IF ( ${prefix_name}_prefix )
	24	SET( ${prefix_name}_sources ${sources} )
	25	SET( ${prefix_name}_libs ${libs} )
	26	IF( NOT "${define}" STREQUAL "" )
	27	ADD_DEFINITIONS("-DCPPAD_${define}")
	28	MESSAGE(STATUS "-DCPPAD_${define}" )
	29	ENDIF( NOT "${define}" STREQUAL "" )
	30	ELSE ( ${prefix_name}_prefix )
	31	SET( ${prefix_name}_sources "" )
	32	SET( ${prefix_name}_libs "" )
	33	ENDIF ( ${prefix_name}_prefix )
	34	ENDMACRO( sources_libs_define )

+157

-81

compare_c/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = det_by_minor_c$(EXEEXT) det_by_minor_cpp$(EXEEXT)
51	80	subdir = compare_c
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

63	93	am_det_by_minor_cpp_OBJECTS = det_by_minor_cpp.$(OBJEXT)
64	94	det_by_minor_cpp_OBJECTS = $(am_det_by_minor_cpp_OBJECTS)
65	95	det_by_minor_cpp_LDADD = $(LDADD)
	96	AM_V_P = $(am__v_P_@AM_V@)
	97	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	98	am__v_P_0 = false
	99	am__v_P_1 = :
	100	AM_V_GEN = $(am__v_GEN_@AM_V@)
	101	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	102	am__v_GEN_0 = @echo " GEN " $@;
	103	am__v_GEN_1 =
	104	AM_V_at = $(am__v_at_@AM_V@)
	105	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	106	am__v_at_0 = @
	107	am__v_at_1 =
66	108	DEFAULT_INCLUDES =
67	109	depcomp = $(SHELL) $(top_srcdir)/depcomp
68	110	am__depfiles_maybe = depfiles

71	113	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
72	114	AM_V_CC = $(am__v_CC_@AM_V@)
73	115	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
74		am__v_CC_0 = @echo " CC " $@;
75		AM_V_at = $(am__v_at_@AM_V@)
76		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
77		am__v_at_0 = @
	116	am__v_CC_0 = @echo " CC " $@;
	117	am__v_CC_1 =
78	118	CCLD = $(CC)
79	119	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
80	120	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
81	121	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
82		am__v_CCLD_0 = @echo " CCLD " $@;
	122	am__v_CCLD_0 = @echo " CCLD " $@;
	123	am__v_CCLD_1 =
83	124	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
84	125	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
85	126	AM_V_CXX = $(am__v_CXX_@AM_V@)
86	127	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
87		am__v_CXX_0 = @echo " CXX " $@;
	128	am__v_CXX_0 = @echo " CXX " $@;
	129	am__v_CXX_1 =
88	130	CXXLD = $(CXX)
89	131	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
90	132	-o $@
91	133	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
92	134	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
93		am__v_CXXLD_0 = @echo " CXXLD " $@;
94		AM_V_GEN = $(am__v_GEN_@AM_V@)
95		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
96		am__v_GEN_0 = @echo " GEN " $@;
	135	am__v_CXXLD_0 = @echo " CXXLD " $@;
	136	am__v_CXXLD_1 =
97	137	SOURCES = $(det_by_minor_c_SOURCES) $(det_by_minor_cpp_SOURCES)
98	138	DIST_SOURCES = $(det_by_minor_c_SOURCES) $(det_by_minor_cpp_SOURCES)
99	139	am__can_run_installinfo = \

101	141	n\|no\|NO) false;; \
102	142	*) (install-info --version) >/dev/null 2>&1;; \
103	143	esac
	144	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	145	# Read a list of newline-separated strings from the standard input,
	146	# and print each of them once, without duplicates. Input order is
	147	# not preserved.
	148	am__uniquify_input = $(AWK) '\
	149	BEGIN { nonempty = 0; } \
	150	{ items[$$0] = 1; nonempty = 1; } \
	151	END { if (nonempty) { for (i in items) print i; }; } \
	152	'
	153	# Make sure the list of sources is unique. This is necessary because,
	154	# e.g., the same source file might be shared among _SOURCES variables
	155	# for different programs/libraries.
	156	am__define_uniq_tagged_files = \
	157	list='$(am__tagged_files)'; \
	158	unique=`for i in $$list; do \
	159	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	160	done \| $(am__uniquify_input)`
104	161	ETAGS = etags
105	162	CTAGS = ctags
106	163	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

110	167	ADOLC_DIR = @ADOLC_DIR@
111	168	AMTAR = @AMTAR@
112	169	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	170	AR = @AR@
113	171	AUTOCONF = @AUTOCONF@
114	172	AUTOHEADER = @AUTOHEADER@
115	173	AUTOMAKE = @AUTOMAKE@

186	244	abs_srcdir = @abs_srcdir@
187	245	abs_top_builddir = @abs_top_builddir@
188	246	abs_top_srcdir = @abs_top_srcdir@
	247	ac_ct_AR = @ac_ct_AR@
189	248	ac_ct_CC = @ac_ct_CC@
190	249	ac_ct_CXX = @ac_ct_CXX@
191	250	ac_ct_FC = @ac_ct_FC@

196	255	am__tar = @am__tar@
197	256	am__untar = @am__untar@
198	257	bindir = @bindir@
	258	build = @build@
199	259	build_alias = @build_alias@
	260	build_cpu = @build_cpu@
	261	build_os = @build_os@
	262	build_vendor = @build_vendor@
200	263	builddir = @builddir@
201	264	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
202	265	cppad_boostvector = @cppad_boostvector@
203	266	cppad_cflags = @cppad_cflags@
	267	cppad_compiler_has_erf = @cppad_compiler_has_erf@
204	268	cppad_cppadvector = @cppad_cppadvector@
205	269	cppad_description = @cppad_description@
206	270	cppad_eigenvector = @cppad_eigenvector@
	271	cppad_has_colpack = @cppad_has_colpack@
	272	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
207	273	cppad_has_gettimeofday = @cppad_has_gettimeofday@
208	274	cppad_has_nullptr = @cppad_has_nullptr@
	275	cppad_has_rvalue = @cppad_has_rvalue@
209	276	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
210	277	cppad_internal_sparse_set = @cppad_internal_sparse_set@
211	278	cppad_libs = @cppad_libs@
212	279	cppad_max_num_threads = @cppad_max_num_threads@
213	280	cppad_requires = @cppad_requires@
214		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	281	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
215	282	cppad_stdvector = @cppad_stdvector@
216	283	cppad_tape_addr_type = @cppad_tape_addr_type@
217	284	cppad_tape_id_type = @cppad_tape_id_type@

223	290	dvidir = @dvidir@
224	291	eigen_prefix = @eigen_prefix@
225	292	exec_prefix = @exec_prefix@
226		have_ar = @have_ar@
227	293	have_pkg_config = @have_pkg_config@
	294	host = @host@
228	295	host_alias = @host_alias@
	296	host_cpu = @host_cpu@
	297	host_os = @host_os@
	298	host_vendor = @host_vendor@
229	299	htmldir = @htmldir@
230	300	includedir = @includedir@
231	301	infodir = @infodir@

251	321	top_builddir = @top_builddir@
252	322	top_srcdir = @top_srcdir@
253	323
254		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	324	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
255	325	# -----------------------------------------------------------------------------
256	326	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
257	327	#

317	387
318	388	clean-checkPROGRAMS:
319	389	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	390
320	391	det_by_minor_c$(EXEEXT): $(det_by_minor_c_OBJECTS) $(det_by_minor_c_DEPENDENCIES) $(EXTRA_det_by_minor_c_DEPENDENCIES)
321	392	@rm -f det_by_minor_c$(EXEEXT)
322	393	$(AM_V_CCLD)$(LINK) $(det_by_minor_c_OBJECTS) $(det_by_minor_c_LDADD) $(LIBS)
	394
323	395	det_by_minor_cpp$(EXEEXT): $(det_by_minor_cpp_OBJECTS) $(det_by_minor_cpp_DEPENDENCIES) $(EXTRA_det_by_minor_cpp_DEPENDENCIES)
324	396	@rm -f det_by_minor_cpp$(EXEEXT)
325	397	$(AM_V_CXXLD)$(CXXLINK) $(det_by_minor_cpp_OBJECTS) $(det_by_minor_cpp_LDADD) $(LIBS)

334	406	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/det_by_minor_cpp.Po@am__quote@
335	407
336	408	.c.o:
337		@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
338		@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	409	@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	410	@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	411	@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
339	412	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
340	413	@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
341		@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c $<
	414	@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
342	415
343	416	.c.obj:
344		@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
345		@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	417	@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	418	@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	419	@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
346	420	@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
347	421	@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
348		@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c `$(CYGPATH_W) '$<'`
	422	@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
349	423
350	424	.cpp.o:
351		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
352		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	425	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	426	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	427	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
353	428	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
354	429	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
355	430	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
356	431
357	432	.cpp.obj:
358		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
359		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	433	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	434	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	435	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
360	436	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
361	437	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
362	438	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
363	439
364		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
365		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
366		unique=`for i in $$list; do \
367		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
368		done \| \
369		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
370		END { if (nonempty) { for (i in files) print i; }; }'`; \
371		mkid -fID $$unique
372		tags: TAGS
373
374		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
375		$(TAGS_FILES) $(LISP)
	440	ID: $(am__tagged_files)
	441	$(am__define_uniq_tagged_files); mkid -fID $$unique
	442	tags: tags-am
	443	TAGS: tags
	444
	445	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
376	446	set x; \
377	447	here=`pwd`; \
378		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
379		unique=`for i in $$list; do \
380		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
381		done \| \
382		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
383		END { if (nonempty) { for (i in files) print i; }; }'`; \
	448	$(am__define_uniq_tagged_files); \
384	449	shift; \
385	450	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
386	451	test -n "$$unique" \|\| unique=$$empty_fix; \

392	457	$$unique; \
393	458	fi; \
394	459	fi
395		ctags: CTAGS
396		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
397		$(TAGS_FILES) $(LISP)
398		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
399		unique=`for i in $$list; do \
400		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
401		done \| \
402		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
403		END { if (nonempty) { for (i in files) print i; }; }'`; \
	460	ctags: ctags-am
	461
	462	CTAGS: ctags
	463	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	464	$(am__define_uniq_tagged_files); \
404	465	test -z "$(CTAGS_ARGS)$$unique" \
405	466	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
406	467	$$unique

409	470	here=`$(am__cd) $(top_builddir) && pwd` \
410	471	&& $(am__cd) $(top_srcdir) \
411	472	&& gtags -i $(GTAGS_ARGS) "$$here"
	473	cscopelist: cscopelist-am
	474
	475	cscopelist-am: $(am__tagged_files)
	476	list='$(am__tagged_files)'; \
	477	case "$(srcdir)" in \
	478	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	479	*) sdir=$(subdir)/$(srcdir) ;; \
	480	esac; \
	481	for i in $$list; do \
	482	if test -f "$$i"; then \
	483	echo "$(subdir)/$$i"; \
	484	else \
	485	echo "$$sdir/$$i"; \
	486	fi; \
	487	done >> $(top_builddir)/cscope.files
412	488
413	489	distclean-tags:
414	490	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

552	628
553	629	.MAKE: all check check-am install install-am install-strip
554	630
555		.PHONY: CTAGS GTAGS all all-am check check-am clean \
556		clean-checkPROGRAMS clean-generic ctags distclean \
557		distclean-compile distclean-generic distclean-tags distdir dvi \
558		dvi-am html html-am info info-am install install-am \
559		install-data install-data-am install-dvi install-dvi-am \
560		install-exec install-exec-am install-html install-html-am \
561		install-info install-info-am install-man install-pdf \
562		install-pdf-am install-ps install-ps-am install-strip \
563		installcheck installcheck-am installdirs maintainer-clean \
564		maintainer-clean-generic mostlyclean mostlyclean-compile \
565		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
566		uninstall-am
	631	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	632	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	633	distclean distclean-compile distclean-generic distclean-tags \
	634	distdir dvi dvi-am html html-am info info-am install \
	635	install-am install-data install-data-am install-dvi \
	636	install-dvi-am install-exec install-exec-am install-html \
	637	install-html-am install-info install-info-am install-man \
	638	install-pdf install-pdf-am install-ps install-ps-am \
	639	install-strip installcheck installcheck-am installdirs \
	640	maintainer-clean maintainer-clean-generic mostlyclean \
	641	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	642	tags tags-am uninstall uninstall-am
567	643
568	644	det_by_minor_c.c: det_by_minor.c
569	645	cp $(srcdir)/det_by_minor.c det_by_minor_c.c

+1420

-0

config.guess less more

	0	#! /bin/sh
	1	# Attempt to guess a canonical system name.
	2	# Copyright 1992-2014 Free Software Foundation, Inc.
	3
	4	timestamp='2014-03-23'
	5
	6	# This file is free software; you can redistribute it and/or modify it
	7	# under the terms of the GNU General Public License as published by
	8	# the Free Software Foundation; either version 3 of the License, or
	9	# (at your option) any later version.
	10	#
	11	# This program is distributed in the hope that it will be useful, but
	12	# WITHOUT ANY WARRANTY; without even the implied warranty of
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	# General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License
	17	# along with this program; if not, see <http://www.gnu.org/licenses/>.
	18	#
	19	# As a special exception to the GNU General Public License, if you
	20	# distribute this file as part of a program that contains a
	21	# configuration script generated by Autoconf, you may include it under
	22	# the same distribution terms that you use for the rest of that
	23	# program. This Exception is an additional permission under section 7
	24	# of the GNU General Public License, version 3 ("GPLv3").
	25	#
	26	# Originally written by Per Bothner.
	27	#
	28	# You can get the latest version of this script from:
	29	# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
	30	#
	31	# Please send patches with a ChangeLog entry to config-patches@gnu.org.
	32
	33
	34	me=`echo "$0" \| sed -e 's,.*/,,'`
	35
	36	usage="\
	37	Usage: $0 [OPTION]
	38
	39	Output the configuration name of the system \`$me' is run on.
	40
	41	Operation modes:
	42	-h, --help print this help, then exit
	43	-t, --time-stamp print date of last modification, then exit
	44	-v, --version print version number, then exit
	45
	46	Report bugs and patches to <config-patches@gnu.org>."
	47
	48	version="\
	49	GNU config.guess ($timestamp)
	50
	51	Originally written by Per Bothner.
	52	Copyright 1992-2014 Free Software Foundation, Inc.
	53
	54	This is free software; see the source for copying conditions. There is NO
	55	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
	56
	57	help="
	58	Try \`$me --help' for more information."
	59
	60	# Parse command line
	61	while test $# -gt 0 ; do
	62	case $1 in
	63	--time-stamp \| --time* \| -t )
	64	echo "$timestamp" ; exit ;;
	65	--version \| -v )
	66	echo "$version" ; exit ;;
	67	--help \| --h* \| -h )
	68	echo "$usage"; exit ;;
	69	-- ) # Stop option processing
	70	shift; break ;;
	71	- ) # Use stdin as input.
	72	break ;;
	73	-* )
	74	echo "$me: invalid option $1$help" >&2
	75	exit 1 ;;
	76	* )
	77	break ;;
	78	esac
	79	done
	80
	81	if test $# != 0; then
	82	echo "$me: too many arguments$help" >&2
	83	exit 1
	84	fi
	85
	86	trap 'exit 1' 1 2 15
	87
	88	# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
	89	# compiler to aid in system detection is discouraged as it requires
	90	# temporary files to be created and, as you can see below, it is a
	91	# headache to deal with in a portable fashion.
	92
	93	# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
	94	# use `HOST_CC' if defined, but it is deprecated.
	95
	96	# Portable tmp directory creation inspired by the Autoconf team.
	97
	98	set_cc_for_build='
	99	trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
	100	trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
	101	: ${TMPDIR=/tmp} ;
	102	{ tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } \|\|
	103	{ test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } \|\|
	104	{ tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } \|\|
	105	{ echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
	106	dummy=$tmp/dummy ;
	107	tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
	108	case $CC_FOR_BUILD,$HOST_CC,$CC in
	109	,,) echo "int x;" > $dummy.c ;
	110	for c in cc gcc c89 c99 ; do
	111	if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
	112	CC_FOR_BUILD="$c"; break ;
	113	fi ;
	114	done ;
	115	if test x"$CC_FOR_BUILD" = x ; then
	116	CC_FOR_BUILD=no_compiler_found ;
	117	fi
	118	;;
	119	,,*) CC_FOR_BUILD=$CC ;;
	120	,,) CC_FOR_BUILD=$HOST_CC ;;
	121	esac ; set_cc_for_build= ;'
	122
	123	# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
	124	# (ghazi@noc.rutgers.edu 1994-08-24)
	125	if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
	126	PATH=$PATH:/.attbin ; export PATH
	127	fi
	128
	129	UNAME_MACHINE=`(uname -m) 2>/dev/null` \|\| UNAME_MACHINE=unknown
	130	UNAME_RELEASE=`(uname -r) 2>/dev/null` \|\| UNAME_RELEASE=unknown
	131	UNAME_SYSTEM=`(uname -s) 2>/dev/null` \|\| UNAME_SYSTEM=unknown
	132	UNAME_VERSION=`(uname -v) 2>/dev/null` \|\| UNAME_VERSION=unknown
	133
	134	case "${UNAME_SYSTEM}" in
	135	Linux\|GNU\|GNU/*)
	136	# If the system lacks a compiler, then just pick glibc.
	137	# We could probably try harder.
	138	LIBC=gnu
	139
	140	eval $set_cc_for_build
	141	cat <<-EOF > $dummy.c
	142	#include <features.h>
	143	#if defined(__UCLIBC__)
	144	LIBC=uclibc
	145	#elif defined(__dietlibc__)
	146	LIBC=dietlibc
	147	#else
	148	LIBC=gnu
	149	#endif
	150	EOF
	151	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null \| grep '^LIBC' \| sed 's, ,,g'`
	152	;;
	153	esac
	154
	155	# Note: order is significant - the case branches are not exclusive.
	156
	157	case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
	158	:NetBSD::*)
	159	# NetBSD (nbsd) targets should (where applicable) match one or
	160	# more of the tuples: --netbsdelf, --netbsdaout,
	161	# --netbsdecoff* and --netbsd*. For targets that recently
	162	# switched to ELF, --netbsd* would select the old
	163	# object file format. This provides both forward
	164	# compatibility and a consistent mechanism for selecting the
	165	# object file format.
	166	#
	167	# Note: NetBSD doesn't particularly care about the vendor
	168	# portion of the name. We always set it to "unknown".
	169	sysctl="sysctl -n hw.machine_arch"
	170	UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null \|\| \
	171	/usr/sbin/$sysctl 2>/dev/null \|\| echo unknown)`
	172	case "${UNAME_MACHINE_ARCH}" in
	173	armeb) machine=armeb-unknown ;;
	174	arm*) machine=arm-unknown ;;
	175	sh3el) machine=shl-unknown ;;
	176	sh3eb) machine=sh-unknown ;;
	177	sh5el) machine=sh5le-unknown ;;
	178	*) machine=${UNAME_MACHINE_ARCH}-unknown ;;
	179	esac
	180	# The Operating System including object format, if it has switched
	181	# to ELF recently, or will in the future.
	182	case "${UNAME_MACHINE_ARCH}" in
	183	arm\|i386\|m68k\|ns32k\|sh3\|sparc\|vax)
	184	eval $set_cc_for_build
	185	if echo __ELF__ \| $CC_FOR_BUILD -E - 2>/dev/null \
	186	\| grep -q __ELF__
	187	then
	188	# Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
	189	# Return netbsd for either. FIX?
	190	os=netbsd
	191	else
	192	os=netbsdelf
	193	fi
	194	;;
	195	*)
	196	os=netbsd
	197	;;
	198	esac
	199	# The OS release
	200	# Debian GNU/NetBSD machines have a different userland, and
	201	# thus, need a distinct triplet. However, they do not need
	202	# kernel version information, so it can be replaced with a
	203	# suitable tag, in the style of linux-gnu.
	204	case "${UNAME_VERSION}" in
	205	Debian*)
	206	release='-gnu'
	207	;;
	208	*)
	209	release=`echo ${UNAME_RELEASE}\|sed -e 's/[-_].*/\./'`
	210	;;
	211	esac
	212	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
	213	# contains redundant information, the shorter form:
	214	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
	215	echo "${machine}-${os}${release}"
	216	exit ;;
	217	:Bitrig::*)
	218	UNAME_MACHINE_ARCH=`arch \| sed 's/Bitrig.//'`
	219	echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
	220	exit ;;
	221	:OpenBSD::*)
	222	UNAME_MACHINE_ARCH=`arch \| sed 's/OpenBSD.//'`
	223	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
	224	exit ;;
	225	:ekkoBSD::*)
	226	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
	227	exit ;;
	228	:SolidBSD::*)
	229	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
	230	exit ;;
	231	macppc:MirBSD::)
	232	echo powerpc-unknown-mirbsd${UNAME_RELEASE}
	233	exit ;;
	234	:MirBSD::*)
	235	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
	236	exit ;;
	237	alpha:OSF1::)
	238	case $UNAME_RELEASE in
	239	*4.0)
	240	UNAME_RELEASE=`/usr/sbin/sizer -v \| awk '{print $3}'`
	241	;;
	242	5.)
	243	UNAME_RELEASE=`/usr/sbin/sizer -v \| awk '{print $4}'`
	244	;;
	245	esac
	246	# According to Compaq, /usr/sbin/psrinfo has been available on
	247	# OSF/1 and Tru64 systems produced since 1995. I hope that
	248	# covers most systems running today. This code pipes the CPU
	249	# types through head -n 1, so we only detect the type of CPU 0.
	250	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v \| sed -n -e 's/^ The alpha $.$ processor.$/\1/p' \| head -n 1`
	251	case "$ALPHA_CPU_TYPE" in
	252	"EV4 (21064)")
	253	UNAME_MACHINE="alpha" ;;
	254	"EV4.5 (21064)")
	255	UNAME_MACHINE="alpha" ;;
	256	"LCA4 (21066/21068)")
	257	UNAME_MACHINE="alpha" ;;
	258	"EV5 (21164)")
	259	UNAME_MACHINE="alphaev5" ;;
	260	"EV5.6 (21164A)")
	261	UNAME_MACHINE="alphaev56" ;;
	262	"EV5.6 (21164PC)")
	263	UNAME_MACHINE="alphapca56" ;;
	264	"EV5.7 (21164PC)")
	265	UNAME_MACHINE="alphapca57" ;;
	266	"EV6 (21264)")
	267	UNAME_MACHINE="alphaev6" ;;
	268	"EV6.7 (21264A)")
	269	UNAME_MACHINE="alphaev67" ;;
	270	"EV6.8CB (21264C)")
	271	UNAME_MACHINE="alphaev68" ;;
	272	"EV6.8AL (21264B)")
	273	UNAME_MACHINE="alphaev68" ;;
	274	"EV6.8CX (21264D)")
	275	UNAME_MACHINE="alphaev68" ;;
	276	"EV6.9A (21264/EV69A)")
	277	UNAME_MACHINE="alphaev69" ;;
	278	"EV7 (21364)")
	279	UNAME_MACHINE="alphaev7" ;;
	280	"EV7.9 (21364A)")
	281	UNAME_MACHINE="alphaev79" ;;
	282	esac
	283	# A Pn.n version is a patched version.
	284	# A Vn.n version is a released version.
	285	# A Tn.n version is a released field test version.
	286	# A Xn.n version is an unreleased experimental baselevel.
	287	# 1.2 uses "1.2" for uname -r.
	288	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} \| sed -e 's/^[PVTX]//' \| tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
	289	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
	290	exitcode=$?
	291	trap '' 0
	292	exit $exitcode ;;
	293	Alpha\ :Windows_NT:*)
	294	# How do we know it's Interix rather than the generic POSIX subsystem?
	295	# Should we change UNAME_MACHINE based on the output of uname instead
	296	# of the specific Alpha model?
	297	echo alpha-pc-interix
	298	exit ;;
	299	21064:Windows_NT:50:3)
	300	echo alpha-dec-winnt3.5
	301	exit ;;
	302	Amiga:UNIX_System_V:4.0:)
	303	echo m68k-unknown-sysv4
	304	exit ;;
	305	:[Aa]miga[Oo][Ss]::*)
	306	echo ${UNAME_MACHINE}-unknown-amigaos
	307	exit ;;
	308	:[Mm]orph[Oo][Ss]::*)
	309	echo ${UNAME_MACHINE}-unknown-morphos
	310	exit ;;
	311	:OS/390::*)
	312	echo i370-ibm-openedition
	313	exit ;;
	314	:z/VM::*)
	315	echo s390-ibm-zvmoe
	316	exit ;;
	317	:OS400::*)
	318	echo powerpc-ibm-os400
	319	exit ;;
	320	arm:RISC:1.[012]:\|arm:riscix:1.[012]:*)
	321	echo arm-acorn-riscix${UNAME_RELEASE}
	322	exit ;;
	323	arm:riscos::\|arm:RISCOS::)
	324	echo arm-unknown-riscos
	325	exit ;;
	326	SR2?01:HI-UX/MPP:: \| SR8000:HI-UX/MPP::)
	327	echo hppa1.1-hitachi-hiuxmpp
	328	exit ;;
	329	Pyramid:OSx:: \| MIS:OSx:: \| MIS:SMP_DC-OSx::)
	330	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
	331	if test "`(/bin/universe) 2>/dev/null`" = att ; then
	332	echo pyramid-pyramid-sysv3
	333	else
	334	echo pyramid-pyramid-bsd
	335	fi
	336	exit ;;
	337	NILE::*:dcosx)
	338	echo pyramid-pyramid-svr4
	339	exit ;;
	340	DRS?6000:unix:4.0:6*)
	341	echo sparc-icl-nx6
	342	exit ;;
	343	DRS?6000:UNIX_SV:4.2:7 \| DRS?6000:isis:4.2:7)
	344	case `/usr/bin/uname -p` in
	345	sparc) echo sparc-icl-nx7; exit ;;
	346	esac ;;
	347	s390x:SunOS::)
	348	echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}\|sed -e 's/[^.]*//'`
	349	exit ;;
	350	sun4H:SunOS:5.:)
	351	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}\|sed -e 's/[^.]*//'`
	352	exit ;;
	353	sun4:SunOS:5.:* \| tadpole:SunOS:5.:*)
	354	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}\|sed -e 's/[^.]*//'`
	355	exit ;;
	356	i86pc:AuroraUX:5.: \| i86xen:AuroraUX:5.:)
	357	echo i386-pc-auroraux${UNAME_RELEASE}
	358	exit ;;
	359	i86pc:SunOS:5.: \| i86xen:SunOS:5.:)
	360	eval $set_cc_for_build
	361	SUN_ARCH="i386"
	362	# If there is a compiler, see if it is configured for 64-bit objects.
	363	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
	364	# This test works for both compilers.
	365	if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
	366	if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') \| \
	367	(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) \| \
	368	grep IS_64BIT_ARCH >/dev/null
	369	then
	370	SUN_ARCH="x86_64"
	371	fi
	372	fi
	373	echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}\|sed -e 's/[^.]*//'`
	374	exit ;;
	375	sun4:SunOS:6:*)
	376	# According to config.sub, this is the proper way to canonicalize
	377	# SunOS6. Hard to guess exactly what SunOS6 will be like, but
	378	# it's likely to be more like Solaris than SunOS4.
	379	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}\|sed -e 's/[^.]*//'`
	380	exit ;;
	381	sun4:SunOS::*)
	382	case "`/usr/bin/arch -k`" in
	383	Series\|S4)
	384	UNAME_RELEASE=`uname -v`
	385	;;
	386	esac
	387	# Japanese Language versions have a version number like `4.1.3-JL'.
	388	echo sparc-sun-sunos`echo ${UNAME_RELEASE}\|sed -e 's/-/_/'`
	389	exit ;;
	390	sun3:SunOS::*)
	391	echo m68k-sun-sunos${UNAME_RELEASE}
	392	exit ;;
	393	sun::4.2BSD:*)
	394	UNAME_RELEASE=`(sed 1q /etc/motd \| awk '{print substr($5,1,3)}') 2>/dev/null`
	395	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
	396	case "`/bin/arch`" in
	397	sun3)
	398	echo m68k-sun-sunos${UNAME_RELEASE}
	399	;;
	400	sun4)
	401	echo sparc-sun-sunos${UNAME_RELEASE}
	402	;;
	403	esac
	404	exit ;;
	405	aushp:SunOS::)
	406	echo sparc-auspex-sunos${UNAME_RELEASE}
	407	exit ;;
	408	# The situation for MiNT is a little confusing. The machine name
	409	# can be virtually everything (everything which is not
	410	# "atarist" or "atariste" at least should have a processor
	411	# > m68000). The system name ranges from "MiNT" over "FreeMiNT"
	412	# to the lowercase version "mint" (or "freemint"). Finally
	413	# the system name "TOS" denotes a system which is actually not
	414	# MiNT. But MiNT is downward compatible to TOS, so this should
	415	# be no problem.
	416	atarist[e]:MiNT::* \| atarist[e]:mint::* \| atarist[e]:TOS::*)
	417	echo m68k-atari-mint${UNAME_RELEASE}
	418	exit ;;
	419	atari:MiNT:: \| atari:mint:: \| atarist[e]:TOS::*)
	420	echo m68k-atari-mint${UNAME_RELEASE}
	421	exit ;;
	422	falcon:MiNT::* \| falcon:mint::* \| falcon:TOS::*)
	423	echo m68k-atari-mint${UNAME_RELEASE}
	424	exit ;;
	425	milan:MiNT:: \| milan:mint:: \| milan:TOS::*)
	426	echo m68k-milan-mint${UNAME_RELEASE}
	427	exit ;;
	428	hades:MiNT:: \| hades:mint:: \| hades:TOS::*)
	429	echo m68k-hades-mint${UNAME_RELEASE}
	430	exit ;;
	431	:MiNT:: \| :mint:: \| :TOS::)
	432	echo m68k-unknown-mint${UNAME_RELEASE}
	433	exit ;;
	434	m68k:machten::)
	435	echo m68k-apple-machten${UNAME_RELEASE}
	436	exit ;;
	437	powerpc:machten::)
	438	echo powerpc-apple-machten${UNAME_RELEASE}
	439	exit ;;
	440	RISC:Mach::*)
	441	echo mips-dec-mach_bsd4.3
	442	exit ;;
	443	RISC:ULTRIX::*)
	444	echo mips-dec-ultrix${UNAME_RELEASE}
	445	exit ;;
	446	VAX:ULTRIX::)
	447	echo vax-dec-ultrix${UNAME_RELEASE}
	448	exit ;;
	449	2020:CLIX:: \| 2430:CLIX::)
	450	echo clipper-intergraph-clix${UNAME_RELEASE}
	451	exit ;;
	452	mips:::UMIPS \| mips:::RISCos)
	453	eval $set_cc_for_build
	454	sed 's/^ //' << EOF >$dummy.c
	455	#ifdef __cplusplus
	456	#include <stdio.h> /* for printf() prototype */
	457	int main (int argc, char *argv[]) {
	458	#else
	459	int main (argc, argv) int argc; char *argv[]; {
	460	#endif
	461	#if defined (host_mips) && defined (MIPSEB)
	462	#if defined (SYSTYPE_SYSV)
	463	printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
	464	#endif
	465	#if defined (SYSTYPE_SVR4)
	466	printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
	467	#endif
	468	#if defined (SYSTYPE_BSD43) \|\| defined(SYSTYPE_BSD)
	469	printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
	470	#endif
	471	#endif
	472	exit (-1);
	473	}
	474	EOF
	475	$CC_FOR_BUILD -o $dummy $dummy.c &&
	476	dummyarg=`echo "${UNAME_RELEASE}" \| sed -n 's/$[0-9]$./\1/p'` &&
	477	SYSTEM_NAME=`$dummy $dummyarg` &&
	478	{ echo "$SYSTEM_NAME"; exit; }
	479	echo mips-mips-riscos${UNAME_RELEASE}
	480	exit ;;
	481	Motorola:PowerMAX_OS::)
	482	echo powerpc-motorola-powermax
	483	exit ;;
	484	Motorola::4.3:PL8-)
	485	echo powerpc-harris-powermax
	486	exit ;;
	487	Night_Hawk:::PowerMAX_OS \| Synergy:PowerMAX_OS::)
	488	echo powerpc-harris-powermax
	489	exit ;;
	490	Night_Hawk:Power_UNIX::)
	491	echo powerpc-harris-powerunix
	492	exit ;;
	493	m88k:CX/UX:7:)
	494	echo m88k-harris-cxux7
	495	exit ;;
	496	m88k::4:R4*)
	497	echo m88k-motorola-sysv4
	498	exit ;;
	499	m88k::3:R3*)
	500	echo m88k-motorola-sysv3
	501	exit ;;
	502	AViiON:dgux::)
	503	# DG/UX returns AViiON for all architectures
	504	UNAME_PROCESSOR=`/usr/bin/uname -p`
	505	if [ $UNAME_PROCESSOR = mc88100 ] \|\| [ $UNAME_PROCESSOR = mc88110 ]
	506	then
	507	if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] \|\| \
	508	[ ${TARGET_BINARY_INTERFACE}x = x ]
	509	then
	510	echo m88k-dg-dgux${UNAME_RELEASE}
	511	else
	512	echo m88k-dg-dguxbcs${UNAME_RELEASE}
	513	fi
	514	else
	515	echo i586-dg-dgux${UNAME_RELEASE}
	516	fi
	517	exit ;;
	518	M88:DolphinOS::*) # DolphinOS (SVR3)
	519	echo m88k-dolphin-sysv3
	520	exit ;;
	521	M88::R3:)
	522	# Delta 88k system running SVR3
	523	echo m88k-motorola-sysv3
	524	exit ;;
	525	XD88:::) # Tektronix XD88 system running UTekV (SVR3)
	526	echo m88k-tektronix-sysv3
	527	exit ;;
	528	Tek43[0-9][0-9]:UTek::) # Tektronix 4300 system running UTek (BSD)
	529	echo m68k-tektronix-bsd
	530	exit ;;
	531	:IRIX::)
	532	echo mips-sgi-irix`echo ${UNAME_RELEASE}\|sed -e 's/-/_/g'`
	533	exit ;;
	534	????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
	535	echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id
	536	exit ;; # Note that: echo "'`uname -s`'" gives 'AIX '
	537	i86:AIX::*)
	538	echo i386-ibm-aix
	539	exit ;;
	540	ia64:AIX::)
	541	if [ -x /usr/bin/oslevel ] ; then
	542	IBM_REV=`/usr/bin/oslevel`
	543	else
	544	IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
	545	fi
	546	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
	547	exit ;;
	548	*:AIX:2:3)
	549	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
	550	eval $set_cc_for_build
	551	sed 's/^ //' << EOF >$dummy.c
	552	#include <sys/systemcfg.h>
	553
	554	main()
	555	{
	556	if (!__power_pc())
	557	exit(1);
	558	puts("powerpc-ibm-aix3.2.5");
	559	exit(0);
	560	}
	561	EOF
	562	if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
	563	then
	564	echo "$SYSTEM_NAME"
	565	else
	566	echo rs6000-ibm-aix3.2.5
	567	fi
	568	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
	569	echo rs6000-ibm-aix3.2.4
	570	else
	571	echo rs6000-ibm-aix3.2
	572	fi
	573	exit ;;
	574	:AIX::[4567])
	575	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available \| sed 1q \| awk '{ print $1 }'`
	576	if /usr/sbin/lsattr -El ${IBM_CPU_ID} \| grep ' POWER' >/dev/null 2>&1; then
	577	IBM_ARCH=rs6000
	578	else
	579	IBM_ARCH=powerpc
	580	fi
	581	if [ -x /usr/bin/oslevel ] ; then
	582	IBM_REV=`/usr/bin/oslevel`
	583	else
	584	IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
	585	fi
	586	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
	587	exit ;;
	588	:AIX::*)
	589	echo rs6000-ibm-aix
	590	exit ;;
	591	ibmrt:4.4BSD:\|romp-ibm:BSD:)
	592	echo romp-ibm-bsd4.4
	593	exit ;;
	594	ibmrt:BSD:\|romp-ibm:BSD:*) # covers RT/PC BSD and
	595	echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to
	596	exit ;; # report: romp-ibm BSD 4.3
	597	:BOSX::*)
	598	echo rs6000-bull-bosx
	599	exit ;;
	600	DPX/2?00:B.O.S.::)
	601	echo m68k-bull-sysv3
	602	exit ;;
	603	9000/[34]??:4.3bsd:1.:)
	604	echo m68k-hp-bsd
	605	exit ;;
	606	hp300:4.4BSD:: \| 9000/[34]??:4.3bsd:2.:)
	607	echo m68k-hp-bsd4.4
	608	exit ;;
	609	9000/[34678]??:HP-UX::)
	610	HPUX_REV=`echo ${UNAME_RELEASE}\|sed -e 's/[^.].[0B]//'`
	611	case "${UNAME_MACHINE}" in
	612	9000/31? ) HP_ARCH=m68000 ;;
	613	9000/[34]?? ) HP_ARCH=m68k ;;
	614	9000/[678][0-9][0-9])
	615	if [ -x /usr/bin/getconf ]; then
	616	sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
	617	sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
	618	case "${sc_cpu_version}" in
	619	523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
	620	528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
	621	532) # CPU_PA_RISC2_0
	622	case "${sc_kernel_bits}" in
	623	32) HP_ARCH="hppa2.0n" ;;
	624	64) HP_ARCH="hppa2.0w" ;;
	625	'') HP_ARCH="hppa2.0" ;; # HP-UX 10.20
	626	esac ;;
	627	esac
	628	fi
	629	if [ "${HP_ARCH}" = "" ]; then
	630	eval $set_cc_for_build
	631	sed 's/^ //' << EOF >$dummy.c
	632
	633	#define _HPUX_SOURCE
	634	#include <stdlib.h>
	635	#include <unistd.h>
	636
	637	int main ()
	638	{
	639	#if defined(_SC_KERNEL_BITS)
	640	long bits = sysconf(_SC_KERNEL_BITS);
	641	#endif
	642	long cpu = sysconf (_SC_CPU_VERSION);
	643
	644	switch (cpu)
	645	{
	646	case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
	647	case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
	648	case CPU_PA_RISC2_0:
	649	#if defined(_SC_KERNEL_BITS)
	650	switch (bits)
	651	{
	652	case 64: puts ("hppa2.0w"); break;
	653	case 32: puts ("hppa2.0n"); break;
	654	default: puts ("hppa2.0"); break;
	655	} break;
	656	#else /* !defined(_SC_KERNEL_BITS) */
	657	puts ("hppa2.0"); break;
	658	#endif
	659	default: puts ("hppa1.0"); break;
	660	}
	661	exit (0);
	662	}
	663	EOF
	664	(CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
	665	test -z "$HP_ARCH" && HP_ARCH=hppa
	666	fi ;;
	667	esac
	668	if [ ${HP_ARCH} = "hppa2.0w" ]
	669	then
	670	eval $set_cc_for_build
	671
	672	# hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
	673	# 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler
	674	# generating 64-bit code. GNU and HP use different nomenclature:
	675	#
	676	# $ CC_FOR_BUILD=cc ./config.guess
	677	# => hppa2.0w-hp-hpux11.23
	678	# $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
	679	# => hppa64-hp-hpux11.23
	680
	681	if echo __LP64__ \| (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) \|
	682	grep -q __LP64__
	683	then
	684	HP_ARCH="hppa2.0w"
	685	else
	686	HP_ARCH="hppa64"
	687	fi
	688	fi
	689	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
	690	exit ;;
	691	ia64:HP-UX::)
	692	HPUX_REV=`echo ${UNAME_RELEASE}\|sed -e 's/[^.].[0B]//'`
	693	echo ia64-hp-hpux${HPUX_REV}
	694	exit ;;
	695	3050:HI-UX::*)
	696	eval $set_cc_for_build
	697	sed 's/^ //' << EOF >$dummy.c
	698	#include <unistd.h>
	699	int
	700	main ()
	701	{
	702	long cpu = sysconf (_SC_CPU_VERSION);
	703	/* The order matters, because CPU_IS_HP_MC68K erroneously returns
	704	true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct
	705	results, however. */
	706	if (CPU_IS_PA_RISC (cpu))
	707	{
	708	switch (cpu)
	709	{
	710	case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
	711	case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
	712	case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
	713	default: puts ("hppa-hitachi-hiuxwe2"); break;
	714	}
	715	}
	716	else if (CPU_IS_HP_MC68K (cpu))
	717	puts ("m68k-hitachi-hiuxwe2");
	718	else puts ("unknown-hitachi-hiuxwe2");
	719	exit (0);
	720	}
	721	EOF
	722	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
	723	{ echo "$SYSTEM_NAME"; exit; }
	724	echo unknown-hitachi-hiuxwe2
	725	exit ;;
	726	9000/7??:4.3bsd:: \| 9000/8?[79]:4.3bsd:: )
	727	echo hppa1.1-hp-bsd
	728	exit ;;
	729	9000/8??:4.3bsd::)
	730	echo hppa1.0-hp-bsd
	731	exit ;;
	732	9??:MPE/iX:: \| 3000:MPE/iX::)
	733	echo hppa1.0-hp-mpeix
	734	exit ;;
	735	hp7??:OSF1:: \| hp8?[79]:OSF1:: )
	736	echo hppa1.1-hp-osf
	737	exit ;;
	738	hp8??:OSF1::)
	739	echo hppa1.0-hp-osf
	740	exit ;;
	741	i86:OSF1::*)
	742	if [ -x /usr/sbin/sysversion ] ; then
	743	echo ${UNAME_MACHINE}-unknown-osf1mk
	744	else
	745	echo ${UNAME_MACHINE}-unknown-osf1
	746	fi
	747	exit ;;
	748	parisc:Lites::)
	749	echo hppa1.1-hp-lites
	750	exit ;;
	751	C1:ConvexOS::* \| convex:ConvexOS:C1:)
	752	echo c1-convex-bsd
	753	exit ;;
	754	C2:ConvexOS::* \| convex:ConvexOS:C2:)
	755	if getsysinfo -f scalar_acc
	756	then echo c32-convex-bsd
	757	else echo c2-convex-bsd
	758	fi
	759	exit ;;
	760	C34:ConvexOS::* \| convex:ConvexOS:C34:)
	761	echo c34-convex-bsd
	762	exit ;;
	763	C38:ConvexOS::* \| convex:ConvexOS:C38:)
	764	echo c38-convex-bsd
	765	exit ;;
	766	C4:ConvexOS::* \| convex:ConvexOS:C4:)
	767	echo c4-convex-bsd
	768	exit ;;
	769	CRAYY-MP:::)
	770	echo ymp-cray-unicos${UNAME_RELEASE} \| sed -e 's/\.[^.]*$/.X/'
	771	exit ;;
	772	CRAY[A-Z]90:::)
	773	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
	774	\| sed -e 's/CRAY.*$[A-Z]90$/\1/' \
	775	-e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
	776	-e 's/\.[^.]*$/.X/'
	777	exit ;;
	778	CRAYTS:::)
	779	echo t90-cray-unicos${UNAME_RELEASE} \| sed -e 's/\.[^.]*$/.X/'
	780	exit ;;
	781	CRAYT3E:::)
	782	echo alphaev5-cray-unicosmk${UNAME_RELEASE} \| sed -e 's/\.[^.]*$/.X/'
	783	exit ;;
	784	CRAYSV1:::)
	785	echo sv1-cray-unicos${UNAME_RELEASE} \| sed -e 's/\.[^.]*$/.X/'
	786	exit ;;
	787	:UNICOS/mp::*)
	788	echo craynv-cray-unicosmp${UNAME_RELEASE} \| sed -e 's/\.[^.]*$/.X/'
	789	exit ;;
	790	F30[01]:UNIX_System_V:: \| F700:UNIX_System_V::)
	791	FUJITSU_PROC=`uname -m \| tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
	792	FUJITSU_SYS=`uname -p \| tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' \| sed -e 's/\///'`
	793	FUJITSU_REL=`echo ${UNAME_RELEASE} \| sed -e 's/ /_/'`
	794	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
	795	exit ;;
	796	5000:UNIX_System_V:4.:)
	797	FUJITSU_SYS=`uname -p \| tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' \| sed -e 's/\///'`
	798	FUJITSU_REL=`echo ${UNAME_RELEASE} \| tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' \| sed -e 's/ /_/'`
	799	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
	800	exit ;;
	801	i86:BSD/386::* \| i86:BSD/OS::* \| :Ascend\ Embedded/OS::*)
	802	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
	803	exit ;;
	804	sparc:BSD/OS::*)
	805	echo sparc-unknown-bsdi${UNAME_RELEASE}
	806	exit ;;
	807	:BSD/OS::*)
	808	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
	809	exit ;;
	810	:FreeBSD::*)
	811	UNAME_PROCESSOR=`/usr/bin/uname -p`
	812	case ${UNAME_PROCESSOR} in
	813	amd64)
	814	echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}\|sed -e 's/[-(].*//'` ;;
	815	*)
	816	echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}\|sed -e 's/[-(].*//'` ;;
	817	esac
	818	exit ;;
	819	i:CYGWIN:*)
	820	echo ${UNAME_MACHINE}-pc-cygwin
	821	exit ;;
	822	:MINGW64:*)
	823	echo ${UNAME_MACHINE}-pc-mingw64
	824	exit ;;
	825	:MINGW:*)
	826	echo ${UNAME_MACHINE}-pc-mingw32
	827	exit ;;
	828	:MSYS:*)
	829	echo ${UNAME_MACHINE}-pc-msys
	830	exit ;;
	831	i:windows32:*)
	832	# uname -m includes "-pc" on this system.
	833	echo ${UNAME_MACHINE}-mingw32
	834	exit ;;
	835	i:PW:*)
	836	echo ${UNAME_MACHINE}-pc-pw32
	837	exit ;;
	838	:Interix:*)
	839	case ${UNAME_MACHINE} in
	840	x86)
	841	echo i586-pc-interix${UNAME_RELEASE}
	842	exit ;;
	843	authenticamd \| genuineintel \| EM64T)
	844	echo x86_64-unknown-interix${UNAME_RELEASE}
	845	exit ;;
	846	IA64)
	847	echo ia64-unknown-interix${UNAME_RELEASE}
	848	exit ;;
	849	esac ;;
	850	[345]86:Windows_95:* \| [345]86:Windows_98:* \| [345]86:Windows_NT:*)
	851	echo i${UNAME_MACHINE}-pc-mks
	852	exit ;;
	853	8664:Windows_NT:*)
	854	echo x86_64-pc-mks
	855	exit ;;
	856	i:Windows_NT:* \| Pentium:Windows_NT:*)
	857	# How do we know it's Interix rather than the generic POSIX subsystem?
	858	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
	859	# UNAME_MACHINE based on the output of uname instead of i386?
	860	echo i586-pc-interix
	861	exit ;;
	862	i:UWIN:*)
	863	echo ${UNAME_MACHINE}-pc-uwin
	864	exit ;;
	865	amd64:CYGWIN::* \| x86_64:CYGWIN::*)
	866	echo x86_64-unknown-cygwin
	867	exit ;;
	868	p:CYGWIN:*)
	869	echo powerpcle-unknown-cygwin
	870	exit ;;
	871	prep:SunOS:5.:*)
	872	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}\|sed -e 's/[^.]*//'`
	873	exit ;;
	874	:GNU::*)
	875	# the GNU system
	876	echo `echo ${UNAME_MACHINE}\|sed -e 's,[-/].$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}\|sed -e 's,/.$,,'`
	877	exit ;;
	878	:GNU/::)
	879	# other systems with GNU libc and userland
	880	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} \| sed 's,^[^/]/,,' \| tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}\|sed -e 's/[-(].//'`-${LIBC}
	881	exit ;;
	882	i86:Minix::*)
	883	echo ${UNAME_MACHINE}-pc-minix
	884	exit ;;
	885	aarch64:Linux::)
	886	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	887	exit ;;
	888	aarch64_be:Linux::)
	889	UNAME_MACHINE=aarch64_be
	890	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	891	exit ;;
	892	alpha:Linux::)
	893	case `sed -n '/^cpu model/s/^.: $.$/\1/p' < /proc/cpuinfo` in
	894	EV5) UNAME_MACHINE=alphaev5 ;;
	895	EV56) UNAME_MACHINE=alphaev56 ;;
	896	PCA56) UNAME_MACHINE=alphapca56 ;;
	897	PCA57) UNAME_MACHINE=alphapca56 ;;
	898	EV6) UNAME_MACHINE=alphaev6 ;;
	899	EV67) UNAME_MACHINE=alphaev67 ;;
	900	EV68*) UNAME_MACHINE=alphaev68 ;;
	901	esac
	902	objdump --private-headers /bin/sh \| grep -q ld.so.1
	903	if test "$?" = 0 ; then LIBC="gnulibc1" ; fi
	904	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	905	exit ;;
	906	arc:Linux:: \| arceb:Linux::)
	907	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	908	exit ;;
	909	arm:Linux::*)
	910	eval $set_cc_for_build
	911	if echo __ARM_EABI__ \| $CC_FOR_BUILD -E - 2>/dev/null \
	912	\| grep -q __ARM_EABI__
	913	then
	914	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	915	else
	916	if echo __ARM_PCS_VFP \| $CC_FOR_BUILD -E - 2>/dev/null \
	917	\| grep -q __ARM_PCS_VFP
	918	then
	919	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
	920	else
	921	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
	922	fi
	923	fi
	924	exit ;;
	925	avr32:Linux::*)
	926	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	927	exit ;;
	928	cris:Linux::)
	929	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
	930	exit ;;
	931	crisv32:Linux::)
	932	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
	933	exit ;;
	934	frv:Linux::)
	935	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	936	exit ;;
	937	hexagon:Linux::)
	938	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	939	exit ;;
	940	i86:Linux::*)
	941	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
	942	exit ;;
	943	ia64:Linux::)
	944	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	945	exit ;;
	946	m32r:Linux::*)
	947	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	948	exit ;;
	949	m68:Linux::*)
	950	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	951	exit ;;
	952	mips:Linux:: \| mips64:Linux::)
	953	eval $set_cc_for_build
	954	sed 's/^ //' << EOF >$dummy.c
	955	#undef CPU
	956	#undef ${UNAME_MACHINE}
	957	#undef ${UNAME_MACHINE}el
	958	#if defined(__MIPSEL__) \|\| defined(__MIPSEL) \|\| defined(_MIPSEL) \|\| defined(MIPSEL)
	959	CPU=${UNAME_MACHINE}el
	960	#else
	961	#if defined(__MIPSEB__) \|\| defined(__MIPSEB) \|\| defined(_MIPSEB) \|\| defined(MIPSEB)
	962	CPU=${UNAME_MACHINE}
	963	#else
	964	CPU=
	965	#endif
	966	#endif
	967	EOF
	968	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null \| grep '^CPU'`
	969	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
	970	;;
	971	openrisc:Linux::*)
	972	echo or1k-unknown-linux-${LIBC}
	973	exit ;;
	974	or32:Linux:: \| or1k:Linux::*)
	975	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	976	exit ;;
	977	padre:Linux::)
	978	echo sparc-unknown-linux-${LIBC}
	979	exit ;;
	980	parisc64:Linux:: \| hppa64:Linux::)
	981	echo hppa64-unknown-linux-${LIBC}
	982	exit ;;
	983	parisc:Linux:: \| hppa:Linux::)
	984	# Look for CPU level
	985	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null \| cut -d' ' -f2` in
	986	PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
	987	PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
	988	*) echo hppa-unknown-linux-${LIBC} ;;
	989	esac
	990	exit ;;
	991	ppc64:Linux::)
	992	echo powerpc64-unknown-linux-${LIBC}
	993	exit ;;
	994	ppc:Linux::)
	995	echo powerpc-unknown-linux-${LIBC}
	996	exit ;;
	997	ppc64le:Linux::)
	998	echo powerpc64le-unknown-linux-${LIBC}
	999	exit ;;
	1000	ppcle:Linux::)
	1001	echo powerpcle-unknown-linux-${LIBC}
	1002	exit ;;
	1003	s390:Linux:: \| s390x:Linux::)
	1004	echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
	1005	exit ;;
	1006	sh64:Linux::*)
	1007	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	1008	exit ;;
	1009	sh:Linux::*)
	1010	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	1011	exit ;;
	1012	sparc:Linux:: \| sparc64:Linux::)
	1013	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	1014	exit ;;
	1015	tile:Linux::*)
	1016	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	1017	exit ;;
	1018	vax:Linux::)
	1019	echo ${UNAME_MACHINE}-dec-linux-${LIBC}
	1020	exit ;;
	1021	x86_64:Linux::)
	1022	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	1023	exit ;;
	1024	xtensa:Linux::*)
	1025	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	1026	exit ;;
	1027	i86:DYNIX/ptx:4:*)
	1028	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
	1029	# earlier versions are messed up and put the nodename in both
	1030	# sysname and nodename.
	1031	echo i386-sequent-sysv4
	1032	exit ;;
	1033	i86:UNIX_SV:4.2MP:2.)
	1034	# Unixware is an offshoot of SVR4, but it has its own version
	1035	# number series starting with 2...
	1036	# I am not positive that other SVR4 systems won't match this,
	1037	# I just have to hope. -- rms.
	1038	# Use sysv4.2uw... so that sysv4* matches it.
	1039	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
	1040	exit ;;
	1041	i86:OS/2::*)
	1042	# If we were able to find `uname', then EMX Unix compatibility
	1043	# is probably installed.
	1044	echo ${UNAME_MACHINE}-pc-os2-emx
	1045	exit ;;
	1046	i86:XTS-300::STOP)
	1047	echo ${UNAME_MACHINE}-unknown-stop
	1048	exit ;;
	1049	i86:atheos::*)
	1050	echo ${UNAME_MACHINE}-unknown-atheos
	1051	exit ;;
	1052	i86:syllable::*)
	1053	echo ${UNAME_MACHINE}-pc-syllable
	1054	exit ;;
	1055	i86:LynxOS:2.:* \| i86:LynxOS:3.[01]:* \| i86:LynxOS:4.[02]:*)
	1056	echo i386-unknown-lynxos${UNAME_RELEASE}
	1057	exit ;;
	1058	i86:DOS::)
	1059	echo ${UNAME_MACHINE}-pc-msdosdjgpp
	1060	exit ;;
	1061	i86::4.: \| i86:SYSTEM_V:4.:*)
	1062	UNAME_REL=`echo ${UNAME_RELEASE} \| sed 's/\/MP$//'`
	1063	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
	1064	echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
	1065	else
	1066	echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
	1067	fi
	1068	exit ;;
	1069	i86::5:[678]*)
	1070	# UnixWare 7.x, OpenUNIX and OpenServer 6.
	1071	case `/bin/uname -X \| grep "^Machine"` in
	1072	486) UNAME_MACHINE=i486 ;;
	1073	*Pentium) UNAME_MACHINE=i586 ;;
	1074	Pent\|*Celeron) UNAME_MACHINE=i686 ;;
	1075	esac
	1076	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
	1077	exit ;;
	1078	i86::3.2:*)
	1079	if test -f /usr/options/cb.name; then
	1080	UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
	1081	echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
	1082	elif /bin/uname -X 2>/dev/null >/dev/null ; then
	1083	UNAME_REL=`(/bin/uname -X\|grep Release\|sed -e 's/.*= //')`
	1084	(/bin/uname -X\|grep i80486 >/dev/null) && UNAME_MACHINE=i486
	1085	(/bin/uname -X\|grep '^Machine.*Pentium' >/dev/null) \
	1086	&& UNAME_MACHINE=i586
	1087	(/bin/uname -X\|grep '^Machine.Pent II' >/dev/null) \
	1088	&& UNAME_MACHINE=i686
	1089	(/bin/uname -X\|grep '^Machine.*Pentium Pro' >/dev/null) \
	1090	&& UNAME_MACHINE=i686
	1091	echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
	1092	else
	1093	echo ${UNAME_MACHINE}-pc-sysv32
	1094	fi
	1095	exit ;;
	1096	pc:::*)
	1097	# Left here for compatibility:
	1098	# uname -m prints for DJGPP always 'pc', but it prints nothing about
	1099	# the processor, so we play safe by assuming i586.
	1100	# Note: whatever this is, it MUST be the same as what config.sub
	1101	# prints for the "djgpp" host, or else GDB configury will decide that
	1102	# this is a cross-build.
	1103	echo i586-pc-msdosdjgpp
	1104	exit ;;
	1105	Intel:Mach:3:)
	1106	echo i386-pc-mach3
	1107	exit ;;
	1108	paragon:::*)
	1109	echo i860-intel-osf1
	1110	exit ;;
	1111	i860::4.:*) # i860-SVR4
	1112	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
	1113	echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
	1114	else # Add other i860-SVR4 vendors below as they are discovered.
	1115	echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4
	1116	fi
	1117	exit ;;
	1118	mini:CTIX:SYS5:*)
	1119	# "miniframe"
	1120	echo m68010-convergent-sysv
	1121	exit ;;
	1122	mc68k:UNIX:SYSTEM5:3.51m)
	1123	echo m68k-convergent-sysv
	1124	exit ;;
	1125	M680?0:D-NIX:5.3:*)
	1126	echo m68k-diab-dnix
	1127	exit ;;
	1128	M68::R3V[5678]:)
	1129	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
	1130	3[345]??::4.0:3.0 \| 3[34]??A::4.0:3.0 \| 3[34]??,::4.0:3.0 \| 3[34]??/::4.0:3.0 \| 4400::4.0:3.0 \| 4850::4.0:3.0 \| SKA40::4.0:3.0 \| SDS2::4.0:3.0 \| SHG2::4.0:3.0 \| S7501:*:4.0:3.0)
	1131	OS_REL=''
	1132	test -r /etc/.relid \
	1133	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* $[0-9][0-9]$.*/\1/p' < /etc/.relid`
	1134	/bin/uname -p 2>/dev/null \| grep 86 >/dev/null \
	1135	&& { echo i486-ncr-sysv4.3${OS_REL}; exit; }
	1136	/bin/uname -p 2>/dev/null \| /bin/grep entium >/dev/null \
	1137	&& { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
	1138	3[34]??::4.0: \| 3[34]??,::4.0:*)
	1139	/bin/uname -p 2>/dev/null \| grep 86 >/dev/null \
	1140	&& { echo i486-ncr-sysv4; exit; } ;;
	1141	NCR::4.2:* \| MPRAS::4.2:*)
	1142	OS_REL='.3'
	1143	test -r /etc/.relid \
	1144	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* $[0-9][0-9]$.*/\1/p' < /etc/.relid`
	1145	/bin/uname -p 2>/dev/null \| grep 86 >/dev/null \
	1146	&& { echo i486-ncr-sysv4.3${OS_REL}; exit; }
	1147	/bin/uname -p 2>/dev/null \| /bin/grep entium >/dev/null \
	1148	&& { echo i586-ncr-sysv4.3${OS_REL}; exit; }
	1149	/bin/uname -p 2>/dev/null \| /bin/grep pteron >/dev/null \
	1150	&& { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
	1151	m68:LynxOS:2.:* \| m68:LynxOS:3.0:*)
	1152	echo m68k-unknown-lynxos${UNAME_RELEASE}
	1153	exit ;;
	1154	mc68030:UNIX_System_V:4.:)
	1155	echo m68k-atari-sysv4
	1156	exit ;;
	1157	TSUNAMI:LynxOS:2.:)
	1158	echo sparc-unknown-lynxos${UNAME_RELEASE}
	1159	exit ;;
	1160	rs6000:LynxOS:2.:)
	1161	echo rs6000-unknown-lynxos${UNAME_RELEASE}
	1162	exit ;;
	1163	PowerPC:LynxOS:2.: \| PowerPC:LynxOS:3.[01]: \| PowerPC:LynxOS:4.[02]:)
	1164	echo powerpc-unknown-lynxos${UNAME_RELEASE}
	1165	exit ;;
	1166	SM[BE]S:UNIX_SV::)
	1167	echo mips-dde-sysv${UNAME_RELEASE}
	1168	exit ;;
	1169	RM:ReliantUNIX-::)
	1170	echo mips-sni-sysv4
	1171	exit ;;
	1172	RM:SINIX-::)
	1173	echo mips-sni-sysv4
	1174	exit ;;
	1175	:SINIX-::)
	1176	if uname -p 2>/dev/null >/dev/null ; then
	1177	UNAME_MACHINE=`(uname -p) 2>/dev/null`
	1178	echo ${UNAME_MACHINE}-sni-sysv4
	1179	else
	1180	echo ns32k-sni-sysv
	1181	fi
	1182	exit ;;
	1183	PENTIUM::4.0:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
	1184	# says <Richard.M.Bartel@ccMail.Census.GOV>
	1185	echo i586-unisys-sysv4
	1186	exit ;;
	1187	:UNIX_System_V:4:FTX*)
	1188	# From Gerald Hewes <hewes@openmarket.com>.
	1189	# How about differentiating between stratus architectures? -djm
	1190	echo hppa1.1-stratus-sysv4
	1191	exit ;;
	1192	:::FTX)
	1193	# From seanf@swdc.stratus.com.
	1194	echo i860-stratus-sysv4
	1195	exit ;;
	1196	i86:VOS::*)
	1197	# From Paul.Green@stratus.com.
	1198	echo ${UNAME_MACHINE}-stratus-vos
	1199	exit ;;
	1200	:VOS::*)
	1201	# From Paul.Green@stratus.com.
	1202	echo hppa1.1-stratus-vos
	1203	exit ;;
	1204	mc68:A/UX::*)
	1205	echo m68k-apple-aux${UNAME_RELEASE}
	1206	exit ;;
	1207	news:NEWS-OS:6:*)
	1208	echo mips-sony-newsos6
	1209	exit ;;
	1210	R[34]000:System_V:: \| R4000:UNIX_SYSV:: \| R000:UNIX_SV::*)
	1211	if [ -d /usr/nec ]; then
	1212	echo mips-nec-sysv${UNAME_RELEASE}
	1213	else
	1214	echo mips-unknown-sysv${UNAME_RELEASE}
	1215	fi
	1216	exit ;;
	1217	BeBox:BeOS::) # BeOS running on hardware made by Be, PPC only.
	1218	echo powerpc-be-beos
	1219	exit ;;
	1220	BeMac:BeOS::) # BeOS running on Mac or Mac clone, PPC only.
	1221	echo powerpc-apple-beos
	1222	exit ;;
	1223	BePC:BeOS::) # BeOS running on Intel PC compatible.
	1224	echo i586-pc-beos
	1225	exit ;;
	1226	BePC:Haiku::) # Haiku running on Intel PC compatible.
	1227	echo i586-pc-haiku
	1228	exit ;;
	1229	x86_64:Haiku::)
	1230	echo x86_64-unknown-haiku
	1231	exit ;;
	1232	SX-4:SUPER-UX::)
	1233	echo sx4-nec-superux${UNAME_RELEASE}
	1234	exit ;;
	1235	SX-5:SUPER-UX::)
	1236	echo sx5-nec-superux${UNAME_RELEASE}
	1237	exit ;;
	1238	SX-6:SUPER-UX::)
	1239	echo sx6-nec-superux${UNAME_RELEASE}
	1240	exit ;;
	1241	SX-7:SUPER-UX::)
	1242	echo sx7-nec-superux${UNAME_RELEASE}
	1243	exit ;;
	1244	SX-8:SUPER-UX::)
	1245	echo sx8-nec-superux${UNAME_RELEASE}
	1246	exit ;;
	1247	SX-8R:SUPER-UX::)
	1248	echo sx8r-nec-superux${UNAME_RELEASE}
	1249	exit ;;
	1250	Power:Rhapsody::*)
	1251	echo powerpc-apple-rhapsody${UNAME_RELEASE}
	1252	exit ;;
	1253	:Rhapsody::*)
	1254	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
	1255	exit ;;
	1256	:Darwin::*)
	1257	UNAME_PROCESSOR=`uname -p` \|\| UNAME_PROCESSOR=unknown
	1258	eval $set_cc_for_build
	1259	if test "$UNAME_PROCESSOR" = unknown ; then
	1260	UNAME_PROCESSOR=powerpc
	1261	fi
	1262	if test `echo "$UNAME_RELEASE" \| sed -e 's/\..*//'` -le 10 ; then
	1263	if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
	1264	if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') \| \
	1265	(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) \| \
	1266	grep IS_64BIT_ARCH >/dev/null
	1267	then
	1268	case $UNAME_PROCESSOR in
	1269	i386) UNAME_PROCESSOR=x86_64 ;;
	1270	powerpc) UNAME_PROCESSOR=powerpc64 ;;
	1271	esac
	1272	fi
	1273	fi
	1274	elif test "$UNAME_PROCESSOR" = i386 ; then
	1275	# Avoid executing cc on OS X 10.9, as it ships with a stub
	1276	# that puts up a graphical alert prompting to install
	1277	# developer tools. Any system running Mac OS X 10.7 or
	1278	# later (Darwin 11 and later) is required to have a 64-bit
	1279	# processor. This is not true of the ARM version of Darwin
	1280	# that Apple uses in portable devices.
	1281	UNAME_PROCESSOR=x86_64
	1282	fi
	1283	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
	1284	exit ;;
	1285	:procnto:: \| :QNX:[0123456789]:*)
	1286	UNAME_PROCESSOR=`uname -p`
	1287	if test "$UNAME_PROCESSOR" = "x86"; then
	1288	UNAME_PROCESSOR=i386
	1289	UNAME_MACHINE=pc
	1290	fi
	1291	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
	1292	exit ;;
	1293	:QNX::4*)
	1294	echo i386-pc-qnx
	1295	exit ;;
	1296	NEO-?:NONSTOP_KERNEL::)
	1297	echo neo-tandem-nsk${UNAME_RELEASE}
	1298	exit ;;
	1299	NSE-:NONSTOP_KERNEL::*)
	1300	echo nse-tandem-nsk${UNAME_RELEASE}
	1301	exit ;;
	1302	NSR-?:NONSTOP_KERNEL::)
	1303	echo nsr-tandem-nsk${UNAME_RELEASE}
	1304	exit ;;
	1305	:NonStop-UX::*)
	1306	echo mips-compaq-nonstopux
	1307	exit ;;
	1308	BS2000:POSIX::*)
	1309	echo bs2000-siemens-sysv
	1310	exit ;;
	1311	DS/:UNIX_System_V::*)
	1312	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
	1313	exit ;;
	1314	:Plan9::*)
	1315	# "uname -m" is not consistent, so use $cputype instead. 386
	1316	# is converted to i386 for consistency with other x86
	1317	# operating systems.
	1318	if test "$cputype" = "386"; then
	1319	UNAME_MACHINE=i386
	1320	else
	1321	UNAME_MACHINE="$cputype"
	1322	fi
	1323	echo ${UNAME_MACHINE}-unknown-plan9
	1324	exit ;;
	1325	:TOPS-10::*)
	1326	echo pdp10-unknown-tops10
	1327	exit ;;
	1328	:TENEX::*)
	1329	echo pdp10-unknown-tenex
	1330	exit ;;
	1331	KS10:TOPS-20:: \| KL10:TOPS-20:: \| TYPE4:TOPS-20::)
	1332	echo pdp10-dec-tops20
	1333	exit ;;
	1334	XKL-1:TOPS-20:: \| TYPE5:TOPS-20::)
	1335	echo pdp10-xkl-tops20
	1336	exit ;;
	1337	:TOPS-20::*)
	1338	echo pdp10-unknown-tops20
	1339	exit ;;
	1340	:ITS::*)
	1341	echo pdp10-unknown-its
	1342	exit ;;
	1343	SEI:::SEIUX)
	1344	echo mips-sei-seiux${UNAME_RELEASE}
	1345	exit ;;
	1346	:DragonFly::*)
	1347	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}\|sed -e 's/[-(].*//'`
	1348	exit ;;
	1349	:VMS::)
	1350	UNAME_MACHINE=`(uname -p) 2>/dev/null`
	1351	case "${UNAME_MACHINE}" in
	1352	A*) echo alpha-dec-vms ; exit ;;
	1353	I*) echo ia64-dec-vms ; exit ;;
	1354	V*) echo vax-dec-vms ; exit ;;
	1355	esac ;;
	1356	:XENIX::SysV)
	1357	echo i386-pc-xenix
	1358	exit ;;
	1359	i86:skyos::*)
	1360	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` \| sed -e 's/ .*$//'
	1361	exit ;;
	1362	i86:rdos::*)
	1363	echo ${UNAME_MACHINE}-pc-rdos
	1364	exit ;;
	1365	i86:AROS::*)
	1366	echo ${UNAME_MACHINE}-pc-aros
	1367	exit ;;
	1368	x86_64:VMkernel::)
	1369	echo ${UNAME_MACHINE}-unknown-esx
	1370	exit ;;
	1371	esac
	1372
	1373	cat >&2 <<EOF
	1374	$0: unable to guess system type
	1375
	1376	This script, last modified $timestamp, has failed to recognize
	1377	the operating system you are using. It is advised that you
	1378	download the most up to date version of the config scripts from
	1379
	1380	http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
	1381	and
	1382	http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
	1383
	1384	If the version you run ($0) is already up to date, please
	1385	send the following data and any information you think might be
	1386	pertinent to <config-patches@gnu.org> in order to provide the needed
	1387	information to handle your system.
	1388
	1389	config.guess timestamp = $timestamp
	1390
	1391	uname -m = `(uname -m) 2>/dev/null \|\| echo unknown`
	1392	uname -r = `(uname -r) 2>/dev/null \|\| echo unknown`
	1393	uname -s = `(uname -s) 2>/dev/null \|\| echo unknown`
	1394	uname -v = `(uname -v) 2>/dev/null \|\| echo unknown`
	1395
	1396	/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
	1397	/bin/uname -X = `(/bin/uname -X) 2>/dev/null`
	1398
	1399	hostinfo = `(hostinfo) 2>/dev/null`
	1400	/bin/universe = `(/bin/universe) 2>/dev/null`
	1401	/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null`
	1402	/bin/arch = `(/bin/arch) 2>/dev/null`
	1403	/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null`
	1404	/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
	1405
	1406	UNAME_MACHINE = ${UNAME_MACHINE}
	1407	UNAME_RELEASE = ${UNAME_RELEASE}
	1408	UNAME_SYSTEM = ${UNAME_SYSTEM}
	1409	UNAME_VERSION = ${UNAME_VERSION}
	1410	EOF
	1411
	1412	exit 1
	1413
	1414	# Local variables:
	1415	# eval: (add-hook 'write-file-hooks 'time-stamp)
	1416	# time-stamp-start: "timestamp='"
	1417	# time-stamp-format: "%:y-%02m-%02d"
	1418	# time-stamp-end: "'"
	1419	# End:

+1798

-0

config.sub less more

	0	#! /bin/sh
	1	# Configuration validation subroutine script.
	2	# Copyright 1992-2014 Free Software Foundation, Inc.
	3
	4	timestamp='2014-07-28'
	5
	6	# This file is free software; you can redistribute it and/or modify it
	7	# under the terms of the GNU General Public License as published by
	8	# the Free Software Foundation; either version 3 of the License, or
	9	# (at your option) any later version.
	10	#
	11	# This program is distributed in the hope that it will be useful, but
	12	# WITHOUT ANY WARRANTY; without even the implied warranty of
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	# General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License
	17	# along with this program; if not, see <http://www.gnu.org/licenses/>.
	18	#
	19	# As a special exception to the GNU General Public License, if you
	20	# distribute this file as part of a program that contains a
	21	# configuration script generated by Autoconf, you may include it under
	22	# the same distribution terms that you use for the rest of that
	23	# program. This Exception is an additional permission under section 7
	24	# of the GNU General Public License, version 3 ("GPLv3").
	25
	26
	27	# Please send patches with a ChangeLog entry to config-patches@gnu.org.
	28	#
	29	# Configuration subroutine to validate and canonicalize a configuration type.
	30	# Supply the specified configuration type as an argument.
	31	# If it is invalid, we print an error message on stderr and exit with code 1.
	32	# Otherwise, we print the canonical config type on stdout and succeed.
	33
	34	# You can get the latest version of this script from:
	35	# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
	36
	37	# This file is supposed to be the same for all GNU packages
	38	# and recognize all the CPU types, system types and aliases
	39	# that are meaningful with any GNU software.
	40	# Each package is responsible for reporting which valid configurations
	41	# it does not support. The user should be able to distinguish
	42	# a failure to support a valid configuration from a meaningless
	43	# configuration.
	44
	45	# The goal of this file is to map all the various variations of a given
	46	# machine specification into a single specification in the form:
	47	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
	48	# or in some cases, the newer four-part form:
	49	# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
	50	# It is wrong to echo any other type of specification.
	51
	52	me=`echo "$0" \| sed -e 's,.*/,,'`
	53
	54	usage="\
	55	Usage: $0 [OPTION] CPU-MFR-OPSYS
	56	$0 [OPTION] ALIAS
	57
	58	Canonicalize a configuration name.
	59
	60	Operation modes:
	61	-h, --help print this help, then exit
	62	-t, --time-stamp print date of last modification, then exit
	63	-v, --version print version number, then exit
	64
	65	Report bugs and patches to <config-patches@gnu.org>."
	66
	67	version="\
	68	GNU config.sub ($timestamp)
	69
	70	Copyright 1992-2014 Free Software Foundation, Inc.
	71
	72	This is free software; see the source for copying conditions. There is NO
	73	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
	74
	75	help="
	76	Try \`$me --help' for more information."
	77
	78	# Parse command line
	79	while test $# -gt 0 ; do
	80	case $1 in
	81	--time-stamp \| --time* \| -t )
	82	echo "$timestamp" ; exit ;;
	83	--version \| -v )
	84	echo "$version" ; exit ;;
	85	--help \| --h* \| -h )
	86	echo "$usage"; exit ;;
	87	-- ) # Stop option processing
	88	shift; break ;;
	89	- ) # Use stdin as input.
	90	break ;;
	91	-* )
	92	echo "$me: invalid option $1$help"
	93	exit 1 ;;
	94
	95	local)
	96	# First pass through any local machine types.
	97	echo $1
	98	exit ;;
	99
	100	* )
	101	break ;;
	102	esac
	103	done
	104
	105	case $# in
	106	0) echo "$me: missing argument$help" >&2
	107	exit 1;;
	108	1) ;;
	109	*) echo "$me: too many arguments$help" >&2
	110	exit 1;;
	111	esac
	112
	113	# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
	114	# Here we must recognize all the valid KERNEL-OS combinations.
	115	maybe_os=`echo $1 \| sed 's/^$.$-$[^-]-[^-]*$$/\2/'`
	116	case $maybe_os in
	117	nto-qnx* \| linux-gnu* \| linux-android* \| linux-dietlibc \| linux-newlib* \| \
	118	linux-musl* \| linux-uclibc* \| uclinux-uclibc* \| uclinux-gnu* \| kfreebsd-gnu \| \
	119	knetbsd-gnu \| netbsd-gnu \| \
	120	kopensolaris-gnu \| \
	121	storm-chaos* \| os2-emx* \| rtmk-nova*)
	122	os=-$maybe_os
	123	basic_machine=`echo $1 \| sed 's/^$.$-$[^-]-[^-]*$$/\1/'`
	124	;;
	125	android-linux)
	126	os=-linux-android
	127	basic_machine=`echo $1 \| sed 's/^$.$-$[^-]-[^-]*$$/\1/'`-unknown
	128	;;
	129	*)
	130	basic_machine=`echo $1 \| sed 's/-[^-]*$//'`
	131	if [ $basic_machine != $1 ]
	132	then os=`echo $1 \| sed 's/.*-/-/'`
	133	else os=; fi
	134	;;
	135	esac
	136
	137	### Let's recognize common machines as not being operating systems so
	138	### that things like config.sub decstation-3100 work. We also
	139	### recognize some manufacturers as not being operating systems, so we
	140	### can provide default operating systems below.
	141	case $os in
	142	-sunos)
	143	# Prevent following clause from handling this invalid input.
	144	;;
	145	-dec* \| -mips* \| -sequent* \| -encore* \| -pc532* \| -sgi* \| -sony* \| \
	146	-att* \| -7300* \| -3300* \| -delta* \| -motorola* \| -sun[234]* \| \
	147	-unicom* \| -ibm* \| -next \| -hp \| -isi* \| -apollo \| -altos* \| \
	148	-convergent* \| -ncr* \| -news \| -32* \| -3600* \| -3100* \| -hitachi* \|\
	149	-c[123]* \| -convex* \| -sun \| -crds \| -omron* \| -dg \| -ultra \| -tti* \| \
	150	-harris \| -dolphin \| -highlevel \| -gould \| -cbm \| -ns \| -masscomp \| \
	151	-apple \| -axis \| -knuth \| -cray \| -microblaze*)
	152	os=
	153	basic_machine=$1
	154	;;
	155	-bluegene*)
	156	os=-cnk
	157	;;
	158	-sim \| -cisco \| -oki \| -wec \| -winbond)
	159	os=
	160	basic_machine=$1
	161	;;
	162	-scout)
	163	;;
	164	-wrs)
	165	os=-vxworks
	166	basic_machine=$1
	167	;;
	168	-chorusos*)
	169	os=-chorusos
	170	basic_machine=$1
	171	;;
	172	-chorusrdb)
	173	os=-chorusrdb
	174	basic_machine=$1
	175	;;
	176	-hiux*)
	177	os=-hiuxwe2
	178	;;
	179	-sco6)
	180	os=-sco5v6
	181	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	182	;;
	183	-sco5)
	184	os=-sco3.2v5
	185	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	186	;;
	187	-sco4)
	188	os=-sco3.2v4
	189	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	190	;;
	191	-sco3.2.[4-9]*)
	192	os=`echo $os \| sed -e 's/sco3.2./sco3.2v/'`
	193	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	194	;;
	195	-sco3.2v[4-9]*)
	196	# Don't forget version if it is 3.2v4 or newer.
	197	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	198	;;
	199	-sco5v6*)
	200	# Don't forget version if it is 3.2v4 or newer.
	201	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	202	;;
	203	-sco*)
	204	os=-sco3.2v2
	205	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	206	;;
	207	-udk*)
	208	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	209	;;
	210	-isc)
	211	os=-isc2.2
	212	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	213	;;
	214	-clix*)
	215	basic_machine=clipper-intergraph
	216	;;
	217	-isc*)
	218	basic_machine=`echo $1 \| sed -e 's/86-.*/86-pc/'`
	219	;;
	220	-lynx*178)
	221	os=-lynxos178
	222	;;
	223	-lynx*5)
	224	os=-lynxos5
	225	;;
	226	-lynx*)
	227	os=-lynxos
	228	;;
	229	-ptx*)
	230	basic_machine=`echo $1 \| sed -e 's/86-.*/86-sequent/'`
	231	;;
	232	-windowsnt*)
	233	os=`echo $os \| sed -e 's/windowsnt/winnt/'`
	234	;;
	235	-psos*)
	236	os=-psos
	237	;;
	238	-mint \| -mint[0-9]*)
	239	basic_machine=m68k-atari
	240	os=-mint
	241	;;
	242	esac
	243
	244	# Decode aliases for certain CPU-COMPANY combinations.
	245	case $basic_machine in
	246	# Recognize the basic CPU types without company name.
	247	# Some are omitted here because they have special meanings below.
	248	1750a \| 580 \
	249	\| a29k \
	250	\| aarch64 \| aarch64_be \
	251	\| alpha \| alphaev[4-8] \| alphaev56 \| alphaev6[78] \| alphapca5[67] \
	252	\| alpha64 \| alpha64ev[4-8] \| alpha64ev56 \| alpha64ev6[78] \| alpha64pca5[67] \
	253	\| am33_2.0 \
	254	\| arc \| arceb \
	255	\| arm \| arm[bl]e \| arme[lb] \| armv[2-8] \| armv[3-8][lb] \| armv7[arm] \
	256	\| avr \| avr32 \
	257	\| be32 \| be64 \
	258	\| bfin \
	259	\| c4x \| c8051 \| clipper \
	260	\| d10v \| d30v \| dlx \| dsp16xx \
	261	\| epiphany \
	262	\| fido \| fr30 \| frv \
	263	\| h8300 \| h8500 \| hppa \| hppa1.[01] \| hppa2.0 \| hppa2.0[nw] \| hppa64 \
	264	\| hexagon \
	265	\| i370 \| i860 \| i960 \| ia64 \
	266	\| ip2k \| iq2000 \
	267	\| k1om \
	268	\| le32 \| le64 \
	269	\| lm32 \
	270	\| m32c \| m32r \| m32rle \| m68000 \| m68k \| m88k \
	271	\| maxq \| mb \| microblaze \| microblazeel \| mcore \| mep \| metag \
	272	\| mips \| mipsbe \| mipseb \| mipsel \| mipsle \
	273	\| mips16 \
	274	\| mips64 \| mips64el \
	275	\| mips64octeon \| mips64octeonel \
	276	\| mips64orion \| mips64orionel \
	277	\| mips64r5900 \| mips64r5900el \
	278	\| mips64vr \| mips64vrel \
	279	\| mips64vr4100 \| mips64vr4100el \
	280	\| mips64vr4300 \| mips64vr4300el \
	281	\| mips64vr5000 \| mips64vr5000el \
	282	\| mips64vr5900 \| mips64vr5900el \
	283	\| mipsisa32 \| mipsisa32el \
	284	\| mipsisa32r2 \| mipsisa32r2el \
	285	\| mipsisa32r6 \| mipsisa32r6el \
	286	\| mipsisa64 \| mipsisa64el \
	287	\| mipsisa64r2 \| mipsisa64r2el \
	288	\| mipsisa64r6 \| mipsisa64r6el \
	289	\| mipsisa64sb1 \| mipsisa64sb1el \
	290	\| mipsisa64sr71k \| mipsisa64sr71kel \
	291	\| mipsr5900 \| mipsr5900el \
	292	\| mipstx39 \| mipstx39el \
	293	\| mn10200 \| mn10300 \
	294	\| moxie \
	295	\| mt \
	296	\| msp430 \
	297	\| nds32 \| nds32le \| nds32be \
	298	\| nios \| nios2 \| nios2eb \| nios2el \
	299	\| ns16k \| ns32k \
	300	\| open8 \| or1k \| or1knd \| or32 \
	301	\| pdp10 \| pdp11 \| pj \| pjl \
	302	\| powerpc \| powerpc64 \| powerpc64le \| powerpcle \
	303	\| pyramid \
	304	\| rl78 \| rx \
	305	\| score \
	306	\| sh \| sh[1234] \| sh[24]a \| sh[24]aeb \| sh[23]e \| sh[34]eb \| sheb \| shbe \| shle \| sh[1234]le \| sh3ele \
	307	\| sh64 \| sh64le \
	308	\| sparc \| sparc64 \| sparc64b \| sparc64v \| sparc86x \| sparclet \| sparclite \
	309	\| sparcv8 \| sparcv9 \| sparcv9b \| sparcv9v \
	310	\| spu \
	311	\| tahoe \| tic4x \| tic54x \| tic55x \| tic6x \| tic80 \| tron \
	312	\| ubicom32 \
	313	\| v850 \| v850e \| v850e1 \| v850e2 \| v850es \| v850e2v3 \
	314	\| we32k \
	315	\| x86 \| xc16x \| xstormy16 \| xtensa \
	316	\| z8k \| z80)
	317	basic_machine=$basic_machine-unknown
	318	;;
	319	c54x)
	320	basic_machine=tic54x-unknown
	321	;;
	322	c55x)
	323	basic_machine=tic55x-unknown
	324	;;
	325	c6x)
	326	basic_machine=tic6x-unknown
	327	;;
	328	m6811 \| m68hc11 \| m6812 \| m68hc12 \| m68hcs12x \| nvptx \| picochip)
	329	basic_machine=$basic_machine-unknown
	330	os=-none
	331	;;
	332	m88110 \| m680[12346]0 \| m683?2 \| m68360 \| m5200 \| v70 \| w65 \| z8k)
	333	;;
	334	ms1)
	335	basic_machine=mt-unknown
	336	;;
	337
	338	strongarm \| thumb \| xscale)
	339	basic_machine=arm-unknown
	340	;;
	341	xgate)
	342	basic_machine=$basic_machine-unknown
	343	os=-none
	344	;;
	345	xscaleeb)
	346	basic_machine=armeb-unknown
	347	;;
	348
	349	xscaleel)
	350	basic_machine=armel-unknown
	351	;;
	352
	353	# We use `pc' rather than `unknown'
	354	# because (1) that's what they normally are, and
	355	# (2) the word "unknown" tends to confuse beginning users.
	356	i*86 \| x86_64)
	357	basic_machine=$basic_machine-pc
	358	;;
	359	# Object if more than one company name word.
	360	--*)
	361	echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
	362	exit 1
	363	;;
	364	# Recognize the basic CPU types with company name.
	365	580-* \
	366	\| a29k-* \
	367	\| aarch64-* \| aarch64_be-* \
	368	\| alpha-* \| alphaev[4-8]-* \| alphaev56-* \| alphaev6[78]-* \
	369	\| alpha64-* \| alpha64ev[4-8]-* \| alpha64ev56-* \| alpha64ev6[78]-* \
	370	\| alphapca5[67]-* \| alpha64pca5[67]-* \| arc-* \| arceb-* \
	371	\| arm-* \| armbe-* \| armle-* \| armeb-* \| armv- \
	372	\| avr-* \| avr32-* \
	373	\| be32-* \| be64-* \
	374	\| bfin-* \| bs2000-* \
	375	\| c[123]* \| c30-* \| [cjt]90-* \| c4x-* \
	376	\| c8051-* \| clipper-* \| craynv-* \| cydra-* \
	377	\| d10v-* \| d30v-* \| dlx-* \
	378	\| elxsi-* \
	379	\| f30[01]-* \| f700-* \| fido-* \| fr30-* \| frv-* \| fx80-* \
	380	\| h8300-* \| h8500-* \
	381	\| hppa-* \| hppa1.[01]-* \| hppa2.0-* \| hppa2.0[nw]-* \| hppa64-* \
	382	\| hexagon-* \
	383	\| i86- \| i860-* \| i960-* \| ia64-* \
	384	\| ip2k-* \| iq2000-* \
	385	\| k1om-* \
	386	\| le32-* \| le64-* \
	387	\| lm32-* \
	388	\| m32c-* \| m32r-* \| m32rle-* \
	389	\| m68000-* \| m680[012346]0-* \| m68360-* \| m683?2-* \| m68k-* \
	390	\| m88110-* \| m88k-* \| maxq-* \| mcore-* \| metag-* \
	391	\| microblaze-* \| microblazeel-* \
	392	\| mips-* \| mipsbe-* \| mipseb-* \| mipsel-* \| mipsle-* \
	393	\| mips16-* \
	394	\| mips64-* \| mips64el-* \
	395	\| mips64octeon-* \| mips64octeonel-* \
	396	\| mips64orion-* \| mips64orionel-* \
	397	\| mips64r5900-* \| mips64r5900el-* \
	398	\| mips64vr-* \| mips64vrel-* \
	399	\| mips64vr4100-* \| mips64vr4100el-* \
	400	\| mips64vr4300-* \| mips64vr4300el-* \
	401	\| mips64vr5000-* \| mips64vr5000el-* \
	402	\| mips64vr5900-* \| mips64vr5900el-* \
	403	\| mipsisa32-* \| mipsisa32el-* \
	404	\| mipsisa32r2-* \| mipsisa32r2el-* \
	405	\| mipsisa32r6-* \| mipsisa32r6el-* \
	406	\| mipsisa64-* \| mipsisa64el-* \
	407	\| mipsisa64r2-* \| mipsisa64r2el-* \
	408	\| mipsisa64r6-* \| mipsisa64r6el-* \
	409	\| mipsisa64sb1-* \| mipsisa64sb1el-* \
	410	\| mipsisa64sr71k-* \| mipsisa64sr71kel-* \
	411	\| mipsr5900-* \| mipsr5900el-* \
	412	\| mipstx39-* \| mipstx39el-* \
	413	\| mmix-* \
	414	\| mt-* \
	415	\| msp430-* \
	416	\| nds32-* \| nds32le-* \| nds32be-* \
	417	\| nios-* \| nios2-* \| nios2eb-* \| nios2el-* \
	418	\| none-* \| np1-* \| ns16k-* \| ns32k-* \
	419	\| open8-* \
	420	\| or1k- \
	421	\| orion-* \
	422	\| pdp10-* \| pdp11-* \| pj-* \| pjl-* \| pn-* \| power-* \
	423	\| powerpc-* \| powerpc64-* \| powerpc64le-* \| powerpcle-* \
	424	\| pyramid-* \
	425	\| rl78-* \| romp-* \| rs6000-* \| rx-* \
	426	\| sh-* \| sh[1234]-* \| sh[24]a-* \| sh[24]aeb-* \| sh[23]e-* \| sh[34]eb-* \| sheb-* \| shbe-* \
	427	\| shle-* \| sh[1234]le-* \| sh3ele-* \| sh64-* \| sh64le-* \
	428	\| sparc-* \| sparc64-* \| sparc64b-* \| sparc64v-* \| sparc86x-* \| sparclet-* \
	429	\| sparclite-* \
	430	\| sparcv8-* \| sparcv9-* \| sparcv9b-* \| sparcv9v-* \| sv1-* \| sx?-* \
	431	\| tahoe-* \
	432	\| tic30-* \| tic4x-* \| tic54x-* \| tic55x-* \| tic6x-* \| tic80-* \
	433	\| tile- \
	434	\| tron-* \
	435	\| ubicom32-* \
	436	\| v850-* \| v850e-* \| v850e1-* \| v850es-* \| v850e2-* \| v850e2v3-* \
	437	\| vax-* \
	438	\| we32k-* \
	439	\| x86-* \| x86_64-* \| xc16x-* \| xps100-* \
	440	\| xstormy16-* \| xtensa- \
	441	\| ymp-* \
	442	\| z8k-* \| z80-*)
	443	;;
	444	# Recognize the basic CPU types without company name, with glob match.
	445	xtensa*)
	446	basic_machine=$basic_machine-unknown
	447	;;
	448	# Recognize the various machine names and aliases which stand
	449	# for a CPU type and a company and sometimes even an OS.
	450	386bsd)
	451	basic_machine=i386-unknown
	452	os=-bsd
	453	;;
	454	3b1 \| 7300 \| 7300-att \| att-7300 \| pc7300 \| safari \| unixpc)
	455	basic_machine=m68000-att
	456	;;
	457	3b*)
	458	basic_machine=we32k-att
	459	;;
	460	a29khif)
	461	basic_machine=a29k-amd
	462	os=-udi
	463	;;
	464	abacus)
	465	basic_machine=abacus-unknown
	466	;;
	467	adobe68k)
	468	basic_machine=m68010-adobe
	469	os=-scout
	470	;;
	471	alliant \| fx80)
	472	basic_machine=fx80-alliant
	473	;;
	474	altos \| altos3068)
	475	basic_machine=m68k-altos
	476	;;
	477	am29k)
	478	basic_machine=a29k-none
	479	os=-bsd
	480	;;
	481	amd64)
	482	basic_machine=x86_64-pc
	483	;;
	484	amd64-*)
	485	basic_machine=x86_64-`echo $basic_machine \| sed 's/^[^-]*-//'`
	486	;;
	487	amdahl)
	488	basic_machine=580-amdahl
	489	os=-sysv
	490	;;
	491	amiga \| amiga-*)
	492	basic_machine=m68k-unknown
	493	;;
	494	amigaos \| amigados)
	495	basic_machine=m68k-unknown
	496	os=-amigaos
	497	;;
	498	amigaunix \| amix)
	499	basic_machine=m68k-unknown
	500	os=-sysv4
	501	;;
	502	apollo68)
	503	basic_machine=m68k-apollo
	504	os=-sysv
	505	;;
	506	apollo68bsd)
	507	basic_machine=m68k-apollo
	508	os=-bsd
	509	;;
	510	aros)
	511	basic_machine=i386-pc
	512	os=-aros
	513	;;
	514	aux)
	515	basic_machine=m68k-apple
	516	os=-aux
	517	;;
	518	balance)
	519	basic_machine=ns32k-sequent
	520	os=-dynix
	521	;;
	522	blackfin)
	523	basic_machine=bfin-unknown
	524	os=-linux
	525	;;
	526	blackfin-*)
	527	basic_machine=bfin-`echo $basic_machine \| sed 's/^[^-]*-//'`
	528	os=-linux
	529	;;
	530	bluegene*)
	531	basic_machine=powerpc-ibm
	532	os=-cnk
	533	;;
	534	c54x-*)
	535	basic_machine=tic54x-`echo $basic_machine \| sed 's/^[^-]*-//'`
	536	;;
	537	c55x-*)
	538	basic_machine=tic55x-`echo $basic_machine \| sed 's/^[^-]*-//'`
	539	;;
	540	c6x-*)
	541	basic_machine=tic6x-`echo $basic_machine \| sed 's/^[^-]*-//'`
	542	;;
	543	c90)
	544	basic_machine=c90-cray
	545	os=-unicos
	546	;;
	547	cegcc)
	548	basic_machine=arm-unknown
	549	os=-cegcc
	550	;;
	551	convex-c1)
	552	basic_machine=c1-convex
	553	os=-bsd
	554	;;
	555	convex-c2)
	556	basic_machine=c2-convex
	557	os=-bsd
	558	;;
	559	convex-c32)
	560	basic_machine=c32-convex
	561	os=-bsd
	562	;;
	563	convex-c34)
	564	basic_machine=c34-convex
	565	os=-bsd
	566	;;
	567	convex-c38)
	568	basic_machine=c38-convex
	569	os=-bsd
	570	;;
	571	cray \| j90)
	572	basic_machine=j90-cray
	573	os=-unicos
	574	;;
	575	craynv)
	576	basic_machine=craynv-cray
	577	os=-unicosmp
	578	;;
	579	cr16 \| cr16-*)
	580	basic_machine=cr16-unknown
	581	os=-elf
	582	;;
	583	crds \| unos)
	584	basic_machine=m68k-crds
	585	;;
	586	crisv32 \| crisv32-* \| etraxfs*)
	587	basic_machine=crisv32-axis
	588	;;
	589	cris \| cris-* \| etrax*)
	590	basic_machine=cris-axis
	591	;;
	592	crx)
	593	basic_machine=crx-unknown
	594	os=-elf
	595	;;
	596	da30 \| da30-*)
	597	basic_machine=m68k-da30
	598	;;
	599	decstation \| decstation-3100 \| pmax \| pmax-* \| pmin \| dec3100 \| decstatn)
	600	basic_machine=mips-dec
	601	;;
	602	decsystem10* \| dec10*)
	603	basic_machine=pdp10-dec
	604	os=-tops10
	605	;;
	606	decsystem20* \| dec20*)
	607	basic_machine=pdp10-dec
	608	os=-tops20
	609	;;
	610	delta \| 3300 \| motorola-3300 \| motorola-delta \
	611	\| 3300-motorola \| delta-motorola)
	612	basic_machine=m68k-motorola
	613	;;
	614	delta88)
	615	basic_machine=m88k-motorola
	616	os=-sysv3
	617	;;
	618	dicos)
	619	basic_machine=i686-pc
	620	os=-dicos
	621	;;
	622	djgpp)
	623	basic_machine=i586-pc
	624	os=-msdosdjgpp
	625	;;
	626	dpx20 \| dpx20-*)
	627	basic_machine=rs6000-bull
	628	os=-bosx
	629	;;
	630	dpx2* \| dpx2*-bull)
	631	basic_machine=m68k-bull
	632	os=-sysv3
	633	;;
	634	ebmon29k)
	635	basic_machine=a29k-amd
	636	os=-ebmon
	637	;;
	638	elxsi)
	639	basic_machine=elxsi-elxsi
	640	os=-bsd
	641	;;
	642	encore \| umax \| mmax)
	643	basic_machine=ns32k-encore
	644	;;
	645	es1800 \| OSE68k \| ose68k \| ose \| OSE)
	646	basic_machine=m68k-ericsson
	647	os=-ose
	648	;;
	649	fx2800)
	650	basic_machine=i860-alliant
	651	;;
	652	genix)
	653	basic_machine=ns32k-ns
	654	;;
	655	gmicro)
	656	basic_machine=tron-gmicro
	657	os=-sysv
	658	;;
	659	go32)
	660	basic_machine=i386-pc
	661	os=-go32
	662	;;
	663	h3050r* \| hiux*)
	664	basic_machine=hppa1.1-hitachi
	665	os=-hiuxwe2
	666	;;
	667	h8300hms)
	668	basic_machine=h8300-hitachi
	669	os=-hms
	670	;;
	671	h8300xray)
	672	basic_machine=h8300-hitachi
	673	os=-xray
	674	;;
	675	h8500hms)
	676	basic_machine=h8500-hitachi
	677	os=-hms
	678	;;
	679	harris)
	680	basic_machine=m88k-harris
	681	os=-sysv3
	682	;;
	683	hp300-*)
	684	basic_machine=m68k-hp
	685	;;
	686	hp300bsd)
	687	basic_machine=m68k-hp
	688	os=-bsd
	689	;;
	690	hp300hpux)
	691	basic_machine=m68k-hp
	692	os=-hpux
	693	;;
	694	hp3k9[0-9][0-9] \| hp9[0-9][0-9])
	695	basic_machine=hppa1.0-hp
	696	;;
	697	hp9k2[0-9][0-9] \| hp9k31[0-9])
	698	basic_machine=m68000-hp
	699	;;
	700	hp9k3[2-9][0-9])
	701	basic_machine=m68k-hp
	702	;;
	703	hp9k6[0-9][0-9] \| hp6[0-9][0-9])
	704	basic_machine=hppa1.0-hp
	705	;;
	706	hp9k7[0-79][0-9] \| hp7[0-79][0-9])
	707	basic_machine=hppa1.1-hp
	708	;;
	709	hp9k78[0-9] \| hp78[0-9])
	710	# FIXME: really hppa2.0-hp
	711	basic_machine=hppa1.1-hp
	712	;;
	713	hp9k8[67]1 \| hp8[67]1 \| hp9k80[24] \| hp80[24] \| hp9k8[78]9 \| hp8[78]9 \| hp9k893 \| hp893)
	714	# FIXME: really hppa2.0-hp
	715	basic_machine=hppa1.1-hp
	716	;;
	717	hp9k8[0-9][13679] \| hp8[0-9][13679])
	718	basic_machine=hppa1.1-hp
	719	;;
	720	hp9k8[0-9][0-9] \| hp8[0-9][0-9])
	721	basic_machine=hppa1.0-hp
	722	;;
	723	hppa-next)
	724	os=-nextstep3
	725	;;
	726	hppaosf)
	727	basic_machine=hppa1.1-hp
	728	os=-osf
	729	;;
	730	hppro)
	731	basic_machine=hppa1.1-hp
	732	os=-proelf
	733	;;
	734	i370-ibm* \| ibm*)
	735	basic_machine=i370-ibm
	736	;;
	737	i*86v32)
	738	basic_machine=`echo $1 \| sed -e 's/86.*/86-pc/'`
	739	os=-sysv32
	740	;;
	741	i86v4)
	742	basic_machine=`echo $1 \| sed -e 's/86.*/86-pc/'`
	743	os=-sysv4
	744	;;
	745	i*86v)
	746	basic_machine=`echo $1 \| sed -e 's/86.*/86-pc/'`
	747	os=-sysv
	748	;;
	749	i*86sol2)
	750	basic_machine=`echo $1 \| sed -e 's/86.*/86-pc/'`
	751	os=-solaris2
	752	;;
	753	i386mach)
	754	basic_machine=i386-mach
	755	os=-mach
	756	;;
	757	i386-vsta \| vsta)
	758	basic_machine=i386-unknown
	759	os=-vsta
	760	;;
	761	iris \| iris4d)
	762	basic_machine=mips-sgi
	763	case $os in
	764	-irix*)
	765	;;
	766	*)
	767	os=-irix4
	768	;;
	769	esac
	770	;;
	771	isi68 \| isi)
	772	basic_machine=m68k-isi
	773	os=-sysv
	774	;;
	775	m68knommu)
	776	basic_machine=m68k-unknown
	777	os=-linux
	778	;;
	779	m68knommu-*)
	780	basic_machine=m68k-`echo $basic_machine \| sed 's/^[^-]*-//'`
	781	os=-linux
	782	;;
	783	m88k-omron*)
	784	basic_machine=m88k-omron
	785	;;
	786	magnum \| m3230)
	787	basic_machine=mips-mips
	788	os=-sysv
	789	;;
	790	merlin)
	791	basic_machine=ns32k-utek
	792	os=-sysv
	793	;;
	794	microblaze*)
	795	basic_machine=microblaze-xilinx
	796	;;
	797	mingw64)
	798	basic_machine=x86_64-pc
	799	os=-mingw64
	800	;;
	801	mingw32)
	802	basic_machine=i686-pc
	803	os=-mingw32
	804	;;
	805	mingw32ce)
	806	basic_machine=arm-unknown
	807	os=-mingw32ce
	808	;;
	809	miniframe)
	810	basic_machine=m68000-convergent
	811	;;
	812	mint \| -mint[0-9] \| MiNT \| MiNT[0-9]*)
	813	basic_machine=m68k-atari
	814	os=-mint
	815	;;
	816	mips3-)
	817	basic_machine=`echo $basic_machine \| sed -e 's/mips3/mips64/'`
	818	;;
	819	mips3*)
	820	basic_machine=`echo $basic_machine \| sed -e 's/mips3/mips64/'`-unknown
	821	;;
	822	monitor)
	823	basic_machine=m68k-rom68k
	824	os=-coff
	825	;;
	826	morphos)
	827	basic_machine=powerpc-unknown
	828	os=-morphos
	829	;;
	830	moxiebox)
	831	basic_machine=moxie-unknown
	832	os=-moxiebox
	833	;;
	834	msdos)
	835	basic_machine=i386-pc
	836	os=-msdos
	837	;;
	838	ms1-*)
	839	basic_machine=`echo $basic_machine \| sed -e 's/ms1-/mt-/'`
	840	;;
	841	msys)
	842	basic_machine=i686-pc
	843	os=-msys
	844	;;
	845	mvs)
	846	basic_machine=i370-ibm
	847	os=-mvs
	848	;;
	849	nacl)
	850	basic_machine=le32-unknown
	851	os=-nacl
	852	;;
	853	ncr3000)
	854	basic_machine=i486-ncr
	855	os=-sysv4
	856	;;
	857	netbsd386)
	858	basic_machine=i386-unknown
	859	os=-netbsd
	860	;;
	861	netwinder)
	862	basic_machine=armv4l-rebel
	863	os=-linux
	864	;;
	865	news \| news700 \| news800 \| news900)
	866	basic_machine=m68k-sony
	867	os=-newsos
	868	;;
	869	news1000)
	870	basic_machine=m68030-sony
	871	os=-newsos
	872	;;
	873	news-3600 \| risc-news)
	874	basic_machine=mips-sony
	875	os=-newsos
	876	;;
	877	necv70)
	878	basic_machine=v70-nec
	879	os=-sysv
	880	;;
	881	next \| m*-next )
	882	basic_machine=m68k-next
	883	case $os in
	884	-nextstep* )
	885	;;
	886	-ns2*)
	887	os=-nextstep2
	888	;;
	889	*)
	890	os=-nextstep3
	891	;;
	892	esac
	893	;;
	894	nh3000)
	895	basic_machine=m68k-harris
	896	os=-cxux
	897	;;
	898	nh[45]000)
	899	basic_machine=m88k-harris
	900	os=-cxux
	901	;;
	902	nindy960)
	903	basic_machine=i960-intel
	904	os=-nindy
	905	;;
	906	mon960)
	907	basic_machine=i960-intel
	908	os=-mon960
	909	;;
	910	nonstopux)
	911	basic_machine=mips-compaq
	912	os=-nonstopux
	913	;;
	914	np1)
	915	basic_machine=np1-gould
	916	;;
	917	neo-tandem)
	918	basic_machine=neo-tandem
	919	;;
	920	nse-tandem)
	921	basic_machine=nse-tandem
	922	;;
	923	nsr-tandem)
	924	basic_machine=nsr-tandem
	925	;;
	926	op50n-* \| op60c-*)
	927	basic_machine=hppa1.1-oki
	928	os=-proelf
	929	;;
	930	openrisc \| openrisc-*)
	931	basic_machine=or32-unknown
	932	;;
	933	os400)
	934	basic_machine=powerpc-ibm
	935	os=-os400
	936	;;
	937	OSE68000 \| ose68000)
	938	basic_machine=m68000-ericsson
	939	os=-ose
	940	;;
	941	os68k)
	942	basic_machine=m68k-none
	943	os=-os68k
	944	;;
	945	pa-hitachi)
	946	basic_machine=hppa1.1-hitachi
	947	os=-hiuxwe2
	948	;;
	949	paragon)
	950	basic_machine=i860-intel
	951	os=-osf
	952	;;
	953	parisc)
	954	basic_machine=hppa-unknown
	955	os=-linux
	956	;;
	957	parisc-*)
	958	basic_machine=hppa-`echo $basic_machine \| sed 's/^[^-]*-//'`
	959	os=-linux
	960	;;
	961	pbd)
	962	basic_machine=sparc-tti
	963	;;
	964	pbb)
	965	basic_machine=m68k-tti
	966	;;
	967	pc532 \| pc532-*)
	968	basic_machine=ns32k-pc532
	969	;;
	970	pc98)
	971	basic_machine=i386-pc
	972	;;
	973	pc98-*)
	974	basic_machine=i386-`echo $basic_machine \| sed 's/^[^-]*-//'`
	975	;;
	976	pentium \| p5 \| k5 \| k6 \| nexgen \| viac3)
	977	basic_machine=i586-pc
	978	;;
	979	pentiumpro \| p6 \| 6x86 \| athlon \| athlon_*)
	980	basic_machine=i686-pc
	981	;;
	982	pentiumii \| pentium2 \| pentiumiii \| pentium3)
	983	basic_machine=i686-pc
	984	;;
	985	pentium4)
	986	basic_machine=i786-pc
	987	;;
	988	pentium-* \| p5-* \| k5-* \| k6-* \| nexgen-* \| viac3-*)
	989	basic_machine=i586-`echo $basic_machine \| sed 's/^[^-]*-//'`
	990	;;
	991	pentiumpro-* \| p6-* \| 6x86-* \| athlon-*)
	992	basic_machine=i686-`echo $basic_machine \| sed 's/^[^-]*-//'`
	993	;;
	994	pentiumii-* \| pentium2-* \| pentiumiii-* \| pentium3-*)
	995	basic_machine=i686-`echo $basic_machine \| sed 's/^[^-]*-//'`
	996	;;
	997	pentium4-*)
	998	basic_machine=i786-`echo $basic_machine \| sed 's/^[^-]*-//'`
	999	;;
	1000	pn)
	1001	basic_machine=pn-gould
	1002	;;
	1003	power) basic_machine=power-ibm
	1004	;;
	1005	ppc \| ppcbe) basic_machine=powerpc-unknown
	1006	;;
	1007	ppc-* \| ppcbe-*)
	1008	basic_machine=powerpc-`echo $basic_machine \| sed 's/^[^-]*-//'`
	1009	;;
	1010	ppcle \| powerpclittle \| ppc-le \| powerpc-little)
	1011	basic_machine=powerpcle-unknown
	1012	;;
	1013	ppcle-* \| powerpclittle-*)
	1014	basic_machine=powerpcle-`echo $basic_machine \| sed 's/^[^-]*-//'`
	1015	;;
	1016	ppc64) basic_machine=powerpc64-unknown
	1017	;;
	1018	ppc64-* \| ppc64p7-) basic_machine=powerpc64-`echo $basic_machine \| sed 's/^[^-]-//'`
	1019	;;
	1020	ppc64le \| powerpc64little \| ppc64-le \| powerpc64-little)
	1021	basic_machine=powerpc64le-unknown
	1022	;;
	1023	ppc64le-* \| powerpc64little-*)
	1024	basic_machine=powerpc64le-`echo $basic_machine \| sed 's/^[^-]*-//'`
	1025	;;
	1026	ps2)
	1027	basic_machine=i386-ibm
	1028	;;
	1029	pw32)
	1030	basic_machine=i586-unknown
	1031	os=-pw32
	1032	;;
	1033	rdos \| rdos64)
	1034	basic_machine=x86_64-pc
	1035	os=-rdos
	1036	;;
	1037	rdos32)
	1038	basic_machine=i386-pc
	1039	os=-rdos
	1040	;;
	1041	rom68k)
	1042	basic_machine=m68k-rom68k
	1043	os=-coff
	1044	;;
	1045	rm[46]00)
	1046	basic_machine=mips-siemens
	1047	;;
	1048	rtpc \| rtpc-*)
	1049	basic_machine=romp-ibm
	1050	;;
	1051	s390 \| s390-*)
	1052	basic_machine=s390-ibm
	1053	;;
	1054	s390x \| s390x-*)
	1055	basic_machine=s390x-ibm
	1056	;;
	1057	sa29200)
	1058	basic_machine=a29k-amd
	1059	os=-udi
	1060	;;
	1061	sb1)
	1062	basic_machine=mipsisa64sb1-unknown
	1063	;;
	1064	sb1el)
	1065	basic_machine=mipsisa64sb1el-unknown
	1066	;;
	1067	sde)
	1068	basic_machine=mipsisa32-sde
	1069	os=-elf
	1070	;;
	1071	sei)
	1072	basic_machine=mips-sei
	1073	os=-seiux
	1074	;;
	1075	sequent)
	1076	basic_machine=i386-sequent
	1077	;;
	1078	sh)
	1079	basic_machine=sh-hitachi
	1080	os=-hms
	1081	;;
	1082	sh5el)
	1083	basic_machine=sh5le-unknown
	1084	;;
	1085	sh64)
	1086	basic_machine=sh64-unknown
	1087	;;
	1088	sparclite-wrs \| simso-wrs)
	1089	basic_machine=sparclite-wrs
	1090	os=-vxworks
	1091	;;
	1092	sps7)
	1093	basic_machine=m68k-bull
	1094	os=-sysv2
	1095	;;
	1096	spur)
	1097	basic_machine=spur-unknown
	1098	;;
	1099	st2000)
	1100	basic_machine=m68k-tandem
	1101	;;
	1102	stratus)
	1103	basic_machine=i860-stratus
	1104	os=-sysv4
	1105	;;
	1106	strongarm-* \| thumb-*)
	1107	basic_machine=arm-`echo $basic_machine \| sed 's/^[^-]*-//'`
	1108	;;
	1109	sun2)
	1110	basic_machine=m68000-sun
	1111	;;
	1112	sun2os3)
	1113	basic_machine=m68000-sun
	1114	os=-sunos3
	1115	;;
	1116	sun2os4)
	1117	basic_machine=m68000-sun
	1118	os=-sunos4
	1119	;;
	1120	sun3os3)
	1121	basic_machine=m68k-sun
	1122	os=-sunos3
	1123	;;
	1124	sun3os4)
	1125	basic_machine=m68k-sun
	1126	os=-sunos4
	1127	;;
	1128	sun4os3)
	1129	basic_machine=sparc-sun
	1130	os=-sunos3
	1131	;;
	1132	sun4os4)
	1133	basic_machine=sparc-sun
	1134	os=-sunos4
	1135	;;
	1136	sun4sol2)
	1137	basic_machine=sparc-sun
	1138	os=-solaris2
	1139	;;
	1140	sun3 \| sun3-*)
	1141	basic_machine=m68k-sun
	1142	;;
	1143	sun4)
	1144	basic_machine=sparc-sun
	1145	;;
	1146	sun386 \| sun386i \| roadrunner)
	1147	basic_machine=i386-sun
	1148	;;
	1149	sv1)
	1150	basic_machine=sv1-cray
	1151	os=-unicos
	1152	;;
	1153	symmetry)
	1154	basic_machine=i386-sequent
	1155	os=-dynix
	1156	;;
	1157	t3e)
	1158	basic_machine=alphaev5-cray
	1159	os=-unicos
	1160	;;
	1161	t90)
	1162	basic_machine=t90-cray
	1163	os=-unicos
	1164	;;
	1165	tile*)
	1166	basic_machine=$basic_machine-unknown
	1167	os=-linux-gnu
	1168	;;
	1169	tx39)
	1170	basic_machine=mipstx39-unknown
	1171	;;
	1172	tx39el)
	1173	basic_machine=mipstx39el-unknown
	1174	;;
	1175	toad1)
	1176	basic_machine=pdp10-xkl
	1177	os=-tops20
	1178	;;
	1179	tower \| tower-32)
	1180	basic_machine=m68k-ncr
	1181	;;
	1182	tpf)
	1183	basic_machine=s390x-ibm
	1184	os=-tpf
	1185	;;
	1186	udi29k)
	1187	basic_machine=a29k-amd
	1188	os=-udi
	1189	;;
	1190	ultra3)
	1191	basic_machine=a29k-nyu
	1192	os=-sym1
	1193	;;
	1194	v810 \| necv810)
	1195	basic_machine=v810-nec
	1196	os=-none
	1197	;;
	1198	vaxv)
	1199	basic_machine=vax-dec
	1200	os=-sysv
	1201	;;
	1202	vms)
	1203	basic_machine=vax-dec
	1204	os=-vms
	1205	;;
	1206	vpp\|vx\|vx-)
	1207	basic_machine=f301-fujitsu
	1208	;;
	1209	vxworks960)
	1210	basic_machine=i960-wrs
	1211	os=-vxworks
	1212	;;
	1213	vxworks68)
	1214	basic_machine=m68k-wrs
	1215	os=-vxworks
	1216	;;
	1217	vxworks29k)
	1218	basic_machine=a29k-wrs
	1219	os=-vxworks
	1220	;;
	1221	w65*)
	1222	basic_machine=w65-wdc
	1223	os=-none
	1224	;;
	1225	w89k-*)
	1226	basic_machine=hppa1.1-winbond
	1227	os=-proelf
	1228	;;
	1229	xbox)
	1230	basic_machine=i686-pc
	1231	os=-mingw32
	1232	;;
	1233	xps \| xps100)
	1234	basic_machine=xps100-honeywell
	1235	;;
	1236	xscale-* \| xscalee[bl]-*)
	1237	basic_machine=`echo $basic_machine \| sed 's/^xscale/arm/'`
	1238	;;
	1239	ymp)
	1240	basic_machine=ymp-cray
	1241	os=-unicos
	1242	;;
	1243	z8k-*-coff)
	1244	basic_machine=z8k-unknown
	1245	os=-sim
	1246	;;
	1247	z80-*-coff)
	1248	basic_machine=z80-unknown
	1249	os=-sim
	1250	;;
	1251	none)
	1252	basic_machine=none-none
	1253	os=-none
	1254	;;
	1255
	1256	# Here we handle the default manufacturer of certain CPU types. It is in
	1257	# some cases the only manufacturer, in others, it is the most popular.
	1258	w89k)
	1259	basic_machine=hppa1.1-winbond
	1260	;;
	1261	op50n)
	1262	basic_machine=hppa1.1-oki
	1263	;;
	1264	op60c)
	1265	basic_machine=hppa1.1-oki
	1266	;;
	1267	romp)
	1268	basic_machine=romp-ibm
	1269	;;
	1270	mmix)
	1271	basic_machine=mmix-knuth
	1272	;;
	1273	rs6000)
	1274	basic_machine=rs6000-ibm
	1275	;;
	1276	vax)
	1277	basic_machine=vax-dec
	1278	;;
	1279	pdp10)
	1280	# there are many clones, so DEC is not a safe bet
	1281	basic_machine=pdp10-unknown
	1282	;;
	1283	pdp11)
	1284	basic_machine=pdp11-dec
	1285	;;
	1286	we32k)
	1287	basic_machine=we32k-att
	1288	;;
	1289	sh[1234] \| sh[24]a \| sh[24]aeb \| sh[34]eb \| sh[1234]le \| sh[23]ele)
	1290	basic_machine=sh-unknown
	1291	;;
	1292	sparc \| sparcv8 \| sparcv9 \| sparcv9b \| sparcv9v)
	1293	basic_machine=sparc-sun
	1294	;;
	1295	cydra)
	1296	basic_machine=cydra-cydrome
	1297	;;
	1298	orion)
	1299	basic_machine=orion-highlevel
	1300	;;
	1301	orion105)
	1302	basic_machine=clipper-highlevel
	1303	;;
	1304	mac \| mpw \| mac-mpw)
	1305	basic_machine=m68k-apple
	1306	;;
	1307	pmac \| pmac-mpw)
	1308	basic_machine=powerpc-apple
	1309	;;
	1310	*-unknown)
	1311	# Make sure to match an already-canonicalized machine name.
	1312	;;
	1313	*)
	1314	echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
	1315	exit 1
	1316	;;
	1317	esac
	1318
	1319	# Here we canonicalize certain aliases for manufacturers.
	1320	case $basic_machine in
	1321	-digital)
	1322	basic_machine=`echo $basic_machine \| sed 's/digital.*/dec/'`
	1323	;;
	1324	-commodore)
	1325	basic_machine=`echo $basic_machine \| sed 's/commodore.*/cbm/'`
	1326	;;
	1327	*)
	1328	;;
	1329	esac
	1330
	1331	# Decode manufacturer-specific aliases for certain operating systems.
	1332
	1333	if [ x"$os" != x"" ]
	1334	then
	1335	case $os in
	1336	# First match some system type aliases
	1337	# that might get confused with valid system types.
	1338	# -solaris* is a basic system type, with this one exception.
	1339	-auroraux)
	1340	os=-auroraux
	1341	;;
	1342	-solaris1 \| -solaris1.*)
	1343	os=`echo $os \| sed -e 's\|solaris1\|sunos4\|'`
	1344	;;
	1345	-solaris)
	1346	os=-solaris2
	1347	;;
	1348	-svr4*)
	1349	os=-sysv4
	1350	;;
	1351	-unixware*)
	1352	os=-sysv4.2uw
	1353	;;
	1354	-gnu/linux*)
	1355	os=`echo $os \| sed -e 's\|gnu/linux\|linux-gnu\|'`
	1356	;;
	1357	# First accept the basic system types.
	1358	# The portable systems comes first.
	1359	# Each alternative MUST END IN A *, to match a version number.
	1360	# -sysv* is not here because it comes later, after sysvr4.
	1361	-gnu* \| -bsd* \| -mach* \| -minix* \| -genix* \| -ultrix* \| -irix* \
	1362	\| -vms \| -sco* \| -esix* \| -isc* \| -aix* \| -cnk* \| -sunos \| -sunos[34]*\
	1363	\| -hpux* \| -unos* \| -osf* \| -luna* \| -dgux* \| -auroraux* \| -solaris* \
	1364	\| -sym* \| -kopensolaris* \| -plan9* \
	1365	\| -amigaos* \| -amigados* \| -msdos* \| -newsos* \| -unicos* \| -aof* \
	1366	\| -aos* \| -aros* \
	1367	\| -nindy* \| -vxsim* \| -vxworks* \| -ebmon* \| -hms* \| -mvs* \
	1368	\| -clix* \| -riscos* \| -uniplus* \| -iris* \| -rtu* \| -xenix* \
	1369	\| -hiux* \| -386bsd* \| -knetbsd* \| -mirbsd* \| -netbsd* \
	1370	\| -bitrig* \| -openbsd* \| -solidbsd* \
	1371	\| -ekkobsd* \| -kfreebsd* \| -freebsd* \| -riscix* \| -lynxos* \
	1372	\| -bosx* \| -nextstep* \| -cxux* \| -aout* \| -elf* \| -oabi* \
	1373	\| -ptx* \| -coff* \| -ecoff* \| -winnt* \| -domain* \| -vsta* \
	1374	\| -udi* \| -eabi* \| -lites* \| -ieee* \| -go32* \| -aux* \
	1375	\| -chorusos* \| -chorusrdb* \| -cegcc* \
	1376	\| -cygwin* \| -msys* \| -pe* \| -psos* \| -moss* \| -proelf* \| -rtems* \
	1377	\| -mingw32* \| -mingw64* \| -linux-gnu* \| -linux-android* \
	1378	\| -linux-newlib* \| -linux-musl* \| -linux-uclibc* \
	1379	\| -uxpv* \| -beos* \| -mpeix* \| -udk* \| -moxiebox* \
	1380	\| -interix* \| -uwin* \| -mks* \| -rhapsody* \| -darwin* \| -opened* \
	1381	\| -openstep* \| -oskit* \| -conix* \| -pw32* \| -nonstopux* \
	1382	\| -storm-chaos* \| -tops10* \| -tenex* \| -tops20* \| -its* \
	1383	\| -os2* \| -vos* \| -palmos* \| -uclinux* \| -nucleus* \
	1384	\| -morphos* \| -superux* \| -rtmk* \| -rtmk-nova* \| -windiss* \
	1385	\| -powermax* \| -dnix* \| -nx6 \| -nx7 \| -sei* \| -dragonfly* \
	1386	\| -skyos* \| -haiku* \| -rdos* \| -toppers* \| -drops* \| -es* \| -tirtos*)
	1387	# Remember, each alternative MUST END IN *, to match a version number.
	1388	;;
	1389	-qnx*)
	1390	case $basic_machine in
	1391	x86-* \| i86-)
	1392	;;
	1393	*)
	1394	os=-nto$os
	1395	;;
	1396	esac
	1397	;;
	1398	-nto-qnx*)
	1399	;;
	1400	-nto*)
	1401	os=`echo $os \| sed -e 's\|nto\|nto-qnx\|'`
	1402	;;
	1403	-sim \| -es1800* \| -hms* \| -xray \| -os68k* \| -none* \| -v88r* \
	1404	\| -windows* \| -osx \| -abug \| -netware* \| -os9* \| -beos* \| -haiku* \
	1405	\| -macos* \| -mpw* \| -magic* \| -mmixware* \| -mon960* \| -lnews*)
	1406	;;
	1407	-mac*)
	1408	os=`echo $os \| sed -e 's\|mac\|macos\|'`
	1409	;;
	1410	-linux-dietlibc)
	1411	os=-linux-dietlibc
	1412	;;
	1413	-linux*)
	1414	os=`echo $os \| sed -e 's\|linux\|linux-gnu\|'`
	1415	;;
	1416	-sunos5*)
	1417	os=`echo $os \| sed -e 's\|sunos5\|solaris2\|'`
	1418	;;
	1419	-sunos6*)
	1420	os=`echo $os \| sed -e 's\|sunos6\|solaris3\|'`
	1421	;;
	1422	-opened*)
	1423	os=-openedition
	1424	;;
	1425	-os400*)
	1426	os=-os400
	1427	;;
	1428	-wince*)
	1429	os=-wince
	1430	;;
	1431	-osfrose*)
	1432	os=-osfrose
	1433	;;
	1434	-osf*)
	1435	os=-osf
	1436	;;
	1437	-utek*)
	1438	os=-bsd
	1439	;;
	1440	-dynix*)
	1441	os=-bsd
	1442	;;
	1443	-acis*)
	1444	os=-aos
	1445	;;
	1446	-atheos*)
	1447	os=-atheos
	1448	;;
	1449	-syllable*)
	1450	os=-syllable
	1451	;;
	1452	-386bsd)
	1453	os=-bsd
	1454	;;
	1455	-ctix* \| -uts*)
	1456	os=-sysv
	1457	;;
	1458	-nova*)
	1459	os=-rtmk-nova
	1460	;;
	1461	-ns2 )
	1462	os=-nextstep2
	1463	;;
	1464	-nsk*)
	1465	os=-nsk
	1466	;;
	1467	# Preserve the version number of sinix5.
	1468	-sinix5.*)
	1469	os=`echo $os \| sed -e 's\|sinix\|sysv\|'`
	1470	;;
	1471	-sinix*)
	1472	os=-sysv4
	1473	;;
	1474	-tpf*)
	1475	os=-tpf
	1476	;;
	1477	-triton*)
	1478	os=-sysv3
	1479	;;
	1480	-oss*)
	1481	os=-sysv3
	1482	;;
	1483	-svr4)
	1484	os=-sysv4
	1485	;;
	1486	-svr3)
	1487	os=-sysv3
	1488	;;
	1489	-sysvr4)
	1490	os=-sysv4
	1491	;;
	1492	# This must come after -sysvr4.
	1493	-sysv*)
	1494	;;
	1495	-ose*)
	1496	os=-ose
	1497	;;
	1498	-es1800*)
	1499	os=-ose
	1500	;;
	1501	-xenix)
	1502	os=-xenix
	1503	;;
	1504	-mint \| -mint[0-9] \| -MiNT \| -MiNT[0-9])
	1505	os=-mint
	1506	;;
	1507	-aros*)
	1508	os=-aros
	1509	;;
	1510	-zvmoe)
	1511	os=-zvmoe
	1512	;;
	1513	-dicos*)
	1514	os=-dicos
	1515	;;
	1516	-nacl*)
	1517	;;
	1518	-none)
	1519	;;
	1520	*)
	1521	# Get rid of the `-' at the beginning of $os.
	1522	os=`echo $os \| sed 's/[^-]*-//'`
	1523	echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
	1524	exit 1
	1525	;;
	1526	esac
	1527	else
	1528
	1529	# Here we handle the default operating systems that come with various machines.
	1530	# The value should be what the vendor currently ships out the door with their
	1531	# machine or put another way, the most popular os provided with the machine.
	1532
	1533	# Note that if you're going to try to match "-MANUFACTURER" here (say,
	1534	# "-sun"), then you have to tell the case statement up towards the top
	1535	# that MANUFACTURER isn't an operating system. Otherwise, code above
	1536	# will signal an error saying that MANUFACTURER isn't an operating
	1537	# system, and we'll never get to this point.
	1538
	1539	case $basic_machine in
	1540	score-*)
	1541	os=-elf
	1542	;;
	1543	spu-*)
	1544	os=-elf
	1545	;;
	1546	*-acorn)
	1547	os=-riscix1.2
	1548	;;
	1549	arm*-rebel)
	1550	os=-linux
	1551	;;
	1552	arm*-semi)
	1553	os=-aout
	1554	;;
	1555	c4x-* \| tic4x-*)
	1556	os=-coff
	1557	;;
	1558	c8051-*)
	1559	os=-elf
	1560	;;
	1561	hexagon-*)
	1562	os=-elf
	1563	;;
	1564	tic54x-*)
	1565	os=-coff
	1566	;;
	1567	tic55x-*)
	1568	os=-coff
	1569	;;
	1570	tic6x-*)
	1571	os=-coff
	1572	;;
	1573	# This must come before the *-dec entry.
	1574	pdp10-*)
	1575	os=-tops20
	1576	;;
	1577	pdp11-*)
	1578	os=-none
	1579	;;
	1580	-dec \| vax-)
	1581	os=-ultrix4.2
	1582	;;
	1583	m68*-apollo)
	1584	os=-domain
	1585	;;
	1586	i386-sun)
	1587	os=-sunos4.0.2
	1588	;;
	1589	m68000-sun)
	1590	os=-sunos3
	1591	;;
	1592	m68*-cisco)
	1593	os=-aout
	1594	;;
	1595	mep-*)
	1596	os=-elf
	1597	;;
	1598	mips*-cisco)
	1599	os=-elf
	1600	;;
	1601	mips-)
	1602	os=-elf
	1603	;;
	1604	or32-*)
	1605	os=-coff
	1606	;;
	1607	*-tti) # must be before sparc entry or we get the wrong os.
	1608	os=-sysv3
	1609	;;
	1610	sparc-* \| *-sun)
	1611	os=-sunos4.1.1
	1612	;;
	1613	*-be)
	1614	os=-beos
	1615	;;
	1616	*-haiku)
	1617	os=-haiku
	1618	;;
	1619	*-ibm)
	1620	os=-aix
	1621	;;
	1622	*-knuth)
	1623	os=-mmixware
	1624	;;
	1625	*-wec)
	1626	os=-proelf
	1627	;;
	1628	*-winbond)
	1629	os=-proelf
	1630	;;
	1631	*-oki)
	1632	os=-proelf
	1633	;;
	1634	*-hp)
	1635	os=-hpux
	1636	;;
	1637	*-hitachi)
	1638	os=-hiux
	1639	;;
	1640	i860-* \| -att \| -ncr \| -altos \| -motorola \| *-convergent)
	1641	os=-sysv
	1642	;;
	1643	*-cbm)
	1644	os=-amigaos
	1645	;;
	1646	*-dg)
	1647	os=-dgux
	1648	;;
	1649	*-dolphin)
	1650	os=-sysv3
	1651	;;
	1652	m68k-ccur)
	1653	os=-rtu
	1654	;;
	1655	m88k-omron*)
	1656	os=-luna
	1657	;;
	1658	*-next )
	1659	os=-nextstep
	1660	;;
	1661	*-sequent)
	1662	os=-ptx
	1663	;;
	1664	*-crds)
	1665	os=-unos
	1666	;;
	1667	*-ns)
	1668	os=-genix
	1669	;;
	1670	i370-*)
	1671	os=-mvs
	1672	;;
	1673	*-next)
	1674	os=-nextstep3
	1675	;;
	1676	*-gould)
	1677	os=-sysv
	1678	;;
	1679	*-highlevel)
	1680	os=-bsd
	1681	;;
	1682	*-encore)
	1683	os=-bsd
	1684	;;
	1685	*-sgi)
	1686	os=-irix
	1687	;;
	1688	*-siemens)
	1689	os=-sysv4
	1690	;;
	1691	*-masscomp)
	1692	os=-rtu
	1693	;;
	1694	f30[01]-fujitsu \| f700-fujitsu)
	1695	os=-uxpv
	1696	;;
	1697	*-rom68k)
	1698	os=-coff
	1699	;;
	1700	-bug)
	1701	os=-coff
	1702	;;
	1703	*-apple)
	1704	os=-macos
	1705	;;
	1706	-atari)
	1707	os=-mint
	1708	;;
	1709	*)
	1710	os=-none
	1711	;;
	1712	esac
	1713	fi
	1714
	1715	# Here we handle the case where we know the os, and the CPU type, but not the
	1716	# manufacturer. We pick the logical manufacturer.
	1717	vendor=unknown
	1718	case $basic_machine in
	1719	*-unknown)
	1720	case $os in
	1721	-riscix*)
	1722	vendor=acorn
	1723	;;
	1724	-sunos*)
	1725	vendor=sun
	1726	;;
	1727	-cnk\|-aix)
	1728	vendor=ibm
	1729	;;
	1730	-beos*)
	1731	vendor=be
	1732	;;
	1733	-hpux*)
	1734	vendor=hp
	1735	;;
	1736	-mpeix*)
	1737	vendor=hp
	1738	;;
	1739	-hiux*)
	1740	vendor=hitachi
	1741	;;
	1742	-unos*)
	1743	vendor=crds
	1744	;;
	1745	-dgux*)
	1746	vendor=dg
	1747	;;
	1748	-luna*)
	1749	vendor=omron
	1750	;;
	1751	-genix*)
	1752	vendor=ns
	1753	;;
	1754	-mvs* \| -opened*)
	1755	vendor=ibm
	1756	;;
	1757	-os400*)
	1758	vendor=ibm
	1759	;;
	1760	-ptx*)
	1761	vendor=sequent
	1762	;;
	1763	-tpf*)
	1764	vendor=ibm
	1765	;;
	1766	-vxsim* \| -vxworks* \| -windiss*)
	1767	vendor=wrs
	1768	;;
	1769	-aux*)
	1770	vendor=apple
	1771	;;
	1772	-hms*)
	1773	vendor=hitachi
	1774	;;
	1775	-mpw* \| -macos*)
	1776	vendor=apple
	1777	;;
	1778	-mint \| -mint[0-9] \| -MiNT \| -MiNT[0-9])
	1779	vendor=atari
	1780	;;
	1781	-vos*)
	1782	vendor=stratus
	1783	;;
	1784	esac
	1785	basic_machine=`echo $basic_machine \| sed "s/unknown/$vendor/"`
	1786	;;
	1787	esac
	1788
	1789	echo $basic_machine$os
	1790	exit
	1791
	1792	# Local variables:
	1793	# eval: (add-hook 'write-file-hooks 'time-stamp)
	1794	# time-stamp-start: "timestamp='"
	1795	# time-stamp-format: "%:y-%02m-%02d"
	1796	# time-stamp-end: "'"
	1797	# End:

+1130

-830

configure less more

0	0	#! /bin/sh
1	1	# Guess values for system-dependent variables and create Makefiles.
2		# Generated by GNU Autoconf 2.68 for cppad 20140000.3.
	2	# Generated by GNU Autoconf 2.69 for cppad 20150000.0.
3	3	#
4	4	# Report bugs to <cppad@list.coin-or.org>.
5	5	#
6	6	#
7		# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
8		# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
9		# Foundation, Inc.
	7	# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
10	8	#
11	9	#
12	10	# This configure script is free software; the Free Software Foundation

135	133	# CDPATH.
136	134	(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
137	135
	136	# Use a proper internal environment variable to ensure we don't fall
	137	# into an infinite loop, continuously re-executing ourselves.
	138	if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
	139	_as_can_reexec=no; export _as_can_reexec;
	140	# We cannot yet assume a decent shell, so we have to provide a
	141	# neutralization value for shells without unset; and this also
	142	# works around shells that cannot unset nonexistent variables.
	143	# Preserve -v and -x to the replacement shell.
	144	BASH_ENV=/dev/null
	145	ENV=/dev/null
	146	(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
	147	case $- in # ((((
	148	vx* \| xv* ) as_opts=-vx ;;
	149	v ) as_opts=-v ;;
	150	x ) as_opts=-x ;;
	151	* ) as_opts= ;;
	152	esac
	153	exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
	154	# Admittedly, this is quite paranoid, since all the known shells bail
	155	# out after a failed `exec'.
	156	$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
	157	as_fn_exit 255
	158	fi
	159	# We don't want this to propagate to other subprocesses.
	160	{ _as_can_reexec=; unset _as_can_reexec;}
138	161	if test "x$CONFIG_SHELL" = x; then
139	162	as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
140	163	emulate sh

168	191	else
169	192	exitcode=1; echo positional parameters were not saved.
170	193	fi
171		test x\$exitcode = x0 \|\| exit 1"
	194	test x\$exitcode = x0 \|\| exit 1
	195	test -x / \|\| exit 1"
172	196	as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
173	197	as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
174	198	eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&

213	237
214	238
215	239	if test "x$CONFIG_SHELL" != x; then :
216		# We cannot yet assume a decent shell, so we have to provide a
217		# neutralization value for shells without unset; and this also
218		# works around shells that cannot unset nonexistent variables.
219		# Preserve -v and -x to the replacement shell.
220		BASH_ENV=/dev/null
221		ENV=/dev/null
222		(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
223		export CONFIG_SHELL
224		case $- in # ((((
225		vx* \| xv* ) as_opts=-vx ;;
226		v ) as_opts=-v ;;
227		x ) as_opts=-x ;;
228		* ) as_opts= ;;
229		esac
230		exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"}
	240	export CONFIG_SHELL
	241	# We cannot yet assume a decent shell, so we have to provide a
	242	# neutralization value for shells without unset; and this also
	243	# works around shells that cannot unset nonexistent variables.
	244	# Preserve -v and -x to the replacement shell.
	245	BASH_ENV=/dev/null
	246	ENV=/dev/null
	247	(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
	248	case $- in # ((((
	249	vx* \| xv* ) as_opts=-vx ;;
	250	v ) as_opts=-v ;;
	251	x ) as_opts=-x ;;
	252	* ) as_opts= ;;
	253	esac
	254	exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
	255	# Admittedly, this is quite paranoid, since all the known shells bail
	256	# out after a failed `exec'.
	257	$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
	258	exit 255
231	259	fi
232	260
233	261	if test x$as_have_required = xno; then :

330	358
331	359
332	360	} # as_fn_mkdir_p
	361
	362	# as_fn_executable_p FILE
	363	# -----------------------
	364	# Test if FILE is an executable regular file.
	365	as_fn_executable_p ()
	366	{
	367	test -f "$1" && test -x "$1"
	368	} # as_fn_executable_p
333	369	# as_fn_append VAR VALUE
334	370	# ----------------------
335	371	# Append the text in VALUE to the end of the definition contained in VAR. Take

451	487	chmod +x "$as_me.lineno" \|\|
452	488	{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
453	489
	490	# If we had to re-execute with $CONFIG_SHELL, we're ensured to have
	491	# already done that, so ensure we don't try to do so again and fall
	492	# in an infinite loop. This has already happened in practice.
	493	_as_can_reexec=no; export _as_can_reexec
454	494	# Don't try to exec as it changes $[0], causing all sort of problems
455	495	# (the dirname of $[0] is not the place where we might find the
456	496	# original and so on. Autoconf is especially sensitive to this).

485	525	# ... but there are two gotchas:
486	526	# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
487	527	# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
488		# In both cases, we have to default to `cp -p'.
	528	# In both cases, we have to default to `cp -pR'.
489	529	ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe \|\|
490		as_ln_s='cp -p'
	530	as_ln_s='cp -pR'
491	531	elif ln conf$$.file conf$$ 2>/dev/null; then
492	532	as_ln_s=ln
493	533	else
494		as_ln_s='cp -p'
	534	as_ln_s='cp -pR'
495	535	fi
496	536	else
497		as_ln_s='cp -p'
	537	as_ln_s='cp -pR'
498	538	fi
499	539	rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
500	540	rmdir conf$$.dir 2>/dev/null

506	546	as_mkdir_p=false
507	547	fi
508	548
509		if test -x / >/dev/null 2>&1; then
510		as_test_x='test -x'
511		else
512		if ls -dL / >/dev/null 2>&1; then
513		as_ls_L_option=L
514		else
515		as_ls_L_option=
516		fi
517		as_test_x='
518		eval sh -c '\''
519		if test -d "$1"; then
520		test -d "$1/.";
521		else
522		case $1 in #(
523		-*)set "./$1";;
524		esac;
525		case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
526		???[sx]):;;)false;;esac;fi
527		'\'' sh
528		'
529		fi
530		as_executable_p=$as_test_x
	549	as_test_x='test -x'
	550	as_executable_p=as_fn_executable_p
531	551
532	552	# Sed expression to map a string onto a valid CPP name.
533	553	as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

559	579	# Identity of this package.
560	580	PACKAGE_NAME='cppad'
561	581	PACKAGE_TARNAME='cppad'
562		PACKAGE_VERSION='20140000.3'
563		PACKAGE_STRING='cppad 20140000.3'
	582	PACKAGE_VERSION='20150000.0'
	583	PACKAGE_STRING='cppad 20150000.0'
564	584	PACKAGE_BUGREPORT='cppad@list.coin-or.org'
565	585	PACKAGE_URL=''
566	586

628	648	ABS_TOP_SRCDIR
629	649	ABS_TOP_BUILDDIR
630	650	FCLIBS
	651	host_os
	652	host_vendor
	653	host_cpu
	654	host
	655	build_os
	656	build_vendor
	657	build_cpu
	658	build
631	659	ac_ct_FC
632	660	FCFLAGS
633	661	FC

675	703	INSTALL_PROGRAM
676	704	cppad_has_gettimeofday
677	705	cppad_cppadvector
678		cppad_size_t_same_unsigned_int
	706	cppad_size_t_not_unsigned_int
679	707	EGREP
680	708	GREP
681	709	CPP
682		OBJEXT
683		EXEEXT
684		ac_ct_CC
685		CPPFLAGS
686		LDFLAGS
687		CFLAGS
688		CC
	710	cppad_compiler_has_erf
	711	cppad_has_cstdint_8_to_64
	712	cppad_has_rvalue
689	713	cppad_has_nullptr
	714	cppad_has_colpack
690	715	cppad_tape_id_type
691	716	TAPE_ID_TYPE
692	717	cppad_tape_addr_type

731	756	CppAD_DOCUMENTATION_TRUE
732	757	CppAD_HAVE_AR_FALSE
733	758	CppAD_HAVE_AR_TRUE
734		have_ar
	759	OBJEXT
	760	EXEEXT
	761	ac_ct_CC
	762	CPPFLAGS
	763	LDFLAGS
	764	CFLAGS
	765	CC
	766	ac_ct_AR
	767	AR
735	768	CppAD_PKG_CONFIG_FALSE
736	769	CppAD_PKG_CONFIG_TRUE
737	770	have_pkg_config

804	837	ac_precious_vars='build_alias
805	838	host_alias
806	839	target_alias
	840	CC
	841	CFLAGS
	842	LDFLAGS
	843	LIBS
	844	CPPFLAGS
807	845	POSTFIX_DIR
808	846	ADOLC_DIR
809	847	EIGEN_DIR

816	854	MAX_NUM_THREADS
817	855	TAPE_ADDR_TYPE
818	856	TAPE_ID_TYPE
819		CC
820		CFLAGS
821		LDFLAGS
822		LIBS
823		CPPFLAGS
824	857	CPP
825	858	CXX
826	859	CXXFLAGS

1282	1315	if test "x$host_alias" != x; then
1283	1316	if test "x$build_alias" = x; then
1284	1317	cross_compiling=maybe
1285		$as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
1286		If a cross compiler is detected then cross compile mode will be used" >&2
1287	1318	elif test "x$build_alias" != "x$host_alias"; then
1288	1319	cross_compiling=yes
1289	1320	fi

1369	1400	# Omit some internal or obsolete options to make the list less imposing.
1370	1401	# This message is too long to be a string in the A/UX 3.1 sh.
1371	1402	cat <<_ACEOF
1372		\`configure' configures cppad 20140000.3 to adapt to many kinds of systems.
	1403	\`configure' configures cppad 20150000.0 to adapt to many kinds of systems.
1373	1404
1374	1405	Usage: $0 [OPTION]... [VAR=VALUE]...
1375	1406

1430	1461	--program-prefix=PREFIX prepend PREFIX to installed program names
1431	1462	--program-suffix=SUFFIX append SUFFIX to installed program names
1432	1463	--program-transform-name=PROGRAM run sed PROGRAM on installed program names
	1464
	1465	System types:
	1466	--build=BUILD configure for building on BUILD [guessed]
	1467	--host=HOST cross-compile to build programs to run on HOST [BUILD]
1433	1468	_ACEOF
1434	1469	fi
1435	1470
1436	1471	if test -n "$ac_init_help"; then
1437	1472	case $ac_init_help in
1438		short \| recursive ) echo "Configuration of cppad 20140000.3:";;
	1473	short \| recursive ) echo "Configuration of cppad 20150000.0:";;
1439	1474	esac
1440	1475	cat <<\_ACEOF
1441	1476

1443	1478	--disable-option-checking ignore unrecognized --enable/--with options
1444	1479	--disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
1445	1480	--enable-FEATURE[=ARG] include FEATURE [ARG=yes]
1446		--enable-silent-rules less verbose build output (undo: `make V=1')
1447		--disable-silent-rules verbose build output (undo: `make V=0')
1448		--enable-maintainer-mode enable make rules and dependencies not useful
1449		(and sometimes confusing) to the casual installer
1450		--disable-dependency-tracking speeds up one-time build
1451		--enable-dependency-tracking do not reject slow dependency extractors
	1481	--enable-silent-rules less verbose build output (undo: "make V=1")
	1482	--disable-silent-rules verbose build output (undo: "make V=0")
	1483	--enable-maintainer-mode
	1484	enable make rules and dependencies not useful (and
	1485	sometimes confusing) to the casual installer
	1486	--enable-dependency-tracking
	1487	do not reject slow dependency extractors
	1488	--disable-dependency-tracking
	1489	speeds up one-time build
1452	1490
1453	1491	Optional Packages:
1454	1492	--with-PACKAGE[=ARG] use PACKAGE [ARG=yes]

1470	1508	type
1471	1509
1472	1510	Some influential environment variables:
	1511	CC C compiler command
	1512	CFLAGS C compiler flags
	1513	LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
	1514	nonstandard directory <lib dir>
	1515	LIBS libraries to pass to the linker, e.g. -l<library>
	1516	CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
	1517	you have headers in a nonstandard directory <include dir>
1473	1518	POSTFIX_DIR postfix directory for CppAD installation
1474	1519	ADOLC_DIR value of configure prefix directory during Adolc install
1475	1520	EIGEN_DIR value of configure prefix directory during Eigen install

1486	1531	type used for addresses in AD tapes
1487	1532	TAPE_ID_TYPE
1488	1533	type used for addresses in AD tapes
1489		CC C compiler command
1490		CFLAGS C compiler flags
1491		LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
1492		nonstandard directory <lib dir>
1493		LIBS libraries to pass to the linker, e.g. -l<library>
1494		CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1495		you have headers in a nonstandard directory <include dir>
1496	1534	CPP C preprocessor
1497	1535	CXX C++ compiler command
1498	1536	CXXFLAGS C++ compiler flags

1565	1603	test -n "$ac_init_help" && exit $ac_status
1566	1604	if $ac_init_version; then
1567	1605	cat <<\_ACEOF
1568		cppad configure 20140000.3
1569		generated by GNU Autoconf 2.68
1570
1571		Copyright (C) 2010 Free Software Foundation, Inc.
	1606	cppad configure 20150000.0
	1607	generated by GNU Autoconf 2.69
	1608
	1609	Copyright (C) 2012 Free Software Foundation, Inc.
1572	1610	This configure script is free software; the Free Software Foundation
1573	1611	gives unlimited permission to copy, distribute and modify it.
1574	1612	_ACEOF

1676	1714	main ()
1677	1715	{
1678	1716	static int test_array [1 - 2 * !(($2) >= 0)];
1679		test_array [0] = 0
	1717	test_array [0] = 0;
	1718	return test_array [0];
1680	1719
1681	1720	;
1682	1721	return 0;

1692	1731	main ()
1693	1732	{
1694	1733	static int test_array [1 - 2 * !(($2) <= $ac_mid)];
1695		test_array [0] = 0
	1734	test_array [0] = 0;
	1735	return test_array [0];
1696	1736
1697	1737	;
1698	1738	return 0;

1718	1758	main ()
1719	1759	{
1720	1760	static int test_array [1 - 2 * !(($2) < 0)];
1721		test_array [0] = 0
	1761	test_array [0] = 0;
	1762	return test_array [0];
1722	1763
1723	1764	;
1724	1765	return 0;

1734	1775	main ()
1735	1776	{
1736	1777	static int test_array [1 - 2 * !(($2) >= $ac_mid)];
1737		test_array [0] = 0
	1778	test_array [0] = 0;
	1779	return test_array [0];
1738	1780
1739	1781	;
1740	1782	return 0;

1768	1810	main ()
1769	1811	{
1770	1812	static int test_array [1 - 2 * !(($2) <= $ac_mid)];
1771		test_array [0] = 0
	1813	test_array [0] = 0;
	1814	return test_array [0];
1772	1815
1773	1816	;
1774	1817	return 0;

1932	1975	test ! -s conftest.err
1933	1976	} && test -s conftest$ac_exeext && {
1934	1977	test "$cross_compiling" = yes \|\|
1935		$as_test_x conftest$ac_exeext
	1978	test -x conftest$ac_exeext
1936	1979	}; then :
1937	1980	ac_retval=0
1938	1981	else

2121	2164	test ! -s conftest.err
2122	2165	} && test -s conftest$ac_exeext && {
2123	2166	test "$cross_compiling" = yes \|\|
2124		$as_test_x conftest$ac_exeext
	2167	test -x conftest$ac_exeext
2125	2168	}; then :
2126	2169	ac_retval=0
2127	2170	else

2167	2210	test ! -s conftest.err
2168	2211	} && test -s conftest$ac_exeext && {
2169	2212	test "$cross_compiling" = yes \|\|
2170		$as_test_x conftest$ac_exeext
	2213	test -x conftest$ac_exeext
2171	2214	}; then :
2172	2215	ac_retval=0
2173	2216	else

2189	2232	This file contains any messages produced by compilers while
2190	2233	running configure, to aid debugging if configure makes a mistake.
2191	2234
2192		It was created by cppad $as_me 20140000.3, which was
2193		generated by GNU Autoconf 2.68. Invocation command line was
	2235	It was created by cppad $as_me 20150000.0, which was
	2236	generated by GNU Autoconf 2.69. Invocation command line was
2194	2237
2195	2238	$ $0 $@
2196	2239

2542	2585	enableval=$enable_silent_rules;
2543	2586	fi
2544	2587
2545		case $enable_silent_rules in
2546		yes) AM_DEFAULT_VERBOSITY=0;;
2547		no) AM_DEFAULT_VERBOSITY=1;;
2548		*) AM_DEFAULT_VERBOSITY=1;;
	2588	case $enable_silent_rules in # (((
	2589	yes) AM_DEFAULT_VERBOSITY=0;;
	2590	no) AM_DEFAULT_VERBOSITY=1;;
	2591	*) AM_DEFAULT_VERBOSITY=0;;
2549	2592	esac
2550	2593	am_make=${MAKE-make}
2551	2594	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5

2620	2663	IFS=$as_save_IFS
2621	2664	test -z "$as_dir" && as_dir=.
2622	2665	for ac_exec_ext in '' $ac_executable_extensions; do
2623		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	2666	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2624	2667	ac_cv_prog_have_pkg_config="yes"
2625	2668	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2626	2669	break 2

2651	2694	fi
2652	2695
2653	2696
2654		# Extract the first word of "ar", so it can be a program name with args.
2655		set dummy ar; ac_word=$2
2656		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2657		$as_echo_n "checking for $ac_word... " >&6; }
2658		if ${ac_cv_prog_have_ar+:} false; then :
2659		$as_echo_n "(cached) " >&6
2660		else
2661		if test -n "$have_ar"; then
2662		ac_cv_prog_have_ar="$have_ar" # Let the user override the test.
2663		else
2664		as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2665		for as_dir in $PATH
2666		do
2667		IFS=$as_save_IFS
2668		test -z "$as_dir" && as_dir=.
2669		for ac_exec_ext in '' $ac_executable_extensions; do
2670		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2671		ac_cv_prog_have_ar="yes"
2672		$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2673		break 2
2674		fi
2675		done
2676		done
2677		IFS=$as_save_IFS
2678
2679		test -z "$ac_cv_prog_have_ar" && ac_cv_prog_have_ar="no"
2680		fi
2681		fi
2682		have_ar=$ac_cv_prog_have_ar
2683		if test -n "$have_ar"; then
2684		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_ar" >&5
2685		$as_echo "$have_ar" >&6; }
2686		else
2687		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2688		$as_echo "no" >&6; }
2689		fi
2690
2691
2692		if test "$have_ar" = "yes"; then
2693		CppAD_HAVE_AR_TRUE=
2694		CppAD_HAVE_AR_FALSE='#'
2695		else
2696		CppAD_HAVE_AR_TRUE='#'
2697		CppAD_HAVE_AR_FALSE=
2698		fi
2699
2700		if test "$have_ar" = "no"; then
2701		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot build any libraries because ar is missing, speed/* is not used
2702		" >&5
2703		$as_echo "$as_me: WARNING: cannot build any libraries because ar is missing, speed/* is not used
2704		" >&2;}
2705		fi
2706
2707		{ $as_echo "$as_me:${as_lineno-$LINENO}: * Check command line arguments that are longer used **" >&5
2708		$as_echo "$as_me: * Check command line arguments that are longer used **" >&6;}
2709
2710		if test "$CPP_ERROR_WARN" != "" ; then
2711		as_fn_error $? "The CPP_ERROR_WARN configure option is now CXX_FLAGS" "$LINENO" 5
2712		fi
2713
2714		# Check whether --with-SpeedExample was given.
2715		if test "${with_SpeedExample+set}" = set; then :
2716		withval=$with_SpeedExample; SpeedExample="yes"
2717		else
2718		SpeedExample="no"
2719
2720		fi
2721
2722		if test "$SpeedExample" = "yes" ; then
2723		as_fn_error $? "--with-SpeedExample not necessary, see install instructions." "$LINENO" 5
2724		fi
2725
2726		# Check whether --with-profiling was given.
2727		if test "${with_profiling+set}" = set; then :
2728		withval=$with_profiling; profiling="yes"
2729		else
2730		profiling="no"
2731
2732		fi
2733
2734		if test "$profiling" = "yes" ; then
2735		as_fn_error $? "--with-profiling not necessary, see install instructions." "$LINENO" 5
2736		fi
2737
2738		# Check whether --with-Speed was given.
2739		if test "${with_Speed+set}" = set; then :
2740		withval=$with_Speed; Speed="yes"
2741		else
2742		Speed="no"
2743
2744		fi
2745
2746		if test "$Speed" = "yes" ; then
2747		as_fn_error $? "--with-Speed not necessary, see install instructions." "$LINENO" 5
2748		fi
2749
2750		# Check whether --with-Introduction was given.
2751		if test "${with_Introduction+set}" = set; then :
2752		withval=$with_Introduction; Introduction="yes"
2753		else
2754		Introduction="no"
2755
2756		fi
2757
2758		if test "$Introduction" = "yes" ; then
2759		as_fn_error $? "--with-Introduction not necessary, see install instructions." "$LINENO" 5
2760		fi
2761
2762		# Check whether --with-Example was given.
2763		if test "${with_Example+set}" = set; then :
2764		withval=$with_Example; Example="yes"
2765		else
2766		Example="no"
2767
2768		fi
2769
2770		if test "$Example" = "yes" ; then
2771		as_fn_error $? "--with-Example not necessary, see install instructions." "$LINENO" 5
2772		fi
2773
2774		# Check whether --with-TestMore was given.
2775		if test "${with_TestMore+set}" = set; then :
2776		withval=$with_TestMore; TestMore="yes"
2777		else
2778		TestMore="no"
2779
2780		fi
2781
2782		if test "$TestMore" = "yes" ; then
2783		as_fn_error $? "--with-TestMore not necessary, see install instructions." "$LINENO" 5
2784		fi
2785
2786		# Check whether --with-PrintFor was given.
2787		if test "${with_PrintFor+set}" = set; then :
2788		withval=$with_PrintFor; PrintFor="yes"
2789		else
2790		PrintFor="no"
2791
2792		fi
2793
2794		if test "$PrintFor" = "yes" ; then
2795		as_fn_error $? "--with-PrintFor not necessary, see install instructions." "$LINENO" 5
2796		fi
2797		{ $as_echo "$as_me:${as_lineno-$LINENO}: **** Check command line arguments that are used *********" >&5
2798		$as_echo "$as_me: **** Check command line arguments that are used *********" >&6;}
2799		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --prefix" >&5
2800		$as_echo_n "checking --prefix... " >&6; }
2801		if test "$prefix" = "NONE" ; then
2802		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOME" >&5
2803		$as_echo "$HOME" >&6; }
2804		else
2805		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $prefix" >&5
2806		$as_echo "$prefix" >&6; }
2807		fi
2808
2809		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-Documentation" >&5
2810		$as_echo_n "checking --with-Documentation... " >&6; }
2811
2812		# Check whether --with-Documentation was given.
2813		if test "${with_Documentation+set}" = set; then :
2814		withval=$with_Documentation; Documentation="yes"
2815		else
2816		Documentation="no"
2817
2818		fi
2819
2820		if test "$Documentation" = "yes"; then
2821		CppAD_DOCUMENTATION_TRUE=
2822		CppAD_DOCUMENTATION_FALSE='#'
2823		else
2824		CppAD_DOCUMENTATION_TRUE='#'
2825		CppAD_DOCUMENTATION_FALSE=
2826		fi
2827
2828		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $Documentation" >&5
2829		$as_echo "$Documentation" >&6; }
2830
2831		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-stdvector" >&5
2832		$as_echo_n "checking --with-stdvector... " >&6; }
2833
2834		# Check whether --with-stdvector was given.
2835		if test "${with_stdvector+set}" = set; then :
2836		withval=$with_stdvector; stdvector="yes"
2837		else
2838		stdvector="no"
2839
2840		fi
2841
2842		if test "$stdvector" = "yes" ; then
2843		cppad_stdvector=1
2844
2845		else
2846		cppad_stdvector=0
2847
2848		fi
2849		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $stdvector" >&5
2850		$as_echo "$stdvector" >&6; }
2851
2852		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-boostvector" >&5
2853		$as_echo_n "checking --with-boostvector... " >&6; }
2854
2855		# Check whether --with-boostvector was given.
2856		if test "${with_boostvector+set}" = set; then :
2857		withval=$with_boostvector; boostvector="yes"
2858		else
2859		boostvector="no"
2860
2861		fi
2862
2863		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $boostvector" >&5
2864		$as_echo "$boostvector" >&6; }
2865		if test "$boostvector" = "yes" ; then
2866		if test "$stdvector" != "no" ; then
2867		as_fn_error $? "cannot --with both stdvector and boostvector" "$LINENO" 5
2868		fi
2869		cppad_boostvector=1
2870
2871		else
2872		cppad_boostvector=0
2873
2874		fi
2875
2876		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-eigenvector" >&5
2877		$as_echo_n "checking --with-eigenvector... " >&6; }
2878
2879		# Check whether --with-eigenvector was given.
2880		if test "${with_eigenvector+set}" = set; then :
2881		withval=$with_eigenvector; eigenvector="yes"
2882		else
2883		eigenvector="no"
2884
2885		fi
2886
2887		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $eigenvector" >&5
2888		$as_echo "$eigenvector" >&6; }
2889		if test "$eigenvector" = "yes" ; then
2890		if test "$stdvector" != "no" ; then
2891		as_fn_error $? "cannot --with both stdvector and eigenvector" "$LINENO" 5
2892		fi
2893		if test "$boostvector" != "no" ; then
2894		as_fn_error $? "cannot --with both boostvector and eigenvector" "$LINENO" 5
2895		fi
2896		cppad_eigenvector=1
2897
2898		else
2899		cppad_eigenvector=0
2900
2901		fi
2902
2903		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_set" >&5
2904		$as_echo_n "checking --with-sparse_set... " >&6; }
2905
2906		# Check whether --with-sparse_set was given.
2907		if test "${with_sparse_set+set}" = set; then :
2908		withval=$with_sparse_set; sparse_set="yes"
2909		else
2910		sparse_set="no"
2911
2912		fi
2913
2914		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_set" >&5
2915		$as_echo "$sparse_set" >&6; }
2916		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_list" >&5
2917		$as_echo_n "checking --with-sparse_list... " >&6; }
2918
2919		# Check whether --with-sparse_list was given.
2920		if test "${with_sparse_list+set}" = set; then :
2921		withval=$with_sparse_list; sparse_list="yes"
2922		else
2923		sparse_list="no"
2924
2925		fi
2926
2927		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_list" >&5
2928		$as_echo "$sparse_list" >&6; }
2929		if test "$sparse_set" = "yes" ; then
2930		if test "$sparse_list" == "yes" ; then
2931		as_fn_error $? "cannot --with both sparse_set and sparse_list" "$LINENO" 5
2932		fi
2933		cppad_internal_sparse_set=sparse_set
2934
2935		else
2936		cppad_internal_sparse_set=sparse_list
2937
2938		fi
2939
2940
2941		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-implicit_ctor" >&5
2942		$as_echo_n "checking --with-implicit_ctor... " >&6; }
2943
2944		# Check whether --with-implicit_ctor was given.
2945		if test "${with_implicit_ctor+set}" = set; then :
2946		withval=$with_implicit_ctor; implicit_ctor="yes"
2947		else
2948		implicit_ctor="no"
2949
2950		fi
2951
2952		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $implicit_ctor" >&5
2953		$as_echo "$implicit_ctor" >&6; }
2954		if test "$implicit_ctor" = "yes" ; then
2955		cppad_implicit_ctor_from_any_type="1"
2956
2957		else
2958		cppad_implicit_ctor_from_any_type="0"
2959
2960		fi
2961
2962		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking POSTFIX_DIR" >&5
2963		$as_echo_n "checking POSTFIX_DIR... " >&6; }
2964
2965		if test "$POSTFIX_DIR" != ""; then
2966		CppAD_POSTFIX_TRUE=
2967		CppAD_POSTFIX_FALSE='#'
2968		else
2969		CppAD_POSTFIX_TRUE='#'
2970		CppAD_POSTFIX_FALSE=
2971		fi
2972
2973		if test "$POSTFIX_DIR" != "" ; then
2974		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $POSTFIX_DIR" >&5
2975		$as_echo "$POSTFIX_DIR" >&6; }
2976		else
2977		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2978		$as_echo "no" >&6; }
2979		fi
2980
2981		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking ADOLC_DIR" >&5
2982		$as_echo_n "checking ADOLC_DIR... " >&6; }
2983
2984		if test "$ADOLC_DIR" != ""; then
2985		CppAD_ADOLC_TRUE=
2986		CppAD_ADOLC_FALSE='#'
2987		else
2988		CppAD_ADOLC_TRUE='#'
2989		CppAD_ADOLC_FALSE=
2990		fi
2991
2992		if test "$ADOLC_DIR" != "" ; then
2993		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ADOLC_DIR" >&5
2994		$as_echo "$ADOLC_DIR" >&6; }
2995		if test "$have_ar" = "no"; then
2996		as_fn_error $? "ar is missing and ADOLC_DIR is present" "$LINENO" 5
2997		fi
2998		else
2999		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3000		$as_echo "no" >&6; }
3001		fi
3002
3003		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking EIGEN_DIR" >&5
3004		$as_echo_n "checking EIGEN_DIR... " >&6; }
3005
3006		if test "$EIGEN_DIR" != ""; then
3007		CppAD_EIGEN_DIR_TRUE=
3008		CppAD_EIGEN_DIR_FALSE='#'
3009		else
3010		CppAD_EIGEN_DIR_TRUE='#'
3011		CppAD_EIGEN_DIR_FALSE=
3012		fi
3013
3014		if test "$EIGEN_DIR" != "" ; then
3015		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $EIGEN_DIR" >&5
3016		$as_echo "$EIGEN_DIR" >&6; }
3017		EIGEN_INCLUDE=-I$EIGEN_DIR/include
3018
3019		else
3020		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3021		$as_echo "no" >&6; }
3022
3023		fi
3024
3025		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking FADBAD_DIR" >&5
3026		$as_echo_n "checking FADBAD_DIR... " >&6; }
3027
3028		if test "$FADBAD_DIR" != ""; then
3029		CppAD_FADBAD_TRUE=
3030		CppAD_FADBAD_FALSE='#'
3031		else
3032		CppAD_FADBAD_TRUE='#'
3033		CppAD_FADBAD_FALSE=
3034		fi
3035
3036		if test "$FADBAD_DIR" != "" ; then
3037		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FADBAD_DIR" >&5
3038		$as_echo "$FADBAD_DIR" >&6; }
3039		if test "$have_ar" = "no"; then
3040		as_fn_error $? "ar is missing and FADBAD_DIR is present" "$LINENO" 5
3041		fi
3042		else
3043		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3044		$as_echo "no" >&6; }
3045		fi
3046
3047		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking SACADO_DIR" >&5
3048		$as_echo_n "checking SACADO_DIR... " >&6; }
3049
3050		if test "$SACADO_DIR" != ""; then
3051		CppAD_SACADO_TRUE=
3052		CppAD_SACADO_FALSE='#'
3053		else
3054		CppAD_SACADO_TRUE='#'
3055		CppAD_SACADO_FALSE=
3056		fi
3057
3058		if test "$SACADO_DIR" != "" ; then
3059		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SACADO_DIR" >&5
3060		$as_echo "$SACADO_DIR" >&6; }
3061		if test "$have_ar" = "no"; then
3062		as_fn_error $? "ar is missing and SACADO_DIR is present" "$LINENO" 5
3063		fi
3064		else
3065		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3066		$as_echo "no" >&6; }
3067		fi
3068
3069		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking IPOPT_DIR" >&5
3070		$as_echo_n "checking IPOPT_DIR... " >&6; }
3071
3072		if test "$IPOPT_DIR" != ""; then
3073		CppAD_IPOPT_TRUE=
3074		CppAD_IPOPT_FALSE='#'
3075		else
3076		CppAD_IPOPT_TRUE='#'
3077		CppAD_IPOPT_FALSE=
3078		fi
3079
3080		if test "$IPOPT_DIR" != "" ; then
3081		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $IPOPT_DIR" >&5
3082		$as_echo "$IPOPT_DIR" >&6; }
3083		if test "$have_ar" = "no"; then
3084		as_fn_error $? "ar is missing and IPOPT_DIR is present" "$LINENO" 5
3085		fi
3086		else
3087		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3088		$as_echo "no" >&6; }
3089		fi
3090
3091		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking BOOST_DIR" >&5
3092		$as_echo_n "checking BOOST_DIR... " >&6; }
3093
3094		if test "$BOOST_DIR" != ""; then
3095		CppAD_BOOST_DIR_TRUE=
3096		CppAD_BOOST_DIR_FALSE='#'
3097		else
3098		CppAD_BOOST_DIR_TRUE='#'
3099		CppAD_BOOST_DIR_FALSE=
3100		fi
3101
3102		if test "$BOOST_DIR" != "" ; then
3103		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOST_DIR" >&5
3104		$as_echo "$BOOST_DIR" >&6; }
3105		BOOST_INCLUDE=-I$BOOST_DIR/include
3106
3107		else
3108		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3109		$as_echo "no" >&6; }
3110
3111		fi
3112
3113		#
3114		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking CXX_FLAGS" >&5
3115		$as_echo_n "checking CXX_FLAGS... " >&6; }
3116
3117		# cxx_flags for fadbad and eigen
3118		if test "$CXX_FLAGS" != "" ; then
3119		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX_FLAGS" >&5
3120		$as_echo "$CXX_FLAGS" >&6; }
3121		cxx_flags_fadbad=`echo "$CXX_FLAGS" \| sed -e 's\|-Wshadow\|\|'`
3122		cxx_flags_eigen="$cxx_flags_fadbda -Wno-long-long"
3123		else
3124		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3125		$as_echo "no" >&6; }
3126		cxx_flags_fadbad=""
3127		cxx_flags_eigen=""
3128		fi
3129		CXX_FLAGS_FADBAD="$cxx_flags_fadbad"
3130
3131		CXX_FLAGS_EIGEN="$cxx_flags_eigen"
3132
3133
3134		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking OPENMP_FLAGS" >&5
3135		$as_echo_n "checking OPENMP_FLAGS... " >&6; }
3136
3137		if test "$OPENMP_FLAGS" != "" ; then
3138		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENMP_FLAGS" >&5
3139		$as_echo "$OPENMP_FLAGS" >&6; }
3140		else
3141		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3142		$as_echo "no" >&6; }
3143		fi
3144		if test "$OPENMP_FLAGS" != ""; then
3145		CppAD_OPENMP_TRUE=
3146		CppAD_OPENMP_FALSE='#'
3147		else
3148		CppAD_OPENMP_TRUE='#'
3149		CppAD_OPENMP_FALSE=
3150		fi
3151
3152
3153		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking MAX_NUM_THREADS" >&5
3154		$as_echo_n "checking MAX_NUM_THREADS... " >&6; }
3155
3156		if test "$MAX_NUM_THREADS" != "" ; then
3157		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAX_NUM_THREADS" >&5
3158		$as_echo "$MAX_NUM_THREADS" >&6; }
3159		if test "$MAX_NUM_THREADS" -lt "4" ; then
3160		as_fn_error $? " MAX_NUM_THREADS=$MAX_NUM_THREADS is less than 4
3161		" "$LINENO" 5
3162		fi
3163		max_num_threads="$MAX_NUM_THREADS"
3164		else
3165		max_num_threads="48"
3166		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using default value $max_num_threads" >&5
3167		$as_echo "no, using default value $max_num_threads" >&6; }
3168		fi
3169		cppad_max_num_threads=$max_num_threads
3170
3171
3172		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking TAPE_ADDR_TYPE" >&5
3173		$as_echo_n "checking TAPE_ADDR_TYPE... " >&6; }
3174
3175		if test "$TAPE_ADDR_TYPE" == "" ; then
3176		addr_t="unsigned int"
3177		else
3178		addr_t="$TAPE_ADDR_TYPE"
3179		fi
3180		cppad_tape_addr_type=$addr_t
3181
3182		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $addr_t" >&5
3183		$as_echo "$addr_t" >&6; }
3184		ok="no"
3185		if test "$addr_t" == "size_t" ; then
3186		ok="yes"
3187		fi
3188		if test "$addr_t" == "int" ; then
3189		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: TAPE_ADDR_TYPE=int is for CppAD developers (not users)
3190		" >&5
3191		$as_echo "$as_me: WARNING: TAPE_ADDR_TYPE=int is for CppAD developers (not users)
3192		" >&2;}
3193		ok="yes"
3194		fi
3195		if test "$addr_t" == "unsigned int" ; then
3196		ok="yes"
3197		fi
3198		if test "$addr_t" == "unsigned short int" ; then
3199		ok="yes"
3200		fi
3201		if test "$ok" == "no" ; then
3202		as_fn_error $? "$addr_t is not a valid choice for TAPE_ADDR_TYPE
3203		" "$LINENO" 5
3204		fi
3205
3206		{ $as_echo "$as_me:${as_lineno-$LINENO}: checking TAPE_ID_TYPE" >&5
3207		$as_echo_n "checking TAPE_ID_TYPE... " >&6; }
3208
3209		if test "$TAPE_ID_TYPE" == "" ; then
3210		tape_id_t="unsigned int"
3211		else
3212		tape_id_t="$TAPE_ID_TYPE"
3213		fi
3214		cppad_tape_id_type=$tape_id_t
3215
3216		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tape_id_t" >&5
3217		$as_echo "$tape_id_t" >&6; }
3218		ok="no"
3219		if test "$tape_id_t" == "size_t" ; then
3220		ok="yes"
3221		fi
3222		if test "$tape_id_t" == "int" ; then
3223		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: TAPE_ID_TYPE=int is for CppAD developers (not users)
3224		" >&5
3225		$as_echo "$as_me: WARNING: TAPE_ID_TYPE=int is for CppAD developers (not users)
3226		" >&2;}
3227		ok="yes"
3228		fi
3229		if test "$tape_id_t" == "unsigned int" ; then
3230		ok="yes"
3231		fi
3232		if test "$tape_id_t" == "unsigned short int" ; then
3233		ok="yes"
3234		fi
3235		if test "$ok" == "no" ; then
3236		as_fn_error $? "$tape_id_t is not a valid choice for TAPE_ID_TYPE
3237		" "$LINENO" 5
3238		fi
3239		{ $as_echo "$as_me:${as_lineno-$LINENO}: ******** End Checking Command Line arguments *************" >&5
3240		$as_echo "$as_me: ******** End Checking Command Line arguments *************" >&6;}
3241
3242		cppad_has_nullptr=0
3243
	2697	# expand $ac_aux_dir to an absolute path
	2698	am_aux_dir=`cd $ac_aux_dir && pwd`
3244	2699
3245	2700	ac_ext=c
3246	2701	ac_cpp='$CPP $CPPFLAGS'

3264	2719	IFS=$as_save_IFS
3265	2720	test -z "$as_dir" && as_dir=.
3266	2721	for ac_exec_ext in '' $ac_executable_extensions; do
3267		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	2722	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3268	2723	ac_cv_prog_CC="${ac_tool_prefix}gcc"
3269	2724	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3270	2725	break 2

3304	2759	IFS=$as_save_IFS
3305	2760	test -z "$as_dir" && as_dir=.
3306	2761	for ac_exec_ext in '' $ac_executable_extensions; do
3307		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	2762	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3308	2763	ac_cv_prog_ac_ct_CC="gcc"
3309	2764	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3310	2765	break 2

3357	2812	IFS=$as_save_IFS
3358	2813	test -z "$as_dir" && as_dir=.
3359	2814	for ac_exec_ext in '' $ac_executable_extensions; do
3360		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	2815	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3361	2816	ac_cv_prog_CC="${ac_tool_prefix}cc"
3362	2817	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3363	2818	break 2

3398	2853	IFS=$as_save_IFS
3399	2854	test -z "$as_dir" && as_dir=.
3400	2855	for ac_exec_ext in '' $ac_executable_extensions; do
3401		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	2856	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3402	2857	if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3403	2858	ac_prog_rejected=yes
3404	2859	continue

3456	2911	IFS=$as_save_IFS
3457	2912	test -z "$as_dir" && as_dir=.
3458	2913	for ac_exec_ext in '' $ac_executable_extensions; do
3459		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	2914	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3460	2915	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3461	2916	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3462	2917	break 2

3500	2955	IFS=$as_save_IFS
3501	2956	test -z "$as_dir" && as_dir=.
3502	2957	for ac_exec_ext in '' $ac_executable_extensions; do
3503		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	2958	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3504	2959	ac_cv_prog_ac_ct_CC="$ac_prog"
3505	2960	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3506	2961	break 2

3946	3401	/* end confdefs.h. */
3947	3402	#include <stdarg.h>
3948	3403	#include <stdio.h>
3949		#include <sys/types.h>
3950		#include <sys/stat.h>
	3404	struct stat;
3951	3405	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
3952	3406	struct buf { int x; };
3953	3407	FILE * (rcsopen) (struct buf , struct stat *, int);

4031	3485	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4032	3486	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4033	3487	ac_compiler_gnu=$ac_cv_c_compiler_gnu
	3488
	3489
	3490	if test -n "$ac_tool_prefix"; then
	3491	for ac_prog in ar lib "link -lib"
	3492	do
	3493	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
	3494	set dummy $ac_tool_prefix$ac_prog; ac_word=$2
	3495	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
	3496	$as_echo_n "checking for $ac_word... " >&6; }
	3497	if ${ac_cv_prog_AR+:} false; then :
	3498	$as_echo_n "(cached) " >&6
	3499	else
	3500	if test -n "$AR"; then
	3501	ac_cv_prog_AR="$AR" # Let the user override the test.
	3502	else
	3503	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
	3504	for as_dir in $PATH
	3505	do
	3506	IFS=$as_save_IFS
	3507	test -z "$as_dir" && as_dir=.
	3508	for ac_exec_ext in '' $ac_executable_extensions; do
	3509	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
	3510	ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
	3511	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
	3512	break 2
	3513	fi
	3514	done
	3515	done
	3516	IFS=$as_save_IFS
	3517
	3518	fi
	3519	fi
	3520	AR=$ac_cv_prog_AR
	3521	if test -n "$AR"; then
	3522	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
	3523	$as_echo "$AR" >&6; }
	3524	else
	3525	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	3526	$as_echo "no" >&6; }
	3527	fi
	3528
	3529
	3530	test -n "$AR" && break
	3531	done
	3532	fi
	3533	if test -z "$AR"; then
	3534	ac_ct_AR=$AR
	3535	for ac_prog in ar lib "link -lib"
	3536	do
	3537	# Extract the first word of "$ac_prog", so it can be a program name with args.
	3538	set dummy $ac_prog; ac_word=$2
	3539	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
	3540	$as_echo_n "checking for $ac_word... " >&6; }
	3541	if ${ac_cv_prog_ac_ct_AR+:} false; then :
	3542	$as_echo_n "(cached) " >&6
	3543	else
	3544	if test -n "$ac_ct_AR"; then
	3545	ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
	3546	else
	3547	as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
	3548	for as_dir in $PATH
	3549	do
	3550	IFS=$as_save_IFS
	3551	test -z "$as_dir" && as_dir=.
	3552	for ac_exec_ext in '' $ac_executable_extensions; do
	3553	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
	3554	ac_cv_prog_ac_ct_AR="$ac_prog"
	3555	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
	3556	break 2
	3557	fi
	3558	done
	3559	done
	3560	IFS=$as_save_IFS
	3561
	3562	fi
	3563	fi
	3564	ac_ct_AR=$ac_cv_prog_ac_ct_AR
	3565	if test -n "$ac_ct_AR"; then
	3566	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
	3567	$as_echo "$ac_ct_AR" >&6; }
	3568	else
	3569	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	3570	$as_echo "no" >&6; }
	3571	fi
	3572
	3573
	3574	test -n "$ac_ct_AR" && break
	3575	done
	3576
	3577	if test "x$ac_ct_AR" = x; then
	3578	AR="false"
	3579	else
	3580	case $cross_compiling:$ac_tool_warned in
	3581	yes:)
	3582	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
	3583	$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
	3584	ac_tool_warned=yes ;;
	3585	esac
	3586	AR=$ac_ct_AR
	3587	fi
	3588	fi
	3589
	3590	: ${AR=ar}
	3591
	3592	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the archiver ($AR) interface" >&5
	3593	$as_echo_n "checking the archiver ($AR) interface... " >&6; }
	3594	if ${am_cv_ar_interface+:} false; then :
	3595	$as_echo_n "(cached) " >&6
	3596	else
	3597	am_cv_ar_interface=ar
	3598	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
	3599	/* end confdefs.h. */
	3600	int some_variable = 0;
	3601	_ACEOF
	3602	if ac_fn_c_try_compile "$LINENO"; then :
	3603	am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&5'
	3604	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5
	3605	(eval $am_ar_try) 2>&5
	3606	ac_status=$?
	3607	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
	3608	test $ac_status = 0; }
	3609	if test "$ac_status" -eq 0; then
	3610	am_cv_ar_interface=ar
	3611	else
	3612	am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&5'
	3613	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5
	3614	(eval $am_ar_try) 2>&5
	3615	ac_status=$?
	3616	$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
	3617	test $ac_status = 0; }
	3618	if test "$ac_status" -eq 0; then
	3619	am_cv_ar_interface=lib
	3620	else
	3621	am_cv_ar_interface=unknown
	3622	fi
	3623	fi
	3624	rm -f conftest.lib libconftest.a
	3625
	3626	fi
	3627	rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
	3628
	3629	fi
	3630	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_ar_interface" >&5
	3631	$as_echo "$am_cv_ar_interface" >&6; }
	3632
	3633	case $am_cv_ar_interface in
	3634	ar)
	3635	;;
	3636	lib)
	3637	# Microsoft lib, so override with the ar-lib wrapper script.
	3638	# FIXME: It is wrong to rewrite AR.
	3639	# But if we don't then we get into trouble of one sort or another.
	3640	# A longer-term fix would be to have automake use am__AR in this case,
	3641	# and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something
	3642	# similar.
	3643	AR="$am_aux_dir/ar-lib $AR"
	3644	;;
	3645	unknown)
	3646	as_fn_error $? "could not determine $AR interface" "$LINENO" 5
	3647	;;
	3648	esac
	3649
	3650	if test "$AR" = "ar"; then
	3651	CppAD_HAVE_AR_TRUE=
	3652	CppAD_HAVE_AR_FALSE='#'
	3653	else
	3654	CppAD_HAVE_AR_TRUE='#'
	3655	CppAD_HAVE_AR_FALSE=
	3656	fi
	3657
	3658	if test "$AR" != "ar"; then
	3659	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot build any libraries because ar is missing; e.g,, speed/* not built
	3660	" >&5
	3661	$as_echo "$as_me: WARNING: cannot build any libraries because ar is missing; e.g,, speed/* not built
	3662	" >&2;}
	3663	fi
	3664
	3665	{ $as_echo "$as_me:${as_lineno-$LINENO}: * Check command line arguments that are longer used **" >&5
	3666	$as_echo "$as_me: * Check command line arguments that are longer used **" >&6;}
	3667
	3668	if test "$CPP_ERROR_WARN" != "" ; then
	3669	as_fn_error $? "The CPP_ERROR_WARN configure option is now CXX_FLAGS" "$LINENO" 5
	3670	fi
	3671
	3672	# Check whether --with-SpeedExample was given.
	3673	if test "${with_SpeedExample+set}" = set; then :
	3674	withval=$with_SpeedExample; SpeedExample="yes"
	3675	else
	3676	SpeedExample="no"
	3677
	3678	fi
	3679
	3680	if test "$SpeedExample" = "yes" ; then
	3681	as_fn_error $? "--with-SpeedExample not necessary, see install instructions." "$LINENO" 5
	3682	fi
	3683
	3684	# Check whether --with-profiling was given.
	3685	if test "${with_profiling+set}" = set; then :
	3686	withval=$with_profiling; profiling="yes"
	3687	else
	3688	profiling="no"
	3689
	3690	fi
	3691
	3692	if test "$profiling" = "yes" ; then
	3693	as_fn_error $? "--with-profiling not necessary, see install instructions." "$LINENO" 5
	3694	fi
	3695
	3696	# Check whether --with-Speed was given.
	3697	if test "${with_Speed+set}" = set; then :
	3698	withval=$with_Speed; Speed="yes"
	3699	else
	3700	Speed="no"
	3701
	3702	fi
	3703
	3704	if test "$Speed" = "yes" ; then
	3705	as_fn_error $? "--with-Speed not necessary, see install instructions." "$LINENO" 5
	3706	fi
	3707
	3708	# Check whether --with-Introduction was given.
	3709	if test "${with_Introduction+set}" = set; then :
	3710	withval=$with_Introduction; Introduction="yes"
	3711	else
	3712	Introduction="no"
	3713
	3714	fi
	3715
	3716	if test "$Introduction" = "yes" ; then
	3717	as_fn_error $? "--with-Introduction not necessary, see install instructions." "$LINENO" 5
	3718	fi
	3719
	3720	# Check whether --with-Example was given.
	3721	if test "${with_Example+set}" = set; then :
	3722	withval=$with_Example; Example="yes"
	3723	else
	3724	Example="no"
	3725
	3726	fi
	3727
	3728	if test "$Example" = "yes" ; then
	3729	as_fn_error $? "--with-Example not necessary, see install instructions." "$LINENO" 5
	3730	fi
	3731
	3732	# Check whether --with-TestMore was given.
	3733	if test "${with_TestMore+set}" = set; then :
	3734	withval=$with_TestMore; TestMore="yes"
	3735	else
	3736	TestMore="no"
	3737
	3738	fi
	3739
	3740	if test "$TestMore" = "yes" ; then
	3741	as_fn_error $? "--with-TestMore not necessary, see install instructions." "$LINENO" 5
	3742	fi
	3743
	3744	# Check whether --with-PrintFor was given.
	3745	if test "${with_PrintFor+set}" = set; then :
	3746	withval=$with_PrintFor; PrintFor="yes"
	3747	else
	3748	PrintFor="no"
	3749
	3750	fi
	3751
	3752	if test "$PrintFor" = "yes" ; then
	3753	as_fn_error $? "--with-PrintFor not necessary, see install instructions." "$LINENO" 5
	3754	fi
	3755	{ $as_echo "$as_me:${as_lineno-$LINENO}: **** Check command line arguments that are used *********" >&5
	3756	$as_echo "$as_me: **** Check command line arguments that are used *********" >&6;}
	3757	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --prefix" >&5
	3758	$as_echo_n "checking --prefix... " >&6; }
	3759	if test "$prefix" = "NONE" ; then
	3760	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOME" >&5
	3761	$as_echo "$HOME" >&6; }
	3762	else
	3763	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $prefix" >&5
	3764	$as_echo "$prefix" >&6; }
	3765	fi
	3766
	3767	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-Documentation" >&5
	3768	$as_echo_n "checking --with-Documentation... " >&6; }
	3769
	3770	# Check whether --with-Documentation was given.
	3771	if test "${with_Documentation+set}" = set; then :
	3772	withval=$with_Documentation; Documentation="yes"
	3773	else
	3774	Documentation="no"
	3775
	3776	fi
	3777
	3778	if test "$Documentation" = "yes"; then
	3779	CppAD_DOCUMENTATION_TRUE=
	3780	CppAD_DOCUMENTATION_FALSE='#'
	3781	else
	3782	CppAD_DOCUMENTATION_TRUE='#'
	3783	CppAD_DOCUMENTATION_FALSE=
	3784	fi
	3785
	3786	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $Documentation" >&5
	3787	$as_echo "$Documentation" >&6; }
	3788
	3789	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-stdvector" >&5
	3790	$as_echo_n "checking --with-stdvector... " >&6; }
	3791
	3792	# Check whether --with-stdvector was given.
	3793	if test "${with_stdvector+set}" = set; then :
	3794	withval=$with_stdvector; stdvector="yes"
	3795	else
	3796	stdvector="no"
	3797
	3798	fi
	3799
	3800	if test "$stdvector" = "yes" ; then
	3801	cppad_stdvector=1
	3802
	3803	else
	3804	cppad_stdvector=0
	3805
	3806	fi
	3807	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $stdvector" >&5
	3808	$as_echo "$stdvector" >&6; }
	3809
	3810	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-boostvector" >&5
	3811	$as_echo_n "checking --with-boostvector... " >&6; }
	3812
	3813	# Check whether --with-boostvector was given.
	3814	if test "${with_boostvector+set}" = set; then :
	3815	withval=$with_boostvector; boostvector="yes"
	3816	else
	3817	boostvector="no"
	3818
	3819	fi
	3820
	3821	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $boostvector" >&5
	3822	$as_echo "$boostvector" >&6; }
	3823	if test "$boostvector" = "yes" ; then
	3824	if test "$stdvector" != "no" ; then
	3825	as_fn_error $? "cannot --with both stdvector and boostvector" "$LINENO" 5
	3826	fi
	3827	cppad_boostvector=1
	3828
	3829	else
	3830	cppad_boostvector=0
	3831
	3832	fi
	3833
	3834	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-eigenvector" >&5
	3835	$as_echo_n "checking --with-eigenvector... " >&6; }
	3836
	3837	# Check whether --with-eigenvector was given.
	3838	if test "${with_eigenvector+set}" = set; then :
	3839	withval=$with_eigenvector; eigenvector="yes"
	3840	else
	3841	eigenvector="no"
	3842
	3843	fi
	3844
	3845	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $eigenvector" >&5
	3846	$as_echo "$eigenvector" >&6; }
	3847	if test "$eigenvector" = "yes" ; then
	3848	if test "$stdvector" != "no" ; then
	3849	as_fn_error $? "cannot --with both stdvector and eigenvector" "$LINENO" 5
	3850	fi
	3851	if test "$boostvector" != "no" ; then
	3852	as_fn_error $? "cannot --with both boostvector and eigenvector" "$LINENO" 5
	3853	fi
	3854	cppad_eigenvector=1
	3855
	3856	else
	3857	cppad_eigenvector=0
	3858
	3859	fi
	3860
	3861	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_set" >&5
	3862	$as_echo_n "checking --with-sparse_set... " >&6; }
	3863
	3864	# Check whether --with-sparse_set was given.
	3865	if test "${with_sparse_set+set}" = set; then :
	3866	withval=$with_sparse_set; sparse_set="yes"
	3867	else
	3868	sparse_set="no"
	3869
	3870	fi
	3871
	3872	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_set" >&5
	3873	$as_echo "$sparse_set" >&6; }
	3874	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-sparse_list" >&5
	3875	$as_echo_n "checking --with-sparse_list... " >&6; }
	3876
	3877	# Check whether --with-sparse_list was given.
	3878	if test "${with_sparse_list+set}" = set; then :
	3879	withval=$with_sparse_list; sparse_list="yes"
	3880	else
	3881	sparse_list="no"
	3882
	3883	fi
	3884
	3885	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $sparse_list" >&5
	3886	$as_echo "$sparse_list" >&6; }
	3887	if test "$sparse_set" = "yes" ; then
	3888	if test "$sparse_list" == "yes" ; then
	3889	as_fn_error $? "cannot --with both sparse_set and sparse_list" "$LINENO" 5
	3890	fi
	3891	cppad_internal_sparse_set=sparse_set
	3892
	3893	else
	3894	cppad_internal_sparse_set=sparse_list
	3895
	3896	fi
	3897
	3898
	3899	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking --with-implicit_ctor" >&5
	3900	$as_echo_n "checking --with-implicit_ctor... " >&6; }
	3901
	3902	# Check whether --with-implicit_ctor was given.
	3903	if test "${with_implicit_ctor+set}" = set; then :
	3904	withval=$with_implicit_ctor; implicit_ctor="yes"
	3905	else
	3906	implicit_ctor="no"
	3907
	3908	fi
	3909
	3910	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $implicit_ctor" >&5
	3911	$as_echo "$implicit_ctor" >&6; }
	3912	if test "$implicit_ctor" = "yes" ; then
	3913	cppad_implicit_ctor_from_any_type="1"
	3914
	3915	else
	3916	cppad_implicit_ctor_from_any_type="0"
	3917
	3918	fi
	3919
	3920	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking POSTFIX_DIR" >&5
	3921	$as_echo_n "checking POSTFIX_DIR... " >&6; }
	3922
	3923	if test "$POSTFIX_DIR" != ""; then
	3924	CppAD_POSTFIX_TRUE=
	3925	CppAD_POSTFIX_FALSE='#'
	3926	else
	3927	CppAD_POSTFIX_TRUE='#'
	3928	CppAD_POSTFIX_FALSE=
	3929	fi
	3930
	3931	if test "$POSTFIX_DIR" != "" ; then
	3932	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $POSTFIX_DIR" >&5
	3933	$as_echo "$POSTFIX_DIR" >&6; }
	3934	else
	3935	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	3936	$as_echo "no" >&6; }
	3937	fi
	3938
	3939	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking ADOLC_DIR" >&5
	3940	$as_echo_n "checking ADOLC_DIR... " >&6; }
	3941
	3942	if test "$ADOLC_DIR" != ""; then
	3943	CppAD_ADOLC_TRUE=
	3944	CppAD_ADOLC_FALSE='#'
	3945	else
	3946	CppAD_ADOLC_TRUE='#'
	3947	CppAD_ADOLC_FALSE=
	3948	fi
	3949
	3950	if test "$ADOLC_DIR" != "" ; then
	3951	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ADOLC_DIR" >&5
	3952	$as_echo "$ADOLC_DIR" >&6; }
	3953	if test "$have_ar" = "no"; then
	3954	as_fn_error $? "ar is missing and ADOLC_DIR is present" "$LINENO" 5
	3955	fi
	3956	else
	3957	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	3958	$as_echo "no" >&6; }
	3959	fi
	3960
	3961	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking EIGEN_DIR" >&5
	3962	$as_echo_n "checking EIGEN_DIR... " >&6; }
	3963
	3964	if test "$EIGEN_DIR" != ""; then
	3965	CppAD_EIGEN_DIR_TRUE=
	3966	CppAD_EIGEN_DIR_FALSE='#'
	3967	else
	3968	CppAD_EIGEN_DIR_TRUE='#'
	3969	CppAD_EIGEN_DIR_FALSE=
	3970	fi
	3971
	3972	if test "$EIGEN_DIR" != "" ; then
	3973	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $EIGEN_DIR" >&5
	3974	$as_echo "$EIGEN_DIR" >&6; }
	3975	EIGEN_INCLUDE=-I$EIGEN_DIR/include
	3976
	3977	else
	3978	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	3979	$as_echo "no" >&6; }
	3980
	3981	fi
	3982
	3983	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking FADBAD_DIR" >&5
	3984	$as_echo_n "checking FADBAD_DIR... " >&6; }
	3985
	3986	if test "$FADBAD_DIR" != ""; then
	3987	CppAD_FADBAD_TRUE=
	3988	CppAD_FADBAD_FALSE='#'
	3989	else
	3990	CppAD_FADBAD_TRUE='#'
	3991	CppAD_FADBAD_FALSE=
	3992	fi
	3993
	3994	if test "$FADBAD_DIR" != "" ; then
	3995	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $FADBAD_DIR" >&5
	3996	$as_echo "$FADBAD_DIR" >&6; }
	3997	if test "$have_ar" = "no"; then
	3998	as_fn_error $? "ar is missing and FADBAD_DIR is present" "$LINENO" 5
	3999	fi
	4000	else
	4001	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	4002	$as_echo "no" >&6; }
	4003	fi
	4004
	4005	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking SACADO_DIR" >&5
	4006	$as_echo_n "checking SACADO_DIR... " >&6; }
	4007
	4008	if test "$SACADO_DIR" != ""; then
	4009	CppAD_SACADO_TRUE=
	4010	CppAD_SACADO_FALSE='#'
	4011	else
	4012	CppAD_SACADO_TRUE='#'
	4013	CppAD_SACADO_FALSE=
	4014	fi
	4015
	4016	if test "$SACADO_DIR" != "" ; then
	4017	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SACADO_DIR" >&5
	4018	$as_echo "$SACADO_DIR" >&6; }
	4019	if test "$have_ar" = "no"; then
	4020	as_fn_error $? "ar is missing and SACADO_DIR is present" "$LINENO" 5
	4021	fi
	4022	else
	4023	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	4024	$as_echo "no" >&6; }
	4025	fi
	4026
	4027	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking IPOPT_DIR" >&5
	4028	$as_echo_n "checking IPOPT_DIR... " >&6; }
	4029
	4030	if test "$IPOPT_DIR" != ""; then
	4031	CppAD_IPOPT_TRUE=
	4032	CppAD_IPOPT_FALSE='#'
	4033	else
	4034	CppAD_IPOPT_TRUE='#'
	4035	CppAD_IPOPT_FALSE=
	4036	fi
	4037
	4038	if test "$IPOPT_DIR" != "" ; then
	4039	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $IPOPT_DIR" >&5
	4040	$as_echo "$IPOPT_DIR" >&6; }
	4041	if test "$have_ar" = "no"; then
	4042	as_fn_error $? "ar is missing and IPOPT_DIR is present" "$LINENO" 5
	4043	fi
	4044	else
	4045	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	4046	$as_echo "no" >&6; }
	4047	fi
	4048
	4049	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking BOOST_DIR" >&5
	4050	$as_echo_n "checking BOOST_DIR... " >&6; }
	4051
	4052	if test "$BOOST_DIR" != ""; then
	4053	CppAD_BOOST_DIR_TRUE=
	4054	CppAD_BOOST_DIR_FALSE='#'
	4055	else
	4056	CppAD_BOOST_DIR_TRUE='#'
	4057	CppAD_BOOST_DIR_FALSE=
	4058	fi
	4059
	4060	if test "$BOOST_DIR" != "" ; then
	4061	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOST_DIR" >&5
	4062	$as_echo "$BOOST_DIR" >&6; }
	4063	BOOST_INCLUDE=-I$BOOST_DIR/include
	4064
	4065	else
	4066	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	4067	$as_echo "no" >&6; }
	4068
	4069	fi
	4070
	4071	#
	4072	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking CXX_FLAGS" >&5
	4073	$as_echo_n "checking CXX_FLAGS... " >&6; }
	4074
	4075	# cxx_flags for fadbad and eigen
	4076	if test "$CXX_FLAGS" != "" ; then
	4077	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX_FLAGS" >&5
	4078	$as_echo "$CXX_FLAGS" >&6; }
	4079	cxx_flags_fadbad=`echo "$CXX_FLAGS" \| sed -e 's\|-Wshadow\|\|'`
	4080	cxx_flags_eigen="$cxx_flags_fadbda -Wno-long-long"
	4081	else
	4082	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	4083	$as_echo "no" >&6; }
	4084	cxx_flags_fadbad=""
	4085	cxx_flags_eigen=""
	4086	fi
	4087	CXX_FLAGS_FADBAD="$cxx_flags_fadbad"
	4088
	4089	CXX_FLAGS_EIGEN="$cxx_flags_eigen"
	4090
	4091
	4092	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking OPENMP_FLAGS" >&5
	4093	$as_echo_n "checking OPENMP_FLAGS... " >&6; }
	4094
	4095	if test "$OPENMP_FLAGS" != "" ; then
	4096	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENMP_FLAGS" >&5
	4097	$as_echo "$OPENMP_FLAGS" >&6; }
	4098	else
	4099	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
	4100	$as_echo "no" >&6; }
	4101	fi
	4102	if test "$OPENMP_FLAGS" != ""; then
	4103	CppAD_OPENMP_TRUE=
	4104	CppAD_OPENMP_FALSE='#'
	4105	else
	4106	CppAD_OPENMP_TRUE='#'
	4107	CppAD_OPENMP_FALSE=
	4108	fi
	4109
	4110
	4111	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking MAX_NUM_THREADS" >&5
	4112	$as_echo_n "checking MAX_NUM_THREADS... " >&6; }
	4113
	4114	if test "$MAX_NUM_THREADS" != "" ; then
	4115	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAX_NUM_THREADS" >&5
	4116	$as_echo "$MAX_NUM_THREADS" >&6; }
	4117	if test "$MAX_NUM_THREADS" -lt "4" ; then
	4118	as_fn_error $? " MAX_NUM_THREADS=$MAX_NUM_THREADS is less than 4
	4119	" "$LINENO" 5
	4120	fi
	4121	max_num_threads="$MAX_NUM_THREADS"
	4122	else
	4123	max_num_threads="48"
	4124	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using default value $max_num_threads" >&5
	4125	$as_echo "no, using default value $max_num_threads" >&6; }
	4126	fi
	4127	cppad_max_num_threads=$max_num_threads
	4128
	4129
	4130	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking TAPE_ADDR_TYPE" >&5
	4131	$as_echo_n "checking TAPE_ADDR_TYPE... " >&6; }
	4132
	4133	if test "$TAPE_ADDR_TYPE" == "" ; then
	4134	addr_t="unsigned int"
	4135	else
	4136	addr_t="$TAPE_ADDR_TYPE"
	4137	fi
	4138	cppad_tape_addr_type=$addr_t
	4139
	4140	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $addr_t" >&5
	4141	$as_echo "$addr_t" >&6; }
	4142	ok="no"
	4143	if test "$addr_t" == "size_t" ; then
	4144	ok="yes"
	4145	fi
	4146	if test "$addr_t" == "int" ; then
	4147	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: TAPE_ADDR_TYPE=int is for CppAD developers (not users)
	4148	" >&5
	4149	$as_echo "$as_me: WARNING: TAPE_ADDR_TYPE=int is for CppAD developers (not users)
	4150	" >&2;}
	4151	ok="yes"
	4152	fi
	4153	if test "$addr_t" == "unsigned int" ; then
	4154	ok="yes"
	4155	fi
	4156	if test "$addr_t" == "unsigned short int" ; then
	4157	ok="yes"
	4158	fi
	4159	if test "$ok" == "no" ; then
	4160	as_fn_error $? "$addr_t is not a valid choice for TAPE_ADDR_TYPE
	4161	" "$LINENO" 5
	4162	fi
	4163
	4164	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking TAPE_ID_TYPE" >&5
	4165	$as_echo_n "checking TAPE_ID_TYPE... " >&6; }
	4166
	4167	if test "$TAPE_ID_TYPE" == "" ; then
	4168	tape_id_t="unsigned int"
	4169	else
	4170	tape_id_t="$TAPE_ID_TYPE"
	4171	fi
	4172	cppad_tape_id_type=$tape_id_t
	4173
	4174	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tape_id_t" >&5
	4175	$as_echo "$tape_id_t" >&6; }
	4176	ok="no"
	4177	if test "$tape_id_t" == "size_t" ; then
	4178	ok="yes"
	4179	fi
	4180	if test "$tape_id_t" == "int" ; then
	4181	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: TAPE_ID_TYPE=int is for CppAD developers (not users)
	4182	" >&5
	4183	$as_echo "$as_me: WARNING: TAPE_ID_TYPE=int is for CppAD developers (not users)
	4184	" >&2;}
	4185	ok="yes"
	4186	fi
	4187	if test "$tape_id_t" == "unsigned int" ; then
	4188	ok="yes"
	4189	fi
	4190	if test "$tape_id_t" == "unsigned short int" ; then
	4191	ok="yes"
	4192	fi
	4193	if test "$ok" == "no" ; then
	4194	as_fn_error $? "$tape_id_t is not a valid choice for TAPE_ID_TYPE
	4195	" "$LINENO" 5
	4196	fi
	4197	{ $as_echo "$as_me:${as_lineno-$LINENO}: ******** End Checking Command Line arguments *************" >&5
	4198	$as_echo "$as_me: ******** End Checking Command Line arguments *************" >&6;}
	4199
	4200	cppad_has_colpack=0
	4201
	4202
	4203	cppad_has_nullptr=0
	4204
	4205	cppad_has_rvalue=0
	4206
	4207	cppad_has_cstdint_8_to_64=0
	4208
	4209	cppad_compiler_has_erf=0
4034	4210
4035	4211
4036	4212	ac_ext=c

4187	4363	for ac_prog in grep ggrep; do
4188	4364	for ac_exec_ext in '' $ac_executable_extensions; do
4189	4365	ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4190		{ test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } \|\| continue
	4366	as_fn_executable_p "$ac_path_GREP" \|\| continue
4191	4367	# Check for GNU ac_path_GREP and select it if it is found.
4192	4368	# Check for GNU $ac_path_GREP
4193	4369	case `"$ac_path_GREP" --version 2>&1` in

4253	4429	for ac_prog in egrep; do
4254	4430	for ac_exec_ext in '' $ac_executable_extensions; do
4255	4431	ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
4256		{ test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } \|\| continue
	4432	as_fn_executable_p "$ac_path_EGREP" \|\| continue
4257	4433	# Check for GNU ac_path_EGREP and select it if it is found.
4258	4434	# Check for GNU $ac_path_EGREP
4259	4435	case `"$ac_path_EGREP" --version 2>&1` in

4497	4673
4498	4674
4499	4675	if test "$ac_cv_size_t" == "$ac_cv_unsigned_int" ; then
4500		cppad_size_t_same_unsigned_int=1
4501
4502		else
4503		cppad_size_t_same_unsigned_int=0
	4676	cppad_size_t_not_unsigned_int=1
	4677
	4678	else
	4679	cppad_size_t_not_unsigned_int=0
4504	4680
4505	4681	fi
4506	4682

4528	4704
4529	4705	fi
4530	4706
4531		am__api_version='1.11'
	4707	am__api_version='1.13'
4532	4708
4533	4709	ac_aux_dir=
4534	4710	for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do

4596	4772	# by default.
4597	4773	for ac_prog in ginstall scoinst install; do
4598	4774	for ac_exec_ext in '' $ac_executable_extensions; do
4599		if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
	4775	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
4600	4776	if test $ac_prog = install &&
4601	4777	grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
4602	4778	# AIX install. It has an incompatible calling convention.

4654	4830
4655	4831	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
4656	4832	$as_echo_n "checking whether build environment is sane... " >&6; }
4657		# Just in case
4658		sleep 1
4659		echo timestamp > conftest.file
4660	4833	# Reject unsafe characters in $srcdir or the absolute working directory
4661	4834	# name. Accept space and tab only in the latter.
4662	4835	am_lf='

4667	4840	esac
4668	4841	case $srcdir in
4669	4842	[\\\"\#\$\&\'\`$am_lf\ \ ])
4670		as_fn_error $? "unsafe srcdir value: \`$srcdir'" "$LINENO" 5;;
	4843	as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
4671	4844	esac
4672	4845
4673		# Do `set' in a subshell so we don't clobber the current shell's
	4846	# Do 'set' in a subshell so we don't clobber the current shell's
4674	4847	# arguments. Must try -L first in case configure is actually a
4675	4848	# symlink; some systems play weird games with the mod time of symlinks
4676	4849	# (eg FreeBSD returns the mod time of the symlink's containing
4677	4850	# directory).
4678	4851	if (
4679		set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
4680		if test "$*" = "X"; then
4681		# -L didn't work.
4682		set X `ls -t "$srcdir/configure" conftest.file`
4683		fi
4684		rm -f conftest.file
4685		if test "$*" != "X $srcdir/configure conftest.file" \
4686		&& test "$*" != "X conftest.file $srcdir/configure"; then
4687
4688		# If neither matched, then we have a broken ls. This can happen
4689		# if, for instance, CONFIG_SHELL is bash and it inherits a
4690		# broken ls alias from the environment. This has actually
4691		# happened. Such a system could not be considered "sane".
4692		as_fn_error $? "ls -t appears to fail. Make sure there is not a broken
4693		alias in your environment" "$LINENO" 5
4694		fi
4695
	4852	am_has_slept=no
	4853	for am_try in 1 2; do
	4854	echo "timestamp, slept: $am_has_slept" > conftest.file
	4855	set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
	4856	if test "$*" = "X"; then
	4857	# -L didn't work.
	4858	set X `ls -t "$srcdir/configure" conftest.file`
	4859	fi
	4860	if test "$*" != "X $srcdir/configure conftest.file" \
	4861	&& test "$*" != "X conftest.file $srcdir/configure"; then
	4862
	4863	# If neither matched, then we have a broken ls. This can happen
	4864	# if, for instance, CONFIG_SHELL is bash and it inherits a
	4865	# broken ls alias from the environment. This has actually
	4866	# happened. Such a system could not be considered "sane".
	4867	as_fn_error $? "ls -t appears to fail. Make sure there is not a broken
	4868	alias in your environment" "$LINENO" 5
	4869	fi
	4870	if test "$2" = conftest.file \|\| test $am_try -eq 2; then
	4871	break
	4872	fi
	4873	# Just in case.
	4874	sleep 1
	4875	am_has_slept=yes
	4876	done
4696	4877	test "$2" = conftest.file
4697	4878	)
4698	4879	then

4704	4885	fi
4705	4886	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4706	4887	$as_echo "yes" >&6; }
	4888	# If we didn't sleep, we still need to ensure time stamps of config.status and
	4889	# generated files are strictly newer.
	4890	am_sleep_pid=
	4891	if grep 'slept: no' conftest.file >/dev/null 2>&1; then
	4892	( sleep 1 ) &
	4893	am_sleep_pid=$!
	4894	fi
	4895
	4896	rm -f conftest.file
	4897
4707	4898	test "$program_prefix" != NONE &&
4708	4899	program_transform_name="s&^&$program_prefix&;$program_transform_name"
4709	4900	# Use a double $ so make ignores it.

4714	4905	ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
4715	4906	program_transform_name=`$as_echo "$program_transform_name" \| sed "$ac_script"`
4716	4907
4717		# expand $ac_aux_dir to an absolute path
4718		am_aux_dir=`cd $ac_aux_dir && pwd`
4719
4720	4908	if test x"${MISSING+set}" != xset; then
4721	4909	case $am_aux_dir in
4722	4910	\ \| \ )

4726	4914	esac
4727	4915	fi
4728	4916	# Use eval to expand $SHELL
4729		if eval "$MISSING --run true"; then
4730		am_missing_run="$MISSING --run "
	4917	if eval "$MISSING --is-lightweight"; then
	4918	am_missing_run="$MISSING "
4731	4919	else
4732	4920	am_missing_run=
4733		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5
4734		$as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
	4921	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
	4922	$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
4735	4923	fi
4736	4924
4737	4925	if test x"${install_sh}" != xset; then

4743	4931	esac
4744	4932	fi
4745	4933
4746		# Installed binaries are usually stripped using `strip' when the user
4747		# run `make install-strip'. However `strip' might not be the right
	4934	# Installed binaries are usually stripped using 'strip' when the user
	4935	# run "make install-strip". However 'strip' might not be the right
4748	4936	# tool to use in cross-compilation environments, therefore Automake
4749		# will honor the `STRIP' environment variable to overrule this program.
	4937	# will honor the 'STRIP' environment variable to overrule this program.
4750	4938	if test "$cross_compiling" != no; then
4751	4939	if test -n "$ac_tool_prefix"; then
4752	4940	# Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.

4765	4953	IFS=$as_save_IFS
4766	4954	test -z "$as_dir" && as_dir=.
4767	4955	for ac_exec_ext in '' $ac_executable_extensions; do
4768		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	4956	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4769	4957	ac_cv_prog_STRIP="${ac_tool_prefix}strip"
4770	4958	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4771	4959	break 2

4805	4993	IFS=$as_save_IFS
4806	4994	test -z "$as_dir" && as_dir=.
4807	4995	for ac_exec_ext in '' $ac_executable_extensions; do
4808		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	4996	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4809	4997	ac_cv_prog_ac_ct_STRIP="strip"
4810	4998	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4811	4999	break 2

4856	5044	test -z "$as_dir" && as_dir=.
4857	5045	for ac_prog in mkdir gmkdir; do
4858	5046	for ac_exec_ext in '' $ac_executable_extensions; do
4859		{ test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; } \|\| continue
	5047	as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" \|\| continue
4860	5048	case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
4861	5049	'mkdir (GNU coreutils) '* \| \
4862	5050	'mkdir (coreutils) '* \| \

4885	5073	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
4886	5074	$as_echo "$MKDIR_P" >&6; }
4887	5075
4888		mkdir_p="$MKDIR_P"
4889		case $mkdir_p in
4890		[\\/$]* \| ?:[\\/]*) ;;
4891		/) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
4892		esac
4893
4894	5076	for ac_prog in gawk mawk nawk awk
4895	5077	do
4896	5078	# Extract the first word of "$ac_prog", so it can be a program name with args.

4909	5091	IFS=$as_save_IFS
4910	5092	test -z "$as_dir" && as_dir=.
4911	5093	for ac_exec_ext in '' $ac_executable_extensions; do
4912		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	5094	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4913	5095	ac_cv_prog_AWK="$ac_prog"
4914	5096	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4915	5097	break 2

4992	5174	_am_result=none
4993	5175	# First try GNU make style include.
4994	5176	echo "include confinc" > confmf
4995		# Ignore all kinds of additional output from `make'.
	5177	# Ignore all kinds of additional output from 'make'.
4996	5178	case `$am_make -s -f confmf 2> /dev/null` in #(
4997	5179	the\ am__doit\ target)
4998	5180	am__include=include

5058	5240
5059	5241	# Define the identity of the package.
5060	5242	PACKAGE='cppad'
5061		VERSION='20140000.3'
	5243	VERSION='20150000.0'
5062	5244
5063	5245
5064	5246	cat >>confdefs.h <<_ACEOF

5085	5267
5086	5268
5087	5269	MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
	5270
	5271	# For better backward compatibility. To be removed once Automake 1.9.x
	5272	# dies out for good. For more background, see:
	5273	# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
	5274	# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
	5275	mkdir_p='$(MKDIR_P)'
5088	5276
5089	5277	# We need awk for the "check" target. The system "awk" is bad on
5090	5278	# some platforms.

5092	5280	# in the wild :-( We should find a proper way to deprecate it ...
5093	5281	AMTAR='$${TAR-tar}'
5094	5282
	5283
	5284	# We'll loop over all known methods to create a tar archive until one works.
	5285	_am_tools='gnutar pax cpio none'
	5286
5095	5287	am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
	5288
5096	5289
5097	5290
5098	5291

5108	5301	# We make a subdir and do the tests there. Otherwise we can end up
5109	5302	# making bogus files that we don't know about and never remove. For
5110	5303	# instance it was reported that on HP-UX the gcc test will end up
5111		# making a dummy file named `D' -- because `-MD' means `put the output
5112		# in D'.
	5304	# making a dummy file named 'D' -- because '-MD' means "put the output
	5305	# in D".
5113	5306	rm -rf conftest.dir
5114	5307	mkdir conftest.dir
5115	5308	# Copy depcomp to subdir because otherwise we won't find it if we're

5144	5337	: > sub/conftest.c
5145	5338	for i in 1 2 3 4 5 6; do
5146	5339	echo '#include "conftst'$i'.h"' >> sub/conftest.c
5147		# Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
5148		# Solaris 8's {/usr,}/bin/sh.
5149		touch sub/conftst$i.h
	5340	# Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
	5341	# Solaris 10 /bin/sh.
	5342	echo '/* dummy */' > sub/conftst$i.h
5150	5343	done
5151	5344	echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
5152	5345
5153		# We check with `-c' and `-o' for the sake of the "dashmstdout"
	5346	# We check with '-c' and '-o' for the sake of the "dashmstdout"
5154	5347	# mode. It turns out that the SunPro C++ compiler does not properly
5155		# handle `-M -o', and we need to detect this. Also, some Intel
5156		# versions had trouble with output in subdirs
	5348	# handle '-M -o', and we need to detect this. Also, some Intel
	5349	# versions had trouble with output in subdirs.
5157	5350	am__obj=sub/conftest.${OBJEXT-o}
5158	5351	am__minus_obj="-o $am__obj"
5159	5352	case $depmode in

5162	5355	test "$am__universal" = false \|\| continue
5163	5356	;;
5164	5357	nosideeffect)
5165		# after this tag, mechanisms are not by side-effect, so they'll
5166		# only be used when explicitly requested
	5358	# After this tag, mechanisms are not by side-effect, so they'll
	5359	# only be used when explicitly requested.
5167	5360	if test "x$enable_dependency_tracking" = xyes; then
5168	5361	continue
5169	5362	else

5171	5364	fi
5172	5365	;;
5173	5366	msvc7 \| msvc7msys \| msvisualcpp \| msvcmsys)
5174		# This compiler won't grok `-c -o', but also, the minuso test has
	5367	# This compiler won't grok '-c -o', but also, the minuso test has
5175	5368	# not run yet. These depmodes are late enough in the game, and
5176	5369	# so weak that their functioning should not be impacted.
5177	5370	am__obj=conftest.${OBJEXT-o}

5245	5438	IFS=$as_save_IFS
5246	5439	test -z "$as_dir" && as_dir=.
5247	5440	for ac_exec_ext in '' $ac_executable_extensions; do
5248		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	5441	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5249	5442	ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
5250	5443	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5251	5444	break 2

5285	5478	IFS=$as_save_IFS
5286	5479	test -z "$as_dir" && as_dir=.
5287	5480	for ac_exec_ext in '' $ac_executable_extensions; do
5288		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	5481	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5289	5482	ac_cv_prog_ac_ct_RANLIB="ranlib"
5290	5483	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5291	5484	break 2

5349	5542	IFS=$as_save_IFS
5350	5543	test -z "$as_dir" && as_dir=.
5351	5544	for ac_exec_ext in '' $ac_executable_extensions; do
5352		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	5545	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5353	5546	ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
5354	5547	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5355	5548	break 2

5393	5586	IFS=$as_save_IFS
5394	5587	test -z "$as_dir" && as_dir=.
5395	5588	for ac_exec_ext in '' $ac_executable_extensions; do
5396		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	5589	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5397	5590	ac_cv_prog_ac_ct_CXX="$ac_prog"
5398	5591	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5399	5592	break 2

5589	5782	# We make a subdir and do the tests there. Otherwise we can end up
5590	5783	# making bogus files that we don't know about and never remove. For
5591	5784	# instance it was reported that on HP-UX the gcc test will end up
5592		# making a dummy file named `D' -- because `-MD' means `put the output
5593		# in D'.
	5785	# making a dummy file named 'D' -- because '-MD' means "put the output
	5786	# in D".
5594	5787	rm -rf conftest.dir
5595	5788	mkdir conftest.dir
5596	5789	# Copy depcomp to subdir because otherwise we won't find it if we're

5625	5818	: > sub/conftest.c
5626	5819	for i in 1 2 3 4 5 6; do
5627	5820	echo '#include "conftst'$i'.h"' >> sub/conftest.c
5628		# Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
5629		# Solaris 8's {/usr,}/bin/sh.
5630		touch sub/conftst$i.h
	5821	# Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
	5822	# Solaris 10 /bin/sh.
	5823	echo '/* dummy */' > sub/conftst$i.h
5631	5824	done
5632	5825	echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
5633	5826
5634		# We check with `-c' and `-o' for the sake of the "dashmstdout"
	5827	# We check with '-c' and '-o' for the sake of the "dashmstdout"
5635	5828	# mode. It turns out that the SunPro C++ compiler does not properly
5636		# handle `-M -o', and we need to detect this. Also, some Intel
5637		# versions had trouble with output in subdirs
	5829	# handle '-M -o', and we need to detect this. Also, some Intel
	5830	# versions had trouble with output in subdirs.
5638	5831	am__obj=sub/conftest.${OBJEXT-o}
5639	5832	am__minus_obj="-o $am__obj"
5640	5833	case $depmode in

5643	5836	test "$am__universal" = false \|\| continue
5644	5837	;;
5645	5838	nosideeffect)
5646		# after this tag, mechanisms are not by side-effect, so they'll
5647		# only be used when explicitly requested
	5839	# After this tag, mechanisms are not by side-effect, so they'll
	5840	# only be used when explicitly requested.
5648	5841	if test "x$enable_dependency_tracking" = xyes; then
5649	5842	continue
5650	5843	else

5652	5845	fi
5653	5846	;;
5654	5847	msvc7 \| msvc7msys \| msvisualcpp \| msvcmsys)
5655		# This compiler won't grok `-c -o', but also, the minuso test has
	5848	# This compiler won't grok '-c -o', but also, the minuso test has
5656	5849	# not run yet. These depmodes are late enough in the game, and
5657	5850	# so weak that their functioning should not be impacted.
5658	5851	am__obj=conftest.${OBJEXT-o}

5749	5942	IFS=$as_save_IFS
5750	5943	test -z "$as_dir" && as_dir=.
5751	5944	for ac_exec_ext in '' $ac_executable_extensions; do
5752		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	5945	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5753	5946	ac_cv_prog_CC="${ac_tool_prefix}gcc"
5754	5947	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5755	5948	break 2

5789	5982	IFS=$as_save_IFS
5790	5983	test -z "$as_dir" && as_dir=.
5791	5984	for ac_exec_ext in '' $ac_executable_extensions; do
5792		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	5985	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5793	5986	ac_cv_prog_ac_ct_CC="gcc"
5794	5987	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5795	5988	break 2

5842	6035	IFS=$as_save_IFS
5843	6036	test -z "$as_dir" && as_dir=.
5844	6037	for ac_exec_ext in '' $ac_executable_extensions; do
5845		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	6038	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5846	6039	ac_cv_prog_CC="${ac_tool_prefix}cc"
5847	6040	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5848	6041	break 2

5883	6076	IFS=$as_save_IFS
5884	6077	test -z "$as_dir" && as_dir=.
5885	6078	for ac_exec_ext in '' $ac_executable_extensions; do
5886		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	6079	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5887	6080	if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
5888	6081	ac_prog_rejected=yes
5889	6082	continue

5941	6134	IFS=$as_save_IFS
5942	6135	test -z "$as_dir" && as_dir=.
5943	6136	for ac_exec_ext in '' $ac_executable_extensions; do
5944		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	6137	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5945	6138	ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
5946	6139	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5947	6140	break 2

5985	6178	IFS=$as_save_IFS
5986	6179	test -z "$as_dir" && as_dir=.
5987	6180	for ac_exec_ext in '' $ac_executable_extensions; do
5988		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	6181	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5989	6182	ac_cv_prog_ac_ct_CC="$ac_prog"
5990	6183	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5991	6184	break 2

6181	6374	/* end confdefs.h. */
6182	6375	#include <stdarg.h>
6183	6376	#include <stdio.h>
6184		#include <sys/types.h>
6185		#include <sys/stat.h>
	6377	struct stat;
6186	6378	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
6187	6379	struct buf { int x; };
6188	6380	FILE * (rcsopen) (struct buf , struct stat *, int);

6460	6652	ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6461	6653	ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6462	6654	if test -n "$ac_tool_prefix"; then
6463		for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
	6655	for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
6464	6656	do
6465	6657	# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
6466	6658	set dummy $ac_tool_prefix$ac_prog; ac_word=$2

6478	6670	IFS=$as_save_IFS
6479	6671	test -z "$as_dir" && as_dir=.
6480	6672	for ac_exec_ext in '' $ac_executable_extensions; do
6481		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	6673	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6482	6674	ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
6483	6675	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6484	6676	break 2

6504	6696	fi
6505	6697	if test -z "$FC"; then
6506	6698	ac_ct_FC=$FC
6507		for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
	6699	for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
6508	6700	do
6509	6701	# Extract the first word of "$ac_prog", so it can be a program name with args.
6510	6702	set dummy $ac_prog; ac_word=$2

6522	6714	IFS=$as_save_IFS
6523	6715	test -z "$as_dir" && as_dir=.
6524	6716	for ac_exec_ext in '' $ac_executable_extensions; do
6525		if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
	6717	if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6526	6718	ac_cv_prog_ac_ct_FC="$ac_prog"
6527	6719	$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6528	6720	break 2

6655	6847	fi
6656	6848	fi
6657	6849
	6850	if test $ac_compiler_gnu = yes; then
	6851	GFC=yes
	6852	else
	6853	GFC=
	6854	fi
6658	6855	ac_ext=c
6659	6856	ac_cpp='$CPP $CPPFLAGS'
6660	6857	ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6661	6858	ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6662	6859	ac_compiler_gnu=$ac_cv_c_compiler_gnu
	6860
	6861	# Make sure we can run config.sub.
	6862	$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 \|\|
	6863	as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
	6864
	6865	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
	6866	$as_echo_n "checking build system type... " >&6; }
	6867	if ${ac_cv_build+:} false; then :
	6868	$as_echo_n "(cached) " >&6
	6869	else
	6870	ac_build_alias=$build_alias
	6871	test "x$ac_build_alias" = x &&
	6872	ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
	6873	test "x$ac_build_alias" = x &&
	6874	as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
	6875	ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` \|\|
	6876	as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
	6877
	6878	fi
	6879	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
	6880	$as_echo "$ac_cv_build" >&6; }
	6881	case $ac_cv_build in
	6882	--*) ;;
	6883	*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
	6884	esac
	6885	build=$ac_cv_build
	6886	ac_save_IFS=$IFS; IFS='-'
	6887	set x $ac_cv_build
	6888	shift
	6889	build_cpu=$1
	6890	build_vendor=$2
	6891	shift; shift
	6892	# Remember, the first character of IFS is used to create $*,
	6893	# except with old shells:
	6894	build_os=$*
	6895	IFS=$ac_save_IFS
	6896	case $build_os in \ ) build_os=`echo "$build_os" \| sed 's/ /-/g'`;; esac
	6897
	6898
	6899	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
	6900	$as_echo_n "checking host system type... " >&6; }
	6901	if ${ac_cv_host+:} false; then :
	6902	$as_echo_n "(cached) " >&6
	6903	else
	6904	if test "x$host_alias" = x; then
	6905	ac_cv_host=$ac_cv_build
	6906	else
	6907	ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` \|\|
	6908	as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
	6909	fi
	6910
	6911	fi
	6912	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
	6913	$as_echo "$ac_cv_host" >&6; }
	6914	case $ac_cv_host in
	6915	--*) ;;
	6916	*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
	6917	esac
	6918	host=$ac_cv_host
	6919	ac_save_IFS=$IFS; IFS='-'
	6920	set x $ac_cv_host
	6921	shift
	6922	host_cpu=$1
	6923	host_vendor=$2
	6924	shift; shift
	6925	# Remember, the first character of IFS is used to create $*,
	6926	# except with old shells:
	6927	host_os=$*
	6928	IFS=$ac_save_IFS
	6929	case $host_os in \ ) host_os=`echo "$host_os" \| sed 's/ /-/g'`;; esac
	6930
6663	6931
6664	6932
6665	6933	ac_ext=${ac_fc_srcext-f}

6716	6984	# that detects unbalanced quotes in FLIBS should be implemented
6717	6985	# and (ugh) tested at some point.
6718	6986	case $ac_fc_v_output in
6719		# If we are using xlf then replace all the commas with spaces.
	6987	# With xlf replace commas with spaces,
	6988	# and remove "-link" and closing parenthesis.
6720	6989	xlfentry)
6721		ac_fc_v_output=`echo $ac_fc_v_output \| sed 's/,/ /g'` ;;
	6990	ac_fc_v_output=`echo $ac_fc_v_output \|
	6991	sed '
	6992	s/,/ /g
	6993	s/ -link / /g
	6994	s/) *$//
	6995	'
	6996	` ;;
6722	6997
6723	6998	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6724	6999	# $LIBS confuse us, and the libraries appear later in the output anyway).

6733	7008	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
6734	7009	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
6735	7010	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
	7011
	7012	# If we are using fort77 (the f2c wrapper) then filter output and delete quotes.
	7013	fort77f2cgcc)
	7014	ac_fc_v_output=`echo "$ac_fc_v_output" \| sed -n '
	7015	/:[ ]\+Running[ ]\{1,\}"gcc"/{
	7016	/"-c"/d
	7017	/[.]c"*/d
	7018	s/^.*"gcc"/"gcc"/
	7019	s/"//gp
	7020	}'` ;;
6736	7021
6737	7022	# If we are using Cray Fortran then delete quotes.
6738	7023	cft90)

6807	7092	# that detects unbalanced quotes in FLIBS should be implemented
6808	7093	# and (ugh) tested at some point.
6809	7094	case $ac_fc_v_output in
6810		# If we are using xlf then replace all the commas with spaces.
	7095	# With xlf replace commas with spaces,
	7096	# and remove "-link" and closing parenthesis.
6811	7097	xlfentry)
6812		ac_fc_v_output=`echo $ac_fc_v_output \| sed 's/,/ /g'` ;;
	7098	ac_fc_v_output=`echo $ac_fc_v_output \|
	7099	sed '
	7100	s/,/ /g
	7101	s/ -link / /g
	7102	s/) *$//
	7103	'
	7104	` ;;
6813	7105
6814	7106	# With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6815	7107	# $LIBS confuse us, and the libraries appear later in the output anyway).

6824	7116	s/-cmdline '[^']'/ /g; s/-cmdline \"[^\"]\"/ /g
6825	7117	s/-ignore '[^']'/ /g; s/-ignore \"[^\"]\"/ /g
6826	7118	s/-def '[^']'/ /g; s/-def \"[^\"]\"/ /g"` ;;
	7119
	7120	# If we are using fort77 (the f2c wrapper) then filter output and delete quotes.
	7121	fort77f2cgcc)
	7122	ac_fc_v_output=`echo "$ac_fc_v_output" \| sed -n '
	7123	/:[ ]\+Running[ ]\{1,\}"gcc"/{
	7124	/"-c"/d
	7125	/[.]c"*/d
	7126	s/^.*"gcc"/"gcc"/
	7127	s/"//gp
	7128	}'` ;;
6827	7129
6828	7130	# If we are using Cray Fortran then delete quotes.
6829	7131	cft90)

6883	7185	\|-LANG:=* \| -LIST:* \| -LNO:* \| -link)
6884	7186	;;
6885	7187	-lkernel32)
6886		test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
	7188	case $host_os in
	7189	cygwin) ;;
	7190	*) ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
	7191	;;
	7192	esac
6887	7193	;;
6888	7194	-[LRuYz])
6889	7195	# These flags, when seen by themselves, take an argument.

7669	7975	as_fn_error $? "conditional \"CppAD_OPENMP\" was never defined.
7670	7976	Usually this means the macro was only invoked conditionally." "$LINENO" 5
7671	7977	fi
	7978	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
	7979	$as_echo_n "checking that generated files are newer than configure... " >&6; }
	7980	if test -n "$am_sleep_pid"; then
	7981	# Hide warnings about reused PIDs.
	7982	wait $am_sleep_pid 2>/dev/null
	7983	fi
	7984	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
	7985	$as_echo "done" >&6; }
7672	7986	if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
7673	7987	as_fn_error $? "conditional \"AMDEP\" was never defined.
7674	7988	Usually this means the macro was only invoked conditionally." "$LINENO" 5

7999	8313	# ... but there are two gotchas:
8000	8314	# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
8001	8315	# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
8002		# In both cases, we have to default to `cp -p'.
	8316	# In both cases, we have to default to `cp -pR'.
8003	8317	ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe \|\|
8004		as_ln_s='cp -p'
	8318	as_ln_s='cp -pR'
8005	8319	elif ln conf$$.file conf$$ 2>/dev/null; then
8006	8320	as_ln_s=ln
8007	8321	else
8008		as_ln_s='cp -p'
	8322	as_ln_s='cp -pR'
8009	8323	fi
8010	8324	else
8011		as_ln_s='cp -p'
	8325	as_ln_s='cp -pR'
8012	8326	fi
8013	8327	rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
8014	8328	rmdir conf$$.dir 2>/dev/null

8068	8382	as_mkdir_p=false
8069	8383	fi
8070	8384
8071		if test -x / >/dev/null 2>&1; then
8072		as_test_x='test -x'
8073		else
8074		if ls -dL / >/dev/null 2>&1; then
8075		as_ls_L_option=L
8076		else
8077		as_ls_L_option=
8078		fi
8079		as_test_x='
8080		eval sh -c '\''
8081		if test -d "$1"; then
8082		test -d "$1/.";
8083		else
8084		case $1 in #(
8085		-*)set "./$1";;
8086		esac;
8087		case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
8088		???[sx]):;;)false;;esac;fi
8089		'\'' sh
8090		'
8091		fi
8092		as_executable_p=$as_test_x
	8385
	8386	# as_fn_executable_p FILE
	8387	# -----------------------
	8388	# Test if FILE is an executable regular file.
	8389	as_fn_executable_p ()
	8390	{
	8391	test -f "$1" && test -x "$1"
	8392	} # as_fn_executable_p
	8393	as_test_x='test -x'
	8394	as_executable_p=as_fn_executable_p
8093	8395
8094	8396	# Sed expression to map a string onto a valid CPP name.
8095	8397	as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

8110	8412	# report actual input values of CONFIG_FILES etc. instead of their
8111	8413	# values after options handling.
8112	8414	ac_log="
8113		This file was extended by cppad $as_me 20140000.3, which was
8114		generated by GNU Autoconf 2.68. Invocation command line was
	8415	This file was extended by cppad $as_me 20150000.0, which was
	8416	generated by GNU Autoconf 2.69. Invocation command line was
8115	8417
8116	8418	CONFIG_FILES = $CONFIG_FILES
8117	8419	CONFIG_HEADERS = $CONFIG_HEADERS

8167	8469	cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
8168	8470	ac_cs_config="`$as_echo "$ac_configure_args" \| sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
8169	8471	ac_cs_version="\\
8170		cppad config.status 20140000.3
8171		configured by $0, generated by GNU Autoconf 2.68,
	8472	cppad config.status 20150000.0
	8473	configured by $0, generated by GNU Autoconf 2.69,
8172	8474	with options \\"\$ac_cs_config\\"
8173	8475
8174		Copyright (C) 2010 Free Software Foundation, Inc.
	8476	Copyright (C) 2012 Free Software Foundation, Inc.
8175	8477	This config.status script is free software; the Free Software Foundation
8176	8478	gives unlimited permission to copy, distribute and modify it."
8177	8479

8251	8553	_ACEOF
8252	8554	cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
8253	8555	if \$ac_cs_recheck; then
8254		set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
	8556	set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
8255	8557	shift
8256	8558	\$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
8257	8559	CONFIG_SHELL='$SHELL'

8763	9065
8764	9066	case $ac_file$ac_mode in
8765	9067	"depfiles":C) test x"$AMDEP_TRUE" != x"" \|\| {
8766		# Autoconf 2.62 quotes --file arguments for eval, but not when files
	9068	# Older Autoconf quotes --file arguments for eval, but not when files
8767	9069	# are listed without --file. Let's play safe and only enable the eval
8768	9070	# if we detect the quoting.
8769	9071	case $CONFIG_FILES in

8776	9078	# Strip MF so we end up with the name of the file.
8777	9079	mf=`echo "$mf" \| sed -e 's/:.*$//'`
8778	9080	# Check whether this is an Automake generated Makefile or not.
8779		# We used to match only the files named `Makefile.in', but
	9081	# We used to match only the files named 'Makefile.in', but
8780	9082	# some people rename them; so instead we look at the file content.
8781	9083	# Grep'ing the first line is not enough: some people post-process
8782	9084	# each Makefile.in and add a new line on top of each file to say so.

8810	9112	continue
8811	9113	fi
8812	9114	# Extract the definition of DEPDIR, am__include, and am__quote
8813		# from the Makefile without running `make'.
	9115	# from the Makefile without running 'make'.
8814	9116	DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
8815	9117	test -z "$DEPDIR" && continue
8816	9118	am__include=`sed -n 's/^am__include = //p' < "$mf"`
8817		test -z "am__include" && continue
	9119	test -z "$am__include" && continue
8818	9120	am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
8819		# When using ansi2knr, U may be empty or an underscore; expand it
8820		U=`sed -n 's/^U = //p' < "$mf"`
8821	9121	# Find all dependency output files, they are included files with
8822	9122	# $(DEPDIR) in their names. We invoke sed twice because it is the
8823	9123	# simplest approach to changing $(DEPDIR) to its actual value in the
8824	9124	# expansion.
8825	9125	for file in `sed -n "
8826	9126	s/^$am__include $am__quote$.(DEPDIR).$$am__quote"'$/\1/p' <"$mf" \| \
8827		sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
	9127	sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
8828	9128	# Make sure the directory exists.
8829	9129	test -f "$dirpart/$file" && continue
8830	9130	fdir=`$as_dirname -- "$file" \|\|

+16

-10

configure.ac less more

0		dnl $Id: configure.ac 3099 2014-02-18 03:29:44Z bradbell $
	0	dnl $Id: configure.ac 3509 2014-12-27 20:38:37Z bradbell $
1	1	dnl ---------------------------------------------------------------------------
2	2	dnl CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	dnl

11	11	dnl
12	12	dnl Process this file with autoconf to produce a configure script.
13	13	dnl package version bug-report
14		AC_INIT(cppad, 20140000.3, cppad@list.coin-or.org)
	14	AC_INIT([cppad], [20150000.0], [cppad@list.coin-or.org])
15	15	AM_SILENT_RULES([yes])
16	16
17	17	dnl By defalut disable maintainer mode when running configure;

31	31	AC_CHECK_PROG(have_pkg_config, [pkg-config], [yes], [no])
32	32	AM_CONDITIONAL(CppAD_PKG_CONFIG, test "$have_pkg_config" = "yes")
33	33
34		AC_CHECK_PROG(have_ar, [ar], [yes], [no])
35		AM_CONDITIONAL(CppAD_HAVE_AR, test "$have_ar" = "yes")
36		if test "$have_ar" = "no"; then
	34	AM_PROG_AR()
	35	AM_CONDITIONAL(CppAD_HAVE_AR, test "$AR" = "ar")
	36	if test "$AR" != "ar"; then
37	37	AC_MSG_WARN(
38		[cannot build any libraries because ar is missing, speed/* is not used]
	38	[cannot build any libraries because ar is missing; e.g,, speed/* not built]
39	39	)
40	40	fi
41	41

435	435	fi
436	436	AC_MSG_NOTICE([******** End Checking Command Line arguments *************])
437	437
	438	dnl auto-tools version does not support ColPack coloring
	439	AC_SUBST(cppad_has_colpack, 0)
	440
438	441	dnl auto-tools version cannot use c++11 compiler
439	442	dnl so supress corresponding features
440	443	AC_SUBST(cppad_has_nullptr, 0)
	444	AC_SUBST(cppad_has_rvalue, 0)
	445	AC_SUBST(cppad_has_cstdint_8_to_64, 0)
	446	AC_SUBST(cppad_compiler_has_erf, 0)
441	447
442	448	dnl Determine if size_t has same size as unsigned int
443	449	AC_CHECK_SIZEOF([size_t])
444	450	AC_CHECK_SIZEOF([unsigned int])
445	451	if test "$ac_cv_size_t" == "$ac_cv_unsigned_int" ; then
446		AC_SUBST(cppad_size_t_same_unsigned_int, 1)
447		else
448		AC_SUBST(cppad_size_t_same_unsigned_int, 0)
	452	AC_SUBST(cppad_size_t_not_unsigned_int, 1)
	453	else
	454	AC_SUBST(cppad_size_t_not_unsigned_int, 0)
449	455	fi
450	456
451	457	dnl Determine which definition we are using for CPPAD_TESTVECTOR

469	475
470	476	dnl Run any macros required for proper operation of generated makefiles
471	477	dnl nostdinc: Do not define standard include directories in generated makefiles
472		AM_INIT_AUTOMAKE(nostdinc)
	478	AM_INIT_AUTOMAKE([nostdinc subdir-objects -Wall])
473	479
474	480	dnl Use LIBTOOL for cppad_ipopt ?
475	481	dnl AC_PROG_LIBTOOL

+85

-13

cppad/CMakeLists.txt less more

0		#CppAD $Id: CMakeLists.txt 3064 2013-12-28 18:01:30Z bradbell $
1		# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	0	# $Id: CMakeLists.txt 3495 2014-12-24 01:16:15Z bradbell $
	1	# -----------------------------------------------------------------------------
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

105	105	ENDIF( cppad_eigenvector )
106	106
107	107	# -----------------------------------------------------------------------------
	108	# cppad_has_rvalue
	109	#
	110	# CHECK_CXX_SOURCE_RUNS(source variable)
	111	SET(CMAKE_REQUIRED_INCLUDES "")
	112	SET(CMAKE_REQUIRED_LIBRARIES "")
	113	SET(CMAKE_REQUIRED_FLAGS ${cppad_cxx_flags})
	114	SET(source "
	115	int main(void)
	116	{ int&& value = 1 + 2;
	117	if( value != 3 )
	118	return 1;
	119	return 0;
	120	}" )
	121	CHECK_CXX_SOURCE_RUNS("${source}" rvalue_ok)
	122	IF( rvalue_ok )
	123	SET(cppad_has_rvalue 1)
	124	ELSE( rvalue_ok )
	125	SET(cppad_has_rvalue 0)
	126	ENDIF( rvalue_ok )
	127	MESSAGE(STATUS "cppad_has_rvalue = ${cppad_has_rvalue}" )
	128	# -----------------------------------------------------------------------------
108	129	# cppad_has_nullptr
109	130	#
110	131	# CHECK_CXX_SOURCE_RUNS(source variable)

130	151	# CHECK_CXX_SOURCE_RUNS(source variable)
131	152	SET(CMAKE_REQUIRED_INCLUDES "")
132	153	SET(CMAKE_REQUIRED_LIBRARIES "")
133		SET(CMAKE_REQUIRED_FLAGS "")
	154	SET(CMAKE_REQUIRED_FLAGS ${cppad_cxx_flags})
134	155	SET(source "
135	156	# include<sys/time.h>
136	157	int main(void)

146	167	ENDIF( gettimeofday_ok )
147	168	MESSAGE(STATUS "cppad_has_gettimeofday = ${cppad_has_gettimeofday}" )
148	169	# -----------------------------------------------------------------------------
149		# cppad_size_t_same_unsigned_int
150		#
151		# CHECK_CXX_SOURCE_RUNS(source variable)
152		SET(CMAKE_REQUIRED_INCLUDES "")
153		SET(CMAKE_REQUIRED_LIBRARIES "")
154		SET(CMAKE_REQUIRED_FLAGS "")
	170	# cppad_size_t_not_unsigned_int
	171	#
	172	# CHECK_CXX_SOURCE_RUNS(source variable)
	173	SET(CMAKE_REQUIRED_INCLUDES "")
	174	SET(CMAKE_REQUIRED_LIBRARIES "")
	175	SET(CMAKE_REQUIRED_FLAGS ${cppad_cxx_flags})
155	176	SET(source "
156	177	# include <cstring>
157	178	template <class T> inline bool is_pod(void) { return false; }

162	183	" )
163	184	CHECK_CXX_SOURCE_RUNS("${source}" size_t_not_unsigned_int)
164	185	IF( size_t_not_unsigned_int )
165		SET(cppad_size_t_same_unsigned_int 0)
	186	SET(cppad_size_t_not_unsigned_int 1)
166	187	ELSE( size_t_not_unsigned_int )
167		SET(cppad_size_t_same_unsigned_int 1)
	188	SET(cppad_size_t_not_unsigned_int 0)
168	189	ENDIF( size_t_not_unsigned_int )
169	190	MESSAGE(STATUS
170		"cppad_size_t_same_unsigned_int = ${cppad_size_t_same_unsigned_int}"
	191	"cppad_size_t_not_unsigned_int = ${cppad_size_t_not_unsigned_int}"
	192	)
	193	# -----------------------------------------------------------------------------
	194	# cppad_has_cstdint_8_to_64
	195	#
	196	# CHECK_CXX_SOURCE_RUNS(source variable)
	197	SET(CMAKE_REQUIRED_INCLUDES "")
	198	SET(CMAKE_REQUIRED_LIBRARIES "")
	199	SET(CMAKE_REQUIRED_FLAGS ${cppad_cxx_flags})
	200	SET(source "
	201	# include <cstdint>
	202	template <class T> inline bool is_pod(void) { return false; }
	203	template <> inline bool is_pod<uint8_t>(void) { return true; }
	204	template <> inline bool is_pod<uint16_t>(void) { return true; }
	205	template <> inline bool is_pod<uint32_t>(void) { return true; }
	206	template <> inline bool is_pod<uint64_t>(void) { return true; }
	207	int main(void)
	208	{ return 0; }
	209	" )
	210	CHECK_CXX_SOURCE_RUNS("${source}" has_cstdint_8_to_64)
	211	IF( has_cstdint_8_to_64 )
	212	SET(cppad_has_cstdint_8_to_64 1)
	213	ELSE( has_cstdint_8_to_64 )
	214	SET(cppad_has_cstdint_8_to_64 0)
	215	ENDIF( has_cstdint_8_to_64 )
	216	MESSAGE(STATUS
	217	"cppad_has_cstdint_8_to_64 = ${cppad_has_cstdint_8_to_64}"
	218	)
	219	# -----------------------------------------------------------------------------
	220	# cppad_compiler_has_erf
	221	#
	222	# CHECK_CXX_SOURCE_RUNS(source variable)
	223	SET(CMAKE_REQUIRED_INCLUDES "")
	224	SET(CMAKE_REQUIRED_LIBRARIES "")
	225	SET(CMAKE_REQUIRED_FLAGS ${cppad_cxx_flags})
	226	SET(source "
	227	# include <cmath>
	228	int main(void)
	229	{ if( std::erf(0.0) == 0.0 )
	230	return 0;
	231	return 1;
	232	}
	233	" )
	234	CHECK_CXX_SOURCE_RUNS("${source}" has_error_function)
	235	IF( has_error_function )
	236	SET(cppad_compiler_has_erf 1)
	237	ELSE( has_error_function )
	238	SET(cppad_compiler_has_erf 0)
	239	ENDIF( has_error_function )
	240	MESSAGE(STATUS
	241	"has_error_function = ${has_error_function}"
	242	"cppad_compiler_has_erf = ${cppad_compiler_has_erf}"
171	243	)
172	244	# -----------------------------------------------------------------------------
173	245	# cppad_tape_addr_type, cppad_tape_id_type

-2

cppad/base_require.hpp less more

0		// $Id: base_require.hpp 3062 2013-12-28 10:40:48Z bradbell $
	0	// $Id: base_require.hpp 3495 2014-12-24 01:16:15Z bradbell $
1	1	# ifndef CPPAD_BASE_REQUIRE_INCLUDED
2	2	# define CPPAD_BASE_REQUIRE_INCLUDED
3	3

45	45	Op
46	46	std
47	47	CondExp
48		erf
49	48	$$
50	49
51	50	$index Base, require$$

+32

-9

cppad/configure.hpp.in less more

0		/* $Id: configure.hpp.in 3064 2013-12-28 18:01:30Z bradbell $ */
	0	// $Id: configure.hpp.in 3495 2014-12-24 01:16:15Z bradbell $
1	1	# ifndef CPPAD_CONFIGURE_INCLUDED
2	2	# define CPPAD_CONFIGURE_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

33	33	*/
34	34
35	35	/*!
36		\defgroup configure_hpp configure.hpp
37		\{
38	36	\file configure.hpp
39	37	Replacement for config.h so that all preprocessor symbols begin with CPPAD_
40	38	*/
	39
	40	/*!
	41	\def CPPAD_HAS_RVALUE
	42	Does this compiler cupport c++11 rvalues; i.e., values with move semantics
	43	*/
	44	# define CPPAD_HAS_RVALUE @cppad_has_rvalue@
41	45
42	46	/*!
43	47	\def CPPAD_PACKAGE_STRING
44	48	cppad-yyyymmdd as a C string where yyyy is year, mm is month, and dd is day.
45	49	*/
46	50	# define CPPAD_PACKAGE_STRING "cppad-@cppad_version@"
	51
	52	/*!
	53	def CPPAD_HAS_COLPACK
	54	Was a colpack_prefix specified on the cmake command line.
	55	*/
	56	# define CPPAD_HAS_COLPACK @cppad_has_colpack@
47	57
48	58	/*!
49	59	def CPPAD_HAS_NULLPTR

112	122	# define CPPAD_HAS_GETTIMEOFDAY @cppad_has_gettimeofday@
113	123
114	124	/*!
115		\def CPPAD_SIZE_T_SAME_UNSIGNED_INT
116		If this symbol is one, the type size_t is the same as the type unsigned int,
117		otherwise this symbol is zero.
	125	\def CPPAD_SIZE_T_NOT_UNSIGNED_INT
	126	If this symbol is zero, the type size_t is the same as the type unsigned int,
	127	otherwise this symbol is one.
118	128	*/
119		# define CPPAD_SIZE_T_SAME_UNSIGNED_INT @cppad_size_t_same_unsigned_int@
	129	# define CPPAD_SIZE_T_NOT_UNSIGNED_INT @cppad_size_t_not_unsigned_int@
	130
	131	/*!
	132	\def CPPAD_HAS_CSTDINT_8_TO_64
	133	If this symbol is one, the types uint_8, uint_16, uint_32, and uint_64
	134	are defined. otherwise this symbol is zero.
	135	*/
	136	# define CPPAD_HAS_CSTDINT_8_TO_64 @cppad_has_cstdint_8_to_64@
	137
	138	/*!
	139	\def CPPAD_COMPILER_HAS_ERF
	140	If this symbol is one, the function std::erf(double) is defined by the
	141	C++ compiler, otherwise the symbol is zero.
	142	*/
	143	# define CPPAD_COMPILER_HAS_ERF @cppad_compiler_has_erf@
120	144
121	145	/*!
122	146	\def CPPAD_TAPE_ADDR_TYPE

158	182	# define CPPAD_MAX_NUM_THREADS @cppad_max_num_threads@
159	183	# endif
160	184
161		/! \} /
162	185	# endif

-5

cppad/cppad.hpp less more

0		/* $Id: cppad.hpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: cppad.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_CPPAD_INCLUDED
2	2	# define CPPAD_CPPAD_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

11	11	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
12	12	-------------------------------------------------------------------------- */
13	13	/*!
14		\defgroup cppad_hpp cppad.hpp
15		\{
16	14	\file cppad.hpp
17	15	\brief includes the entire CppAD package in the necessary order.
18	16

95	93	// undo definitions in Define.h
96	94	# include <cppad/local/undef.hpp>
97	95
98		/! \} /
99	96	# endif

-5

cppad/elapsed_seconds.hpp less more

0		/* $Id: elapsed_seconds.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: elapsed_seconds.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_ELAPSED_SECONDS_INCLUDED
2	2	# define CPPAD_ELAPSED_SECONDS_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

85	85	# include <cppad/thread_alloc.hpp>
86	86	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
87	87	/*!
88		\defgroup elapsed_seconds_hpp elapsed_seconds.hpp
89		\{
90	88	\file elapsed_seconds.hpp
91	89	\brief Function that returns the elapsed seconds from first call.
92	90	*/

147	145	}
148	146	# endif
149	147
150		/! \} /
151	148	} // END_CPPAD_NAMESPACE
152	149	# endif

+23

-1

cppad/example/base_adolc.hpp less more

0		/* $Id: base_adolc.hpp 2939 2013-10-14 11:06:18Z bradbell $ */
	0	/* $Id: base_adolc.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_BASE_ADOLC_INCLUDED
2	2	# define CPPAD_BASE_ADOLC_INCLUDED
3	3	/* --------------------------------------------------------------------------

13	13	/*
14	14	$begin base_adolc.hpp$$
15	15	$spell
	16	erf
16	17	ifndef
17	18	define
18	19	endif

213	214	$code sqrt$$,
214	215	$code tan$$.
215	216
	217	$head erf$$
	218	If the error function is supported by the compiler,
	219	it must also be supported by a $icode Base$$ type;
	220	see $cref/erf/base_std_math/erf/$$.
	221	The adolc package does not support this function:
	222	$codep */
	223	namespace CppAD {
	224	# if CPPAD_COMPILER_HAS_ERF
	225	inline adouble erf(const adouble& x)
	226	{ CPPAD_ASSERT_KNOWN(
	227	false,
	228	"erf: adolc does not support the error function"
	229	);
	230	return 0;
	231	}
	232	# endif
	233	}
	234	/* $$
	235
	236
	237
216	238	$head sign$$
217	239	This $cref/required/base_require/$$ function is defined using the
218	240	$code codassign$$ function so that its $code adouble$$ operation sequence

-1

cppad/example/cppad_eigen.hpp less more

0		/* $Id: cppad_eigen.hpp 3067 2013-12-29 17:35:34Z bradbell $ */
	0	/* $Id: cppad_eigen.hpp 3065 2013-12-29 14:03:45Z bradbell $ */
1	1	# ifndef CPPAD_CPPAD_EIGEN_INCLUDED
2	2	# define CPPAD_CPPAD_EIGEN_INCLUDED
3	3	/* --------------------------------------------------------------------------

-5

cppad/index_sort.hpp less more

0		/* $Id: index_sort.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: index_sort.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_INDEX_SORT_INCLUDED
2	2	# define CPPAD_INDEX_SORT_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

81	81
82	82	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
83	83	/*!
84		\defgroup index_sort_hpp index_sort.hpp
85		\{
86	84	\file index_sort.hpp
87	85	File used to implement the CppAD index sort utility
88	86	*/

174	172	return;
175	173	}
176	174
177		/! \} /
178	175	} // END_CPPAD_NAMESPACE
179	176
180	177	# endif

-5

cppad/ipopt/solve.hpp less more

0		/* $Id: solve.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: solve.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_SOLVE_INCLUDED
2	2	# define CPPAD_SOLVE_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

406	406	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
407	407	namespace ipopt {
408	408	/*!
409		\defgroup solve_hpp solve.hpp
410		\{
411	409	\file solve.hpp
412	410	\brief Implement the ipopt::solve Nonlinear Programming Solver
413	411	*/

639	637	return;
640	638	}
641	639
642		/! \} /
643	640	} // end ipopt namespace
644	641	} // END_CPPAD_NAMESPACE
645	642	# endif

-9

cppad/ipopt/solve_callback.hpp less more

0		/* $Id: solve_callback.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
1		# ifndef CPPAD_SOLVE_FULL_INCLUDED
2		# define CPPAD_SOLVE_FULL_INCLUDED
	0	/* $Id: solve_callback.hpp 3275 2014-05-20 17:35:11Z bradbell $ */
	1	# ifndef CPPAD_SOLVE_CALLBACK_INCLUDED
	2	# define CPPAD_SOLVE_CALLBACK_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

18	18
19	19	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
20	20	namespace ipopt {
21		/*
22		\defgroup solve_callback solve_callback.hpp
23		\{
	21	/*!
24	22	\file solve_callback.hpp
25	23	\brief Class that connects ipopt::solve to Ipopt
26	24	*/

118	116	// Hessian information
119	117	// ----------------------------------------------------------------------
120	118	/// Sparsity pattern for Hessian of Lagragian
121		/// \f[ L(x) = \sigma \sum_i f_i (x) + \sum_i \lambad_i g_i (x) \f]
	119	/// \f[ L(x) = \sigma \sum_i f_i (x) + \sum_i \lambda_i g_i (x) \f]
122	120	/// If sparse is true, this pattern set by constructor and does not change.
123	121	/// Otherwise this vector has size zero.
124	122	CppAD::vector< std::set<size_t> > pattern_hes_;

1109	1107	}
1110	1108	};
1111	1109
1112		/! \} /
1113	1110	} // end namespace ipopt
1114	1111	} // END_CPPAD_NAMESPACE
1115	1112

-6

cppad/ipopt/solve_result.hpp less more

0		/* $Id: solve_result.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: solve_result.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_SOLVE_RESULT_INCLUDED
2	2	# define CPPAD_SOLVE_RESULT_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

13	13
14	14	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
15	15	namespace ipopt {
16		/*
17		\defgroup solve_result solve_result.hpp
18		\{
	16	/*!
19	17	\file solve_result.hpp
20	18	Class that contains information about solve problem result
21	19	*/

68	66	{ status = not_defined; }
69	67	};
70	68
71		/! \} /
72	69	} // end namespace ipopt
73	70	} // END_CPPAD_NAMESPACE
74	71

+51

-22

cppad/local/abs_op.hpp less more

0		/* $Id: abs_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: abs_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_ABS_OP_INCLUDED
2	2	# define CPPAD_ABS_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup abs_op_hpp abs_op.hpp
19		\{
20	18	\file abs_op.hpp
21	19	Forward and reverse mode calculations for z = abs(x).
22	20	*/

33	31	*/
34	32	template <class Base>
35	33	inline void forward_abs_op(
	34	size_t p ,
36	35	size_t q ,
37		size_t p ,
38	36	size_t i_z ,
39	37	size_t i_x ,
40		size_t nc_taylor ,
	38	size_t cap_order ,
41	39	Base* taylor )
42	40	{
43	41	// check assumptions
44	42	CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
45	43	CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
46		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
47		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
48		CPPAD_ASSERT_UNKNOWN( q <= p );
	44	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	45	CPPAD_ASSERT_UNKNOWN( p <= q );
49	46
50	47	// Taylor coefficients corresponding to argument and result
51		Base* x = taylor + i_x * nc_taylor;
52		Base* z = taylor + i_z * nc_taylor;
	48	Base* x = taylor + i_x * cap_order;
	49	Base* z = taylor + i_z * cap_order;
53	50
54		for(size_t j = q; j <= p; j++)
	51	for(size_t j = p; j <= q; j++)
55	52	z[j] = sign(x[0]) * x[j];
	53	}
	54
	55	/*!
	56	Multiple directions forward mode Taylor coefficient for op = AbsOp.
	57
	58	The C++ source code corresponding to this operation is
	59	\verbatim
	60	z = abs(x)
	61	\endverbatim
	62
	63	\copydetails forward_unary1_op_dir
	64	*/
	65	template <class Base>
	66	inline void forward_abs_op_dir(
	67	size_t q ,
	68	size_t r ,
	69	size_t i_z ,
	70	size_t i_x ,
	71	size_t cap_order ,
	72	Base* taylor )
	73	{
	74	// check assumptions
	75	CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
	76	CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
	77	CPPAD_ASSERT_UNKNOWN( 0 < q );
	78	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	79
	80	// Taylor coefficients corresponding to argument and result
	81	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	82	Base* x = taylor + i_x * num_taylor_per_var;
	83	Base* z = taylor + i_z * num_taylor_per_var;
	84
	85	size_t m = (q-1) * r + 1;
	86	for(size_t ell = 0; ell < r; ell++)
	87	z[m + ell] = sign(x[0]) * x[m + ell];
56	88	}
57	89
58	90	/*!

69	101	inline void forward_abs_op_0(
70	102	size_t i_z ,
71	103	size_t i_x ,
72		size_t nc_taylor ,
	104	size_t cap_order ,
73	105	Base* taylor )
74	106	{
75	107
76	108	// check assumptions
77	109	CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
78	110	CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
79		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
80		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	111	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
81	112
82	113	// Taylor coefficients corresponding to argument and result
83		Base x0 = (taylor + i_x nc_taylor);
84		Base* z = taylor + i_z * nc_taylor;
	114	Base x0 = (taylor + i_x cap_order);
	115	Base* z = taylor + i_z * cap_order;
85	116
86	117	z[0] = abs(x0);
87	118	}

101	132	size_t d ,
102	133	size_t i_z ,
103	134	size_t i_x ,
104		size_t nc_taylor ,
	135	size_t cap_order ,
105	136	const Base* taylor ,
106	137	size_t nc_partial ,
107	138	Base* partial )

110	141	// check assumptions
111	142	CPPAD_ASSERT_UNKNOWN( NumArg(AbsOp) == 1 );
112	143	CPPAD_ASSERT_UNKNOWN( NumRes(AbsOp) == 1 );
113		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
114		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	144	CPPAD_ASSERT_UNKNOWN( d < cap_order );
115	145	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
116	146
117	147	// Taylor coefficients and partials corresponding to argument
118		const Base* x = taylor + i_x * nc_taylor;
	148	const Base* x = taylor + i_x * cap_order;
119	149	Base* px = partial + i_x * nc_partial;
120	150
121	151	// Taylor coefficients and partials corresponding to result

125	155	px[j] += sign(x[0]) * pz[j];
126	156	}
127	157
128		/! \} /
129	158	} // END_CPPAD_NAMESPACE
130	159	# endif

+77

-30

cppad/local/acos_op.hpp less more

0		/* $Id: acos_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: acos_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_ACOS_OP_INCLUDED
2	2	# define CPPAD_ACOS_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup acos_op_hpp acos_op.hpp
19		\{
20	18	\file acos_op.hpp
21	19	Forward and reverse mode calculations for z = acos(x).
22	20	*/

40	38	*/
41	39	template <class Base>
42	40	inline void forward_acos_op(
	41	size_t p ,
43	42	size_t q ,
44		size_t p ,
45	43	size_t i_z ,
46	44	size_t i_x ,
47		size_t nc_taylor ,
	45	size_t cap_order ,
48	46	Base* taylor )
49	47	{
50	48	// check assumptions
51	49	CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
52	50	CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
53		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
54		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
55		CPPAD_ASSERT_UNKNOWN( q <= p );
	51	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	52	CPPAD_ASSERT_UNKNOWN( p <= q );
56	53
57	54	// Taylor coefficients corresponding to argument and result
58		Base* x = taylor + i_x * nc_taylor;
59		Base* z = taylor + i_z * nc_taylor;
60		Base* b = z - nc_taylor; // called y in documentation
	55	Base* x = taylor + i_x * cap_order;
	56	Base* z = taylor + i_z * cap_order;
	57	Base* b = z - cap_order; // called y in documentation
61	58
62	59	size_t k;
63	60	Base uj;
64		if( q == 0 )
	61	if( p == 0 )
65	62	{ z[0] = acos( x[0] );
66	63	uj = Base(1) - x[0] * x[0];
67	64	b[0] = sqrt( uj );
68		q++;
69		}
70		for(size_t j = q; j <= p; j++)
71		{ uj = 0.;
	65	p++;
	66	}
	67	for(size_t j = p; j <= q; j++)
	68	{ uj = Base(0);
72	69	for(k = 0; k <= j; k++)
73	70	uj -= x[k] * x[j-k];
74	71	b[j] = Base(0);

87	84	z[j] /= b[0];
88	85	}
89	86	}
	87	/*!
	88	Multiple directions forward mode Taylor coefficient for op = AcosOp.
	89
	90	The C++ source code corresponding to this operation is
	91	\verbatim
	92	z = acos(x)
	93	\endverbatim
	94	The auxillary result is
	95	\verbatim
	96	y = sqrt(1 - x * x)
	97	\endverbatim
	98	The value of y, and its derivatives, are computed along with the value
	99	and derivatives of z.
	100
	101	\copydetails forward_unary2_op_dir
	102	*/
	103	template <class Base>
	104	inline void forward_acos_op_dir(
	105	size_t q ,
	106	size_t r ,
	107	size_t i_z ,
	108	size_t i_x ,
	109	size_t cap_order ,
	110	Base* taylor )
	111	{
	112	// check assumptions
	113	CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
	114	CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
	115	CPPAD_ASSERT_UNKNOWN( 0 < q );
	116	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	117
	118	// Taylor coefficients corresponding to argument and result
	119	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	120	Base* x = taylor + i_x * num_taylor_per_var;
	121	Base* z = taylor + i_z * num_taylor_per_var;
	122	Base* b = z - num_taylor_per_var; // called y in documentation
	123
	124	size_t k, ell;
	125	size_t m = (q-1) * r + 1;
	126	for(ell = 0; ell < r; ell ++)
	127	{ Base uq = - 2.0 * x[m + ell] * x[0];
	128	for(k = 1; k < q; k++)
	129	uq -= x[(k-1)r+1+ell] x[(q-k-1)*r+1+ell];
	130	b[m+ell] = Base(0);
	131	z[m+ell] = Base(0);
	132	for(k = 1; k < q; k++)
	133	{ b[m+ell] += Base(k) * b[(k-1)r+1+ell] b[(q-k-1)*r+1+ell];
	134	z[m+ell] += Base(k) * z[(k-1)r+1+ell] b[(q-k-1)*r+1+ell];
	135	}
	136	b[m+ell] = ( uq / Base(2) - b[m+ell] / Base(q) ) / b[0];
	137	z[m+ell] = -( x[m+ell] + z[m+ell] / Base(q) ) / b[0];
	138	}
	139	}
90	140
91	141	/*!
92	142	Compute zero order forward mode Taylor coefficient for result of op = AcosOp.

107	157	inline void forward_acos_op_0(
108	158	size_t i_z ,
109	159	size_t i_x ,
110		size_t nc_taylor ,
	160	size_t cap_order ,
111	161	Base* taylor )
112	162	{
113	163	// check assumptions
114	164	CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
115	165	CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
116		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
117		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	166	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
118	167
119	168	// Taylor coefficients corresponding to argument and result
120		Base* x = taylor + i_x * nc_taylor;
121		Base* z = taylor + i_z * nc_taylor;
122		Base* b = z - nc_taylor; // called y in documentation
	169	Base* x = taylor + i_x * cap_order;
	170	Base* z = taylor + i_z * cap_order;
	171	Base* b = z - cap_order; // called y in documentation
123	172
124	173	z[0] = acos( x[0] );
125	174	b[0] = sqrt( Base(1) - x[0] * x[0] );

145	194	size_t d ,
146	195	size_t i_z ,
147	196	size_t i_x ,
148		size_t nc_taylor ,
	197	size_t cap_order ,
149	198	const Base* taylor ,
150	199	size_t nc_partial ,
151	200	Base* partial )

153	202	// check assumptions
154	203	CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
155	204	CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
156		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
157		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	205	CPPAD_ASSERT_UNKNOWN( d < cap_order );
158	206	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
159	207
160	208	// Taylor coefficients and partials corresponding to argument
161		const Base* x = taylor + i_x * nc_taylor;
	209	const Base* x = taylor + i_x * cap_order;
162	210	Base* px = partial + i_x * nc_partial;
163	211
164	212	// Taylor coefficients and partials corresponding to first result
165		const Base* z = taylor + i_z * nc_taylor;
	213	const Base* z = taylor + i_z * cap_order;
166	214	Base* pz = partial + i_z * nc_partial;
167	215
168	216	// Taylor coefficients and partials corresponding to auxillary result
169		const Base* b = z - nc_taylor; // called y in documentation
	217	const Base* b = z - cap_order; // called y in documentation
170	218	Base* pb = pz - nc_partial;
171	219
172	220	// number of indices to access

209	257	px[0] -= ( pz[0] + pb[0] * x[0]) / b[0];
210	258	}
211	259
212		/! \} /
213	260	} // END_CPPAD_NAMESPACE
214	261	# endif

-1

cppad/local/ad.hpp less more

0		/* $Id: ad.hpp 3064 2013-12-28 18:01:30Z bradbell $ */
	0	/* $Id: ad.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_AD_INCLUDED
2	2	# define CPPAD_AD_INCLUDED
3	3

204	204	inline AD sqrt(void) const;
205	205	inline AD tan(void) const;
206	206	inline AD tanh(void) const;
	207	# if CPPAD_COMPILER_HAS_ERF
	208	inline AD erf(void) const;
	209	# endif
207	210
208	211	// ----------------------------------------------------------
209	212	// static public member functions

-5

cppad/local/ad_assign.hpp less more

0		/* $Id: ad_assign.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: ad_assign.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_AD_ASSIGN_INCLUDED
2	2	# define CPPAD_AD_ASSIGN_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

68	68	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
69	69
70	70	/*!
71		\defgroup ad_assign_hpp ad_assign.hpp
72		\{
73	71	\file ad_assign.hpp
74	72	AD<Base> constructors and and copy operations.
75	73	*/

142	140	{ return *this = Base(t); }
143	141
144	142
145		/! \} /
146	143	} // END_CPPAD_NAMESPACE
147	144	# endif

-5

cppad/local/ad_ctor.hpp less more

0		/* $Id: ad_ctor.hpp 3064 2013-12-28 18:01:30Z bradbell $ */
	0	/* $Id: ad_ctor.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_AD_CTOR_INCLUDED
2	2	# define CPPAD_AD_CTOR_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

97	97	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
98	98
99	99	/*!
100		\defgroup ad_ctor_hpp ad_ctor.hpp
101		\{
102	100	\file ad_ctor.hpp
103	101	AD<Base> constructors and and copy operations.
104	102	*/

186	184	, taddr_(0)
187	185	{ }
188	186
189		/! \} /
190	187	} // END_CPPAD_NAMESPACE
191	188	# endif

+102

-149

cppad/local/ad_fun.hpp less more

0		/* $Id: ad_fun.hpp 2994 2013-10-23 15:47:20Z bradbell $ */
	0	/* $Id: ad_fun.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_AD_FUN_INCLUDED
2	2	# define CPPAD_AD_FUN_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

58	58
59	59	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
60	60	/*!
61		\defgroup ad_fun_hpp ad_fun.hpp
62		\{
63	61	\file ad_fun.hpp
64	62	File used to define the ADFun<Base> class.
65	63	*/

83	81	/// debug checking number of comparision operations that changed
84	82	size_t compare_change_;
85	83
86		/// number of taylor_ coefficieint per variable (currently stored)
87		size_t taylor_per_var_;
88
89		/// number of columns currently allocated for taylor_ array
90		size_t taylor_col_dim_;
91
92		/// number of rows (variables) in the recording (play_)
93		size_t total_num_var_;
	84	/// number of orders stored in taylor_
	85	size_t num_order_taylor_;
	86
	87	/// maximum number of orders that will fit in taylor_
	88	size_t cap_order_taylor_;
	89
	90	/// number of directions stored in taylor_
	91	size_t num_direction_taylor_;
	92
	93	/// number of variables in the recording (play_)
	94	size_t num_var_tape_;
94	95
95	96	/// tape address for the independent variables
96	97	CppAD::vector<size_t> ind_taddr_;

101	102	/// which dependent variables are actually parameters
102	103	CppAD::vector<bool> dep_parameter_;
103	104
	105	/// results of the forward mode calculations
	106	pod_vector<Base> taylor_;
	107
	108	/// which operations can be conditionally skipped
	109	/// Set during forward pass of order zero
	110	pod_vector<bool> cskip_op_;
	111
	112	/// Variable on the tape corresponding to each vecad load operation
	113	/// (if zero, the operation corresponds to a parameter).
	114	pod_vector<addr_t> load_op_;
	115
104	116	/// the operation sequence corresponding to this object
105	117	player<Base> play_;
106
107		/// results of the forward mode calculations
108		pod_vector<Base> taylor_;
109
110		/// which operations can be conditionally skipped
111		/// Set during forward pass of order zero
112		CppAD::vector<bool> cskip_op_;
113	118
114	119	/// Packed results of the forward mode Jacobian sparsity calculations.
115	120	/// for_jac_sparse_pack_.n_set() != 0 implies other sparsity results

195	200	// ------------------------------------------------------------
196	201	// Forward mode version of SparseJacobian
197	202	// (see doxygen in sparse_jacobian.hpp)
198		template <class VectorBase, class VectorSet>
	203	template <class VectorBase, class VectorSet, class VectorSize>
199	204	size_t SparseJacobianFor(
200		const VectorBase& x ,
201		VectorSet& p_transpose ,
202		VectorBase& jac ,
203		sparse_jacobian_work& work
	205	const VectorBase& x ,
	206	VectorSet& p_transpose ,
	207	const VectorSize& row ,
	208	const VectorSize& col ,
	209	VectorBase& jac ,
	210	sparse_jacobian_work& work
204	211	);
205	212	// Reverse mode version of SparseJacobian
206	213	// (see doxygen in sparse_jacobian.hpp)
207		template <class VectorBase, class VectorSet>
	214	template <class VectorBase, class VectorSet, class VectorSize>
208	215	size_t SparseJacobianRev(
209		const VectorBase& x ,
210		VectorSet& p ,
211		VectorBase& jac ,
212		sparse_jacobian_work& work
213		);
214		// ------------------------------------------------------------
215		// vector of bool version of SparseJacobian
216		// (see doxygen in sparse_jacobian.hpp)
217		template <class VectorBase, class VectorSet>
218		size_t SparseJacobianCase(
219		bool set_type ,
220		const VectorBase& x ,
221		const VectorSet& p ,
222		VectorBase& jac ,
223		sparse_jacobian_work& work
224		);
225		// vector of std::set<size_t> version of SparseJacobian
226		// (see doxygen in sparse_jacobian.hpp)
227		template <class VectorBase, class VectorSet>
228		size_t SparseJacobianCase(
229		const std::set<size_t>& set_type ,
230		const VectorBase& x ,
231		const VectorSet& p ,
232		VectorBase& jac ,
233		sparse_jacobian_work& work
234		);
235		// vector of bool version of SparseJacobian
236		// (see doxygen in sparse_jacobian.hpp)
237		template <class VectorBase, class VectorSet>
238		void SparseJacobianCase(
239		bool set_type ,
240		const VectorBase& x ,
241		const VectorSet& p ,
242		VectorBase& jac
243		);
244		// vector of std::set<size_t> version of SparseJacobian
245		// (see doxygen in sparse_jacobian.hpp)
246		template <class VectorBase, class VectorSet>
247		void SparseJacobianCase(
248		const std::set<size_t>& set_type ,
249		const VectorBase& x ,
250		const VectorSet& p ,
251		VectorBase& jac
	216	const VectorBase& x ,
	217	VectorSet& p ,
	218	const VectorSize& row ,
	219	const VectorSize& col ,
	220	VectorBase& jac ,
	221	sparse_jacobian_work& work
252	222	);
253	223	// ------------------------------------------------------------
254	224	// combined sparse_set, sparse_list and sparse_pack version of
255	225	// SparseHessian (see doxygen in sparse_hessian.hpp)
256		template <class VectorBase, class VectorSet>
	226	template <class VectorBase, class VectorSet, class VectorSize>
257	227	size_t SparseHessianCompute(
258		const VectorBase& x ,
259		const VectorBase& w ,
260		VectorSet& sparsity ,
261		VectorBase& hes ,
262		sparse_hessian_work& work
263		);
264		// vector of bool version of SparseHessian
265		// (see doxygen in sparse_hessian.hpp)
266		template <class VectorBase, class VectorSet>
267		size_t SparseHessianCase(
268		bool set_type ,
269		const VectorBase& x ,
270		const VectorBase& w ,
271		const VectorSet& p ,
272		VectorBase& hes ,
273		sparse_hessian_work& work
274		);
275		// vector of std::set<size_t> version of SparseHessian
276		// (see doxygen in sparse_hessian.hpp)
277		template <class VectorBase, class VectorSet>
278		size_t SparseHessianCase(
279		const std::set<size_t>& set_type ,
280		const VectorBase& x ,
281		const VectorBase& w ,
282		const VectorSet& p ,
283		VectorBase& hes ,
284		sparse_hessian_work& work
285		);
286		// vector of bool version of SparseHessian
287		// (see doxygen in sparse_hessian.hpp)
288		template <class VectorBase, class VectorSet>
289		void SparseHessianCase(
290		bool set_type ,
291		const VectorBase& x ,
292		const VectorBase& w ,
293		const VectorSet& p ,
294		VectorBase& hes
295		);
296		// vector of std::set<size_t> version of SparseHessian
297		// (see doxygen in sparse_hessian.hpp)
298		template <class VectorBase, class VectorSet>
299		void SparseHessianCase(
300		const std::set<size_t>& set_type ,
301		const VectorBase& x ,
302		const VectorBase& w ,
303		const VectorSet& p ,
304		VectorBase& hes
	228	const VectorBase& x ,
	229	const VectorBase& w ,
	230	VectorSet& sparsity ,
	231	const VectorSize& row ,
	232	const VectorSize& col ,
	233	VectorBase& hes ,
	234	sparse_hessian_work& work
305	235	);
306	236	// ------------------------------------------------------------
307	237	public:
308	238	/// copy constructor
309	239	ADFun(const ADFun& g)
310		: total_num_var_(0)
	240	: num_var_tape_(0)
311	241	{ CppAD::ErrorHandler::Call(
312	242	true,
313	243	__LINE__,

344	274	template <typename ADvector>
345	275	void Dependent(const ADvector &x, const ADvector &y);
346	276
347		/// forward mode sweep
348		template <typename VectorBase>
349		VectorBase Forward(
350		size_t p, const VectorBase& x, std::ostream& s = std::cout);
	277	/// forward mode user API, one order multiple directions.
	278	template <typename VectorBase>
	279	VectorBase Forward(size_t q, size_t r, const VectorBase& x);
	280
	281	/// forward mode user API, multiple directions one order.
	282	template <typename VectorBase>
	283	VectorBase Forward(size_t q,
	284	const VectorBase& x, std::ostream& s = std::cout
	285	);
351	286
352	287	/// reverse mode sweep
353	288	template <typename VectorBase>

401	336
402	337	/// number of operators in the operation sequence
403	338	size_t size_op(void) const
404		{ return play_.num_rec_op(); }
	339	{ return play_.num_op_rec(); }
405	340
406	341	/// number of operator arguments in the operation sequence
407	342	size_t size_op_arg(void) const
408		{ return play_.num_rec_op_arg(); }
	343	{ return play_.num_op_arg_rec(); }
409	344
410	345	/// amount of memory required for the operation sequence
411	346	size_t size_op_seq(void) const

413	348
414	349	/// number of parameters in the operation sequence
415	350	size_t size_par(void) const
416		{ return play_.num_rec_par(); }
417
418		/// number of taylor_ coefficients currently calculated (per variable)
419		size_t size_taylor(void) const
420		{ return taylor_per_var_; }
	351	{ return play_.num_par_rec(); }
	352
	353	/// number taylor coefficient orders calculated
	354	size_t size_order(void) const
	355	{ return num_order_taylor_; }
	356
	357	/// number taylor coefficient directions calculated
	358	size_t size_direction(void) const
	359	{ return num_direction_taylor_; }
421	360
422	361	/// number of characters in the operation sequence
423	362	size_t size_text(void) const
424		{ return play_.num_rec_text(); }
	363	{ return play_.num_text_rec(); }
425	364
426	365	/// number of variables in opertion sequence
427	366	size_t size_var(void) const
428		{ return total_num_var_; }
	367	{ return num_var_tape_; }
429	368
430	369	/// number of VecAD indices in the operation sequence
431	370	size_t size_VecAD(void) const
432		{ return play_.num_rec_vecad_ind(); }
433
434		/// set number of coefficients currently allocated (per variable)
435		void capacity_taylor(size_t per_var);
	371	{ return play_.num_vec_ind_rec(); }
	372
	373	/// set number of orders currently allocated (user API)
	374	void capacity_order(size_t c);
	375
	376	/// set number of orders and directions currently allocated
	377	void capacity_order(size_t c, size_t r);
436	378
437	379	/// number of variables in conditional expressions that can be skipped
438	380	size_t number_skip(void);

557	499	template <typename ADvector>
558	500	void Dependent(const ADvector &y);
559	501
560		/// deprecated: number of variables in opertion sequence
	502	/// Deprecated: number of variables in opertion sequence
561	503	size_t Size(void) const
562		{ return total_num_var_; }
563
564		/// deprecated: # taylor_ coefficients currently stored (per variable)
	504	{ return num_var_tape_; }
	505
	506	/// Deprecated: # taylor_ coefficients currently stored
	507	/// (per variable,direction)
565	508	size_t Order(void) const
566		{ return taylor_per_var_ - 1; }
	509	{ return num_order_taylor_ - 1; }
567	510
568	511	/// Deprecated: amount of memory for this object
569	512	/// Note that an approximation is used for the std::set<size_t> memory
570	513	size_t Memory(void) const
571		{ size_t pervar = taylor_col_dim_ * sizeof(Base)
	514	{ size_t pervar = cap_order_taylor_ * sizeof(Base)
572	515	+ for_jac_sparse_pack_.memory()
573	516	+ 3 * sizeof(size_t) * for_jac_sparse_set_.number_elements();
574		size_t total = total_num_var_ * pervar + play_.Memory();
	517	size_t total = num_var_tape_ * pervar + play_.Memory();
575	518	return total;
576	519	}
577	520
578		/// deprecated: # taylor_ coefficients stored (per variable)
	521	/// Deprecated: # taylor_ coefficient orderss stored
	522	/// (per variable,direction)
579	523	size_t taylor_size(void) const
580		{ return taylor_per_var_; }
581
582		/// deprecated: Does this AD operation sequence use
583		//VecAD<Base>::reference operands
	524	{ return num_order_taylor_; }
	525
	526	/// Deprecated: Does this AD operation sequence use
	527	/// VecAD<Base>::reference operands
584	528	bool use_VecAD(void) const
585		{ return play_.num_rec_vecad_ind() > 0; }
	529	{ return play_.num_vec_ind_rec() > 0; }
	530
	531	/// Deprecated: # taylor_ coefficient orders calculated
	532	/// (per variable,direction)
	533	size_t size_taylor(void) const
	534	{ return num_order_taylor_; }
	535
	536	/// Deprecated: set number of orders currently allocated
	537	/// (per variable,direction)
	538	void capacity_taylor(size_t per_var);
586	539	};
587	540	// ---------------------------------------------------------------------------
588	541
589		/! \} /
590	542	} // END_CPPAD_NAMESPACE
591	543
592	544	// non-user interfaces
593	545	# include <cppad/local/forward0sweep.hpp>
594		# include <cppad/local/forward_sweep.hpp>
	546	# include <cppad/local/forward1sweep.hpp>
	547	# include <cppad/local/forward2sweep.hpp>
595	548	# include <cppad/local/reverse_sweep.hpp>
596	549	# include <cppad/local/for_jac_sweep.hpp>
597	550	# include <cppad/local/rev_jac_sweep.hpp>

-5

cppad/local/ad_io.hpp less more

0		/* $Id: ad_io.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: ad_io.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_AD_IO_INCLUDED
2	2	# define CPPAD_AD_IO_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

164	164	*/
165	165	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
166	166	/*!
167		\defgroup ad_io_hpp ad_io.hpp
168		\{
169	167	\file ad_io.hpp
170	168	AD<Base> input and ouput stream operators.
171	169	*/

229	227	std::ostream& operator << (std::ostream &os, const VecAD_reference<Base> &x)
230	228	{ return (os << x.ADBase()); }
231	229
232		/! \} /
233	230	} // END_CPPAD_NAMESPACE
234	231	# endif

+12

-4

cppad/local/ad_tape.hpp less more

0		/* $Id: ad_tape.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: ad_tape.hpp 3153 2014-03-04 19:49:06Z bradbell $ */
1	1	# ifndef CPPAD_AD_TAPE_INCLUDED
2	2	# define CPPAD_AD_TAPE_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

155	155	\return
156	156	variable index (for this recording) correpsonding to the parameter.
157	157
158		\par Wish List
	158	\par 2DO
159	159	All these operates are preformed in \c Rec_, so we should
160	160	move this routine from <tt>ADTape<Base></tt> to <tt>recorder<Base></tt>.
161	161	*/

185	185	initial values for the <tt>VecAD<Base></tt> object
186	186	(values before it becomes a variable).
187	187
188		\par Wish List
	188	\return
	189	index of the start of this vector in the list of vector indices.
	190	The value for this vector index is the length of the vector.
	191	There are \c length indices following for this vector.
	192	The values for these vector indices are the corresponding
	193	parameter indices in the tape for the initial value of the corresponding
	194	vec_ad element.
	195
	196	\par 2DO
189	197	All these operates are preformed in \c Rec_, so we should
190	198	move this routine from <tt>ADTape<Base></tt> to <tt>recorder<Base></tt>.
191	199	*/

+157

-93

cppad/local/add_op.hpp less more

0		/* $Id: add_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: add_op.hpp 3321 2014-09-12 09:50:39Z bradbell $ */
1	1	# ifndef CPPAD_ADD_OP_INCLUDED
2	2	# define CPPAD_ADD_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup add_op_hpp add_op.hpp
18		\{
19	17	\file add_op.hpp
20	18	Forward and reverse mode calculations for z = x + y.
21	19	*/

37	35
38	36	template <class Base>
39	37	inline void forward_addvv_op(
	38	size_t p ,
40	39	size_t q ,
41		size_t p ,
42		size_t i_z ,
43		const addr_t* arg ,
44		const Base* parameter ,
45		size_t nc_taylor ,
46		Base* taylor )
47		{
48		// check assumptions
49		CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
50		CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
51		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
52		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
53		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
54		CPPAD_ASSERT_UNKNOWN( q <= p );
55
56		// Taylor coefficients corresponding to arguments and result
57		Base* x = taylor + arg[0] * nc_taylor;
58		Base* y = taylor + arg[1] * nc_taylor;
59		Base* z = taylor + i_z * nc_taylor;
60
61		for(size_t j = q; j <= p; j++)
	40	size_t i_z ,
	41	const addr_t* arg ,
	42	const Base* parameter ,
	43	size_t cap_order ,
	44	Base* taylor )
	45	{
	46	// check assumptions
	47	CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
	48	CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
	49	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	50	CPPAD_ASSERT_UNKNOWN( p <= q );
	51
	52	// Taylor coefficients corresponding to arguments and result
	53	Base* x = taylor + arg[0] * cap_order;
	54	Base* y = taylor + arg[1] * cap_order;
	55	Base* z = taylor + i_z * cap_order;
	56
	57	for(size_t j = p; j <= q; j++)
62	58	z[j] = x[j] + y[j];
63	59	}
64
65		/*!
66		Compute zero order forward mode Taylor coefficients for result of op = AddvvOp.
	60	/*!
	61	Multiple directions forward mode Taylor coefficients for op = AddvvOp.
67	62
68	63	The C++ source code corresponding to this operation is
69	64	\verbatim

73	68	this operations is for the case where both x and y are variables
74	69	and the argument \a parameter is not used.
75	70
76		\copydetails forward_binary_op_0
77		*/
78
79		template <class Base>
80		inline void forward_addvv_op_0(
81		size_t i_z ,
82		const addr_t* arg ,
83		const Base* parameter ,
84		size_t nc_taylor ,
85		Base* taylor )
86		{
87		// check assumptions
88		CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
89		CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
90		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
91		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
92
93		// Taylor coefficients corresponding to arguments and result
94		Base* x = taylor + arg[0] * nc_taylor;
95		Base* y = taylor + arg[1] * nc_taylor;
96		Base* z = taylor + i_z * nc_taylor;
97
98		z[0] = x[0] + y[0];
99		}
100
101		/*!
102		Compute reverse mode partial derivatives for result of op = AddvvOp.
	71	\copydetails forward_binary_op_dir
	72	*/
	73
	74	template <class Base>
	75	inline void forward_addvv_op_dir(
	76	size_t q ,
	77	size_t r ,
	78	size_t i_z ,
	79	const addr_t* arg ,
	80	const Base* parameter ,
	81	size_t cap_order ,
	82	Base* taylor )
	83	{
	84	// check assumptions
	85	CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
	86	CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
	87	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	88	CPPAD_ASSERT_UNKNOWN( 0 < q );
	89
	90	// Taylor coefficients corresponding to arguments and result
	91	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	92	Base* x = taylor + arg[0] * num_taylor_per_var;
	93	Base* y = taylor + arg[1] * num_taylor_per_var;
	94	Base* z = taylor + i_z * num_taylor_per_var;
	95
	96	size_t m = (q-1)*r + 1 ;
	97	for(size_t ell = 0; ell < r; ell++)
	98	z[m+ell] = x[m+ell] + y[m+ell];
	99	}
	100
	101	/*!
	102	Compute zero order forward mode Taylor coefficients for result of op = AddvvOp.
103	103
104	104	The C++ source code corresponding to this operation is
105	105	\verbatim

109	109	this operations is for the case where both x and y are variables
110	110	and the argument \a parameter is not used.
111	111
	112	\copydetails forward_binary_op_0
	113	*/
	114
	115	template <class Base>
	116	inline void forward_addvv_op_0(
	117	size_t i_z ,
	118	const addr_t* arg ,
	119	const Base* parameter ,
	120	size_t cap_order ,
	121	Base* taylor )
	122	{
	123	// check assumptions
	124	CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
	125	CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
	126
	127	// Taylor coefficients corresponding to arguments and result
	128	Base* x = taylor + arg[0] * cap_order;
	129	Base* y = taylor + arg[1] * cap_order;
	130	Base* z = taylor + i_z * cap_order;
	131
	132	z[0] = x[0] + y[0];
	133	}
	134
	135	/*!
	136	Compute reverse mode partial derivatives for result of op = AddvvOp.
	137
	138	The C++ source code corresponding to this operation is
	139	\verbatim
	140	z = x + y
	141	\endverbatim
	142	In the documentation below,
	143	this operations is for the case where both x and y are variables
	144	and the argument \a parameter is not used.
	145
112	146	\copydetails reverse_binary_op
113	147	*/
114	148

118	152	size_t i_z ,
119	153	const addr_t* arg ,
120	154	const Base* parameter ,
121		size_t nc_taylor ,
	155	size_t cap_order ,
122	156	const Base* taylor ,
123	157	size_t nc_partial ,
124	158	Base* partial )

126	160	// check assumptions
127	161	CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
128	162	CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
129		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
130		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
131		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	163	CPPAD_ASSERT_UNKNOWN( d < cap_order );
132	164	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
133	165
134	166	// Partial derivatives corresponding to arguments and result

158	190
159	191	\copydetails forward_binary_op
160	192	*/
161
162	193	template <class Base>
163	194	inline void forward_addpv_op(
	195	size_t p ,
164	196	size_t q ,
165		size_t p ,
166		size_t i_z ,
167		const addr_t* arg ,
168		const Base* parameter ,
169		size_t nc_taylor ,
	197	size_t i_z ,
	198	const addr_t* arg ,
	199	const Base* parameter ,
	200	size_t cap_order ,
170	201	Base* taylor )
171	202	{
172	203	// check assumptions
173	204	CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
174	205	CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
175		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
176		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
177		CPPAD_ASSERT_UNKNOWN( q <= p );
178
179		// Taylor coefficients corresponding to arguments and result
180		Base* y = taylor + arg[1] * nc_taylor;
181		Base* z = taylor + i_z * nc_taylor;
182
183		if( q == 0 )
	206	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	207	CPPAD_ASSERT_UNKNOWN( p <= q );
	208
	209	// Taylor coefficients corresponding to arguments and result
	210	Base* y = taylor + arg[1] * cap_order;
	211	Base* z = taylor + i_z * cap_order;
	212
	213	if( p == 0 )
184	214	{ // Paraemter value
185	215	Base x = parameter[ arg[0] ];
186	216	z[0] = x + y[0];
187		q++;
	217	p++;
188	218	}
189		for(size_t j = q; j <= p; j++)
	219	for(size_t j = p; j <= q; j++)
190	220	z[j] = y[j];
191	221	}
192	222	/*!
193		Compute zero order forward mode Taylor coefficient for result of op = AddpvOp.
	223	Multiple directions forward mode Taylor coefficients for op = AddpvOp.
194	224
195	225	The C++ source code corresponding to this operation is
196	226	\verbatim

199	229	In the documentation below,
200	230	this operations is for the case where x is a parameter and y is a variable.
201	231
202		\copydetails forward_binary_op_0
203		*/
204
205		template <class Base>
206		inline void forward_addpv_op_0(
207		size_t i_z ,
208		const addr_t* arg ,
209		const Base* parameter ,
210		size_t nc_taylor ,
	232	\copydetails forward_binary_op_dir
	233	*/
	234	template <class Base>
	235	inline void forward_addpv_op_dir(
	236	size_t q ,
	237	size_t r ,
	238	size_t i_z ,
	239	const addr_t* arg ,
	240	const Base* parameter ,
	241	size_t cap_order ,
211	242	Base* taylor )
212	243	{
213	244	// check assumptions
214	245	CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
215	246	CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
216		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
	247	CPPAD_ASSERT_UNKNOWN( 0 < q );
	248	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	249
	250	// Taylor coefficients corresponding to arguments and result
	251	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	252	size_t m = (q-1) * r + 1;
	253	Base* y = taylor + arg[1] * num_taylor_per_var + m;
	254	Base* z = taylor + i_z * num_taylor_per_var + m;
	255
	256	for(size_t ell = 0; ell < r; ell++)
	257	z[ell] = y[ell];
	258	}
	259	/*!
	260	Compute zero order forward mode Taylor coefficient for result of op = AddpvOp.
	261
	262	The C++ source code corresponding to this operation is
	263	\verbatim
	264	z = x + y
	265	\endverbatim
	266	In the documentation below,
	267	this operations is for the case where x is a parameter and y is a variable.
	268
	269	\copydetails forward_binary_op_0
	270	*/
	271
	272	template <class Base>
	273	inline void forward_addpv_op_0(
	274	size_t i_z ,
	275	const addr_t* arg ,
	276	const Base* parameter ,
	277	size_t cap_order ,
	278	Base* taylor )
	279	{
	280	// check assumptions
	281	CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
	282	CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
217	283
218	284	// Paraemter value
219	285	Base x = parameter[ arg[0] ];
220	286
221	287	// Taylor coefficients corresponding to arguments and result
222		Base* y = taylor + arg[1] * nc_taylor;
223		Base* z = taylor + i_z * nc_taylor;
	288	Base* y = taylor + arg[1] * cap_order;
	289	Base* z = taylor + i_z * cap_order;
224	290
225	291	z[0] = x + y[0];
226	292	}

244	310	size_t i_z ,
245	311	const addr_t* arg ,
246	312	const Base* parameter ,
247		size_t nc_taylor ,
	313	size_t cap_order ,
248	314	const Base* taylor ,
249	315	size_t nc_partial ,
250	316	Base* partial )

252	318	// check assumptions
253	319	CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
254	320	CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
255		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
256		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	321	CPPAD_ASSERT_UNKNOWN( d < cap_order );
257	322	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
258	323
259	324	// Partial derivatives corresponding to arguments and result

269	334	}
270	335
271	336
272		/! \} /
273	337	} // END_CPPAD_NAMESPACE
274	338	# endif

+77

-30

cppad/local/asin_op.hpp less more

0		/* $Id: asin_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: asin_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_ASIN_OP_INCLUDED
2	2	# define CPPAD_ASIN_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup asin_op_hpp asin_op.hpp
19		\{
20	18	\file asin_op.hpp
21	19	Forward and reverse mode calculations for z = asin(x).
22	20	*/

40	38	*/
41	39	template <class Base>
42	40	inline void forward_asin_op(
	41	size_t p ,
43	42	size_t q ,
44		size_t p ,
45	43	size_t i_z ,
46	44	size_t i_x ,
47		size_t nc_taylor ,
	45	size_t cap_order ,
48	46	Base* taylor )
49	47	{
50	48	// check assumptions
51	49	CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
52	50	CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
53		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
54		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
55		CPPAD_ASSERT_UNKNOWN( q <= p );
	51	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	52	CPPAD_ASSERT_UNKNOWN( p <= q );
56	53
57	54	// Taylor coefficients corresponding to argument and result
58		Base* x = taylor + i_x * nc_taylor;
59		Base* z = taylor + i_z * nc_taylor;
60		Base* b = z - nc_taylor; // called y in documentation
	55	Base* x = taylor + i_x * cap_order;
	56	Base* z = taylor + i_z * cap_order;
	57	Base* b = z - cap_order; // called y in documentation
61	58
62	59	size_t k;
63	60	Base uj;
64		if( q == 0 )
	61	if( p == 0 )
65	62	{ z[0] = asin( x[0] );
66	63	uj = Base(1) - x[0] * x[0];
67	64	b[0] = sqrt( uj );
68		q++;
69		}
70		for(size_t j = q; j <= p; j++)
71		{ uj = 0.;
	65	p++;
	66	}
	67	for(size_t j = p; j <= q; j++)
	68	{ uj = Base(0);
72	69	for(k = 0; k <= j; k++)
73	70	uj -= x[k] * x[j-k];
74	71	b[j] = Base(0);

87	84	z[j] /= b[0];
88	85	}
89	86	}
	87	/*!
	88	Multiple directions forward mode Taylor coefficient for op = AsinOp.
	89
	90	The C++ source code corresponding to this operation is
	91	\verbatim
	92	z = asin(x)
	93	\endverbatim
	94	The auxillary result is
	95	\verbatim
	96	y = sqrt(1 - x * x)
	97	\endverbatim
	98	The value of y, and its derivatives, are computed along with the value
	99	and derivatives of z.
	100
	101	\copydetails forward_unary2_op_dir
	102	*/
	103	template <class Base>
	104	inline void forward_asin_op_dir(
	105	size_t q ,
	106	size_t r ,
	107	size_t i_z ,
	108	size_t i_x ,
	109	size_t cap_order ,
	110	Base* taylor )
	111	{
	112	// check assumptions
	113	CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
	114	CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
	115	CPPAD_ASSERT_UNKNOWN( 0 < q );
	116	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	117
	118	// Taylor coefficients corresponding to argument and result
	119	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	120	Base* x = taylor + i_x * num_taylor_per_var;
	121	Base* z = taylor + i_z * num_taylor_per_var;
	122	Base* b = z - num_taylor_per_var; // called y in documentation
	123
	124	size_t k, ell;
	125	size_t m = (q-1) * r + 1;
	126	for(ell = 0; ell < r; ell ++)
	127	{ Base uq = - 2.0 * x[m + ell] * x[0];
	128	for(k = 1; k < q; k++)
	129	uq -= x[(k-1)r+1+ell] x[(q-k-1)*r+1+ell];
	130	b[m+ell] = Base(0);
	131	z[m+ell] = Base(0);
	132	for(k = 1; k < q; k++)
	133	{ b[m+ell] += Base(k) * b[(k-1)r+1+ell] b[(q-k-1)*r+1+ell];
	134	z[m+ell] += Base(k) * z[(k-1)r+1+ell] b[(q-k-1)*r+1+ell];
	135	}
	136	b[m+ell] = ( uq / Base(2) - b[m+ell] / Base(q) ) / b[0];
	137	z[m+ell] = ( x[m+ell] - z[m+ell] / Base(q) ) / b[0];
	138	}
	139	}
90	140
91	141	/*!
92	142	Compute zero order forward mode Taylor coefficient for result of op = AsinOp.

107	157	inline void forward_asin_op_0(
108	158	size_t i_z ,
109	159	size_t i_x ,
110		size_t nc_taylor ,
	160	size_t cap_order ,
111	161	Base* taylor )
112	162	{
113	163	// check assumptions
114	164	CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
115	165	CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
116		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
117		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	166	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
118	167
119	168	// Taylor coefficients corresponding to argument and result
120		Base* x = taylor + i_x * nc_taylor;
121		Base* z = taylor + i_z * nc_taylor;
122		Base* b = z - nc_taylor; // called y in documentation
	169	Base* x = taylor + i_x * cap_order;
	170	Base* z = taylor + i_z * cap_order;
	171	Base* b = z - cap_order; // called y in documentation
123	172
124	173	z[0] = asin( x[0] );
125	174	b[0] = sqrt( Base(1) - x[0] * x[0] );

145	194	size_t d ,
146	195	size_t i_z ,
147	196	size_t i_x ,
148		size_t nc_taylor ,
	197	size_t cap_order ,
149	198	const Base* taylor ,
150	199	size_t nc_partial ,
151	200	Base* partial )

153	202	// check assumptions
154	203	CPPAD_ASSERT_UNKNOWN( NumArg(AsinOp) == 1 );
155	204	CPPAD_ASSERT_UNKNOWN( NumRes(AsinOp) == 2 );
156		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
157		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	205	CPPAD_ASSERT_UNKNOWN( d < cap_order );
158	206	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
159	207
160	208	// Taylor coefficients and partials corresponding to argument
161		const Base* x = taylor + i_x * nc_taylor;
	209	const Base* x = taylor + i_x * cap_order;
162	210	Base* px = partial + i_x * nc_partial;
163	211
164	212	// Taylor coefficients and partials corresponding to first result
165		const Base* z = taylor + i_z * nc_taylor;
	213	const Base* z = taylor + i_z * cap_order;
166	214	Base* pz = partial + i_z * nc_partial;
167	215
168	216	// Taylor coefficients and partials corresponding to auxillary result
169		const Base* b = z - nc_taylor; // called y in documentation
	217	const Base* b = z - cap_order; // called y in documentation
170	218	Base* pb = pz - nc_partial;
171	219
172	220	// number of indices to access

209	257	px[0] += ( pz[0] - pb[0] * x[0]) / b[0];
210	258	}
211	259
212		/! \} /
213	260	} // END_CPPAD_NAMESPACE
214	261	# endif

-1

cppad/local/atan2.hpp less more

0		/* $Id: atan2.hpp 3085 2014-01-20 22:53:15Z bradbell $ */
	0	/* $Id: atan2.hpp 3083 2014-01-10 18:35:07Z bradbell $ */
1	1	# ifndef CPPAD_ATAN2_INCLUDED
2	2	# define CPPAD_ATAN2_INCLUDED
3	3

+72

-29

cppad/local/atan_op.hpp less more

0		/* $Id: atan_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: atan_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_ATAN_OP_INCLUDED
2	2	# define CPPAD_ATAN_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup atan_op_hpp atan_op.hpp
19		\{
20	18	\file atan_op.hpp
21	19	Forward and reverse mode calculations for z = atan(x).
22	20	*/

40	38	*/
41	39	template <class Base>
42	40	inline void forward_atan_op(
	41	size_t p ,
43	42	size_t q ,
44		size_t p ,
45	43	size_t i_z ,
46	44	size_t i_x ,
47		size_t nc_taylor ,
	45	size_t cap_order ,
48	46	Base* taylor )
49	47	{
50	48	// check assumptions
51	49	CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
52	50	CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
53		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
54		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
55		CPPAD_ASSERT_UNKNOWN( q <= p );
	51	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	52	CPPAD_ASSERT_UNKNOWN( p <= q );
56	53
57	54	// Taylor coefficients corresponding to argument and result
58		Base* x = taylor + i_x * nc_taylor;
59		Base* z = taylor + i_z * nc_taylor;
60		Base* b = z - nc_taylor; // called y in documentation
	55	Base* x = taylor + i_x * cap_order;
	56	Base* z = taylor + i_z * cap_order;
	57	Base* b = z - cap_order; // called y in documentation
61	58
62	59	size_t k;
63		if( q == 0 )
	60	if( p == 0 )
64	61	{ z[0] = atan( x[0] );
65	62	b[0] = Base(1) + x[0] * x[0];
66		q++;
67		}
68		for(size_t j = q; j <= p; j++)
	63	p++;
	64	}
	65	for(size_t j = p; j <= q; j++)
69	66	{
70	67	b[j] = Base(2) * x[0] * x[j];
71	68	z[j] = Base(0);

80	77	}
81	78
82	79	/*!
	80	Multiple direction Taylor coefficient for op = AtanOp.
	81
	82	The C++ source code corresponding to this operation is
	83	\verbatim
	84	z = atan(x)
	85	\endverbatim
	86	The auxillary result is
	87	\verbatim
	88	y = 1 + x * x
	89	\endverbatim
	90	The value of y, and its derivatives, are computed along with the value
	91	and derivatives of z.
	92
	93	\copydetails forward_unary2_op_dir
	94	*/
	95	template <class Base>
	96	inline void forward_atan_op_dir(
	97	size_t q ,
	98	size_t r ,
	99	size_t i_z ,
	100	size_t i_x ,
	101	size_t cap_order ,
	102	Base* taylor )
	103	{
	104	// check assumptions
	105	CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
	106	CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
	107	CPPAD_ASSERT_UNKNOWN( 0 < q );
	108	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	109
	110	// Taylor coefficients corresponding to argument and result
	111	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	112	Base* x = taylor + i_x * num_taylor_per_var;
	113	Base* z = taylor + i_z * num_taylor_per_var;
	114	Base* b = z - num_taylor_per_var; // called y in documentation
	115
	116	size_t m = (q-1) * r + 1;
	117	for(size_t ell = 0; ell < r; ell++)
	118	{ b[m+ell] = Base(2) * x[m+ell] * x[0];
	119	z[m+ell] = Base(q) * x[m+ell];
	120	for(size_t k = 1; k < q; k++)
	121	{ b[m+ell] += x[(k-1)r+1+ell] x[(q-k-1)*r+1+ell];
	122	z[m+ell] -= Base(k) * z[(k-1)r+1+ell] b[(q-k-1)*r+1+ell];
	123	}
	124	z[m+ell] /= ( Base(q) * b[0] );
	125	}
	126	}
	127
	128	/*!
83	129	Zero order forward mode Taylor coefficient for result of op = AtanOp.
84	130
85	131	The C++ source code corresponding to this operation is

98	144	inline void forward_atan_op_0(
99	145	size_t i_z ,
100	146	size_t i_x ,
101		size_t nc_taylor ,
	147	size_t cap_order ,
102	148	Base* taylor )
103	149	{
104	150	// check assumptions
105	151	CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
106	152	CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
107		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
108		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	153	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
109	154
110	155	// Taylor coefficients corresponding to argument and result
111		Base* x = taylor + i_x * nc_taylor;
112		Base* z = taylor + i_z * nc_taylor;
113		Base* b = z - nc_taylor; // called y in documentation
	156	Base* x = taylor + i_x * cap_order;
	157	Base* z = taylor + i_z * cap_order;
	158	Base* b = z - cap_order; // called y in documentation
114	159
115	160	z[0] = atan( x[0] );
116	161	b[0] = Base(1) + x[0] * x[0];

136	181	size_t d ,
137	182	size_t i_z ,
138	183	size_t i_x ,
139		size_t nc_taylor ,
	184	size_t cap_order ,
140	185	const Base* taylor ,
141	186	size_t nc_partial ,
142	187	Base* partial )

144	189	// check assumptions
145	190	CPPAD_ASSERT_UNKNOWN( NumArg(AtanOp) == 1 );
146	191	CPPAD_ASSERT_UNKNOWN( NumRes(AtanOp) == 2 );
147		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
148		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	192	CPPAD_ASSERT_UNKNOWN( d < cap_order );
149	193	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
150	194
151	195	// Taylor coefficients and partials corresponding to argument
152		const Base* x = taylor + i_x * nc_taylor;
	196	const Base* x = taylor + i_x * cap_order;
153	197	Base* px = partial + i_x * nc_partial;
154	198
155	199	// Taylor coefficients and partials corresponding to first result
156		const Base* z = taylor + i_z * nc_taylor;
	200	const Base* z = taylor + i_z * cap_order;
157	201	Base* pz = partial + i_z * nc_partial;
158	202
159	203	// Taylor coefficients and partials corresponding to auxillary result
160		const Base* b = z - nc_taylor; // called y in documentation
	204	const Base* b = z - cap_order; // called y in documentation
161	205	Base* pb = pz - nc_partial;
162	206
163	207	// number of indices to access

185	229	px[0] += pz[0] / b[0] + pb[0] * Base(2) * x[0];
186	230	}
187	231
188		/! \} /
189	232	} // END_CPPAD_NAMESPACE
190	233	# endif

+72

-75

cppad/local/atomic_base.hpp less more

0		/* $Id: atomic_base.hpp 3012 2013-11-27 22:00:48Z bradbell $ */
	0	/* $Id: atomic_base.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_ATOMIC_BASE_INCLUDED
2	2	# define CPPAD_ATOMIC_BASE_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

19	19
20	20	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
21	21	/*!
22		\defgroup atomic_base.hpp atomic_base.hpp
23		\{
24	22	\file atomic_base.hpp
25	23	Base class for atomic user operations.
26	24	*/

441	439	}
442	440	}
443	441	// Use zero order forward mode to compute values
444		size_t q = 0, p = 0;
	442	size_t p = 0, q = 0;
445	443	set_id(id);
446	444	# ifdef NDEBUG
447		forward(q, p, vx, vy, tx, ty);
	445	forward(p, q, vx, vy, tx, ty);
448	446	# else
449		ok = forward(q, p, vx, vy, tx, ty);
	447	ok = forward(p, q, vx, vy, tx, ty);
450	448	if( ! ok )
451	449	{ msg += afun_name() + ": ok is false for "
452	450	"zero order forward mode calculation.";

549	547
550	548
551	549	$head Syntax$$
552		$icode%ok% = %afun%.forward(%q%, %p%, %vx%, %vy%, %tx%, %ty%)%$$
	550	$icode%ok% = %afun%.forward(%p%, %q%, %vx%, %vy%, %tx%, %ty%)%$$
553	551
554	552	$head Purpose$$
555	553	This virtual function is used by $cref atomic_afun$$

562	560	$cref/atomic_user/atomic_ctor/atomic_user/$$ class.
563	561	It can just return $icode%ok% == false%$$
564	562	(and not compute anything) for values
565		of $icode%p% > 0%$$ that are greater than those used by your
	563	of $icode%q% > 0%$$ that are greater than those used by your
566	564	$cref/forward/Forward/$$ mode calculations.
	565
	566	$head p$$
	567	The argument $icode p$$ has prototype
	568	$codei%
	569	size_t %p%
	570	%$$
	571	It specifies the lowest order Taylor coefficient that we are evaluating.
	572	During calls to $cref atomic_afun$$, $icode%p% == 0%$$.
567	573
568	574	$head q$$
569	575	The argument $icode q$$ has prototype
570	576	$codei%
571	577	size_t %q%
572	578	%$$
573		It specifies the lowest order Taylor coefficient that we are evaluating.
	579	It specifies the highest order Taylor coefficient that we are evaluating.
574	580	During calls to $cref atomic_afun$$, $icode%q% == 0%$$.
575
576		$head p$$
577		The argument $icode p$$ has prototype
578		$codei%
579		size_t %p%
580		%$$
581		It specifies the highest order Taylor coefficient that we are evaluating.
582		During calls to $cref atomic_afun$$, $icode%p% == 0%$$.
583	581
584	582	$head vx$$
585	583	The $code forward$$ argument $icode vx$$ has prototype

589	587	The case $icode%vx%.size() > 0%$$ only occurs while evaluating a call to
590	588	$cref atomic_afun$$.
591	589	In this case,
592		$icode%q% == %p% == 0%$$,
	590	$icode%p% == %q% == 0%$$,
593	591	$icode%vx%.size() == %n%$$, and
594	592	for $latex j = 0 , \ldots , n-1$$,
595	593	$icode%vx%[%j%]%$$ is true if and only if

609	607	%$$
610	608	If $icode%vy%.size() == 0%$$, it should not be used.
611	609	Otherwise,
612		$icode%p% == 0%$$ and $icode%vy%.size() == %m%$$.
	610	$icode%q% == 0%$$ and $icode%vy%.size() == %m%$$.
613	611	The input values of the elements of $icode vy$$
614	612	are not specified (must not matter).
615	613	Upon return, for $latex j = 0 , \ldots , m-1$$,

622	620	$codei%
623	621	const CppAD::vector<%Base%>& %tx%
624	622	%$$
625		and $icode%tx%.size() == (%p%+1)*%n%$$.
626		For $latex j = 0 , \ldots , n-1$$ and $latex k = 0 , \ldots , p$$,
	623	and $icode%tx%.size() == (%q%+1)*%n%$$.
	624	For $latex j = 0 , \ldots , n-1$$ and $latex k = 0 , \ldots , q$$,
627	625	we use the Taylor coefficient notation
628	626	$latex \[
629	627	\begin{array}{rcl}
630		x_j^k & = & tx [ j * ( p + 1 ) + k ]
	628	x_j^k & = & tx [ j * ( q + 1 ) + k ]
631	629	\\
632		X_j (t) & = & x_j^0 + x_j^1 t^1 + \cdots + x_j^p t^p
	630	X_j (t) & = & x_j^0 + x_j^1 t^1 + \cdots + x_j^q t^q
633	631	\end{array}
634	632	\] $$
635	633	Note that superscripts represent an index for $latex x_j^k$$

645	643	$codei%
646	644	CppAD::vector<%Base%>& %ty%
647	645	%$$
648		and $icode%tx%.size() == (%p%+1)*%m%$$.
	646	and $icode%tx%.size() == (%q%+1)*%m%$$.
649	647	Upon return,
650		For $latex i = 0 , \ldots , m-1$$ and $latex k = 0 , \ldots , p$$,
	648	For $latex i = 0 , \ldots , m-1$$ and $latex k = 0 , \ldots , q$$,
651	649	$latex \[
652	650	\begin{array}{rcl}
653	651	Y_i (t) & = & f_i [ X(t) ]
654	652	\\
655		Y_i (t) & = & y_i^0 + y_i^1 t^1 + \cdots + y_i^p t^p + o ( t^p )
	653	Y_i (t) & = & y_i^0 + y_i^1 t^1 + \cdots + y_i^q t^q + o ( t^q )
656	654	\\
657		ty [ i * ( p + 1 ) + k ] & = & y_i^k
	655	ty [ i * ( q + 1 ) + k ] & = & y_i^k
658	656	\end{array}
659	657	\] $$
660		where $latex o( t^p ) / t^p \rightarrow 0$$ as $latex t \rightarrow 0$$.
	658	where $latex o( t^q ) / t^q \rightarrow 0$$ as $latex t \rightarrow 0$$.
661	659	Note that superscripts represent an index for $latex y_j^k$$
662	660	and an exponent for $latex t^k$$.
663	661	Also note that the Taylor coefficients for $latex Y(t)$$ correspond

665	663	$latex \[
666	664	y_j^k = \frac{1}{ k ! } Y_j^{(k)} (0)
667	665	\] $$
668		If $latex q > 0$$,
669		for $latex i = 0 , \ldots , m-1$$ and $latex k = 0 , \ldots , q-1$$,
	666	If $latex p > 0$$,
	667	for $latex i = 0 , \ldots , m-1$$ and $latex k = 0 , \ldots , p-1$$,
670	668	the input of $icode ty$$ satisfies
671	669	$latex \[
672		ty [ i * ( p + 1 ) + k ] = y_i^k
	670	ty [ i * ( q + 1 ) + k ] = y_i^k
673	671	\]$$
674	672	and hence the corresponding elements need not be recalculated.
675	673

678	676	Otherwise, it should be false.
679	677
680	678	$head Discussion$$
681		For example, suppose that $icode%p% == 2%$$,
	679	For example, suppose that $icode%q% == 2%$$,
682	680	and you know how to compute the function $latex f(x)$$,
683	681	its first derivative $latex f^{(1)} (x)$$,
684	682	and it component wise Hessian $latex f_i^{(2)} (x)$$.

704	702	\] $$
705	703	For $latex i = 0 , \ldots , m-1$$, and $latex k = 0 , 1 , 2$$,
706	704	$latex \[
707		ty [ i * (p + 1) + k ] = y_i^k
	705	ty [ i * (q + 1) + k ] = y_i^k
708	706	\] $$
709	707
710	708	$head Examples$$

732	730	/*!
733	731	Link from atomic_base to forward mode
734	732
	733	\param p [in]
	734	lowerest order for this forward mode calculation.
	735
735	736	\param q [in]
736		lowerest order for this forward mode calculation.
737
738		\param p [in]
739	737	highest order for this forward mode calculation.
740	738
741	739	\param vx [in]

753	751	See the forward mode in user's documentation for base_atomic
754	752	*/
755	753	virtual bool forward(
	754	size_t p ,
756	755	size_t q ,
757		size_t p ,
758	756	const vector<bool>& vx ,
759	757	vector<bool>& vy ,
760	758	const vector<Base>& tx ,

784	782	$$
785	783
786	784	$head Syntax$$
787		$icode%ok% = %afun%.reverse(%p%, %tx%, %ty%, %px%, %py%)%$$
	785	$icode%ok% = %afun%.reverse(%q%, %tx%, %ty%, %px%, %py%)%$$
788	786
789	787	$head Purpose$$
790	788	This function is used by $cref/reverse/Reverse/$$

797	795	$cref/atomic_user/atomic_ctor/atomic_user/$$ class.
798	796	It can just return $icode%ok% == false%$$
799	797	(and not compute anything) for values
800		of $icode p$$ that are greater than those used by your
	798	of $icode q$$ that are greater than those used by your
801	799	$cref/reverse/Reverse/$$ mode calculations.
802	800
803		$head p$$
804		The argument $icode p$$ has prototype
805		$codei%
806		size_t %p%
	801	$head q$$
	802	The argument $icode q$$ has prototype
	803	$codei%
	804	size_t %q%
807	805	%$$
808	806	It specifies the highest order Taylor coefficient that
809	807	computing the derivative of.

813	811	$codei%
814	812	const CppAD::vector<%Base%>& %tx%
815	813	%$$
816		and $icode%tx%.size() == (%p%+1)*%n%$$.
817		For $latex j = 0 , \ldots , n-1$$ and $latex k = 0 , \ldots , p$$,
	814	and $icode%tx%.size() == (%q%+1)*%n%$$.
	815	For $latex j = 0 , \ldots , n-1$$ and $latex k = 0 , \ldots , q$$,
818	816	we use the Taylor coefficient notation
819	817	$latex \[
820	818	\begin{array}{rcl}
821		x_j^k & = & tx [ j * ( p + 1 ) + k ]
	819	x_j^k & = & tx [ j * ( q + 1 ) + k ]
822	820	\\
823		X_j (t) & = & x_j^0 + x_j^1 t^1 + \cdots + x_j^p t^p
	821	X_j (t) & = & x_j^0 + x_j^1 t^1 + \cdots + x_j^q t^q
824	822	\end{array}
825	823	\] $$
826	824	Note that superscripts represent an index for $latex x_j^k$$

836	834	$codei%
837	835	const CppAD::vector<%Base%>& %ty%
838	836	%$$
839		and $icode%tx%.size() == (%p%+1)*%m%$$.
840		For $latex i = 0 , \ldots , m-1$$ and $latex k = 0 , \ldots , p$$,
	837	and $icode%tx%.size() == (%q%+1)*%m%$$.
	838	For $latex i = 0 , \ldots , m-1$$ and $latex k = 0 , \ldots , q$$,
841	839	we use the Taylor coefficient notation
842	840	$latex \[
843	841	\begin{array}{rcl}
844	842	Y_i (t) & = & f_i [ X(t) ]
845	843	\\
846		Y_i (t) & = & y_i^0 + y_i^1 t^1 + \cdots + y_i^p t^p + o ( t^p )
	844	Y_i (t) & = & y_i^0 + y_i^1 t^1 + \cdots + y_i^q t^q + o ( t^q )
847	845	\\
848		y_i^k & = & ty [ i * ( p + 1 ) + k ]
	846	y_i^k & = & ty [ i * ( q + 1 ) + k ]
849	847	\end{array}
850	848	\] $$
851		where $latex o( t^p ) / t^p \rightarrow 0$$ as $latex t \rightarrow 0$$.
	849	where $latex o( t^q ) / t^q \rightarrow 0$$ as $latex t \rightarrow 0$$.
852	850	Note that superscripts represent an index for $latex y_j^k$$
853	851	and an exponent for $latex t^k$$.
854	852	Also note that the Taylor coefficients for $latex Y(t)$$ correspond

859	857
860	858
861	859	$head F, G, H$$
862		We use the notation $latex \{ x_j^k \} \in B^{n \times (p+1)}$$ for
863		$latex \[
864		\{ x_j^k \W{:} j = 0 , \ldots , n-1, k = 0 , \ldots , p \}
	860	We use the notation $latex \{ x_j^k \} \in B^{n \times (q+1)}$$ for
	861	$latex \[
	862	\{ x_j^k \W{:} j = 0 , \ldots , n-1, k = 0 , \ldots , q \}
865	863	\]$$
866		We use the notation $latex \{ y_i^k \} \in B^{m \times (p+1)}$$ for
867		$latex \[
868		\{ y_i^k \W{:} i = 0 , \ldots , m-1, k = 0 , \ldots , p \}
	864	We use the notation $latex \{ y_i^k \} \in B^{m \times (q+1)}$$ for
	865	$latex \[
	866	\{ y_i^k \W{:} i = 0 , \ldots , m-1, k = 0 , \ldots , q \}
869	867	\]$$
870	868	We define the function
871		$latex F : B^{n \times (p+1)} \rightarrow B^{m \times (p+1)}$$ by
	869	$latex F : B^{n \times (q+1)} \rightarrow B^{m \times (q+1)}$$ by
872	870	$latex \[
873	871	y_i^k = F_i^k [ \{ x_j^k \} ]
874	872	\] $$
875		We use $latex G : B^{m \times (p+1)} \rightarrow B$$
	873	We use $latex G : B^{m \times (q+1)} \rightarrow B$$
876	874	to denote an arbitrary scalar valued function of $latex \{ y_i^k \}$$.
877		We use $latex H : B^{n \times (p+1)} \rightarrow B$$
	875	We use $latex H : B^{n \times (q+1)} \rightarrow B$$
878	876	defined by
879	877	$latex \[
880	878	H ( \{ x_j^k \} ) = G[ F( \{ x_j^k \} ) ]

885	883	$codei%
886	884	const CppAD::vector<%Base%>& %py%
887	885	%$$
888		and $icode%py%.size() == m * (%p%+1)%$$.
889		For $latex i = 0 , \ldots , m-1$$, $latex k = 0 , \ldots , p$$,
890		$latex \[
891		py[ i * (p + 1 ) + k ] = \partial G / \partial y_i^k
	886	and $icode%py%.size() == m * (%q%+1)%$$.
	887	For $latex i = 0 , \ldots , m-1$$, $latex k = 0 , \ldots , q$$,
	888	$latex \[
	889	py[ i * (q + 1 ) + k ] = \partial G / \partial y_i^k
892	890	\] $$
893	891
894	892	$subhead px$$

896	894	$codei%
897	895	CppAD::vector<%Base%>& %px%
898	896	%$$
899		and $icode%px%.size() == n * (%p%+1)%$$.
	897	and $icode%px%.size() == n * (%q%+1)%$$.
900	898	The input values of the elements of $icode px$$
901	899	are not specified (must not matter).
902	900	Upon return,
903		for $latex j = 0 , \ldots , n-1$$ and $latex \ell = 0 , \ldots , p$$,
	901	for $latex j = 0 , \ldots , n-1$$ and $latex \ell = 0 , \ldots , q$$,
904	902	$latex \[
905	903	\begin{array}{rcl}
906		px [ j * (p + 1) + \ell ] & = & \partial H / \partial x_j^\ell
	904	px [ j * (q + 1) + \ell ] & = & \partial H / \partial x_j^\ell
907	905	\\
908	906	& = &
909	907	( \partial G / \partial \{ y_i^k \} )
910	908	( \partial \{ y_i^k \} / \partial x_j^\ell )
911	909	\\
912	910	& = &
913		\sum_{i=0}^{m-1} \sum_{k=0}^p
	911	\sum_{i=0}^{m-1} \sum_{k=0}^q
914	912	( \partial G / \partial y_i^k ) ( \partial y_i^k / \partial x_j^\ell )
915	913	\\
916	914	& = &
917		\sum_{i=0}^{m-1} \sum_{k=\ell}^p
918		py[ i * (p + 1 ) + k ] ( \partial F_i^k / \partial x_j^\ell )
	915	\sum_{i=0}^{m-1} \sum_{k=\ell}^q
	916	py[ i * (q + 1 ) + k ] ( \partial F_i^k / \partial x_j^\ell )
919	917	\end{array}
920	918	\] $$
921	919	Note that we have used the fact that for $latex k < \ell$$,

951	949	/*!
952	950	Link from reverse mode sweep to users routine.
953	951
954		\param p [in]
	952	\param q [in]
955	953	highest order for this reverse mode calculation.
956	954
957	955	\param tx [in]

969	967	See atomic_reverse mode use documentation
970	968	*/
971	969	virtual bool reverse(
972		size_t p ,
	970	size_t q ,
973	971	const vector<Base>& tx ,
974	972	const vector<Base>& ty ,
975	973	vector<Base>& px ,

1511	1509	{ }
1512	1510	// ---------------------------------------------------------------------------
1513	1511	};
1514		/! \} /
1515	1512	} // END_CPPAD_NAMESPACE
1516	1513	# endif

+15

-1

cppad/local/base_complex.hpp less more

0		/* $Id: base_complex.hpp 2765 2013-03-03 15:48:35Z bradbell $ */
	0	/* $Id: base_complex.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_BASE_COMPLEX_INCLUDED
2	2	# define CPPAD_BASE_COMPLEX_INCLUDED
3	3	/* --------------------------------------------------------------------------

10	10	A copy of this license is included in the COPYING file of this distribution.
11	11	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
12	12	-------------------------------------------------------------------------- */
	13	# include <cppad/configure.hpp>
13	14	# include <limits>
14	15	# include <complex>
15	16

19	20	/*
20	21	$begin base_complex.hpp$$
21	22	$spell
	23	endif
22	24	eps
23	25	abs_geq
24	26	Rel

168	170	{ return std::abs(x) >= std::abs(y); }
169	171	}
170	172	/* $$
	173
	174	$head erf$$
	175	Complex types do not support the error function
	176	(use CPPAD_USER_MACRO define above).
	177	$codep */
	178	# if CPPAD_COMPILER_HAS_ERF
	179	namespace CppAD {
	180	CPPAD_USER_MACRO(erf)
	181	}
	182	# endif
	183	/* $$
	184
171	185
172	186	$head Integer$$
173	187	The implementation of this function must agree

-5

cppad/local/base_cond_exp.hpp less more

0		/* $Id: base_cond_exp.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: base_cond_exp.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_BASE_COND_EXP_INCLUDED
2	2	# define CPPAD_BASE_COND_EXP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

155	155	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
156	156
157	157	/*!
158		\defgroup base_cond_exp_hpp base_cond_exp.hpp
159		\{
160	158	\file base_cond_exp.hpp
161	159	CondExp operations that aid in meeting Base type requirements.
162	160	*/

281	279	return returnValue;
282	280	}
283	281
284		/! \} /
285	282	} // END_CPPAD_NAMESPACE
286	283	# endif

-1

cppad/local/base_double.hpp less more

0		/* $Id: base_double.hpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: base_double.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_BASE_DOUBLE_INCLUDED
2	2	# define CPPAD_BASE_DOUBLE_INCLUDED
3	3	/* --------------------------------------------------------------------------

10	10	A copy of this license is included in the COPYING file of this distribution.
11	11	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
12	12	-------------------------------------------------------------------------- */
	13	# include <cppad/configure.hpp>
13	14	# include <limits>
14	15
15	16	/*
16	17	$begin base_double.hpp$$
17	18	$spell
	19	erf
	20	endif
18	21	abs_geq
19	22	acos
20	23	asin

141	144	CPPAD_STANDARD_MATH_UNARY(double, sqrt)
142	145	CPPAD_STANDARD_MATH_UNARY(double, tan)
143	146	CPPAD_STANDARD_MATH_UNARY(double, tanh)
	147	# if CPPAD_COMPILER_HAS_ERF
	148	CPPAD_STANDARD_MATH_UNARY(double, erf)
	149	# endif
144	150	}
145	151	/* $$
146	152	The absolute value function is special because its $code std$$ name is

-1

cppad/local/base_float.hpp less more

0		/* $Id: base_float.hpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: base_float.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_BASE_FLOAT_INCLUDED
2	2	# define CPPAD_BASE_FLOAT_INCLUDED
3	3	/* --------------------------------------------------------------------------

10	10	A copy of this license is included in the COPYING file of this distribution.
11	11	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
12	12	-------------------------------------------------------------------------- */
	13	# include <cppad/configure.hpp>
13	14	# include <limits>
14	15
15	16	/*
16	17	$begin base_float.hpp$$
17	18	$spell
	19	erf
	20	endif
18	21	abs_geq
19	22	acos
20	23	asin

142	145	CPPAD_STANDARD_MATH_UNARY(float, sqrt)
143	146	CPPAD_STANDARD_MATH_UNARY(float, tan)
144	147	CPPAD_STANDARD_MATH_UNARY(float, tanh)
	148	# if CPPAD_COMPILER_HAS_ERF
	149	CPPAD_STANDARD_MATH_UNARY(float, erf)
	150	# endif
145	151	}
146	152	/* $$
147	153	The absolute value function is special because its $code std$$ name is

+21

-15

cppad/local/base_std_math.hpp less more

0		/* $Id: base_std_math.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: base_std_math.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_BASE_STD_MATH_INCLUDED
2	2	# define CPPAD_BASE_STD_MATH_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

29	29	const
30	30	CppAD
31	31	namespace
	32	erf
32	33	$$
33	34
34	35	$section Base Type Requirements for Standard Math Functions$$

87	88	For example,
88	89	$cref/float/base_float.hpp/Unary Standard Math/$$.
89	90
	91	$head erf$$
	92	$index erf, base require$$
	93	$index base, erf require$$
	94	$index require, base erf$$
	95	If the error function is supported by the compiler,
	96	$cref/CPPAD_COMPILER_HAS_ERF/erf/Method/CPPAD_COMPILER_HAS_ERF/$$
	97	is one,
	98	the type $icode Base$$ must support the syntax
	99	$codei%
	100	%y% = CppAD::erf(%x%)
	101	%$$
	102	where $icode x$$ and $icode y$$ have the same prototype as above.
	103	For example, see
	104	$cref/base_alloc/base_alloc.hpp/erf/$$.
	105
90	106	$head sign$$
91	107	$index sign, base require$$
92	108	$index base, sign require$$

97	113	%$$
98	114	which computes
99	115	$latex \[
100		z = \left\{ \begin{array}{ll}
	116	y = \left\{ \begin{array}{ll}
101	117	+1 & {\rm if} \; x > 0 \\
102	118	0 & {\rm if} \; x = 0 \\
103	119	-1 & {\rm if} \; x < 0
104	120	\end{array} \right.
105	121	\] $$
106		The arguments $icode x$$ has prototype
107		$codei%
108		const %Base%& %x%
109		%$$
110		and the return value $icode z$$ has prototype
111		$codei%
112		%Base% %z%
113		%$$
	122	where $icode x$$ and $icode y$$ have the same prototype as above.
114	123	For example, see
115	124	$cref/base_alloc/base_alloc.hpp/sign/$$.
116	125	Note that, if ordered comparisons are not defined for the type $icode Base$$,

182	191	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
183	192
184	193	/*!
185		\defgroup base_std_math_hpp base_std_math.hpp
186		\{
187	194	\file base_std_math.hpp
188	195	Defintions that aid meeting Base type requirements for standard math functions.
189	196	*/

198	205	using the corresponding function <code>std::Fun</code>.
199	206	*/
200	207	# define CPPAD_STANDARD_MATH_UNARY(Type, Fun) \
201		inline Type Fun(const Type& x) \
	208	inline Type Fun(const Type& x) \
202	209	{ return std::Fun(x); }
203	210
204		/! \} /
205	211	} // END_CPPAD_NAMESPACE
206	212
207	213	# endif

-7

cppad/local/bool_fun.hpp less more

0		/* $Id: bool_fun.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: bool_fun.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_BOOL_FUN_INCLUDED
2	2	# define CPPAD_BOOL_FUN_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

155	155
156	156	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
157	157	/*!
158		\defgroup bool_fun_hpp bool_fun.hpp
159		\{
160	158	\file bool_fun.hpp
161		Routines and macros that implement functions from AD<Base> to bool
162		\ref bool_fun_hpp.
	159	Routines and macros that implement functions from AD<Base> to bool.
163	160	*/
164	161
165	162	/*!

247	244	return FunName(x.value_, y.value_);
248	245	}
249	246
250		/! \} /
251	247	} // END_CPPAD_NAMESPACE
252	248	# endif

-167

~~cppad/local/cap_taylor.hpp~~ less more

0		/* $Id: cap_taylor.hpp 2506 2012-10-24 19:36:49Z bradbell $ */
1		# ifndef CPPAD_CAP_TAYLOR_INCLUDED
2		# define CPPAD_CAP_TAYLOR_INCLUDED
3
4		/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
6
7		CppAD is distributed under multiple licenses. This distribution is under
8		the terms of the
9		GNU General Public License Version 3.
10
11		A copy of this license is included in the COPYING file of this distribution.
12		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13		-------------------------------------------------------------------------- */
14
15		/*
16		$begin capacity_taylor$$
17		$spell
18		var
19		taylor_
20		$$
21
22		$index Forward, capacity$$
23		$index capacity_taylor$$
24		$index capacity, Forward$$
25		$index control, memory$$
26		$index memory, control$$
27
28		$section Controlling Taylor Coefficients Memory Allocation$$
29
30		$head Syntax$$
31		$icode%f%.capacity_taylor(%c%)%$$
32
33		$subhead See Also$$
34		$cref seq_property$$
35
36		$head Purpose$$
37		The Taylor coefficients calculated by $cref Forward$$ mode calculations
38		are retained in an $cref ADFun$$ object for subsequent use during
39		$cref Reverse$$ mode or higher order Forward mode calculations.
40		To be specific, a call to $cref/Forward/ForwardAny/$$ with the syntax
41		$codei%
42		%y_p% = %f%.Forward(%p%, %x_p%)
43		%$$
44		uses the lower order Taylor coefficients and
45		computes the $th p$$ order Taylor coefficients for all
46		the variables in the operation sequence corresponding to $icode f$$.
47		You can determine the number of variables in the operation sequence
48		using the $cref/size_var/seq_property/size_var/$$ function.
49		The $code capacity_taylor$$ operation allows you to control that
50		amount of memory that is retained by an AD function object
51		(to hold $code Forward$$ results for subsequent calculations).
52
53		$head f$$
54		The object $icode f$$ has prototype
55		$codei%
56		ADFun<%Base%> %f%
57		%$$
58
59		$head c$$
60		The argument $icode c$$ has prototype
61		$codei%
62		size_t %c%
63		%$$
64		It specifies the number of Taylor coefficients that are allocated for
65		each variable in the AD operation sequence corresponding to $icode f$$.
66
67
68		$subhead Pre-Allocating Memory$$
69		If you plan to make calls to $code Forward$$ with the maximum value of
70		$icode p$$ equal to $icode q$$,
71		it should be faster to pre-allocate memory for these calls using
72		$codei%
73		%f%.capacity_taylor(%c%)
74		%$$
75		with $icode c$$ equal to $latex q + 1$$.
76		If you do no do this, $code Forward$$ will automatically allocate memory
77		and will copy the results to a larger buffer, when necessary.
78		$pre
79
80		$$
81		Note that each call to $cref Dependent$$ frees the old memory
82		connected to the function object and sets the corresponding
83		taylor capacity to zero.
84
85		$subhead Freeing Memory$$
86		If you no longer need the Taylor coefficients of order $icode q$$
87		and higher (that are stored in $icode f$$),
88		you can reduce the memory allocated to $icode f$$ using
89		$codei%
90		%f%.capacity_taylor(%c%)
91		%$$
92		with $icode c$$ equal to $icode q$$.
93		Note that, if $cref ta_hold_memory$$ is true, this memory is not actually
94		returned to the system, but rather held for future use by the same thread.
95
96		$head Original State$$
97		If $icode f$$ is $cref/constructed/FunConstruct/$$ with the syntax
98		$codei%
99		ADFun<%Base%> %f%(%x%, %y%)
100		%$$,
101		there is an implicit call to $code Forward$$ with $icode p$$ equal to zero
102		and $icode x_p$$ equal to
103		the value of the
104		$cref/independent variables/glossary/Tape/Independent Variable/$$
105		when the AD operation sequence was recorded.
106
107		$children%
108		example/capacity_taylor.cpp
109		%$$
110		$head Example$$
111		The file
112		$cref capacity_taylor.cpp$$
113		contains an example and test of these operations.
114		It returns true if it succeeds and false otherwise.
115
116		$end
117		-----------------------------------------------------------------------------
118		*/
119
120		// BEGIN CppAD namespace
121		namespace CppAD {
122
123		template <typename Base>
124		void ADFun<Base>::capacity_taylor(size_t c)
125		{ // temporary indices
126		size_t i, j, p;
127
128		if( c == taylor_col_dim_ )
129		return;
130
131		if( c == 0 )
132		{ taylor_.free();
133		taylor_per_var_ = 0;
134		taylor_col_dim_ = 0;
135		return;
136		}
137
138		// Allocate new matrix with requested number of columns
139		size_t new_len = c * total_num_var_;
140		pod_vector<Base> new_taylor;
141		new_taylor.extend(new_len);
142
143		// number of columns to copy
144		p = std::min(taylor_per_var_, c);
145
146		// copy the old data into the new matrix
147		CPPAD_ASSERT_UNKNOWN( (taylor_per_var_ == 0) \| (taylor_.size() != 0) );
148		for(i = 0; i < total_num_var_; i++)
149		{ for(j = 0; j < p; j++)
150		{ new_taylor[i * c + j] = taylor_[i * taylor_col_dim_ + j];
151		}
152		}
153
154		// replace taylor_ by new_taylor
155		taylor_.swap(new_taylor);
156		taylor_col_dim_ = c;
157		taylor_per_var_ = p;
158
159		// note that the destructor for new_taylor will free the old taylor memory
160		return;
161		}
162
163		} // END CppAD namespace
164
165
166		# endif

+264

-0

cppad/local/capacity_order.hpp less more

	0	/* $Id: capacity_order.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
	1	# ifndef CPPAD_CAPACITY_ORDER_INCLUDED
	2	# define CPPAD_CAPACITY_ORDER_INCLUDED
	3
	4	/* --------------------------------------------------------------------------
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	6
	7	CppAD is distributed under multiple licenses. This distribution is under
	8	the terms of the
	9	GNU General Public License Version 3.
	10
	11	A copy of this license is included in the COPYING file of this distribution.
	12	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	13	-------------------------------------------------------------------------- */
	14
	15	/*
	16	$begin capacity_order$$
	17	$spell
	18	var
	19	taylor_
	20	xq
	21	yq
	22	$$
	23
	24	$index Forward, capacity$$
	25	$index capacity_order$$
	26	$index capacity, Forward$$
	27	$index control, memory$$
	28	$index memory, control$$
	29
	30	$section Controlling Taylor Coefficients Memory Allocation$$
	31
	32	$head Syntax$$
	33	$icode%f%.capacity_order(%c%)%$$
	34
	35	$subhead See Also$$
	36	$cref seq_property$$
	37
	38	$head Purpose$$
	39	The Taylor coefficients calculated by $cref Forward$$ mode calculations
	40	are retained in an $cref ADFun$$ object for subsequent use during
	41	$cref Reverse$$ mode and higher order Forward mode calculations.
	42	For example, a call to $cref/Forward/forward_order/$$ with the syntax
	43	$codei%
	44	%yq% = %f%.Forward(%q%, %xq%)
	45	%$$
	46	where $icode%q% > 0%$$ and $code%xq%.size() == %f%.Domain()%$$,
	47	uses the lower order Taylor coefficients and
	48	computes the $th q$$ order Taylor coefficients for all
	49	the variables in the operation sequence corresponding to $icode f$$.
	50	The $code capacity_order$$ operation allows you to control that
	51	amount of memory that is retained by an AD function object
	52	(to hold $code Forward$$ results for subsequent calculations).
	53
	54	$head f$$
	55	The object $icode f$$ has prototype
	56	$codei%
	57	ADFun<%Base%> %f%
	58	%$$
	59
	60	$head c$$
	61	The argument $icode c$$ has prototype
	62	$codei%
	63	size_t %c%
	64	%$$
	65	It specifies the number of Taylor coefficient orders that are allocated
	66	in the AD operation sequence corresponding to $icode f$$.
	67
	68	$subhead Pre-Allocating Memory$$
	69	If you plan to make calls to $code Forward$$ with the maximum value of
	70	$icode q$$ equal to $icode Q$$,
	71	it should be faster to pre-allocate memory for these calls using
	72	$codei%
	73	%f%.capacity_order(%c%)
	74	%$$
	75	with $icode c$$ equal to $latex Q + 1$$.
	76	If you do no do this, $code Forward$$ will automatically allocate memory
	77	and will copy the results to a larger buffer, when necessary.
	78	$pre
	79
	80	$$
	81	Note that each call to $cref Dependent$$ frees the old memory
	82	connected to the function object and sets the corresponding
	83	taylor capacity to zero.
	84
	85	$subhead Freeing Memory$$
	86	If you no longer need the Taylor coefficients of order $icode q$$
	87	and higher (that are stored in $icode f$$),
	88	you can reduce the memory allocated to $icode f$$ using
	89	$codei%
	90	%f%.capacity_order(%c%)
	91	%$$
	92	with $icode c$$ equal to $icode q$$.
	93	Note that, if $cref ta_hold_memory$$ is true, this memory is not actually
	94	returned to the system, but rather held for future use by the same thread.
	95
	96	$head Original State$$
	97	If $icode f$$ is $cref/constructed/FunConstruct/$$ with the syntax
	98	$codei%
	99	ADFun<%Base%> %f%(%x%, %y%)
	100	%$$,
	101	there is an implicit call to $cref forward_zero$$ with $icode xq$$ equal to
	102	the value of the
	103	$cref/independent variables/glossary/Tape/Independent Variable/$$
	104	when the AD operation sequence was recorded.
	105	This corresponds to $icode%c% == 1%$$.
	106
	107	$children%
	108	example/capacity_order.cpp
	109	%$$
	110	$head Example$$
	111	The file
	112	$cref capacity_order.cpp$$
	113	contains an example and test of these operations.
	114	It returns true if it succeeds and false otherwise.
	115
	116	$end
	117	-----------------------------------------------------------------------------
	118	*/
	119
	120	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
	121	/*!
	122	\file capacity_order.hpp
	123	Control of number of orders allocated.
	124	\}
	125	*/
	126
	127	/*!
	128	Control of number of orders and directions allocated.
	129
	130	\tparam Base
	131	The type used during the forward mode computations; i.e., the corresponding
	132	recording of operations used the type AD<Base>.
	133
	134	\param c
	135	is the number of orders to allocate memory for.
	136	If <code>c == 0</code> then \c r must also be zero.
	137	In this case num_order_taylor_, cap_order_taylor_, and num_direction_taylor_
	138	are all set to zero.
	139	In addition, taylor_.free() is called.
	140
	141	\param r
	142	is the number of directions to allocate memory for.
	143	If <code>c == 1</code> then \c r must also be one.
	144	In all cases, it must hold that
	145	<code>
	146	r == num_direction_taylor_ \|\| num_order_taylor <= 1
	147	</code>
	148	Upon return, num_direction_taylor_ is equal to r.
	149
	150	\par num_order_taylor_
	151	The output value of num_order_taylor_ is the mininumum of its input
	152	value and c. This minimum is the number of orders that are copied to the
	153	new taylor coefficient buffer.
	154
	155	\par num_direction_taylor_
	156	The output value of num_direction_taylor_ is equal to \c r.
	157	*/
	158
	159	template <typename Base>
	160	void ADFun<Base>::capacity_order(size_t c, size_t r)
	161	{ // temporary indices
	162	size_t i, k, ell;
	163
	164	if( (c == cap_order_taylor_) & (r == num_direction_taylor_) )
	165	return;
	166
	167	if( c == 0 )
	168	{ CPPAD_ASSERT_UNKNOWN( r == 0 );
	169	taylor_.free();
	170	num_order_taylor_ = 0;
	171	cap_order_taylor_ = 0;
	172	num_direction_taylor_ = r;
	173	return;
	174	}
	175	CPPAD_ASSERT_UNKNOWN(r==num_direction_taylor_ \|\| num_order_taylor_<=1);
	176
	177	// Allocate new taylor with requested number of orders and directions
	178	size_t new_len = ( (c-1)r + 1 ) num_var_tape_;
	179	pod_vector<Base> new_taylor;
	180	new_taylor.extend(new_len);
	181
	182	// number of orders to copy
	183	size_t p = std::min(num_order_taylor_, c);
	184	if( p > 0 )
	185	{
	186	// old order capacity
	187	size_t C = cap_order_taylor_;
	188
	189	// old number of directions
	190	size_t R = num_direction_taylor_;
	191
	192	// copy the old data into the new matrix
	193	CPPAD_ASSERT_UNKNOWN( p == 1 \|\| r == R );
	194	for(i = 0; i < num_var_tape_; i++)
	195	{ // copy zero order
	196	size_t old_index = ((C-1) * R + 1) * i + 0;
	197	size_t new_index = ((c-1) * r + 1) * i + 0;
	198	new_taylor[ new_index ] = taylor_[ old_index ];
	199	// copy higher orders
	200	for(k = 1; k < p; k++)
	201	{ for(ell = 0; ell < R; ell++)
	202	{ old_index = ((C-1) * R + 1) * i + (k-1) * R + ell + 1;
	203	new_index = ((c-1) * r + 1) * i + (k-1) * r + ell + 1;
	204	new_taylor[ new_index ] = taylor_[ old_index ];
	205	}
	206	}
	207	}
	208	}
	209
	210	// replace taylor_ by new_taylor
	211	taylor_.swap(new_taylor);
	212	cap_order_taylor_ = c;
	213	num_order_taylor_ = p;
	214	num_direction_taylor_ = r;
	215
	216	// note that the destructor for new_taylor will free the old taylor memory
	217	return;
	218	}
	219
	220	/*!
	221	User API control of number of orders allocated.
	222
	223	\tparam Base
	224	The type used during the forward mode computations; i.e., the corresponding
	225	recording of operations used the type AD<Base>.
	226
	227	\param c
	228	is the number of orders to allocate memory for.
	229	If <code>c == 0</code>,
	230	num_order_taylor_, cap_order_taylor_, and num_direction_taylor_
	231	are all set to zero.
	232	In addition, taylor_.free() is called.
	233
	234	\par num_order_taylor_
	235	The output value of num_order_taylor_ is the mininumum of its input
	236	value and c. This minimum is the number of orders that are copied to the
	237	new taylor coefficient buffer.
	238
	239	\par num_direction_taylor_
	240	If \c is zero (one), \c num_direction_taylor_ is set to zero (one).
	241	Otherwise, if \c num_direction_taylor_ is zero, it is set to one.
	242	Othwerwise, \c num_direction_taylor_ is not modified.
	243	*/
	244
	245	template <typename Base>
	246	void ADFun<Base>::capacity_order(size_t c)
	247	{ size_t r;
	248	if( (c == 0) \| (c == 1) )
	249	{ r = c;
	250	capacity_order(c, r);
	251	return;
	252	}
	253	r = num_direction_taylor_;
	254	if( r == 0 )
	255	r = 1;
	256	capacity_order(c, r);
	257	return;
	258	}
	259
	260	} // END CppAD namespace
	261
	262
	263	# endif

+26

-25

cppad/local/checkpoint.hpp less more

0		/* $Id: checkpoint.hpp 3008 2013-11-13 14:59:21Z bradbell $ */
	0	/* $Id: checkpoint.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_CHECKPOINT_INCLUDED
2	2	# define CPPAD_CHECKPOINT_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup checkpoint checkpoint.hpp
18		\{
19	17	\file checkpoint.hpp
20	18	defining checkpoint functions.
21	19	*/

229	227	\copydetails atomic_base::forward
230	228	*/
231	229	virtual bool forward(
	230	size_t p ,
232	231	size_t q ,
233		size_t p ,
234	232	const vector<bool>& vx ,
235	233	vector<bool>& vy ,
236	234	const vector<Base>& tx ,
237	235	vector<Base>& ty )
238	236	{
239	237	CPPAD_ASSERT_UNKNOWN( f_.size_var() > 0 );
240		CPPAD_ASSERT_UNKNOWN( tx.size() % (p+1) == 0 );
241		CPPAD_ASSERT_UNKNOWN( ty.size() % (p+1) == 0 );
242		size_t n = tx.size() / (p+1);
243		size_t m = ty.size() / (p+1);
	238	CPPAD_ASSERT_UNKNOWN( tx.size() % (q+1) == 0 );
	239	CPPAD_ASSERT_UNKNOWN( ty.size() % (q+1) == 0 );
	240	size_t n = tx.size() / (q+1);
	241	size_t m = ty.size() / (q+1);
244	242	bool ok = true;
245	243	size_t i, j;
246	244

271	269	}
272	270	}
273	271	}
274		ty = f_.Forward(p, tx);
	272	ty = f_.Forward(q, tx);
275	273
276	274	// no longer need the Taylor coefficients in f_
277	275	// (have to reconstruct them every time)
278		f_.capacity_taylor(0);
	276	size_t c = 0;
	277	size_t r = 0;
	278	f_.capacity_order(c, r);
279	279	return ok;
280	280	}
281	281	/*!

284	284	\copydetails atomic_base::reverse
285	285	*/
286	286	virtual bool reverse(
287		size_t p ,
	287	size_t q ,
288	288	const vector<Base>& tx ,
289	289	const vector<Base>& ty ,
290	290	vector<Base>& px ,
291	291	const vector<Base>& py )
292	292	{
293	293	CPPAD_ASSERT_UNKNOWN( f_.size_var() > 0 );
294		CPPAD_ASSERT_UNKNOWN( tx.size() % (p+1) == 0 );
295		CPPAD_ASSERT_UNKNOWN( ty.size() % (p+1) == 0 );
	294	CPPAD_ASSERT_UNKNOWN( tx.size() % (q+1) == 0 );
	295	CPPAD_ASSERT_UNKNOWN( ty.size() % (q+1) == 0 );
296	296	bool ok = true;
297	297
298	298	// put proper forward mode coefficients in f_
299	299	# ifdef NDEBUG
300		f_.Forward(p, tx);
	300	f_.Forward(q, tx);
301	301	# else
302		size_t n = tx.size() / (p+1);
303		size_t m = ty.size() / (p+1);
304		CPPAD_ASSERT_UNKNOWN( px.size() == n * (p+1) );
305		CPPAD_ASSERT_UNKNOWN( py.size() == m * (p+1) );
	302	size_t n = tx.size() / (q+1);
	303	size_t m = ty.size() / (q+1);
	304	CPPAD_ASSERT_UNKNOWN( px.size() == n * (q+1) );
	305	CPPAD_ASSERT_UNKNOWN( py.size() == m * (q+1) );
306	306	size_t i, j, k;
307	307	//
308		vector<Base> check_ty = f_.Forward(p, tx);
	308	vector<Base> check_ty = f_.Forward(q, tx);
309	309	for(i = 0; i < m; i++)
310		{ for(k = 0; k <= p; k++)
311		{ j = i * (p+1) + k;
	310	{ for(k = 0; k <= q; k++)
	311	{ j = i * (q+1) + k;
312	312	CPPAD_ASSERT_UNKNOWN( check_ty[j] == ty[j] );
313	313	}
314	314	}
315	315	# endif
316	316	// now can run reverse mode
317		px = f_.Reverse(p+1, py);
	317	px = f_.Reverse(q+1, py);
318	318
319	319	// no longer need the Taylor coefficients in f_
320	320	// (have to reconstruct them every time)
321		f_.capacity_taylor(0);
	321	size_t c = 0;
	322	size_t r = 0;
	323	f_.capacity_order(c, r);
322	324	return ok;
323	325	}
324	326	/*!

523	525	}
524	526	};
525	527
526		/! \} /
527	528	} // END_CPPAD_NAMESPACE
528	529	# endif

+287

-0

cppad/local/color_general.hpp less more

	0	/* $Id: color_general.hpp 3239 2014-04-28 23:00:17Z bradbell $ */
	1	# ifndef CPPAD_COLOR_GENERAL_INCLUDED
	2	# define CPPAD_COLOR_GENERAL_INCLUDED
	3
	4	/* --------------------------------------------------------------------------
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	6
	7	CppAD is distributed under multiple licenses. This distribution is under
	8	the terms of the
	9	GNU General Public License Version 3.
	10
	11	A copy of this license is included in the COPYING file of this distribution.
	12	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	13	-------------------------------------------------------------------------- */
	14	# include <cppad/local/cppad_colpack.hpp>
	15
	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
	17	/*!
	18	\file color_general.hpp
	19	Coloring algorithm for a general sparse matrix.
	20	*/
	21	// --------------------------------------------------------------------------
	22	/*!
	23	Determine which rows of a general sparse matrix can be computed together;
	24	i.e., do not have non-zero overlapping values.
	25
	26	\tparam VectorSize
	27	is a simple vector class with elements of type \c size_t.
	28
	29	\tparam VectorSet
	30	is an unspecified type with the exception that it must support the
	31	operations under \c pattern and the following operations where
	32	\c p is a \c VectorSet object:
	33	\n
	34	<code>VectorSet p</code>
	35	Constructs a new vector of sets object.
	36	\n
	37	<code>p.resize(ns, ne)</code>
	38	resizes \p to \c ns sets with elements between zero \c ne.
	39	All of the \c ns sets are initially empty.
	40	\n
	41	<code>p.add_element(s, e)</code>
	42	add element \c e to set with index \c s.
	43
	44	\param pattern [in]
	45	Is a representation of the sparsity pattern for the matrix.
	46	Note that \c color_general does not change the values in \c pattern,
	47	but it is not \c const because its iterator facility modifies some of its
	48	internal data.
	49	\n
	50	<code>m = pattern.n_set()</code>
	51	\n
	52	sets \c m to the number of rows in the sparse matrix.
	53	All of the row indices are less than this value.
	54	\n
	55	<code>n = pattern.end()</code>
	56	\n
	57	sets \c n to the number of columns in the sparse matrix.
	58	All of the column indices are less than this value.
	59	\n
	60	<code>pattern.begin(i)</code>
	61	instructs the iterator facility to start iterating over
	62	columns in the i-th row of the sparsity pattern.
	63	\n
	64	<code>j = pattern.next_element()</code>
	65	Sets \c j to the next possibly non-zero column
	66	in the row specified by the previous call to <code>pattern.begin</code>.
	67	If there are no more such columns, the value
	68	<code>pattern.end()</code> is returned.
	69
	70	\param row [in]
	71	is a vector specifying which row indices to compute.
	72
	73	\param col [in]
	74	is a vector, with the same size as \c row,
	75	that specifies which column indices to compute.
	76	For each valid index \c k, the index pair
	77	<code>(row[k], col[k])</code> must be present in the sparsity pattern.
	78	It may be that some entries in the sparsity pattern do not need to be computed;
	79	i.e, do not appear in the set of
	80	<code>(row[k], col[k])</code> entries.
	81
	82	\param color [out]
	83	is a vector with size \c m.
	84	The input value of its elements does not matter.
	85	Upon return, it is a coloring for the rows of the sparse matrix.
	86	\n
	87	\n
	88	If for come \c i, <code>color[i] == m</code>, then
	89	the i-th row does not appear in the vector \c row.
	90	Otherwise, <code>color[i] < m</code>.
	91	\n
	92	\n
	93	Suppose two differen rows, <code>i != r</code> have the same color and
	94	column index \c j is such that both of the pairs
	95	<code>(i, j)</code> and <code>(r, j)</code> appear in the sparsity pattern.
	96	It follows that neither of these pairs appear in the set of
	97	<code>(row[k], col[k])</code> entries.
	98	\n
	99	\n
	100	This routine tries to minimize, with respect to the choice of colors,
	101	the maximum, with respct to \c k, of <code>color[ row[k] ]</code>.
	102	*/
	103	template <class VectorSet, class VectorSize>
	104	void color_general_cppad(
	105	VectorSet& pattern ,
	106	const VectorSize& row ,
	107	const VectorSize& col ,
	108	CppAD::vector<size_t>& color )
	109	{ size_t i, j, k, ell, r;
	110
	111	size_t K = row.size();
	112	size_t m = pattern.n_set();
	113	size_t n = pattern.end();
	114
	115	CPPAD_ASSERT_UNKNOWN( col.size() == K );
	116	CPPAD_ASSERT_UNKNOWN( color.size() == m );
	117
	118	// We define the set of rows, columns, and pairs that appear
	119	// by the set ( row[k], col[k] ) for k = 0, ... , K-1.
	120
	121	// initialize rows that appear
	122	CppAD::vector<bool> row_appear(m);
	123	for(i = 0; i < m; i++)
	124	row_appear[i] = false;
	125
	126	// rows and columns that appear
	127	VectorSet c2r_appear, r2c_appear;
	128	c2r_appear.resize(n, m);
	129	r2c_appear.resize(m, n);
	130	for(k = 0; k < K; k++)
	131	{ CPPAD_ASSERT_UNKNOWN( pattern.is_element(row[k], col[k]) );
	132	row_appear[ row[k] ] = true;
	133	c2r_appear.add_element(col[k], row[k]);
	134	r2c_appear.add_element(row[k], col[k]);
	135	}
	136
	137	// for each column, which rows are non-zero and do not appear
	138	VectorSet not_appear;
	139	not_appear.resize(n, m);
	140	for(i = 0; i < m; i++)
	141	{ pattern.begin(i);
	142	j = pattern.next_element();
	143	while( j != pattern.end() )
	144	{ if( ! c2r_appear.is_element(j , i) )
	145	not_appear.add_element(j, i);
	146	j = pattern.next_element();
	147	}
	148	}
	149
	150	// initial coloring
	151	color.resize(m);
	152	ell = 0;
	153	for(i = 0; i < m; i++)
	154	{ if( row_appear[i] )
	155	color[i] = ell++;
	156	else color[i] = m;
	157	}
	158	/*
	159	See GreedyPartialD2Coloring Algorithm Section 3.6.2 of
	160	Graph Coloring in Optimization Revisited by
	161	Assefaw Gebremedhin, Fredrik Maane, Alex Pothen
	162
	163	The algorithm above was modified (by Brad Bell) to take advantage of the
	164	fact that only the entries (subset of the sparsity pattern) specified by
	165	row and col need to be computed.
	166	*/
	167	CppAD::vector<bool> forbidden(m);
	168	for(i = 1; i < m; i++) // for each row that appears
	169	if( color[i] < m )
	170	{
	171	// initial all colors as ok for this row
	172	// (value of forbidden for ell > initial color[i] does not matter)
	173	for(ell = 0; ell <= color[i]; ell++)
	174	forbidden[ell] = false;
	175
	176	// -----------------------------------------------------
	177	// Forbid colors for which this row would destroy results:
	178	//
	179	// for each column that is non-zero for this row
	180	pattern.begin(i);
	181	j = pattern.next_element();
	182	while( j != pattern.end() )
	183	{ // for each row that appears with this column
	184	c2r_appear.begin(j);
	185	r = c2r_appear.next_element();
	186	while( r != c2r_appear.end() )
	187	{ // if this is not the same row, forbid its color
	188	if( (r < i) & (color[r] < m) )
	189	forbidden[ color[r] ] = true;
	190	r = c2r_appear.next_element();
	191	}
	192	j = pattern.next_element();
	193	}
	194
	195
	196	// -----------------------------------------------------
	197	// Forbid colors that destroy results needed for this row.
	198	//
	199	// for each column that appears with this row
	200	r2c_appear.begin(i);
	201	j = r2c_appear.next_element();
	202	while( j != r2c_appear.end() )
	203	{ // For each row that is non-zero for this column
	204	// (the appear rows have already been checked above).
	205	not_appear.begin(j);
	206	r = not_appear.next_element();
	207	while( r != not_appear.end() )
	208	{ // if this is not the same row, forbid its color
	209	if( (r < i) & (color[r] < m) )
	210	forbidden[ color[r] ] = true;
	211	r = not_appear.next_element();
	212	}
	213	j = r2c_appear.next_element();
	214	}
	215
	216	// pick the color with smallest index
	217	ell = 0;
	218	while( forbidden[ell] )
	219	{ ell++;
	220	CPPAD_ASSERT_UNKNOWN( ell <= color[i] );
	221	}
	222	color[i] = ell;
	223	}
	224	return;
	225	}
	226
	227	# if CPPAD_HAS_COLPACK
	228	/*!
	229	Colpack version of determining which rows of a sparse matrix
	230	can be computed together.
	231
	232	\copydetails color_general
	233	*/
	234	template <class VectorSet, class VectorSize>
	235	void color_general_colpack(
	236	VectorSet& pattern ,
	237	const VectorSize& row ,
	238	const VectorSize& col ,
	239	CppAD::vector<size_t>& color )
	240	{ size_t i, j, k;
	241	size_t m = pattern.n_set();
	242	size_t n = pattern.end();
	243
	244	// Determine number of non-zero entries in each row
	245	CppAD::vector<size_t> n_nonzero(m);
	246	size_t n_nonzero_total = 0;
	247	for(i = 0; i < m; i++)
	248	{ n_nonzero[i] = 0;
	249	pattern.begin(i);
	250	j = pattern.next_element();
	251	while( j != pattern.end() )
	252	{ n_nonzero[i]++;
	253	j = pattern.next_element();
	254	}
	255	n_nonzero_total += n_nonzero[i];
	256	}
	257
	258	// Allocate memory and fill in Adolc sparsity pattern
	259	CppAD::vector<unsigned int*> adolc_pattern(m);
	260	CppAD::vector<unsigned int> adolc_memory(m + n_nonzero_total);
	261	size_t i_memory = 0;
	262	for(i = 0; i < m; i++)
	263	{ adolc_pattern[i] = adolc_memory.data() + i_memory;
	264	adolc_pattern[i][0] = n_nonzero[i];
	265	pattern.begin(i);
	266	j = pattern.next_element();
	267	k = 1;
	268	while(j != pattern.end() )
	269	{ adolc_pattern[i][k++] = j;
	270	j = pattern.next_element();
	271	}
	272	CPPAD_ASSERT_UNKNOWN( k == 1 + n_nonzero[i] );
	273	i_memory += k;
	274	}
	275	CPPAD_ASSERT_UNKNOWN( i_memory == m + n_nonzero_total );
	276
	277	// Must use an external routine for this part of the calculation because
	278	// ColPack/ColPackHeaders.h has as 'using namespace std' at global level.
	279	cppad_colpack_general(color, m, n, adolc_pattern);
	280
	281	return;
	282	}
	283	# endif // CPPAD_HAS_COLPACK
	284
	285	} // END_CPPAD_NAMESPACE
	286	# endif

-11

cppad/local/comp_op.hpp less more

0		/* $Id: comp_op.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: comp_op.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_COMP_OP_INCLUDED
2	2	# define CPPAD_COMP_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup comp_op_hpp comp_op.hpp
19		\{
20	18	\file comp_op.hpp
21	19	Zero order forward mode check how many comparisons changed.
22	20	*/

85	83	If left is a parameter, \a parameter[ arg[2] ] is its value.
86	84	If right is a parameter, \a parameter[ arg[3] ] is its value.
87	85
88		\param nc_taylor
	86	\param cap_order
89	87	number of columns in the matrix containing the Taylor coefficients.
90	88
91	89	\param taylor
92	90	Matrix of Taylor coefficients.
93		If left is a variable, \a taylor[ arg[2] * nc_taylor + 0 ] is its value.
94		If right is a variable, \a taylor[ arg[3] * nc_taylor + 0 ] is its value.
	91	If left is a variable, \a taylor[ arg[2] * cap_order + 0 ] is its value.
	92	If right is a variable, \a taylor[ arg[3] * cap_order + 0 ] is its value.
95	93
96	94
97	95	\par Checked Assertions where op is a binary operator:

109	107	const addr_t* arg ,
110	108	size_t num_par ,
111	109	const Base* parameter ,
112		size_t nc_taylor ,
	110	size_t cap_order ,
113	111	Base* taylor )
114	112	{ bool result;
115	113	Base left;

125	123
126	124	// value of left operand for this forward sweep
127	125	if( arg[1] & 2 )
128		left = taylor[ arg[2] * nc_taylor + 0 ];
	126	left = taylor[ arg[2] * cap_order + 0 ];
129	127	else
130	128	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
131	129	left = parameter[ arg[2] ];

133	131
134	132	// value of right operand for this forward sweep.
135	133	if( arg[1] & 4 )
136		right = taylor[ arg[3] * nc_taylor + 0 ];
	134	right = taylor[ arg[3] * cap_order + 0 ];
137	135	else
138	136	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
139	137	right = parameter[ arg[3] ];

168	166	}
169	167	return;
170	168	}
171		/! \} /
172	169	} // END_CPPAD_NAMESPACE
173	170	# endif

-3

cppad/local/cond_exp.hpp less more

0		/* $Id: cond_exp.hpp 2992 2013-10-22 16:45:13Z bradbell $ */
	0	/* $Id: cond_exp.hpp 3170 2014-03-09 14:33:53Z bradbell $ */
1	1	# ifndef CPPAD_COND_EXP_INCLUDED
2	2	# define CPPAD_COND_EXP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

120	120	$head Optimize$$
121	121	The $cref optimize$$ method will optimize conditional expressions
122	122	in the following way:
123		During $cref/zero order forward mode/ForwardZero/$$,
	123	During $cref/zero order forward mode/forward_zero/$$,
124	124	once the value of the $icode left$$ and $icode right$$ have been determined,
125	125	it is known if the true or false case is required.
126	126	From this point on, values corresponding to the case that is not required

+243

-84

cppad/local/cond_op.hpp less more

0		/* $Id: cond_op.hpp 2997 2013-10-27 12:32:25Z bradbell $ */
	0	/* $Id: cond_op.hpp 3323 2014-09-12 12:10:54Z bradbell $ */
1	1	# ifndef CPPAD_COND_OP_INCLUDED
2	2	# define CPPAD_COND_OP_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

13	13
14	14	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
15	15	/*!
16		\defgroup cond_op_hpp cond_op.hpp
17		\{
18	16	\file cond_op.hpp
19	17	Forward, reverse, and sparse operations for conditional expressions.
20	18	*/

86	84	For j = 0, 1, 2, 3,
87	85	if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
88	86
89		\param nc_taylor
	87	\param cap_order
90	88	number of columns in the matrix containing the Taylor coefficients.
91	89
92	90	\par Checked Assertions

95	93	\li arg[0] < static_cast<size_t> ( CompareNe )
96	94	\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
97	95	\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
98		\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
99	96	<!-- end conditional_exp_op -->
100	97	*/
101	98	template <class Base>

104	101	const addr_t* arg ,
105	102	size_t num_par ,
106	103	const Base* parameter ,
107		size_t nc_taylor )
	104	size_t cap_order )
108	105	{ // This routine is only for documentation, it should never be used
109	106	CPPAD_ASSERT_UNKNOWN( false );
110	107	}

177	174	\li arg[0] < static_cast<size_t> ( CompareNe )
178	175	\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
179	176	\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
180		\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
181	177	<!-- end sparse_conditional_exp_op -->
182	178	*/
183	179	template <class Vector_set>

256	252	For j = 0, 1, 2, 3,
257	253	if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
258	254
259		\param nc_taylor
	255	\param cap_order
260	256	number of columns in the matrix containing the Taylor coefficients.
261	257
262	258	\par Checked Assertions

265	261	\li arg[0] < static_cast<size_t> ( CompareNe )
266	262	\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
267	263	\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
268		\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
269	264	<!-- end conditional_exp_op -->
270	265
	266	\param p
	267	is the lowest order of the Taylor coefficient of z that we are computing.
	268
271	269	\param q
272		is the lowest order of the Taylor coefficient of z that we are computing.
273
274		\param p
275	270	is the highest order of the Taylor coefficient of z that we are computing.
276	271
277	272	\param taylor
278	273	\b Input:
279		For j = 0, 1, 2, 3 and k = 0 , ... , p,
	274	For j = 0, 1, 2, 3 and k = 0 , ... , q,
280	275	if y_j is a variable then
281		<code>taylor [ arg[2+j] * nc_taylor + k ]</code>
	276	<code>taylor [ arg[2+j] * cap_order + k ]</code>
282	277	is the k-th order Taylor coefficient corresponding to y_j.
283	278	\n
284		\b Input: <code>taylor [ i_z * nc_taylor + k ]</code>
285		for k = 0 , ... , q-1,
	279	\b Input: <code>taylor [ i_z * cap_order + k ]</code>
	280	for k = 0 , ... , p-1,
286	281	is the k-th order Taylor coefficient corresponding to z.
287	282	\n
288		\b Output: <code>taylor [ i_z * nc_taylor + k ]</code>
289		for k = q , ... , p,
	283	\b Output: <code>taylor [ i_z * cap_order + k ]</code>
	284	for k = p , ... , q,
290	285	is the k-th order Taylor coefficient corresponding to z.
291	286
292	287	*/
293	288	template <class Base>
294	289	inline void forward_cond_op(
	290	size_t p ,
295	291	size_t q ,
296		size_t p ,
297	292	size_t i_z ,
298	293	const addr_t* arg ,
299	294	size_t num_par ,
300	295	const Base* parameter ,
301		size_t nc_taylor ,
	296	size_t cap_order ,
302	297	Base* taylor )
303	298	{ Base y_0, y_1, y_2, y_3;
304	299	Base zero(0);
305		Base* z = taylor + i_z * nc_taylor;
	300	Base* z = taylor + i_z * cap_order;
306	301
307	302	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
308	303	CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );

310	305	CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
311	306
312	307	if( arg[1] & 1 )
313		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
314		y_0 = taylor[ arg[2] * nc_taylor + 0 ];
	308	{
	309	y_0 = taylor[ arg[2] * cap_order + 0 ];
315	310	}
316	311	else
317	312	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
318	313	y_0 = parameter[ arg[2] ];
319	314	}
320	315	if( arg[1] & 2 )
321		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
322		y_1 = taylor[ arg[3] * nc_taylor + 0 ];
	316	{
	317	y_1 = taylor[ arg[3] * cap_order + 0 ];
323	318	}
324	319	else
325	320	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
326	321	y_1 = parameter[ arg[3] ];
327	322	}
328		if( q == 0 )
	323	if( p == 0 )
329	324	{ if( arg[1] & 4 )
330		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
331		y_2 = taylor[ arg[4] * nc_taylor + 0 ];
	325	{
	326	y_2 = taylor[ arg[4] * cap_order + 0 ];
332	327	}
333	328	else
334	329	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
335	330	y_2 = parameter[ arg[4] ];
336	331	}
337	332	if( arg[1] & 8 )
338		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
339		y_3 = taylor[ arg[5] * nc_taylor + 0 ];
	333	{
	334	y_3 = taylor[ arg[5] * cap_order + 0 ];
340	335	}
341	336	else
342	337	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );

349	344	y_2,
350	345	y_3
351	346	);
352		q++;
353		}
354		for(size_t d = q; d <= p; d++)
	347	p++;
	348	}
	349	for(size_t d = p; d <= q; d++)
355	350	{ if( arg[1] & 4 )
356		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
357		y_2 = taylor[ arg[4] * nc_taylor + d];
	351	{
	352	y_2 = taylor[ arg[4] * cap_order + d];
358	353	}
359	354	else y_2 = zero;
360	355	if( arg[1] & 8 )
361		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
362		y_3 = taylor[ arg[5] * nc_taylor + d];
	356	{
	357	y_3 = taylor[ arg[5] * cap_order + d];
363	358	}
364	359	else y_3 = zero;
365	360	z[d] = CondExpOp(

374	369	}
375	370
376	371	/*!
377		Compute zero order forward mode Taylor coefficients for op = CExpOp.
	372	Multiple directions forward mode Taylor coefficients for op = CExpOp.
378	373
379	374	<!-- replace conditional_exp_op -->
380	375	The C++ source code coresponding to this operation is

440	435	For j = 0, 1, 2, 3,
441	436	if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
442	437
443		\param nc_taylor
	438	\param cap_order
444	439	number of columns in the matrix containing the Taylor coefficients.
445	440
446	441	\par Checked Assertions

449	444	\li arg[0] < static_cast<size_t> ( CompareNe )
450	445	\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
451	446	\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
452		\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
	447	<!-- end conditional_exp_op -->
	448
	449	\param q
	450	is order of the Taylor coefficient of z that we are computing.
	451
	452	\param r
	453	is the number of Taylor coefficient directions that we are computing.
	454
	455	\par tpv
	456	We use the notation
	457	<code>tpv = (cap_order-1) * r + 1</code>
	458	which is the number of Taylor coefficients per variable
	459
	460	\param taylor
	461	\b Input:
	462	For j = 0, 1, 2, 3, k = 1, ..., q,
	463	if y_j is a variable then
	464	<code>taylor [ arg[2+j] * tpv + 0 ]</code>
	465	is the zero order Taylor coefficient corresponding to y_j and
	466	<code>taylor [ arg[2+j] * tpv + (k-1)*r+1+ell</code> is its
	467	k-th order Taylor coefficient in the ell-th direction.
	468	\n
	469	\b Input:
	470	For j = 0, 1, 2, 3, k = 1, ..., q-1,
	471	<code>taylor [ i_z * tpv + 0 ]</code>
	472	is the zero order Taylor coefficient corresponding to z and
	473	<code>taylor [ i_z * tpv + (k-1)*r+1+ell</code> is its
	474	k-th order Taylor coefficient in the ell-th direction.
	475	\n
	476	\b Output: <code>taylor [ i_z * tpv + (q-1)*r+1+ell ]</code>
	477	is the q-th order Taylor coefficient corresponding to z
	478	in the ell-th direction.
	479	*/
	480	template <class Base>
	481	inline void forward_cond_op_dir(
	482	size_t q ,
	483	size_t r ,
	484	size_t i_z ,
	485	const addr_t* arg ,
	486	size_t num_par ,
	487	const Base* parameter ,
	488	size_t cap_order ,
	489	Base* taylor )
	490	{ Base y_0, y_1, y_2, y_3;
	491	Base zero(0);
	492	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	493	Base* z = taylor + i_z * num_taylor_per_var;
	494
	495	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < static_cast<size_t> (CompareNe) );
	496	CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
	497	CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
	498	CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
	499	CPPAD_ASSERT_UNKNOWN( 0 < q );
	500	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	501
	502	if( arg[1] & 1 )
	503	{
	504	y_0 = taylor[ arg[2] * num_taylor_per_var + 0 ];
	505	}
	506	else
	507	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
	508	y_0 = parameter[ arg[2] ];
	509	}
	510	if( arg[1] & 2 )
	511	{
	512	y_1 = taylor[ arg[3] * num_taylor_per_var + 0 ];
	513	}
	514	else
	515	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
	516	y_1 = parameter[ arg[3] ];
	517	}
	518	size_t m = (q-1) * r + 1;
	519	for(size_t ell = 0; ell < r; ell++)
	520	{ if( arg[1] & 4 )
	521	{
	522	y_2 = taylor[ arg[4] * num_taylor_per_var + m + ell];
	523	}
	524	else y_2 = zero;
	525	if( arg[1] & 8 )
	526	{
	527	y_3 = taylor[ arg[5] * num_taylor_per_var + m + ell];
	528	}
	529	else y_3 = zero;
	530	z[m+ell] = CondExpOp(
	531	CompareOp( arg[0] ),
	532	y_0,
	533	y_1,
	534	y_2,
	535	y_3
	536	);
	537	}
	538	return;
	539	}
	540
	541	/*!
	542	Compute zero order forward mode Taylor coefficients for op = CExpOp.
	543
	544	<!-- replace conditional_exp_op -->
	545	The C++ source code coresponding to this operation is
	546	\verbatim
	547	z = CondExpRel(y_0, y_1, y_2, y_3)
	548	\endverbatim
	549	where Rel is one of the following: Lt, Le, Eq, Ge, Gt.
	550
	551	\tparam Base
	552	base type for the operator; i.e., this operation was recorded
	553	using AD< \a Base > and computations by this routine are done using type
	554	\a Base.
	555
	556	\param i_z
	557	is the AD variable index corresponding to the variable z.
	558
	559	\param arg
	560	\n
	561	\a arg[0]
	562	is static cast to size_t from the enum type
	563	\verbatim
	564	enum CompareOp {
	565	CompareLt,
	566	CompareLe,
	567	CompareEq,
	568	CompareGe,
	569	CompareGt,
	570	CompareNe
	571	}
	572	\endverbatim
	573	for this operation.
	574	Note that arg[0] cannot be equal to CompareNe.
	575	\n
	576	\n
	577	\a arg[1] & 1
	578	\n
	579	If this is zero, y_0 is a parameter. Otherwise it is a variable.
	580	\n
	581	\n
	582	\a arg[1] & 2
	583	\n
	584	If this is zero, y_1 is a parameter. Otherwise it is a variable.
	585	\n
	586	\n
	587	\a arg[1] & 4
	588	\n
	589	If this is zero, y_2 is a parameter. Otherwise it is a variable.
	590	\n
	591	\n
	592	\a arg[1] & 8
	593	\n
	594	If this is zero, y_3 is a parameter. Otherwise it is a variable.
	595	\n
	596	\n
	597	\a arg[2 + j ] for j = 0, 1, 2, 3
	598	\n
	599	is the index corresponding to y_j.
	600
	601	\param num_par
	602	is the total number of values in the vector \a parameter.
	603
	604	\param parameter
	605	For j = 0, 1, 2, 3,
	606	if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
	607
	608	\param cap_order
	609	number of columns in the matrix containing the Taylor coefficients.
	610
	611	\par Checked Assertions
	612	\li NumArg(CExpOp) == 6
	613	\li NumRes(CExpOp) == 1
	614	\li arg[0] < static_cast<size_t> ( CompareNe )
	615	\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
	616	\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
453	617	<!-- end conditional_exp_op -->
454	618
455	619	\param taylor
456	620	\b Input:
457	621	For j = 0, 1, 2, 3,
458	622	if y_j is a variable then
459		\a taylor [ \a arg[2+j] * nc_taylor + 0 ]
	623	\a taylor [ \a arg[2+j] * cap_order + 0 ]
460	624	is the zero order Taylor coefficient corresponding to y_j.
461	625	\n
462		\b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
	626	\b Output: \a taylor [ \a i_z * \a cap_order + 0 ]
463	627	is the zero order Taylor coefficient corresponding to z.
464	628	*/
465	629	template <class Base>

468	632	const addr_t* arg ,
469	633	size_t num_par ,
470	634	const Base* parameter ,
471		size_t nc_taylor ,
	635	size_t cap_order ,
472	636	Base* taylor )
473	637	{ Base y_0, y_1, y_2, y_3;
474	638	Base* z;

479	643	CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
480	644
481	645	if( arg[1] & 1 )
482		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
483		y_0 = taylor[ arg[2] * nc_taylor + 0 ];
	646	{
	647	y_0 = taylor[ arg[2] * cap_order + 0 ];
484	648	}
485	649	else
486	650	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
487	651	y_0 = parameter[ arg[2] ];
488	652	}
489	653	if( arg[1] & 2 )
490		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
491		y_1 = taylor[ arg[3] * nc_taylor + 0 ];
	654	{
	655	y_1 = taylor[ arg[3] * cap_order + 0 ];
492	656	}
493	657	else
494	658	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
495	659	y_1 = parameter[ arg[3] ];
496	660	}
497	661	if( arg[1] & 4 )
498		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
499		y_2 = taylor[ arg[4] * nc_taylor + 0 ];
	662	{
	663	y_2 = taylor[ arg[4] * cap_order + 0 ];
500	664	}
501	665	else
502	666	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
503	667	y_2 = parameter[ arg[4] ];
504	668	}
505	669	if( arg[1] & 8 )
506		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
507		y_3 = taylor[ arg[5] * nc_taylor + 0 ];
	670	{
	671	y_3 = taylor[ arg[5] * cap_order + 0 ];
508	672	}
509	673	else
510	674	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < num_par );
511	675	y_3 = parameter[ arg[5] ];
512	676	}
513		z = taylor + i_z * nc_taylor;
	677	z = taylor + i_z * cap_order;
514	678	z[0] = CondExpOp(
515	679	CompareOp( arg[0] ),
516	680	y_0,

596	760	For j = 0, 1, 2, 3,
597	761	if y_j is a parameter, \a parameter [ arg[2 + j] ] is its value.
598	762
599		\param nc_taylor
	763	\param cap_order
600	764	number of columns in the matrix containing the Taylor coefficients.
601	765
602	766	\par Checked Assertions

605	769	\li arg[0] < static_cast<size_t> ( CompareNe )
606	770	\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
607	771	\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
608		\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
609	772	<!-- end conditional_exp_op -->
610	773
611	774	\param d

615	778	\b Input:
616	779	For j = 0, 1, 2, 3 and k = 0 , ... , \a d,
617	780	if y_j is a variable then
618		\a taylor [ \a arg[2+j] * nc_taylor + k ]
	781	\a taylor [ \a arg[2+j] * cap_order + k ]
619	782	is the k-th order Taylor coefficient corresponding to y_j.
620	783	\n
621		\a taylor [ \a i_z * \a nc_taylor + k ]
	784	\a taylor [ \a i_z * \a cap_order + k ]
622	785	for k = 0 , ... , \a d
623	786	is the k-th order Taylor coefficient corresponding to z.
624	787

633	796	is the partial derivative of G( z , y , x , w , u , ... )
634	797	with respect to the k-th order Taylor coefficient corresponding to y_j.
635	798	\n
636		\b Input: \a partial [ \a i_z * \a nc_taylor + k ]
	799	\b Input: \a partial [ \a i_z * \a cap_order + k ]
637	800	for k = 0 , ... , \a d
638	801	is the partial derivative of G( z , y , x , w , u , ... )
639	802	with respect to the k-th order Taylor coefficient corresponding to z.

653	816	const addr_t* arg ,
654	817	size_t num_par ,
655	818	const Base* parameter ,
656		size_t nc_taylor ,
	819	size_t cap_order ,
657	820	const Base* taylor ,
658	821	size_t nc_partial ,
659	822	Base* partial )

670	833
671	834	pz = partial + i_z * nc_partial + 0;
672	835	if( arg[1] & 1 )
673		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
674		y_0 = taylor[ arg[2] * nc_taylor + 0 ];
	836	{
	837	y_0 = taylor[ arg[2] * cap_order + 0 ];
675	838	}
676	839	else
677	840	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
678	841	y_0 = parameter[ arg[2] ];
679	842	}
680	843	if( arg[1] & 2 )
681		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
682		y_1 = taylor[ arg[3] * nc_taylor + 0 ];
	844	{
	845	y_1 = taylor[ arg[3] * cap_order + 0 ];
683	846	}
684	847	else
685	848	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
686	849	y_1 = parameter[ arg[3] ];
687	850	}
688	851	if( arg[1] & 4 )
689		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
	852	{
690	853	py_2 = partial + arg[4] * nc_partial;
691	854	size_t j = d + 1;
692	855	while(j--)

700	863	}
701	864	}
702	865	if( arg[1] & 8 )
703		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
	866	{
704	867	py_3 = partial + arg[5] * nc_partial;
705	868	size_t j = d + 1;
706	869	while(j--)

784	947	\li arg[0] < static_cast<size_t> ( CompareNe )
785	948	\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
786	949	\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
787		\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
788	950	<!-- end sparse_conditional_exp_op -->
789	951
790	952	\param sparsity

820	982
821	983	# ifndef NDEBUG
822	984	if( arg[1] & 1 )
823		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
	985	{
824	986	}
825	987	else
826	988	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
827	989	}
828	990	if( arg[1] & 2 )
829		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
	991	{
830	992	}
831	993	else
832	994	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );
833	995	}
834	996	# endif
835	997	if( arg[1] & 4 )
836		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
	998	{
837	999	if( arg[1] & 8 )
838		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
	1000	{
839	1001	sparsity.binary_union(i_z, arg[4], arg[5], sparsity);
840	1002	}
841	1003	else

846	1008	else
847	1009	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < num_par );
848	1010	if( arg[1] & 8 )
849		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
	1011	{
850	1012	sparsity.assignment(i_z, arg[5], sparsity);
851	1013	}
852	1014	else

933	1095	\li arg[0] < static_cast<size_t> ( CompareNe )
934	1096	\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
935	1097	\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
936		\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
937	1098	<!-- end sparse_conditional_exp_op -->
938	1099
939	1100	\param nz_compare

980	1141
981	1142	# ifndef NDEBUG
982	1143	if( arg[1] & 1 )
983		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
	1144	{
984	1145	}
985	1146	else
986	1147	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
987	1148	}
988	1149	if( arg[1] & 2 )
989		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
	1150	{
990	1151	}
991	1152	else
992	1153	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );

1000	1161	# endif
1001	1162	if( nz_compare )
1002	1163	{ if( arg[1] & 1 )
1003		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
	1164	{
1004	1165	sparsity.binary_union(arg[2], arg[2], i_z, sparsity);
1005	1166	}
1006	1167	if( arg[1] & 2 )
1007		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
	1168	{
1008	1169	sparsity.binary_union(arg[3], arg[3], i_z, sparsity);
1009	1170	}
1010	1171	}
1011	1172	// --------------------------------------------------------------------
1012	1173	if( arg[1] & 4 )
1013		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
	1174	{
1014	1175	sparsity.binary_union(arg[4], arg[4], i_z, sparsity);
1015	1176	}
1016	1177	if( arg[1] & 8 )
1017		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
	1178	{
1018	1179	sparsity.binary_union(arg[5], arg[5], i_z, sparsity);
1019	1180	}
1020	1181	return;

1096	1257	\li arg[0] < static_cast<size_t> ( CompareNe )
1097	1258	\li arg[1] != 0; i.e., not all of y_0, y_1, y_2, y_3 are parameters.
1098	1259	\li For j = 0, 1, 2, 3 if y_j is a parameter, arg[2+j] < num_par.
1099		\li For j = 0, 1, 2, 3 if y_j is a variable, arg[2+j] < iz.
1100	1260	<!-- end sparse_conditional_exp_op -->
1101	1261
1102	1262

1160	1320
1161	1321	# ifndef NDEBUG
1162	1322	if( arg[1] & 1 )
1163		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
	1323	{
1164	1324	}
1165	1325	else
1166	1326	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
1167	1327	}
1168	1328	if( arg[1] & 2 )
1169		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < i_z );
	1329	{
1170	1330	}
1171	1331	else
1172	1332	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );

1179	1339	}
1180	1340	# endif
1181	1341	if( arg[1] & 4 )
1182		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < i_z );
	1342	{
1183	1343
1184	1344	hes_sparsity.binary_union(arg[4], arg[4], i_z, hes_sparsity);
1185	1345	jac_reverse[ arg[4] ] \|= jac_reverse[i_z];
1186	1346	}
1187	1347	if( arg[1] & 8 )
1188		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < i_z );
	1348	{
1189	1349
1190	1350	hes_sparsity.binary_union(arg[5], arg[5], i_z, hes_sparsity);
1191	1351	jac_reverse[ arg[5] ] \|= jac_reverse[i_z];

1193	1353	return;
1194	1354	}
1195	1355
1196		/! \} /
1197	1356	} // END_CPPAD_NAMESPACE
1198	1357	# endif

+77

-30

cppad/local/cos_op.hpp less more

0		/* $Id: cos_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: cos_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_COS_OP_INCLUDED
2	2	# define CPPAD_COS_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup cos_op_hpp cos_op.hpp
19		\{
20	18	\file cos_op.hpp
21	19	Forward and reverse mode calculations for z = cos(x).
22	20	*/
23	21
24
25	22	/*!
26	23	Compute forward mode Taylor coefficient for result of op = CosOp.
27	24

40	37	*/
41	38	template <class Base>
42	39	inline void forward_cos_op(
	40	size_t p ,
43	41	size_t q ,
44		size_t p ,
45	42	size_t i_z ,
46	43	size_t i_x ,
47		size_t nc_taylor ,
	44	size_t cap_order ,
48	45	Base* taylor )
49	46	{
50	47	// check assumptions
51	48	CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
52	49	CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
53		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
54		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
55		CPPAD_ASSERT_UNKNOWN( q <= p );
	50	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	51	CPPAD_ASSERT_UNKNOWN( p <= q );
56	52
57	53	// Taylor coefficients corresponding to argument and result
58		Base* x = taylor + i_x * nc_taylor;
59		Base* c = taylor + i_z * nc_taylor;
60		Base* s = c - nc_taylor;
	54	Base* x = taylor + i_x * cap_order;
	55	Base* c = taylor + i_z * cap_order;
	56	Base* s = c - cap_order;
61	57
62	58
63	59	// rest of this routine is identical for the following cases:
64	60	// forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op.
	61	// (except that there is a sign difference for the hyperbolic case).
65	62	size_t k;
66		if( q == 0 )
	63	if( p == 0 )
67	64	{ s[0] = sin( x[0] );
68	65	c[0] = cos( x[0] );
69		q++;
70		}
71		for(size_t j = q; j <= p; j++)
	66	p++;
	67	}
	68	for(size_t j = p; j <= q; j++)
72	69	{
73	70	s[j] = Base(0);
74	71	c[j] = Base(0);

80	77	c[j] /= Base(j);
81	78	}
82	79	}
	80	/*!
	81	Compute forward mode Taylor coefficient for result of op = CosOp.
	82
	83	The C++ source code corresponding to this operation is
	84	\verbatim
	85	z = cos(x)
	86	\endverbatim
	87	The auxillary result is
	88	\verbatim
	89	y = sin(x)
	90	\endverbatim
	91	The value of y, and its derivatives, are computed along with the value
	92	and derivatives of z.
	93
	94	\copydetails forward_unary2_op_dir
	95	*/
	96	template <class Base>
	97	inline void forward_cos_op_dir(
	98	size_t q ,
	99	size_t r ,
	100	size_t i_z ,
	101	size_t i_x ,
	102	size_t cap_order ,
	103	Base* taylor )
	104	{
	105	// check assumptions
	106	CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
	107	CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
	108	CPPAD_ASSERT_UNKNOWN( 0 < q );
	109	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	110
	111	// Taylor coefficients corresponding to argument and result
	112	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	113	Base* x = taylor + i_x * num_taylor_per_var;
	114	Base* c = taylor + i_z * num_taylor_per_var;
	115	Base* s = c - num_taylor_per_var;
	116
	117
	118	// rest of this routine is identical for the following cases:
	119	// forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op
	120	// (except that there is a sign difference for the hyperbolic case).
	121	size_t m = (q-1) * r + 1;
	122	for(size_t ell = 0; ell < r; ell++)
	123	{ s[m+ell] = Base(q) * x[m + ell] * c[0];
	124	c[m+ell] = - Base(q) * x[m + ell] * s[0];
	125	for(size_t k = 1; k < q; k++)
	126	{ s[m+ell] += Base(k) * x[(k-1)r+1+ell] c[(q-k-1)*r+1+ell];
	127	c[m+ell] -= Base(k) * x[(k-1)r+1+ell] s[(q-k-1)*r+1+ell];
	128	}
	129	s[m+ell] /= Base(q);
	130	c[m+ell] /= Base(q);
	131	}
	132	}
83	133
84	134	/*!
85	135	Compute zero order forward mode Taylor coefficient for result of op = CosOp.

100	150	inline void forward_cos_op_0(
101	151	size_t i_z ,
102	152	size_t i_x ,
103		size_t nc_taylor ,
	153	size_t cap_order ,
104	154	Base* taylor )
105	155	{
106	156	// check assumptions
107	157	CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
108	158	CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
109		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
110		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	159	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
111	160
112	161	// Taylor coefficients corresponding to argument and result
113		Base* x = taylor + i_x * nc_taylor;
114		Base* c = taylor + i_z * nc_taylor; // called z in documentation
115		Base* s = c - nc_taylor; // called y in documentation
	162	Base* x = taylor + i_x * cap_order;
	163	Base* c = taylor + i_z * cap_order; // called z in documentation
	164	Base* s = c - cap_order; // called y in documentation
116	165
117	166	c[0] = cos( x[0] );
118	167	s[0] = sin( x[0] );

138	187	size_t d ,
139	188	size_t i_z ,
140	189	size_t i_x ,
141		size_t nc_taylor ,
	190	size_t cap_order ,
142	191	const Base* taylor ,
143	192	size_t nc_partial ,
144	193	Base* partial )

146	195	// check assumptions
147	196	CPPAD_ASSERT_UNKNOWN( NumArg(CosOp) == 1 );
148	197	CPPAD_ASSERT_UNKNOWN( NumRes(CosOp) == 2 );
149		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
150		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	198	CPPAD_ASSERT_UNKNOWN( d < cap_order );
151	199	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
152	200
153	201	// Taylor coefficients and partials corresponding to argument
154		const Base* x = taylor + i_x * nc_taylor;
	202	const Base* x = taylor + i_x * cap_order;
155	203	Base* px = partial + i_x * nc_partial;
156	204
157	205	// Taylor coefficients and partials corresponding to first result
158		const Base* c = taylor + i_z * nc_taylor; // called z in doc
	206	const Base* c = taylor + i_z * cap_order; // called z in doc
159	207	Base* pc = partial + i_z * nc_partial;
160	208
161	209	// Taylor coefficients and partials corresponding to auxillary result
162		const Base* s = c - nc_taylor; // called y in documentation
	210	const Base* s = c - cap_order; // called y in documentation
163	211	Base* ps = pc - nc_partial;
164	212
165	213

186	234	px[0] -= pc[0] * s[0];
187	235	}
188	236
189		/! \} /
190	237	} // END_CPPAD_NAMESPACE
191	238	# endif

+77

-29

cppad/local/cosh_op.hpp less more

0		/* $Id: cosh_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: cosh_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_COSH_OP_INCLUDED
2	2	# define CPPAD_COSH_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup cosh_op_hpp cosh_op.hpp
19		\{
20	18	\file cosh_op.hpp
21	19	Forward and reverse mode calculations for z = cosh(x).
22	20	*/

40	38	*/
41	39	template <class Base>
42	40	inline void forward_cosh_op(
	41	size_t p ,
43	42	size_t q ,
44		size_t p ,
45	43	size_t i_z ,
46	44	size_t i_x ,
47		size_t nc_taylor ,
	45	size_t cap_order ,
48	46	Base* taylor )
49	47	{
50	48	// check assumptions
51	49	CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
52	50	CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
53		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
54		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
55		CPPAD_ASSERT_UNKNOWN( q <= p );
	51	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	52	CPPAD_ASSERT_UNKNOWN( p <= q );
56	53
57	54	// Taylor coefficients corresponding to argument and result
58		Base* x = taylor + i_x * nc_taylor;
59		Base* c = taylor + i_z * nc_taylor;
60		Base* s = c - nc_taylor;
	55	Base* x = taylor + i_x * cap_order;
	56	Base* c = taylor + i_z * cap_order;
	57	Base* s = c - cap_order;
61	58
62	59	// rest of this routine is identical for the following cases:
63	60	// forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op.
	61	// (except that there is a sign difference for hyperbolic case).
64	62	size_t k;
65		if( q == 0 )
	63	if( p == 0 )
66	64	{ s[0] = sinh( x[0] );
67	65	c[0] = cosh( x[0] );
68		q++;
69		}
70		for(size_t j = q; j <= p; j++)
	66	p++;
	67	}
	68	for(size_t j = p; j <= q; j++)
71	69	{
72	70	s[j] = Base(0);
73	71	c[j] = Base(0);

79	77	c[j] /= Base(j);
80	78	}
81	79	}
	80	/*!
	81	Compute forward mode Taylor coefficient for result of op = CoshOp.
	82
	83	The C++ source code corresponding to this operation is
	84	\verbatim
	85	z = cosh(x)
	86	\endverbatim
	87	The auxillary result is
	88	\verbatim
	89	y = sinh(x)
	90	\endverbatim
	91	The value of y, and its derivatives, are computed along with the value
	92	and derivatives of z.
	93
	94	\copydetails forward_unary2_op_dir
	95	*/
	96	template <class Base>
	97	inline void forward_cosh_op_dir(
	98	size_t q ,
	99	size_t r ,
	100	size_t i_z ,
	101	size_t i_x ,
	102	size_t cap_order ,
	103	Base* taylor )
	104	{
	105	// check assumptions
	106	CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
	107	CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
	108	CPPAD_ASSERT_UNKNOWN( 0 < q );
	109	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	110
	111	// Taylor coefficients corresponding to argument and result
	112	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	113	Base* x = taylor + i_x * num_taylor_per_var;
	114	Base* s = taylor + i_z * num_taylor_per_var;
	115	Base* c = s - num_taylor_per_var;
	116
	117
	118	// rest of this routine is identical for the following cases:
	119	// forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op
	120	// (except that there is a sign difference for the hyperbolic case).
	121	size_t m = (q-1) * r + 1;
	122	for(size_t ell = 0; ell < r; ell++)
	123	{ s[m+ell] = Base(q) * x[m + ell] * c[0];
	124	c[m+ell] = Base(q) * x[m + ell] * s[0];
	125	for(size_t k = 1; k < q; k++)
	126	{ s[m+ell] += Base(k) * x[(k-1)r+1+ell] c[(q-k-1)*r+1+ell];
	127	c[m+ell] += Base(k) * x[(k-1)r+1+ell] s[(q-k-1)*r+1+ell];
	128	}
	129	s[m+ell] /= Base(q);
	130	c[m+ell] /= Base(q);
	131	}
	132	}
82	133
83	134	/*!
84	135	Compute zero order forward mode Taylor coefficient for result of op = CoshOp.

99	150	inline void forward_cosh_op_0(
100	151	size_t i_z ,
101	152	size_t i_x ,
102		size_t nc_taylor ,
	153	size_t cap_order ,
103	154	Base* taylor )
104	155	{
105	156	// check assumptions
106	157	CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
107	158	CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
108		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
109		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	159	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
110	160
111	161	// Taylor coefficients corresponding to argument and result
112		Base* x = taylor + i_x * nc_taylor;
113		Base* c = taylor + i_z * nc_taylor; // called z in documentation
114		Base* s = c - nc_taylor; // called y in documentation
	162	Base* x = taylor + i_x * cap_order;
	163	Base* c = taylor + i_z * cap_order; // called z in documentation
	164	Base* s = c - cap_order; // called y in documentation
115	165
116	166	c[0] = cosh( x[0] );
117	167	s[0] = sinh( x[0] );

137	187	size_t d ,
138	188	size_t i_z ,
139	189	size_t i_x ,
140		size_t nc_taylor ,
	190	size_t cap_order ,
141	191	const Base* taylor ,
142	192	size_t nc_partial ,
143	193	Base* partial )

145	195	// check assumptions
146	196	CPPAD_ASSERT_UNKNOWN( NumArg(CoshOp) == 1 );
147	197	CPPAD_ASSERT_UNKNOWN( NumRes(CoshOp) == 2 );
148		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
149		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	198	CPPAD_ASSERT_UNKNOWN( d < cap_order );
150	199	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
151	200
152	201	// Taylor coefficients and partials corresponding to argument
153		const Base* x = taylor + i_x * nc_taylor;
	202	const Base* x = taylor + i_x * cap_order;
154	203	Base* px = partial + i_x * nc_partial;
155	204
156	205	// Taylor coefficients and partials corresponding to first result
157		const Base* c = taylor + i_z * nc_taylor; // called z in doc
	206	const Base* c = taylor + i_z * cap_order; // called z in doc
158	207	Base* pc = partial + i_z * nc_partial;
159	208
160	209	// Taylor coefficients and partials corresponding to auxillary result
161		const Base* s = c - nc_taylor; // called y in documentation
	210	const Base* s = c - cap_order; // called y in documentation
162	211	Base* ps = pc - nc_partial;
163	212
164	213	// rest of this routine is identical for the following cases:

184	233	px[0] += pc[0] * s[0];
185	234	}
186	235
187		/! \} /
188	236	} // END_CPPAD_NAMESPACE
189	237	# endif

+18

-6

cppad/local/cppad_assert.hpp less more

0		/* $Id: cppad_assert.hpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: cppad_assert.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_CPPAD_ASSERT_INCLUDED
2	2	# define CPPAD_CPPAD_ASSERT_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

13	13	-------------------------------------------------------------------------- */
14	14
15	15	/*!
16		\defgroup cppad_assert_hpp cppad_assert.hpp
17		\{
18	16	\file cppad_assert.hpp
19	17	Define the CppAD error checking macros (all of which begin with CPPAD_ASSERT_)
20	18	*/

198	196	}
199	197	# endif
200	198
201		/! \} /
202		# endif
	199	/*!
	200	\def CPPAD_ASSERT_ARG_BEFORE_RESULT
	201	Check that operator arguments come before result.
	202
	203	If \c NDEBUG is defined, this macro has no effect,
	204	otherwise it calls the function assert_arg_before_result.
	205	*/
	206	# ifdef NDEBUG
	207	# define CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, result)
	208	# else
	209	# define CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, result) \
	210	assert_arg_before_result(op, arg, result)
	211
	212	# endif
	213
	214	# endif

+137

-0

cppad/local/cppad_colpack.cpp less more

	0	/* $Id: cppad_colpack.cpp 3240 2014-04-29 13:12:19Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	# include <vector>
	13	# include <cppad/vector.hpp>
	14	# include <ColPack/ColPackHeaders.h>
	15
	16	namespace CppAD {
	17	void cppad_colpack_general(
	18	CppAD::vector<size_t>& color ,
	19	size_t m ,
	20	size_t n ,
	21	const CppAD::vector<unsigned int*>& adolc_pattern )
	22	{ size_t i, k;
	23	CPPAD_ASSERT_UNKNOWN( adolc_pattern.size() == m );
	24
	25	// Use adolc sparsity pattern to create corresponding bipartite graph
	26	ColPack::BipartiteGraphPartialColoringInterface graph(
	27	SRC_MEM_ADOLC,
	28	adolc_pattern.data(),
	29	m,
	30	n
	31	);
	32
	33	// row ordered Partial-Distance-Two-Coloring of the bipartite graph
	34	graph.PartialDistanceTwoColoring(
	35	"SMALLEST_LAST", "ROW_PARTIAL_DISTANCE_TWO"
	36	);
	37
	38	// Use coloring information to create seed matrix
	39	int n_seed_row;
	40	int n_seed_col;
	41	double** seed_matrix = graph.GetSeedMatrix(&n_seed_row, &n_seed_col);
	42	CPPAD_ASSERT_UNKNOWN( size_t(n_seed_col) == m );
	43
	44	// now return coloring in format required by CppAD
	45	for(i = 0; i < m; i++)
	46	color[i] = m;
	47	for(k = 0; k < size_t(n_seed_row); k++)
	48	{ for(i = 0; i < m; i++)
	49	{ if( seed_matrix[k][i] != 0.0 )
	50	{ // check that no row appears twice in the coloring
	51	CPPAD_ASSERT_UNKNOWN( color[i] == m );
	52	color[i] = k;
	53	}
	54	}
	55	}
	56	# ifndef NDEBUG
	57	// check that all non-zero rows appear in the coloring
	58	for(i = 0; i < m; i++)
	59	CPPAD_ASSERT_UNKNOWN(color[i] < m \|\| adolc_pattern[i][0] == 0);
	60
	61	// check that no rows with the same color have overlapping entries
	62	CppAD::vector<bool> found(n);
	63	for(k = 0; k < size_t(n_seed_row); k++)
	64	{ size_t j, ell;
	65	for(j = 0; j < n; j++)
	66	found[j] = false;
	67	for(i = 0; i < m; i++) if( color[i] == k )
	68	{ for(ell = 0; ell < adolc_pattern[i][0]; ell++)
	69	{ j = adolc_pattern[i][1 + ell];
	70	CPPAD_ASSERT_UNKNOWN( ! found[j] );
	71	found[j] = true;
	72	}
	73	}
	74	}
	75	# endif
	76	return;
	77	}
	78	// The following routine is not yet used or tested.
	79	void cppad_colpack_symmetric(
	80	CppAD::vector<size_t>& color ,
	81	size_t n ,
	82	const CppAD::vector<unsigned int*>& adolc_pattern )
	83	{ size_t i, k;
	84	CPPAD_ASSERT_UNKNOWN( adolc_pattern.size() == n );
	85
	86	// Use adolc sparsity pattern to create corresponding bipartite graph
	87	ColPack::GraphColoringInterface graph(
	88	SRC_MEM_ADOLC,
	89	adolc_pattern.data(),
	90	n
	91	);
	92
	93	// Color the graph with the speciied ordering
	94	// graph.Coloring("SMALLEST_LAST", "STAR") is slower in adolc testing
	95	graph.Coloring("SMALLEST_LAST", "ACYCLIC_FOR_INDIRECT_RECOVERY");
	96
	97	// Use coloring information to create seed matrix
	98	int n_seed_row;
	99	int n_seed_col;
	100	double** seed_matrix = graph.GetSeedMatrix(&n_seed_row, &n_seed_col);
	101	CPPAD_ASSERT_UNKNOWN( size_t(n_seed_col) == n );
	102
	103	// now return coloring in format required by CppAD
	104	for(i = 0; i < n; i++)
	105	color[i] = n;
	106	for(k = 0; k < size_t(n_seed_row); k++)
	107	{ for(i = 0; i < n; i++)
	108	{ if( seed_matrix[k][i] != 0.0 )
	109	{ CPPAD_ASSERT_UNKNOWN( color[i] == n );
	110	color[i] = k;
	111	}
	112	}
	113	}
	114	# ifndef NDEBUG
	115	for(i = 0; i < n; i++)
	116	CPPAD_ASSERT_UNKNOWN(color[i] < n \|\| adolc_pattern[i][0] == 0);
	117
	118	// The coloring above will probably fail this test.
	119	// Check that no rows with the same color have overlapping entries:
	120	CppAD::vector<bool> found(n);
	121	for(k = 0; k < size_t(n_seed_row); k++)
	122	{ size_t j, ell;
	123	for(j = 0; j < n; j++)
	124	found[j] = false;
	125	for(i = 0; i < n; i++) if( color[i] == k )
	126	{ for(ell = 0; ell < adolc_pattern[i][0]; ell++)
	127	{ j = adolc_pattern[i][1 + ell];
	128	CPPAD_ASSERT_UNKNOWN( ! found[j] );
	129	found[j] = true;
	130	}
	131	}
	132	}
	133	# endif
	134	return;
	135	}
	136	}

+104

-0

cppad/local/cppad_colpack.hpp less more

	0	/* $Id: cppad_colpack.hpp 3240 2014-04-29 13:12:19Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	# ifndef CPPAD_CPPAD_COLPACK_INCLUDED
	12	# define CPPAD_CPPAD_COLPACK_INCLUDED
	13	# if CPPAD_HAS_COLPACK
	14
	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
	16	/*!
	17	\file cppad_colpack.hpp
	18	External interface to Colpack routines used by cppad.
	19	*/
	20	// ---------------------------------------------------------------------------
	21	/*!
	22	Link from CppAD to ColPack used for general sparse matrices.
	23
	24	This CppAD library routine is necessary because
	25	<code>ColPack/ColPackHeaders.h</code> has a
	26	<code>using namespace std</code> at the global level.
	27
	28	\param m [in]
	29	is the number of rows in the sparse matrix
	30
	31	\param n [in]
	32	is the nubmer of columns in the sparse matrix.
	33
	34	\param adolc_pattern [in]
	35	This vector has size \c m,
	36	<code>adolc_pattern[i][0]</code> is the number of non-zeros in row \c i.
	37	For <code>j = 1 , ... , adolc_sparsity[i]<code>,
	38	<code>adolc_pattern[i][j]</code> is the column index (base zero) for the
	39	non-zeros in row \c i.
	40
	41	\param color [out]
	42	is a vector with size \c m.
	43	The input value of its elements does not matter.
	44	Upon return, it is a coloring for the rows of the sparse matrix.
	45	\n
	46	\n
	47	If for some \c i, <code>color[i] == m</code>, then
	48	<code>adolc_pattern[i][0] == 0</code>.
	49	Otherwise, <code>color[i] < m</code>.
	50	\n
	51	\n
	52	Suppose two differen rows, <code>i != r</code> have the same color.
	53	It follows that for all column indices \c j;
	54	it is not the case that both
	55	<code>(i, j)</code> and <code>(r, j)</code> appear in the sparsity pattern.
	56	\n
	57	\n
	58	This routine tries to minimize, with respect to the choice of colors,
	59	the number of colors.
	60	*/
	61	extern void cppad_colpack_general(
	62	CppAD::vector<size_t>& color ,
	63	size_t m ,
	64	size_t n ,
	65	const CppAD::vector<unsigned int*>& adolc_pattern
	66	);
	67
	68	/*!
	69	Link from CppAD to ColPack used for symmetric sparse matrices
	70	(not yet used or tested).
	71
	72	This CppAD library routine is necessary because
	73	<code>ColPack/ColPackHeaders.h</code> has a
	74	<code>using namespace std</code> at the global level.
	75
	76	\param n [in]
	77	is the nubmer of rows and columns in the symmetric sparse matrix.
	78
	79	\param adolc_pattern [in]
	80	This vector has size \c n,
	81	<code>adolc_pattern[i][0]</code> is the number of non-zeros in row \c i.
	82	For <code>j = 1 , ... , adolc_sparsity[i]<code>,
	83	<code>adolc_pattern[i][j]</code> is the column index (base zero) for the
	84	non-zeros in row \c i.
	85
	86	\param color [out]
	87	The input value of its elements does not matter.
	88	Upon return, it is a coloring for the rows of the sparse matrix.
	89	The properties of this coloring have not yet been determined; see
	90	Efficient Computation of Sparse Hessians Using Coloring
	91	and Automatic Differentiation (pdf/ad/gebemedhin14.pdf)
	92	*/
	93	extern void cppad_colpack_symmetric(
	94	CppAD::vector<size_t>& color ,
	95	size_t n ,
	96	const CppAD::vector<unsigned int*>& adolc_pattern
	97	);
	98
	99	} // END_CPPAD_NAMESPACE
	100
	101	# endif
	102	# endif
	103

+16

-17

cppad/local/cskip_op.hpp less more

0		// $Id: cskip_op.hpp 2991 2013-10-22 16:25:15Z bradbell $
	0	// $Id: cskip_op.hpp 3370 2014-09-28 10:52:36Z bradbell $
1	1	# ifndef CPPAD_CSKIP_OP_INCLUDED
2	2	# define CPPAD_CSKIP_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup cskip_op_hpp cskip_op.hpp
18		\{
19	17	\file cskip_op.hpp
20	18	Zero order forward mode set which operations to skip.
21	19	*/

90	88	If right is a parameter,
91	89	<code>parameter [ arg[3] ]</code> is its value.
92	90
93		\param nc_taylor [in]
	91	\param cap_order [in]
94	92	number of columns in the matrix containing the Taylor coefficients.
95	93
96	94	\param taylor [in]
97	95	If left is a variable,
98		<code>taylor [ arg[2] * nc_taylor + 0 ]</code>
	96	<code>taylor [ arg[2] * cap_order + 0 ]</code>
99	97	is the zeroth order Taylor coefficient corresponding to left.
100	98	If right is a variable,
101		<code>taylor [ arg[3] * nc_taylor + 0 ]</code>
	99	<code>taylor [ arg[3] * cap_order + 0 ]</code>
102	100	is the zeroth order Taylor coefficient corresponding to right.
103	101
104		\param \cskip_var [in,out]
	102	\param \cskip_op [in,out]
105	103	is vector specifying which operations are at this point are know to be
106	104	unecessary and can be skipped.
107	105	This is both an input and an output.

112	110	const addr_t* arg ,
113	111	size_t num_par ,
114	112	const Base* parameter ,
115		size_t nc_taylor ,
	113	size_t cap_order ,
116	114	Base* taylor ,
117		CppAD::vector<bool>& cskip_var )
	115	bool* cskip_op )
118	116	{
119	117	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < size_t(CompareNe) );
120	118	CPPAD_ASSERT_UNKNOWN( arg[1] != 0 );
121	119
122	120	Base left, right;
123	121	if( arg[1] & 1 )
124		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= i_z );
125		left = taylor[ arg[2] * nc_taylor + 0 ];
	122	{ // If varialbe arg[2] <= i_z, it has already been computed,
	123	// but it will be skipped for higher orders.
	124	left = taylor[ arg[2] * cap_order + 0 ];
126	125	CPPAD_ASSERT_UNKNOWN( IdenticalPar(left) );
127	126	}
128	127	else

131	130	CPPAD_ASSERT_UNKNOWN( IdenticalPar(left) );
132	131	}
133	132	if( arg[1] & 2 )
134		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= i_z );
135		right = taylor[ arg[3] * nc_taylor + 0 ];
	133	{ // If varialbe arg[3] <= i_z, it has already been computed,
	134	// but it will be skipped for higher orders.
	135	right = taylor[ arg[3] * cap_order + 0 ];
136	136	CPPAD_ASSERT_UNKNOWN( IdenticalPar(right) );
137	137	}
138	138	else

176	176	}
177	177	if( true_case )
178	178	{ for(size_t i = 0; i < size_t(arg[4]); i++)
179		cskip_var[ arg[6+i] ] = true;
	179	cskip_op[ arg[6+i] ] = true;
180	180	}
181	181	else
182	182	{ for(size_t i = 0; i < size_t(arg[5]); i++)
183		cskip_var[ arg[6+arg[4]+i] ] = true;
	183	cskip_op[ arg[6+arg[4]+i] ] = true;
184	184	}
185	185	return;
186	186	}
187		/! \} /
188	187	} // END_CPPAD_NAMESPACE
189	188	# endif
190	189

+153

-37

cppad/local/csum_op.hpp less more

0		// $Id: csum_op.hpp 2910 2013-10-07 13:27:58Z bradbell $
	0	// $Id: csum_op.hpp 3301 2014-05-24 05:20:21Z bradbell $
1	1	# ifndef CPPAD_CSUM_OP_INCLUDED
2	2	# define CPPAD_CSUM_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup csum_op_hpp csum_op.hpp
18		\{
19	17	\file csum_op.hpp
20	18	Forward, reverse and sparsity calculations for cummulative summation.
21	19	*/

33	31	using AD< \a Base > and computations by this routine are done using type
34	32	\a Base.
35	33
	34	\param p
	35	lowest order of the Taylor coefficient that we are computing.
	36
36	37	\param q
37		lowest order of the Taylor coefficient that we are computing.
38
39		\param p
40	38	highest order of the Taylor coefficient that we are computing.
41	39
42	40	\param i_z

67	65	\param parameter
68	66	is the parameter vector for this operation sequence.
69	67
70		\param nc_taylor
	68	\param cap_order
71	69	number of colums in the matrix containing all the Taylor coefficients.
72	70
73	71	\param taylor
74		\b Input: <tt>taylor [ arg[2+i] * nc_taylor + k ]</tt>
	72	\b Input: <tt>taylor [ arg[2+i] * cap_order + k ]</tt>
75	73	for <tt>i = 1 , ... , m</tt>
76		and <tt>k = 0 , ... , p</tt>
	74	and <tt>k = 0 , ... , q</tt>
77	75	is the k-th order Taylor coefficient corresponding to <tt>x(i)</tt>
78	76	\n
79		\b Input: <tt>taylor [ arg[2+m+i] * nc_taylor + k ]</tt>
	77	\b Input: <tt>taylor [ arg[2+m+i] * cap_order + k ]</tt>
80	78	for <tt>i = 1 , ... , n</tt>
81		and <tt>k = 0 , ... , p</tt>
	79	and <tt>k = 0 , ... , q</tt>
82	80	is the k-th order Taylor coefficient corresponding to <tt>y(i)</tt>
83	81	\n
84		\b Input: <tt>taylor [ i_z * nc_taylor + k ]</tt>
85		for k = 0 , ... , q,
	82	\b Input: <tt>taylor [ i_z * cap_order + k ]</tt>
	83	for k = 0 , ... , p,
86	84	is the k-th order Taylor coefficient corresponding to z.
87	85	\n
88		\b Output: <tt>taylor [ i_z * nc_taylor + k ]</tt>
89		for k = q , ... , p,
	86	\b Output: <tt>taylor [ i_z * cap_order + k ]</tt>
	87	for k = p , ... , q,
90	88	is the \a k-th order Taylor coefficient corresponding to z.
91	89	*/
92	90	template <class Base>
93	91	inline void forward_csum_op(
	92	size_t p ,
94	93	size_t q ,
95		size_t p ,
96	94	size_t i_z ,
97	95	const addr_t* arg ,
98	96	size_t num_par ,
99	97	const Base* parameter ,
100		size_t nc_taylor ,
	98	size_t cap_order ,
101	99	Base* taylor )
102	100	{ Base zero(0);
103	101	size_t i, j, k;
104	102
105	103	// check assumptions
106	104	CPPAD_ASSERT_UNKNOWN( NumRes(CSumOp) == 1 );
107		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
108		CPPAD_ASSERT_UNKNOWN( q <= p );
	105	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	106	CPPAD_ASSERT_UNKNOWN( p <= q );
109	107	CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
110	108	CPPAD_ASSERT_UNKNOWN(
111	109	arg[0] + arg[1] == arg[ arg[0] + arg[1] + 3 ]
112	110	);
113	111
114	112	// Taylor coefficients corresponding to result
115		Base* z = taylor + i_z * nc_taylor;
116		for(k = q; k <= p; k++)
	113	Base* z = taylor + i_z * cap_order;
	114	for(k = p; k <= q; k++)
117	115	z[k] = zero;
118		if( q == 0 )
119		z[q] = parameter[ arg[2] ];
	116	if( p == 0 )
	117	z[p] = parameter[ arg[2] ];
120	118	Base* x;
121	119	i = arg[0];
122	120	j = 2;
123	121	while(i--)
124	122	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[j+1]) < i_z );
125		x = taylor + arg[++j] * nc_taylor;
126		for(k = q; k <= p; k++)
	123	x = taylor + arg[++j] * cap_order;
	124	for(k = p; k <= q; k++)
127	125	z[k] += x[k];
128	126	}
129	127	i = arg[1];
130	128	while(i--)
131	129	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[j+1]) < i_z );
132		x = taylor + arg[++j] * nc_taylor;
133		for(k = q; k <= p; k++)
	130	x = taylor + arg[++j] * cap_order;
	131	for(k = p; k <= q; k++)
134	132	z[k] -= x[k];
	133	}
	134	}
	135
	136	/*!
	137	Multiple direction forward mode Taylor coefficients for op = CsumOp.
	138
	139	This operation is
	140	\verbatim
	141	z = s + x(1) + ... + x(m) - y(1) - ... - y(n).
	142	\endverbatim
	143
	144	\tparam Base
	145	base type for the operator; i.e., this operation was recorded
	146	using AD<Base> and computations by this routine are done using type
	147	\a Base.
	148
	149	\param q
	150	order ot the Taylor coefficients that we are computing.
	151
	152	\param r
	153	number of directions for Taylor coefficients that we are computing.
	154
	155	\param i_z
	156	variable index corresponding to the result for this operation;
	157	i.e. the row index in \a taylor corresponding to z.
	158
	159	\param arg
	160	\a arg[0]
	161	is the number of addition variables in this cummulative summation; i.e.,
	162	<tt>m</tt>.
	163	\n
	164	\a arg[1]
	165	is the number of subtraction variables in this cummulative summation; i.e.,
	166	\c m.
	167	\n
	168	<tt>parameter[ arg[2] ]</tt>
	169	is the parameter value \c s in this cummunative summation.
	170	\n
	171	<tt>arg[2+i]</tt>
	172	for <tt>i = 1 , ... , m</tt> is the variable index of <tt>x(i)</tt>.
	173	\n
	174	<tt>arg[2+arg[0]+i]</tt>
	175	for <tt>i = 1 , ... , n</tt> is the variable index of <tt>y(i)</tt>.
	176
	177	\param num_par
	178	is the number of parameters in \a parameter.
	179
	180	\param parameter
	181	is the parameter vector for this operation sequence.
	182
	183	\param cap_order
	184	number of colums in the matrix containing all the Taylor coefficients.
	185
	186	\param taylor
	187	\b Input: <tt>taylor [ arg[2+i]((cap_order-1)r + 1) + 0 ]</tt>
	188	for <tt>i = 1 , ... , m</tt>
	189	is the 0-th order Taylor coefficient corresponding to <tt>x(i)</tt> and
	190	<tt>taylor [ arg[2+i]((cap_order-1)r + 1) + (q-1)*r + ell + 1 ]</tt>
	191	for <tt>i = 1 , ... , m</tt>,
	192	<tt>ell = 0 , ... , r-1</tt>
	193	is the q-th order Taylor coefficient corresponding to <tt>x(i)</tt>
	194	and direction ell.
	195	\n
	196	\b Input: <tt>taylor [ arg[2+m+i]((cap_order-1)r + 1) + 0 ]</tt>
	197	for <tt>i = 1 , ... , n</tt>
	198	is the 0-th order Taylor coefficient corresponding to <tt>y(i)</tt> and
	199	<tt>taylor [ arg[2+m+i]((cap_order-1)r + 1) + (q-1)*r + ell + 1 ]</tt>
	200	for <tt>i = 1 , ... , n</tt>,
	201	<tt>ell = 0 , ... , r-1</tt>
	202	is the q-th order Taylor coefficient corresponding to <tt>y(i)</tt>
	203	and direction ell.
	204	\n
	205	\b Output: <tt>taylor [ i_z((cap_order-1)r+1) + (q-1)*r + ell + 1 ]</tt>
	206	is the \a q-th order Taylor coefficient corresponding to z
	207	for direction <tt>ell = 0 , ... , r-1</tt>.
	208	*/
	209	template <class Base>
	210	inline void forward_csum_op_dir(
	211	size_t q ,
	212	size_t r ,
	213	size_t i_z ,
	214	const addr_t* arg ,
	215	size_t num_par ,
	216	const Base* parameter ,
	217	size_t cap_order ,
	218	Base* taylor )
	219	{ Base zero(0);
	220	size_t i, j, ell;
	221
	222	// check assumptions
	223	CPPAD_ASSERT_UNKNOWN( NumRes(CSumOp) == 1 );
	224	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	225	CPPAD_ASSERT_UNKNOWN( 0 < q );
	226	CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
	227	CPPAD_ASSERT_UNKNOWN(
	228	arg[0] + arg[1] == arg[ arg[0] + arg[1] + 3 ]
	229	);
	230
	231	// Taylor coefficients corresponding to result
	232	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	233	size_t m = (q-1)*r + 1;
	234	Base* z = taylor + i_z * num_taylor_per_var + m;
	235	for(ell = 0; ell < r; ell++)
	236	z[ell] = zero;
	237	Base* x;
	238	i = arg[0];
	239	j = 2;
	240	while(i--)
	241	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[j+1]) < i_z );
	242	x = taylor + arg[++j] * num_taylor_per_var + m;
	243	for(ell = 0; ell < r; ell++)
	244	z[ell] += x[ell];
	245	}
	246	i = arg[1];
	247	while(i--)
	248	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[j+1]) < i_z );
	249	x = taylor + arg[++j] * num_taylor_per_var + m;
	250	for(ell = 0; ell < r; ell++)
	251	z[ell] -= x[ell];
135	252	}
136	253	}
137	254

140	257
141	258	This operation is
142	259	\verbatim
143		z = p + x(1) + ... + x(m) - y(1) - ... - y(n).
	260	z = q + x(1) + ... + x(m) - y(1) - ... - y(n).
144	261	H(y, x, w, ...) = G[ z(x, y), y, x, w, ... ]
145	262	\endverbatim
146	263

167	284	\c m.
168	285	\n
169	286	<tt>parameter[ arg[2] ]</tt>
170		is the parameter value \c p in this cummunative summation.
	287	is the parameter value \c q in this cummunative summation.
171	288	\n
172	289	<tt>arg[2+i]</tt>
173	290	for <tt>i = 1 , ... , m</tt> is the value <tt>x(i)</tt>.

252	369
253	370	This operation is
254	371	\verbatim
255		z = p + x(1) + ... + x(m) - y(1) - ... - y(n).
	372	z = q + x(1) + ... + x(m) - y(1) - ... - y(n).
256	373	\endverbatim
257	374
258	375	\tparam Vector_set

273	390	\c m.
274	391	\n
275	392	<tt>parameter[ arg[2] ]</tt>
276		is the parameter value \c p in this cummunative summation.
	393	is the parameter value \c q in this cummunative summation.
277	394	\n
278	395	<tt>arg[2+i]</tt>
279	396	for <tt>i = 1 , ... , m</tt> is the value <tt>x(i)</tt>.

329	446
330	447	This operation is
331	448	\verbatim
332		z = p + x(1) + ... + x(m) - y(1) - ... - y(n).
	449	z = q + x(1) + ... + x(m) - y(1) - ... - y(n).
333	450	H(y, x, w, ...) = G[ z(x, y), y, x, w, ... ]
334	451	\endverbatim
335	452

351	468	\c m.
352	469	\n
353	470	<tt>parameter[ arg[2] ]</tt>
354		is the parameter value \c p in this cummunative summation.
	471	is the parameter value \c q in this cummunative summation.
355	472	\n
356	473	<tt>arg[2+i]</tt>
357	474	for <tt>i = 1 , ... , m</tt> is the value <tt>x(i)</tt>.

405	522
406	523	This operation is
407	524	\verbatim
408		z = p + x(1) + ... + x(m) - y(1) - ... - y(n).
	525	z = q + x(1) + ... + x(m) - y(1) - ... - y(n).
409	526	H(y, x, w, ...) = G[ z(x, y), y, x, w, ... ]
410	527	\endverbatim
411	528

427	544	\c m.
428	545	\n
429	546	<tt>parameter[ arg[2] ]</tt>
430		is the parameter value \c p in this cummunative summation.
	547	is the parameter value \c q in this cummunative summation.
431	548	\n
432	549	<tt>arg[2+i]</tt>
433	550	for <tt>i = 1 , ... , m</tt> is the value <tt>x(i)</tt>.

501	618	}
502	619	}
503	620
504		/! \} /
505	621	} // END_CPPAD_NAMESPACE
506	622	# endif

-1

cppad/local/declare_ad.hpp less more

0		/* $Id: declare_ad.hpp 2859 2013-05-28 06:03:21Z bradbell $ */
	0	/* $Id: declare_ad.hpp 3476 2014-12-16 17:15:01Z bradbell $ */
1	1	# ifndef CPPAD_DECLARE_AD_INCLUDED
2	2	# define CPPAD_DECLARE_AD_INCLUDED
3	3

11	11	A copy of this license is included in the COPYING file of this distribution.
12	12	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13	13	-------------------------------------------------------------------------- */
	14
	15	# include <cppad/configure.hpp>
	16	# if CPPAD_HAS_CSTDINT_8_TO_64
	17	# include <cstdint>
	18	# endif
14	19
15	20	namespace CppAD {
16	21	// The conditional expression operator enum type

-18

cppad/local/define.hpp less more

0		/* $Id: define.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: define.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_DEFINE_INCLUDED
2	2	# define CPPAD_DEFINE_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

13	13	-------------------------------------------------------------------------- */
14	14
15	15	/*!
16		\defgroup define_hpp define.hpp
17		\{
18	16	\file define.hpp
19	17	Define processor symbols and macros that are used by CppAD.
20	18	*/

32	30	*/
33	31	# define CPPAD_OP_CODE_TYPE unsigned char
34	32
35		/*!
36		\def CPPAD_USE_FORWARD0SWEEP
37		If ture, use compute zero order sweeps using a specialized routine.
38
39		The value of this define should be zero or one.
40		If it is one, a specialized routine is used for zero order forward sweeps.
41		Otherwise, use the general forward routine is used for zero order.
42		Using the specialized routine is an optimization that makes the source
43		more complicated and a significant speed improvement has not been
44		verified (as yet).
45		This preprocessor symbol makes it easier to compare these two options.
46		*/
47		# define CPPAD_USE_FORWARD0SWEEP 1
48	33
49	34	/*!
50	35	\def CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION

331	316	(const VecAD_reference<double> &left, const double &right) \
332	317	{ return left.ADBase() Op AD<double>(right); }
333	318
334		/! \} /
335	319	# endif

+61

-40

cppad/local/dependent.hpp less more

0		/* $Id: dependent.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: dependent.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_DEPENDENT_INCLUDED
2	2	# define CPPAD_DEPENDENT_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

107	107	No $cref Forward$$ calculation is preformed during this operation.
108	108	Thus, directly after this operation,
109	109	$codei%
110		%f%.size_taylor()
	110	%f%.size_order()
111	111	%$$
112		is zero (see $cref size_taylor$$).
	112	is zero (see $cref size_order$$).
113	113
114	114	$head Parallel Mode$$
115	115	$index parallel, Dependent$$

140	140
141	141	// BEGIN CppAD namespace
142	142	namespace CppAD {
	143
	144	/*!
	145	\file dependent.hpp
	146	Different versions of Dependent function.
	147	*/
143	148
144	149	/*!
145	150	Determine the \c tape corresponding to this exeuction thread and then use

227	232
228	233	\param y
229	234	The dependent variable vector for the function being stored in this object.
	235
	236	\par
	237	All of the private member data in ad_fun.hpp is set to correspond to the
	238	new tape except for check_for_nan_.
230	239	*/
231	240
232	241	template <typename Base>

245	254	y.size() > 0,
246	255	"ADFun operation sequence dependent variable size is zero size"
247	256	);
248
249		// set total number of variables in tape, parameter flag,
250		// make a tape copy of dependent variables that are parameters,
251		// and store tape address for each dependent variable
	257	// ---------------------------------------------------------------------
	258	// Begin setting ad_fun.hpp private member data
	259	// ---------------------------------------------------------------------
	260	// dep_parameter_, dep_taddr_
252	261	CPPAD_ASSERT_UNKNOWN( NumRes(ParOp) == 1 );
253	262	dep_parameter_.resize(m);
254	263	dep_taddr_.resize(m);
255	264	for(i = 0; i < m; i++)
256	265	{ dep_parameter_[i] = CppAD::Parameter(y[i]);
257	266	if( dep_parameter_[i] )
	267	{ // make a tape copy of dependent variables that are parameters,
258	268	y_taddr = tape->RecordParOp( y[i].value_ );
	269	}
259	270	else y_taddr = y[i].taddr_;
260	271
261	272	CPPAD_ASSERT_UNKNOWN( y_taddr > 0 );

265	276	// put an EndOp at the end of the tape
266	277	tape->Rec_.PutOp(EndOp);
267	278
268		// total number of variables on the tape
269		total_num_var_ = tape->Rec_.num_rec_var();
270
271		// conditional skip vector
272		cskip_op_.clear();
273		cskip_op_.resize( tape->Rec_.num_rec_op() );
274		for(i = 0; i < cskip_op_.size(); i++)
275		cskip_op_[i] = false;
276
277		// now that each dependent variable has a place in the tape,
	279	// some size_t values in ad_fun.hpp
	280	compare_change_ = 0;
	281	num_order_taylor_ = 0;
	282	num_direction_taylor_ = 0;
	283	cap_order_taylor_ = 0;
	284
	285	// num_var_tape_
	286	// Now that all the variables are in the tape, we can set this value.
	287	num_var_tape_ = tape->Rec_.num_var_rec();
	288
	289	// taylor_
	290	taylor_.erase();
	291
	292	// cskip_op_
	293	cskip_op_.erase();
	294	cskip_op_.extend( tape->Rec_.num_op_rec() );
	295
	296	// load_op_
	297	load_op_.erase();
	298	load_op_.extend( tape->Rec_.num_load_op_rec() );
	299
	300	// play_
	301	// Now that each dependent variable has a place in the tape,
278	302	// and there is a EndOp at the end of the tape, we can transfer the
279	303	// recording to the player and and erase the tape.
280	304	play_.get(tape->Rec_);
281	305
282		// now we can delete the tape
283		AD<Base>::tape_manage(tape_manage_delete);
284
285		// total number of varables in this recording
286		CPPAD_ASSERT_UNKNOWN( total_num_var_ == play_.num_rec_var() );
287
288		// used to determine if there is an operation sequence in *this
289		CPPAD_ASSERT_UNKNOWN( total_num_var_ > 0 );
290
291		// free old buffers
292		for_jac_sparse_pack_.resize(0, 0);
293		for_jac_sparse_set_.resize(0,0);
294
295		// initial row and column dimensions
296		taylor_.erase();
297		taylor_per_var_ = 0;
298		taylor_col_dim_ = 0;
299
300		// set tape address
	306	// ind_taddr_
	307	// Note that play_ has been set, we can use it to check operators
301	308	ind_taddr_.resize(n);
302		CPPAD_ASSERT_UNKNOWN(
303		n < total_num_var_
304		);
	309	CPPAD_ASSERT_UNKNOWN( n < num_var_tape_);
305	310	for(j = 0; j < n; j++)
306	311	{ CPPAD_ASSERT_UNKNOWN( play_.GetOp(j+1) == InvOp );
307	312	ind_taddr_[j] = j+1;
308	313	}
309	314
	315	// for_jac_sparse_pack_, for_jac_sparse_set_
	316	for_jac_sparse_pack_.resize(0, 0);
	317	for_jac_sparse_set_.resize(0,0);
	318	// ---------------------------------------------------------------------
	319	// End set ad_fun.hpp private member data
	320	// ---------------------------------------------------------------------
	321
	322	// now we can delete the tape
	323	AD<Base>::tape_manage(tape_manage_delete);
	324
	325	// total number of varables in this recording
	326	CPPAD_ASSERT_UNKNOWN( num_var_tape_ == play_.num_var_rec() );
	327
	328	// used to determine if there is an operation sequence in *this
	329	CPPAD_ASSERT_UNKNOWN( num_var_tape_ > 0 );
	330
310	331	}
311	332
312	333	} // END CppAD namespace

-6

cppad/local/discrete.hpp less more

0		/* $Id: discrete.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: discrete.hpp 3359 2014-09-26 00:12:56Z bradbell $ */
1	1	# ifndef CPPAD_DISCRETE_INCLUDED
2	2	# define CPPAD_DISCRETE_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

164	164
165	165	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
166	166	/*!
167		\defgroup discrete_hpp discrete.hpp
168		\{
169	167	\file discrete.hpp
170	168	user define discrete functions
171	169	*/

230	228	/*!
231	229	Constructor called for each invocation of CPPAD_DISCRETE_FUNCTION.
232	230
233		Put this objec in the list of all objects for this class and set
	231	Put this object in the list of all objects for this class and set
234	232	the constant private data name_, f_, and index_.
235	233
236	234	\param Name

306	304	}
307	305	};
308	306
309		/! \} /
310	307	} // END_CPPAD_NAMESPACE
311	308	# endif

+48

-21

cppad/local/discrete_op.hpp less more

0		/* $Id: discrete_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: discrete_op.hpp 3321 2014-09-12 09:50:39Z bradbell $ */
1	1	# ifndef CPPAD_DISCRETE_OP_INCLUDED
2	2	# define CPPAD_DISCRETE_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup discrete_op_hpp discrete_op.hpp
19		\{
20	18	\file discrete_op.hpp
21		Zero order forward mode for z = f(x) where f is piecewise constant.
	19	Forward mode for z = f(x) where f is piecewise constant.
22	20	*/
23	21
24	22
25	23	/*!
26		Compute zero order forward mode Taylor coefficient for result of op = DisOp.
	24	forward mode Taylor coefficient for result of op = DisOp.
27	25
28	26	The C++ source code corresponding to this operation is
29	27	\verbatim

36	34	base type for the operator; i.e., this operation was recorded
37	35	using AD< \a Base > and computations by this routine are done using type
38	36	\a Base .
	37
	38	\param p
	39	is the lowest order Taylor coefficient that will be calculated.
	40
	41	\param q
	42	is the highest order Taylor coefficient that will be calculated.
	43
	44	\param r
	45	is the number of directions, for each order,
	46	that will be calculated (except for order zero wich only has one direction).
39	47
40	48	\param i_z
41	49	variable index corresponding to the result for this operation;

52	60	variable index corresponding to the argument for this operator;
53	61	i.e. the row index in \a taylor corresponding to x.
54	62
55		\param nc_taylor
56		number of colums in the matrix containing all the Taylor coefficients.
	63	\param cap_order
	64	maximum number of orders that will fit in the taylor array.
	65
	66	\par tpv
	67	We use the notation
	68	<code>tpv = (cap_order-1) * r + 1</code>
	69	which is the number of Taylor coefficients per variable
57	70
58	71	\param taylor
59		\b Input: \a taylor [ \a arg[1] * \a nc_taylor + 0 ]
60		is the zero order Taylor coefficient corresponding to x.
	72	\b Input: <code>taylor [ arg[1] * tpv + 0 ]</code>
	73	is the zero order Taylor coefficient corresponding to x.
61	74	\n
62		\b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
	75	\b Output: if <code>p == 0</code>
	76	<code>taylor [ i_z * tpv + 0 ]</code>
63	77	is the zero order Taylor coefficient corresponding to z.
	78	For k = max(p, 1), ... , q,
	79	<code>taylor [ i_z * tpv + (k-1)*r + 1 + ell ]</code>
	80	is the k-th order Taylor coefficient corresponding to z
	81	(which is zero).
64	82
65	83	\par Checked Assertions where op is the unary operator with one result:
66	84	\li NumArg(op) == 2
67	85	\li NumRes(op) == 1
68		\li \a arg[1] < \a i_z
69		\li \a 0 < \a nc_taylor
	86	\li q < cap_order
	87	\li 0 < r
70	88	*/
71	89	template <class Base>
72		inline void forward_dis_op_0(
	90	inline void forward_dis_op(
	91	size_t p ,
	92	size_t q ,
	93	size_t r ,
73	94	size_t i_z ,
74	95	const addr_t* arg ,
75		size_t nc_taylor ,
	96	size_t cap_order ,
76	97	Base* taylor )
77	98	{
78	99	// check assumptions
79	100	CPPAD_ASSERT_UNKNOWN( NumArg(DisOp) == 2 );
80	101	CPPAD_ASSERT_UNKNOWN( NumRes(DisOp) == 1 );
81		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
82		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	102	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	103	CPPAD_ASSERT_UNKNOWN( 0 < r );
83	104
84	105	// Taylor coefficients corresponding to argument and result
85		Base* x = taylor + arg[1] * nc_taylor;
86		Base* z = taylor + i_z * nc_taylor;
	106	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	107	Base* x = taylor + arg[1] * num_taylor_per_var;
	108	Base* z = taylor + i_z * num_taylor_per_var;
87	109
88		z[0] = discrete<Base>::eval(arg[0], x[0]);
	110	if( p == 0 )
	111	{ z[0] = discrete<Base>::eval(arg[0], x[0]);
	112	p++;
	113	}
	114	for(size_t ell = 0; ell < r; ell++)
	115	for(size_t k = p; k <= q; k++)
	116	z[ (k-1) * r + 1 + ell ] = Base(0);
89	117	}
90	118
91	119
92		/! \} /
93	120	} // END_CPPAD_NAMESPACE
94	121	# endif

+240

-121

cppad/local/div_op.hpp less more

0		/* $Id: div_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: div_op.hpp 3321 2014-09-12 09:50:39Z bradbell $ */
1	1	# ifndef CPPAD_DIV_OP_INCLUDED
2	2	# define CPPAD_DIV_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup div_op_hpp div_op.hpp
18		\{
19	17	\file div_op.hpp
20	18	Forward and reverse mode calculations for z = x / y.
21	19	*/

37	35
38	36	template <class Base>
39	37	inline void forward_divvv_op(
	38	size_t p ,
40	39	size_t q ,
41		size_t p ,
42		size_t i_z ,
43		const addr_t* arg ,
44		const Base* parameter ,
45		size_t nc_taylor ,
	40	size_t i_z ,
	41	const addr_t* arg ,
	42	const Base* parameter ,
	43	size_t cap_order ,
46	44	Base* taylor )
47	45	{
48	46	// check assumptions
49	47	CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
50	48	CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
51		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
52		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
53		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
54		CPPAD_ASSERT_UNKNOWN( q <= p );
55
56		// Taylor coefficients corresponding to arguments and result
57		Base* x = taylor + arg[0] * nc_taylor;
58		Base* y = taylor + arg[1] * nc_taylor;
59		Base* z = taylor + i_z * nc_taylor;
	49	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	50	CPPAD_ASSERT_UNKNOWN( p <= q );
	51
	52	// Taylor coefficients corresponding to arguments and result
	53	Base* x = taylor + arg[0] * cap_order;
	54	Base* y = taylor + arg[1] * cap_order;
	55	Base* z = taylor + i_z * cap_order;
60	56
61	57
62	58	// Using CondExp, it can make sense to divide by zero,
63	59	// so do not make it an error.
64	60	size_t k;
65		for(size_t d = q; d <= p; d++)
	61	for(size_t d = p; d <= q; d++)
66	62	{ z[d] = x[d];
67	63	for(k = 1; k <= d; k++)
68	64	z[d] -= z[d-k] * y[k];
69	65	z[d] /= y[0];
70	66	}
71	67	}
72
73
74		/*!
75		Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
	68	/*!
	69	Multiple directions forward mode Taylor coefficients for op = DivvvOp.
76	70
77	71	The C++ source code corresponding to this operation is
78	72	\verbatim

82	76	this operations is for the case where both x and y are variables
83	77	and the argument \a parameter is not used.
84	78
85		\copydetails forward_binary_op_0
86		*/
87
88		template <class Base>
89		inline void forward_divvv_op_0(
90		size_t i_z ,
91		const addr_t* arg ,
92		const Base* parameter ,
93		size_t nc_taylor ,
	79	\copydetails forward_binary_op_dir
	80	*/
	81
	82	template <class Base>
	83	inline void forward_divvv_op_dir(
	84	size_t q ,
	85	size_t r ,
	86	size_t i_z ,
	87	const addr_t* arg ,
	88	const Base* parameter ,
	89	size_t cap_order ,
94	90	Base* taylor )
95	91	{
96	92	// check assumptions
97	93	CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
98	94	CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
99		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
100		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
101
102		// Taylor coefficients corresponding to arguments and result
103		Base* x = taylor + arg[0] * nc_taylor;
104		Base* y = taylor + arg[1] * nc_taylor;
105		Base* z = taylor + i_z * nc_taylor;
106
107		z[0] = x[0] / y[0];
108		}
109
110		/*!
111		Compute reverse mode partial derivatives for result of op = DivvvOp.
	95	CPPAD_ASSERT_UNKNOWN( 0 < q );
	96	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	97
	98	// Taylor coefficients corresponding to arguments and result
	99	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	100	Base* x = taylor + arg[0] * num_taylor_per_var;
	101	Base* y = taylor + arg[1] * num_taylor_per_var;
	102	Base* z = taylor + i_z * num_taylor_per_var;
	103
	104
	105	// Using CondExp, it can make sense to divide by zero,
	106	// so do not make it an error.
	107	size_t m = (q-1) * r + 1;
	108	for(size_t ell = 0; ell < r; ell++)
	109	{ z[m+ell] = x[m+ell] - z[0] * y[m+ell];
	110	for(size_t k = 1; k < q; k++)
	111	z[m+ell] -= z[(q-k-1)r+1+ell] y[(k-1)*r+1+ell];
	112	z[m+ell] /= y[0];
	113	}
	114	}
	115
	116
	117	/*!
	118	Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
112	119
113	120	The C++ source code corresponding to this operation is
114	121	\verbatim

118	125	this operations is for the case where both x and y are variables
119	126	and the argument \a parameter is not used.
120	127
	128	\copydetails forward_binary_op_0
	129	*/
	130
	131	template <class Base>
	132	inline void forward_divvv_op_0(
	133	size_t i_z ,
	134	const addr_t* arg ,
	135	const Base* parameter ,
	136	size_t cap_order ,
	137	Base* taylor )
	138	{
	139	// check assumptions
	140	CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
	141	CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
	142
	143	// Taylor coefficients corresponding to arguments and result
	144	Base* x = taylor + arg[0] * cap_order;
	145	Base* y = taylor + arg[1] * cap_order;
	146	Base* z = taylor + i_z * cap_order;
	147
	148	z[0] = x[0] / y[0];
	149	}
	150
	151	/*!
	152	Compute reverse mode partial derivatives for result of op = DivvvOp.
	153
	154	The C++ source code corresponding to this operation is
	155	\verbatim
	156	z = x / y
	157	\endverbatim
	158	In the documentation below,
	159	this operations is for the case where both x and y are variables
	160	and the argument \a parameter is not used.
	161
121	162	\copydetails reverse_binary_op
122	163	*/
123	164

127	168	size_t i_z ,
128	169	const addr_t* arg ,
129	170	const Base* parameter ,
130		size_t nc_taylor ,
	171	size_t cap_order ,
131	172	const Base* taylor ,
132	173	size_t nc_partial ,
133	174	Base* partial )

135	176	// check assumptions
136	177	CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
137	178	CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
138		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
139		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
140		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	179	CPPAD_ASSERT_UNKNOWN( d < cap_order );
141	180	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
142	181
143	182	// Arguments
144		const Base* y = taylor + arg[1] * nc_taylor;
145		const Base* z = taylor + i_z * nc_taylor;
	183	const Base* y = taylor + arg[1] * cap_order;
	184	const Base* z = taylor + i_z * cap_order;
146	185
147	186	// Partial derivatives corresponding to arguments and result
148	187	Base* px = partial + arg[0] * nc_partial;

185	224
186	225	template <class Base>
187	226	inline void forward_divpv_op(
	227	size_t p ,
188	228	size_t q ,
189		size_t p ,
190		size_t i_z ,
191		const addr_t* arg ,
192		const Base* parameter ,
193		size_t nc_taylor ,
	229	size_t i_z ,
	230	const addr_t* arg ,
	231	const Base* parameter ,
	232	size_t cap_order ,
194	233	Base* taylor )
195	234	{
196	235	// check assumptions
197	236	CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
198	237	CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
199		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
200		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
201		CPPAD_ASSERT_UNKNOWN( q <= p );
202
203		// Taylor coefficients corresponding to arguments and result
204		Base* y = taylor + arg[1] * nc_taylor;
205		Base* z = taylor + i_z * nc_taylor;
	238	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	239	CPPAD_ASSERT_UNKNOWN( p <= q );
	240
	241	// Taylor coefficients corresponding to arguments and result
	242	Base* y = taylor + arg[1] * cap_order;
	243	Base* z = taylor + i_z * cap_order;
206	244
207	245	// Paraemter value
208	246	Base x = parameter[ arg[0] ];

210	248	// Using CondExp, it can make sense to divide by zero,
211	249	// so do not make it an error.
212	250	size_t k;
213		if( q == 0 )
	251	if( p == 0 )
214	252	{ z[0] = x / y[0];
215		q++;
216		}
217		for(size_t d = q; d <= p; d++)
	253	p++;
	254	}
	255	for(size_t d = p; d <= q; d++)
218	256	{ z[d] = Base(0);
219	257	for(k = 1; k <= d; k++)
220	258	z[d] -= z[d-k] * y[k];
221	259	z[d] /= y[0];
222	260	}
223	261	}
224
225		/*!
226		Compute zero order forward mode Taylor coefficient for result of op = DivpvOp.
	262	/*!
	263	Multiple directions forward mode Taylor coefficients for op = DivpvOp.
227	264
228	265	The C++ source code corresponding to this operation is
229	266	\verbatim

232	269	In the documentation below,
233	270	this operations is for the case where x is a parameter and y is a variable.
234	271
235		\copydetails forward_binary_op_0
236		*/
237
238		template <class Base>
239		inline void forward_divpv_op_0(
240		size_t i_z ,
241		const addr_t* arg ,
242		const Base* parameter ,
243		size_t nc_taylor ,
	272	\copydetails forward_binary_op_dir
	273	*/
	274
	275	template <class Base>
	276	inline void forward_divpv_op_dir(
	277	size_t q ,
	278	size_t r ,
	279	size_t i_z ,
	280	const addr_t* arg ,
	281	const Base* parameter ,
	282	size_t cap_order ,
244	283	Base* taylor )
245	284	{
246	285	// check assumptions
247	286	CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
248	287	CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
249		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
	288	CPPAD_ASSERT_UNKNOWN( 0 < q );
	289	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	290
	291	// Taylor coefficients corresponding to arguments and result
	292	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	293	Base* y = taylor + arg[1] * num_taylor_per_var;
	294	Base* z = taylor + i_z * num_taylor_per_var;
	295
	296	// Using CondExp, it can make sense to divide by zero,
	297	// so do not make it an error.
	298	size_t m = (q-1) * r + 1;
	299	for(size_t ell = 0; ell < r; ell++)
	300	{ z[m+ell] = - z[0] * y[m+ell];
	301	for(size_t k = 1; k < q; k++)
	302	z[m+ell] -= z[(q-k-1)r+1+ell] y[(k-1)*r+1+ell];
	303	z[m+ell] /= y[0];
	304	}
	305	}
	306
	307	/*!
	308	Compute zero order forward mode Taylor coefficient for result of op = DivpvOp.
	309
	310	The C++ source code corresponding to this operation is
	311	\verbatim
	312	z = x / y
	313	\endverbatim
	314	In the documentation below,
	315	this operations is for the case where x is a parameter and y is a variable.
	316
	317	\copydetails forward_binary_op_0
	318	*/
	319
	320	template <class Base>
	321	inline void forward_divpv_op_0(
	322	size_t i_z ,
	323	const addr_t* arg ,
	324	const Base* parameter ,
	325	size_t cap_order ,
	326	Base* taylor )
	327	{
	328	// check assumptions
	329	CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );
	330	CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
250	331
251	332	// Paraemter value
252	333	Base x = parameter[ arg[0] ];
253	334
254	335	// Taylor coefficients corresponding to arguments and result
255		Base* y = taylor + arg[1] * nc_taylor;
256		Base* z = taylor + i_z * nc_taylor;
	336	Base* y = taylor + arg[1] * cap_order;
	337	Base* z = taylor + i_z * cap_order;
257	338
258	339	z[0] = x / y[0];
259	340	}

277	358	size_t i_z ,
278	359	const addr_t* arg ,
279	360	const Base* parameter ,
280		size_t nc_taylor ,
	361	size_t cap_order ,
281	362	const Base* taylor ,
282	363	size_t nc_partial ,
283	364	Base* partial )

285	366	// check assumptions
286	367	CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );
287	368	CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
288		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
289		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	369	CPPAD_ASSERT_UNKNOWN( d < cap_order );
290	370	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
291	371
292	372	// Arguments
293		const Base* y = taylor + arg[1] * nc_taylor;
294		const Base* z = taylor + i_z * nc_taylor;
	373	const Base* y = taylor + arg[1] * cap_order;
	374	const Base* z = taylor + i_z * cap_order;
295	375
296	376	// Partial derivatives corresponding to arguments and result
297	377	Base* py = partial + arg[1] * nc_partial;

333	413
334	414	template <class Base>
335	415	inline void forward_divvp_op(
	416	size_t p ,
336	417	size_t q ,
337		size_t p ,
338		size_t i_z ,
339		const addr_t* arg ,
340		const Base* parameter ,
341		size_t nc_taylor ,
	418	size_t i_z ,
	419	const addr_t* arg ,
	420	const Base* parameter ,
	421	size_t cap_order ,
342	422	Base* taylor )
343	423	{
344	424	// check assumptions
345	425	CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
346	426	CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
347		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
348		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
349		CPPAD_ASSERT_UNKNOWN( q <= p );
350
351		// Taylor coefficients corresponding to arguments and result
352		Base* x = taylor + arg[0] * nc_taylor;
353		Base* z = taylor + i_z * nc_taylor;
	427	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	428	CPPAD_ASSERT_UNKNOWN( p <= q );
	429
	430	// Taylor coefficients corresponding to arguments and result
	431	Base* x = taylor + arg[0] * cap_order;
	432	Base* z = taylor + i_z * cap_order;
354	433
355	434	// Parameter value
356	435	Base y = parameter[ arg[1] ];
357	436
358	437	// Using CondExp and multiple levels of AD, it can make sense
359	438	// to divide by zero so do not make it an error.
360		for(size_t d = q; d <= p; d++)
	439	for(size_t d = p; d <= q; d++)
361	440	z[d] = x[d] / y;
362	441	}
363
364
365		/*!
366		Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
	442	/*!
	443	Multiple direction forward mode Taylor coefficients for op = DivvvOp.
367	444
368	445	The C++ source code corresponding to this operation is
369	446	\verbatim

372	449	In the documentation below,
373	450	this operations is for the case where x is a variable and y is a parameter.
374	451
375		\copydetails forward_binary_op_0
376		*/
377
378		template <class Base>
379		inline void forward_divvp_op_0(
380		size_t i_z ,
381		const addr_t* arg ,
382		const Base* parameter ,
383		size_t nc_taylor ,
	452	\copydetails forward_binary_op_dir
	453	*/
	454
	455	template <class Base>
	456	inline void forward_divvp_op_dir(
	457	size_t q ,
	458	size_t r ,
	459	size_t i_z ,
	460	const addr_t* arg ,
	461	const Base* parameter ,
	462	size_t cap_order ,
384	463	Base* taylor )
385	464	{
386	465	// check assumptions
387	466	CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
388	467	CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
389		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
	468	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	469	CPPAD_ASSERT_UNKNOWN( 0 < q );
	470
	471	// Taylor coefficients corresponding to arguments and result
	472	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	473	Base* x = taylor + arg[0] * num_taylor_per_var;
	474	Base* z = taylor + i_z * num_taylor_per_var;
390	475
391	476	// Parameter value
392	477	Base y = parameter[ arg[1] ];
393	478
394		// Taylor coefficients corresponding to arguments and result
395		Base* x = taylor + arg[0] * nc_taylor;
396		Base* z = taylor + i_z * nc_taylor;
	479	// Using CondExp and multiple levels of AD, it can make sense
	480	// to divide by zero so do not make it an error.
	481	size_t m = (q-1)*r + 1;
	482	for(size_t ell = 0; ell < r; ell++)
	483	z[m + ell] = x[m + ell] / y;
	484	}
	485
	486
	487	/*!
	488	Compute zero order forward mode Taylor coefficients for result of op = DivvvOp.
	489
	490	The C++ source code corresponding to this operation is
	491	\verbatim
	492	z = x / y
	493	\endverbatim
	494	In the documentation below,
	495	this operations is for the case where x is a variable and y is a parameter.
	496
	497	\copydetails forward_binary_op_0
	498	*/
	499
	500	template <class Base>
	501	inline void forward_divvp_op_0(
	502	size_t i_z ,
	503	const addr_t* arg ,
	504	const Base* parameter ,
	505	size_t cap_order ,
	506	Base* taylor )
	507	{
	508	// check assumptions
	509	CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
	510	CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
	511
	512	// Parameter value
	513	Base y = parameter[ arg[1] ];
	514
	515	// Taylor coefficients corresponding to arguments and result
	516	Base* x = taylor + arg[0] * cap_order;
	517	Base* z = taylor + i_z * cap_order;
397	518
398	519	z[0] = x[0] / y;
399	520	}

417	538	size_t i_z ,
418	539	const addr_t* arg ,
419	540	const Base* parameter ,
420		size_t nc_taylor ,
	541	size_t cap_order ,
421	542	const Base* taylor ,
422	543	size_t nc_partial ,
423	544	Base* partial )

425	546	// check assumptions
426	547	CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );
427	548	CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
428		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
429		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	549	CPPAD_ASSERT_UNKNOWN( d < cap_order );
430	550	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
431	551
432	552	// Argument values

447	567	}
448	568	}
449	569
450		/! \} /
451	570	} // END_CPPAD_NAMESPACE
452	571	# endif

+22

-3

cppad/local/erf.hpp less more

0		/* $Id: erf.hpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: erf.hpp 3495 2014-12-24 01:16:15Z bradbell $
1	1	# ifndef CPPAD_ERF_INCLUDED
2	2	# define CPPAD_ERF_INCLUDED
3	3

18	18
19	19	$section The AD Error Function$$
20	20	$spell
	21	std
	22	cmath
21	23	Vedder
22	24	Cpp
23	25	namespace

58	60	of $icode x$$.
59	61
60	62	$head Method$$
61		This is a fast approximation (few numerical operations)
	63
	64	$subhead CPPAD_COMPILER_HAS_ERF$$
	65	$index CPPAD_COMPILER_HAS_ERF$$
	66	This preprocessor symbol is one if
	67	the function $codei%std::erf(double %x%)%$$ is defined the in the
	68	include file $code <cmath>$$.
	69	Otherwise this preprocessor symbol is zero.
	70	If this preprocessor symbols is one,
	71	CppAD uses the compiler's version of $code erf$$
	72	and it corresponds to an $cref/atomic/glossary/Operation/Atomic/$$ operation.
	73
	74	$subhead Other$$
	75	If the function $codei%std::erf(double %x%)%$$ is not defined,
	76	CppAD uses a fast approximation (few numerical operations)
62	77	with relative error bound $latex 4 \times 10^{-4}$$; see
63	78	Vedder, J.D.,
64	79	$icode Simple approximations for the error function and its inverse$$,

80	95	$end
81	96	-------------------------------------------------------------------------------
82	97	*/
	98	# include <cppad/configure.hpp>
83	99	# include <cppad/local/cppad_assert.hpp>
84	100
85	101	// needed before one can use CPPAD_ASSERT_FIRST_CALL_NOT_PARALLEL
86	102	# include <cppad/thread_alloc.hpp>
	103
	104	# if ! CPPAD_COMPILER_HAS_ERF
87	105
88	106	// BEGIN CppAD namespace
89	107	namespace CppAD {

114	132
115	133	} // END CppAD namespace
116	134
117		# endif
	135	# endif // CPPAD_COMPILER_HAS_ERF
	136	# endif // CPPAD_ERF_INCLUDED

+420

-0

cppad/local/erf_op.hpp less more

	0	/* $Id$ */
	1	# ifndef CPPAD_ERF_OP_INCLUDED
	2	# define CPPAD_ERF_OP_INCLUDED
	3	# if CPPAD_COMPILER_HAS_ERF
	4
	5	/* --------------------------------------------------------------------------
	6	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	7
	8	CppAD is distributed under multiple licenses. This distribution is under
	9	the terms of the
	10	GNU General Public License Version 3.
	11
	12	A copy of this license is included in the COPYING file of this distribution.
	13	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	14	-------------------------------------------------------------------------- */
	15
	16	# include <cppad/local/mul_op.hpp>
	17	# include <cppad/local/sub_op.hpp>
	18	# include <cppad/local/exp_op.hpp>
	19
	20
	21	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
	22	/*!
	23	\file erf_op.hpp
	24	Forward and reverse mode calculations for z = erf(x).
	25	*/
	26
	27	/*!
	28	Forward mode Taylor coefficient for result of op = ErfOp.
	29
	30	The C++ source code corresponding to this operation is
	31	\verbatim
	32	z = erf(x)
	33	\endverbatim
	34
	35	\par CPPAD_HAS_ERROF_FUNCTION
	36	This macro is either zero or one and forward_erf_op is only defined
	37	when it is one.
	38
	39	\tparam Base
	40	base type for the operator; i.e., this operation was recorded
	41	using AD< \a Base > and computations by this routine are done using type
	42	\a Base.
	43
	44	\param p
	45	lowest order of the Taylor coefficients that we are computing.
	46
	47	\param q
	48	highest order of the Taylor coefficients that we are computing.
	49
	50	\param i_z
	51	variable index corresponding to the last (primary) result for this operation;
	52	i.e. the row index in \a taylor corresponding to z.
	53	The auxillary result is called y has index \a i_z - 1.
	54
	55	\param arg
	56	arg[0]: is the variable index corresponding to x.
	57	\n
	58	arg[1]: is the parameter index corresponding to the value zero.
	59	\n
	60	\arg[2]: is the parameter index correspodning to the value 2 / sqrt(pi).
	61
	62	\param parameter
	63	parameter[ arg[1] ] is the value zero,
	64	and parameter[ arg[2] ] is the value 2 / sqrt(pi).
	65
	66	\param cap_order
	67	maximum number of orders that will fit in the \c taylor array.
	68
	69	\param taylor
	70	\b Input:
	71	taylor [ arg[0] * cap_order + k ]
	72	for k = 0 , ... , q,
	73	is the k-th order Taylor coefficient corresponding to x.
	74	\n
	75	\b Input:
	76	taylor [ i_z * cap_order + k ]
	77	for k = 0 , ... , p - 1,
	78	is the k-th order Taylor coefficient corresponding to z.
	79	\n
	80	\b Input:
	81	taylor [ ( i_z - j) * cap_order + k ]
	82	for k = 0 , ... , p-1,
	83	and j = 0 , ... , 4,
	84	is the k-th order Taylor coefficient corresponding to the j-th result for z.
	85	\n
	86	\b Output:
	87	taylor [ (i_z-j) * cap_order + k ],
	88	for k = p , ... , q,
	89	and j = 0 , ... , 4,
	90	is the k-th order Taylor coefficient corresponding to the j-th result for z.
	91
	92	\par Checked Assertions
	93	\li NumArg(op) == 3
	94	\li NumRes(op) == 5
	95	\li q < cap_order
	96	\li p <= q
	97	*/
	98	template <class Base>
	99	inline void forward_erf_op(
	100	size_t p ,
	101	size_t q ,
	102	size_t i_z ,
	103	const addr_t* arg ,
	104	const Base* parameter ,
	105	size_t cap_order ,
	106	Base* taylor )
	107	{
	108	// check assumptions
	109	CPPAD_ASSERT_UNKNOWN( NumArg(ErfOp) == 3 );
	110	CPPAD_ASSERT_UNKNOWN( NumRes(ErfOp) == 5 );
	111	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	112	CPPAD_ASSERT_UNKNOWN( p <= q );
	113
	114	// array used to pass parameter values for sub-operations
	115	addr_t addr[2];
	116
	117	// convert from final result to first result
	118	i_z -= 4; // 4 = NumRes(ErfOp) - 1;
	119
	120	// z_0 = x * x
	121	addr[0] = arg[0]; // x
	122	addr[1] = arg[0]; // x
	123	forward_mulvv_op(p, q, i_z+0, addr, parameter, cap_order, taylor);
	124
	125	// z_1 = - x * x
	126	addr[0] = arg[1]; // zero
	127	addr[1] = i_z; // z_0
	128	forward_subpv_op(p, q, i_z+1, addr, parameter, cap_order, taylor);
	129
	130	// z_2 = exp( - x * x )
	131	forward_exp_op(p, q, i_z+2, i_z+1, cap_order, taylor);
	132
	133	// z_3 = (2 / sqrt(pi)) * exp( - x * x )
	134	addr[0] = arg[2]; // 2 / sqrt(pi)
	135	addr[1] = i_z + 2; // z_2
	136	forward_mulpv_op(p, q, i_z+3, addr, parameter, cap_order, taylor);
	137
	138	// pointers to taylor coefficients for x , z_3, and z_4
	139	Base* x = taylor + arg[0] * cap_order;
	140	Base* z_3 = taylor + (i_z+3) * cap_order;
	141	Base* z_4 = taylor + (i_z+4) * cap_order;
	142
	143	// calculte z_4 coefficients
	144	if( p == 0 )
	145	{ // zero order Taylor coefficient for z_4
	146	z_4[0] = erf(x[0]);
	147	p++;
	148	}
	149	for(size_t j = p; j <= q; j++)
	150	{ Base base_j = static_cast<Base>(j);
	151	z_4[j] = static_cast<Base>(0);
	152	for(size_t k = 1; k <= j; k++)
	153	z_4[j] += (Base(k) / base_j) * x[k] * z_3[j-k];
	154	}
	155	}
	156
	157	/*!
	158	Zero order Forward mode Taylor coefficient for result of op = ErfOp.
	159
	160	The C++ source code corresponding to this operation is
	161	\verbatim
	162	z = erf(x)
	163	\endverbatim
	164
	165	\par CPPAD_HAS_ERROF_FUNCTION
	166	This macro is either zero or one and forward_erf_op is only defined
	167	when it is one.
	168
	169	\tparam Base
	170	base type for the operator; i.e., this operation was recorded
	171	using AD< \a Base > and computations by this routine are done using type
	172	\a Base.
	173
	174	\param i_z
	175	variable index corresponding to the last (primary) result for this operation;
	176	i.e. the row index in \a taylor corresponding to z.
	177	The auxillary result is called y has index \a i_z - 1.
	178
	179	\param arg
	180	arg[0]: is the variable index corresponding to x.
	181	\n
	182	arg[1]: is the parameter index corresponding to the value zero.
	183	\n
	184	\arg[2]: is the parameter index correspodning to the value 2 / sqrt(pi).
	185
	186	\param parameter
	187	parameter[ arg[1] ] is the value zero,
	188	and parameter[ arg[2] ] is the value 2 / sqrt(pi).
	189
	190	\param cap_order
	191	maximum number of orders that will fit in the \c taylor array.
	192
	193	\param taylor
	194	\b Input:
	195	taylor [ arg[0] * cap_order + 0 ]
	196	is the zero order Taylor coefficient corresponding to x.
	197	\n
	198	\b Input:
	199	taylor [ i_z * cap_order + 0 ]
	200	is the zero order Taylor coefficient corresponding to z.
	201	\n
	202	\b Output:
	203	taylor [ (i_z-j) * cap_order + 0 ],
	204	for j = 0 , ... , 4,
	205	is the zero order Taylor coefficient for j-th result corresponding to z.
	206
	207	\par Checked Assertions
	208	\li NumArg(op) == 3
	209	\li NumRes(op) == 5
	210	\li q < cap_order
	211	\li p <= q
	212	*/
	213	template <class Base>
	214	inline void forward_erf_op_0(
	215	size_t i_z ,
	216	const addr_t* arg ,
	217	const Base* parameter ,
	218	size_t cap_order ,
	219	Base* taylor )
	220	{
	221	// check assumptions
	222	CPPAD_ASSERT_UNKNOWN( NumArg(ErfOp) == 3 );
	223	CPPAD_ASSERT_UNKNOWN( NumRes(ErfOp) == 5 );
	224	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
	225
	226	// array used to pass parameter values for sub-operations
	227	addr_t addr[2];
	228
	229	// convert from final result to first result
	230	i_z -= 4; // 4 = NumRes(ErfOp) - 1;
	231
	232	// z_0 = x * x
	233	addr[0] = arg[0]; // x
	234	addr[1] = arg[0]; // x
	235	forward_mulvv_op_0(i_z+0, addr, parameter, cap_order, taylor);
	236
	237	// z_1 = - x * x
	238	addr[0] = arg[1]; // zero
	239	addr[1] = i_z; // z_0
	240	forward_subpv_op_0(i_z+1, addr, parameter, cap_order, taylor);
	241
	242	// z_2 = exp( - x * x )
	243	forward_exp_op_0(i_z+2, i_z+1, cap_order, taylor);
	244
	245	// z_3 = (2 / sqrt(pi)) * exp( - x * x )
	246	addr[0] = arg[2]; // 2 / sqrt(pi)
	247	addr[1] = i_z + 2; // z_2
	248	forward_mulpv_op_0(i_z+3, addr, parameter, cap_order, taylor);
	249
	250	// zero order Taylor coefficient for z_4
	251	Base* x = taylor + arg[0] * cap_order;
	252	Base* z_4 = taylor + i_z + 4 * cap_order;
	253	z_4[0] = erf(x[0]);
	254	}
	255
	256	/*!
	257	Compute reverse mode partial derivatives for result of op = ErfOp.
	258
	259	The C++ source code corresponding to this operation is
	260	\verbatim
	261	z = erf(x)
	262	\endverbatim
	263
	264	\par CPPAD_HAS_ERROF_FUNCTION
	265	This macro is either zero or one and reverse_tan_op is only defined
	266	when it is one.
	267
	268	\tparam Base
	269	base type for the operator; i.e., this operation was recorded
	270	using AD< \a Base > and computations by this routine are done using type
	271	\a Base.
	272
	273	\param d
	274	highest order Taylor of the Taylor coefficients that we are computing
	275	the partial derivatives with respect to.
	276
	277	\param i_z
	278	variable index corresponding to the last (primary) result for this operation;
	279	i.e. the row index in \a taylor corresponding to z.
	280	The auxillary result is called y has index \a i_z - 1.
	281
	282	\param arg
	283	arg[0]: is the variable index corresponding to x.
	284	\n
	285	arg[1]: is the parameter index corresponding to the value zero.
	286	\n
	287	\arg[2]: is the parameter index correspodning to the value 2 / sqrt(pi).
	288
	289	\param parameter
	290	parameter[ arg[1] ] is the value zero,
	291	and parameter[ arg[2] ] is the value 2 / sqrt(pi).
	292
	293	\param cap_order
	294	maximum number of orders that will fit in the \c taylor array.
	295
	296	\param taylor
	297	\b Input:
	298	taylor [ arg[0] * cap_order + k ]
	299	for k = 0 , ... , d,
	300	is the k-th order Taylor coefficient corresponding to x.
	301	\n
	302	taylor [ (i_z - j) * cap_order + k ]
	303	for k = 0 , ... , d,
	304	and for j = 0 , ... , 4,
	305	is the k-th order Taylor coefficient corresponding to the j-th result
	306	for this operation.
	307
	308	\param nc_partial
	309	number of columns in the matrix containing all the partial derivatives
	310
	311	\param partial
	312	\b Input:
	313	partial [ arg[0] * nc_partial + k ]
	314	for k = 0 , ... , d,
	315	is the partial derivative of G( z , x , w , u , ... ) with respect to
	316	the k-th order Taylor coefficient for x.
	317	\n
	318	\b Input:
	319	partial [ (i_z - j) * nc_partial + k ]
	320	for k = 0 , ... , d,
	321	and for j = 0 , ... , 4,
	322	is the partial derivative of G( z , x , w , u , ... ) with respect to
	323	the k-th order Taylor coefficient for the j-th result of this operation.
	324	\n
	325	\b Output:
	326	partial [ arg[0] * nc_partial + k ]
	327	for k = 0 , ... , d,
	328	is the partial derivative of H( x , w , u , ... ) with respect to
	329	the k-th order Taylor coefficient for x.
	330	\n
	331	\b Output:
	332	partial [ (i_z-j) * nc_partial + k ]
	333	for k = 0 , ... , d,
	334	and for j = 0 , ... , 4,
	335	may be used as work space; i.e., may change in an unspecified manner.
	336
	337	\par Checked Assertions
	338	\li NumArg(op) == 3
	339	\li NumRes(op) == 5
	340	\li q < cap_order
	341	\li p <= q
	342	*/
	343	template <class Base>
	344	inline void reverse_erf_op(
	345	size_t d ,
	346	size_t i_z ,
	347	const addr_t* arg ,
	348	const Base* parameter ,
	349	size_t cap_order ,
	350	const Base* taylor ,
	351	size_t nc_partial ,
	352	Base* partial )
	353	{
	354	// check assumptions
	355	CPPAD_ASSERT_UNKNOWN( NumArg(ErfOp) == 3 );
	356	CPPAD_ASSERT_UNKNOWN( NumRes(ErfOp) == 5 );
	357	CPPAD_ASSERT_UNKNOWN( d < cap_order );
	358
	359	// array used to pass parameter values for sub-operations
	360	addr_t addr[2];
	361
	362	// convert from final result to first result
	363	i_z -= 4; // 4 = NumRes(ErfOp) - 1;
	364
	365	// Taylor coefficients and partials corresponding to x
	366	const Base* x = taylor + arg[0] * cap_order;
	367	Base* px = partial + arg[0] * nc_partial;
	368
	369	// Taylor coefficients and partials corresponding to z_3
	370	const Base* z_3 = taylor + (i_z+3) * cap_order;
	371	Base* pz_3 = partial + (i_z+3) * nc_partial;
	372
	373	// Taylor coefficients and partials corresponding to z_4
	374	Base* pz_4 = partial + (i_z+4) * nc_partial;
	375
	376	// Reverse z_4
	377	size_t j = d;
	378	while(j)
	379	{ pz_4[j] /= Base(j);
	380	for(size_t k = 1; k <= j; k++)
	381	{ px[k] += pz_4[j] * z_3[j-k] * Base(k);
	382	pz_3[j-k] += pz_4[j] * x[k] * Base(k);
	383	}
	384	j--;
	385	}
	386	px[0] += pz_4[0] * z_3[0];
	387
	388	// z_3 = (2 / sqrt(pi)) * exp( - x * x )
	389	addr[0] = arg[2]; // 2 / sqrt(pi)
	390	addr[1] = i_z + 2; // z_2
	391	reverse_mulpv_op(
	392	d, i_z+3, addr, parameter, cap_order, taylor, nc_partial, partial
	393	);
	394
	395	// z_2 = exp( - x * x )
	396	reverse_exp_op(
	397	d, i_z+2, i_z+1, cap_order, taylor, nc_partial, partial
	398	);
	399
	400	// z_1 = - x * x
	401	addr[0] = arg[1]; // zero
	402	addr[1] = i_z; // z_0
	403	reverse_subpv_op(
	404	d, i_z+1, addr, parameter, cap_order, taylor, nc_partial, partial
	405	);
	406
	407	// z_0 = x * x
	408	addr[0] = arg[0]; // x
	409	addr[1] = arg[0]; // x
	410	reverse_mulvv_op(
	411	d, i_z+0, addr, parameter, cap_order, taylor, nc_partial, partial
	412	);
	413
	414	}
	415
	416
	417	} // END_CPPAD_NAMESPACE
	418	# endif // CPPAD_COMPILER_HAS_ERF
	419	# endif // CPPAD_ERF_OP_INCLUDED

+59

-25

cppad/local/exp_op.hpp less more

0		/* $Id: exp_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: exp_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_EXP_OP_INCLUDED
2	2	# define CPPAD_EXP_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup exp_op_hpp exp_op.hpp
19		\{
20	18	\file exp_op.hpp
21	19	Forward and reverse mode calculations for z = exp(x).
22	20	*/

34	32	*/
35	33	template <class Base>
36	34	inline void forward_exp_op(
	35	size_t p ,
37	36	size_t q ,
38		size_t p ,
39	37	size_t i_z ,
40	38	size_t i_x ,
41		size_t nc_taylor ,
	39	size_t cap_order ,
42	40	Base* taylor )
43	41	{
44	42	// check assumptions
45	43	CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
46	44	CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
47		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
48		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
49		CPPAD_ASSERT_UNKNOWN( q <= p );
	45	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	46	CPPAD_ASSERT_UNKNOWN( p <= q );
50	47
51	48	// Taylor coefficients corresponding to argument and result
52		Base* x = taylor + i_x * nc_taylor;
53		Base* z = taylor + i_z * nc_taylor;
	49	Base* x = taylor + i_x * cap_order;
	50	Base* z = taylor + i_z * cap_order;
54	51
55	52	size_t k;
56		if( q == 0 )
	53	if( p == 0 )
57	54	{ z[0] = exp( x[0] );
58		q++;
	55	p++;
59	56	}
60		for(size_t j = q; j <= p; j++)
	57	for(size_t j = p; j <= q; j++)
61	58	{
62	59	z[j] = x[1] * z[j-1];
63	60	for(k = 2; k <= j; k++)
64	61	z[j] += Base(k) * x[k] * z[j-k];
65	62	z[j] /= Base(j);
	63	}
	64	}
	65
	66
	67	/*!
	68	Multiple direction forward mode Taylor coefficient for op = ExpOp.
	69
	70	The C++ source code corresponding to this operation is
	71	\verbatim
	72	z = exp(x)
	73	\endverbatim
	74
	75	\copydetails forward_unary1_op_dir
	76	*/
	77	template <class Base>
	78	inline void forward_exp_op_dir(
	79	size_t q ,
	80	size_t r ,
	81	size_t i_z ,
	82	size_t i_x ,
	83	size_t cap_order ,
	84	Base* taylor )
	85	{
	86	// check assumptions
	87	CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
	88	CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
	89	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	90	CPPAD_ASSERT_UNKNOWN( 0 < q );
	91
	92	// Taylor coefficients corresponding to argument and result
	93	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	94	Base* x = taylor + i_x * num_taylor_per_var;
	95	Base* z = taylor + i_z * num_taylor_per_var;
	96
	97	size_t m = (q-1)*r + 1;
	98	for(size_t ell = 0; ell < r; ell++)
	99	{ z[m+ell] = Base(q) * x[m+ell] * z[0];
	100	for(size_t k = 1; k < q; k++)
	101	z[m+ell] += Base(k) * x[(k-1)r+ell+1] z[(q-k-1)*r+ell+1];
	102	z[m+ell] /= Base(q);
66	103	}
67	104	}
68	105

80	117	inline void forward_exp_op_0(
81	118	size_t i_z ,
82	119	size_t i_x ,
83		size_t nc_taylor ,
	120	size_t cap_order ,
84	121	Base* taylor )
85	122	{
86	123	// check assumptions
87	124	CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
88	125	CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
89		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
90		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	126	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
91	127
92	128	// Taylor coefficients corresponding to argument and result
93		Base* x = taylor + i_x * nc_taylor;
94		Base* z = taylor + i_z * nc_taylor;
	129	Base* x = taylor + i_x * cap_order;
	130	Base* z = taylor + i_z * cap_order;
95	131
96	132	z[0] = exp( x[0] );
97	133	}

111	147	size_t d ,
112	148	size_t i_z ,
113	149	size_t i_x ,
114		size_t nc_taylor ,
	150	size_t cap_order ,
115	151	const Base* taylor ,
116	152	size_t nc_partial ,
117	153	Base* partial )

119	155	// check assumptions
120	156	CPPAD_ASSERT_UNKNOWN( NumArg(ExpOp) == 1 );
121	157	CPPAD_ASSERT_UNKNOWN( NumRes(ExpOp) == 1 );
122		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
123		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	158	CPPAD_ASSERT_UNKNOWN( d < cap_order );
124	159	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
125	160
126	161	// Taylor coefficients and partials corresponding to argument
127		const Base* x = taylor + i_x * nc_taylor;
	162	const Base* x = taylor + i_x * cap_order;
128	163	Base* px = partial + i_x * nc_partial;
129	164
130	165	// Taylor coefficients and partials corresponding to result
131		const Base* z = taylor + i_z * nc_taylor;
	166	const Base* z = taylor + i_z * cap_order;
132	167	Base* pz = partial + i_z * nc_partial;
133	168
134	169	// loop through orders in reverse

147	182	px[0] += pz[0] * z[0];
148	183	}
149	184
150		/! \} /
151	185	} // END_CPPAD_NAMESPACE
152	186	# endif

+49

-33

cppad/local/for_jac_sweep.hpp less more

0		/* $Id: for_jac_sweep.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: for_jac_sweep.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_FOR_JAC_SWEEP_INCLUDED
2	2	# define CPPAD_FOR_JAC_SWEEP_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7		the terms of the
	7	the terms of the
8	8	GNU General Public License Version 3.
9	9
10	10	A copy of this license is included in the COPYING file of this distribution.

16	16
17	17	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
18	18	/*!
19		\defgroup for_jac_sweep_hpp for_jac_sweep.hpp
20		\{
21	19	\file for_jac_sweep.hpp
22	20	Compute Forward mode Jacobian sparsity patterns.
23	21	*/
24	22
25	23	/*!
26	24	\def CPPAD_FOR_JAC_SWEEP_TRACE
27		This value is either zero or one.
	25	This value is either zero or one.
28	26	Zero is the normal operational value.
29	27	If it is one, a trace of every for_jac_sweep computation is printed.
30	28	*/

41	39	\code
42	40	user_ok = user_atom->for_sparse_jac
43	41	\endcode
44		This maco is undefined at the end of this file to facillitate is
	42	This maco is undefined at the end of this file to facillitate is
45	43	use with a different definition in other files.
46	44	*/
47	45	# ifdef NDEBUG

56	54
57	55	\tparam Base
58	56	base type for the operator; i.e., this operation sequence was recorded
59		using AD< \a Base > and computations by this routine are done using type
	57	using AD< \a Base > and computations by this routine are done using type
60	58	\a Base.
61	59
62	60	\tparam Vector_set

68	66
69	67	\param numvar
70	68	is the total number of variables on the tape; i.e.,
71		\a play->num_rec_var().
	69	\a play->num_var_rec().
72	70
73	71	\param play
74	72	The information stored in \a play

84	82	with in the tape and this changes during playback.
85	83
86	84	\param var_sparsity
87		\b Input: For j = 1 , ... , \a n,
	85	\b Input: For j = 1 , ... , \a n,
88	86	the sparsity pattern for the independent variable with index (j-1)
89	87	corresponds to the set with index j in \a var_sparsity.
90	88	\n

95	93
96	94	\par Checked Assertions:
97	95	\li numvar == var_sparsity.n_set()
98		\li numvar == play->num_rec_var()
	96	\li numvar == play->num_var_rec()
99	97	*/
100	98
101	99	template <class Base, class Vector_set>

114	112	size_t i, j, k;
115	113
116	114	// check numvar argument
117		CPPAD_ASSERT_UNKNOWN( play->num_rec_var() == numvar );
	115	CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
118	116	CPPAD_ASSERT_UNKNOWN( var_sparsity.n_set() == numvar );
119	117
120	118	// length of the parameter vector (used by CppAD assert macros)
121		const size_t num_par = play->num_rec_par();
	119	const size_t num_par = play->num_par_rec();
122	120
123	121	// cum_sparsity accumulates sparsity pattern a cummulative sum
124	122	size_t limit = var_sparsity.end();

127	125	// to all the other variables.
128	126	// vecad_ind maps a VecAD index (the beginning of the
129	127	// VecAD object) to its from index in vecad_sparsity
130		size_t num_vecad_ind = play->num_rec_vecad_ind();
131		size_t num_vecad_vec = play->num_rec_vecad_vec();
	128	size_t num_vecad_ind = play->num_vec_ind_rec();
	129	size_t num_vecad_vec = play->num_vecad_vec_rec();
132	130	Vector_set vecad_sparsity;
133	131	vecad_sparsity.resize(num_vecad_vec, limit);
134	132	pod_vector<size_t> vecad_ind;

140	138	{ // length of this VecAD
141	139	length = play->GetVecInd(j);
142	140	// set to proper index for this VecAD
143		vecad_ind[j] = i;
	141	vecad_ind[j] = i;
144	142	for(k = 1; k <= length; k++)
145	143	vecad_ind[j+k] = num_vecad_vec; // invalid index
146	144	// start of next VecAD
147	145	j += length + 1;
148	146	}
149		CPPAD_ASSERT_UNKNOWN( j == play->num_rec_vecad_ind() );
	147	CPPAD_ASSERT_UNKNOWN( j == play->num_vec_ind_rec() );
150	148	}
151	149
152	150	// --------------------------------------------------------------

181	179
182	180	# if CPPAD_FOR_JAC_SWEEP_TRACE
183	181	std::cout << std::endl;
184		CppAD::vector<bool> z_value(limit);
	182	CppAD::vectorBool z_value(limit);
185	183	# endif
186	184
187	185	// skip the BeginOp at the beginning of the recording
188		play->start_forward(op, arg, i_op, i_var);
	186	play->forward_start(op, arg, i_op, i_var);
189	187	CPPAD_ASSERT_UNKNOWN( op == BeginOp );
190	188	bool more_operators = true;
191	189	while(more_operators)
192	190	{
193	191	// this op
194		play->next_forward(op, arg, i_op, i_var);
195		CPPAD_ASSERT_UNKNOWN( (i_op > n) \| (op == InvOp) );
196		CPPAD_ASSERT_UNKNOWN( (i_op <= n) \| (op != InvOp) );
	192	play->forward_next(op, arg, i_op, i_var);
	193	CPPAD_ASSERT_UNKNOWN( (i_op > n) \| (op == InvOp) );
	194	CPPAD_ASSERT_UNKNOWN( (i_op <= n) \| (op != InvOp) );
	195	CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
197	196
198	197	// rest of information depends on the case
199	198	switch( op )

251	250
252	251	case CSkipOp:
253	252	// CSipOp has a variable number of arguments and
254		// next_forward thinks it one has one argument.
255		// we must inform next_forward of this special case.
	253	// forward_next thinks it has no arguments.
	254	// we must inform forward_next of this special case.
256	255	play->forward_cskip(op, arg, i_op, i_var);
257	256	break;
258	257	// -------------------------------------------------
259	258
260	259	case CSumOp:
261	260	// CSumOp has a variable number of arguments and
262		// next_forward thinks it one has one argument.
263		// we must inform next_forward of this special case.
264		play->forward_csum(op, arg, i_op, i_var);
	261	// forward_next thinks it has no arguments.
	262	// we must inform forward_next of this special case.
265	263	forward_sparse_jacobian_csum_op(
266	264	i_var, arg, var_sparsity
267	265	);
	266	play->forward_csum(op, arg, i_op, i_var);
268	267	break;
269	268	// -------------------------------------------------
270	269

332	331	case EndOp:
333	332	CPPAD_ASSERT_NARG_NRES(op, 0, 0);
334	333	more_operators = false;
	334	break;
	335	// -------------------------------------------------
	336
	337	case ErfOp:
	338	CPPAD_ASSERT_NARG_NRES(op, 1, 1);
	339	forward_sparse_jacobian_unary_op(
	340	i_var, arg[0], var_sparsity
	341	);
335	342	break;
336	343	// -------------------------------------------------
337	344

558	565	user_atom = atomic_base<Base>::class_object(user_index);
559	566	# ifndef NDEBUG
560	567	if( user_atom == CPPAD_NULL )
561		{ std::string msg =
	568	{ std::string msg =
562	569	atomic_base<Base>::class_name(user_index)
563	570	+ ": atomic_base function has been deleted";
564	571	CPPAD_ASSERT_KNOWN(false, msg.c_str() );

595	602	CPPAD_ASSERT_UNKNOWN( user_m == size_t(arg[3]) );
596	603	# ifndef NDEBUG
597	604	if( ! user_ok )
598		{ std::string msg =
	605	{ std::string msg =
599	606	atomic_base<Base>::class_name(user_index)
600	607	+ ": atomic_base.for_sparse_jac: returned false";
601	608	CPPAD_ASSERT_KNOWN(false, msg.c_str() );

694	701	CPPAD_ASSERT_UNKNOWN(0);
695	702	}
696	703	# if CPPAD_FOR_JAC_SWEEP_TRACE
	704	const addr_t* arg_tmp = arg;
	705	if( op == CSumOp )
	706	arg_tmp = arg - arg[-1] - 4;
	707	if( op == CSkipOp )
	708	arg_tmp = arg - arg[-1] - 7;
	709	//
697	710	// value for this variable
698	711	for(j = 0; j < limit; j++)
699	712	z_value[j] = false;

709	722	i_op,
710	723	i_var,
711	724	op,
712		arg,
	725	arg_tmp
	726	);
	727	if( NumRes(op) > 0 ) printOpResult(
	728	std::cout,
713	729	1,
714	730	&z_value,
715	731	0,
716		(CppAD::vector<bool> *) CPPAD_NULL
	732	(CppAD::vectorBool *) CPPAD_NULL
717	733	);
	734	std::cout << std::endl;
718	735	}
719	736	std::cout << std::endl;
720	737	# else
721	738	}
722	739	# endif
723		CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_rec_var() );
	740	CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
724	741
725	742	return;
726	743	}
727	744
728		/! \} /
729	745	} // END_CPPAD_NAMESPACE
730	746
731	747	// preprocessor symbols that are local to this file

-9

cppad/local/for_sparse_jac.hpp less more

0		/* $Id: for_sparse_jac.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: for_sparse_jac.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_FOR_SPARSE_JAC_INCLUDED
2	2	# define CPPAD_FOR_SPARSE_JAC_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

210	210
211	211	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
212	212	/*!
213		\defgroup for_sparse_jac_hpp for_sparse_jac.hpp
214		\{
215	213	\file for_sparse_jac.hpp
216	214	Forward mode Jacobian sparsity patterns.
217	215	*/

546	544	q ,
547	545	r ,
548	546	s ,
549		total_num_var_ ,
	547	num_var_tape_ ,
550	548	dep_taddr_ ,
551	549	ind_taddr_ ,
552	550	play_ ,

604	602	q ,
605	603	r ,
606	604	s ,
607		total_num_var_ ,
	605	num_var_tape_ ,
608	606	dep_taddr_ ,
609	607	ind_taddr_ ,
610	608	play_ ,

660	658	tape is stored in \c for_jac_sparse_pack__.
661	659	In this case
662	660	\verbatim
663		for_jac_sparse_pack_.n_set() == total_num_var_
	661	for_jac_sparse_pack_.n_set() == num_var_tape_
664	662	for_jac_sparse_pack_.end() == q
665	663	for_jac_sparse_set_.n_set() == 0
666	664	for_jac_sparse_set_.end() == 0

672	670	tape is stored in \c for_jac_sparse_set__.
673	671	In this case
674	672	\verbatim
675		for_jac_sparse_set_.n_set() == total_num_var_
	673	for_jac_sparse_set_.n_set() == num_var_tape_
676	674	for_jac_sparse_set_.end() == q
677	675	for_jac_sparse_pack_.n_set() == 0
678	676	for_jac_sparse_pack_.end() == 0

703	701	}
704	702
705	703
706		/! \} /
707	704	} // END_CPPAD_NAMESPACE
708	705	# endif

+302

-116

cppad/local/forward.hpp less more

0		/* $Id: forward.hpp 3098 2014-02-18 03:19:39Z bradbell $ */
	0	/* $Id: forward.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_FORWARD_INCLUDED
2	2	# define CPPAD_FORWARD_INCLUDED
3	3

12	12	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13	13	-------------------------------------------------------------------------- */
14	14
15		/*
16		$begin Forward$$
17
18		$section Forward Mode$$
19
20		$childtable%
21		omh/forward.omh%
22		cppad/local/cap_taylor.hpp%
23		cppad/local/num_skip.hpp%
24		example/forward.cpp%
25		example/forward_mul.cpp
26		%$$
27
28		$end
29		-----------------------------------------------------------------------------
30		*/
31
32	15	// documened after Forward but included here so easy to see
33		# include <cppad/local/cap_taylor.hpp>
	16	# include <cppad/local/capacity_order.hpp>
34	17	# include <cppad/local/num_skip.hpp>
35	18
36	19	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
37	20	/*!
38		\defgroup forward_hpp forward.hpp
39		\{
40	21	\file forward.hpp
41		User interface to forward mode computations
	22	User interface to forward mode computations.
42	23	*/
43	24
44	25	/*!
45		Compute arbitrary order forward mode Taylor coefficieints.
	26	Multiple orders, one direction, forward mode Taylor coefficieints.
46	27
47	28	\tparam Base
48	29	The type used during the forward mode computations; i.e., the corresponding
49		recording of operations used the type \c AD<Base>.
50
51		\tparam Vector
52		is a Simple Vector class with eleements of type \c Base.
53
54		\param p
	30	recording of operations used the type AD<Base>.
	31
	32	\tparam VectorBase
	33	is a Simple Vector class with eleements of type Base.
	34
	35	\param q
55	36	is the hightest order for this forward mode computation; i.e.,
56		after this calculation there will be <code>p+1</code>
57		Taylor coefficients per variables.
58
59		\param x_p
	37	after this calculation there will be <code>q+1</code>
	38	Taylor coefficients per variable.
	39
	40	\param xq
60	41	contains Taylor coefficients for the independent variables.
61		The size of \a x_p must either be \c n or <code>n*(p+1)</code>,
62		We define <code>q = p + 1 - x_p.size() / n</code>.
63		The Taylor coefficients of order k, for
64		k = q, ... , p are calculated.
	42	The size of xq must either be n or <code>(q+1)*n</code>,
	43	We define <code>p = q + 1 - xq.size()/n</code>.
	44	For <code>j = 0 , ... , n-1</code>,
	45	<code>k = p, ... , q</code>, are
	46	<code>xq[ (q+1-p)*j + k - p ]</code>
	47	is the k-th order coefficient for the j-th independent variable.
65	48
66	49	\param s
67		Is the stream where output corresponding to \c PriOp operations will written.
	50	Is the stream where output corresponding to PriOp operations will written.
	51
	52	\return
	53	contains Taylor coefficients for the dependent variables.
	54	The size of the return value y is <code>m*(q+1-p)</code>.
	55	For <code>i = 0, ... , m-1</code>,
	56	<code>k = p, ..., q</code>,
	57	<code>y[(q+1-p)*i + (k-p)]</code>
	58	is the k-th order coefficient for the i-th dependent variable.
	59
	60	\par taylor_
	61	The Taylor coefficients up to order p-1 are inputs
	62	and the coefficents from order p through q are outputs.
	63	Let <code>N = num_var_tape_</code>, and
	64	<code>C = cap_order_taylor_</code>.
	65	Note that for
	66	<code>i = 1 , ..., N-1</code>,
	67	<code>k = 0 , ..., q</code>,
	68	<code>taylor_[ C*i + k ]</code>
	69	is the k-th order cofficent,
	70	for the i-th varaible on the tape.
	71	(The first independent variable has index one on the tape
	72	and there is no variable with index zero.)
68	73	*/
69	74
70	75	template <typename Base>
71		template <typename Vector>
72		Vector ADFun<Base>::Forward(
73		size_t p ,
74		const Vector& x_p ,
75		std::ostream& s )
	76	template <typename VectorBase>
	77	VectorBase ADFun<Base>::Forward(
	78	size_t q ,
	79	const VectorBase& xq ,
	80	std::ostream& s )
76	81	{ // temporary indices
77	82	size_t i, j, k;
78	83

83	88	size_t m = dep_taddr_.size();
84	89
85	90	// check Vector is Simple Vector class with Base type elements
86		CheckSimpleVector<Base, Vector>();
87
88		CPPAD_ASSERT_KNOWN(
89		size_t(x_p.size()) == n \|\| size_t(x_p.size()) == n*(p+1),
90		"Forward: x_p.size() is not equal n or n*(p+1)"
91		);
92		size_t n_order = size_t(x_p.size()) / n;
93		CPPAD_ASSERT_KNOWN(
94		p <= taylor_per_var_ \|\| n_order == p + 1,
95		"The number of Taylor coefficient currently stored in this ADFun\n"
96		"is less than p and x_p.size() != n*(p+1)."
	91	CheckSimpleVector<Base, VectorBase>();
	92
	93
	94	CPPAD_ASSERT_KNOWN(
	95	size_t(xq.size()) == n \|\| size_t(xq.size()) == n*(q+1),
	96	"Forward(q, xq): xq.size() is not equal n or n*(q+1)"
	97	);
	98
	99	// lowest order we are computing
	100	size_t p = q + 1 - size_t(xq.size()) / n;
	101	CPPAD_ASSERT_UNKNOWN( p == 0 \|\| p == q );
	102	CPPAD_ASSERT_KNOWN(
	103	q <= num_order_taylor_ \|\| p == 0,
	104	"Forward(q, xq): Number of Taylor coefficient orders stored in this"
	105	" ADFun\nis less than q and xq.size() != n*(q+1)."
97	106	);
98
99		// check if the taylor_ matrix needs more columns
100		if( taylor_col_dim_ <= p )
101		capacity_taylor(p + 1);
102		CPPAD_ASSERT_UNKNOWN( taylor_col_dim_ > p );
103
104		// set the p-th order taylor_ coefficients for independent variables
	107	CPPAD_ASSERT_KNOWN(
	108	p <= 1 \|\| num_direction_taylor_ == 1,
	109	"Forward(q, xq): computing order q >= 2"
	110	" and number of directions is not one."
	111	"\nMust use Forward(q, r, xq) for this case"
	112	);
	113	// does taylor_ need more orders or fewer directions
	114	if( (cap_order_taylor_ <= q) \| (num_direction_taylor_ != 1) )
	115	{ if( p == 0 )
	116	{ // no need to copy old values during capacity_order
	117	num_order_taylor_ = 0;
	118	}
	119	else num_order_taylor_ = q;
	120	size_t c = std::max(q + 1, cap_order_taylor_);
	121	size_t r = 1;
	122	capacity_order(c, r);
	123	}
	124	CPPAD_ASSERT_UNKNOWN( cap_order_taylor_ > q );
	125	CPPAD_ASSERT_UNKNOWN( num_direction_taylor_ == 1 );
	126
	127	// short hand notation for order capacity
	128	size_t C = cap_order_taylor_;
	129
	130	// set Taylor coefficients for independent variables
105	131	for(j = 0; j < n; j++)
106		{ CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < total_num_var_ );
	132	{ CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < num_var_tape_ );
107	133
108	134	// ind_taddr_[j] is operator taddr for j-th independent variable
109	135	CPPAD_ASSERT_UNKNOWN( play_.GetOp( ind_taddr_[j] ) == InvOp );
110	136
111		// It is also variable taddr for j-th independent variable
112		if( n_order == 1 )
113		taylor_[ind_taddr_[j] * taylor_col_dim_ + p] = x_p[j];
114		else for(k = 0; k < n_order; k++)
115		taylor_[ind_taddr_[j] * taylor_col_dim_ + k] =
116		x_p[j * n_order + k];
	137	if( p == q )
	138	taylor_[ C * ind_taddr_[j] + q] = xq[j];
	139	else
	140	{ for(k = 0; k <= q; k++)
	141	taylor_[ C * ind_taddr_[j] + k] = xq[ (q+1)*j + k];
	142	}
117	143	}
118	144
119	145	// evaluate the derivatives
120		size_t q = (p + 1) - n_order;
121		if( p == 0 )
	146	CPPAD_ASSERT_UNKNOWN( cskip_op_.size() == play_.num_op_rec() );
	147	CPPAD_ASSERT_UNKNOWN( load_op_.size() == play_.num_load_op_rec() );
	148	if( q == 0 )
122	149	{
123		# if CPPAD_USE_FORWARD0SWEEP
124	150	compare_change_ = forward0sweep(s, true,
125		n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
126		cskip_op_
127		);
128		# else
129		compare_change_ = forward_sweep(s, true, q,
130		p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
131		cskip_op_
132		);
133		# endif
134		}
135		else if( q == 0 )
136		{ compare_change_ = forward_sweep(s, true, q,
137		p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
138		cskip_op_
	151	n, num_var_tape_, &play_, C,
	152	taylor_.data(), cskip_op_.data(), load_op_
	153	);
	154	}
	155	else if( p == 0 )
	156	{ compare_change_ = forward1sweep(s, true, p, q,
	157	n, num_var_tape_, &play_, C,
	158	taylor_.data(), cskip_op_.data(), load_op_
139	159	);
140	160	}
141	161	else
142		{ forward_sweep(s, true, q,
143		p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
144		cskip_op_
	162	{ forward1sweep(s, true, p, q,
	163	n, num_var_tape_, &play_, C,
	164	taylor_.data(), cskip_op_.data(), load_op_
145	165	);
146	166	}
147	167
148	168	// return Taylor coefficients for dependent variables
149		Vector y_p;
150		if( n_order == 1 )
151		{ y_p.resize(m);
	169	VectorBase yq;
	170	if( p == q )
	171	{ yq.resize(m);
152	172	for(i = 0; i < m; i++)
153		{ CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < total_num_var_ );
154		y_p[i] = taylor_[dep_taddr_[i] * taylor_col_dim_ + p];
	173	{ CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
	174	yq[i] = taylor_[ C * dep_taddr_[i] + q];
155	175	}
156	176	}
157	177	else
158		{ y_p.resize(m * n_order );
	178	{ yq.resize(m * (q+1) );
159	179	for(i = 0; i < m; i++)
160		{ for(k = 0; k < n_order; k++)
161		y_p[ i * n_order + k] =
162		taylor_[ dep_taddr_[i] * taylor_col_dim_ + k ];
	180	{ for(k = 0; k <= q; k++)
	181	yq[ (q+1) * i + k] =
	182	taylor_[ C * dep_taddr_[i] + k ];
163	183	}
164	184	}
165	185	# ifndef NDEBUG
166	186	if( check_for_nan_ )
167	187	{ bool ok = true;
168		if( p == 0 && n_order == 1 )
169		ok = ! hasnan(y_p);
170		else if( n_order != 1 )
	188	if( p == 0 )
171	189	{ for(i = 0; i < m; i++)
172		// on MS Visual Studio 2012, CppAD required in front of isnan ?
173		ok &= ! CppAD::isnan( y_p[ i * n_order + 0 ] );
	190	{ // Visual Studio 2012, CppAD required in front of isnan ?
	191	ok &= ! CppAD::isnan( yq[ (q+1) * i + 0 ] );
	192	}
174	193	}
175	194	CPPAD_ASSERT_KNOWN(ok,
176		"y_p = f.Forward(p, x): has a zero order Taylor coefficient "
	195	"yq = f.Forward(q, xq): has a zero order Taylor coefficient "
177	196	"with the value nan."
178	197	);
179		if( p != 0 && n_order == 1 )
180		ok = ! hasnan(y_p);
181		else if( n_order != 1 )
	198	if( 0 < q )
182	199	{ for(i = 0; i < m; i++)
183		{ for(k = 1; k < n_order; k++)
184		// Studio 2012, CppAD required in front of isnan ?
185		ok &= ! CppAD::isnan( y_p[ i * n_order + k ] );
	200	{ for(k = p; k <= q; k++)
	201	{ // Studio 2012, CppAD required in front of isnan ?
	202	ok &= ! CppAD::isnan( yq[ (q+1-p)*i + k-p ] );
	203	}
186	204	}
187	205	}
188	206	CPPAD_ASSERT_KNOWN(ok,
189		"y_p = f.Forward(p, x): has a non-zero order Taylor coefficient\n"
	207	"yq = f.Forward(q, xq): has a non-zero order Taylor coefficient\n"
190	208	"with the value nan (but zero order coefficients are not nan)."
191	209	);
192	210	}
193	211	# endif
194	212
195
196		// now we have p + 1 taylor_ coefficients per variable
197		taylor_per_var_ = p + 1;
198
199		return y_p;
	213	// now we have q + 1 taylor_ coefficient orders per variable
	214	num_order_taylor_ = q + 1;
	215
	216	return yq;
200	217	}
201	218
202		/! \} /
	219	/*!
	220	One order, multiple directions, forward mode Taylor coefficieints.
	221
	222	\tparam Base
	223	The type used during the forward mode computations; i.e., the corresponding
	224	recording of operations used the type AD<Base>.
	225
	226	\tparam VectorBase
	227	is a Simple Vector class with eleements of type Base.
	228
	229	\param q
	230	is the order for this forward mode computation,
	231	<code>q > 0</code>.
	232	There must be at least <code>q</code> Taylor coefficients
	233	per variable before this call.
	234	After this call there will be <code>q+1</code>
	235	Taylor coefficients per variable.
	236
	237	\param r
	238	is the number of directions for this calculation.
	239	If <code>q != 1</code>, \c r must be the same as in the previous
	240	call to Forward where \c q was equal to one.
	241
	242	\param xq
	243	contains Taylor coefficients for the independent variables.
	244	The size of xq must either be <code>r*n</code>,
	245	For <code>j = 0 , ... , n-1</code>,
	246	<code>ell = 0, ... , r-1</code>,
	247	<code>xq[ ( r*j + ell ]</code>
	248	is the q-th order coefficient for the j-th independent variable
	249	and the ell-th direction.
	250
	251	\return
	252	contains Taylor coefficients for the dependent variables.
	253	The size of the return value \c y is <code>r*m</code>.
	254	For <code>i = 0, ... , m-1</code>,
	255	<code>ell = 0, ... , r-1</code>,
	256	<code>y[ r*i + ell ]</code>
	257	is the q-th order coefficient for the i-th dependent variable
	258	and the ell-th direction.
	259
	260	\par taylor_
	261	The Taylor coefficients up to order <code>q-1</code> are inputs
	262	and the coefficents of order \c q are outputs.
	263	Let <code>N = num_var_tape_</code>, and
	264	<code>C = cap_order_taylor_</code>.
	265	Note that for
	266	<code>i = 1 , ..., N-1</code>,
	267	<code>taylor_[ (C-1)ri + i + 0 ]</code>
	268	is the zero order cofficent,
	269	for the i-th varaible, and all directions.
	270	For <code>i = 1 , ..., N-1</code>,
	271	<code>k = 1 , ..., q</code>,
	272	<code>ell = 0 , ..., r-1</code>,
	273	<code>taylor_[ (C-1)ri + i + (k-1)*r + ell + 1 ]</code>
	274	is the k-th order cofficent,
	275	for the i-th varaible, and ell-th direction.
	276	(The first independent variable has index one on the tape
	277	and there is no variable with index zero.)
	278	*/
	279
	280	template <typename Base>
	281	template <typename VectorBase>
	282	VectorBase ADFun<Base>::Forward(
	283	size_t q ,
	284	size_t r ,
	285	const VectorBase& xq )
	286	{ // temporary indices
	287	size_t i, j, ell;
	288
	289	// number of independent variables
	290	size_t n = ind_taddr_.size();
	291
	292	// number of dependent variables
	293	size_t m = dep_taddr_.size();
	294
	295	// check Vector is Simple Vector class with Base type elements
	296	CheckSimpleVector<Base, VectorBase>();
	297
	298	CPPAD_ASSERT_KNOWN( q > 0, "Forward(q, r, xq): q == 0" );
	299	CPPAD_ASSERT_KNOWN(
	300	size_t(xq.size()) == r * n,
	301	"Forward(q, r, xq): xq.size() is not equal r * n"
	302	);
	303	CPPAD_ASSERT_KNOWN(
	304	q <= num_order_taylor_ ,
	305	"Forward(q, r, xq): Number of Taylor coefficient orders stored in"
	306	" this ADFun is less than q"
	307	);
	308	CPPAD_ASSERT_KNOWN(
	309	q == 1 \|\| num_direction_taylor_ == r ,
	310	"Forward(q, r, xq): q > 1 and number of Taylor directions r"
	311	" is not same as previous Forward(1, r, xq)"
	312	);
	313
	314	// does taylor_ need more orders or new number of directions
	315	if( cap_order_taylor_ <= q \|\| num_direction_taylor_ != r )
	316	{ if( num_direction_taylor_ != r )
	317	num_order_taylor_ = 1;
	318
	319	size_t c = std::max(q + 1, cap_order_taylor_);
	320	capacity_order(c, r);
	321	}
	322	CPPAD_ASSERT_UNKNOWN( cap_order_taylor_ > q );
	323	CPPAD_ASSERT_UNKNOWN( num_direction_taylor_ == r )
	324
	325	// short hand notation for order capacity
	326	size_t c = cap_order_taylor_;
	327
	328	// set Taylor coefficients for independent variables
	329	for(j = 0; j < n; j++)
	330	{ CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < num_var_tape_ );
	331
	332	// ind_taddr_[j] is operator taddr for j-th independent variable
	333	CPPAD_ASSERT_UNKNOWN( play_.GetOp( ind_taddr_[j] ) == InvOp );
	334
	335	for(ell = 0; ell < r; ell++)
	336	{ size_t index = ((c-1)r + 1)ind_taddr_[j] + (q-1)*r + ell + 1;
	337	taylor_[ index ] = xq[ r * j + ell ];
	338	}
	339	}
	340
	341	// evaluate the derivatives
	342	CPPAD_ASSERT_UNKNOWN( cskip_op_.size() == play_.num_op_rec() );
	343	CPPAD_ASSERT_UNKNOWN( load_op_.size() == play_.num_load_op_rec() );
	344	forward2sweep(
	345	q,
	346	r,
	347	n,
	348	num_var_tape_,
	349	&play_,
	350	c,
	351	taylor_.data(),
	352	cskip_op_.data(),
	353	load_op_
	354	);
	355
	356	// return Taylor coefficients for dependent variables
	357	VectorBase yq;
	358	yq.resize(r * m);
	359	for(i = 0; i < m; i++)
	360	{ CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
	361	for(ell = 0; ell < r; ell++)
	362	{ size_t index = ((c-1)r + 1)dep_taddr_[i] + (q-1)*r + ell + 1;
	363	yq[ r * i + ell ] = taylor_[ index ];
	364	}
	365	}
	366	# ifndef NDEBUG
	367	if( check_for_nan_ )
	368	{ bool ok = true;
	369	for(i = 0; i < m; i++)
	370	{ for(ell = 0; ell < r; ell++)
	371	{ // Studio 2012, CppAD required in front of isnan ?
	372	ok &= ! CppAD::isnan( yq[ r * i + ell ] );
	373	}
	374	}
	375	CPPAD_ASSERT_KNOWN(ok,
	376	"yq = f.Forward(q, r, xq): has a non-zero order Taylor coefficient\n"
	377	"with the value nan (but zero order coefficients are not nan)."
	378	);
	379	}
	380	# endif
	381
	382	// now we have q + 1 taylor_ coefficient orders per variable
	383	num_order_taylor_ = q + 1;
	384
	385	return yq;
	386	}
	387
	388
203	389	} // END_CPPAD_NAMESPACE
204	390	# endif

+259

-179

cppad/local/forward0sweep.hpp less more

0		/* $Id: forward0sweep.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: forward0sweep.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_FORWARD0SWEEP_INCLUDED
2	2	# define CPPAD_FORWARD0SWEEP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup forward0sweep_hpp forward0sweep.hpp
18		\{
19	17	\file forward0sweep.hpp
20	18	Compute zero order forward mode Taylor coefficients.
21	19	*/

23	21	/*
24	22	\def CPPAD_ATOMIC_CALL
25	23	This avoids warnings when NDEBUG is defined and user_ok is not used.
26		If \c NDEBUG is defined, this resolves to
	24	If NDEBUG is defined, this resolves to
27	25	\code
28	26	user_atom->forward
29	27	\endcode

52	50	/*!
53	51	Compute zero order forward mode Taylor coefficients.
54	52
	53	<!-- define forward0sweep_doc_define -->
55	54	\tparam Base
56	55	The type used during the forward mode computations; i.e., the corresponding
57		recording of operations used the type \c AD<Base>.
	56	recording of operations used the type AD<Base>.
58	57
59	58	\param s_out
60		Is the stream where output corresponding to \c PriOp operations will
	59	Is the stream where output corresponding to PriOp operations will
61	60	be written.
62	61
63	62	\param print
64		If \a print is false,
	63	If print is false,
65	64	suppress the output that is otherwise generated by the c PriOp instructions.
66	65
67	66	\param n

69	68
70	69	\param numvar
71	70	is the total number of variables on the tape.
72		This is also equal to the number of rows in the matrix \a Taylor; i.e.,
73		\a Rec->num_rec_var().
74
75		\param Rec
76		2DO: change this name from Rec to play (becuase it is a player
77		and not a recorder).
78		The information stored in \a Rec
	71	This is also equal to the number of rows in the matrix taylor; i.e.,
	72	play->num_var_rec().
	73
	74	\param play
	75	The information stored in play
79	76	is a recording of the operations corresponding to the function
80	77	\f[
81	78	F : {\bf R}^n \rightarrow {\bf R}^m

84	81	\f$ m \f$ is the number of dependent variables.
85	82	\n
86	83	\n
87		The object \a Rec is effectly constant.
88		There are two exceptions to this.
89		The first exception is that while palying back the tape
90		the object \a Rec holds information about the current location
	84	The object play is effectly constant.
	85	The exception to this is that while palying back the tape
	86	the object play holds information about the current location
91	87	with in the tape and this changes during palyback.
92		The second exception is the fact that the
93		zero order ( \a d = 0 ) versions of the VecAD operators LdpOp and LdvOp
94		modify the corresponding \a op_arg values returned by
95		\ref player::next_forward and \ref player::next_reverse; see the
96		\link load_op.hpp LdpOp and LdvOp \endlink operations.
97	88
98	89	\param J
99		Is the number of columns in the coefficient matrix \a Taylor.
	90	Is the number of columns in the coefficient matrix taylor.
100	91	This must be greater than or equal one.
101	92
102		\param Taylor
103		\b Input: For j = 1 , ... , \a n,
104		\a Taylor [ j * J + 0 ]
105		variable with index i on the tape
106		(independent variable with index (j-1) in the independent variable vector).
	93	<!-- end forward0sweep_doc_define -->
	94
	95	\param taylor
	96	\n
	97	\b Input:
	98	For i = 1 , ... , n,
	99	<code>taylor [i * J + 0]</code>
	100	variable with index j on the tape
	101	(these are the independent variables).
107	102	\n
108	103	\n
109		\b Output: For i = \a n + 1, ... , \a numvar - 1,
110		\a Taylor [ i * J + 0 ]
	104	\b Output:
	105	For i = n + 1, ... , numvar - 1,
	106	<code>taylor [i * J + 0]</code>
111	107	is the zero order Taylor coefficient for the variable with
112	108	index i on the tape.
113	109
114	110	\param cskip_op
115		Is a vector with size Rec->num_rec_op(),
116		the input value of the elements does not matter.
117		Upon return, if cskip_op[i] is true, the operator index i in the recording
118		does not affect any of the dependent variable (given the value
119		of the independent variables).
120
121		\a return
	111	Is a vector with size play->num_op_rec().
	112	The input value of the elements does not matter.
	113	Upon return, if cskip_op[i] is true, the operator index i
	114	does not affect any of the dependent variable
	115	(given the value of the independent variables).
	116
	117	\param var_by_load_op
	118	Is a vector with size play->num_load_op_rec().
	119	The input value of the elements does not matter.
	120	Upon return,
	121	it is the variable index corresponding the result for each load operator.
	122	In the case where the index is zero,
	123	the load operator results in a parameter (not a variable).
	124	Note that the is no variable with index zero on the tape.
	125
	126	\return
122	127	The return value is equal to the number of ComOp operations
123	128	that have a different result from when the information in
124		\a Rec was recorded.
	129	play was recorded.
125	130	(Note that if NDEBUG is true, there are no ComOp operations
126		in Rec and hence this return value is always zero.)
	131	in play and hence this return value is always zero.)
127	132	*/
128	133
129	134	template <class Base>

132	137	bool print,
133	138	size_t n,
134	139	size_t numvar,
135		player<Base> *Rec,
	140	player<Base>* play,
136	141	size_t J,
137		Base *Taylor,
138		CppAD::vector<bool>& cskip_op
	142	Base* taylor,
	143	bool* cskip_op,
	144	pod_vector<addr_t>& var_by_load_op
139	145	)
140	146	{ CPPAD_ASSERT_UNKNOWN( J >= 1 );
141
	147	CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
	148
	149	// use p, q, r so other forward sweeps can use code defined here
	150	size_t p = 0;
	151	size_t q = 0;
	152	size_t r = 1;
	153	/*
	154	<!-- define forward0sweep_code_define -->
	155	*/
142	156	// op code for current instruction
143		OpCode op;
	157	OpCode op;
144	158
145	159	// index for current instruction
146		size_t i_op;
	160	size_t i_op;
147	161
148	162	// next variables
149		size_t i_var;
150
151		// constant and non-constant version of the operation argument indices
152		addr_t* non_const_arg;
	163	size_t i_var;
	164
	165	// operation argument indices
153	166	const addr_t* arg = CPPAD_NULL;
154	167
155	168	// initialize the comparision operator (ComOp) counter
156	169	size_t compareCount = 0;
157	170
158		// This is an order zero calculation, initialize vector indices
159		pod_vector<size_t> VectorInd; // address for each element
160		pod_vector<bool> VectorVar; // is element a variable
161		size_t i = Rec->num_rec_vecad_ind();
162		if( i > 0 )
163		{ VectorInd.extend(i);
164		VectorVar.extend(i);
165		while(i--)
166		{ VectorInd[i] = Rec->GetVecInd(i);
167		VectorVar[i] = false;
	171	// If this includes a zero calculation, initialize this information
	172	pod_vector<bool> isvar_by_ind;
	173	pod_vector<size_t> index_by_ind;
	174	if( p == 0 )
	175	{ size_t i;
	176
	177	// this includes order zero calculation, initialize vector indices
	178	size_t num = play->num_vec_ind_rec();
	179	if( num > 0 )
	180	{ isvar_by_ind.extend(num);
	181	index_by_ind.extend(num);
	182	for(i = 0; i < num; i++)
	183	{ index_by_ind[i] = play->GetVecInd(i);
	184	isvar_by_ind[i] = false;
	185	}
168	186	}
	187	// includes zero order, so initialize conditional skip flags
	188	num = play->num_op_rec();
	189	for(i = 0; i < num; i++)
	190	cskip_op[i] = false;
169	191	}
170	192
171		// zero order, so initialize conditional skip flags
172		for(i = 0; i < Rec->num_rec_op(); i++)
173		cskip_op[i] = false;
174
175	193	// work space used by UserOp.
176		const size_t user_q = 0; // lowest order
177		const size_t user_p = 0; // highest order
178	194	vector<bool> user_vx; // empty vecotor
179	195	vector<bool> user_vy; // empty vecotor
180	196	vector<Base> user_tx; // argument vector Taylor coefficients

192	208	# endif
193	209	//
194	210	// next expected operator in a UserOp sequence
195		enum { user_start, user_arg, user_ret, user_end } user_state = user_start;
196
197		// check numvar argument
198		CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
	211	enum { user_start, user_arg, user_ret, user_end, user_trace }
	212	user_state = user_start;
199	213
200	214	// length of the parameter vector (used by CppAD assert macros)
201		const size_t num_par = Rec->num_rec_par();
202
203		// length of the text vector (used by CppAD assert macros)
204		const size_t num_text = Rec->num_rec_text();
	215	const size_t num_par = play->num_par_rec();
205	216
206	217	// pointer to the beginning of the parameter vector
207	218	const Base* parameter = CPPAD_NULL;
208	219	if( num_par > 0 )
209		parameter = Rec->GetPar();
	220	parameter = play->GetPar();
	221
	222	// length of the text vector (used by CppAD assert macros)
	223	const size_t num_text = play->num_text_rec();
210	224
211	225	// pointer to the beginning of the text vector
212	226	const char* text = CPPAD_NULL;
213	227	if( num_text > 0 )
214		text = Rec->GetTxt(0);
	228	text = play->GetTxt(0);
	229	/*
	230	<!-- end forward0sweep_code_define -->
	231	*/
	232
	233	# if CPPAD_FORWARD0SWEEP_TRACE
	234	// variable indices for results vector
	235	// (done differently for order zero).
	236	vector<size_t> user_iy;
	237	# endif
215	238
216	239	// skip the BeginOp at the beginning of the recording
217		Rec->start_forward(op, arg, i_op, i_var);
	240	play->forward_start(op, arg, i_op, i_var);
218	241	CPPAD_ASSERT_UNKNOWN( op == BeginOp );
219	242	# if CPPAD_FORWARD0SWEEP_TRACE
220	243	std::cout << std::endl;

223	246	while(more_operators)
224	247	{
225	248	// this op
226		Rec->next_forward(op, arg, i_op, i_var);
	249	play->forward_next(op, arg, i_op, i_var);
227	250	CPPAD_ASSERT_UNKNOWN( (i_op > n) \| (op == InvOp) );
228	251	CPPAD_ASSERT_UNKNOWN( (i_op <= n) \| (op != InvOp) );
	252	CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
	253	CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
229	254
230	255	// check if we are skipping this operation
231	256	while( cskip_op[i_op] )
232	257	{ if( op == CSumOp )
233	258	{ // CSumOp has a variable number of arguments
234		Rec->forward_csum(op, arg, i_op, i_var);
	259	play->forward_csum(op, arg, i_op, i_var);
235	260	}
236		Rec->next_forward(op, arg, i_op, i_var);
	261	CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
	262	// if( op == CSkipOp )
	263	// { // CSkip has a variable number of arguments
	264	// play->forward_cskip(op, arg, i_op, i_var);
	265	// }
	266	play->forward_next(op, arg, i_op, i_var);
	267	CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
237	268	}
238	269
239	270	// action to take depends on the case
240	271	switch( op )
241	272	{
242	273	case AbsOp:
243		forward_abs_op_0(i_var, arg[0], J, Taylor);
	274	forward_abs_op_0(i_var, arg[0], J, taylor);
244	275	break;
245	276	// -------------------------------------------------
246	277
247	278	case AddvvOp:
248		forward_addvv_op_0(i_var, arg, parameter, J, Taylor);
	279	forward_addvv_op_0(i_var, arg, parameter, J, taylor);
249	280	break;
250	281	// -------------------------------------------------
251	282
252	283	case AddpvOp:
253	284	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
254		forward_addpv_op_0(i_var, arg, parameter, J, Taylor);
	285	forward_addpv_op_0(i_var, arg, parameter, J, taylor);
255	286	break;
256	287	// -------------------------------------------------
257	288
258	289	case AcosOp:
259	290	// sqrt(1 - x * x), acos(x)
260	291	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
261		forward_acos_op_0(i_var, arg[0], J, Taylor);
	292	forward_acos_op_0(i_var, arg[0], J, taylor);
262	293	break;
263	294	// -------------------------------------------------
264	295
265	296	case AsinOp:
266	297	// sqrt(1 - x * x), asin(x)
267	298	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
268		forward_asin_op_0(i_var, arg[0], J, Taylor);
	299	forward_asin_op_0(i_var, arg[0], J, taylor);
269	300	break;
270	301	// -------------------------------------------------
271	302
272	303	case AtanOp:
273	304	// 1 + x * x, atan(x)
274	305	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
275		forward_atan_op_0(i_var, arg[0], J, Taylor);
	306	forward_atan_op_0(i_var, arg[0], J, taylor);
276	307	break;
277	308	// -------------------------------------------------
278	309

280	311	// Use the general case with d == 0
281	312	// (could create an optimzied verison for this case)
282	313	forward_cond_op_0(
283		i_var, arg, num_par, parameter, J, Taylor
	314	i_var, arg, num_par, parameter, J, taylor
284	315	);
285	316	break;
286	317	// ---------------------------------------------------
287	318	case ComOp:
288	319	forward_comp_op_0(
289		compareCount, arg, num_par, parameter, J, Taylor
	320	compareCount, arg, num_par, parameter, J, taylor
290	321	);
291	322	break;
292	323	// ---------------------------------------------------

294	325	case CosOp:
295	326	// sin(x), cos(x)
296	327	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
297		forward_cos_op_0(i_var, arg[0], J, Taylor);
	328	forward_cos_op_0(i_var, arg[0], J, taylor);
298	329	break;
299	330	// ---------------------------------------------------
300	331
301	332	case CoshOp:
302	333	// sinh(x), cosh(x)
303	334	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
304		forward_cosh_op_0(i_var, arg[0], J, Taylor);
	335	forward_cosh_op_0(i_var, arg[0], J, taylor);
305	336	break;
306	337	// -------------------------------------------------
307	338
308	339	case CSkipOp:
309	340	// CSkipOp has a variable number of arguments and
310		// next_forward thinks it one has one argument.
311		// we must inform next_forward of this special case.
312		Rec->forward_cskip(op, arg, i_op, i_var);
	341	// forward_next thinks it has no arguments.
	342	// we must inform forward_next of this special case.
313	343	forward_cskip_op_0(
314		i_var, arg, num_par, parameter, J, Taylor, cskip_op
315		);
	344	i_var, arg, num_par, parameter, J, taylor, cskip_op
	345	);
	346	play->forward_cskip(op, arg, i_op, i_var);
316	347	break;
317	348	// -------------------------------------------------
318	349
319	350	case CSumOp:
320	351	// CSumOp has a variable number of arguments and
321		// next_forward thinks it one has one argument.
322		// we must inform next_forward of this special case.
323		Rec->forward_csum(op, arg, i_op, i_var);
	352	// forward_next thinks it has no arguments.
	353	// we must inform forward_next of this special case.
324	354	forward_csum_op(
325		0, 0, i_var, arg, num_par, parameter, J, Taylor
326		);
	355	0, 0, i_var, arg, num_par, parameter, J, taylor
	356	);
	357	play->forward_csum(op, arg, i_op, i_var);
327	358	break;
328	359	// -------------------------------------------------
329	360
330	361	case DisOp:
331		forward_dis_op_0(i_var, arg, J, Taylor);
	362	forward_dis_op(p, q, r, i_var, arg, J, taylor);
332	363	break;
333	364	// -------------------------------------------------
334	365
335	366	case DivvvOp:
336		forward_divvv_op_0(i_var, arg, parameter, J, Taylor);
	367	forward_divvv_op_0(i_var, arg, parameter, J, taylor);
337	368	break;
338	369	// -------------------------------------------------
339	370
340	371	case DivpvOp:
341	372	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
342		forward_divpv_op_0(i_var, arg, parameter, J, Taylor);
	373	forward_divpv_op_0(i_var, arg, parameter, J, taylor);
343	374	break;
344	375	// -------------------------------------------------
345	376
346	377	case DivvpOp:
347	378	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
348		forward_divvp_op_0(i_var, arg, parameter, J, Taylor);
	379	forward_divvp_op_0(i_var, arg, parameter, J, taylor);
349	380	break;
350	381	// -------------------------------------------------
351	382

355	386	break;
356	387	// -------------------------------------------------
357	388
	389	# if CPPAD_COMPILER_HAS_ERF
	390	case ErfOp:
	391	CPPAD_ASSERT_UNKNOWN( CPPAD_COMPILER_HAS_ERF );
	392	// 2DO: implement zero order version of this function
	393	forward_erf_op_0(i_var, arg, parameter, J, taylor);
	394	break;
	395	# endif
	396	// -------------------------------------------------
	397
358	398	case ExpOp:
359		forward_exp_op_0(i_var, arg[0], J, Taylor);
	399	forward_exp_op_0(i_var, arg[0], J, taylor);
360	400	break;
361	401	// -------------------------------------------------
362	402
363	403	case InvOp:
	404	CPPAD_ASSERT_NARG_NRES(op, 0, 1);
364	405	break;
365	406	// -------------------------------------------------
366	407
367	408	case LdpOp:
368		CPPAD_ASSERT_UNKNOWN( VectorInd.size() != 0 );
369		CPPAD_ASSERT_UNKNOWN( VectorVar.size() != 0 );
370		non_const_arg = Rec->forward_non_const_arg();
371	409	forward_load_p_op_0(
	410	play,
372	411	i_var,
373		non_const_arg,
374		num_par,
	412	arg,
375	413	parameter,
376	414	J,
377		Taylor,
378		Rec->num_rec_vecad_ind(),
379		VectorVar.data(),
380		VectorInd.data()
	415	taylor,
	416	isvar_by_ind.data(),
	417	index_by_ind.data(),
	418	var_by_load_op.data()
381	419	);
382	420	break;
383	421	// -------------------------------------------------
384	422
385	423	case LdvOp:
386		CPPAD_ASSERT_UNKNOWN( VectorInd.size() != 0 );
387		CPPAD_ASSERT_UNKNOWN( VectorVar.size() != 0 );
388		non_const_arg = Rec->forward_non_const_arg();
389	424	forward_load_v_op_0(
	425	play,
390	426	i_var,
391		non_const_arg,
392		num_par,
	427	arg,
393	428	parameter,
394	429	J,
395		Taylor,
396		Rec->num_rec_vecad_ind(),
397		VectorVar.data(),
398		VectorInd.data()
	430	taylor,
	431	isvar_by_ind.data(),
	432	index_by_ind.data(),
	433	var_by_load_op.data()
399	434	);
400	435	break;
401	436	// -------------------------------------------------
402	437
403	438	case LogOp:
404		forward_log_op_0(i_var, arg[0], J, Taylor);
	439	forward_log_op_0(i_var, arg[0], J, taylor);
405	440	break;
406	441	// -------------------------------------------------
407	442
408	443	case MulvvOp:
409		forward_mulvv_op_0(i_var, arg, parameter, J, Taylor);
	444	forward_mulvv_op_0(i_var, arg, parameter, J, taylor);
410	445	break;
411	446	// -------------------------------------------------
412	447
413	448	case MulpvOp:
414	449	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
415		forward_mulpv_op_0(i_var, arg, parameter, J, Taylor);
	450	forward_mulpv_op_0(i_var, arg, parameter, J, taylor);
416	451	break;
417	452	// -------------------------------------------------
418	453
419	454	case ParOp:
420	455	forward_par_op_0(
421		i_var, arg, num_par, parameter, J, Taylor
	456	i_var, arg, num_par, parameter, J, taylor
422	457	);
423	458	break;
424	459	// -------------------------------------------------
425	460
426	461	case PowvpOp:
427	462	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
428		forward_powvp_op_0(i_var, arg, parameter, J, Taylor);
	463	forward_powvp_op_0(i_var, arg, parameter, J, taylor);
429	464	break;
430	465	// -------------------------------------------------
431	466
432	467	case PowpvOp:
433	468	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
434		forward_powpv_op_0(i_var, arg, parameter, J, Taylor);
	469	forward_powpv_op_0(i_var, arg, parameter, J, taylor);
435	470	break;
436	471	// -------------------------------------------------
437	472
438	473	case PowvvOp:
439		forward_powvv_op_0(i_var, arg, parameter, J, Taylor);
	474	forward_powvv_op_0(i_var, arg, parameter, J, taylor);
440	475	break;
441	476	// -------------------------------------------------
442	477
443	478	case PriOp:
444	479	if( print ) forward_pri_0(s_out,
445		i_var, arg, num_text, text, num_par, parameter, J, Taylor
	480	arg, num_text, text, num_par, parameter, J, taylor
446	481	);
447	482	break;
448	483	// -------------------------------------------------

450	485	case SignOp:
451	486	// cos(x), sin(x)
452	487	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
453		forward_sign_op_0(i_var, arg[0], J, Taylor);
	488	forward_sign_op_0(i_var, arg[0], J, taylor);
454	489	break;
455	490	// -------------------------------------------------
456	491
457	492	case SinOp:
458	493	// cos(x), sin(x)
459	494	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
460		forward_sin_op_0(i_var, arg[0], J, Taylor);
	495	forward_sin_op_0(i_var, arg[0], J, taylor);
461	496	break;
462	497	// -------------------------------------------------
463	498
464	499	case SinhOp:
465	500	// cosh(x), sinh(x)
466	501	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
467		forward_sinh_op_0(i_var, arg[0], J, Taylor);
	502	forward_sinh_op_0(i_var, arg[0], J, taylor);
468	503	break;
469	504	// -------------------------------------------------
470	505
471	506	case SqrtOp:
472		forward_sqrt_op_0(i_var, arg[0], J, Taylor);
	507	forward_sqrt_op_0(i_var, arg[0], J, taylor);
473	508	break;
474	509	// -------------------------------------------------
475	510

479	514	arg,
480	515	num_par,
481	516	J,
482		Taylor,
483		Rec->num_rec_vecad_ind(),
484		VectorVar.data(),
485		VectorInd.data()
	517	taylor,
	518	isvar_by_ind.data(),
	519	index_by_ind.data()
486	520	);
487	521	break;
488	522	// -------------------------------------------------

493	527	arg,
494	528	num_par,
495	529	J,
496		Taylor,
497		Rec->num_rec_vecad_ind(),
498		VectorVar.data(),
499		VectorInd.data()
	530	taylor,
	531	isvar_by_ind.data(),
	532	index_by_ind.data()
500	533	);
501	534	break;
502	535	// -------------------------------------------------

507	540	arg,
508	541	num_par,
509	542	J,
510		Taylor,
511		Rec->num_rec_vecad_ind(),
512		VectorVar.data(),
513		VectorInd.data()
	543	taylor,
	544	isvar_by_ind.data(),
	545	index_by_ind.data()
514	546	);
515	547	break;
516	548	// -------------------------------------------------

521	553	arg,
522	554	num_par,
523	555	J,
524		Taylor,
525		Rec->num_rec_vecad_ind(),
526		VectorVar.data(),
527		VectorInd.data()
	556	taylor,
	557	isvar_by_ind.data(),
	558	index_by_ind.data()
528	559	);
529	560	break;
530	561	// -------------------------------------------------
531	562
532	563	case SubvvOp:
533		forward_subvv_op_0(i_var, arg, parameter, J, Taylor);
	564	forward_subvv_op_0(i_var, arg, parameter, J, taylor);
534	565	break;
535	566	// -------------------------------------------------
536	567
537	568	case SubpvOp:
538	569	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
539		forward_subpv_op_0(i_var, arg, parameter, J, Taylor);
	570	forward_subpv_op_0(i_var, arg, parameter, J, taylor);
540	571	break;
541	572	// -------------------------------------------------
542	573
543	574	case SubvpOp:
544	575	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
545		forward_subvp_op_0(i_var, arg, parameter, J, Taylor);
	576	forward_subvp_op_0(i_var, arg, parameter, J, taylor);
546	577	break;
547	578	// -------------------------------------------------
548	579
549	580	case TanOp:
550	581	// tan(x)^2, tan(x)
551	582	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
552		forward_tan_op_0(i_var, arg[0], J, Taylor);
	583	forward_tan_op_0(i_var, arg[0], J, taylor);
553	584	break;
554	585	// -------------------------------------------------
555	586
556	587	case TanhOp:
557	588	// tanh(x)^2, tanh(x)
558	589	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
559		forward_tanh_op_0(i_var, arg[0], J, Taylor);
	590	forward_tanh_op_0(i_var, arg[0], J, taylor);
560	591	break;
561	592	// -------------------------------------------------
562	593

582	613	user_tx.resize(user_n);
583	614	if(user_ty.size() != user_m)
584	615	user_ty.resize(user_m);
	616	# if CPPAD_FORWARD0SWEEP_TRACE
	617	if( user_iy.size() != user_m )
	618	user_iy.resize(user_m);
	619	# endif
585	620	user_j = 0;
586	621	user_i = 0;
587	622	user_state = user_arg;

600	635	CPPAD_ASSERT_KNOWN(false, msg.c_str() );
601	636	}
602	637	# endif
	638	# if CPPAD_FORWARD0SWEEP_TRACE
	639	user_state = user_trace;
	640	# else
603	641	user_state = user_start;
	642	# endif
604	643	}
605	644	break;
606	645

613	652	if( user_j == user_n )
614	653	{ // call users function for this operation
615	654	user_atom->set_id(user_id);
616		CPPAD_ATOMIC_CALL(user_q, user_p,
	655	CPPAD_ATOMIC_CALL(p, q,
617	656	user_vx, user_vy, user_tx, user_ty
618	657	);
619	658	user_state = user_ret;

625	664	CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
626	665	CPPAD_ASSERT_UNKNOWN( user_j < user_n );
627	666	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
628		user_tx[user_j++] = Taylor[ arg[0] * J + 0 ];
	667	user_tx[user_j++] = taylor[ arg[0] * J + 0 ];
629	668	if( user_j == user_n )
630	669	{ // call users function for this operation
631	670	user_atom->set_id(user_id);
632		CPPAD_ATOMIC_CALL(user_q, user_p,
	671	CPPAD_ATOMIC_CALL(p, q,
633	672	user_vx, user_vy, user_tx, user_ty
634	673	);
635	674	user_state = user_ret;

640	679	// parameter result in an atomic operation sequence
641	680	CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
642	681	CPPAD_ASSERT_UNKNOWN( user_i < user_m );
	682	# if CPPAD_FORWARD0SWEEP_TRACE
	683	user_iy[user_i] = 0;
	684	# endif
643	685	user_i++;
644	686	if( user_i == user_m )
645	687	user_state = user_end;

649	691	// variable result in an atomic operation sequence
650	692	CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
651	693	CPPAD_ASSERT_UNKNOWN( user_i < user_m );
652		Taylor[ i_var * J + 0 ] = user_ty[user_i++];
	694	# if CPPAD_FORWARD0SWEEP_TRACE
	695	user_iy[user_i] = i_var;
	696	# endif
	697	taylor[ i_var * J + 0 ] = user_ty[user_i++];
653	698	if( user_i == user_m )
654	699	user_state = user_end;
655	700	break;

659	704	CPPAD_ASSERT_UNKNOWN(false);
660	705	}
661	706	# if CPPAD_FORWARD0SWEEP_TRACE
662		size_t d = 0;
663		size_t i_tmp = i_var;
664		Base* Z_tmp = Taylor + i_var * J;
665
666		printOp(
667		std::cout,
668		Rec,
669		i_op,
670		i_tmp,
671		op,
672		arg,
673		d + 1,
674		Z_tmp,
675		0,
676		(Base *) CPPAD_NULL
677		);
	707	size_t d = 0;
	708	if( user_state == user_trace )
	709	{ user_state = user_start;
	710
	711	CPPAD_ASSERT_UNKNOWN( op == UserOp );
	712	CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
	713	for(size_t i = 0; i < user_m; i++) if( user_iy[i] > 0 )
	714	{ size_t i_tmp = (i_op + i) - user_m;
	715	printOp(
	716	std::cout,
	717	play,
	718	i_tmp,
	719	user_iy[i],
	720	UsrrvOp,
	721	CPPAD_NULL
	722	);
	723	Base* Z_tmp = taylor + user_iy[i] * J;
	724	printOpResult(
	725	std::cout,
	726	d + 1,
	727	Z_tmp,
	728	0,
	729	(Base *) CPPAD_NULL
	730	);
	731	std::cout << std::endl;
	732	}
	733	}
	734	Base* Z_tmp = taylor + i_var * J;
	735	const addr_t* arg_tmp = arg;
	736	if( op == CSumOp )
	737	arg_tmp = arg - arg[-1] - 4;
	738	if( op == CSkipOp )
	739	arg_tmp = arg - arg[-1] - 7;
	740	if( op != UsrrvOp )
	741	{
	742	printOp(
	743	std::cout,
	744	play,
	745	i_op,
	746	i_var,
	747	op,
	748	arg_tmp
	749	);
	750	if( NumRes(op) > 0 ) printOpResult(
	751	std::cout,
	752	d + 1,
	753	Z_tmp,
	754	0,
	755	(Base *) CPPAD_NULL
	756	);
	757	std::cout << std::endl;
	758	}
678	759	}
679	760	std::cout << std::endl;
680	761	# else
681	762	}
682	763	# endif
683	764	CPPAD_ASSERT_UNKNOWN( user_state == user_start );
684		CPPAD_ASSERT_UNKNOWN( i_var + 1 == Rec->num_rec_var() );
	765	CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
685	766
686	767	return compareCount;
687	768	}
688	769
689		/! \} /
690	770	} // END_CPPAD_NAMESPACE
691	771
692	772	// preprocessor symbols that are local to this file

+896

-0

cppad/local/forward1sweep.hpp less more

	0	/* $Id: forward1sweep.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
	1	# ifndef CPPAD_FORWARD1SWEEP_INCLUDED
	2	# define CPPAD_FORWARD1SWEEP_INCLUDED
	3
	4	/* --------------------------------------------------------------------------
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	6
	7	CppAD is distributed under multiple licenses. This distribution is under
	8	the terms of the
	9	GNU General Public License Version 3.
	10
	11	A copy of this license is included in the COPYING file of this distribution.
	12	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	13	-------------------------------------------------------------------------- */
	14
	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
	16	/*!
	17	\file forward1sweep.hpp
	18	Compute one Taylor coefficient for each order requested.
	19	*/
	20
	21	/*
	22	\def CPPAD_ATOMIC_CALL
	23	This avoids warnings when NDEBUG is defined and user_ok is not used.
	24	If NDEBUG is defined, this resolves to
	25	\code
	26	user_atom->forward
	27	\endcode
	28	otherwise, it respolves to
	29	\code
	30	user_ok = user_atom->forward
	31	\endcode
	32	This macro is undefined at the end of this file to facillitate its
	33	use with a different definition in other files.
	34	*/
	35	# ifdef NDEBUG
	36	# define CPPAD_ATOMIC_CALL user_atom->forward
	37	# else
	38	# define CPPAD_ATOMIC_CALL user_ok = user_atom->forward
	39	# endif
	40
	41	/*!
	42	\def CPPAD_FORWARD1SWEEP_TRACE
	43	This value is either zero or one.
	44	Zero is the normal operational value.
	45	If it is one, a trace of every forward1sweep computation is printed.
	46	*/
	47	# define CPPAD_FORWARD1SWEEP_TRACE 0
	48
	49	/*!
	50	Compute arbitrary order forward mode Taylor coefficients.
	51
	52	<!-- replace forward0sweep_doc_define -->
	53	\tparam Base
	54	The type used during the forward mode computations; i.e., the corresponding
	55	recording of operations used the type AD<Base>.
	56
	57	\param s_out
	58	Is the stream where output corresponding to PriOp operations will
	59	be written.
	60
	61	\param print
	62	If print is false,
	63	suppress the output that is otherwise generated by the c PriOp instructions.
	64
	65	\param n
	66	is the number of independent variables on the tape.
	67
	68	\param numvar
	69	is the total number of variables on the tape.
	70	This is also equal to the number of rows in the matrix taylor; i.e.,
	71	play->num_var_rec().
	72
	73	\param play
	74	The information stored in play
	75	is a recording of the operations corresponding to the function
	76	\f[
	77	F : {\bf R}^n \rightarrow {\bf R}^m
	78	\f]
	79	where \f$ n \f$ is the number of independent variables and
	80	\f$ m \f$ is the number of dependent variables.
	81	\n
	82	\n
	83	The object play is effectly constant.
	84	The exception to this is that while palying back the tape
	85	the object play holds information about the current location
	86	with in the tape and this changes during palyback.
	87
	88	\param J
	89	Is the number of columns in the coefficient matrix taylor.
	90	This must be greater than or equal one.
	91
	92	<!-- end forward0sweep_doc_define -->
	93
	94	\param cskip_op
	95	Is a vector with size play->num_op_rec().
	96	\n
	97	\n
	98	<tt>p = 0</tt>
	99	\n
	100	In this case,
	101	the input value of the elements does not matter.
	102	Upon return, if cskip_op[i] is true, the operator with index i
	103	does not affect any of the dependent variable
	104	(given the value of the independent variables).
	105	\n
	106	\n
	107	<tt>p > 0</tt>
	108	\n
	109	In this case cskip_op is not modified and has the same meaning
	110	as its return value above.
	111
	112	\param var_by_load_op
	113	is a vector with size play->num_load_op_rec().
	114	\n
	115	\n
	116	<tt>p == 0</tt>
	117	\n
	118	In this case,
	119	The input value of the elements does not matter.
	120	Upon return,
	121	it is the variable index corresponding the result for each load operator.
	122	In the case where the index is zero,
	123	the load operator results in a parameter (not a variable).
	124	Note that the is no variable with index zero on the tape.
	125	\n
	126	\n
	127	<tt>p > 0</tt>
	128	\n
	129	In this case var_by_load_op is not modified and has the meaning
	130	as its return value above.
	131
	132	\param p
	133	is the lowest order of the Taylor coefficients
	134	that are computed during this call.
	135
	136	\param q
	137	is the highest order of the Taylor coefficients
	138	that are computed during this call.
	139
	140	\param taylor
	141	\n
	142	\b Input:
	143	For <code>i = 1 , ... , numvar-1</code>,
	144	<code>k = 0 , ... , p-1</code>,
	145	<code>taylor[ J*i + k]</code>
	146	is the k-th order Taylor coefficient corresponding to
	147	the i-th variable.
	148	\n
	149	\n
	150	\b Input:
	151	For <code>i = 1 , ... , n</code>,
	152	<code>k = p , ... , q</code>,
	153	<code>taylor[ J*j + k]</code>
	154	is the k-th order Taylor coefficient corresponding to
	155	the i-th variable
	156	(these are the independent varaibles).
	157	\n
	158	\n
	159	\b Output:
	160	For <code>i = n+1 , ... , numvar-1</code>, and
	161	<code>k = 0 , ... , p-1</code>,
	162	<code>taylor[ J*i + k]</code>
	163	is the k-th order Taylor coefficient corresponding to
	164	the i-th variable.
	165
	166	\return
	167	If p is not zero, the return value is zero.
	168	If p is zero,
	169	the return value is equal to the number of ComOp operations
	170	that have a different result from when the information in
	171	a play was recorded.
	172	(Note that if NDEBUG is true, there are no ComOp operations
	173	in play and hence this return value is always zero.)
	174	*/
	175
	176	template <class Base>
	177	size_t forward1sweep(
	178	std::ostream& s_out,
	179	const bool print,
	180	const size_t p,
	181	const size_t q,
	182	const size_t n,
	183	const size_t numvar,
	184	player<Base>* play,
	185	const size_t J,
	186	Base* taylor,
	187	bool* cskip_op,
	188	pod_vector<addr_t>& var_by_load_op
	189	)
	190	{
	191	// number of directions
	192	const size_t r = 1;
	193
	194	CPPAD_ASSERT_UNKNOWN( p <= q );
	195	CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
	196	CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
	197
	198	/*
	199	<!-- replace forward0sweep_code_define -->
	200	*/
	201	// op code for current instruction
	202	OpCode op;
	203
	204	// index for current instruction
	205	size_t i_op;
	206
	207	// next variables
	208	size_t i_var;
	209
	210	// operation argument indices
	211	const addr_t* arg = CPPAD_NULL;
	212
	213	// initialize the comparision operator (ComOp) counter
	214	size_t compareCount = 0;
	215
	216	// If this includes a zero calculation, initialize this information
	217	pod_vector<bool> isvar_by_ind;
	218	pod_vector<size_t> index_by_ind;
	219	if( p == 0 )
	220	{ size_t i;
	221
	222	// this includes order zero calculation, initialize vector indices
	223	size_t num = play->num_vec_ind_rec();
	224	if( num > 0 )
	225	{ isvar_by_ind.extend(num);
	226	index_by_ind.extend(num);
	227	for(i = 0; i < num; i++)
	228	{ index_by_ind[i] = play->GetVecInd(i);
	229	isvar_by_ind[i] = false;
	230	}
	231	}
	232	// includes zero order, so initialize conditional skip flags
	233	num = play->num_op_rec();
	234	for(i = 0; i < num; i++)
	235	cskip_op[i] = false;
	236	}
	237
	238	// work space used by UserOp.
	239	vector<bool> user_vx; // empty vecotor
	240	vector<bool> user_vy; // empty vecotor
	241	vector<Base> user_tx; // argument vector Taylor coefficients
	242	vector<Base> user_ty; // result vector Taylor coefficients
	243	size_t user_index = 0; // indentifier for this atomic operation
	244	size_t user_id = 0; // user identifier for this call to operator
	245	size_t user_i = 0; // index in result vector
	246	size_t user_j = 0; // index in argument vector
	247	size_t user_m = 0; // size of result vector
	248	size_t user_n = 0; // size of arugment vector
	249	//
	250	atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
	251	# ifndef NDEBUG
	252	bool user_ok = false; // atomic op return value
	253	# endif
	254	//
	255	// next expected operator in a UserOp sequence
	256	enum { user_start, user_arg, user_ret, user_end, user_trace }
	257	user_state = user_start;
	258
	259	// length of the parameter vector (used by CppAD assert macros)
	260	const size_t num_par = play->num_par_rec();
	261
	262	// pointer to the beginning of the parameter vector
	263	const Base* parameter = CPPAD_NULL;
	264	if( num_par > 0 )
	265	parameter = play->GetPar();
	266
	267	// length of the text vector (used by CppAD assert macros)
	268	const size_t num_text = play->num_text_rec();
	269
	270	// pointer to the beginning of the text vector
	271	const char* text = CPPAD_NULL;
	272	if( num_text > 0 )
	273	text = play->GetTxt(0);
	274	/*
	275	<!-- end forward0sweep_code_define -->
	276	*/
	277	// temporary indices
	278	size_t i, k;
	279
	280	// number of orders for this user calculation
	281	// (not needed for order zero)
	282	const size_t user_q1 = q+1;
	283
	284	// variable indices for results vector
	285	// (done differently for order zero).
	286	vector<size_t> user_iy;
	287
	288	// skip the BeginOp at the beginning of the recording
	289	play->forward_start(op, arg, i_op, i_var);
	290	CPPAD_ASSERT_UNKNOWN( op == BeginOp );
	291	# if CPPAD_FORWARD1SWEEP_TRACE
	292	std::cout << std::endl;
	293	# endif
	294	bool more_operators = true;
	295	while(more_operators)
	296	{
	297	// this op
	298	play->forward_next(op, arg, i_op, i_var);
	299	CPPAD_ASSERT_UNKNOWN( (i_op > n) \| (op == InvOp) );
	300	CPPAD_ASSERT_UNKNOWN( (i_op <= n) \| (op != InvOp) );
	301	CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
	302	CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
	303
	304	// check if we are skipping this operation
	305	while( cskip_op[i_op] )
	306	{ if( op == CSumOp )
	307	{ // CSumOp has a variable number of arguments
	308	play->forward_csum(op, arg, i_op, i_var);
	309	}
	310	CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
	311	// if( op == CSkipOp )
	312	// { // CSkip has a variable number of arguments
	313	// play->forward_cskip(op, arg, i_op, i_var);
	314	// }
	315	play->forward_next(op, arg, i_op, i_var);
	316	CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
	317	}
	318
	319	// action depends on the operator
	320	switch( op )
	321	{
	322	case AbsOp:
	323	forward_abs_op(p, q, i_var, arg[0], J, taylor);
	324	break;
	325	// -------------------------------------------------
	326
	327	case AddvvOp:
	328	forward_addvv_op(p, q, i_var, arg, parameter, J, taylor);
	329	break;
	330	// -------------------------------------------------
	331
	332	case AddpvOp:
	333	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	334	forward_addpv_op(p, q, i_var, arg, parameter, J, taylor);
	335	break;
	336	// -------------------------------------------------
	337
	338	case AcosOp:
	339	// sqrt(1 - x * x), acos(x)
	340	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	341	forward_acos_op(p, q, i_var, arg[0], J, taylor);
	342	break;
	343	// -------------------------------------------------
	344
	345	case AsinOp:
	346	// sqrt(1 - x * x), asin(x)
	347	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	348	forward_asin_op(p, q, i_var, arg[0], J, taylor);
	349	break;
	350	// -------------------------------------------------
	351
	352	case AtanOp:
	353	// 1 + x * x, atan(x)
	354	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	355	forward_atan_op(p, q, i_var, arg[0], J, taylor);
	356	break;
	357	// -------------------------------------------------
	358
	359	# if CPPAD_COMPILER_HAS_ERF
	360	case ErfOp:
	361	CPPAD_ASSERT_UNKNOWN( CPPAD_COMPILER_HAS_ERF );
	362	// 2DO: implement zero order version of this function
	363	forward_erf_op(p, q, i_var, arg, parameter, J, taylor);
	364	break;
	365	# endif
	366	// -------------------------------------------------
	367
	368	case CExpOp:
	369	forward_cond_op(
	370	p, q, i_var, arg, num_par, parameter, J, taylor
	371	);
	372	break;
	373	// ---------------------------------------------------
	374
	375	case ComOp:
	376	if( p == 0 ) forward_comp_op_0(
	377	compareCount, arg, num_par, parameter, J, taylor
	378	);
	379	break;
	380	// ---------------------------------------------------
	381
	382	case CosOp:
	383	// sin(x), cos(x)
	384	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	385	forward_cos_op(p, q, i_var, arg[0], J, taylor);
	386	break;
	387	// ---------------------------------------------------
	388
	389	case CoshOp:
	390	// sinh(x), cosh(x)
	391	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	392	forward_cosh_op(p, q, i_var, arg[0], J, taylor);
	393	break;
	394	// -------------------------------------------------
	395
	396	case CSkipOp:
	397	// CSkipOp has a variable number of arguments and
	398	// forward_next thinks it has no arguments.
	399	// we must inform forward_next of this special case.
	400	if( p == 0 )
	401	{ forward_cskip_op_0(
	402	i_var, arg, num_par, parameter, J, taylor, cskip_op
	403	);
	404	}
	405	play->forward_cskip(op, arg, i_op, i_var);
	406	break;
	407	// -------------------------------------------------
	408
	409	case CSumOp:
	410	// CSumOp has a variable number of arguments and
	411	// forward_next thinks it has no arguments.
	412	// we must inform forward_next of this special case.
	413	forward_csum_op(
	414	p, q, i_var, arg, num_par, parameter, J, taylor
	415	);
	416	play->forward_csum(op, arg, i_op, i_var);
	417	break;
	418	// -------------------------------------------------
	419
	420	case DisOp:
	421	forward_dis_op(p, q, r, i_var, arg, J, taylor);
	422	break;
	423	// -------------------------------------------------
	424
	425	case DivvvOp:
	426	forward_divvv_op(p, q, i_var, arg, parameter, J, taylor);
	427	break;
	428	// -------------------------------------------------
	429
	430	case DivpvOp:
	431	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	432	forward_divpv_op(p, q, i_var, arg, parameter, J, taylor);
	433	break;
	434	// -------------------------------------------------
	435
	436	case DivvpOp:
	437	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
	438	forward_divvp_op(p, q, i_var, arg, parameter, J, taylor);
	439	break;
	440	// -------------------------------------------------
	441
	442	case EndOp:
	443	CPPAD_ASSERT_NARG_NRES(op, 0, 0);
	444	more_operators = false;
	445	break;
	446	// -------------------------------------------------
	447
	448	case ExpOp:
	449	forward_exp_op(p, q, i_var, arg[0], J, taylor);
	450	break;
	451	// -------------------------------------------------
	452
	453	case InvOp:
	454	CPPAD_ASSERT_NARG_NRES(op, 0, 1);
	455	break;
	456	// -------------------------------------------------
	457
	458	case LdpOp:
	459	if( p == 0 )
	460	{ forward_load_p_op_0(
	461	play,
	462	i_var,
	463	arg,
	464	parameter,
	465	J,
	466	taylor,
	467	isvar_by_ind.data(),
	468	index_by_ind.data(),
	469	var_by_load_op.data()
	470	);
	471	if( p < q ) forward_load_op(
	472	play,
	473	op,
	474	p+1,
	475	q,
	476	r,
	477	J,
	478	i_var,
	479	arg,
	480	var_by_load_op.data(),
	481	taylor
	482	);
	483	}
	484	else forward_load_op(
	485	play,
	486	op,
	487	p,
	488	q,
	489	r,
	490	J,
	491	i_var,
	492	arg,
	493	var_by_load_op.data(),
	494	taylor
	495	);
	496	break;
	497	// -------------------------------------------------
	498
	499	case LdvOp:
	500	if( p == 0 )
	501	{ forward_load_v_op_0(
	502	play,
	503	i_var,
	504	arg,
	505	parameter,
	506	J,
	507	taylor,
	508	isvar_by_ind.data(),
	509	index_by_ind.data(),
	510	var_by_load_op.data()
	511	);
	512	if( p < q ) forward_load_op(
	513	play,
	514	op,
	515	p+1,
	516	q,
	517	r,
	518	J,
	519	i_var,
	520	arg,
	521	var_by_load_op.data(),
	522	taylor
	523	);
	524	}
	525	else forward_load_op(
	526	play,
	527	op,
	528	p,
	529	q,
	530	r,
	531	J,
	532	i_var,
	533	arg,
	534	var_by_load_op.data(),
	535	taylor
	536	);
	537	break;
	538	// -------------------------------------------------
	539
	540	case LogOp:
	541	forward_log_op(p, q, i_var, arg[0], J, taylor);
	542	break;
	543	// -------------------------------------------------
	544
	545	case MulvvOp:
	546	forward_mulvv_op(p, q, i_var, arg, parameter, J, taylor);
	547	break;
	548	// -------------------------------------------------
	549
	550	case MulpvOp:
	551	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	552	forward_mulpv_op(p, q, i_var, arg, parameter, J, taylor);
	553	break;
	554	// -------------------------------------------------
	555
	556	case ParOp:
	557	i = p;
	558	if( i == 0 )
	559	{ forward_par_op_0(
	560	i_var, arg, num_par, parameter, J, taylor
	561	);
	562	i++;
	563	}
	564	while(i <= q)
	565	{ taylor[ i_var * J + i] = Base(0);
	566	i++;
	567	}
	568	break;
	569	// -------------------------------------------------
	570
	571	case PowvpOp:
	572	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
	573	forward_powvp_op(p, q, i_var, arg, parameter, J, taylor);
	574	break;
	575	// -------------------------------------------------
	576
	577	case PowpvOp:
	578	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	579	forward_powpv_op(p, q, i_var, arg, parameter, J, taylor);
	580	break;
	581	// -------------------------------------------------
	582
	583	case PowvvOp:
	584	forward_powvv_op(p, q, i_var, arg, parameter, J, taylor);
	585	break;
	586	// -------------------------------------------------
	587
	588	case PriOp:
	589	if( (p == 0) & print ) forward_pri_0(s_out,
	590	arg, num_text, text, num_par, parameter, J, taylor
	591	);
	592	break;
	593	// -------------------------------------------------
	594
	595	case SignOp:
	596	// sign(x)
	597	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	598	forward_sign_op(p, q, i_var, arg[0], J, taylor);
	599	break;
	600	// -------------------------------------------------
	601
	602	case SinOp:
	603	// cos(x), sin(x)
	604	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	605	forward_sin_op(p, q, i_var, arg[0], J, taylor);
	606	break;
	607	// -------------------------------------------------
	608
	609	case SinhOp:
	610	// cosh(x), sinh(x)
	611	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	612	forward_sinh_op(p, q, i_var, arg[0], J, taylor);
	613	break;
	614	// -------------------------------------------------
	615
	616	case SqrtOp:
	617	forward_sqrt_op(p, q, i_var, arg[0], J, taylor);
	618	break;
	619	// -------------------------------------------------
	620
	621	case StppOp:
	622	if( p == 0 )
	623	{ forward_store_pp_op_0(
	624	i_var,
	625	arg,
	626	num_par,
	627	J,
	628	taylor,
	629	isvar_by_ind.data(),
	630	index_by_ind.data()
	631	);
	632	}
	633	break;
	634	// -------------------------------------------------
	635
	636	case StpvOp:
	637	if( p == 0 )
	638	{ forward_store_pv_op_0(
	639	i_var,
	640	arg,
	641	num_par,
	642	J,
	643	taylor,
	644	isvar_by_ind.data(),
	645	index_by_ind.data()
	646	);
	647	}
	648	break;
	649	// -------------------------------------------------
	650
	651	case StvpOp:
	652	if( p == 0 )
	653	{ forward_store_vp_op_0(
	654	i_var,
	655	arg,
	656	num_par,
	657	J,
	658	taylor,
	659	isvar_by_ind.data(),
	660	index_by_ind.data()
	661	);
	662	}
	663	break;
	664	// -------------------------------------------------
	665
	666	case StvvOp:
	667	if( p == 0 )
	668	{ forward_store_vv_op_0(
	669	i_var,
	670	arg,
	671	num_par,
	672	J,
	673	taylor,
	674	isvar_by_ind.data(),
	675	index_by_ind.data()
	676	);
	677	}
	678	break;
	679	// -------------------------------------------------
	680
	681	case SubvvOp:
	682	forward_subvv_op(p, q, i_var, arg, parameter, J, taylor);
	683	break;
	684	// -------------------------------------------------
	685
	686	case SubpvOp:
	687	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	688	forward_subpv_op(p, q, i_var, arg, parameter, J, taylor);
	689	break;
	690	// -------------------------------------------------
	691
	692	case SubvpOp:
	693	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
	694	forward_subvp_op(p, q, i_var, arg, parameter, J, taylor);
	695	break;
	696	// -------------------------------------------------
	697
	698	case TanOp:
	699	// tan(x)^2, tan(x)
	700	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	701	forward_tan_op(p, q, i_var, arg[0], J, taylor);
	702	break;
	703	// -------------------------------------------------
	704
	705	case TanhOp:
	706	// tanh(x)^2, tanh(x)
	707	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	708	forward_tanh_op(p, q, i_var, arg[0], J, taylor);
	709	break;
	710	// -------------------------------------------------
	711
	712	case UserOp:
	713	// start or end an atomic operation sequence
	714	CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
	715	CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
	716	if( user_state == user_start )
	717	{ user_index = arg[0];
	718	user_id = arg[1];
	719	user_n = arg[2];
	720	user_m = arg[3];
	721	user_atom = atomic_base<Base>::class_object(user_index);
	722	# ifndef NDEBUG
	723	if( user_atom == CPPAD_NULL )
	724	{ std::string msg =
	725	atomic_base<Base>::class_name(user_index)
	726	+ ": atomic_base function has been deleted";
	727	CPPAD_ASSERT_KNOWN(false, msg.c_str() );
	728	}
	729	# endif
	730	if(user_tx.size() != user_n * user_q1)
	731	user_tx.resize(user_n * user_q1);
	732	if(user_ty.size() != user_m * user_q1)
	733	user_ty.resize(user_m * user_q1);
	734	if(user_iy.size() != user_m)
	735	user_iy.resize(user_m);
	736	user_j = 0;
	737	user_i = 0;
	738	user_state = user_arg;
	739	}
	740	else
	741	{ CPPAD_ASSERT_UNKNOWN( user_state == user_end );
	742	CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
	743	CPPAD_ASSERT_UNKNOWN( user_id == size_t(arg[1]) );
	744	CPPAD_ASSERT_UNKNOWN( user_n == size_t(arg[2]) );
	745	CPPAD_ASSERT_UNKNOWN( user_m == size_t(arg[3]) );
	746
	747	// call users function for this operation
	748	user_atom->set_id(user_id);
	749	CPPAD_ATOMIC_CALL(
	750	p, q, user_vx, user_vy, user_tx, user_ty
	751	);
	752	# ifndef NDEBUG
	753	if( ! user_ok )
	754	{ std::string msg =
	755	atomic_base<Base>::class_name(user_index)
	756	+ ": atomic_base.forward: returned false";
	757	CPPAD_ASSERT_KNOWN(false, msg.c_str() );
	758	}
	759	# endif
	760	for(i = 0; i < user_m; i++)
	761	if( user_iy[i] > 0 )
	762	for(k = p; k <= q; k++)
	763	taylor[ user_iy[i] * J + k ] =
	764	user_ty[ i * user_q1 + k ];
	765	# if CPPAD_FORWARD1SWEEP_TRACE
	766	user_state = user_trace;
	767	# else
	768	user_state = user_start;
	769	# endif
	770	}
	771	break;
	772
	773	case UsrapOp:
	774	// parameter argument in an atomic operation sequence
	775	CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
	776	CPPAD_ASSERT_UNKNOWN( user_j < user_n );
	777	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	778	user_tx[user_j * user_q1 + 0] = parameter[ arg[0]];
	779	for(k = 1; k < user_q1; k++)
	780	user_tx[user_j * user_q1 + k] = Base(0);
	781	++user_j;
	782	if( user_j == user_n )
	783	user_state = user_ret;
	784	break;
	785
	786	case UsravOp:
	787	// variable argument in an atomic operation sequence
	788	CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
	789	CPPAD_ASSERT_UNKNOWN( user_j < user_n );
	790	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
	791	for(k = 0; k < user_q1; k++)
	792	user_tx[user_j * user_q1 + k] = taylor[ arg[0] * J + k];
	793	++user_j;
	794	if( user_j == user_n )
	795	user_state = user_ret;
	796	break;
	797
	798	case UsrrpOp:
	799	// parameter result in an atomic operation sequence
	800	CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
	801	CPPAD_ASSERT_UNKNOWN( user_i < user_m );
	802	user_iy[user_i] = 0;
	803	user_ty[user_i * user_q1 + 0] = parameter[ arg[0]];
	804	for(k = 1; k < p; k++)
	805	user_ty[user_i * user_q1 + k] = Base(0);
	806	user_i++;
	807	if( user_i == user_m )
	808	user_state = user_end;
	809	break;
	810
	811	case UsrrvOp:
	812	// variable result in an atomic operation sequence
	813	CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
	814	CPPAD_ASSERT_UNKNOWN( user_i < user_m );
	815	user_iy[user_i] = i_var;
	816	for(k = 0; k < p; k++)
	817	user_ty[user_i * user_q1 + k] = taylor[ i_var * J + k];
	818	user_i++;
	819	if( user_i == user_m )
	820	user_state = user_end;
	821	break;
	822	// -------------------------------------------------
	823
	824	default:
	825	CPPAD_ASSERT_UNKNOWN(0);
	826	}
	827	# if CPPAD_FORWARD1SWEEP_TRACE
	828	if( user_state == user_trace )
	829	{ user_state = user_start;
	830
	831	CPPAD_ASSERT_UNKNOWN( op == UserOp );
	832	CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
	833	for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
	834	{ size_t i_tmp = (i_op + i) - user_m;
	835	printOp(
	836	std::cout,
	837	play,
	838	i_tmp,
	839	user_iy[i],
	840	UsrrvOp,
	841	CPPAD_NULL
	842	);
	843	Base* Z_tmp = taylor + user_iy[i] * J;
	844	printOpResult(
	845	std::cout,
	846	q + 1,
	847	Z_tmp,
	848	0,
	849	(Base *) CPPAD_NULL
	850	);
	851	std::cout << std::endl;
	852	}
	853	}
	854	Base* Z_tmp = taylor + J * i_var;
	855	const addr_t* arg_tmp = arg;
	856	if( op == CSumOp )
	857	arg_tmp = arg - arg[-1] - 4;
	858	if( op == CSkipOp )
	859	arg_tmp = arg - arg[-1] - 7;
	860	if( op != UsrrvOp )
	861	{
	862	printOp(
	863	std::cout,
	864	play,
	865	i_op,
	866	i_var,
	867	op,
	868	arg_tmp
	869	);
	870	if( NumRes(op) > 0 ) printOpResult(
	871	std::cout,
	872	q + 1,
	873	Z_tmp,
	874	0,
	875	(Base *) CPPAD_NULL
	876	);
	877	std::cout << std::endl;
	878	}
	879	}
	880	std::cout << std::endl;
	881	# else
	882	}
	883	# endif
	884	CPPAD_ASSERT_UNKNOWN( user_state == user_start );
	885	CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
	886
	887	return compareCount;
	888	}
	889
	890	// preprocessor symbols that are local to this file
	891	# undef CPPAD_FORWARD1SWEEP_TRACE
	892	# undef CPPAD_ATOMIC_CALL
	893
	894	} // END_CPPAD_NAMESPACE
	895	# endif

+746

-0

cppad/local/forward2sweep.hpp less more

	0	/* $Id: forward2sweep.hpp 3372 2014-09-28 18:42:37Z bradbell $ */
	1	# ifndef CPPAD_FORWARD2SWEEP_INCLUDED
	2	# define CPPAD_FORWARD2SWEEP_INCLUDED
	3
	4	/* --------------------------------------------------------------------------
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	6
	7	CppAD is distributed under multiple licenses. This distribution is under
	8	the terms of the
	9	GNU General Public License Version 3.
	10
	11	A copy of this license is included in the COPYING file of this distribution.
	12	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	13	-------------------------------------------------------------------------- */
	14
	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
	16	/*!
	17	\file forward2sweep.hpp
	18	Compute one Taylor coefficient for each direction requested.
	19	*/
	20
	21	/*
	22	\def CPPAD_ATOMIC_CALL
	23	This avoids warnings when NDEBUG is defined and user_ok is not used.
	24	If NDEBUG is defined, this resolves to
	25	\code
	26	user_atom->forward
	27	\endcode
	28	otherwise, it respolves to
	29	\code
	30	user_ok = user_atom->forward
	31	\endcode
	32	This macro is undefined at the end of this file to facillitate its
	33	use with a different definition in other files.
	34	*/
	35	# ifdef NDEBUG
	36	# define CPPAD_ATOMIC_CALL user_atom->forward
	37	# else
	38	# define CPPAD_ATOMIC_CALL user_ok = user_atom->forward
	39	# endif
	40
	41	/*!
	42	\def CPPAD_FORWARD2SWEEP_TRACE
	43	This value is either zero or one.
	44	Zero is the normal operational value.
	45	If it is one, a trace of every forward2sweep computation is printed.
	46	*/
	47	# define CPPAD_FORWARD2SWEEP_TRACE 0
	48
	49	/*!
	50	Compute multiple directions forward mode Taylor coefficients.
	51
	52	\tparam Base
	53	The type used during the forward mode computations; i.e., the corresponding
	54	recording of operations used the type AD<Base>.
	55
	56	\param q
	57	is the order of the Taylor coefficients
	58	that are computed during this call;
	59	<code>q > 0</code>.
	60
	61	\param r
	62	is the number of Taylor coefficients
	63	that are computed during this call.
	64
	65	\param n
	66	is the number of independent variables on the tape.
	67
	68	\param numvar
	69	is the total number of variables on the tape.
	70	This is also equal to the number of rows in the matrix taylor; i.e.,
	71	play->num_var_rec().
	72
	73	\param play
	74	The information stored in play
	75	is a recording of the operations corresponding to the function
	76	\f[
	77	F : {\bf R}^n \rightarrow {\bf R}^m
	78	\f]
	79	where \f$ n \f$ is the number of independent variables and
	80	\f$ m \f$ is the number of dependent variables.
	81	\n
	82	\n
	83	The object play is effectly constant.
	84	The exception to this is that while palying back the tape
	85	the object play holds information about the current location
	86	with in the tape and this changes during palyback.
	87
	88	\param J
	89	Is the number of columns in the coefficient matrix taylor.
	90	This must be greater than or equal one.
	91
	92	\param taylor
	93	\n
	94	\b Input:
	95	For <code>i = 1 , ... , numvar-1</code>,
	96	<code>taylor[ (J-1)ri + i + 0 ]</code>
	97	is the zero order Taylor coefficient corresponding to
	98	the i-th variable and all directions.
	99	For <code>i = 1 , ... , numvar-1</code>,
	100	For <code>k = 1 , ... , q-1</code>,
	101	<code>ell = 0 , ... , r-1</code>,
	102	<code>taylor[ (J-1)ri + i + (k-1)*r + ell + 1 ]</code>
	103	is the k-th order Taylor coefficient corresponding to
	104	the i-th variabel and ell-th direction.
	105	\n
	106	\n
	107	\b Input:
	108	For <code>i = 1 , ... , n</code>,
	109	<code>ell = 0 , ... , r-1</code>,
	110	<code>taylor[ (J-1)ri + i + (q-1)*r + ell + 1 ]</code>
	111	is the q-th order Taylor coefficient corresponding to
	112	the i-th variable and ell-th direction
	113	(these are the independent varaibles).
	114	\n
	115	\n
	116	\b Output:
	117	For <code>i = n+1 , ... , numvar-1</code>,
	118	<code>ell = 0 , ... , r-1</code>,
	119	<code>taylor[ (J-1)ri + i + (q-1)*r + ell + 1 ]</code>
	120	is the q-th order Taylor coefficient corresponding to
	121	the i-th variable and ell-th direction.
	122
	123	\param cskip_op
	124	Is a vector with size play->num_op_rec().
	125	If cskip_op[i] is true, the operator with index i
	126	does not affect any of the dependent variable (given the value
	127	of the independent variables).
	128
	129	\param var_by_load_op
	130	is a vector with size play->num_load_op_rec().
	131	It is the variable index corresponding to each the
	132	load instruction.
	133	In the case where the index is zero,
	134	the instruction corresponds to a parameter (not variable).
	135
	136	\return
	137	The return value is zero.
	138	*/
	139
	140	template <class Base>
	141	size_t forward2sweep(
	142	const size_t q,
	143	const size_t r,
	144	const size_t n,
	145	const size_t numvar,
	146	player<Base>* play,
	147	const size_t J,
	148	Base* taylor,
	149	const bool* cskip_op,
	150	const pod_vector<addr_t>& var_by_load_op
	151	)
	152	{
	153	CPPAD_ASSERT_UNKNOWN( q > 0 );
	154	CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
	155	CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
	156
	157	// used to avoid compiler errors until all operators are implemented
	158	size_t p = q;
	159
	160	// op code for current instruction
	161	OpCode op;
	162
	163	// index for current instruction
	164	size_t i_op;
	165
	166	// next variables
	167	size_t i_var;
	168
	169	// operation argument indices
	170	const addr_t* arg = CPPAD_NULL;
	171
	172	// initialize the comparision operator (ComOp) counter
	173	const size_t compareCount = 0;
	174
	175	// work space used by UserOp.
	176	vector<bool> user_vx; // empty vecotor
	177	vector<bool> user_vy; // empty vecotor
	178	vector<Base> user_tx_one; // argument vector Taylor coefficients
	179	vector<Base> user_tx_all;
	180	vector<Base> user_ty_one; // result vector Taylor coefficients
	181	vector<Base> user_ty_all;
	182	size_t user_index = 0; // indentifier for this atomic operation
	183	size_t user_id = 0; // user identifier for this call to operator
	184	size_t user_i = 0; // index in result vector
	185	size_t user_j = 0; // index in argument vector
	186	size_t user_m = 0; // size of result vector
	187	size_t user_n = 0; // size of arugment vector
	188	//
	189	atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
	190	# ifndef NDEBUG
	191	bool user_ok = false; // atomic op return value
	192	# endif
	193	//
	194	// next expected operator in a UserOp sequence
	195	enum { user_start, user_arg, user_ret, user_end, user_trace }
	196	user_state = user_start;
	197
	198	// length of the parameter vector (used by CppAD assert macros)
	199	const size_t num_par = play->num_par_rec();
	200
	201	// pointer to the beginning of the parameter vector
	202	const Base* parameter = CPPAD_NULL;
	203	if( num_par > 0 )
	204	parameter = play->GetPar();
	205
	206	// temporary indices
	207	size_t i, j, k, ell;
	208
	209	// number of orders for this user calculation
	210	// (not needed for order zero)
	211	const size_t user_q1 = q+1;
	212
	213	// variable indices for results vector
	214	// (done differently for order zero).
	215	vector<size_t> user_iy;
	216
	217	// skip the BeginOp at the beginning of the recording
	218	play->forward_start(op, arg, i_op, i_var);
	219	CPPAD_ASSERT_UNKNOWN( op == BeginOp );
	220	# if CPPAD_FORWARD2SWEEP_TRACE
	221	std::cout << std::endl;
	222	CppAD::vector<Base> Z_vec(q+1);
	223	# endif
	224	bool more_operators = true;
	225	while(more_operators)
	226	{
	227	// this op
	228	play->forward_next(op, arg, i_op, i_var);
	229	CPPAD_ASSERT_UNKNOWN( (i_op > n) \| (op == InvOp) );
	230	CPPAD_ASSERT_UNKNOWN( (i_op <= n) \| (op != InvOp) );
	231	CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
	232	CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
	233
	234	// check if we are skipping this operation
	235	while( cskip_op[i_op] )
	236	{ if( op == CSumOp )
	237	{ // CSumOp has a variable number of arguments
	238	play->forward_csum(op, arg, i_op, i_var);
	239	}
	240	CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
	241	// if( op == CSkipOp )
	242	// { // CSkip has a variable number of arguments
	243	// play->forward_cskip(op, arg, i_op, i_var);
	244	// }
	245	play->forward_next(op, arg, i_op, i_var);
	246	CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
	247	}
	248
	249	// action depends on the operator
	250	switch( op )
	251	{
	252	case AbsOp:
	253	forward_abs_op_dir(q, r, i_var, arg[0], J, taylor);
	254	break;
	255	// -------------------------------------------------
	256
	257	case AddvvOp:
	258	forward_addvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	259	break;
	260	// -------------------------------------------------
	261
	262	case AddpvOp:
	263	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	264	forward_addpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	265	break;
	266	// -------------------------------------------------
	267
	268	case AcosOp:
	269	// sqrt(1 - x * x), acos(x)
	270	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	271	forward_acos_op_dir(q, r, i_var, arg[0], J, taylor);
	272	break;
	273	// -------------------------------------------------
	274
	275	case AsinOp:
	276	// sqrt(1 - x * x), asin(x)
	277	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	278	forward_asin_op_dir(q, r, i_var, arg[0], J, taylor);
	279	break;
	280	// -------------------------------------------------
	281
	282	case AtanOp:
	283	// 1 + x * x, atan(x)
	284	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	285	forward_atan_op_dir(q, r, i_var, arg[0], J, taylor);
	286	break;
	287	// -------------------------------------------------
	288
	289	case CExpOp:
	290	forward_cond_op_dir(
	291	q, r, i_var, arg, num_par, parameter, J, taylor
	292	);
	293	break;
	294	// ---------------------------------------------------
	295
	296	case ComOp:
	297	CPPAD_ASSERT_UNKNOWN(q > 0 );
	298	break;
	299	// ---------------------------------------------------
	300
	301	case CosOp:
	302	// sin(x), cos(x)
	303	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	304	forward_cos_op_dir(q, r, i_var, arg[0], J, taylor);
	305	break;
	306	// ---------------------------------------------------
	307
	308	case CoshOp:
	309	// sinh(x), cosh(x)
	310	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	311	forward_cosh_op_dir(q, r, i_var, arg[0], J, taylor);
	312	break;
	313	// -------------------------------------------------
	314
	315	case CSkipOp:
	316	// CSkipOp has a variable number of arguments and
	317	// forward_next thinks it has no arguments.
	318	// we must inform forward_next of this special case.
	319	play->forward_cskip(op, arg, i_op, i_var);
	320	break;
	321	// -------------------------------------------------
	322
	323	case CSumOp:
	324	// CSumOp has a variable number of arguments and
	325	// forward_next thinks it has no arguments.
	326	// we must inform forward_next of this special case.
	327	forward_csum_op_dir(
	328	q, r, i_var, arg, num_par, parameter, J, taylor
	329	);
	330	play->forward_csum(op, arg, i_op, i_var);
	331	break;
	332	// -------------------------------------------------
	333
	334	case DisOp:
	335	forward_dis_op(p, q, r, i_var, arg, J, taylor);
	336	break;
	337	// -------------------------------------------------
	338
	339	case DivvvOp:
	340	forward_divvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	341	break;
	342	// -------------------------------------------------
	343
	344	case DivpvOp:
	345	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	346	forward_divpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	347	break;
	348	// -------------------------------------------------
	349
	350	case DivvpOp:
	351	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
	352	forward_divvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
	353	break;
	354	// -------------------------------------------------
	355
	356	case EndOp:
	357	// needed for sparse_jacobian test
	358	CPPAD_ASSERT_NARG_NRES(op, 0, 0);
	359	more_operators = false;
	360	break;
	361	// -------------------------------------------------
	362
	363	case ExpOp:
	364	forward_exp_op_dir(q, r, i_var, arg[0], J, taylor);
	365	break;
	366	// -------------------------------------------------
	367
	368	case InvOp:
	369	CPPAD_ASSERT_NARG_NRES(op, 0, 1);
	370	break;
	371	// -------------------------------------------------
	372
	373	case LdpOp:
	374	case LdvOp:
	375	forward_load_op(
	376	play,
	377	op,
	378	p,
	379	q,
	380	r,
	381	J,
	382	i_var,
	383	arg,
	384	var_by_load_op.data(),
	385	taylor
	386	);
	387	break;
	388	// -------------------------------------------------
	389
	390	case LogOp:
	391	forward_log_op_dir(q, r, i_var, arg[0], J, taylor);
	392	break;
	393	// -------------------------------------------------
	394
	395	case MulvvOp:
	396	forward_mulvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	397	break;
	398	// -------------------------------------------------
	399
	400	case MulpvOp:
	401	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	402	forward_mulpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	403	break;
	404	// -------------------------------------------------
	405
	406	case ParOp:
	407	k = i_var(J-1)r + i_var + (q-1)*r;
	408	for(ell = 0; ell < r; ell++)
	409	taylor[k + ell] = Base(0);
	410	break;
	411	// -------------------------------------------------
	412
	413	case PowpvOp:
	414	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	415	forward_powpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	416	break;
	417	// -------------------------------------------------
	418
	419	case PowvpOp:
	420	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
	421	forward_powvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
	422	break;
	423	// -------------------------------------------------
	424
	425	case PowvvOp:
	426	forward_powvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	427	break;
	428	// -------------------------------------------------
	429
	430	case PriOp:
	431	CPPAD_ASSERT_UNKNOWN(q > 0);
	432	break;
	433	// -------------------------------------------------
	434
	435	case SignOp:
	436	// sign(x)
	437	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	438	forward_sign_op_dir(q, r, i_var, arg[0], J, taylor);
	439	break;
	440	// -------------------------------------------------
	441
	442	case SinOp:
	443	// cos(x), sin(x)
	444	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	445	forward_sin_op_dir(q, r, i_var, arg[0], J, taylor);
	446	break;
	447	// -------------------------------------------------
	448
	449	case SinhOp:
	450	// cosh(x), sinh(x)
	451	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	452	forward_sinh_op_dir(q, r, i_var, arg[0], J, taylor);
	453	break;
	454	// -------------------------------------------------
	455
	456	case SqrtOp:
	457	forward_sqrt_op_dir(q, r, i_var, arg[0], J, taylor);
	458	break;
	459	// -------------------------------------------------
	460
	461	case StppOp:
	462	case StpvOp:
	463	case StvpOp:
	464	case StvvOp:
	465	CPPAD_ASSERT_UNKNOWN(q > 0 );
	466	break;
	467	// -------------------------------------------------
	468
	469	case SubvvOp:
	470	forward_subvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	471	break;
	472	// -------------------------------------------------
	473
	474	case SubpvOp:
	475	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	476	forward_subpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
	477	break;
	478	// -------------------------------------------------
	479
	480	case SubvpOp:
	481	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
	482	forward_subvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
	483	break;
	484	// -------------------------------------------------
	485
	486	case TanOp:
	487	// tan(x)^2, tan(x)
	488	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	489	forward_tan_op_dir(q, r, i_var, arg[0], J, taylor);
	490	break;
	491	// -------------------------------------------------
	492
	493	case TanhOp:
	494	// tanh(x)^2, tanh(x)
	495	CPPAD_ASSERT_UNKNOWN( i_var < numvar );
	496	forward_tanh_op_dir(q, r, i_var, arg[0], J, taylor);
	497	break;
	498	// -------------------------------------------------
	499
	500	case UserOp:
	501	// start or end an atomic operation sequence
	502	CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
	503	CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
	504	if( user_state == user_start )
	505	{ user_index = arg[0];
	506	user_id = arg[1];
	507	user_n = arg[2];
	508	user_m = arg[3];
	509	user_atom = atomic_base<Base>::class_object(user_index);
	510	# ifndef NDEBUG
	511	if( user_atom == CPPAD_NULL )
	512	{ std::string msg =
	513	atomic_base<Base>::class_name(user_index)
	514	+ ": atomic_base function has been deleted";
	515	CPPAD_ASSERT_KNOWN(false, msg.c_str() );
	516	}
	517	# endif
	518	if(user_tx_one.size() != user_n * user_q1)
	519	user_tx_one.resize(user_n * user_q1);
	520	if( user_tx_all.size() != user_n * (q * r + 1) )
	521	user_tx_all.resize(user_n * (q * r + 1));
	522	//
	523	if(user_ty_one.size() != user_m * user_q1)
	524	user_ty_one.resize(user_m * user_q1);
	525	if( user_ty_all.size() != user_m * (q * r + 1) )
	526	user_ty_all.resize(user_m * (q * r + 1));
	527	//
	528	if(user_iy.size() != user_m)
	529	user_iy.resize(user_m);
	530	user_j = 0;
	531	user_i = 0;
	532	user_state = user_arg;
	533	}
	534	else
	535	{ CPPAD_ASSERT_UNKNOWN( user_state == user_end );
	536	CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
	537	CPPAD_ASSERT_UNKNOWN( user_id == size_t(arg[1]) );
	538	CPPAD_ASSERT_UNKNOWN( user_n == size_t(arg[2]) );
	539	CPPAD_ASSERT_UNKNOWN( user_m == size_t(arg[3]) );
	540
	541	// call users function for this operation
	542	user_atom->set_id(user_id);
	543	for(ell = 0; ell < r; ell++)
	544	{ // set user_tx
	545	for(j = 0; j < user_n; j++)
	546	{ size_t j_all = j * (q * r + 1);
	547	size_t j_one = j * user_q1;
	548	user_tx_one[j_one+0] = user_tx_all[j_all+0];
	549	for(k = 1; k < user_q1; k++)
	550	{ size_t k_all = j_all + (k-1)*r+1+ell;
	551	size_t k_one = j_one + k;
	552	user_tx_one[k_one] = user_tx_all[k_all];
	553	}
	554	}
	555	// set user_ty
	556	for(i = 0; i < user_m; i++)
	557	{ size_t i_all = i * (q * r + 1);
	558	size_t i_one = i * user_q1;
	559	user_ty_one[i_one+0] = user_ty_all[i_all+0];
	560	for(k = 1; k < q; k++)
	561	{ size_t k_all = i_all + (k-1)*r+1+ell;
	562	size_t k_one = i_one + k;
	563	user_ty_one[k_one] = user_ty_all[k_all];
	564	}
	565	}
	566	CPPAD_ATOMIC_CALL(
	567	q, q, user_vx, user_vy, user_tx_one, user_ty_one
	568	);
	569	# ifndef NDEBUG
	570	if( ! user_ok )
	571	{ std::string msg =
	572	atomic_base<Base>::class_name(user_index)
	573	+ ": atomic_base.forward: returned false";
	574	CPPAD_ASSERT_KNOWN(false, msg.c_str() );
	575	}
	576	# endif
	577	for(i = 0; i < user_m; i++)
	578	{ if( user_iy[i] > 0 )
	579	{ size_t i_taylor = user_iy[i]((J-1)r+1);
	580	size_t q_taylor = i_taylor + (q-1)*r+1+ell;
	581	size_t q_one = i * user_q1 + q;
	582	taylor[q_taylor] = user_ty_one[q_one];
	583	}
	584	}
	585	}
	586	# if CPPAD_FORWARD2SWEEP_TRACE
	587	user_state = user_trace;
	588	# else
	589	user_state = user_start;
	590	# endif
	591	}
	592	break;
	593
	594	case UsrapOp:
	595	// parameter argument in an atomic operation sequence
	596	CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
	597	CPPAD_ASSERT_UNKNOWN( user_j < user_n );
	598	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
	599	user_tx_all[user_j(qr+1) + 0] = parameter[ arg[0]];
	600	for(ell = 0; ell < r; ell++)
	601	for(k = 1; k < user_q1; k++)
	602	user_tx_all[user_j(qr+1) + (k-1)*r+1+ell] = Base(0);
	603	++user_j;
	604	if( user_j == user_n )
	605	user_state = user_ret;
	606	break;
	607
	608	case UsravOp:
	609	// variable argument in an atomic operation sequence
	610	CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
	611	CPPAD_ASSERT_UNKNOWN( user_j < user_n );
	612	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
	613	user_tx_all[user_j(qr+1)+0] = taylor[arg[0]((J-1)r+1)+0];
	614	for(ell = 0; ell < r; ell++)
	615	{ for(k = 1; k < user_q1; k++)
	616	{ user_tx_all[user_j(qr+1) + (k-1)*r+1+ell] =
	617	taylor[arg[0]((J-1)r+1) + (k-1)*r+1+ell];
	618	}
	619	}
	620	++user_j;
	621	if( user_j == user_n )
	622	user_state = user_ret;
	623	break;
	624
	625	case UsrrpOp:
	626	// parameter result in an atomic operation sequence
	627	CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
	628	CPPAD_ASSERT_UNKNOWN( user_i < user_m );
	629	user_iy[user_i] = 0;
	630	user_ty_all[user_i(qr+1) + 0] = parameter[ arg[0]];
	631	for(ell = 0; ell < r; ell++)
	632	for(k = 1; k < user_q1; k++)
	633	user_ty_all[user_i(qr+1) + (k-1)*r+1+ell] = Base(0);
	634	user_i++;
	635	if( user_i == user_m )
	636	user_state = user_end;
	637	break;
	638
	639	case UsrrvOp:
	640	// variable result in an atomic operation sequence
	641	CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
	642	CPPAD_ASSERT_UNKNOWN( user_i < user_m );
	643	user_iy[user_i] = i_var;
	644	user_ty_all[user_i(qr+1)+0] = taylor[i_var((J-1)r+1)+0];
	645	for(ell = 0; ell < r; ell++)
	646	{ for(k = 1; k < user_q1; k++)
	647	{ user_ty_all[user_i(qr+1) + (k-1)*r+1+ell] =
	648	taylor[i_var((J-1)r+1) + (k-1)*r+1+ell];
	649	}
	650	}
	651	user_i++;
	652	if( user_i == user_m )
	653	user_state = user_end;
	654	break;
	655	// -------------------------------------------------
	656
	657	default:
	658	CPPAD_ASSERT_UNKNOWN(0);
	659	}
	660	# if CPPAD_FORWARD2SWEEP_TRACE
	661	if( user_state == user_trace )
	662	{ user_state = user_start;
	663	CPPAD_ASSERT_UNKNOWN( op == UserOp );
	664	CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
	665	for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
	666	{ size_t i_tmp = (i_op + i) - user_m;
	667	printOp(
	668	std::cout,
	669	play,
	670	i_tmp,
	671	user_iy[i],
	672	UsrrvOp,
	673	CPPAD_NULL
	674	);
	675	Base* Z_tmp = taylor + user_iy[i]((J-1) r + 1);
	676	{ Z_vec[0] = Z_tmp[0];
	677	for(ell = 0; ell < r; ell++)
	678	{ std::cout << std::endl << " ";
	679	for(size_t p_tmp = 1; p_tmp <= q; p_tmp++)
	680	Z_vec[p_tmp] = Z_tmp[(p_tmp-1)*r+ell+1];
	681	printOpResult(
	682	std::cout,
	683	q + 1,
	684	Z_vec.data(),
	685	0,
	686	(Base *) CPPAD_NULL
	687	);
	688	}
	689	}
	690	std::cout << std::endl;
	691	}
	692	}
	693	const addr_t* arg_tmp = arg;
	694	if( op == CSumOp )
	695	arg_tmp = arg - arg[-1] - 4;
	696	if( op == CSkipOp )
	697	arg_tmp = arg - arg[-1] - 7;
	698	if( op != UsrrvOp )
	699	{ printOp(
	700	std::cout,
	701	play,
	702	i_op,
	703	i_var,
	704	op,
	705	arg_tmp
	706	);
	707	Base* Z_tmp = CPPAD_NULL;
	708	if( op == UsravOp )
	709	Z_tmp = taylor + arg[0]((J-1) r + 1);
	710	else if( NumRes(op) > 0 )
	711	Z_tmp = taylor + i_var((J-1)r + 1);
	712	if( Z_tmp != CPPAD_NULL )
	713	{ Z_vec[0] = Z_tmp[0];
	714	for(ell = 0; ell < r; ell++)
	715	{ std::cout << std::endl << " ";
	716	for(size_t p_tmp = 1; p_tmp <= q; p_tmp++)
	717	Z_vec[p_tmp] = Z_tmp[ (p_tmp-1)*r + ell + 1];
	718	printOpResult(
	719	std::cout,
	720	q + 1,
	721	Z_vec.data(),
	722	0,
	723	(Base *) CPPAD_NULL
	724	);
	725	}
	726	}
	727	std::cout << std::endl;
	728	}
	729	}
	730	std::cout << std::endl;
	731	# else
	732	}
	733	# endif
	734	CPPAD_ASSERT_UNKNOWN( user_state == user_start );
	735	CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
	736
	737	return compareCount;
	738	}
	739
	740	// preprocessor symbols that are local to this file
	741	# undef CPPAD_FORWARD2SWEEP_TRACE
	742	# undef CPPAD_ATOMIC_CALL
	743
	744	} // END_CPPAD_NAMESPACE
	745	# endif

-774

~~cppad/local/forward_sweep.hpp~~ less more

0		/* $Id: forward_sweep.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
1		# ifndef CPPAD_FORWARD_SWEEP_INCLUDED
2		# define CPPAD_FORWARD_SWEEP_INCLUDED
3
4		/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
6
7		CppAD is distributed under multiple licenses. This distribution is under
8		the terms of the
9		GNU General Public License Version 3.
10
11		A copy of this license is included in the COPYING file of this distribution.
12		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13		-------------------------------------------------------------------------- */
14
15		namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16		/*!
17		\defgroup forward_sweep_hpp forward_sweep.hpp
18		\{
19		\file forward_sweep.hpp
20		Compute zero order forward mode Taylor coefficients.
21		*/
22
23		/*
24		\def CPPAD_ATOMIC_CALL
25		This avoids warnings when NDEBUG is defined and user_ok is not used.
26		If \c NDEBUG is defined, this resolves to
27		\code
28		user_atom->forward
29		\endcode
30		otherwise, it respolves to
31		\code
32		user_ok = user_atom->forward
33		\endcode
34		This maco is undefined at the end of this file to facillitate is
35		use with a different definition in other files.
36		*/
37		# ifdef NDEBUG
38		# define CPPAD_ATOMIC_CALL user_atom->forward
39		# else
40		# define CPPAD_ATOMIC_CALL user_ok = user_atom->forward
41		# endif
42
43		/*!
44		\def CPPAD_FORWARD_SWEEP_TRACE
45		This value is either zero or one.
46		Zero is the normal operational value.
47		If it is one, a trace of every forward_sweep computation is printed.
48		*/
49		# define CPPAD_FORWARD_SWEEP_TRACE 0
50
51		/*!
52		Compute arbitrary order forward mode Taylor coefficients.
53
54		\tparam Base
55		base type for the operator; i.e., this operation sequence was recorded
56		using AD< \a Base > and computations by this routine are done using type
57		\a Base.
58
59		\param s_out
60		Is the stream where output corresponding to \c PriOp operations will
61		be written.
62
63		\param print
64		If \a print is false,
65		suppress the output that is otherwise generated by the PriOp instructions.
66
67		\param q
68		is the lowest order of the Taylor coefficients
69		that are computed during this call.
70
71		\param p
72		is the highest order of the Taylor coefficients
73		that are computed during this call.
74
75		\param n
76		is the number of independent variables on the tape.
77
78		\param numvar
79		is the total number of variables on the tape.
80		This is also equal to the number of rows in the matrix \a Taylor; i.e.,
81		Rec->num_rec_var().
82
83		\param Rec
84		2DO: change this name from Rec to play (becuase it is a player
85		and not a recorder).
86		The information stored in \a Rec
87		is a recording of the operations corresponding to the function
88		\f[
89		F : {\bf R}^n \rightarrow {\bf R}^m
90		\f]
91		where \f$ n \f$ is the number of independent variables and
92		\f$ m \f$ is the number of dependent variables.
93		\n
94		\n
95		The object \a Rec is effectly constant.
96		There are two exceptions to this.
97		The first exception is that while palying back the tape
98		the object \a Rec holds information about the current location
99		with in the tape and this changes during palyback.
100		The second exception is the fact that the
101		zero order ( \a p = 0 ) versions of the VecAD operators LdpOp and LdvOp
102		modify the corresponding \a op_arg values returned by
103		\ref player::next_forward and \ref player::next_reverse; see the
104		\link load_op.hpp LdpOp and LdvOp \endlink operations.
105
106		\param J
107		Is the number of columns in the coefficient matrix \a Taylor.
108		This must be greater than or equal \a p + 1.
109
110		\param Taylor
111		\b Input: For j = 1 , ... , \a n, and for k = 0 , ... , \a p,
112		\a Taylor [ j * J + k ]
113		is the k-th order Taylor coefficient corresponding to
114		variable with index j on the tape
115		(independent variable with index (j-1) in the independent variable vector).
116		\n
117		\n
118		\b Output: For i = \a n + 1, ... , \a numvar - 1, and for k = 0 , ... , \a p,
119		\a Taylor [ i * J + k ]
120		is the k-th order Taylor coefficient for the variable with
121		index i on the tape.
122
123		\param cskip_op
124		Is a vector with size \c numvar,
125
126		\li <tt>q = 0</tt>
127		In this case,
128		the input value of the elements does not matter.
129		Upon return, if cskip_op[i] is true, the operator with index i
130		does not affect any of the dependent variable (given the value
131		of the independent variables).
132
133		\li <tt>q > 0</tt>
134		The vector is not modified and
135		if cskip_op[i] is true, the operator with index i
136		does not affect any of the dependent variable (given the value
137		of the independent variables).
138
139		\a return
140		If \a p is not zero, the return value is zero.
141		If \a p is zero,
142		the return value is equal to the number of ComOp operations
143		that have a different result from when the information in
144		\a Rec was recorded.
145		(Note that if NDEBUG is true, there are no ComOp operations
146		in Rec and hence this return value is always zero.)
147		*/
148
149		template <class Base>
150		size_t forward_sweep(
151		std::ostream& s_out,
152		const bool print,
153		const size_t q,
154		const size_t p,
155		const size_t n,
156		const size_t numvar,
157		player<Base> *Rec,
158		const size_t J,
159		Base *Taylor,
160		CppAD::vector<bool>& cskip_op
161		)
162		{ CPPAD_ASSERT_UNKNOWN( J >= p + 1 );
163		CPPAD_ASSERT_UNKNOWN( q <= p );
164
165		// op code for current instruction
166		OpCode op;
167
168		// index for current instruction
169		size_t i_op;
170
171		// next variables
172		size_t i_var;
173
174		// arg (not as a constant)
175		addr_t* non_const_arg = CPPAD_NULL;
176
177		// arg (as a constant)
178		const addr_t* arg = CPPAD_NULL;
179
180		// temporary indices
181		size_t i, ell;
182
183		// initialize the comparision operator (ComOp) counter
184		size_t compareCount = 0;
185
186		pod_vector<size_t> VectorInd; // address for each element
187		pod_vector<bool> VectorVar; // is element a variable
188		if( q == 0 )
189		{
190		// this includes order zero calculation, initialize vector indices
191		i = Rec->num_rec_vecad_ind();
192		if( i > 0 )
193		{ VectorInd.extend(i);
194		VectorVar.extend(i);
195		while(i--)
196		{ VectorInd[i] = Rec->GetVecInd(i);
197		VectorVar[i] = false;
198		}
199		}
200		// includes zero order, so initialize conditional skip flags
201		for(i = 0; i < Rec->num_rec_op(); i++)
202		cskip_op[i] = false;
203		}
204
205		// Work space used by UserOp. Note User assumes q = p.
206		const size_t user_p1 = p+1; // number of orders for this user calculation
207		vector<bool> user_vx; // empty vector
208		vector<bool> user_vy; // empty vector
209		vector<Base> user_tx; // argument vector Taylor coefficients
210		vector<Base> user_ty; // result vector Taylor coefficients
211		vector<size_t> user_iy; // variable indices for results vector
212		size_t user_index = 0; // indentifier for this atomic operation
213		size_t user_id = 0; // user identifier for this call to operator
214		size_t user_i = 0; // index in result vector
215		size_t user_j = 0; // index in argument vector
216		size_t user_m = 0; // size of result vector
217		size_t user_n = 0; // size of arugment vector
218		//
219		atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
220		# ifndef NDEBUG
221		bool user_ok = false; // atomic op return value
222		# endif
223		//
224		// next expected operator in a UserOp sequence
225		enum { user_start, user_arg, user_ret, user_end } user_state = user_start;
226
227		// check numvar argument
228		CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
229
230		// length of the parameter vector (used by CppAD assert macros)
231		const size_t num_par = Rec->num_rec_par();
232
233		// pointer to the beginning of the parameter vector
234		const Base* parameter = CPPAD_NULL;
235		if( num_par > 0 )
236		parameter = Rec->GetPar();
237
238		// length of the text vector (used by CppAD assert macros)
239		const size_t num_text = Rec->num_rec_text();
240
241		// pointer to the beginning of the text vector
242		const char* text = CPPAD_NULL;
243		if( num_text > 0 )
244		text = Rec->GetTxt(0);
245
246		// skip the BeginOp at the beginning of the recording
247		Rec->start_forward(op, arg, i_op, i_var);
248		CPPAD_ASSERT_UNKNOWN( op == BeginOp );
249		# if CPPAD_FORWARD_SWEEP_TRACE
250		std::cout << std::endl;
251		# endif
252		bool more_operators = true;
253		while(more_operators)
254		{
255		// this op
256		Rec->next_forward(op, arg, i_op, i_var);
257		CPPAD_ASSERT_UNKNOWN( (i_op > n) \| (op == InvOp) );
258		CPPAD_ASSERT_UNKNOWN( (i_op <= n) \| (op != InvOp) );
259
260		// check if we are skipping this operation
261		while( cskip_op[i_op] )
262		{ if( op == CSumOp )
263		{ // CSumOp has a variable number of arguments
264		Rec->forward_csum(op, arg, i_op, i_var);
265		}
266		Rec->next_forward(op, arg, i_op, i_var);
267		}
268
269		// action depends on the operator
270		switch( op )
271		{
272		case AbsOp:
273		forward_abs_op(q, p, i_var, arg[0], J, Taylor);
274		break;
275		// -------------------------------------------------
276
277		case AddvvOp:
278		forward_addvv_op(q, p, i_var, arg, parameter, J, Taylor);
279		break;
280		// -------------------------------------------------
281
282		case AddpvOp:
283		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
284		forward_addpv_op(q, p, i_var, arg, parameter, J, Taylor);
285		break;
286		// -------------------------------------------------
287
288		case AcosOp:
289		// sqrt(1 - x * x), acos(x)
290		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
291		forward_acos_op(q, p, i_var, arg[0], J, Taylor);
292		break;
293		// -------------------------------------------------
294
295		case AsinOp:
296		// sqrt(1 - x * x), asin(x)
297		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
298		forward_asin_op(q, p, i_var, arg[0], J, Taylor);
299		break;
300		// -------------------------------------------------
301
302		case AtanOp:
303		// 1 + x * x, atan(x)
304		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
305		forward_atan_op(q, p, i_var, arg[0], J, Taylor);
306		break;
307		// -------------------------------------------------
308
309		case CExpOp:
310		forward_cond_op(
311		q, p, i_var, arg, num_par, parameter, J, Taylor
312		);
313		break;
314		// ---------------------------------------------------
315
316		case ComOp:
317		if( q == 0 ) forward_comp_op_0(
318		compareCount, arg, num_par, parameter, J, Taylor
319		);
320		break;
321		// ---------------------------------------------------
322
323		case CosOp:
324		// sin(x), cos(x)
325		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
326		forward_cos_op(q, p, i_var, arg[0], J, Taylor);
327		break;
328		// ---------------------------------------------------
329
330		case CoshOp:
331		// sinh(x), cosh(x)
332		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
333		forward_cosh_op(q, p, i_var, arg[0], J, Taylor);
334		break;
335		// -------------------------------------------------
336
337		case CSkipOp:
338		// CSkipOp has a variable number of arguments and
339		// next_forward thinks it one has one argument.
340		// we must inform next_forward of this special case.
341		Rec->forward_cskip(op, arg, i_op, i_var);
342		if( q == 0 )
343		{ forward_cskip_op_0(
344		i_var, arg, num_par, parameter, J, Taylor, cskip_op
345		);
346		}
347		break;
348		// -------------------------------------------------
349
350		case CSumOp:
351		// CSumOp has a variable number of arguments and
352		// next_forward thinks it one has one argument.
353		// we must inform next_forward of this special case.
354		Rec->forward_csum(op, arg, i_op, i_var);
355		forward_csum_op(
356		q, p, i_var, arg, num_par, parameter, J, Taylor
357		);
358		break;
359		// -------------------------------------------------
360
361		case DisOp:
362		i = q;
363		if( i == 0 )
364		{ forward_dis_op_0(i_var, arg, J, Taylor);
365		i++;
366		}
367		while(i <= p)
368		{ Taylor[ i_var * J + i] = Base(0);
369		i++;
370		}
371		break;
372		// -------------------------------------------------
373
374		case DivvvOp:
375		forward_divvv_op(q, p, i_var, arg, parameter, J, Taylor);
376		break;
377		// -------------------------------------------------
378
379		case DivpvOp:
380		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
381		forward_divpv_op(q, p, i_var, arg, parameter, J, Taylor);
382		break;
383		// -------------------------------------------------
384
385		case DivvpOp:
386		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
387		forward_divvp_op(q, p, i_var, arg, parameter, J, Taylor);
388		break;
389		// -------------------------------------------------
390
391		case EndOp:
392		CPPAD_ASSERT_NARG_NRES(op, 0, 0);
393		more_operators = false;
394		break;
395		// -------------------------------------------------
396
397		case ExpOp:
398		forward_exp_op(q, p, i_var, arg[0], J, Taylor);
399		break;
400		// -------------------------------------------------
401
402		case InvOp:
403		CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
404		break;
405		// -------------------------------------------------
406
407		case LdpOp:
408		if( q == 0 )
409		{ non_const_arg = Rec->forward_non_const_arg();
410		forward_load_p_op_0(
411		i_var,
412		non_const_arg,
413		num_par,
414		parameter,
415		J,
416		Taylor,
417		Rec->num_rec_vecad_ind(),
418		VectorVar.data(),
419		VectorInd.data()
420		);
421		if( q < p )
422		forward_load_op( op, q+1, p, i_var, arg, J, Taylor);
423		}
424		else
425		{ forward_load_op( op, q, p, i_var, arg, J, Taylor);
426		}
427		break;
428		// -------------------------------------------------
429
430		case LdvOp:
431		if( q == 0 )
432		{ non_const_arg = Rec->forward_non_const_arg();
433		forward_load_v_op_0(
434		i_var,
435		non_const_arg,
436		num_par,
437		parameter,
438		J,
439		Taylor,
440		Rec->num_rec_vecad_ind(),
441		VectorVar.data(),
442		VectorInd.data()
443		);
444		if( q < p )
445		forward_load_op( op, q+1, p, i_var, arg, J, Taylor);
446		}
447		else
448		{ forward_load_op( op, q, p, i_var, arg, J, Taylor);
449		}
450		break;
451		// -------------------------------------------------
452
453		case LogOp:
454		forward_log_op(q, p, i_var, arg[0], J, Taylor);
455		break;
456		// -------------------------------------------------
457
458		case MulvvOp:
459		forward_mulvv_op(q, p, i_var, arg, parameter, J, Taylor);
460		break;
461		// -------------------------------------------------
462
463		case MulpvOp:
464		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
465		forward_mulpv_op(q, p, i_var, arg, parameter, J, Taylor);
466		break;
467		// -------------------------------------------------
468
469		case ParOp:
470		i = q;
471		if( i == 0 )
472		{ forward_par_op_0(
473		i_var, arg, num_par, parameter, J, Taylor
474		);
475		i++;
476		}
477		while(i <= p)
478		{ Taylor[ i_var * J + i] = Base(0);
479		i++;
480		}
481		break;
482		// -------------------------------------------------
483
484		case PowvpOp:
485		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
486		forward_powvp_op(q, p, i_var, arg, parameter, J, Taylor);
487		break;
488		// -------------------------------------------------
489
490		case PowpvOp:
491		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
492		forward_powpv_op(q, p, i_var, arg, parameter, J, Taylor);
493		break;
494		// -------------------------------------------------
495
496		case PowvvOp:
497		forward_powvv_op(q, p, i_var, arg, parameter, J, Taylor);
498		break;
499		// -------------------------------------------------
500
501		case PriOp:
502		if( (q == 0) & print ) forward_pri_0(s_out,
503		i_var, arg, num_text, text, num_par, parameter, J, Taylor
504		);
505		break;
506		// -------------------------------------------------
507
508		case SignOp:
509		// sign(x)
510		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
511		forward_sign_op(q, p, i_var, arg[0], J, Taylor);
512		break;
513		// -------------------------------------------------
514
515		case SinOp:
516		// cos(x), sin(x)
517		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
518		forward_sin_op(q, p, i_var, arg[0], J, Taylor);
519		break;
520		// -------------------------------------------------
521
522		case SinhOp:
523		// cosh(x), sinh(x)
524		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
525		forward_sinh_op(q, p, i_var, arg[0], J, Taylor);
526		break;
527		// -------------------------------------------------
528
529		case SqrtOp:
530		forward_sqrt_op(q, p, i_var, arg[0], J, Taylor);
531		break;
532		// -------------------------------------------------
533
534		case StppOp:
535		if( q == 0 )
536		{ forward_store_pp_op_0(
537		i_var,
538		arg,
539		num_par,
540		J,
541		Taylor,
542		Rec->num_rec_vecad_ind(),
543		VectorVar.data(),
544		VectorInd.data()
545		);
546		}
547		break;
548		// -------------------------------------------------
549
550		case StpvOp:
551		if( q == 0 )
552		{ forward_store_pv_op_0(
553		i_var,
554		arg,
555		num_par,
556		J,
557		Taylor,
558		Rec->num_rec_vecad_ind(),
559		VectorVar.data(),
560		VectorInd.data()
561		);
562		}
563		break;
564		// -------------------------------------------------
565
566		case StvpOp:
567		if( q == 0 )
568		{ forward_store_vp_op_0(
569		i_var,
570		arg,
571		num_par,
572		J,
573		Taylor,
574		Rec->num_rec_vecad_ind(),
575		VectorVar.data(),
576		VectorInd.data()
577		);
578		}
579		break;
580		// -------------------------------------------------
581
582		case StvvOp:
583		if( q == 0 )
584		{ forward_store_vv_op_0(
585		i_var,
586		arg,
587		num_par,
588		J,
589		Taylor,
590		Rec->num_rec_vecad_ind(),
591		VectorVar.data(),
592		VectorInd.data()
593		);
594		}
595		break;
596		// -------------------------------------------------
597
598		case SubvvOp:
599		forward_subvv_op(q, p, i_var, arg, parameter, J, Taylor);
600		break;
601		// -------------------------------------------------
602
603		case SubpvOp:
604		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
605		forward_subpv_op(q, p, i_var, arg, parameter, J, Taylor);
606		break;
607		// -------------------------------------------------
608
609		case SubvpOp:
610		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
611		forward_subvp_op(q, p, i_var, arg, parameter, J, Taylor);
612		break;
613		// -------------------------------------------------
614
615		case TanOp:
616		// tan(x)^2, tan(x)
617		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
618		forward_tan_op(q, p, i_var, arg[0], J, Taylor);
619		break;
620		// -------------------------------------------------
621
622		case TanhOp:
623		// tanh(x)^2, tanh(x)
624		CPPAD_ASSERT_UNKNOWN( i_var < numvar );
625		forward_tanh_op(q, p, i_var, arg[0], J, Taylor);
626		break;
627		// -------------------------------------------------
628
629		case UserOp:
630		// start or end an atomic operation sequence
631		CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
632		CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
633		if( user_state == user_start )
634		{ user_index = arg[0];
635		user_id = arg[1];
636		user_n = arg[2];
637		user_m = arg[3];
638		user_atom = atomic_base<Base>::class_object(user_index);
639		# ifndef NDEBUG
640		if( user_atom == CPPAD_NULL )
641		{ std::string msg =
642		atomic_base<Base>::class_name(user_index)
643		+ ": atomic_base function has been deleted";
644		CPPAD_ASSERT_KNOWN(false, msg.c_str() );
645		}
646		# endif
647		if(user_tx.size() != user_n * user_p1)
648		user_tx.resize(user_n * user_p1);
649		if(user_ty.size() != user_m * user_p1)
650		user_ty.resize(user_m * user_p1);
651		if(user_iy.size() != user_m)
652		user_iy.resize(user_m);
653		user_j = 0;
654		user_i = 0;
655		user_state = user_arg;
656		}
657		else
658		{ CPPAD_ASSERT_UNKNOWN( user_state == user_end );
659		CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
660		CPPAD_ASSERT_UNKNOWN( user_id == size_t(arg[1]) );
661		CPPAD_ASSERT_UNKNOWN( user_n == size_t(arg[2]) );
662		CPPAD_ASSERT_UNKNOWN( user_m == size_t(arg[3]) );
663
664		// call users function for this operation
665		user_atom->set_id(user_id);
666		CPPAD_ATOMIC_CALL(
667		q, p, user_vx, user_vy, user_tx, user_ty
668		);
669		# ifndef NDEBUG
670		if( ! user_ok )
671		{ std::string msg =
672		atomic_base<Base>::class_name(user_index)
673		+ ": atomic_base.forward: returned false";
674		CPPAD_ASSERT_KNOWN(false, msg.c_str() );
675		}
676		# endif
677		for(i = 0; i < user_m; i++)
678		if( user_iy[i] > 0 )
679		for(ell = q; ell <= p; ell++)
680		Taylor[ user_iy[i] * J + ell ] =
681		user_ty[ i * user_p1 + ell ];
682
683		user_state = user_start;
684		}
685		break;
686
687		case UsrapOp:
688		// parameter argument in an atomic operation sequence
689		CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
690		CPPAD_ASSERT_UNKNOWN( user_j < user_n );
691		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
692		user_tx[user_j * user_p1 + 0] = parameter[ arg[0]];
693		for(ell = 1; ell < user_p1; ell++)
694		user_tx[user_j * user_p1 + ell] = Base(0);
695		++user_j;
696		if( user_j == user_n )
697		user_state = user_ret;
698		break;
699
700		case UsravOp:
701		// variable argument in an atomic operation sequence
702		CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
703		CPPAD_ASSERT_UNKNOWN( user_j < user_n );
704		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
705		for(ell = 0; ell < user_p1; ell++)
706		user_tx[user_j * user_p1 + ell] = Taylor[ arg[0] * J + ell];
707		++user_j;
708		if( user_j == user_n )
709		user_state = user_ret;
710		break;
711
712		case UsrrpOp:
713		// parameter result in an atomic operation sequence
714		CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
715		CPPAD_ASSERT_UNKNOWN( user_i < user_m );
716		user_iy[user_i] = 0;
717		user_ty[user_i * user_p1 + 0] = parameter[ arg[0]];
718		for(ell = 1; ell < q; ell++)
719		user_ty[user_i * user_p1 + ell] = Base(0);
720		user_i++;
721		if( user_i == user_m )
722		user_state = user_end;
723		break;
724
725		case UsrrvOp:
726		// variable result in an atomic operation sequence
727		CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
728		CPPAD_ASSERT_UNKNOWN( user_i < user_m );
729		user_iy[user_i] = i_var;
730		for(ell = 0; ell < q; ell++)
731		user_ty[user_i * user_p1 + ell] = Taylor[ i_var * J + ell];
732		user_i++;
733		if( user_i == user_m )
734		user_state = user_end;
735		break;
736		// -------------------------------------------------
737
738		default:
739		CPPAD_ASSERT_UNKNOWN(0);
740		}
741		# if CPPAD_FORWARD_SWEEP_TRACE
742		size_t i_tmp = i_var;
743		Base* Z_tmp = Taylor + J * i_var;
744		printOp(
745		std::cout,
746		Rec,
747		i_op,
748		i_tmp,
749		op,
750		arg,
751		p + 1,
752		Z_tmp,
753		0,
754		(Base *) CPPAD_NULL
755		);
756		}
757		std::cout << std::endl;
758		# else
759		}
760		# endif
761		CPPAD_ASSERT_UNKNOWN( user_state == user_start );
762		CPPAD_ASSERT_UNKNOWN( i_var + 1 == Rec->num_rec_var() );
763
764		return compareCount;
765		}
766
767		// preprocessor symbols that are local to this file
768		# undef CPPAD_FORWARD_SWEEP_TRACE
769		# undef CPPAD_ATOMIC_CALL
770
771		/! \} /
772		} // END_CPPAD_NAMESPACE
773		# endif

+57

-66

cppad/local/fun_construct.hpp less more

0		/* $Id: fun_construct.hpp 3098 2014-02-18 03:19:39Z bradbell $ */
	0	/* $Id: fun_construct.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_FUN_CONSTRUCT_INCLUDED
2	2	# define CPPAD_FUN_CONSTRUCT_INCLUDED
3	3

18	18	num
19	19	Jac
20	20	bool
21		taylor_
	21	taylor
22	22	var
23	23	ADvector
24	24	const

70	70	and
71	71	$codei%
72	72	ADFun<%Base%> %f%(%x%, %y%)
73		%$$.
	73	%$$
74	74
75	75	$head y$$
76	76	If the argument $icode y$$ is present, it has prototype

106	106	$index sequence, ADFun constructor$$
107	107	$index ADFun, sequence constructor$$
108	108	$index constructor, ADFun sequence$$
109		The default constructor
110	109	The sequence constructor
111	110	$codei%
112	111	ADFun<%Base%> %f%(%x%, %y%)

118	117	Independent(%x%)
119	118	%$$
120	119	and stores the corresponding operation sequence in the object $icode f$$.
121		It then stores the first order taylor_ coefficients
	120	It then stores the zero order Taylor coefficients
122	121	(corresponding to the value of $icode x$$) in $icode f$$.
123	122	This is equivalent to the following steps using the default constructor:
124	123

134	133	%$$
135	134	(see $cref Dependent$$).
136	135	$lnext
137		Calculating the first order taylor_ coefficients for all
	136	Calculate the zero order Taylor coefficients for all
138	137	the variables in the operation sequence using
139	138	$codei%
140	139	%f%.Forward(%p%, %x_p%)

164	163	The $codei%ADFun<%Base%>%$$ assignment operation
165	164	$codei%
166	165	%g% = %f%
167		%$$.
	166	%$$
168	167	makes a copy of the operation sequence currently stored in $icode f$$
169	168	in the object $icode g$$.
170	169	The object $icode f$$ is not affected by this operation and
171	170	can be $code const$$.
172		Any operation sequence or other information in $icode g$$ is lost.
	171	All of information (state) stored in $icode f$$ is copied to $icode g$$
	172	and any information originally in $icode g$$ is lost.
173	173
174	174	$subhead Taylor Coefficients$$
175	175	The Taylor coefficient information currently stored in $icode f$$

177	177	copied to $icode g$$.
178	178	Hence, directly after this operation
179	179	$codei%
180		%g%.size_taylor() == %f%.size_taylor()
	180	%g%.size_order() == %f%.size_order()
181	181	%$$
182	182
183	183	$subhead Sparsity Patterns$$

238	238
239	239	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
240	240	/*!
241		\defgroup fun_construct_hpp fun_construct.hpp
242		\{
243	241	\file fun_construct.hpp
244	242	ADFun function constructors and assignment operator.
245	243	*/

263	261	template <typename Base>
264	262	ADFun<Base>::ADFun(void) :
265	263	check_for_nan_(true) ,
266		total_num_var_(0)
	264	num_var_tape_(0)
267	265	{ }
268	266
269	267	/*!

289	287	void ADFun<Base>::operator=(const ADFun<Base>& f)
290	288	{ size_t m = f.Range();
291	289	size_t n = f.Domain();
292
293		// go through member variables in order
294		// (see ad_fun.hpp for meaning of each variable)
295		check_for_nan_ = true;
296		compare_change_ = 0;
297
298		taylor_.erase();
299		taylor_per_var_ = 0;
300		taylor_col_dim_ = 0;
301
302		total_num_var_ = f.total_num_var_;
	290	size_t i;
	291
	292	// go through member variables in ad_fun.hpp order
	293	//
	294	// size_t objects
	295	check_for_nan_ = f.check_for_nan_;
	296	compare_change_ = f.compare_change_;
	297	num_order_taylor_ = f.num_order_taylor_;
	298	cap_order_taylor_ = f.cap_order_taylor_;
	299	num_direction_taylor_ = f.num_direction_taylor_;
	300	num_var_tape_ = f.num_var_tape_;
	301	//
	302	// CppAD::vector objects
303	303	ind_taddr_.resize(n);
304	304	ind_taddr_ = f.ind_taddr_;
305	305	dep_taddr_.resize(m);
306	306	dep_taddr_ = f.dep_taddr_;
307	307	dep_parameter_.resize(m);
308	308	dep_parameter_ = f.dep_parameter_;
	309	//
	310	// pod_vector objects
	311	taylor_ = f.taylor_;
	312	cskip_op_ = f.cskip_op_;
	313	load_op_ = f.load_op_;
	314	//
	315	// player
309	316	play_ = f.play_;
	317	//
	318	// sparse_pack
310	319	for_jac_sparse_pack_.resize(0, 0);
311		for_jac_sparse_set_.resize(0, 0);
312
313		// allocate and copy the Taylor coefficients
314		taylor_per_var_ = f.taylor_per_var_;
315		taylor_col_dim_ = f.taylor_col_dim_;
316		size_t length = total_num_var_ * taylor_col_dim_;
317		if( length > 0 )
318		taylor_.extend(length);
319		size_t i, j;
320		for(i = 0; i < total_num_var_; i++)
321		{ for(j = 0; j < taylor_per_var_; j++)
322		{ taylor_[ i * taylor_col_dim_ + j ] =
323		f.taylor_[ i * taylor_col_dim_ + j ];
324		}
325		}
326
327		// allocate and copy the conditional skip information
328		cskip_op_.clear();
329		cskip_op_ = f.cskip_op_;
330
331		// allocate and copy the forward sparsity information
332	320	size_t n_set = f.for_jac_sparse_pack_.n_set();
333	321	size_t end = f.for_jac_sparse_pack_.end();
334	322	if( n_set > 0 )
335		{ CPPAD_ASSERT_UNKNOWN( n_set == total_num_var_ );
	323	{ CPPAD_ASSERT_UNKNOWN( n_set == num_var_tape_ );
336	324	CPPAD_ASSERT_UNKNOWN( f.for_jac_sparse_set_.n_set() == 0 );
337	325	for_jac_sparse_pack_.resize(n_set, end);
338		for(i = 0; i < total_num_var_ ; i++)
	326	for(i = 0; i < num_var_tape_ ; i++)
339	327	{ for_jac_sparse_pack_.assignment(
340	328	i ,
341	329	i ,

343	331	);
344	332	}
345	333	}
	334	//
	335	// sparse_set
	336	for_jac_sparse_set_.resize(0, 0);
346	337	n_set = f.for_jac_sparse_set_.n_set();
347	338	end = f.for_jac_sparse_set_.end();
348	339	if( n_set > 0 )
349		{ CPPAD_ASSERT_UNKNOWN( n_set == total_num_var_ );
	340	{ CPPAD_ASSERT_UNKNOWN( n_set == num_var_tape_ );
350	341	CPPAD_ASSERT_UNKNOWN( f.for_jac_sparse_pack_.n_set() == 0 );
351	342	for_jac_sparse_set_.resize(n_set, end);
352		for(i = 0; i < total_num_var_; i++)
	343	for(i = 0; i < num_var_tape_; i++)
353	344	{ for_jac_sparse_set_.assignment(
354	345	i ,
355	346	i ,

357	348	);
358	349	}
359	350	}
360
361	351	}
362	352
363	353	/*!

396	386	*/
397	387	template <typename Base>
398	388	template <typename VectorAD>
399		ADFun<Base>::ADFun(const VectorAD &x, const VectorAD &y) :
400		check_for_nan_(true) ,
401		total_num_var_(0)
	389	ADFun<Base>::ADFun(const VectorAD &x, const VectorAD &y)
402	390	{
403	391	CPPAD_ASSERT_KNOWN(
404	392	x.size() > 0,

438	426	// stop the tape and store the operation sequence
439	427	Dependent(tape, y);
440	428
	429	// ad_fun.hpp member values not set by dependent
	430	check_for_nan_ = true;
	431
441	432	// allocate memory for one zero order taylor_ coefficient
442		taylor_per_var_ = 1;
443		taylor_col_dim_ = 1;
444		taylor_.extend(total_num_var_);
	433	CPPAD_ASSERT_UNKNOWN( num_order_taylor_ == 0 );
	434	CPPAD_ASSERT_UNKNOWN( num_direction_taylor_ == 0 );
	435	size_t c = 1;
	436	size_t r = 1;
	437	capacity_order(c, r);
	438	CPPAD_ASSERT_UNKNOWN( cap_order_taylor_ == c );
	439	CPPAD_ASSERT_UNKNOWN( num_direction_taylor_ == r );
445	440
446	441	// set zero order coefficients corresponding to indpendent variables
447	442	CPPAD_ASSERT_UNKNOWN( n == ind_taddr_.size() );

452	447	}
453	448
454	449	// use independent variable values to fill in values for others
455		# if CPPAD_USE_FORWARD0SWEEP
	450	CPPAD_ASSERT_UNKNOWN( cskip_op_.size() == play_.num_op_rec() );
	451	CPPAD_ASSERT_UNKNOWN( load_op_.size() == play_.num_load_op_rec() );
456	452	compare_change_ = forward0sweep(std::cout, false,
457		n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
458		cskip_op_
	453	n, num_var_tape_, &play_, cap_order_taylor_, taylor_.data(),
	454	cskip_op_.data(), load_op_
459	455	);
460		# else
461		size_t p = 0;
462		compare_change_ = forward_sweep(std::cout, false,
463		p, p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
464		cskip_op_
465		);
466		# endif
467	456	CPPAD_ASSERT_UNKNOWN( compare_change_ == 0 );
	457
	458	// now set the number of orders stored
	459	num_order_taylor_ = 1;
468	460
469	461	# ifndef NDEBUG
470	462	// on MS Visual Studio 2012, CppAD required in front of isnan ?

490	482	# endif
491	483	}
492	484
493		/! \} /
494	485	} // END_CPPAD_NAMESPACE
495	486	# endif

-4

cppad/local/fun_eval.hpp less more

0		/* $Id: fun_eval.hpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: fun_eval.hpp 3174 2014-03-10 01:26:06Z bradbell $ */
1	1	# ifndef CPPAD_FUN_EVAL_INCLUDED
2	2	# define CPPAD_FUN_EVAL_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

23	23	$section Evaluate ADFun Functions, Derivatives, and Sparsity Patterns$$
24	24
25	25	$childtable%
26		cppad/local/forward.hpp%
27		cppad/local/reverse.hpp%
	26	omh/forward/forward.omh%
	27	omh/reverse/reverse.omh%
28	28	cppad/local/sparse.hpp
29	29	%$$
30	30

+11

-8

cppad/local/hash_code.hpp less more

0		/* $Id: hash_code.hpp 3011 2013-11-27 11:32:36Z bradbell $ */
	0	/* $Id: hash_code.hpp 3359 2014-09-26 00:12:56Z bradbell $ */
1	1	# ifndef CPPAD_HASH_CODE_INCLUDED
2	2	# define CPPAD_HASH_CODE_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup hash_code_hpp hash_code.hpp
18		\{
19	17	\file hash_code.hpp
20	18	CppAD hashing utility.
21	19	*/

80	78	hash coded and zero is returned:
81	79
82	80	\li unary operators:
83		AbsOp, AcosOp, AsinOp, AtanOp, CosOp, CoshOp, DisOp,
	81	AbsOp, AcosOp, AsinOp, AtanOp, CosOp, CoshOp
84	82	ExpOp, LogOp, SinOp, SinhOp, SqrtOp, TanOp, TanhOp
85	83
86	84	\li binary operators where first argument is a parameter:

89	87	\li binary operators where second argument is a parameter:
90	88	DivvpOp, PowvpOp, SubvpOp
91	89
92		\li binary operators where both arguments are parameters:
	90	\li binary operators where first is an index and second is a variable:
	91	DisOp
	92
	93	\li binary operators where both arguments are variables:
93	94	AddvvOp, DivvvOp, MulvvOp, PowvvOp, SubvvOp
94	95
95	96	\param arg

176	177	code += v[i];
177	178	break;
178	179
	180	// Binary operator where first argument is an index and
	181	// second is a variable (same as both variables).
	182	case DisOp:
	183
179	184	// Binary operators where both arguments are variables
180	185	case AddvvOp:
181	186	case DivvvOp:

211	216	case AtanOp:
212	217	case CosOp:
213	218	case CoshOp:
214		case DisOp:
215	219	case ExpOp:
216	220	case LogOp:
217	221	case SignOp:

234	238	return code % CPPAD_HASH_TABLE_SIZE;
235	239	}
236	240
237		/! \} /
238	241	} // END_CPPAD_NAMESPACE
239	242	# endif

-5

cppad/local/identical.hpp less more

0		/* $Id: identical.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: identical.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_IDENTICAL_INCLUDED
2	2	# define CPPAD_IDENTICAL_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

16	16
17	17	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
18	18	/*!
19		\defgroup identical_hpp identical.hpp
20		\{
21	19	\file identical.hpp
22	20	Check if certain properties is true for any possible AD tape play back.
23	21	*/

102	100	}
103	101	// ==========================================================================
104	102
105		/! \} /
106	103	} // END_CPPAD_NAMESPACE
107	104	# endif

-3

cppad/local/independent.hpp less more

0		/* $Id: independent.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: independent.hpp 3146 2014-03-03 12:33:40Z bradbell $ */
1	1	# ifndef CPPAD_INDEPENDENT_INCLUDED
2	2	# define CPPAD_INDEPENDENT_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

130	130	n > 0,
131	131	"Indepdendent: the argument vector x has zero size"
132	132	);
133		CPPAD_ASSERT_UNKNOWN( Rec_.num_rec_var() == 0 );
	133	CPPAD_ASSERT_UNKNOWN( Rec_.num_var_rec() == 0 );
134	134
135	135	// mark the beginning of the tape and skip the first variable index
136	136	// (zero) because parameters use taddr zero

+25

-25

cppad/local/jacobian.hpp less more

0		/* $Id: jacobian.hpp 2683 2012-12-30 18:17:03Z bradbell $ */
	0	/* $Id: jacobian.hpp 3307 2014-05-25 13:17:40Z bradbell $ */
1	1	# ifndef CPPAD_JACOBIAN_INCLUDED
2	2	# define CPPAD_JACOBIAN_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

119	119	{ size_t i;
120	120	size_t j;
121	121
122		size_t m = f.Domain();
123		size_t n = f.Range();
	122	size_t n = f.Domain();
	123	size_t m = f.Range();
124	124
125	125	// check Vector is Simple Vector class with Base type elements
126	126	CheckSimpleVector<Base, Vector>();

129	129	CPPAD_ASSERT_UNKNOWN( size_t(jac.size()) == f.Range() * f.Domain() );
130	130
131	131	// argument and result for forward mode calculations
132		Vector u(m);
133		Vector v(n);
	132	Vector u(n);
	133	Vector v(m);
134	134
135	135	// initialize all the components
136		for(j = 0; j < m; j++)
	136	for(j = 0; j < n; j++)
137	137	u[j] = Base(0);
138	138
139	139	// loop through the different coordinate directions
140		for(j = 0; j < m; j++)
	140	for(j = 0; j < n; j++)
141	141	{ // set u to the j-th coordinate direction
142	142	u[j] = Base(1);
143	143

148	148	u[j] = Base(0);
149	149
150	150	// return the result
151		for(i = 0; i < n; i++)
152		jac[ i * m + j ] = v[i];
	151	for(i = 0; i < m; i++)
	152	jac[ i * n + j ] = v[i];
153	153	}
154	154	}
155	155	template <typename Base, typename Vector>

157	157	{ size_t i;
158	158	size_t j;
159	159
160		size_t m = f.Domain();
161		size_t n = f.Range();
	160	size_t n = f.Domain();
	161	size_t m = f.Range();
162	162
163	163	CPPAD_ASSERT_UNKNOWN( size_t(x.size()) == f.Domain() );
164	164	CPPAD_ASSERT_UNKNOWN( size_t(jac.size()) == f.Range() * f.Domain() );
165	165
166	166	// argument and result for reverse mode calculations
167		Vector u(m);
168		Vector v(n);
	167	Vector u(n);
	168	Vector v(m);
169	169
170	170	// initialize all the components
171		for(i = 0; i < n; i++)
	171	for(i = 0; i < m; i++)
172	172	v[i] = Base(0);
173	173
174	174	// loop through the different coordinate directions
175		for(i = 0; i < n; i++)
	175	for(i = 0; i < m; i++)
176	176	{ if( f.Parameter(i) )
177	177	{ // return zero for this component of f
178		for(j = 0; j < m; j++)
179		jac[ i * m + j ] = Base(0);
	178	for(j = 0; j < n; j++)
	179	jac[ i * n + j ] = Base(0);
180	180	}
181	181	else
182	182	{

190	190	v[i] = Base(0);
191	191
192	192	// return the result
193		for(j = 0; j < m; j++)
194		jac[ i * m + j ] = u[j];
	193	for(j = 0; j < n; j++)
	194	jac[ i * n + j ] = u[j];
195	195	}
196	196	}
197	197	}

200	200	template <typename Vector>
201	201	Vector ADFun<Base>::Jacobian(const Vector &x)
202	202	{ size_t i;
203		size_t m = Domain();
204		size_t n = Range();
	203	size_t n = Domain();
	204	size_t m = Range();
205	205
206	206	CPPAD_ASSERT_KNOWN(
207		size_t(x.size()) == m,
	207	size_t(x.size()) == n,
208	208	"Jacobian: length of x not equal domain dimension for F"
209	209	);
210	210

212	212	Forward(0, x);
213	213
214	214	// work factor for forward mode
215		size_t workForward = m;
	215	size_t workForward = n;
216	216
217	217	// work factor for reverse mode
218	218	size_t workReverse = 0;
219		for(i = 0; i < n; i++)
	219	for(i = 0; i < m; i++)
220	220	{ if( ! Parameter(i) )
221	221	++workReverse;
222	222	}

-5

cppad/local/limits.hpp less more

0		/* $Id: limits.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: limits.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_LIMITS_INCLUDED
2	2	# define CPPAD_LIMITS_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

121	121
122	122	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
123	123	/*!
124		\defgroup limits_hpp limits.hpp
125		\{
126	124	\file limits.hpp
127	125	File that defines CppAD numeric_limits for AD types
128	126	*/

172	170	{ return AD<Base>( numeric_limits<Base>::max() ); }
173	171	};
174	172
175		/! \} /
176	173	} // END_CPPAD_NAMESPACE
177	174	# endif

+272

-246

cppad/local/load_op.hpp less more

0		/* $Id: load_op.hpp 2920 2013-10-11 12:40:52Z bradbell $ */
	0	/* $Id: load_op.hpp 3322 2014-09-12 10:29:34Z bradbell $ */
1	1	# ifndef CPPAD_LOAD_OP_INCLUDED
2	2	# define CPPAD_LOAD_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup load_op_hpp load_op.hpp
19		\{
20	18	\file load_op.hpp
21	19	Setting a variable so that it corresponds to current value of a VecAD element.
22	20	*/

27	25
28	26	The C++ source code corresponding to this operation is
29	27	\verbatim
30		z = y[x]
31		\endverbatim
32		where y is a VecAD<Base> vector and x is an AD<Base> index.
33		We define the index corresponding to y[x] by
34		\verbatim
35		i_y_x = combined[ arg[0] + i_vec ]
36		\endverbatim
37		where i_vec is defined under the heading \a arg[1] below:
	28	z = v[x]
	29	\endverbatim
	30	where v is a VecAD<Base> vector and x is an AD<Base> index.
	31	We define the index corresponding to v[x] by
	32	\verbatim
	33	i_v_x = index_by_ind[ arg[0] + i_vec ]
	34	\endverbatim
	35	where i_vec is defined under the heading arg[1] below:
38	36
39	37	\tparam Base
40	38	base type for the operator; i.e., this operation was recorded
41		using AD< \a Base > and computations by this routine are done using type
42		\a Base.
	39	using AD<Base> and computations by this routine are done using type Base.
	40
	41	\param play
	42	is the tape that this operation appears in.
	43	This is for error detection and not used when NDEBUG is defined.
43	44
44	45	\param i_z
45	46	is the AD variable index corresponding to the variable z.
46	47
47	48	\param arg
48	49	\n
49		\a arg[0]
	50	arg[0]
50	51	is the offset of this VecAD vector relative to the beginning
51		of the \a combined VecAD array.
	52	of the isvar_by_ind and index)_by_ind arrays.
52	53	\n
53	54	\n
54		\a arg[1]
55		\n
56		If this is the LdpOp operation
57		(the index x is a parameter), i_vec is defined by
	55	arg[1]
	56	\n
	57	If this is the LdpOp operation (if x is a parameter),
	58	i_vec is defined by
58	59	\verbatim
59	60	i_vec = arg[1]
60	61	\endverbatim
61		If this is the LdvOp operation
62		(the index x is a variable), i_vec is defined by
63		\verbatim
64		i_vec = floor( taylor[ arg[1] * nc_taylor + 0 ] )
	62	If this is the LdvOp operation (if x is a variable),
	63	i_vec is defined by
	64	\verbatim
	65	i_vec = floor( taylor[ arg[1] * cap_order + 0 ] )
65	66	\endverbatim
66	67	where floor(c) is the greatest integer less that or equal c.
67	68	\n
68		\a arg[2]
69		\b Input: The input value of \a arg[2] does not matter.
70		\n
71		\b Output:
72		If y[x] is a parameter, \a arg[2] is set to zero
73		(which is not a valid variable index).
74		If y[x] is a variable,
75		\a arg[2] is set to the variable index corresponding to y[x]; i.e. i_y_x.
76
77		\param num_par
78		is the number of parameters in \a parameter.
	69	\n
	70	arg[2]
	71	Is the index of this vecad load instruction in the
	72	var_by_load_op array.
79	73
80	74	\param parameter
81		If y[x] is a parameter, \a parameter [ i_y_x ] is its value.
82
83		\param nc_taylor
	75	If v[x] is a parameter, <code>parameter[ i_v_x ]</code> is its value.
	76	This vector has size play->num_par_rec().
	77
	78	\param cap_order
84	79	number of columns in the matrix containing the Taylor coefficients.
85	80
86	81	\param taylor
87		\b Input: in LdvOp case, \a taylor[ arg[1] * nc_taylor + 0 ]
88		is used to compute the index in the definition of i_vec above
89		\n
90		\b Input: if y[x] is a variable, \a taylor[ i_y_x * nc_taylor + 0 ]
91		is the zero order Taylor coefficient for y[x].
92		\n
93		\b Output: \a taylor[ i_z * nc_taylor + 0 ]
94		is the zero order Taylor coefficient for the variable z.
95
96		\param nc_combined
97		is the total number of elements in the combined VecAD array.
98
99		\param variable
100		If \a variable [ \a arg[0] + i_vec ] is true,
101		y[x] is a variable. Otherwise it is a parameter.
102
103		\param combined
104		\b Input: \a combined[ \a arg[0] - 1 ]
105		is the number of elements in the VecAD vector containing this element.
106		\n
107		\b Input: \a combined[ \a arg[0] + i_vec ]
108		if y[x] is a variable, i_y_x
109		is its index in the Taylor coefficient array \a taylor.
110		Otherwise, i_y_x is its index in parameter array \a parameter.
	82	\n
	83	Input
	84	\n
	85	In LdvOp case, <code>taylor[ arg[1] * cap_order + 0 ]</code>
	86	is used to compute the index in the definition of i_vec above.
	87	If v[x] is a variable, <code>taylor[ i_v_x * cap_order + 0 ]</code>
	88	is the zero order Taylor coefficient for v[x].
	89	\n
	90	\n
	91	Output
	92	\n
	93	<code>taylor[ i_z * cap_order + 0 ]</code>
	94	is set to the zero order Taylor coefficient for the variable z.
	95
	96	\param isvar_by_ind
	97	If <code>isvar_by_ind[ arg[0] + i_vec ] </code> is true,
	98	v[x] is a variable. Otherwise it is a parameter.
	99	This vector has size play->num_vec_ind_rec().
	100
	101	\param index_by_ind
	102	<code>index_by_ind[ arg[0] - 1 ]</code>
	103	is the number of elements in the user vector containing this element.
	104	<code>index_by_ind[ arg[0] + i_vec ]</code> is the variable or
	105	parameter index for this element,
	106	This array has size play->num_vec_ind_rec().
	107
	108	\param var_by_load_op
	109	is a vector with size play->num_load_op_rec().
	110	The input value of its elements does not matter.
	111	Upon return, it contains the variable index corresponding to each load
	112	instruction.
	113	In the case where the index is zero,
	114	the instruction corresponds to a parameter (not variable).
	115	This array has size play->num_load_op_rec().
111	116
112	117	\par Check User Errors
113	118	\li In the LdvOp case check that the index is with in range; i.e.
114		i_vec < combined[ \a arg[0] - 1 ]
115
116		\par Checked Assertions
117		\li combined != CPPAD_NULL
118		\li variable != CPPAD_NULL
119		\li NumArg(LdpOp) == 3
120		\li NumRes(LdpOp) == 1
121		\li 0 < \a arg[0]
122		\li \a arg[0] + i_vec < nc_combined
123		\li i_vec < combined[ \a arg[0] - 1 ]
124		\li if y[x] is a parameter, i_y_x < num_par
125		\li if y[x] is a variable, i_y_x < i_z
126		\li if x is a variable (LpvOp case), arg[1] < i_z
	119	<code>i_vec < index_by_ind[ arg[0] - 1 ]</code>.
	120	Note that, if x is a parameter,
	121	the corresponding vector index and it does not change.
	122	In this case, the error above should be detected during tape recording.
127	123	*/
128	124	template <class Base>
129	125	inline void forward_load_op_0(
	126	player<Base>* play ,
130	127	size_t i_z ,
131		addr_t* arg ,
132		size_t num_par ,
	128	const addr_t* arg ,
133	129	const Base* parameter ,
134		size_t nc_taylor ,
	130	size_t cap_order ,
135	131	Base* taylor ,
136		size_t nc_combined ,
137		const bool* variable ,
138		const size_t* combined )
	132	bool* isvar_by_ind ,
	133	size_t* index_by_ind ,
	134	addr_t* var_by_load_op )
139	135	{
140	136	// This routine is only for documentaiton, it should not be used
141	137	CPPAD_ASSERT_UNKNOWN( false );

224	220	*/
225	221	template <class Base>
226	222	inline void forward_load_p_op_0(
	223	player<Base>* play ,
227	224	size_t i_z ,
228		addr_t* arg ,
229		size_t num_par ,
	225	const addr_t* arg ,
230	226	const Base* parameter ,
231		size_t nc_taylor ,
	227	size_t cap_order ,
232	228	Base* taylor ,
233		size_t nc_combined ,
234		const bool* variable ,
235		const size_t* combined )
236		{ size_t i_vec = arg[1];
	229	bool* isvar_by_ind ,
	230	size_t* index_by_ind ,
	231	addr_t* var_by_load_op )
	232	{ CPPAD_ASSERT_UNKNOWN( NumArg(LdpOp) == 3 );
	233	CPPAD_ASSERT_UNKNOWN( NumRes(LdpOp) == 1 );
	234	CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
	235	CPPAD_ASSERT_UNKNOWN( arg[2] < play->num_load_op_rec() );
237	236
238	237	// Because the index is a parameter, this indexing error should be
239	238	// caught and reported to the user at an when the tape is recording.
240		CPPAD_ASSERT_UNKNOWN( i_vec < combined[ arg[0] - 1 ] );
241
242
243		CPPAD_ASSERT_UNKNOWN( variable != CPPAD_NULL );
244		CPPAD_ASSERT_UNKNOWN( combined != CPPAD_NULL );
245		CPPAD_ASSERT_UNKNOWN( NumArg(LdpOp) == 3 );
246		CPPAD_ASSERT_UNKNOWN( NumRes(LdpOp) == 1 );
247		CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
248		CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
249
250		size_t combined_index = arg[0] + i_vec;
251		size_t i_y_x = combined[ combined_index ];
252		Base* z = taylor + i_z * nc_taylor;
253		if( variable[ combined_index ] )
254		{ CPPAD_ASSERT_UNKNOWN( i_y_x < i_z );
255		Base* y_x = taylor + i_y_x * nc_taylor;
256		arg[2] = i_y_x;
257		z[0] = y_x[0];
	239	size_t i_vec = arg[1];
	240	CPPAD_ASSERT_UNKNOWN( i_vec < index_by_ind[ arg[0] - 1 ] );
	241	CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < play->num_vec_ind_rec() );
	242
	243	size_t i_v_x = index_by_ind[ arg[0] + i_vec ];
	244	Base* z = taylor + i_z * cap_order;
	245	if( isvar_by_ind[ arg[0] + i_vec ] )
	246	{ CPPAD_ASSERT_UNKNOWN( i_v_x < i_z );
	247	var_by_load_op[ arg[2] ] = i_v_x;
	248	Base* v_x = taylor + i_v_x * cap_order;
	249	z[0] = v_x[0];
258	250	}
259	251	else
260		{ CPPAD_ASSERT_UNKNOWN( i_y_x < num_par );
261		Base y_x = parameter[i_y_x];
262		arg[2] = 0;
263		z[0] = y_x;
	252	{ CPPAD_ASSERT_UNKNOWN( i_v_x < play->num_par_rec() );
	253	var_by_load_op[ arg[2] ] = 0;
	254	Base v_x = parameter[i_v_x];
	255	z[0] = v_x;
264	256	}
265	257	}
266	258

271	263	*/
272	264	template <class Base>
273	265	inline void forward_load_v_op_0(
	266	player<Base>* play ,
274	267	size_t i_z ,
275		addr_t* arg ,
276		size_t num_par ,
	268	const addr_t* arg ,
277	269	const Base* parameter ,
278		size_t nc_taylor ,
	270	size_t cap_order ,
279	271	Base* taylor ,
280		size_t nc_combined ,
281		const bool* variable ,
282		const size_t* combined )
283		{
284		CPPAD_ASSERT_UNKNOWN( variable != CPPAD_NULL );
285		CPPAD_ASSERT_UNKNOWN( combined != CPPAD_NULL );
286		CPPAD_ASSERT_UNKNOWN( NumArg(LdvOp) == 3 );
	272	bool* isvar_by_ind ,
	273	size_t* index_by_ind ,
	274	addr_t* var_by_load_op )
	275	{ CPPAD_ASSERT_UNKNOWN( NumArg(LdvOp) == 3 );
287	276	CPPAD_ASSERT_UNKNOWN( NumRes(LdvOp) == 1 );
288	277	CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
289		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
290
291		size_t i_vec = Integer( taylor[ arg[1] * nc_taylor + 0 ] );
	278	CPPAD_ASSERT_UNKNOWN( arg[2] < play->num_load_op_rec() );
	279
	280	size_t i_vec = Integer( taylor[ arg[1] * cap_order + 0 ] );
292	281	CPPAD_ASSERT_KNOWN(
293		i_vec < combined[ arg[0] - 1 ] ,
	282	i_vec < index_by_ind[ arg[0] - 1 ] ,
294	283	"VecAD: index during zero order forward sweep is out of range"
295	284	);
296		CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
297
298		size_t combined_index = arg[0] + i_vec;
299		size_t i_y_x = combined[ combined_index ];
300
301
302		Base* z = taylor + i_z * nc_taylor;
303		if( variable[ combined_index ] )
304		{ CPPAD_ASSERT_UNKNOWN( i_y_x < i_z );
305		Base* y_x = taylor + i_y_x * nc_taylor;
306		arg[2] = i_y_x;
307		z[0] = y_x[0];
	285	CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < play->num_vec_ind_rec() );
	286
	287	size_t i_v_x = index_by_ind[ arg[0] + i_vec ];
	288	Base* z = taylor + i_z * cap_order;
	289	if( isvar_by_ind[ arg[0] + i_vec ] )
	290	{ CPPAD_ASSERT_UNKNOWN( i_v_x < i_z );
	291	var_by_load_op[ arg[2] ] = i_v_x;
	292	Base* v_x = taylor + i_v_x * cap_order;
	293	z[0] = v_x[0];
308	294	}
309	295	else
310		{ CPPAD_ASSERT_UNKNOWN( i_y_x < num_par );
311		Base y_x = parameter[i_y_x];
312		arg[2] = 0;
313		z[0] = y_x;
	296	{ CPPAD_ASSERT_UNKNOWN( i_v_x < play->num_par_rec() );
	297	var_by_load_op[ arg[2] ] = 0;
	298	Base v_x = parameter[i_v_x];
	299	z[0] = v_x;
314	300	}
315	301	}
316	302

319	305
320	306	The C++ source code corresponding to this operation is
321	307	\verbatim
	308	z = v[x]
	309	\endverbatim
	310	where v is a VecAD<Base> vector and x is an AD<Base> or Base index.
	311
	312	\tparam Base
	313	base type for the operator; i.e., this operation was recorded
	314	using AD<Base> and computations by this routine are done using type Base.
	315
	316	\param play
	317	is the tape that this operation appears in.
	318	This is for error detection and not used when NDEBUG is defined.
	319
	320	\param op
	321	is the code corresponding to this operator; i.e., LdpOp or LdvOp
	322	(only used for error checking).
	323
	324	\param p
	325	is the lowest order of the Taylor coefficient that we are computing.
	326
	327	\param q
	328	is the highest order of the Taylor coefficient that we are computing.
	329
	330	\param r
	331	is the number of directions for the Taylor coefficients that we
	332	are computing.
	333
	334	\param cap_order
	335	number of columns in the matrix containing the Taylor coefficients.
	336
	337	\par tpv
	338	We use the notation
	339	<code>tpv = (cap_order-1) * r + 1</code>
	340	which is the number of Taylor coefficients per variable
	341
	342	\param i_z
	343	is the AD variable index corresponding to the variable z.
	344
	345	\param arg
	346	arg[2]
	347	Is the index of this vecad load instruction in the var_by_load_op array.
	348
	349	\param var_by_load_op
	350	is a vector with size play->num_load_op_rec().
	351	It contains the variable index corresponding to each load instruction.
	352	In the case where the index is zero,
	353	the instruction corresponds to a parameter (not variable).
	354
	355	\par i_var
	356	We use the notation
	357	\verbatim
	358	i_var = size_t( var_by_load_op[ arg[2] ] )
	359	\endverbatim
	360
	361	\param taylor
	362	\n
	363	Input
	364	\n
	365	If <code>i_var > 0</code>, v[x] is a variable and
	366	for k = 1 , ... , q
	367	<code>taylor[ i_var * tpv + (k-1)*r+1+ell ]</code>
	368	is the k-th order coefficient for v[x] in the ell-th direction,
	369	\n
	370	\n
	371	Output
	372	\n
	373	for k = p , ... , q,
	374	<code>taylor[ i_z * tpv + (k-1)*r+1+ell ]</code>
	375	is set to the k-order Taylor coefficient for z in the ell-th direction.
	376	*/
	377	template <class Base>
	378	inline void forward_load_op(
	379	const player<Base>* play ,
	380	OpCode op ,
	381	size_t p ,
	382	size_t q ,
	383	size_t r ,
	384	size_t cap_order ,
	385	size_t i_z ,
	386	const addr_t* arg ,
	387	const addr_t* var_by_load_op ,
	388	Base* taylor )
	389	{
	390	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
	391	CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
	392	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	393	CPPAD_ASSERT_UNKNOWN( 0 < r);
	394	CPPAD_ASSERT_UNKNOWN( 0 < p);
	395	CPPAD_ASSERT_UNKNOWN( p <= q );
	396	CPPAD_ASSERT_UNKNOWN( arg[2] < play->num_load_op_rec() );
	397
	398	size_t i_var = size_t( var_by_load_op[ arg[2] ] );
	399	CPPAD_ASSERT_UNKNOWN( i_var < i_z );
	400
	401	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	402	Base* z = taylor + i_z * num_taylor_per_var;
	403	if( i_var > 0 )
	404	{ Base* v_x = taylor + i_var * num_taylor_per_var;
	405	for(size_t ell = 0; ell < r; ell++)
	406	{ for(size_t k = p; k <= q; k++)
	407	{ size_t m = (k-1) * r + 1 + ell;
	408	z[m] = v_x[m];
	409	}
	410	}
	411	}
	412	else
	413	{ for(size_t ell = 0; ell < r; ell++)
	414	{ for(size_t k = p; k <= q; k++)
	415	{ size_t m = (k-1) * r + 1 + ell;
	416	z[m] = Base(0);
	417	}
	418	}
	419	}
	420	}
	421
	422	/*!
	423	Reverse mode for op = LdpOp or LdvOp.
	424
	425	The C++ source code corresponding to this operation is
	426	\verbatim
322	427	z = y[x]
323	428	\endverbatim
324	429	where y is a VecAD<Base> vector and x is an AD<Base> or Base index.
	430
	431	This routine is given the partial derivatives of a function
	432	G(z , y[x] , w , u ... )
	433	and it uses them to compute the partial derivatives of
	434	\verbatim
	435	H( y[x] , w , u , ... ) = G[ z( y[x] ) , y[x] , w , u , ... ]
	436	\endverbatim
325	437
326	438	\tparam Base
327	439	base type for the operator; i.e., this operation was recorded

332	444	is the code corresponding to this operator; i.e., LdpOp or LdvOp
333	445	(only used for error checking).
334	446
335		\param q
336		is the lowest order of the Taylor coefficient that we are computing.
337
338		\param p
339		is the highest order of the Taylor coefficient that we are computing.
340
341		\param i_z
342		is the AD variable index corresponding to the variable z.
343
344		\param arg
345		\a arg[2]
346		If y[x] is a parameter, <code>arg[2]</code> is zero
347		(which is not a valid variable index).
348		If y[x] is a variable,
349		<code>arg[2]</code> is the variable index corresponding to y[x].
350
351		\param nc_taylor
352		number of columns in the matrix containing the Taylor coefficients.
353
354		\param taylor
355		\b Input: if y[x] is a variable,
356		<code>taylor[ arg[2] * nc_taylor + k ]</code>
357		for k = 0 , ... , p,
358		is the k-order Taylor coefficient corresponding to y[x].
359		\n
360		\b Output: <code>taylor[ i_z * nc_taylor + d ]</code>
361		for k = q , ... , p,
362		is the k-order Taylor coefficient for the variable z.
363
364		\par Checked Assertions
365		\li NumArg(op) == 3
366		\li NumRes(op) == 1
367		\li p < nc_taylor
368		\li 0 < q <= p
369		\li size_t(arg[2]) < i_z
370		*/
371		template <class Base>
372		inline void forward_load_op(
373		OpCode op ,
374		size_t q ,
375		size_t p ,
376		size_t i_z ,
377		const addr_t* arg ,
378		size_t nc_taylor ,
379		Base* taylor )
380		{
381
382		CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
383		CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
384		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
385		CPPAD_ASSERT_UNKNOWN( 0 < q && q <= p );
386		CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
387
388		Base* z = taylor + i_z * nc_taylor;
389		if( arg[2] > 0 )
390		{ Base* y_x = taylor + arg[2] * nc_taylor;
391		for(size_t d = q; d <= p; d++)
392		z[d] = y_x[d];
393		}
394		else
395		{ for(size_t d = q; d <= p; d++)
396		z[d] = Base(0);
397		}
398		}
399
400		/*!
401		Reverse mode for op = LdpOp or LdvOp.
402
403		The C++ source code corresponding to this operation is
404		\verbatim
405		z = y[x]
406		\endverbatim
407		where y is a VecAD<Base> vector and x is an AD<Base> or Base index.
408
409		This routine is given the partial derivatives of a function
410		G(z , y[x] , w , u ... )
411		and it uses them to compute the partial derivatives of
412		\verbatim
413		H( y[x] , w , u , ... ) = G[ z( y[x] ) , y[x] , w , u , ... ]
414		\endverbatim
415
416		\tparam Base
417		base type for the operator; i.e., this operation was recorded
418		using AD< \a Base > and computations by this routine are done using type
419		\a Base.
420
421		\param op
422		is the code corresponding to this operator; i.e., LdpOp or LdvOp
423		(only used for error checking).
424
425	447	\param d
426	448	highest order the Taylor coefficient that we are computing the partial
427	449	derivative with respect to.

431	453
432	454	\param arg
433	455	\a arg[2]
434		If y[x] is a parameter, \a arg[2] is zero
435		(which is not a valid variable index).
436		If y[x] is a variable,
437		\a arg[2] is the variable index corresponding to y[x].
438
439		\param nc_taylor
	456	Is the index of this vecad load instruction in the
	457	var_by_load_op array.
	458
	459	\param cap_order
440	460	number of columns in the matrix containing the Taylor coefficients
441	461	(not used).
442	462

467	487	On input, it corresponds to the function G,
468	488	and on output it corresponds to the the function H.
469	489
	490	\param var_by_load_op
	491	is a vector with size play->num_load_op_rec().
	492	It contains the variable index corresponding to each load instruction.
	493	In the case where the index is zero,
	494	the instruction corresponds to a parameter (not variable).
	495
470	496	\par Checked Assertions
471	497	\li NumArg(op) == 3
472	498	\li NumRes(op) == 1
473		\li d < nc_taylor
	499	\li d < cap_order
474	500	\li size_t(arg[2]) < i_z
475	501	*/
476	502	template <class Base>

479	505	size_t d ,
480	506	size_t i_z ,
481	507	const addr_t* arg ,
482		size_t nc_taylor ,
	508	size_t cap_order ,
483	509	const Base* taylor ,
484	510	size_t nc_partial ,
485		Base* partial )
486		{
	511	Base* partial ,
	512	const addr_t* var_by_load_op )
	513	{ size_t i_load = size_t( var_by_load_op[ arg[2] ] );
487	514
488	515	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
489	516	CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
490		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
491		CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < i_z );
492
493		if( arg[2] > 0 )
	517	CPPAD_ASSERT_UNKNOWN( d < cap_order );
	518	CPPAD_ASSERT_UNKNOWN( i_load < i_z );
	519
	520	if( i_load > 0 )
494	521	{
495	522	Base* pz = partial + i_z * nc_partial;
496		Base* py_x = partial + arg[2] * nc_partial;
	523	Base* py_x = partial + i_load * nc_partial;
497	524	size_t j = d + 1;
498	525	while(j--)
499	526	py_x[j] += pz[j];

665	692	}
666	693
667	694
668		/! \} /
669	695	} // END_CPPAD_NAMESPACE
670	696	# endif

+64

-30

cppad/local/log_op.hpp less more

0		/* $Id: log_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: log_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_LOG_OP_INCLUDED
2	2	# define CPPAD_LOG_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup log_op_hpp log_op.hpp
18		\{
19	17	\file log_op.hpp
20	18	Forward and reverse mode calculations for z = log(x).
21	19	*/

32	30	*/
33	31	template <class Base>
34	32	inline void forward_log_op(
	33	size_t p ,
35	34	size_t q ,
36		size_t p ,
37	35	size_t i_z ,
38	36	size_t i_x ,
39		size_t nc_taylor ,
	37	size_t cap_order ,
40	38	Base* taylor )
41	39	{
42	40	size_t k;

44	42	// check assumptions
45	43	CPPAD_ASSERT_UNKNOWN( NumArg(LogOp) == 1 );
46	44	CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
47		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
48		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
49		CPPAD_ASSERT_UNKNOWN( q <= p );
	45	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	46	CPPAD_ASSERT_UNKNOWN( p <= q );
50	47
51	48	// Taylor coefficients corresponding to argument and result
52		Base* x = taylor + i_x * nc_taylor;
53		Base* z = taylor + i_z * nc_taylor;
54
55		if( q == 0 )
	49	Base* x = taylor + i_x * cap_order;
	50	Base* z = taylor + i_z * cap_order;
	51
	52	if( p == 0 )
56	53	{ z[0] = log( x[0] );
57		q++;
58		if( p == 0 )
	54	p++;
	55	if( q == 0 )
59	56	return;
60	57	}
61		if ( q == 1 )
	58	if ( p == 1 )
62	59	{ z[1] = x[1] / x[0];
63		q++;
64		}
65		for(size_t j = q; j <= p; j++)
	60	p++;
	61	}
	62	for(size_t j = p; j <= q; j++)
66	63	{
67	64	z[j] = -z[1] * x[j-1];
68	65	for(k = 2; k < j; k++)

74	71	}
75	72
76	73	/*!
	74	Muiltiple directions Taylor coefficient for op = LogOp.
	75
	76	The C++ source code corresponding to this operation is
	77	\verbatim
	78	z = log(x)
	79	\endverbatim
	80
	81	\copydetails forward_unary1_op_dir
	82	*/
	83	template <class Base>
	84	inline void forward_log_op_dir(
	85	size_t q ,
	86	size_t r ,
	87	size_t i_z ,
	88	size_t i_x ,
	89	size_t cap_order ,
	90	Base* taylor )
	91	{
	92
	93	// check assumptions
	94	CPPAD_ASSERT_UNKNOWN( NumArg(LogOp) == 1 );
	95	CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
	96	CPPAD_ASSERT_UNKNOWN( 0 < q );
	97	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	98
	99	// Taylor coefficients corresponding to argument and result
	100	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	101	Base* x = taylor + i_x * num_taylor_per_var;
	102	Base* z = taylor + i_z * num_taylor_per_var;
	103
	104	size_t m = (q-1) * r + 1;
	105	for(size_t ell = 0; ell < r; ell++)
	106	{ z[m+ell] = Base(q) * x[m+ell];
	107	for(size_t k = 1; k < q; k++)
	108	z[m+ell] -= Base(k) * z[(k-1)r+1+ell] x[(q-k-1)*r+1+ell];
	109	z[m+ell] /= (Base(q) * x[0]);
	110	}
	111	}
	112
	113	/*!
77	114	Compute zero order forward mode Taylor coefficient for result of op = LogOp.
78	115
79	116	The C++ source code corresponding to this operation is

87	124	inline void forward_log_op_0(
88	125	size_t i_z ,
89	126	size_t i_x ,
90		size_t nc_taylor ,
	127	size_t cap_order ,
91	128	Base* taylor )
92	129	{
93	130
94	131	// check assumptions
95	132	CPPAD_ASSERT_UNKNOWN( NumArg(LogOp) == 1 );
96	133	CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
97		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
98		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	134	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
99	135
100	136	// Taylor coefficients corresponding to argument and result
101		Base* x = taylor + i_x * nc_taylor;
102		Base* z = taylor + i_z * nc_taylor;
	137	Base* x = taylor + i_x * cap_order;
	138	Base* z = taylor + i_z * cap_order;
103	139
104	140	z[0] = log( x[0] );
105	141	}

120	156	size_t d ,
121	157	size_t i_z ,
122	158	size_t i_x ,
123		size_t nc_taylor ,
	159	size_t cap_order ,
124	160	const Base* taylor ,
125	161	size_t nc_partial ,
126	162	Base* partial )

129	165	// check assumptions
130	166	CPPAD_ASSERT_UNKNOWN( NumArg(LogOp) == 1 );
131	167	CPPAD_ASSERT_UNKNOWN( NumRes(LogOp) == 1 );
132		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
133		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	168	CPPAD_ASSERT_UNKNOWN( d < cap_order );
134	169	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
135	170
136	171	// Taylor coefficients and partials corresponding to argument
137		const Base* x = taylor + i_x * nc_taylor;
	172	const Base* x = taylor + i_x * cap_order;
138	173	Base* px = partial + i_x * nc_partial;
139	174
140	175	// Taylor coefficients and partials corresponding to result
141		const Base* z = taylor + i_z * nc_taylor;
	176	const Base* z = taylor + i_z * cap_order;
142	177	Base* pz = partial + i_z * nc_partial;
143	178
144	179	j = d;

161	196	px[0] += pz[0] / x[0];
162	197	}
163	198
164		/! \} /
165	199	} // END_CPPAD_NAMESPACE
166	200	# endif

+164

-91

cppad/local/mul_op.hpp less more

0		/* $Id: mul_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: mul_op.hpp 3321 2014-09-12 09:50:39Z bradbell $ */
1	1	# ifndef CPPAD_MUL_OP_INCLUDED
2	2	# define CPPAD_MUL_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup mul_op_hpp mul_op.hpp
18		\{
19	17	\file mul_op.hpp
20	18	Forward and reverse mode calculations for z = x * y.
21	19	*/

37	35
38	36	template <class Base>
39	37	inline void forward_mulvv_op(
	38	size_t p ,
40	39	size_t q ,
41		size_t p ,
42		size_t i_z ,
43		const addr_t* arg ,
44		const Base* parameter ,
45		size_t nc_taylor ,
46		Base* taylor )
47		{
48		// check assumptions
49		CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
50		CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
51		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
52		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
53		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
54		CPPAD_ASSERT_UNKNOWN( q <= p );
55
56		// Taylor coefficients corresponding to arguments and result
57		Base* x = taylor + arg[0] * nc_taylor;
58		Base* y = taylor + arg[1] * nc_taylor;
59		Base* z = taylor + i_z * nc_taylor;
	40	size_t i_z ,
	41	const addr_t* arg ,
	42	const Base* parameter ,
	43	size_t cap_order ,
	44	Base* taylor )
	45	{
	46	// check assumptions
	47	CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
	48	CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
	49	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	50	CPPAD_ASSERT_UNKNOWN( p <= q );
	51
	52	// Taylor coefficients corresponding to arguments and result
	53	Base* x = taylor + arg[0] * cap_order;
	54	Base* y = taylor + arg[1] * cap_order;
	55	Base* z = taylor + i_z * cap_order;
60	56
61	57	size_t k;
62		for(size_t d = q; d <= p; d++)
	58	for(size_t d = p; d <= q; d++)
63	59	{ z[d] = Base(0);
64	60	for(k = 0; k <= d; k++)
65	61	z[d] += x[d-k] * y[k];
66	62	}
67	63	}
68
69		/*!
70		Compute zero order forward mode Taylor coefficients for result of op = MulvvOp.
	64	/*!
	65	Multiple directions forward mode Taylor coefficients for op = MulvvOp.
71	66
72	67	The C++ source code corresponding to this operation is
73	68	\verbatim

77	72	this operations is for the case where both x and y are variables
78	73	and the argument \a parameter is not used.
79	74
80		\copydetails forward_binary_op_0
81		*/
82
83		template <class Base>
84		inline void forward_mulvv_op_0(
85		size_t i_z ,
86		const addr_t* arg ,
87		const Base* parameter ,
88		size_t nc_taylor ,
89		Base* taylor )
90		{
91		// check assumptions
92		CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
93		CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
94		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
95		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
96
97		// Taylor coefficients corresponding to arguments and result
98		Base* x = taylor + arg[0] * nc_taylor;
99		Base* y = taylor + arg[1] * nc_taylor;
100		Base* z = taylor + i_z * nc_taylor;
101
102		z[0] = x[0] * y[0];
103		}
104
105		/*!
106		Compute reverse mode partial derivatives for result of op = MulvvOp.
	75	\copydetails forward_binary_op_dir
	76	*/
	77
	78	template <class Base>
	79	inline void forward_mulvv_op_dir(
	80	size_t q ,
	81	size_t r ,
	82	size_t i_z ,
	83	const addr_t* arg ,
	84	const Base* parameter ,
	85	size_t cap_order ,
	86	Base* taylor )
	87	{
	88	// check assumptions
	89	CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
	90	CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
	91	CPPAD_ASSERT_UNKNOWN( 0 < q );
	92	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	93
	94	// Taylor coefficients corresponding to arguments and result
	95	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	96	Base* x = taylor + arg[0] * num_taylor_per_var;
	97	Base* y = taylor + arg[1] * num_taylor_per_var;
	98	Base* z = taylor + i_z * num_taylor_per_var;
	99
	100	size_t k, ell, m;
	101	for(ell = 0; ell < r; ell++)
	102	{ m = (q-1)*r + ell + 1;
	103	z[m] = x[0] * y[m] + x[m] * y[0];
	104	for(k = 1; k < q; k++)
	105	z[m] += x[(q-k-1)r + ell + 1] y[(k-1)*r + ell + 1];
	106	}
	107	}
	108
	109	/*!
	110	Compute zero order forward mode Taylor coefficients for result of op = MulvvOp.
107	111
108	112	The C++ source code corresponding to this operation is
109	113	\verbatim

113	117	this operations is for the case where both x and y are variables
114	118	and the argument \a parameter is not used.
115	119
	120	\copydetails forward_binary_op_0
	121	*/
	122
	123	template <class Base>
	124	inline void forward_mulvv_op_0(
	125	size_t i_z ,
	126	const addr_t* arg ,
	127	const Base* parameter ,
	128	size_t cap_order ,
	129	Base* taylor )
	130	{
	131	// check assumptions
	132	CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
	133	CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
	134
	135	// Taylor coefficients corresponding to arguments and result
	136	Base* x = taylor + arg[0] * cap_order;
	137	Base* y = taylor + arg[1] * cap_order;
	138	Base* z = taylor + i_z * cap_order;
	139
	140	z[0] = x[0] * y[0];
	141	}
	142
	143	/*!
	144	Compute reverse mode partial derivatives for result of op = MulvvOp.
	145
	146	The C++ source code corresponding to this operation is
	147	\verbatim
	148	z = x * y
	149	\endverbatim
	150	In the documentation below,
	151	this operations is for the case where both x and y are variables
	152	and the argument \a parameter is not used.
	153
116	154	\copydetails reverse_binary_op
117	155	*/
118	156

122	160	size_t i_z ,
123	161	const addr_t* arg ,
124	162	const Base* parameter ,
125		size_t nc_taylor ,
	163	size_t cap_order ,
126	164	const Base* taylor ,
127	165	size_t nc_partial ,
128	166	Base* partial )

130	168	// check assumptions
131	169	CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
132	170	CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
133		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
134		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
135		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	171	CPPAD_ASSERT_UNKNOWN( d < cap_order );
136	172	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
137	173
138	174	// Arguments
139		const Base* x = taylor + arg[0] * nc_taylor;
140		const Base* y = taylor + arg[1] * nc_taylor;
	175	const Base* x = taylor + arg[0] * cap_order;
	176	const Base* y = taylor + arg[1] * cap_order;
141	177
142	178	// Partial derivatives corresponding to arguments and result
143	179	Base* px = partial + arg[0] * nc_partial;

173	209
174	210	template <class Base>
175	211	inline void forward_mulpv_op(
	212	size_t p ,
176	213	size_t q ,
177		size_t p ,
178		size_t i_z ,
179		const addr_t* arg ,
180		const Base* parameter ,
181		size_t nc_taylor ,
	214	size_t i_z ,
	215	const addr_t* arg ,
	216	const Base* parameter ,
	217	size_t cap_order ,
182	218	Base* taylor )
183	219	{
184	220	// check assumptions
185	221	CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
186	222	CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
187		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
188		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
189		CPPAD_ASSERT_UNKNOWN( q <= p );
190
191		// Taylor coefficients corresponding to arguments and result
192		Base* y = taylor + arg[1] * nc_taylor;
193		Base* z = taylor + i_z * nc_taylor;
	223	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	224	CPPAD_ASSERT_UNKNOWN( p <= q );
	225
	226	// Taylor coefficients corresponding to arguments and result
	227	Base* y = taylor + arg[1] * cap_order;
	228	Base* z = taylor + i_z * cap_order;
194	229
195	230	// Paraemter value
196	231	Base x = parameter[ arg[0] ];
197	232
198		for(size_t d = q; d <= p; d++)
	233	for(size_t d = p; d <= q; d++)
199	234	z[d] = x * y[d];
200	235	}
201	236	/*!
202		Compute zero order forward mode Taylor coefficient for result of op = MulpvOp.
	237	Multiple directions forward mode Taylor coefficients for op = MulpvOp.
203	238
204	239	The C++ source code corresponding to this operation is
205	240	\verbatim

208	243	In the documentation below,
209	244	this operations is for the case where x is a parameter and y is a variable.
210	245
211		\copydetails forward_binary_op_0
212		*/
213
214		template <class Base>
215		inline void forward_mulpv_op_0(
216		size_t i_z ,
217		const addr_t* arg ,
218		const Base* parameter ,
219		size_t nc_taylor ,
	246	\copydetails forward_binary_op_dir
	247	*/
	248
	249	template <class Base>
	250	inline void forward_mulpv_op_dir(
	251	size_t q ,
	252	size_t r ,
	253	size_t i_z ,
	254	const addr_t* arg ,
	255	const Base* parameter ,
	256	size_t cap_order ,
220	257	Base* taylor )
221	258	{
222	259	// check assumptions
223	260	CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
224	261	CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
225		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
	262	CPPAD_ASSERT_UNKNOWN( 0 < q );
	263	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	264
	265	// Taylor coefficients corresponding to arguments and result
	266	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	267	size_t m = (q-1) * r + 1;
	268	Base* y = taylor + arg[1] * num_taylor_per_var + m;
	269	Base* z = taylor + i_z * num_taylor_per_var + m;
226	270
227	271	// Paraemter value
228	272	Base x = parameter[ arg[0] ];
229	273
230		// Taylor coefficients corresponding to arguments and result
231		Base* y = taylor + arg[1] * nc_taylor;
232		Base* z = taylor + i_z * nc_taylor;
	274	for(size_t ell = 0; ell < r; ell++)
	275	z[ell] = x * y[ell];
	276	}
	277	/*!
	278	Compute zero order forward mode Taylor coefficient for result of op = MulpvOp.
	279
	280	The C++ source code corresponding to this operation is
	281	\verbatim
	282	z = x * y
	283	\endverbatim
	284	In the documentation below,
	285	this operations is for the case where x is a parameter and y is a variable.
	286
	287	\copydetails forward_binary_op_0
	288	*/
	289
	290	template <class Base>
	291	inline void forward_mulpv_op_0(
	292	size_t i_z ,
	293	const addr_t* arg ,
	294	const Base* parameter ,
	295	size_t cap_order ,
	296	Base* taylor )
	297	{
	298	// check assumptions
	299	CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
	300	CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
	301
	302	// Paraemter value
	303	Base x = parameter[ arg[0] ];
	304
	305	// Taylor coefficients corresponding to arguments and result
	306	Base* y = taylor + arg[1] * cap_order;
	307	Base* z = taylor + i_z * cap_order;
233	308
234	309	z[0] = x * y[0];
235	310	}

253	328	size_t i_z ,
254	329	const addr_t* arg ,
255	330	const Base* parameter ,
256		size_t nc_taylor ,
	331	size_t cap_order ,
257	332	const Base* taylor ,
258	333	size_t nc_partial ,
259	334	Base* partial )

261	336	// check assumptions
262	337	CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
263	338	CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
264		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
265		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	339	CPPAD_ASSERT_UNKNOWN( d < cap_order );
266	340	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
267	341
268	342	// Arguments

281	355	}
282	356
283	357
284		/! \} /
285	358	} // END_CPPAD_NAMESPACE
286	359	# endif

-4

cppad/local/num_skip.hpp less more

0		/* $Id: num_skip.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: num_skip.hpp 3132 2014-03-01 16:55:48Z bradbell $ */
1	1	# ifndef CPPAD_NUM_SKIP_INCLUDED
2	2	# define CPPAD_NUM_SKIP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

83	83	size_t n_skip = 0;
84	84
85	85	// start playback
86		play_.start_forward(op, arg, i_op, i_var);
	86	play_.forward_start(op, arg, i_op, i_var);
87	87	CPPAD_ASSERT_UNKNOWN(op == BeginOp)
88	88	while(op != EndOp)
89	89	{ // next op
90		play_.next_forward(op, arg, i_op, i_var);
	90	play_.forward_next(op, arg, i_op, i_var);
91	91	if( op == CSumOp)
92	92	play_.forward_csum(op, arg, i_op, i_var);
93	93	else if (op == CSkipOp)

+20

-23

cppad/local/old_atomic.hpp less more

0		/* $Id: old_atomic.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: old_atomic.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_OLD_ATOMIC_INCLUDED
2	2	# define CPPAD_OLD_ATOMIC_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

339	339	It is used,
340	340	with $icode%vx%.size() = 0%$$ and
341	341	$icode k$$ equal to the order of the derivative begin computed,
342		by calls to $cref/forward/ForwardAny/$$.
	342	by calls to $cref/forward/forward_order/$$.
343	343
344	344	$subhead vx$$
345	345	The $icode forward$$ argument $icode vx$$ has prototype

746	746
747	747	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
748	748	/*!
749		\defgroup old_atomic_hpp old_atomic.hpp
750		\{
751	749	\file old_atomic.hpp
752	750	user defined atomic operations.
753	751	*/

983	981	\copydetails atomic_base::forward
984	982	*/
985	983	virtual bool forward(
	984	size_t p ,
986	985	size_t q ,
987		size_t p ,
988	986	const vector<bool>& vx ,
989	987	vector<bool>& vy ,
990	988	const vector<Base>& tx ,
991	989	vector<Base>& ty )
992		{ CPPAD_ASSERT_UNKNOWN( tx.size() % (p+1) == 0 );
993		CPPAD_ASSERT_UNKNOWN( ty.size() % (p+1) == 0 );
994		size_t n = tx.size() / (p+1);
995		size_t m = ty.size() / (p+1);
	990	{ CPPAD_ASSERT_UNKNOWN( tx.size() % (q+1) == 0 );
	991	CPPAD_ASSERT_UNKNOWN( ty.size() % (q+1) == 0 );
	992	size_t n = tx.size() / (q+1);
	993	size_t m = ty.size() / (q+1);
996	994	size_t i, j, k, ell;
997	995
998		vector<Base> x(n * (p+1));
999		vector<Base> y(m * (p+1));
	996	vector<Base> x(n * (q+1));
	997	vector<Base> y(m * (q+1));
1000	998	vector<bool> empty;
1001	999
1002	1000	// old_atomic interface can only handel one order at a time
1003	1001	// so must just throuh hoops to get multiple orders at one time.
1004	1002	bool ok = true;
1005		for(k = q; k <= p; k++)
	1003	for(k = p; k <= q; k++)
1006	1004	{ for(j = 0; j < n; j++)
1007	1005	for(ell = 0; ell <= k; ell++)
1008		x[ j * (k+1) + ell ] = tx[ j * (p+1) + ell ];
	1006	x[ j * (k+1) + ell ] = tx[ j * (q+1) + ell ];
1009	1007	for(i = 0; i < m; i++)
1010	1008	for(ell = 0; ell < k; ell++)
1011		y[ i * (k+1) + ell ] = ty[ i * (p+1) + ell ];
	1009	y[ i * (k+1) + ell ] = ty[ i * (q+1) + ell ];
1012	1010	if( k == 0 )
1013	1011	ok &= f_(id_, k, n, m, vx, vy, x, y);
1014	1012	else
1015	1013	ok &= f_(id_, k, n, m, empty, empty, x, y);
1016	1014	for(i = 0; i < m; i++)
1017		ty[ i * (p+1) + k ] = y[ i * (k+1) + k];
	1015	ty[ i * (q+1) + k ] = y[ i * (k+1) + k];
1018	1016	}
1019	1017	return ok;
1020	1018	}

1024	1022	\copydetails atomic_base::reverse
1025	1023	*/
1026	1024	virtual bool reverse(
1027		size_t p ,
	1025	size_t q ,
1028	1026	const vector<Base>& tx ,
1029	1027	const vector<Base>& ty ,
1030	1028	vector<Base>& px ,
1031	1029	const vector<Base>& py )
1032		{ CPPAD_ASSERT_UNKNOWN( tx.size() % (p+1) == 0 );
1033		CPPAD_ASSERT_UNKNOWN( ty.size() % (p+1) == 0 );
1034		size_t n = tx.size() / (p+1);
1035		size_t m = ty.size() / (p+1);
1036		bool ok = r_(id_, p, n, m, tx, ty, px, py);
	1030	{ CPPAD_ASSERT_UNKNOWN( tx.size() % (q+1) == 0 );
	1031	CPPAD_ASSERT_UNKNOWN( ty.size() % (q+1) == 0 );
	1032	size_t n = tx.size() / (q+1);
	1033	size_t m = ty.size() / (q+1);
	1034	bool ok = r_(id_, q, n, m, tx, ty, px, py);
1037	1035	return ok;
1038	1036	}
1039	1037	/*!

1090	1088	}
1091	1089	};
1092	1090
1093		/! \} /
1094	1091	} // END_CPPAD_NAMESPACE
1095	1092	# endif

-1

cppad/local/op.hpp less more

0		/* $Id: op.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: op.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_OP_INCLUDED
2	2	# define CPPAD_OP_INCLUDED
3	3

30	30	# include <cppad/local/csum_op.hpp>
31	31	# include <cppad/local/discrete_op.hpp>
32	32	# include <cppad/local/div_op.hpp>
	33	# include <cppad/local/erf_op.hpp>
33	34	# include <cppad/local/exp_op.hpp>
34	35	# include <cppad/local/load_op.hpp>
35	36	# include <cppad/local/log_op.hpp>

+525

-309

cppad/local/op_code.hpp less more

0		/* $Id: op_code.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: op_code.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_OP_CODE_INCLUDED
2	2	# define CPPAD_OP_CODE_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

22	22	# include <cppad/thread_alloc.hpp>
23	23
24	24	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
25		/*!
26		\defgroup op_code_hpp op_code.hpp
27		\{
	25	/*!
28	26	\file op_code.hpp
29	27	Defines the OpCode enum type and functions related to it.
30	28

46	44	For example, AddpvOp represents the addition operator where the left
47	45	operand is a parameter and the right operand is a variable.
48	46	*/
	47	// alphabetical order is checked by bin/check_op_code.sh
49	48	enum OpCode {
50	49	AbsOp, // abs(variable)
51	50	AcosOp, // asin(variable)

90	89	DivvpOp, // variable / parameter
91	90	DivvvOp, // variable / variable
92	91	EndOp, // used to mark the end of the tape
	92	ErfOp, // erf(variable)
93	93	ExpOp, // exp(variable)
94	94	InvOp, // independent variable
95	95	LdpOp, // z[parameter]

131	131	// at the end of this list and only at the end of this list.
132	132
133	133	/*!
134		Table containing number of arguments for the corresponding operator.
135
136		The i-th element in this table specifes the number of arguments stored for each
	134	Number of arguments for a specified operator.
	135
	136	\return
	137	Number of arguments corresponding to the specified operator.
	138
	139	\param op
	140	Operator for which we are fetching the number of arugments.
	141
	142	\par NumArgTable
	143	this table specifes the number of arguments stored for each
137	144	occurance of the operator that is the i-th value in the OpCode enum type.
138	145	For example, for the first three OpCode enum values we have
139	146	\verbatim

144	151	\endverbatim
145	152	Note that the meaning of the arguments depends on the operator.
146	153	*/
147		const size_t NumArgTable[] = {
148		1, // AbsOp
149		1, // AcosOp
150		2, // AddpvOp
151		2, // AddvvOp
152		1, // AsinOp
153		1, // AtanOp
154		1, // BeginOp offset first real argument to have index 1
155		6, // CExpOp
156		4, // ComOp
157		1, // CosOp
158		1, // CoshOp
159		0, // CSkipOp (actually has a variable number of arguments, not zero)
160		0, // CSumOp (actually has a variable number of arguments, not zero)
161		2, // DisOp
162		2, // DivpvOp
163		2, // DivvpOp
164		2, // DivvvOp
165		0, // EndOp
166		1, // ExpOp
167		0, // InvOp
168		3, // LdpOp
169		3, // LdvOp
170		1, // LogOp
171		2, // MulpvOp
172		2, // MulvvOp
173		1, // ParOp
174		2, // PowpvOp
175		2, // PowvpOp
176		2, // PowvvOp
177		5, // PriOp
178		1, // SignOp
179		1, // SinOp
180		1, // SinhOp
181		1, // SqrtOp
182		3, // StppOp
183		3, // StpvOp
184		3, // StvpOp
185		3, // StvvOp
186		2, // SubpvOp
187		2, // SubvpOp
188		2, // SubvvOp
189		1, // TanOp
190		1, // TanhOp
191		4, // UserOp
192		1, // UsrapOp
193		1, // UsravOp
194		1, // UsrrpOp
195		0 // UsrrvOp
196		};
197
198		/*!
199		Fetch the number of arguments for a specified operator.
200
201		\return
202		Number of arguments corresponding to the specified operator.
203
204		\param op
205		Operator for which we are fetching the number of arugments.
206
207		- Check that argument taple size equal to NumberOp
208		- Check that \c CPPAD_OP_CODE_TYPE can support all the operator codes.
209		- Check that \c op is a valid operator value.
210		*/
211	154	inline size_t NumArg( OpCode op)
212	155	{ CPPAD_ASSERT_FIRST_CALL_NOT_PARALLEL;
	156
	157	// agreement with OpCode is checked by bin/check_op_code.sh
	158	static const size_t NumArgTable[] = {
	159	1, // AbsOp
	160	1, // AcosOp
	161	2, // AddpvOp
	162	2, // AddvvOp
	163	1, // AsinOp
	164	1, // AtanOp
	165	1, // BeginOp offset first real argument to have index 1
	166	6, // CExpOp
	167	4, // ComOp
	168	1, // CosOp
	169	1, // CoshOp
	170	0, // CSkipOp (actually has a variable number of arguments, not zero)
	171	0, // CSumOp (actually has a variable number of arguments, not zero)
	172	2, // DisOp
	173	2, // DivpvOp
	174	2, // DivvpOp
	175	2, // DivvvOp
	176	0, // EndOp
	177	3, // ErfOp
	178	1, // ExpOp
	179	0, // InvOp
	180	3, // LdpOp
	181	3, // LdvOp
	182	1, // LogOp
	183	2, // MulpvOp
	184	2, // MulvvOp
	185	1, // ParOp
	186	2, // PowpvOp
	187	2, // PowvpOp
	188	2, // PowvvOp
	189	5, // PriOp
	190	1, // SignOp
	191	1, // SinOp
	192	1, // SinhOp
	193	1, // SqrtOp
	194	3, // StppOp
	195	3, // StpvOp
	196	3, // StvpOp
	197	3, // StvvOp
	198	2, // SubpvOp
	199	2, // SubvpOp
	200	2, // SubvvOp
	201	1, // TanOp
	202	1, // TanhOp
	203	4, // UserOp
	204	1, // UsrapOp
	205	1, // UsravOp
	206	1, // UsrrpOp
	207	0 // UsrrvOp
	208	};
213	209	# ifndef NDEBUG
214	210	// only do these checks once to save time
215	211	static bool first = true;

226	222	CPPAD_ASSERT_UNKNOWN( size_t(op) < size_t(NumberOp) );
227	223	# endif
228	224
229		return NumArgTable[(size_t) op];
	225	return NumArgTable[op];
230	226	}
231	227
232	228	/*!
233		Number of variables resulting from the corresponding operation.
234
235		The i-th element in this table specifes the number of varibles for each
	229	Number of variables resulting from the specified operation.
	230
	231	\param op
	232	Operator for which we are fecching the number of results.
	233
	234	\par NumResTable
	235	table specifes the number of varibles that result for each
236	236	occurance of the operator that is the i-th value in the OpCode enum type.
237	237	For example, for the first three OpCode enum values we have
238	238	\verbatim

242	242	AddpvOp 1 1 variable that is the result of the addition
243	243	\endverbatim
244	244	*/
245		// alphabetical order (ignoring the Op at the end)
246		const size_t NumResTable[] = {
247		1, // AbsOp
248		2, // AcosOp
249		1, // AddpvOp
250		1, // AddvvOp
251		2, // AsinOp
252		2, // AtanOp
253		1, // BeginOp offsets first variable to have index one (not zero)
254		1, // CExpOp
255		0, // ComOp
256		2, // CosOp
257		2, // CoshOp
258		0, // CSkipOp
259		1, // CSumOp
260		1, // DisOp
261		1, // DivpvOp
262		1, // DivvpOp
263		1, // DivvvOp
264		0, // EndOp
265		1, // ExpOp
266		1, // InvOp
267		1, // LdpOp
268		1, // LdvOp
269		1, // LogOp
270		1, // MulpvOp
271		1, // MulvvOp
272		1, // ParOp
273		3, // PowpvOp
274		3, // PowvpOp
275		3, // PowvvOp
276		0, // PriOp
277		1, // SignOp
278		2, // SinOp
279		2, // SinhOp
280		1, // SqrtOp
281		0, // StppOp
282		0, // StpvOp
283		0, // StvpOp
284		0, // StvvOp
285		1, // SubpvOp
286		1, // SubvpOp
287		1, // SubvvOp
288		2, // TanOp
289		2, // TanhOp
290		0, // UserOp
291		0, // UsrapOp
292		0, // UsravOp
293		0, // UsrrpOp
294		1, // UsrrvOp
295		0 // Last entry not used: avoids warning by g++ 4.3.2 when pycppad builds
296		};
297
298		/*!
299		Fetch the number of variables resulting from the specified operation.
300
301		\return
302		number of variables resulting from the specified operator.
303
304		\param op
305		Operator for which we are fetching the number of result variables.
306		*/
307	245	inline size_t NumRes(OpCode op)
308		{ // check ensuring conversion to size_t is as expected
	246	{ CPPAD_ASSERT_FIRST_CALL_NOT_PARALLEL;
	247
	248	// agreement with OpCode is checked by bin/check_op_code.sh
	249	static const size_t NumResTable[] = {
	250	1, // AbsOp
	251	2, // AcosOp
	252	1, // AddpvOp
	253	1, // AddvvOp
	254	2, // AsinOp
	255	2, // AtanOp
	256	1, // BeginOp offsets first variable to have index one (not zero)
	257	1, // CExpOp
	258	0, // ComOp
	259	2, // CosOp
	260	2, // CoshOp
	261	0, // CSkipOp
	262	1, // CSumOp
	263	1, // DisOp
	264	1, // DivpvOp
	265	1, // DivvpOp
	266	1, // DivvvOp
	267	0, // EndOp
	268	5, // ErfOp
	269	1, // ExpOp
	270	1, // InvOp
	271	1, // LdpOp
	272	1, // LdvOp
	273	1, // LogOp
	274	1, // MulpvOp
	275	1, // MulvvOp
	276	1, // ParOp
	277	3, // PowpvOp
	278	3, // PowvpOp
	279	3, // PowvvOp
	280	0, // PriOp
	281	1, // SignOp
	282	2, // SinOp
	283	2, // SinhOp
	284	1, // SqrtOp
	285	0, // StppOp
	286	0, // StpvOp
	287	0, // StvpOp
	288	0, // StvvOp
	289	1, // SubpvOp
	290	1, // SubvpOp
	291	1, // SubvvOp
	292	2, // TanOp
	293	2, // TanhOp
	294	0, // UserOp
	295	0, // UsrapOp
	296	0, // UsravOp
	297	0, // UsrrpOp
	298	1, // UsrrvOp
	299	0 // Last entry not used: avoids g++ 4.3.2 warn when pycppad builds
	300	};
	301	// check ensuring conversion to size_t is as expected
309	302	CPPAD_ASSERT_UNKNOWN( size_t(NumberOp) ==
310	303	sizeof(NumResTable) / sizeof(NumResTable[0]) - 1
311	304	);
312	305	// this test ensures that all indices are within the table
313	306	CPPAD_ASSERT_UNKNOWN( size_t(op) < size_t(NumberOp) );
314	307
315		return NumResTable[(size_t) op];
	308	return NumResTable[op];
316	309	}
317	310
	311
318	312	/*!
319		Prints a single field corresponding to an operator.
320
321		A specified leader is printed in front of the value
322		and then the value is left justified in the following width character.
323
324		\tparam Type
325		is the type of the value we are printing.
326
327		\param os
328		is the stream that we are printing to.
329
330		\param leader
331		are characters printed before the value.
332
333		\param value
334		is the value being printed.
335
336		\param width
337		is the number of character to print the value in.
338		If the value does not fit in the width, the value is replace
339		by width '*' characters.
	313	Fetch the name for a specified operation.
	314
	315	\return
	316	name of the specified operation.
	317
	318	\param op
	319	Operator for which we are fetching the name
340	320	*/
341		template <class Type>
342		void printOpField(
343		std::ostream &os ,
344		const char * leader ,
345		const Type &value ,
346		size_t width )
347		{
348		std::ostringstream buffer;
349		std::string str;
350
351		// first print the leader
352		os << leader;
353
354		// print the value into an internal buffer
355		buffer << std::setw(width) << value;
356		str = buffer.str();
357
358		// length of the string
359		size_t len = str.size();
360		if( len > width )
361		{ size_t i;
362		for(i = 0; i < width-1; i++)
363		os << str[i];
364		os << "*";
365		return;
366		}
367
368		// count number of spaces at begining
369		size_t nspace = 0;
370		while(str[nspace] == ' ' && nspace < len)
371		nspace++;
372
373		// left justify the string
374		size_t i = nspace;
375		while( i < len )
376		os << str[i++];
377
378		i = width - len + nspace;
379		while(i--)
380		os << " ";
381		}
382
383		/*!
384		Prints a single operator, its operands, and the corresponding result values.
385
386		\tparam Base
387		Is the base type for these AD< \a Base > operations.
388
389		\tparam Value
390		Determines the type of the values that we are printing.
391
392		\param os
393		is the output stream that the information is printed on.
394
395		\param Rec
396		2DO: change this name from Rec to play (becuase it is a player
397		and not a recorder).
398		Is the entire recording for the tape that this operator is in.
399
400		\param i_op
401		is the index for the operator corresponding to this operation.
402
403		\param i_var
404		is the index for the variable corresponding to the result of this operation
405		(ignored if NumRes(op) == 0).
406
407		\param op
408		The operator code (OpCode) for this operation.
409
410		\param ind
411		is the vector of argument indices for this operation
412		(must have NumArg(op) elements).
413
414		\param nfz
415		is the number of forward sweep calculated values of type Value
416		that correspond to this operation
417		(ignored if NumRes(op) == 0).
418
419		\param fz
420		points to the first forward calculated value
421		that correspond to this operation
422		(ignored if NumRes(op) == 0).
423
424		\param nrz
425		is the number of reverse sweep calculated values of type Value
426		that correspond to this operation
427		(ignored if NumRes(op) == 0).
428
429		\param rz
430		points to the first reverse calculated value
431		that correspond to this operation
432		(ignored if NumRes(op) == 0).
433
434		\par 2DO
435		print the operator index (in addition to the variables index).
436		*/
437		template <class Base, class Value>
438		void printOp(
439		std::ostream &os ,
440		const player<Base> *Rec ,
441		size_t i_op ,
442		size_t i_var ,
443		OpCode op ,
444		const addr_t *ind ,
445		size_t nfz ,
446		const Value *fz ,
447		size_t nrz ,
448		const Value *rz )
449		{ size_t i;
450
451		CPPAD_ASSERT_KNOWN(
452		! thread_alloc::in_parallel() ,
453		"cannot print trace of AD operations in parallel mode"
454		);
455		static const char *CompareOpName[] =
456		{ "Lt", "Le", "Eq", "Ge", "Gt", "Ne" };
457		static const char *OpName[] = {
	321	inline const char* OpName(OpCode op)
	322	{ // agreement with OpCode is checked by bin/check_op_code.sh
	323	static const char *OpNameTable[] = {
458	324	"Abs" ,
459	325	"Acos" ,
460	326	"Addpv" ,

473	339	"Divvp" ,
474	340	"Divvv" ,
475	341	"End" ,
	342	"Erf" ,
476	343	"Exp" ,
477	344	"Inv" ,
478	345	"Ldp" ,

502	369	"Usrap" ,
503	370	"Usrav" ,
504	371	"Usrrp" ,
505		"Usrrv"
	372	"Usrrv"
506	373	};
	374	// check ensuring conversion to size_t is as expected
507	375	CPPAD_ASSERT_UNKNOWN(
508		size_t(NumberOp) == sizeof(OpName) / sizeof(OpName[0])
	376	size_t(NumberOp) == sizeof(OpNameTable)/sizeof(OpNameTable[0])
509	377	);
	378	// this test ensures that all indices are within the table
	379	CPPAD_ASSERT_UNKNOWN( size_t(op) < size_t(NumberOp) );
	380
	381	return OpNameTable[op];
	382	}
	383
	384	/*!
	385	Prints a single field corresponding to an operator.
	386
	387	A specified leader is printed in front of the value
	388	and then the value is left justified in the following width character.
	389
	390	\tparam Type
	391	is the type of the value we are printing.
	392
	393	\param os
	394	is the stream that we are printing to.
	395
	396	\param leader
	397	are characters printed before the value.
	398
	399	\param value
	400	is the value being printed.
	401
	402	\param width
	403	is the number of character to print the value in.
	404	If the value does not fit in the width, the value is replace
	405	by width '*' characters.
	406	*/
	407	template <class Type>
	408	void printOpField(
	409	std::ostream &os ,
	410	const char * leader ,
	411	const Type &value ,
	412	size_t width )
	413	{
	414	std::ostringstream buffer;
	415	std::string str;
	416
	417	// first print the leader
	418	os << leader;
	419
	420	// print the value into an internal buffer
	421	buffer << std::setw(width) << value;
	422	str = buffer.str();
	423
	424	// length of the string
	425	size_t len = str.size();
	426	if( len > width )
	427	{ size_t i;
	428	for(i = 0; i < width-1; i++)
	429	os << str[i];
	430	os << "*";
	431	return;
	432	}
	433
	434	// count number of spaces at begining
	435	size_t nspace = 0;
	436	while(str[nspace] == ' ' && nspace < len)
	437	nspace++;
	438
	439	// left justify the string
	440	size_t i = nspace;
	441	while( i < len )
	442	os << str[i++];
	443
	444	i = width - len + nspace;
	445	while(i--)
	446	os << " ";
	447	}
	448
	449	/*!
	450	Prints a single operator and its operands
	451
	452	\tparam Base
	453	Is the base type for these AD< \a Base > operations.
	454
	455	\param os
	456	is the output stream that the information is printed on.
	457
	458	\param play
	459	Is the entire recording for the tape that this operator is in.
	460
	461	\param i_op
	462	is the index for the operator corresponding to this operation.
	463
	464	\param i_var
	465	is the index for the variable corresponding to the result of this operation
	466	(if NumRes(op) > 0).
	467
	468	\param op
	469	The operator code (OpCode) for this operation.
	470
	471	\param ind
	472	is the vector of argument indices for this operation
	473	(must have NumArg(op) elements).
	474	*/
	475	template <class Base>
	476	void printOp(
	477	std::ostream& os ,
	478	const player<Base>* play ,
	479	size_t i_op ,
	480	size_t i_var ,
	481	OpCode op ,
	482	const addr_t* ind )
	483	{ size_t i;
	484	CPPAD_ASSERT_KNOWN(
	485	! thread_alloc::in_parallel() ,
	486	"cannot print trace of AD operations in parallel mode"
	487	);
	488	static const char *CompareOpName[] =
	489	{ "Lt", "Le", "Eq", "Ge", "Gt", "Ne" };
510	490
511	491	// print operator
512	492	printOpField(os, "o=", i_op, 5);
513		printOpField(os, "v=", i_var, 5);
	493	if( NumRes(op) > 0 && op != BeginOp )
	494	printOpField(os, "v=", i_var, 5);
	495	else printOpField(os, "v=", "", 5);
514	496	if( op == CExpOp \|\| op == CSkipOp \|\| op == ComOp )
515		{ printOpField(os, "", OpName[op], 5);
	497	{ printOpField(os, "", OpName(op), 5);
516	498	printOpField(os, "", CompareOpName[ ind[0] ], 3);
517	499	}
518		else printOpField(os, "", OpName[op], 8);
	500	else printOpField(os, "", OpName(op), 8);
519	501
520	502	// print other fields
521	503	size_t ncol = 5;

538	520	CPPAD_ASSERT_UNKNOWN(ind[1] != 0);
539	521	if( ind[1] & 1 )
540	522	printOpField(os, " vl=", ind[2], ncol);
541		else printOpField(os, " pl=", Rec->GetPar(ind[2]), ncol);
	523	else printOpField(os, " pl=", play->GetPar(ind[2]), ncol);
542	524	if( ind[1] & 2 )
543	525	printOpField(os, " vr=", ind[3], ncol);
544		else printOpField(os, " pr=", Rec->GetPar(ind[3]), ncol);
	526	else printOpField(os, " pr=", play->GetPar(ind[3]), ncol);
545	527	if( size_t(ind[4]) < 3 )
546	528	{ for(i = 0; i < size_t(ind[4]); i++)
547	529	printOpField(os, " ot=", ind[6+i], ncol);

573	555	ind[3+ind[0]+ind[1]] == ind[0] + ind[1]
574	556	*/
575	557	CPPAD_ASSERT_UNKNOWN( ind[3+ind[0]+ind[1]] == ind[0]+ind[1] );
576		printOpField(os, " pr=", Rec->GetPar(ind[2]), ncol);
	558	printOpField(os, " pr=", play->GetPar(ind[2]), ncol);
577	559	for(i = 0; i < size_t(ind[0]); i++)
578	560	printOpField(os, " +v=", ind[3+i], ncol);
579	561	for(i = 0; i < size_t(ind[1]); i++)

596	578	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
597	579	printOpField(os, "off=", ind[0], ncol);
598	580	printOpField(os, "idx=", ind[1], ncol);
599		printOpField(os, " pr=", Rec->GetPar(ind[2]), ncol);
	581	printOpField(os, " pr=", play->GetPar(ind[2]), ncol);
600	582	break;
601	583
602	584	case StpvOp:

610	592	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
611	593	printOpField(os, "off=", ind[0], ncol);
612	594	printOpField(os, " vl=", ind[1], ncol);
613		printOpField(os, " pr=", Rec->GetPar(ind[2]), ncol);
	595	printOpField(os, " pr=", play->GetPar(ind[2]), ncol);
614	596	break;
615	597
616	598	case StvvOp:

636	618	case PowpvOp:
637	619	case DivpvOp:
638	620	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
639		printOpField(os, " pl=", Rec->GetPar(ind[0]), ncol);
	621	printOpField(os, " pl=", play->GetPar(ind[0]), ncol);
640	622	printOpField(os, " vr=", ind[1], ncol);
641	623	break;
642	624

645	627	case SubvpOp:
646	628	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
647	629	printOpField(os, " vl=", ind[0], ncol);
648		printOpField(os, " pr=", Rec->GetPar(ind[1]), ncol);
	630	printOpField(os, " pr=", play->GetPar(ind[1]), ncol);
649	631	break;
650	632
651	633	case AbsOp:

667	649	printOpField(os, " v=", ind[0], ncol);
668	650	break;
669	651
	652	case ErfOp:
	653	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
	654	// ind[2] points to the parameter 0
	655	// ind[3] points to the parameter 2 / sqrt(pi)
	656	printOpField(os, " v=", ind[0], ncol);
	657	break;
	658
670	659	case ParOp:
671	660	case UsrapOp:
672	661	case UsrrpOp:
673	662	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
674		printOpField(os, " p=", Rec->GetPar(ind[0]), ncol);
	663	printOpField(os, " p=", play->GetPar(ind[0]), ncol);
675	664	break;
676	665
677	666	case UserOp:

688	677	CPPAD_ASSERT_NARG_NRES(op, 5, 0);
689	678	if( ind[0] & 1 )
690	679	printOpField(os, " v=", ind[1], ncol);
691		else printOpField(os, " p=", Rec->GetPar(ind[1]), ncol);
692		os << "before=\"" << Rec->GetTxt(ind[2]) << "\"";
	680	else printOpField(os, " p=", play->GetPar(ind[1]), ncol);
	681	os << "before=\"" << play->GetTxt(ind[2]) << "\"";
693	682	if( ind[0] & 2 )
694	683	printOpField(os, " v=", ind[3], ncol);
695		else printOpField(os, " p=", Rec->GetPar(ind[3]), ncol);
696		os << "after=\"" << Rec->GetTxt(ind[4]) << "\"";
	684	else printOpField(os, " p=", play->GetPar(ind[3]), ncol);
	685	os << "after=\"" << play->GetTxt(ind[4]) << "\"";
697	686	break;
698	687
699	688	case BeginOp:
	689	// argument not used (created by independent)
	690	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
	691	break;
	692
700	693	case EndOp:
701	694	case InvOp:
702	695	case UsrrvOp:

717	710	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 6 );
718	711	if( ind[1] & 1 )
719	712	printOpField(os, " vl=", ind[2], ncol);
720		else printOpField(os, " pl=", Rec->GetPar(ind[2]), ncol);
	713	else printOpField(os, " pl=", play->GetPar(ind[2]), ncol);
721	714	if( ind[1] & 2 )
722	715	printOpField(os, " vr=", ind[3], ncol);
723		else printOpField(os, " pr=", Rec->GetPar(ind[3]), ncol);
	716	else printOpField(os, " pr=", play->GetPar(ind[3]), ncol);
724	717	if( ind[1] & 4 )
725	718	printOpField(os, " vt=", ind[4], ncol);
726		else printOpField(os, " pt=", Rec->GetPar(ind[4]), ncol);
	719	else printOpField(os, " pt=", play->GetPar(ind[4]), ncol);
727	720	if( ind[1] & 8 )
728	721	printOpField(os, " vf=", ind[5], ncol);
729		else printOpField(os, " pf=", Rec->GetPar(ind[5]), ncol);
	722	else printOpField(os, " pf=", play->GetPar(ind[5]), ncol);
730	723	break;
731	724
732	725	case ComOp:

737	730	else printOpField(os, "res=", 0, ncol);
738	731	if( ind[1] & 2 )
739	732	printOpField(os, " vl=", ind[2], ncol);
740		else printOpField(os, " pl=", Rec->GetPar(ind[2]), ncol);
	733	else printOpField(os, " pl=", play->GetPar(ind[2]), ncol);
741	734	if( ind[1] & 4 )
742	735	printOpField(os, " vr=", ind[3], ncol);
743		else printOpField(os, " pr=", Rec->GetPar(ind[3]), ncol);
	736	else printOpField(os, " pr=", play->GetPar(ind[3]), ncol);
744	737	break;
745	738
746	739	default:
747	740	CPPAD_ASSERT_UNKNOWN(0);
748	741	}
	742	}
	743
	744	/*!
	745	Prints the result values correspnding to an operator.
	746
	747	\tparam Base
	748	Is the base type for these AD< \a Base > operations.
	749
	750	\tparam Value
	751	Determines the type of the values that we are printing.
	752
	753	\param os
	754	is the output stream that the information is printed on.
	755
	756	\param nfz
	757	is the number of forward sweep calculated values of type Value
	758	that correspond to this operation
	759	(ignored if NumRes(op) == 0).
	760
	761	\param fz
	762	points to the first forward calculated value
	763	that correspond to this operation
	764	(ignored if NumRes(op) == 0).
	765
	766	\param nrz
	767	is the number of reverse sweep calculated values of type Value
	768	that correspond to this operation
	769	(ignored if NumRes(op) == 0).
	770
	771	\param rz
	772	points to the first reverse calculated value
	773	that correspond to this operation
	774	(ignored if NumRes(op) == 0).
	775	*/
	776	template <class Value>
	777	void printOpResult(
	778	std::ostream &os ,
	779	size_t nfz ,
	780	const Value *fz ,
	781	size_t nrz ,
	782	const Value *rz )
	783	{
749	784	size_t k;
750		if( NumRes(op) > 0 && (op != BeginOp) )
751		{
752		for(k = 0; k < nfz; k++)
753		std::cout << "\| fz[" << k << "]=" << fz[k];
754		for(k = 0; k < nrz; k++)
755		std::cout << "\| rz[" << k << "]=" << rz[k];
	785	for(k = 0; k < nfz; k++)
	786	os << "\| fz[" << k << "]=" << fz[k];
	787	for(k = 0; k < nrz; k++)
	788	os << "\| rz[" << k << "]=" << rz[k];
	789	}
	790
	791	/*!
	792	If NDEBUG is not defined, assert that arguments come before result.
	793
	794	\param op
	795	Operator for which we are checking order.
	796	All the operators are checked except for those of the form UserOp or Usr..Op.
	797
	798	\param result
	799	is the variable index for the result.
	800
	801	\param arg
	802	is a vector of lenght NumArg(op) pointing to the arguments
	803	for this operation.
	804	*/
	805	inline void assert_arg_before_result(
	806	OpCode op, const addr_t* arg, size_t result
	807	)
	808	{
	809	switch( op )
	810	{
	811
	812	// These cases are not included below
	813	case UserOp:
	814	case UsrapOp:
	815	case UsravOp:
	816	case UsrrpOp:
	817	case UsrrvOp:
	818	break;
	819	// ------------------------------------------------------------------
	820
	821	// 0 arguments
	822	case CSkipOp:
	823	case CSumOp:
	824	case EndOp:
	825	case InvOp:
	826	break;
	827	// ------------------------------------------------------------------
	828
	829	// 1 argument, but is not used
	830	case BeginOp:
	831	break;
	832
	833	// 1 argument , 1 result
	834	case AbsOp:
	835	case ExpOp:
	836	case LogOp:
	837	case ParOp:
	838	case SignOp:
	839	case SqrtOp:
	840	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < result );
	841	break;
	842
	843	// 1 argument, 2 results
	844	case AcosOp:
	845	case AsinOp:
	846	case AtanOp:
	847	case CosOp:
	848	case CoshOp:
	849	case SinOp:
	850	case SinhOp:
	851	case TanOp:
	852	case TanhOp:
	853	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) + 1 < result );
	854	break;
	855
	856	// 1 argument, 5 results
	857	case ErfOp:
	858	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) + 4 < result );
	859	break;
	860	// ------------------------------------------------------------------
	861
	862	// 2 arguments (both variables), 1 results
	863	case AddvvOp:
	864	case DivvvOp:
	865	case MulvvOp:
	866	case SubvvOp:
	867	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < result );
	868	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < result );
	869	break;
	870
	871	// 2 arguments (first variables), 1 results
	872	case DivvpOp:
	873	case SubvpOp:
	874	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < result );
	875	break;
	876
	877	// 2 arguments (second variables), 1 results
	878	case AddpvOp:
	879	case DisOp:
	880	case DivpvOp:
	881	case MulpvOp:
	882	case SubpvOp:
	883	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < result );
	884	break;
	885
	886	// 2 arguments (both variables), 3 results
	887	case PowvvOp:
	888	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) + 2 < result );
	889	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) + 2 < result );
	890	break;
	891
	892	// 2 arguments (first variable), 3 results
	893	case PowvpOp:
	894	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) + 2 < result );
	895	break;
	896
	897	// 2 arguments (second variable), 3 results
	898	case PowpvOp:
	899	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) + 2 < result );
	900	break;
	901	// ------------------------------------------------------------------
	902
	903	// 3 arguments, none variables
	904	case LdpOp:
	905	case StppOp:
	906	break;
	907
	908	// 3 arguments, second variable, 1 result
	909	case LdvOp:
	910	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < result );
	911	break;
	912
	913	// 3 arguments, third variable, no result
	914	case StpvOp:
	915	CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= result );
	916	break;
	917
	918	// 3 arguments, second variable, no result
	919	case StvpOp:
	920	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
	921	break;
	922
	923	// 3 arguments, second and third variable, no result
	924	case StvvOp:
	925	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
	926	CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= result );
	927	break;
	928	// ------------------------------------------------------------------
	929
	930	// 4 arguments, no result
	931	case ComOp:
	932	if( arg[1] & 2 )
	933	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= result );
	934	}
	935	if( arg[1] & 4 )
	936	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= result );
	937	}
	938	break;
	939	// ------------------------------------------------------------------
	940
	941	// 5 arguments, no result
	942	case PriOp:
	943	if( arg[0] & 1 )
	944	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= result );
	945	}
	946	if( arg[0] & 2 )
	947	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= result );
	948	}
	949	break;
	950	// ------------------------------------------------------------------
	951
	952	// 6 arguments, 1 result
	953	case CExpOp:
	954	if( arg[1] & 1 )
	955	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < result );
	956	}
	957	if( arg[1] & 2 )
	958	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < result );
	959	}
	960	if( arg[1] & 4 )
	961	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[4]) < result );
	962	}
	963	if( arg[1] & 8 )
	964	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[5]) < result );
	965	}
	966	break;
	967	// ------------------------------------------------------------------
	968
	969	default:
	970	CPPAD_ASSERT_UNKNOWN(false);
	971	break;
	972
756	973	}
757		std::cout << std::endl;
	974	return;
758	975	}
759	976
760		/! \} /
761	977	} // END_CPPAD_NAMESPACE
762	978	# endif

-5

cppad/local/opt_val_hes.hpp less more

0		/* $Id: opt_val_hes.hpp 2936 2013-10-13 11:44:13Z bradbell $ */
	0	/* $Id: opt_val_hes.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_OPT_VAL_HES_INCLUDED
2	2	# define CPPAD_OPT_VAL_HES_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

239	239
240	240	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
241	241	/*!
242		\defgroup opt_val_hes_hpp opt_val_hes.hpp
243		\{
244	242	\file opt_val_hes.hpp
245	243	\brief Computing Jabobians and Hessians of Optimal Values
246	244	*/

525	523	return signdet;
526	524	}
527	525
528		/! \} /
529	526	} // END_CPPAD_NAMESPACE
530	527
531	528	# endif

+233

-137

cppad/local/optimize.hpp less more

0		/* $Id: optimize.hpp 3085 2014-01-20 22:53:15Z bradbell $ */
	0	/* $Id: optimize.hpp 3507 2014-12-27 16:30:12Z bradbell $ */
1	1	# ifndef CPPAD_OPTIMIZE_INCLUDED
2	2	# define CPPAD_OPTIMIZE_INCLUDED
3	3

63	63	$subhead Testing$$
64	64	You can run the CppAD $cref/speed/speed_main/$$ tests and see
65	65	the corresponding changes in number of variables and execution time;
66		see $cref cppad_test$$.
	66	see $cref cmake_check$$.
67	67
68	68	$head Efficiency$$
69	69	The $code optimize$$ member function
70	70	may greatly reduce the number of variables
71	71	in the operation sequence; see $cref/size_var/seq_property/size_var/$$.
72		If a $cref/zero order forward/ForwardZero/$$ calculation is done during
	72	If a $cref/zero order forward/forward_zero/$$ calculation is done during
73	73	the construction of $icode f$$, it will require more memory
74	74	and time than required after the optimization procedure.
75	75	In addition, it will need to be redone.

113	113	$head Checking Optimization$$
114	114	$index NDEBUG$$
115	115	If $cref/NDEBUG/Faq/Speed/NDEBUG/$$ is not defined,
116		and $cref/f.size_taylor()/size_taylor/$$ is greater than zero,
117		a $cref ForwardZero$$ calculation is done using the optimized version
	116	and $cref/f.size_order()/size_order/$$ is greater than zero,
	117	a $cref forward_zero$$ calculation is done using the optimized version
118	118	of $icode f$$ and the results are checked to see that they are
119	119	the same as before.
120	120	If they are not the same, the

138	138	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
139	139	namespace optimize { // BEGIN_CPPAD_OPTIMIZE_NAMESPACE
140	140	/*!
141		\defgroup optimize_hpp optimize.hpp
142		\{
143	141	\file optimize.hpp
144	142	Routines for optimizing a tape
145	143	*/

259	257	/// New operator index for this varable.
260	258	/// Set during forward sweep to the index in the new tape
261	259	size_t new_op;
	260
	261	/// Did this variable match another variable in the operation sequence
	262	bool match;
262	263	};
263	264
264	265	struct struct_size_pair {

471	472	If the return value is zero,
472	473	no match was found.
473	474	If the return value is greater than zero,
474		it is the index of a new variable that can be used to replace the
475		old variable.
	475	it is the old operation sequence index of a variable,
	476	that comes before current and can be used to replace the current variable.
476	477
477	478	\par Restrictions:
478	479	NumArg( tape[current].op ) == 1
479	480	*/
480	481	template <class Base>
481		size_t unary_match(
	482	addr_t unary_match(
482	483	const CppAD::vector<struct struct_old_variable>& tape ,
483	484	size_t current ,
484	485	size_t npar ,

500	501	npar ,
501	502	par
502	503	);
503		size_t i = hash_table_var[code];
504		CPPAD_ASSERT_UNKNOWN( i < current );
505		if( op == tape[i].op )
506		{ size_t k = tape[i].arg[0];
507		CPPAD_ASSERT_UNKNOWN( k < i );
	504	size_t i_var = hash_table_var[code];
	505	CPPAD_ASSERT_UNKNOWN( i_var < current );
	506	if( op == tape[i_var].op )
	507	{ size_t k = tape[i_var].arg[0];
	508	CPPAD_ASSERT_UNKNOWN( k < i_var );
508	509	if (new_arg[0] == tape[k].new_var )
509		return tape[i].new_var;
	510	return i_var;
510	511	}
511	512	return 0;
512	513	}

585	586	or power operator. NumArg( tape[current].op ) == 1.
586	587	*/
587	588	template <class Base>
588		inline size_t binary_match(
589		const CppAD::vector<struct struct_old_variable>& tape ,
	589	inline addr_t binary_match(
	590	const CppAD::vector<struct struct_old_variable>& tape ,
590	591	size_t current ,
591	592	size_t npar ,
592	593	const Base* par ,

598	599	bool parameter[2];
599	600
600	601	// initialize return value
601		size_t match_var = 0;
	602	addr_t match_var = 0;
602	603
603	604	CPPAD_ASSERT_UNKNOWN( NumArg(op) == 2 );
604	605	CPPAD_ASSERT_UNKNOWN( NumRes(op) > 0 );
605	606	switch(op)
606		{ // parameter op variable ----------------------------------
	607	{ // index op variable
	608	case DisOp:
	609	// parameter not defined for this case
	610	CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < current );
	611	new_arg[0] = arg[0];
	612	new_arg[1] = tape[arg[1]].new_var;
	613	break;
	614
	615	// parameter op variable ----------------------------------
607	616	case AddpvOp:
608	617	case MulpvOp:
609	618	case DivpvOp:

659	668	npar ,
660	669	par
661	670	);
662		size_t i = hash_table_var[code];
663		CPPAD_ASSERT_UNKNOWN( i < current );
664		if( op == tape[i].op )
	671	size_t i_var = hash_table_var[code];
	672	CPPAD_ASSERT_UNKNOWN( i_var < current );
	673	if( op == tape[i_var].op )
665	674	{ bool match = true;
666		size_t j;
667		for(j = 0; j < 2; j++)
668		{ size_t k = tape[i].arg[j];
669		if( parameter[j] )
670		{ CPPAD_ASSERT_UNKNOWN( k < npar );
671		match &= IdenticalEqualPar(
672		par[ arg[j] ], par[k]
673		);
674		}
675		else
676		{ CPPAD_ASSERT_UNKNOWN( k < i );
677		match &= (new_arg[j] == tape[k].new_var);
	675	if( op == DisOp )
	676	{ match &= new_arg[0] == tape[i_var].arg[0];
	677	size_t k = tape[i_var].arg[1];
	678	match &= new_arg[1] == tape[k].new_var;
	679	}
	680	else
	681	{ for(size_t j = 0; j < 2; j++)
	682	{ size_t k = tape[i_var].arg[j];
	683	if( parameter[j] )
	684	{ CPPAD_ASSERT_UNKNOWN( k < npar );
	685	match &= IdenticalEqualPar(
	686	par[ arg[j] ], par[k]
	687	);
	688	}
	689	else
	690	{ CPPAD_ASSERT_UNKNOWN( k < i_var );
	691	match &= (new_arg[j] == tape[k].new_var);
	692	}
678	693	}
679	694	}
680	695	if( match )
681		match_var = tape[i].new_var;
	696	match_var = i_var;
682	697	}
683	698	if( (match_var > 0) \| ( (op != AddvvOp) & (op != MulvvOp ) ) )
684	699	return match_var;
685	700
686	701	// check for match with argument order switched ----------------------
687	702	CPPAD_ASSERT_UNKNOWN( op == AddvvOp \|\| op == MulvvOp );
688		i = new_arg[0];
689		new_arg[0] = new_arg[1];
690		new_arg[1] = i;
	703	std::swap(new_arg[0], new_arg[1]);
691	704	unsigned short code_switch = hash_code(
692	705	op ,
693	706	new_arg ,
694	707	npar ,
695	708	par
696	709	);
697		i = hash_table_var[code_switch];
698		CPPAD_ASSERT_UNKNOWN( i < current );
699		if( op == tape[i].op )
	710	i_var = hash_table_var[code_switch];
	711	CPPAD_ASSERT_UNKNOWN( i_var < current );
	712	if( op == tape[i_var].op )
700	713	{ bool match = true;
701	714	size_t j;
702	715	for(j = 0; j < 2; j++)
703		{ size_t k = tape[i].arg[j];
704		CPPAD_ASSERT_UNKNOWN( k < i );
	716	{ size_t k = tape[i_var].arg[j];
	717	CPPAD_ASSERT_UNKNOWN( k < i_var );
705	718	match &= (new_arg[j] == tape[k].new_var);
706	719	}
707	720	if( match )
708		match_var = tape[i].new_var;
	721	match_var = i_var;
709	722	}
710	723	return match_var;
711	724	}

805	818	rec->PutArg( new_arg[0], new_arg[1] );
806	819
807	820	struct_size_pair ret;
808		ret.i_op = rec->num_rec_op();
	821	ret.i_op = rec->num_op_rec();
809	822	ret.i_var = rec->PutOp(op);
810	823	CPPAD_ASSERT_UNKNOWN( size_t(new_arg[0]) < ret.i_var );
811	824	return ret;

905	918	rec->PutArg( new_arg[0], new_arg[1] );
906	919
907	920	struct_size_pair ret;
908		ret.i_op = rec->num_rec_op();
	921	ret.i_op = rec->num_op_rec();
909	922	ret.i_var = rec->PutOp(op);
910	923	CPPAD_ASSERT_UNKNOWN( size_t(new_arg[0]) < ret.i_var );
911	924	return ret;

1006	1019	rec->PutArg( new_arg[0], new_arg[1] );
1007	1020
1008	1021	struct_size_pair ret;
1009		ret.i_op = rec->num_rec_op();
	1022	ret.i_op = rec->num_op_rec();
1010	1023	ret.i_var = rec->PutOp(op);
1011	1024	CPPAD_ASSERT_UNKNOWN( size_t(new_arg[0]) < ret.i_var );
1012	1025	CPPAD_ASSERT_UNKNOWN( size_t(new_arg[1]) < ret.i_var );

1238	1251
1239	1252
1240	1253	struct_size_pair ret;
1241		ret.i_op = rec->num_rec_op();
	1254	ret.i_op = rec->num_op_rec();
1242	1255	ret.i_var = rec->PutOp(CSumOp);
1243	1256	CPPAD_ASSERT_UNKNOWN( new_arg < ret.i_var );
1244	1257	return ret;

1291	1304	size_t m = dep_taddr.size();
1292	1305
1293	1306	// number of variables in the player
1294		const size_t num_var = play->num_rec_var();
	1307	const size_t num_var = play->num_var_rec();
1295	1308
1296	1309	# ifndef NDEBUG
1297	1310	// number of parameters in the player
1298		const size_t num_par = play->num_rec_par();
	1311	const size_t num_par = play->num_par_rec();
1299	1312	# endif
1300	1313
1301	1314	// number of VecAD indices
1302		size_t num_vecad_ind = play->num_rec_vecad_ind();
	1315	size_t num_vecad_ind = play->num_vec_ind_rec();
1303	1316
1304	1317	// number of VecAD vectors
1305		size_t num_vecad_vec = play->num_rec_vecad_vec();
	1318	size_t num_vecad_vec = play->num_vecad_vec_rec();
1306	1319
1307	1320	// -------------------------------------------------------------
1308	1321	// data structure that maps variable index in original operation

1370	1383
1371	1384	// Initialize a reverse mode sweep through the operation sequence
1372	1385	size_t i_op;
1373		play->start_reverse(op, arg, i_op, i_var);
	1386	play->reverse_start(op, arg, i_op, i_var);
1374	1387	CPPAD_ASSERT_UNKNOWN( op == EndOp );
1375	1388	size_t mask;
1376	1389	user_state = user_end;
1377	1390	while(op != BeginOp)
1378	1391	{ // next op
1379		play->next_reverse(op, arg, i_op, i_var);
	1392	play->reverse_next(op, arg, i_op, i_var);
1380	1393
1381	1394	// Store the operator corresponding to each variable
1382	1395	if( NumRes(op) > 0 )

1393	1406	std::set<class_cexp_pair>& cexp_set = tape[i_var].cexp_set;
1394	1407	switch( op )
1395	1408	{
1396		// Unary operator where operand is arg[0]
	1409	// One variable corresponding to arg[0]
1397	1410	case AbsOp:
1398	1411	case AcosOp:
1399	1412	case AsinOp:

1440	1453	}
1441	1454	break; // --------------------------------------------
1442	1455
1443		// Unary operator where operand is arg[1]
	1456	// One variable corresponding to arg[1]
1444	1457	case DisOp:
1445	1458	case DivpvOp:
1446	1459	case MulpvOp:

1638	1651	info.right = arg[3];
1639	1652	info.n_op_true = 0;
1640	1653	info.n_op_false = 0;
	1654	info.i_arg = 0; // case where no CSkipOp for this CExpOp
1641	1655	//
1642	1656	size_t index = 0;
1643	1657	if( arg[1] & 1 )

1655	1669	cskip_info.push_back(info);
1656	1670	//
1657	1671	if( arg[1] & 4 )
1658		{ tape[arg[4]].connect_type = cexp_connected;
1659		tape[arg[4]].cexp_set = cexp_set;
1660		tape[arg[4]].cexp_set.insert(
1661		class_cexp_pair(true, index)
1662		);
	1672	{ if( tape[arg[4]].connect_type == not_connected )
	1673	{ tape[arg[4]].connect_type = cexp_connected;
	1674	tape[arg[4]].cexp_set = cexp_set;
	1675	tape[arg[4]].cexp_set.insert(
	1676	class_cexp_pair(true, index)
	1677	);
	1678	}
	1679	else
	1680	{ // if arg[4] is cexp_connected, it could be
	1681	// connected for both the true and false case
	1682	// 2DO: if previously cexp_connected
	1683	// and the true/false sense is the same, should
	1684	// keep this conditional connnection.
	1685	tape[arg[4]].cexp_set.clear();
	1686	tape[arg[4]].connect_type = yes_connected;
	1687	}
1663	1688	}
1664	1689	if( arg[1] & 8 )
1665		{ tape[arg[5]].connect_type = cexp_connected;
1666		tape[arg[5]].cexp_set = cexp_set;
1667		tape[arg[5]].cexp_set.insert(
1668		class_cexp_pair(false, index)
1669		);
	1690	{ if( tape[arg[5]].connect_type == not_connected )
	1691	{ tape[arg[5]].connect_type = cexp_connected;
	1692	tape[arg[5]].cexp_set = cexp_set;
	1693	tape[arg[5]].cexp_set.insert(
	1694	class_cexp_pair(false, index)
	1695	);
	1696	}
	1697	else
	1698	{ tape[arg[5]].cexp_set.clear();
	1699	tape[arg[5]].connect_type = yes_connected;
	1700	}
1670	1701	}
1671	1702	}
1672	1703	break; // --------------------------------------------
1673	1704
1674		// Operations where there is noting to do
	1705	// Operations where there is nothing to do
1675	1706	case ComOp:
1676	1707	case EndOp:
1677	1708	case ParOp:

1833	1864	user_info[user_curr].connect_type = yes_connected;
1834	1865	}
1835	1866	else user_info[user_curr].connect_type = yes_connected;
	1867	user_r_set[user_i].insert(0);
	1868	user_r_bool[user_i] = true;
1836	1869	break;
1837	1870
1838	1871	default:

1879	1912	"Optimizing an ADFun object"
1880	1913	" that contains the atomic function\n\t";
1881	1914	s += user_atom->afun_name();
1882		s += "\nCurrent atomoic_sparsity is set to";
	1915	s += "\nCurrent atomic_sparsity is set to";
1883	1916	//
1884	1917	if( user_set )
1885	1918	s += " std::set\nand std::set";

1944	1977	keys[i] = std::max( cskip_info[i].left, cskip_info[i].right );
1945	1978	CppAD::index_sort(keys, cskip_info_order);
1946	1979	}
1947		size_t cskip_info_next = 0;
	1980	// index in sorted order
	1981	size_t cskip_order_next = 0;
	1982	// index in order during reverse sweep
	1983	size_t cskip_info_index = cskip_info.size();
1948	1984
1949	1985
1950	1986	// Initilaize table mapping hash code to variable index in tape

1990	2026	CPPAD_ASSERT_UNKNOWN( j == num_vecad_ind );
1991	2027
1992	2028	// start playing the operations in the forward direction
1993		play->start_forward(op, arg, i_op, i_var);
	2029	play->forward_start(op, arg, i_op, i_var);
1994	2030	CPPAD_ASSERT_UNKNOWN( user_curr == user_info.size() );
1995	2031
1996	2032	// playing forward skips BeginOp at the beginning, but not EndOp at
1997	2033	// the end. Put BeginOp at beginning of recording
1998	2034	CPPAD_ASSERT_UNKNOWN( op == BeginOp );
1999	2035	CPPAD_ASSERT_NARG_NRES(BeginOp, 1, 1);
2000		tape[i_var].new_op = rec->num_rec_op();
	2036	tape[i_var].new_op = rec->num_op_rec();
2001	2037	tape[i_var].new_var = rec->PutOp(BeginOp);
2002	2038	rec->PutArg(0);
2003	2039

2015	2051	user_state = user_start;
2016	2052	while(op != EndOp)
2017	2053	{ // next op
2018		play->next_forward(op, arg, i_op, i_var);
	2054	play->forward_next(op, arg, i_op, i_var);
2019	2055	CPPAD_ASSERT_UNKNOWN( (i_op > n) \| (op == InvOp) );
2020	2056	CPPAD_ASSERT_UNKNOWN( (i_op <= n) \| (op != InvOp) );
2021	2057
2022	2058	// determine if we should insert a conditional skip here
2023		bool skip = cskip_info_next < cskip_info.size();
2024		skip &= (op != BeginOp) & (op != InvOp);
	2059	bool skip = cskip_order_next < cskip_info.size();
	2060	skip &= op != BeginOp;
	2061	skip &= op != InvOp;
	2062	skip &= user_state == user_start;
2025	2063	if( skip )
2026		{ j = cskip_info_order[cskip_info_next];
	2064	{ j = cskip_info_order[cskip_order_next];
2027	2065	if( NumRes(op) > 0 )
2028	2066	skip &= cskip_info[j].max_left_right < i_var;
2029	2067	else
2030	2068	skip &= cskip_info[j].max_left_right <= i_var;
2031	2069	}
2032	2070	if( skip )
2033		{ cskip_info_next++;
2034		skip &= cskip_info[j].skip_var_true.size() > 0 \|\|
2035		cskip_info[j].skip_var_false.size() > 0;
	2071	{ cskip_order_next++;
	2072	struct_cskip_info info = cskip_info[j];
	2073	size_t n_true = info.skip_var_true.size() + info.n_op_true;
	2074	size_t n_false = info.skip_var_false.size() + info.n_op_false;
	2075	skip &= n_true > 0 \|\| n_false > 0;
2036	2076	if( skip )
2037		{ struct_cskip_info info = cskip_info[j];
2038		CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
2039		size_t n_true =
2040		info.skip_var_true.size() + info.n_op_true;
2041		size_t n_false =
2042		info.skip_var_false.size() + info.n_op_false;
	2077	{ CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
2043	2078	size_t n_arg = 7 + n_true + n_false;
2044	2079	// reserve space for the arguments to this operator but
2045	2080	// delay setting them until we have all the new addresses

2047	2082	CPPAD_ASSERT_UNKNOWN( cskip_info[j].i_arg > 0 );
2048	2083	rec->PutOp(CSkipOp);
2049	2084	}
2050		else cskip_info[j].i_arg = 0;
2051	2085	}
2052	2086
2053	2087	// determine if we should keep this operation in the new

2095	2129	break;
2096	2130	}
2097	2131
2098		size_t match_var = 0;
2099	2132	unsigned short code = 0;
2100	2133	bool replace_hash = false;
	2134	addr_t match_var;
	2135	tape[i_var].match = false;
2101	2136	if( keep ) switch( op )
2102	2137	{
2103	2138	// Unary operator where operand is arg[0]

2118	2153	match_var = unary_match(
2119	2154	tape , // inputs
2120	2155	i_var ,
2121		play->num_rec_par() ,
	2156	play->num_par_rec() ,
2122	2157	play->GetPar() ,
2123	2158	hash_table_var ,
2124	2159	code // outputs
2125	2160	);
2126	2161	if( match_var > 0 )
2127		tape[i_var].new_var = match_var;
	2162	{ tape[i_var].match = true;
	2163	tape[match_var].match = true;
	2164	tape[i_var].new_var = tape[match_var].new_var;
	2165	}
2128	2166	else
2129	2167	{
2130	2168	replace_hash = true;
2131	2169	new_arg[0] = tape[ arg[0] ].new_var;
2132	2170	rec->PutArg( new_arg[0] );
2133		tape[i_var].new_op = rec->num_rec_op();
	2171	tape[i_var].new_op = rec->num_op_rec();
2134	2172	tape[i_var].new_var = i = rec->PutOp(op);
2135	2173	CPPAD_ASSERT_UNKNOWN( size_t(new_arg[0]) < i );
2136	2174	}

2145	2183	size_pair = record_csum(
2146	2184	tape , // inputs
2147	2185	i_var ,
2148		play->num_rec_par() ,
	2186	play->num_par_rec() ,
2149	2187	play->GetPar() ,
2150	2188	rec ,
2151	2189	csum_work

2160	2198	match_var = binary_match(
2161	2199	tape , // inputs
2162	2200	i_var ,
2163		play->num_rec_par() ,
	2201	play->num_par_rec() ,
2164	2202	play->GetPar() ,
2165	2203	hash_table_var ,
2166	2204	code // outputs
2167	2205	);
2168	2206	if( match_var > 0 )
2169		tape[i_var].new_var = match_var;
	2207	{ tape[i_var].match = true;
	2208	tape[match_var].match = true;
	2209	tape[i_var].new_var = tape[match_var].new_var;
	2210	}
2170	2211	else
2171	2212	{ size_pair = record_vp(
2172	2213	tape , // inputs
2173	2214	i_var ,
2174		play->num_rec_par() ,
	2215	play->num_par_rec() ,
2175	2216	play->GetPar() ,
2176	2217	rec ,
2177	2218	op ,

2182	2223	replace_hash = true;
2183	2224	}
2184	2225	break;
	2226	// ---------------------------------------------------
	2227	// Binary operators where
	2228	// left is an index and right is a variable
	2229	case DisOp:
	2230	match_var = binary_match(
	2231	tape , // inputs
	2232	i_var ,
	2233	play->num_par_rec() ,
	2234	play->GetPar() ,
	2235	hash_table_var ,
	2236	code // outputs
	2237	);
	2238	if( match_var > 0 )
	2239	{ tape[i_var].match = true;
	2240	tape[match_var].match = true;
	2241	tape[i_var].new_var = tape[match_var].new_var;
	2242	}
	2243	else
	2244	{ new_arg[0] = arg[0];
	2245	new_arg[1] = tape[ arg[1] ].new_var;
	2246	rec->PutArg( new_arg[0], new_arg[1] );
	2247	tape[i_var].new_op = rec->num_op_rec();
	2248	tape[i_var].new_var = rec->PutOp(op);
	2249	CPPAD_ASSERT_UNKNOWN(
	2250	size_t(new_arg[1]) < tape[i_var].new_var
	2251	);
	2252	replace_hash = true;
	2253	}
	2254	break;
	2255
2185	2256	// ---------------------------------------------------
2186	2257	// Binary operators where
2187	2258	// left is a parameter and right is a variable

2193	2264	size_pair = record_csum(
2194	2265	tape , // inputs
2195	2266	i_var ,
2196		play->num_rec_par() ,
	2267	play->num_par_rec() ,
2197	2268	play->GetPar() ,
2198	2269	rec ,
2199	2270	csum_work

2209	2280	match_var = binary_match(
2210	2281	tape , // inputs
2211	2282	i_var ,
2212		play->num_rec_par() ,
	2283	play->num_par_rec() ,
2213	2284	play->GetPar() ,
2214	2285	hash_table_var ,
2215	2286	code // outputs
2216	2287	);
2217	2288	if( match_var > 0 )
2218		tape[i_var].new_var = match_var;
	2289	{ tape[i_var].match = true;
	2290	tape[match_var].match = true;
	2291	tape[i_var].new_var = tape[match_var].new_var;
	2292	}
2219	2293	else
2220	2294	{ size_pair = record_pv(
2221	2295	tape , // inputs
2222	2296	i_var ,
2223		play->num_rec_par() ,
	2297	play->num_par_rec() ,
2224	2298	play->GetPar() ,
2225	2299	rec ,
2226	2300	op ,

2244	2318	size_pair = record_csum(
2245	2319	tape , // inputs
2246	2320	i_var ,
2247		play->num_rec_par() ,
	2321	play->num_par_rec() ,
2248	2322	play->GetPar() ,
2249	2323	rec ,
2250	2324	csum_work

2260	2334	match_var = binary_match(
2261	2335	tape , // inputs
2262	2336	i_var ,
2263		play->num_rec_par() ,
	2337	play->num_par_rec() ,
2264	2338	play->GetPar() ,
2265	2339	hash_table_var ,
2266	2340	code // outputs
2267	2341	);
2268	2342	if( match_var > 0 )
2269		tape[i_var].new_var = match_var;
	2343	{ tape[i_var].match = true;
	2344	tape[match_var].match = true;
	2345	tape[i_var].new_var = tape[match_var].new_var;
	2346	}
2270	2347	else
2271	2348	{ size_pair = record_vv(
2272	2349	tape , // inputs
2273	2350	i_var ,
2274		play->num_rec_par() ,
	2351	play->num_par_rec() ,
2275	2352	play->GetPar() ,
2276	2353	rec ,
2277	2354	op ,

2309	2386	new_arg[4] ,
2310	2387	new_arg[5]
2311	2388	);
2312		tape[i_var].new_op = rec->num_rec_op();
	2389	tape[i_var].new_op = rec->num_op_rec();
2313	2390	tape[i_var].new_var = rec->PutOp(op);
	2391	//
	2392	// The new addresses for left and right are used during
	2393	// fill in the arguments for the CSkip operations. This does not
	2394	// affect max_left_right which is used during this sweep.
	2395	CPPAD_ASSERT_UNKNOWN( cskip_info_index > 0 );
	2396	cskip_info_index--;
	2397	cskip_info[ cskip_info_index ].left = new_arg[2];
	2398	cskip_info[ cskip_info_index ].right = new_arg[3];
2314	2399	break;
2315	2400	// ---------------------------------------------------
2316	2401	// Operations with no arguments and no results

2322	2407	// Operations with no arguments and one result
2323	2408	case InvOp:
2324	2409	CPPAD_ASSERT_NARG_NRES(op, 0, 1);
2325		tape[i_var].new_op = rec->num_rec_op();
	2410	tape[i_var].new_op = rec->num_op_rec();
2326	2411	tape[i_var].new_var = rec->PutOp(op);
2327	2412	break;
2328	2413	// ---------------------------------------------------

2332	2417	new_arg[0] = rec->PutPar( play->GetPar(arg[0] ) );
2333	2418
2334	2419	rec->PutArg( new_arg[0] );
2335		tape[i_var].new_op = rec->num_rec_op();
	2420	tape[i_var].new_op = rec->num_op_rec();
2336	2421	tape[i_var].new_var = rec->PutOp(op);
2337	2422	break;
2338	2423	// ---------------------------------------------------

2341	2426	CPPAD_ASSERT_NARG_NRES(op, 3, 1);
2342	2427	new_arg[0] = new_vecad_ind[ arg[0] ];
2343	2428	new_arg[1] = arg[1];
	2429	new_arg[2] = rec->num_load_op_rec();
2344	2430	CPPAD_ASSERT_UNKNOWN( size_t(new_arg[0]) < num_vecad_ind );
2345	2431	rec->PutArg(
2346	2432	new_arg[0],
2347	2433	new_arg[1],
2348		0
	2434	new_arg[2]
2349	2435	);
2350		tape[i_var].new_op = rec->num_rec_op();
2351		tape[i_var].new_var = rec->PutOp(op);
	2436	tape[i_var].new_op = rec->num_op_rec();
	2437	tape[i_var].new_var = rec->PutLoadOp(op);
2352	2438	break;
2353	2439	// ---------------------------------------------------
2354	2440	// Load using a variable index

2356	2442	CPPAD_ASSERT_NARG_NRES(op, 3, 1);
2357	2443	new_arg[0] = new_vecad_ind[ arg[0] ];
2358	2444	new_arg[1] = tape[arg[1]].new_var;
	2445	new_arg[2] = rec->num_load_op_rec();
2359	2446	CPPAD_ASSERT_UNKNOWN( size_t(new_arg[0]) < num_vecad_ind );
2360	2447	CPPAD_ASSERT_UNKNOWN( size_t(new_arg[1]) < num_var );
2361	2448	rec->PutArg(
2362	2449	new_arg[0],
2363	2450	new_arg[1],
2364		0
	2451	new_arg[2]
2365	2452	);
2366		tape[i_var].new_var = rec->num_rec_op();
2367		tape[i_var].new_var = rec->PutOp(op);
	2453	tape[i_var].new_var = rec->num_op_rec();
	2454	tape[i_var].new_var = rec->PutLoadOp(op);
2368	2455	break;
2369	2456	// ---------------------------------------------------
2370	2457	// Store a parameter using a parameter index

2439	2526	{ user_state = user_arg;
2440	2527	CPPAD_ASSERT_UNKNOWN( user_curr > 0 );
2441	2528	user_curr--;
2442		user_info[user_curr].op_begin = rec->num_rec_op();
	2529	user_info[user_curr].op_begin = rec->num_op_rec();
2443	2530	}
2444	2531	else
2445	2532	{ user_state = user_start;
2446		user_info[user_curr].op_end = rec->num_rec_op() + 1;
	2533	user_info[user_curr].op_end = rec->num_op_rec() + 1;
2447	2534	}
2448	2535	// user_index, user_id, user_n, user_m
2449	2536	if( user_info[user_curr].connect_type != not_connected )

2491	2578	case UsrrvOp:
2492	2579	CPPAD_ASSERT_NARG_NRES(op, 0, 1);
2493	2580	if( user_info[user_curr].connect_type != not_connected )
2494		{ tape[i_var].new_op = rec->num_rec_op();
	2581	{ tape[i_var].new_op = rec->num_op_rec();
2495	2582	tape[i_var].new_var = rec->PutOp(UsrrvOp);
2496	2583	}
2497	2584	break;

2517	2604	}
2518	2605
2519	2606	# ifndef NDEBUG
2520		size_t num_new_op = rec->num_rec_op();
	2607	size_t num_new_op = rec->num_op_rec();
2521	2608	for(i_var = 0; i_var < tape.size(); i_var++)
2522	2609	CPPAD_ASSERT_UNKNOWN( tape[i_var].new_op < num_new_op );
2523	2610	# endif

2541	2628	}
2542	2629
2543	2630	// fill in the arguments for the CSkip operations
2544		CPPAD_ASSERT_UNKNOWN( cskip_info_next == cskip_info.size() );
	2631	CPPAD_ASSERT_UNKNOWN( cskip_order_next == cskip_info.size() );
2545	2632	for(i = 0; i < cskip_info.size(); i++)
2546	2633	{ struct_cskip_info info = cskip_info[i];
2547	2634	if( info.i_arg > 0 )

2560	2647	rec->ReplaceArg(i_arg++, n_false );
2561	2648	for(j = 0; j < info.skip_var_true.size(); j++)
2562	2649	{ i_var = info.skip_var_true[j];
2563		CPPAD_ASSERT_UNKNOWN( tape[i_var].new_op > 0 );
2564		rec->ReplaceArg(i_arg++, tape[i_var].new_op );
	2650	if( tape[i_var].match )
	2651	{ // the operation for this argument has been removed
	2652	rec->ReplaceArg(i_arg++, 0);
	2653	}
	2654	else
	2655	{ CPPAD_ASSERT_UNKNOWN( tape[i_var].new_op > 0 );
	2656	rec->ReplaceArg(i_arg++, tape[i_var].new_op );
	2657	}
2565	2658	}
2566	2659	for(j = 0; j < info.skip_op_true.size(); j++)
2567	2660	{ i_op = info.skip_op_true[j];

2569	2662	}
2570	2663	for(j = 0; j < info.skip_var_false.size(); j++)
2571	2664	{ i_var = info.skip_var_false[j];
2572		CPPAD_ASSERT_UNKNOWN( tape[i_var].new_op > 0 );
2573		rec->ReplaceArg(i_arg++, tape[i_var].new_op );
	2665	if( tape[i_var].match )
	2666	{ // the operation for this argument has been removed
	2667	rec->ReplaceArg(i_arg++, 0);
	2668	}
	2669	else
	2670	{ CPPAD_ASSERT_UNKNOWN( tape[i_var].new_op > 0 );
	2671	rec->ReplaceArg(i_arg++, tape[i_var].new_op );
	2672	}
2574	2673	}
2575	2674	for(j = 0; j < info.skip_op_false.size(); j++)
2576	2675	{ i_op = info.skip_op_false[j];

2607	2706	// number of independent variables
2608	2707	size_t n = ind_taddr_.size();
2609	2708
2610		size_t i;
2611	2709	# ifndef NDEBUG
2612		size_t j, m = dep_taddr_.size();
	2710	size_t i, j, m = dep_taddr_.size();
2613	2711	CppAD::vector<Base> x(n), y(m), check(m);
2614		bool check_zero_order = taylor_per_var_ > 0;
2615	2712	Base max_taylor(0);
	2713	bool check_zero_order = num_order_taylor_ > 0;
2616	2714	if( check_zero_order )
2617	2715	{ // zero order coefficients for independent vars
2618	2716	for(j = 0; j < n; j++)
2619	2717	{ CPPAD_ASSERT_UNKNOWN( play_.GetOp(j+1) == InvOp );
2620	2718	CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] == j+1 );
2621		x[j] = taylor_[ ind_taddr_[j] * taylor_col_dim_ + 0];
	2719	x[j] = taylor_[ ind_taddr_[j] * cap_order_taylor_ + 0];
2622	2720	}
2623	2721	// zero order coefficients for dependent vars
2624	2722	for(i = 0; i < m; i++)
2625		{ CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < total_num_var_ );
2626		y[i] = taylor_[ dep_taddr_[i] * taylor_col_dim_ + 0];
	2723	{ CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
	2724	y[i] = taylor_[ dep_taddr_[i] * cap_order_taylor_ + 0];
2627	2725	}
2628	2726	// maximum zero order coefficient not counting BeginOp at beginning
2629	2727	// (which is correpsonds to uninitialized memory).
2630		for(i = 1; i < total_num_var_; i++)
2631		{ if( abs_geq(taylor_[i*taylor_col_dim_+0] , max_taylor) )
2632		max_taylor = taylor_[i*taylor_col_dim_+0];
	2728	for(i = 1; i < num_var_tape_; i++)
	2729	{ if( abs_geq(taylor_[i*cap_order_taylor_+0] , max_taylor) )
	2730	max_taylor = taylor_[i*cap_order_taylor_+0];
2633	2731	}
2634	2732	}
2635	2733	# endif

2638	2736	CppAD::optimize::optimize_run<Base>(n, dep_taddr_, &play_, &rec);
2639	2737
2640	2738	// number of variables in the recording
2641		total_num_var_ = rec.num_rec_var();
	2739	num_var_tape_ = rec.num_var_rec();
2642	2740
2643	2741	// now replace the recording
2644	2742	play_.get(rec);

2650	2748
2651	2749	// free old Taylor coefficient memory
2652	2750	taylor_.free();
2653		taylor_per_var_ = 0;
2654		taylor_col_dim_ = 0;
	2751	num_order_taylor_ = 0;
	2752	cap_order_taylor_ = 0;
2655	2753
2656	2754	// resize and initilaize conditional skip vector
2657	2755	// (must use player size because it now has the recoreder information)
2658		cskip_op_.resize( play_.num_rec_op() );
2659		for(i = 0; i < cskip_op_.size(); i++)
2660		cskip_op_[i] = false;
	2756	cskip_op_.erase();
	2757	cskip_op_.extend( play_.num_op_rec() );
2661	2758
2662	2759	# ifndef NDEBUG
2663	2760	if( check_zero_order )

2674	2771
2675	2772	// Erase memory that this calculation was done so NDEBUG gives
2676	2773	// same final state for this object (from users perspective)
2677		taylor_per_var_ = 0;
	2774	num_order_taylor_ = 0;
2678	2775	}
2679	2776	# endif
2680	2777	}
2681	2778
2682		/! \} /
2683	2779	} // END_CPPAD_NAMESPACE
2684	2780	# endif

-5

cppad/local/ordered.hpp less more

0		/* $Id: ordered.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: ordered.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_ORDERED_INCLUDED
2	2	# define CPPAD_ORDERED_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

17	17	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
18	18
19	19	/*!
20		\defgroup ordered_hpp ordered.hpp
21		\{
22	20	\file ordered.hpp
23	21	Check and AD values ordering properties relative to zero.
24	22	*/

98	96	bool abs_geq(const AD<Base>& x, const AD<Base>& y)
99	97	{ return abs_geq(x.value_, y.value_); }
100	98	// ============================================================================
101		/! \} /
102	99	} // END_CPPAD_NAMESPACE
103	100	# endif
104	101

-11

cppad/local/parameter_op.hpp less more

0		/* $Id: parameter_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: parameter_op.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_PARAMETER_OP_INCLUDED
2	2	# define CPPAD_PARAMETER_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup parameter_op_hpp parameter_op.hpp
19		\{
20	18	\file parameter_op.hpp
21	19	Zero order forward mode for ParOp
22	20	*/

54	52	\b Input: \a parameter[ \a arg[0] ] is the value of a component
55	53	of y that is a parameter.
56	54
57		\param nc_taylor
	55	\param cap_order
58	56	number of colums in the matrix containing all the Taylor coefficients.
59	57
60	58	\param taylor
61		\b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
	59	\b Output: \a taylor [ \a i_z * \a cap_order + 0 ]
62	60	is the zero order Taylor coefficient corresponding to z.
63	61
64	62	\par Checked Assertions where op is the unary operator with one result:
65	63	\li NumArg(op) == 1
66	64	\li NumRes(op) == 1
67	65	\li \a size_t(arg[0]) < num_par
68		\li \a 0 < \a nc_taylor
	66	\li \a 0 < \a cap_order
69	67	*/
70	68	template <class Base>
71	69	inline void forward_par_op_0(

73	71	const addr_t* arg ,
74	72	size_t num_par ,
75	73	const Base* parameter ,
76		size_t nc_taylor ,
	74	size_t cap_order ,
77	75	Base* taylor )
78	76	{
79	77	// check assumptions
80	78	CPPAD_ASSERT_UNKNOWN( NumArg(ParOp) == 1 );
81	79	CPPAD_ASSERT_UNKNOWN( NumRes(ParOp) == 1 );
82	80	CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
83		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	81	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
84	82
85		Base* z = taylor + i_z * nc_taylor;
	83	Base* z = taylor + i_z * cap_order;
86	84
87	85	z[0] = parameter[ arg[0] ];
88	86	}
89	87
90		/! \} /
91	88	} // END_CPPAD_NAMESPACE
92	89	# endif

+338

-321

cppad/local/player.hpp less more

0		/* $Id: player.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: player.hpp 3372 2014-09-28 18:42:37Z bradbell $ */
1	1	# ifndef CPPAD_PLAYER_INCLUDED
2	2	# define CPPAD_PLAYER_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup player_hpp player.hpp
18		\{
19	17	\file player.hpp
20	18	File used to define the player class.
21	19	*/

34	32	// -------------- Variables that define the recording -----------------------
35	33	private:
36	34	/// Number of variables in the recording.
37		size_t num_rec_var_;
	35	size_t num_var_rec_;
	36
	37	/// number of vecad load opeations in the reconding
	38	size_t num_load_op_rec_;
	39
	40	/// Number of VecAD vectors in the recording
	41	size_t num_vecad_vec_rec_;
38	42
39	43	/// The operators in the recording.
40		pod_vector<CPPAD_OP_CODE_TYPE> rec_op_;
41
42		/// Number of VecAD vectors in the recording
43		size_t num_rec_vecad_vec_;
	44	pod_vector<CPPAD_OP_CODE_TYPE> op_rec_;
44	45
45	46	/// The VecAD indices in the recording.
46		pod_vector<addr_t> rec_vecad_ind_;
	47	pod_vector<addr_t> vecad_ind_rec_;
47	48
48	49	/// The operation argument indices in the recording
49		pod_vector<addr_t> rec_op_arg_;
	50	pod_vector<addr_t> op_arg_rec_;
50	51
51	52	/// The parameters in the recording.
52	53	/// Note that Base may not be plain old data, so use false in consructor.
53		pod_vector<Base> rec_par_;
	54	pod_vector<Base> par_rec_;
54	55
55	56	/// Character strings ('\\0' terminated) in the recording.
56		pod_vector<char> rec_text_;
	57	pod_vector<char> text_rec_;
57	58
58	59
59	60	// --------------- Functions used to create and maniplate a recording -------
60	61	public:
61	62	/// Default constructor
62	63	player(void) :
63		num_rec_var_(0) ,
64		rec_op_( std::numeric_limits<addr_t>::max() ) ,
65		rec_vecad_ind_( std::numeric_limits<addr_t>::max() ) ,
66		rec_op_arg_( std::numeric_limits<addr_t>::max() ) ,
67		rec_par_( std::numeric_limits<addr_t>::max() ) ,
68		rec_text_( std::numeric_limits<addr_t>::max() )
	64	num_var_rec_(0) ,
	65	num_load_op_rec_(0) ,
	66	op_rec_( std::numeric_limits<addr_t>::max() ) ,
	67	vecad_ind_rec_( std::numeric_limits<addr_t>::max() ) ,
	68	op_arg_rec_( std::numeric_limits<addr_t>::max() ) ,
	69	par_rec_( std::numeric_limits<addr_t>::max() ) ,
	70	text_rec_( std::numeric_limits<addr_t>::max() )
69	71	{ }
70	72
71	73	/// Destructor

73	75	{ }
74	76
75	77	// ===============================================================
76		// Begin two functions with idential code but different argument types.
77	78	/*!
78	79	Moving an operation sequence from a recorder to a player
79	80

86	87	void get(recorder<Base>& rec)
87	88	{ size_t i;
88	89
89		// Var
90		num_rec_var_ = rec.num_rec_var_;
91
92		// Op
93		rec_op_.swap(rec.rec_op_);
94
95		// VecInd
96		rec_vecad_ind_.swap(rec.rec_vecad_ind_);
97
98		// Arg
99		rec_op_arg_.swap(rec.rec_op_arg_);
100
101		// Par
102		rec_par_.swap(rec.rec_par_);
103
104		// Txt
105		rec_text_.swap(rec.rec_text_);
	90	// just set size_t values
	91	num_var_rec_ = rec.num_var_rec_;
	92	num_load_op_rec_ = rec.num_load_op_rec_;
	93
	94	// op_rec_
	95	op_rec_.swap(rec.op_rec_);
	96
	97	// vec_ind_rec_
	98	vecad_ind_rec_.swap(rec.vecad_ind_rec_);
	99
	100	// op_arg_rec_
	101	op_arg_rec_.swap(rec.op_arg_rec_);
	102
	103	// par_rec_
	104	par_rec_.swap(rec.par_rec_);
	105
	106	// text_rec_
	107	text_rec_.swap(rec.text_rec_);
106	108
107	109	// set the number of VecAD vectors
108		num_rec_vecad_vec_ = 0;
109		for(i = 0; i < rec_vecad_ind_.size(); i += rec_vecad_ind_[i] + 1)
110		num_rec_vecad_vec_++;
111		// rec_vecad_ind_ contains size of each VecAD followed by
	110	num_vecad_vec_rec_ = 0;
	111	for(i = 0; i < vecad_ind_rec_.size(); i += vecad_ind_rec_[i] + 1)
	112	num_vecad_vec_rec_++;
	113
	114	// vecad_ind_rec_ contains size of each VecAD followed by
112	115	// the parameter indices used to iniialize it.
113		CPPAD_ASSERT_UNKNOWN( i == rec_vecad_ind_.size() );
114		}
115
	116	CPPAD_ASSERT_UNKNOWN( i == vecad_ind_rec_.size() );
	117	}
	118	// ===============================================================
116	119	/*!
117	120	Copying an operation sequence from one player to another
118	121

121	124	*/
122	125	void operator=(const player& play)
123	126	{
124		// Var
125		num_rec_var_ = play.num_rec_var_;
126
127		// Op
128		rec_op_ = play.rec_op_;
129
130		// VecInd
131		num_rec_vecad_vec_ = play.num_rec_vecad_vec_;
132		rec_vecad_ind_ = play.rec_vecad_ind_;
133
134		// Arg
135		rec_op_arg_ = play.rec_op_arg_;
136
137		// Par
138		rec_par_ = play.rec_par_;
139
140		// Txt
141		rec_text_ = play.rec_text_;
142		}
143		// End two functions with idential code but different argument types.
	127	num_var_rec_ = play.num_var_rec_;
	128	num_load_op_rec_ = play.num_load_op_rec_;
	129	op_rec_ = play.op_rec_;
	130	num_vecad_vec_rec_ = play.num_vecad_vec_rec_;
	131	vecad_ind_rec_ = play.vecad_ind_rec_;
	132	op_arg_rec_ = play.op_arg_rec_;
	133	par_rec_ = play.par_rec_;
	134	text_rec_ = play.text_rec_;
	135	}
144	136	// ===============================================================
145	137
146	138	/// Erase all information in an operation sequence player.
147	139	void Erase(void)
148	140	{
149		num_rec_var_ = 0;
150		num_rec_vecad_vec_ = 0;
151
152		rec_op_.erase();
153		rec_vecad_ind_.erase();
154		rec_op_arg_.erase();
155		rec_par_.erase();
156		rec_text_.erase();
157		}
158
159		// ------------------ Old method of palying back a recording -----------------
	141	num_var_rec_ = 0;
	142	num_load_op_rec_ = 0;
	143	num_vecad_vec_rec_ = 0;
	144
	145	op_rec_.erase();
	146	vecad_ind_rec_.erase();
	147	op_arg_rec_.erase();
	148	par_rec_.erase();
	149	text_rec_.erase();
	150	}
	151
160	152	public:
161	153	/*!
162	154	\brief
163		Fetch an operator from the recording.
	155	Old method of fetching an operator from the recording.
164	156
165	157	\return
166	158	the i-th operator in the recording.

169	161	the index of the operator in recording
170	162	*/
171	163	OpCode GetOp (size_t i) const
172		{ return OpCode(rec_op_[i]); }
	164	{ return OpCode(op_rec_[i]); }
173	165
174	166	/*!
175	167	\brief

182	174	the index of the VecAD index in recording
183	175	*/
184	176	size_t GetVecInd (size_t i) const
185		{ return rec_vecad_ind_[i]; }
	177	{ return vecad_ind_rec_[i]; }
186	178
187	179	/*!
188	180	\brief

195	187	the index of the parameter in recording
196	188	*/
197	189	Base GetPar(size_t i) const
198		{ return rec_par_[i]; }
	190	{ return par_rec_[i]; }
199	191
200	192	/*!
201	193	\brief

206	198
207	199	*/
208	200	const Base* GetPar(void) const
209		{ return rec_par_.data(); }
	201	{ return par_rec_.data(); }
210	202
211	203	/*!
212	204	\brief

219	211	the index where the string begins.
220	212	*/
221	213	const char *GetTxt(size_t i) const
222		{ CPPAD_ASSERT_UNKNOWN(i < rec_text_.size() );
223		return rec_text_.data() + i;
224		}
225
226		/*!
227		\brief
228		Replace an argument value in the recording.
229		2DO: change name of this routine to ReplaceArg.
230
231		\param i
232		is the index, in the recording argument vector,
233		of the value that is to be replaced.
234
235		\param value
236		is the new argument value.
237		*/
238		void ReplaceInd(size_t i, size_t value)
239		{ rec_op_arg_[i] = static_cast<addr_t>( value ); }
	214	{ CPPAD_ASSERT_UNKNOWN(i < text_rec_.size() );
	215	return text_rec_.data() + i;
	216	}
240	217
241	218	/// Fetch number of variables in the recording.
242		size_t num_rec_var(void) const
243		{ return num_rec_var_; }
	219	size_t num_var_rec(void) const
	220	{ return num_var_rec_; }
	221
	222	/// Fetch number of vecad load operations
	223	size_t num_load_op_rec(void) const
	224	{ return num_load_op_rec_; }
244	225
245	226	/// Fetch number of operators in the recording.
246		size_t num_rec_op(void) const
247		{ return rec_op_.size(); }
	227	size_t num_op_rec(void) const
	228	{ return op_rec_.size(); }
248	229
249	230	/// Fetch number of VecAD indices in the recording.
250		size_t num_rec_vecad_ind(void) const
251		{ return rec_vecad_ind_.size(); }
	231	size_t num_vec_ind_rec(void) const
	232	{ return vecad_ind_rec_.size(); }
252	233
253	234	/// Fetch number of VecAD vectors in the recording
254		size_t num_rec_vecad_vec(void) const
255		{ return num_rec_vecad_vec_; }
	235	size_t num_vecad_vec_rec(void) const
	236	{ return num_vecad_vec_rec_; }
256	237
257	238	/// Fetch number of argument indices in the recording.
258		size_t num_rec_op_arg(void) const
259		{ return rec_op_arg_.size(); }
	239	size_t num_op_arg_rec(void) const
	240	{ return op_arg_rec_.size(); }
260	241
261	242	/// Fetch number of parameters in the recording.
262		size_t num_rec_par(void) const
263		{ return rec_par_.size(); }
	243	size_t num_par_rec(void) const
	244	{ return par_rec_.size(); }
264	245
265	246	/// Fetch number of characters (representing strings) in the recording.
266		size_t num_rec_text(void) const
267		{ return rec_text_.size(); }
	247	size_t num_text_rec(void) const
	248	{ return text_rec_.size(); }
268	249
269	250	/// Fetch a rough measure of amount of memory used to store recording
270	251	/// (just lengths, not capacities).
271	252	size_t Memory(void) const
272		{ return rec_op_.size() * sizeof(OpCode)
273		+ rec_op_arg_.size() * sizeof(addr_t)
274		+ rec_par_.size() * sizeof(Base)
275		+ rec_text_.size() * sizeof(char)
276		+ rec_vecad_ind_.size() * sizeof(addr_t)
	253	{ return op_rec_.size() * sizeof(OpCode)
	254	+ op_arg_rec_.size() * sizeof(addr_t)
	255	+ par_rec_.size() * sizeof(Base)
	256	+ text_rec_.size() * sizeof(char)
	257	+ vecad_ind_rec_.size() * sizeof(addr_t)
277	258	;
278	259	}
279	260

285	266	/// Index in recording corresponding to current operator
286	267	size_t op_index_;
287	268
288		/// Current offset of the argument indices in rec_op_arg_
289		size_t op_arg_;
	269	/// Current offset of the argument indices in op_arg_rec_
	270	const addr_t* op_arg_;
290	271
291	272	/// Index for primary (last) variable corresponding to current operator
292	273	size_t var_index_;

296	277	/*!
297	278	Start a play back of the recording during a forward sweep.
298	279
299		Use repeated calls to next_forward to play back one operator at a time.
300
301		\param op
302		The input value of op does not matter. Its output value is the
	280	Use repeated calls to forward_next to play back one operator at a time.
	281
	282	\param op [out]
	283	The input value of \c op does not matter. Its output value is the
303	284	first operator in the recording; i.e., BeginOp.
304	285
305		\param op_arg
306		The input value of *op_arg does not matter. Its output value is the
	286	\param op_arg [out]
	287	The input value of \c op_arg does not matter. Its output value is the
307	288	beginning of the vector of argument indices for the first operation;
308	289	i.e., 0
309	290
310		\param op_index
311		The input value of op_index does not matter. Its output value
	291	\param op_index [out]
	292	The input value of \c op_index does not matter. Its output value
312	293	is the index of the next first operator in the recording; i.e., 0.
313	294
314		\param var_index
315		The input value of var_index does not matter. Its output value is the
	295	\param var_index [out]
	296	The input value of \c var_index does not matter. Its output value is the
316	297	index of the primary (last) result corresponding to the the first
317	298	operator (which must be a BeginOp); i.e., 0.
318	299	*/
319		void start_forward(
	300	void forward_start(
320	301	OpCode& op, const addr_t*& op_arg, size_t& op_index, size_t& var_index)
321	302	{
322		op = op_ = OpCode( rec_op_[0] );
323		op_arg_ = 0;
324		op_arg = rec_op_arg_.data();
	303	op = op_ = OpCode( op_rec_[0] );
	304	op_arg = op_arg_ = op_arg_rec_.data();
325	305	op_index = op_index_ = 0;
326	306	var_index = var_index_ = 0;
327	307

334	314	/*!
335	315	Fetch the next operator during a forward sweep.
336	316
337		Use start_forward to initialize to the first operator; i.e.,
	317	Use forward_start to initialize to the first operator; i.e.,
338	318	the BeginOp at the beginning of the recording.
339
340		\param op
341		The input value of op does not matter. Its output value is the
342		next operator in the recording.
343		For speed, \c next_forward does not check for the special cases
	319	We use the notation forward_routine to denote the set
	320	forward_start, forward_next, forward_csum, forward_cskip.
	321
	322	\param op [in,out]
	323	The input value of \c op must be its output value from the
	324	previous call to a forward_routine.
	325	Its output value is the next operator in the recording.
	326	For speed, \c forward_next does not check for the special cases
344	327	where <tt>op == CSumOp</tt> or <tt>op == CSkipOp</tt>. In these cases,
345		the other return values from \c next_forward must be corrected by a call
	328	the other return values from \c forward_next must be corrected by a call
346	329	to \c forward_csum or \c forward_cskip respectively.
347	330
348		\param op_arg
349		The input value of *op_arg does not matter. Its output value is the
	331	\param op_arg [in,out]
	332	The input value of \c op_arg must be its output value form the
	333	previous call to a forward routine.
	334	Its output value is the
350	335	beginning of the vector of argument indices for this operation.
351	336
352		\param op_index
353		The input value of op_index does not matter. Its output value
354		is the index of the next operator in the recording. Thus the ouput
355		value following the previous call to start_forward is one. In addition,
356		the output value increases by one with each call to next_forward.
357
358		\param var_index
359		The input value of var_index does not matter. Its output value is the
	337	\param op_index [in,out]
	338	The input value of \c op_index must be its output value form the
	339	previous call to a forward routine.
	340	Its output value is the index of the next operator in the recording.
	341	Thus the ouput value following the previous call to forward_start is one.
	342	In addition,
	343	the output value increases by one with each call to forward_next.
	344
	345	\param var_index [in,out]
	346	The input value of \c var_index must be its output value form the
	347	previous call to a forward routine.
	348	Its output value is the
360	349	index of the primary (last) result corresponding to the operator op.
361	350	*/
362
363		void next_forward(
	351	void forward_next(
364	352	OpCode& op, const addr_t*& op_arg, size_t& op_index, size_t& var_index)
365	353	{ using CppAD::NumRes;
366	354	using CppAD::NumArg;
	355	CPPAD_ASSERT_UNKNOWN( op_ == op );
	356	CPPAD_ASSERT_UNKNOWN( op_arg == op_arg_ );
	357	CPPAD_ASSERT_UNKNOWN( op_index == op_index_ );
	358	CPPAD_ASSERT_UNKNOWN( var_index == var_index_ );
367	359
368	360	// index for the next operator
369	361	op_index = ++op_index_;
370	362
371	363	// first argument for next operator
372		op_arg_ += NumArg(op_); // index
373		op_arg = op_arg_ + rec_op_arg_.data(); // pointer
	364	op_arg = op_arg_ += NumArg(op_);
374	365
375	366	// next operator
376		op = op_ = OpCode( rec_op_[ op_index_ ] );
	367	op = op_ = OpCode( op_rec_[ op_index_ ] );
377	368
378	369	// index for last result for next operator
379	370	var_index = var_index_ += NumRes(op);
380
381		CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= rec_op_arg_.size() );
382		CPPAD_ASSERT_UNKNOWN( var_index_ < num_rec_var_ );
383		}
384		/*!
385		Correct \c next_forward return values when <tt>op == CSumOp</tt>.
386
387		\param op
	371
	372
	373	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.data() <= op_arg_ );
	374	CPPAD_ASSERT_UNKNOWN(
	375	op_arg_ + NumArg(op) <= op_arg_rec_.data() + op_arg_rec_.size()
	376	);
	377	CPPAD_ASSERT_UNKNOWN( var_index_ < num_var_rec_ );
	378	}
	379	/*!
	380	Correct \c forward_next return values when <tt>op == CSumOp</tt>.
	381
	382	\param op [in]
388	383	The input value of op must be the return value from the previous
389		call to \c next_forward and must be \c CSumOp.
390
391		\param op_arg
392		The input value of *op_arg must be the return value from the
393		previous call to \c next_forward. Its output value is the
394		beginning of the vector of argument indices for this operation.
395
396		\param op_index
397		The input value of op_index does must be the return value from the
398		previous call to \c next_forward. Its output value
399		is the index of this operator in the recording.
400
401		\param var_index
402		The input value of var_index must be the return value from the
403		previous call to \c next_forward. Its output value is the
404		index of the primary (last) result corresponding to this.
	384	call to \c forward_next and must be \c CSumOp. It is not modified.
	385
	386	\param op_arg [in,out]
	387	The input value of \c op_arg must be the return value from the
	388	previous call to \c forward_next. Its output value is the
	389	beginning of the vector of argument indices for the next operation.
	390
	391	\param op_index [in]
	392	The input value of \c op_index does must be the return value from the
	393	previous call to \c forward_next. Its is not modified.
	394
	395	\param var_index [in,out]
	396	The input value of \c var_index must be the return value from the
	397	previous call to \c forward_next. It is not modified.
405	398	*/
406	399	void forward_csum(
407	400	OpCode& op, const addr_t*& op_arg, size_t& op_index, size_t& var_index)
408	401	{ using CppAD::NumRes;
409	402	using CppAD::NumArg;
	403	CPPAD_ASSERT_UNKNOWN( op_ == op );
	404	CPPAD_ASSERT_UNKNOWN( op_arg == op_arg_ );
	405	CPPAD_ASSERT_UNKNOWN( op_index == op_index_ );
	406	CPPAD_ASSERT_UNKNOWN( var_index == var_index_ );
	407
410	408	CPPAD_ASSERT_UNKNOWN( op == CSumOp );
411	409	CPPAD_ASSERT_UNKNOWN( NumArg(CSumOp) == 0 );
412	410	CPPAD_ASSERT_UNKNOWN(

419	417	We must change op_arg_ so that when you add NumArg(CSumOp)
420	418	you get first argument for next operator in sequence.
421	419	*/
422		op_arg_ += op_arg[0] + op_arg[1] + 4;
423
424		CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= rec_op_arg_.size() );
425		CPPAD_ASSERT_UNKNOWN( var_index_ < num_rec_var_ );
426		}
427		/*!
428		Correct \c next_forward return values when <tt>op == CSkipOp</tt>.
429
430		\param op
	420	op_arg = op_arg_ += op_arg[0] + op_arg[1] + 4;
	421
	422	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.data() <= op_arg_ );
	423	CPPAD_ASSERT_UNKNOWN(
	424	op_arg_ + NumArg(op) <= op_arg_rec_.data() + op_arg_rec_.size()
	425	);
	426	CPPAD_ASSERT_UNKNOWN( var_index_ < num_var_rec_ );
	427	}
	428	/*!
	429	Correct \c forward_next return values when <tt>op == CSkipOp</tt>.
	430
	431	\param op [in]
431	432	The input value of op must be the return value from the previous
432		call to \c next_forward and must be \c CSkipOp.
433
434		\param op_arg
435		The input value of *op_arg must be the return value from the
436		previous call to \c next_forward. Its output value is the
437		beginning of the vector of argument indices for this operation.
438
439		\param op_index
440		The input value of op_index does must be the return value from the
441		previous call to \c next_forward. Its output value
442		is the index of this operator in the recording.
443
444		\param var_index
445		The input value of var_index must be the return value from the
446		previous call to \c next_forward. Its output value is the
447		index of the primary (last) result corresponding to this.
	433	call to \c forward_next and must be \c CSkipOp. It is not modified.
	434
	435	\param op_arg [in,out]
	436	The input value of \c op_arg must be the return value from the
	437	previous call to \c forward_next. Its output value is the
	438	beginning of the vector of argument indices for the next operation.
	439
	440	\param op_index [in]
	441	The input value of \c op_index does must be the return value from the
	442	previous call to \c forward_next. Its is not modified.
	443
	444	\param var_index [in,out]
	445	The input value of \c var_index must be the return value from the
	446	previous call to \c forward_next. It is not modified.
448	447	*/
449	448	void forward_cskip(
450	449	OpCode& op, const addr_t*& op_arg, size_t& op_index, size_t& var_index)
451	450	{ using CppAD::NumRes;
452	451	using CppAD::NumArg;
	452	CPPAD_ASSERT_UNKNOWN( op_ == op );
	453	CPPAD_ASSERT_UNKNOWN( op_arg == op_arg_ );
	454	CPPAD_ASSERT_UNKNOWN( op_index == op_index_ );
	455	CPPAD_ASSERT_UNKNOWN( var_index == var_index_ );
	456
453	457	CPPAD_ASSERT_UNKNOWN( op == CSkipOp );
454	458	CPPAD_ASSERT_UNKNOWN( NumArg(CSkipOp) == 0 );
455	459	CPPAD_ASSERT_UNKNOWN(

462	466	We must change op_arg_ so that when you add NumArg(CSkipOp)
463	467	you get first argument for next operator in sequence.
464	468	*/
465		op_arg_ += 7 + op_arg[4] + op_arg[5];
466
467		CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= rec_op_arg_.size() );
468		CPPAD_ASSERT_UNKNOWN( var_index_ < num_rec_var_ );
469		}
470		/*!
471		Get a non-constant version of op_arg returned by previous next_forward
472
473		\return
474		The return value is equal to the return value of op_arg
475		corresponding to the previous call to next_forward.
476		*/
477		addr_t* forward_non_const_arg(void)
478		{ return op_arg_ + rec_op_arg_.data(); }
479
	469	op_arg = op_arg_ += 7 + op_arg[4] + op_arg[5];
	470
	471	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.data() <= op_arg_ );
	472	CPPAD_ASSERT_UNKNOWN(
	473	op_arg_ + NumArg(op) <= op_arg_rec_.data() + op_arg_rec_.size()
	474	);
	475	CPPAD_ASSERT_UNKNOWN( var_index_ < num_var_rec_ );
	476	}
480	477	/*!
481	478	Start a play back of the recording during a reverse sweep.
482	479
483		Use repeated calls to next_reverse to play back one operator at a time.
484
485		\param op
486		The input value of op does not matter. Its output value is the
	480	Use repeated calls to reverse_next to play back one operator at a time.
	481
	482	\param op [out]
	483	The input value of \c op does not matter. Its output value is the
487	484	last operator in the recording; i.e., EndOp.
488	485
489		\param op_arg
490		The input value of *op_arg does not matter. Its output value is the
	486	\param op_arg [out]
	487	The input value of \c op_arg does not matter. Its output value is the
491	488	beginning of the vector of argument indices for the last operation;
492	489	(there are no arguments for the last operation so \a op_arg is invalid).
493	490
494		\param op_index
495		The input value of op_index does not matter. Its output value
	491	\param op_index [out[
	492	The input value of \c op_index does not matter. Its output value
496	493	is the index of the last operator in the recording.
497	494
498		\param var_index
499		The input value of var_index does not matter. Its output value is the
	495	\param var_index [out]
	496	The input value of \c var_index does not matter. Its output value is the
500	497	index of the primary (last) result corresponding to the the last
501	498	operator (which must be a EndOp).
502		(there are no results for the last operation
503		so \a var_index is invalid).
504		*/
505
506		void start_reverse(
	499	(there are no results for the last operation so \a var_index is invalid).
	500	*/
	501
	502	void reverse_start(
507	503	OpCode& op, const addr_t*& op_arg, size_t& op_index, size_t& var_index)
508	504	{
509		op_arg_ = rec_op_arg_.size(); // index
510		op_arg = op_arg_ + rec_op_arg_.data(); // pointer
511
512		op_index = op_index_ = rec_op_.size() - 1;
513		var_index = var_index_ = num_rec_var_ - 1;
514
515		op = op_ = OpCode( rec_op_[ op_index_ ] );
	505	op_arg = op_arg_ = op_arg_rec_.data() + op_arg_rec_.size();
	506	op_index = op_index_ = op_rec_.size() - 1;
	507	var_index = var_index_ = num_var_rec_ - 1;
	508	op = op_ = OpCode( op_rec_[ op_index_ ] );
516	509	CPPAD_ASSERT_UNKNOWN( op_ == EndOp );
517	510	CPPAD_ASSERT_NARG_NRES(op, 0, 0);
518	511	return;

521	514	/*!
522	515	Fetch the next operator during a reverse sweep.
523	516
524		Use start_reverse to initialize to reverse play back.
525		The first call to next_reverse (after start_reverse) will give the
526		last operator in the recording.
527
528		\param op
529		The input value of op does not matter. Its output value is the
530		next operator in the recording (in reverse order).
	517	Use reverse_start to initialize to reverse play back.
	518	The first call to reverse_next (after reverse_start) will give the
	519	last operator in the recording.
	520	We use the notation reverse_routine to denote the set
	521	reverse_start, reverse_next, reverse_csum, reverse_cskip.
	522
	523	\param op [in,out]
	524	The input value of \c op must be its output value from the
	525	previous call to a reverse_routine.
	526	Its output value is the next operator in the recording (in reverse order).
531	527	The last operator sets op equal to EndOp.
532	528
533		\param op_arg
534		The input value of *op_arg does not matter. Its output value is the
	529	\param op_arg [in,out]
	530	The input value of \c op_arg must be its output value from the
	531	previous call to a reverse_routine.
	532	Its output value is the
535	533	beginning of the vector of argument indices for this operation.
536	534	The last operator sets op_arg equal to the beginning of the
537	535	argument indices for the entire recording.
538		For speed, \c next_reverse does not check for the special cases
	536	For speed, \c reverse_next does not check for the special cases
539	537	<tt>op == CSumOp</tt> or <tt>op == CSkipOp</tt>. In these cases, the other
540		return values from \c next_reverse must be corrected by a call to
	538	return values from \c reverse_next must be corrected by a call to
541	539	\c reverse_csum or \c reverse_cskip respectively.
542	540
543	541
544		\param op_index
545		The input value of op_index does not matter. Its output value
	542	\param op_index [in,out]
	543	The input value of \c op_index must be its output value from the
	544	previous call to a reverse_routine.
	545	Its output value
546	546	is the index of this operator in the recording. Thus the output
547		value following the previous call to start_reverse is equal to
	547	value following the previous call to reverse_start is equal to
548	548	the number of variables in the recording minus one.
549	549	In addition, the output value decreases by one with each call to
550		next_reverse.
	550	reverse_next.
551	551	The last operator sets op_index equal to 0.
552	552
553		\param var_index
554		The input value of var_index does not matter. Its output value is the
	553	\param var_index [in,out]
	554	The input value of \c var_index must be its output value from the
	555	previous call to a reverse_routine.
	556	Its output value is the
555	557	index of the primary (last) result corresponding to the operator op.
556	558	The last operator sets var_index equal to 0 (corresponding to BeginOp
557	559	at beginning of operation sequence).
558	560	*/
559
560		void next_reverse(
	561	void reverse_next(
561	562	OpCode& op, const addr_t*& op_arg, size_t& op_index, size_t& var_index)
562	563	{ using CppAD::NumRes;
563	564	using CppAD::NumArg;
	565	CPPAD_ASSERT_UNKNOWN( op_ == op );
	566	CPPAD_ASSERT_UNKNOWN( op_arg == op_arg_ );
	567	CPPAD_ASSERT_UNKNOWN( op_index == op_index_ );
	568	CPPAD_ASSERT_UNKNOWN( var_index == var_index_ );
564	569
565	570	// index of the last result for the next operator
566	571	CPPAD_ASSERT_UNKNOWN( var_index_ >= NumRes(op_) );

569	574	// next operator
570	575	CPPAD_ASSERT_UNKNOWN( op_index_ > 0 );
571	576	op_index = --op_index_; // index
572		op = op_ = OpCode( rec_op_[ op_index_ ] ); // value
	577	op = op_ = OpCode( op_rec_[ op_index_ ] ); // value
573	578
574	579	// first argument for next operator
575		CPPAD_ASSERT_UNKNOWN( op_arg_ >= NumArg(op) );
576		op_arg_ -= NumArg(op); // index
577		op_arg = op_arg_ + rec_op_arg_.data(); // pointer
578		}
579		/*!
580		Correct \c next_reverse return values when <tt>op == CSumOp</tt>.
581
582		\param op
583		The input value of op must be the return value from the previous
584		call to \c next_reverse and must be \c CSumOp.
585
586		\param op_arg
587		The input value of *op_arg must be the return value from the
588		previous call to \c next_reverse. Its output value is the
	580	op_arg = op_arg_ -= NumArg(op);
	581	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.data() <= op_arg_ );
	582	CPPAD_ASSERT_UNKNOWN(
	583	op_arg_ + NumArg(op) <= op_arg_rec_.data() + op_arg_rec_.size()
	584	);
	585	}
	586	/*!
	587	Correct \c reverse_next return values when <tt>op == CSumOp</tt>.
	588
	589	\param op [in]
	590	The input value of \c op must be the return value from the previous
	591	call to \c reverse_next and must be \c CSumOp. It is not modified.
	592
	593	\param op_arg [in,out]
	594	The input value of \c op_arg must be the return value from the
	595	previous call to \c reverse_next. Its output value is the
589	596	beginning of the vector of argument indices for this operation.
590	597
591		\param op_index
592		The input value of op_index must be the return value from the
593		previous call to \c next_reverse. Its output value
594		is the index of the this operator in the recording.
595
596		\param var_index
597		The input value of var_index must be the return value from the
598		previous call to \c next_reverse. Its output value is the
599		index of the primary (last) result corresponding to this operator.
	598	\param op_index [in]
	599	The input value of \c op_index must be the return value from the
	600	previous call to \c reverse_next. It is not modified.
	601
	602	\param var_index [in]
	603	The input value of \c var_index must be the return value from the
	604	previous call to \c reverse_next. It is not modified.
600	605	*/
601	606
602	607	void reverse_csum(
603	608	OpCode& op, const addr_t*& op_arg, size_t& op_index, size_t& var_index)
604	609	{ using CppAD::NumRes;
605	610	using CppAD::NumArg;
	611	CPPAD_ASSERT_UNKNOWN( op_ == op );
	612	CPPAD_ASSERT_UNKNOWN( op_arg == op_arg_ );
	613	CPPAD_ASSERT_UNKNOWN( op_index == op_index_ );
	614	CPPAD_ASSERT_UNKNOWN( var_index == var_index_ );
	615
606	616	CPPAD_ASSERT_UNKNOWN( op == CSumOp );
607	617	CPPAD_ASSERT_UNKNOWN( NumArg(CSumOp) == 0 );
608	618	/*
609		The things needs fixing are op_arg_ and op_arg. Currently,
610		op_arg points first arugment for the previous operator.
	619	The variables that need fixing are op_arg_ and op_arg. Currently,
	620	op_arg points to the last argument for the previous operator.
611	621	*/
	622	// last argument for this csum operation
612	623	--op_arg;
613		op_arg_ -= (op_arg[0] + 4);
614		op_arg = op_arg_ + rec_op_arg_.data();
	624	// first argument for this csum operation
	625	op_arg = op_arg_ -= (op_arg[0] + 4);
	626	// now op_arg points to the first argument for this csum operator
615	627
616	628	CPPAD_ASSERT_UNKNOWN(
617	629	op_arg[0] + op_arg[1] == op_arg[ 3 + op_arg[0] + op_arg[1] ]
618	630	);
619		CPPAD_ASSERT_UNKNOWN( op_index_ < rec_op_.size() );
620		CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= rec_op_arg_.size() );
621		CPPAD_ASSERT_UNKNOWN( var_index_ < num_rec_var_ );
622		}
623		/*!
624		Correct \c next_reverse return values when <tt>op == CSkipOp</tt>.
625
626		\param op
627		The input value of op must be the return value from the previous
628		call to \c next_reverse and must be \c CSkipOp.
629
630		\param op_arg
631		The input value of *op_arg must be the return value from the
632		previous call to \c next_reverse. Its output value is the
	631
	632	CPPAD_ASSERT_UNKNOWN( op_index_ < op_rec_.size() );
	633	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.data() <= op_arg_ );
	634	CPPAD_ASSERT_UNKNOWN( var_index_ < num_var_rec_ );
	635	}
	636	/*!
	637	Correct \c reverse_next return values when <tt>op == CSkipOp</tt>.
	638
	639
	640	\param op [int]
	641	The input value of \c op must be the return value from the previous
	642	call to \c reverse_next and must be \c CSkipOp. It is not modified.
	643
	644	\param op_arg [in,out]
	645	The input value of \c op_arg must be the return value from the
	646	previous call to \c reverse_next. Its output value is the
633	647	beginning of the vector of argument indices for this operation.
634	648
635		\param op_index
636		The input value of op_index must be the return value from the
637		previous call to \c next_reverse. Its output value
638		is the index of the this operator in the recording.
639
640		\param var_index
641		The input value of var_index must be the return value from the
642		previous call to \c next_reverse. Its output value is the
643		index of the primary (last) result corresponding to this operator.
	649	\param op_index [in]
	650	The input value of \c op_index must be the return value from the
	651	previous call to \c reverse_next. It is not modified.
	652
	653	\param var_index [in]
	654	The input value of \c var_index must be the return value from the
	655	previous call to \c reverse_next. It is not modified.
644	656	*/
645	657
646	658	void reverse_cskip(
647	659	OpCode& op, const addr_t*& op_arg, size_t& op_index, size_t& var_index)
648	660	{ using CppAD::NumRes;
649	661	using CppAD::NumArg;
	662	CPPAD_ASSERT_UNKNOWN( op_ == op );
	663	CPPAD_ASSERT_UNKNOWN( op_arg == op_arg_ );
	664	CPPAD_ASSERT_UNKNOWN( op_index == op_index_ );
	665	CPPAD_ASSERT_UNKNOWN( var_index == var_index_ );
	666
650	667	CPPAD_ASSERT_UNKNOWN( op == CSkipOp );
651	668	CPPAD_ASSERT_UNKNOWN( NumArg(CSkipOp) == 0 );
652	669	/*
653		The things needs fixing are op_arg_ and op_arg. Currently,
654		op_arg points first arugment for the previous operator.
	670	The variables that need fixing are op_arg_ and op_arg. Currently,
	671	op_arg points to the last arugment for the previous operator.
655	672	*/
	673	// last argument for this cskip operation
656	674	--op_arg;
657		op_arg_ -= (op_arg[0] + 4);
658		op_arg = op_arg_ + rec_op_arg_.data();
	675	// first argument for this cskip operation
	676	op_arg = op_arg_ -= (op_arg[0] + 7);
659	677
660	678	CPPAD_ASSERT_UNKNOWN(
661		op_arg[1] + op_arg[2] == op_arg[ 3 + op_arg[1] + op_arg[2] ]
662		);
663		CPPAD_ASSERT_UNKNOWN( op_index_ < rec_op_.size() );
664		CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= rec_op_arg_.size() );
665		CPPAD_ASSERT_UNKNOWN( var_index_ < num_rec_var_ );
	679	op_arg[4] + op_arg[5] == op_arg[ 6 + op_arg[4] + op_arg[5] ]
	680	);
	681	CPPAD_ASSERT_UNKNOWN( op_index_ < op_rec_.size() );
	682	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.data() <= op_arg_ );
	683	CPPAD_ASSERT_UNKNOWN( var_index_ < num_var_rec_ );
666	684	}
667	685
668	686	};
669	687
670		/! \} /
671	688	} // END_CPPAD_NAMESPACE
672	689	# endif

+23

-7

cppad/local/pod_vector.hpp less more

0		/* $Id: pod_vector.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	// $Id: pod_vector.hpp 3491 2014-12-21 13:15:12Z bradbell $
1	1	# ifndef CPPAD_POD_VECTOR_INCLUDED
2	2	# define CPPAD_POD_VECTOR_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

12	12	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13	13	-------------------------------------------------------------------------- */
14	14
	15	# if CPPAD_CSTDINT_HAS_8_TO_64
	16	# include <cstdint>
	17	# endif
15	18	# include <algorithm>
16	19	# include <cppad/thread_alloc.hpp>
17	20	# include <cppad/local/cppad_assert.hpp>

19	22
20	23	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
21	24	/*!
22		\defgroup pod_vector_hpp pod_vector.hpp
23		\{
24	25	\file pod_vector.hpp
25	26	File used to define pod_vector class
26	27	*/

32	33	template <class Type> inline bool is_pod(void) { return false; }
33	34	/// system pod types so far:
34	35	template <> inline bool is_pod<bool>(void) { return true; }
35		template <> inline bool is_pod<char>(void) { return true; }
36	36	template <> inline bool is_pod<float>(void) { return true; }
37	37	template <> inline bool is_pod<double>(void) { return true; }
	38	# if CPPAD_CSTDINT_HAS_8_TO_64
	39	template <> inline bool is_pod<int8_t>(void) { return true; }
	40	template <> inline bool is_pod<int16_t>(void) { return true; }
	41	template <> inline bool is_pod<int32_t>(void) { return true; }
	42	template <> inline bool is_pod<int64_t>(void) { return true; }
	43	//
	44	template <> inline bool is_pod<uint8_t>(void) { return true; }
	45	template <> inline bool is_pod<uint16_t>(void) { return true; }
	46	template <> inline bool is_pod<uint32_t>(void) { return true; }
	47	template <> inline bool is_pod<uint64_t>(void) { return true; }
	48	# else // CPPAD_CSTDINT_HAS_8_TO_64
	49	template <> inline bool is_pod<char>(void) { return true; }
	50	template <> inline bool is_pod<short int>(void) { return true; }
	51	template <> inline bool is_pod<int>(void) { return true; }
	52	//
38	53	template <> inline bool is_pod<unsigned char>(void) { return true; }
39	54	template <> inline bool is_pod<unsigned short int>(void) { return true; }
40	55	template <> inline bool is_pod<unsigned int>(void) { return true; }
41		# if ! CPPAD_SIZE_T_SAME_UNSIGNED_INT
	56	# if CPPAD_SIZE_T_NOT_UNSIGNED_INT
42	57	template <> inline bool is_pod<size_t>(void) { return true; }
43	58	# endif
	59	# endif // CPPAD_CSTDINT_HAS_8_TO_64
	60
44	61	/// CppAD pod types so far:
45	62	template <> inline bool is_pod<OpCode>(void) { return true; }
46	63

271	288	}
272	289	};
273	290
274		/! \} /
275	291	} // END_CPPAD_NAMESPACE
276	292	# endif

+268

-140

cppad/local/pow_op.hpp less more

0		/* $Id: pow_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: pow_op.hpp 3321 2014-09-12 09:50:39Z bradbell $ */
1	1	# ifndef CPPAD_POW_OP_INCLUDED
2	2	# define CPPAD_POW_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup pow_op_hpp pow_op.hpp
18		\{
19	17	\file pow_op.hpp
20	18	Forward and reverse mode calculations for z = pow(x, y).
21	19	*/

33	31
34	32	template <class Base>
35	33	inline void forward_powvv_op(
	34	size_t p ,
36	35	size_t q ,
37		size_t p ,
38		size_t i_z ,
39		const addr_t* arg ,
40		const Base* parameter ,
41		size_t nc_taylor ,
	36	size_t i_z ,
	37	const addr_t* arg ,
	38	const Base* parameter ,
	39	size_t cap_order ,
42	40	Base* taylor )
43	41	{
44	42	// convert from final result to first result

47	45	// check assumptions
48	46	CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
49	47	CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
50		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
51		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
52		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
53		CPPAD_ASSERT_UNKNOWN( q <= p );
54
55		// z_0 = log(x)
56		forward_log_op(q, p, i_z, arg[0], nc_taylor, taylor);
	48	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	49	CPPAD_ASSERT_UNKNOWN( p <= q );
	50
	51	// z_0 = log(x)
	52	forward_log_op(p, q, i_z, arg[0], cap_order, taylor);
57	53
58	54	// z_1 = z_0 * y
59	55	addr_t adr[2];
60	56	adr[0] = i_z;
61	57	adr[1] = arg[1];
62		forward_mulvv_op(q, p, i_z+1, adr, parameter, nc_taylor, taylor);
	58	forward_mulvv_op(p, q, i_z+1, adr, parameter, cap_order, taylor);
63	59
64	60	// z_2 = exp(z_1)
65	61	// final result for zero order case is exactly the same as for Base
66		if( q == 0 )
	62	if( p == 0 )
67	63	{ // Taylor coefficients corresponding to arguments and result
68		Base* x = taylor + arg[0] * nc_taylor;
69		Base* y = taylor + arg[1] * nc_taylor;
70		Base* z_2 = taylor + (i_z+2) * nc_taylor;
	64	Base* x = taylor + arg[0] * cap_order;
	65	Base* y = taylor + arg[1] * cap_order;
	66	Base* z_2 = taylor + (i_z+2) * cap_order;
71	67
72	68	z_2[0] = pow(x[0], y[0]);
73		q++;
	69	p++;
74	70	}
75		if( q <= p )
76		forward_exp_op(q, p, i_z+2, i_z+1, nc_taylor, taylor);
77		}
78
	71	if( p <= q )
	72	forward_exp_op(p, q, i_z+2, i_z+1, cap_order, taylor);
	73	}
	74	/*!
	75	Multiple directions forward mode Taylor coefficients for op = PowvvOp.
	76
	77	The C++ source code corresponding to this operation is
	78	\verbatim
	79	z = pow(x, y)
	80	\endverbatim
	81	In the documentation below,
	82	this operations is for the case where x is a variable and y is a parameter.
	83
	84	\copydetails forward_pow_op_dir
	85	*/
	86
	87	template <class Base>
	88	inline void forward_powvv_op_dir(
	89	size_t q ,
	90	size_t r ,
	91	size_t i_z ,
	92	const addr_t* arg ,
	93	const Base* parameter ,
	94	size_t cap_order ,
	95	Base* taylor )
	96	{
	97	// convert from final result to first result
	98	i_z -= 2; // 2 = NumRes(PowvvOp) - 1
	99
	100	// check assumptions
	101	CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
	102	CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
	103	CPPAD_ASSERT_UNKNOWN( 0 < q );
	104	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	105
	106	// z_0 = log(x)
	107	forward_log_op_dir(q, r, i_z, arg[0], cap_order, taylor);
	108
	109	// z_1 = y * z_0
	110	addr_t adr[2];
	111	adr[0] = i_z;
	112	adr[1] = arg[1];
	113	forward_mulvv_op_dir(q, r, i_z+1, adr, parameter, cap_order, taylor);
	114
	115	// z_2 = exp(z_1)
	116	forward_exp_op_dir(q, r, i_z+2, i_z+1, cap_order, taylor);
	117	}
79	118	/*!
80	119	Compute zero order forward mode Taylor coefficients for result of op = PowvvOp.
81	120

95	134	size_t i_z ,
96	135	const addr_t* arg ,
97	136	const Base* parameter ,
98		size_t nc_taylor ,
	137	size_t cap_order ,
99	138	Base* taylor )
100	139	{
101	140	// convert from final result to first result

104	143	// check assumptions
105	144	CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
106	145	CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
107		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
108		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
109	146
110	147	// Taylor coefficients corresponding to arguments and result
111		Base* x = taylor + arg[0] * nc_taylor;
112		Base* y = taylor + arg[1] * nc_taylor;
113		Base* z_0 = taylor + i_z * nc_taylor;
114		Base* z_1 = z_0 + nc_taylor;
115		Base* z_2 = z_1 + nc_taylor;
	148	Base* x = taylor + arg[0] * cap_order;
	149	Base* y = taylor + arg[1] * cap_order;
	150	Base* z_0 = taylor + i_z * cap_order;
	151	Base* z_1 = z_0 + cap_order;
	152	Base* z_2 = z_1 + cap_order;
116	153
117	154	z_0[0] = log( x[0] );
118	155	z_1[0] = z_0[0] * y[0];

140	177	size_t i_z ,
141	178	const addr_t* arg ,
142	179	const Base* parameter ,
143		size_t nc_taylor ,
	180	size_t cap_order ,
144	181	const Base* taylor ,
145	182	size_t nc_partial ,
146	183	Base* partial )

151	188	// check assumptions
152	189	CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
153	190	CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
154		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
155		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
156		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	191	CPPAD_ASSERT_UNKNOWN( d < cap_order );
157	192	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
158	193
159	194	// z_2 = exp(z_1)
160	195	reverse_exp_op(
161		d, i_z+2, i_z+1, nc_taylor, taylor, nc_partial, partial
	196	d, i_z+2, i_z+1, cap_order, taylor, nc_partial, partial
162	197	);
163	198
164	199	// z_1 = z_0 * y

166	201	adr[0] = i_z;
167	202	adr[1] = arg[1];
168	203	reverse_mulvv_op(
169		d, i_z+1, adr, parameter, nc_taylor, taylor, nc_partial, partial
	204	d, i_z+1, adr, parameter, cap_order, taylor, nc_partial, partial
170	205	);
171	206
172	207	// z_0 = log(x)
173	208	reverse_log_op(
174		d, i_z, arg[0], nc_taylor, taylor, nc_partial, partial
	209	d, i_z, arg[0], cap_order, taylor, nc_partial, partial
175	210	);
176	211	}
177	212

191	226
192	227	template <class Base>
193	228	inline void forward_powpv_op(
	229	size_t p ,
194	230	size_t q ,
195		size_t p ,
196		size_t i_z ,
197		const addr_t* arg ,
198		const Base* parameter ,
199		size_t nc_taylor ,
	231	size_t i_z ,
	232	const addr_t* arg ,
	233	const Base* parameter ,
	234	size_t cap_order ,
200	235	Base* taylor )
201	236	{
202	237	// convert from final result to first result

205	240	// check assumptions
206	241	CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
207	242	CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
208		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
209		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
210		CPPAD_ASSERT_UNKNOWN( q <= p );
	243	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	244	CPPAD_ASSERT_UNKNOWN( p <= q );
211	245
212	246	// Taylor coefficients corresponding to arguments and result
213		Base* z_0 = taylor + i_z * nc_taylor;
	247	Base* z_0 = taylor + i_z * cap_order;
214	248
215	249	// z_0 = log(x)
216	250	Base x = parameter[ arg[0] ];
217	251	size_t d;
218		for(d = q; d <= p; d++)
	252	for(d = p; d <= q; d++)
219	253	{ if( d == 0 )
220	254	z_0[d] = log(x);
221	255	else z_0[d] = Base(0);

223	257
224	258	// z_1 = z_0 * y
225	259	addr_t adr[2];
226		adr[0] = i_z * nc_taylor; // offset of z_0 in taylor; i.e., log(x)
227		adr[1] = arg[1]; // variable index of y in taylor
228
229		// use taylor both for parameter and variable values (trick)
230		forward_mulpv_op(q, p, i_z+1, adr, taylor, nc_taylor, taylor);
	260	// offset of z_i in taylor (as if it were a parameter); i.e., log(x)
	261	adr[0] = i_z * cap_order;
	262	// offset of y in taylor (as a variable)
	263	adr[1] = arg[1];
	264
	265	// Trick: use taylor both for the parameter vector and variable values
	266	forward_mulpv_op(p, q, i_z+1, adr, taylor, cap_order, taylor);
231	267
232	268	// z_2 = exp(z_1)
233	269	// zero order case exactly same as Base type operation
234		if( q == 0 )
235		{ Base* y = taylor + arg[1] * nc_taylor;
236		Base* z_2 = taylor + (i_z+2) * nc_taylor;
	270	if( p == 0 )
	271	{ Base* y = taylor + arg[1] * cap_order;
	272	Base* z_2 = taylor + (i_z+2) * cap_order;
237	273	z_2[0] = pow(x, y[0]);
238		q++;
	274	p++;
239	275	}
240		if( q <= p )
241		forward_exp_op(q, p, i_z+2, i_z+1, nc_taylor, taylor);
242		}
243		/*!
244		Compute zero order forward mode Taylor coefficient for result of op = PowpvOp.
	276	if( p <= q )
	277	forward_exp_op(p, q, i_z+2, i_z+1, cap_order, taylor);
	278	}
	279	/*!
	280	Multiple directions forward mode Taylor coefficients for op = PowpvOp.
245	281
246	282	The C++ source code corresponding to this operation is
247	283	\verbatim

250	286	In the documentation below,
251	287	this operations is for the case where x is a parameter and y is a variable.
252	288
253		\copydetails forward_pow_op_0
254		*/
255
256		template <class Base>
257		inline void forward_powpv_op_0(
258		size_t i_z ,
259		const addr_t* arg ,
260		const Base* parameter ,
261		size_t nc_taylor ,
262		Base* taylor )
263		{
264		// convert from final result to first result
265		i_z -= 2; // NumRes(PowpvOp) - 1;
	289	\copydetails forward_pow_op_dir
	290	*/
	291
	292	template <class Base>
	293	inline void forward_powpv_op_dir(
	294	size_t q ,
	295	size_t r ,
	296	size_t i_z ,
	297	const addr_t* arg ,
	298	const Base* parameter ,
	299	size_t cap_order ,
	300	Base* taylor )
	301	{
	302	// convert from final result to first result
	303	i_z -= 2; // 2 = NumRes(PowpvOp) - 1;
266	304
267	305	// check assumptions
268	306	CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
269	307	CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
270		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
	308	CPPAD_ASSERT_UNKNOWN( 0 < q );
	309	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	310
	311	// Taylor coefficients corresponding to arguments and result
	312	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	313	Base* z_0 = taylor + i_z * num_taylor_per_var;
	314
	315	// z_0 = log(x)
	316	size_t m = (q-1) * r + 1;
	317	for(size_t ell = 0; ell < r; ell++)
	318	z_0[m+ell] = Base(0);
	319
	320	// z_1 = z_0 * y
	321	addr_t adr[2];
	322	// offset of z_0 in taylor (as if it were a parameter); i.e., log(x)
	323	adr[0] = i_z * num_taylor_per_var;
	324	// ofset of y in taylor (as a variable)
	325	adr[1] = arg[1];
	326
	327	// Trick: use taylor both for the parameter vector and variable values
	328	forward_mulpv_op_dir(q, r, i_z+1, adr, taylor, cap_order, taylor);
	329
	330	// z_2 = exp(z_1)
	331	forward_exp_op_dir(q, r, i_z+2, i_z+1, cap_order, taylor);
	332	}
	333	/*!
	334	Compute zero order forward mode Taylor coefficient for result of op = PowpvOp.
	335
	336	The C++ source code corresponding to this operation is
	337	\verbatim
	338	z = pow(x, y)
	339	\endverbatim
	340	In the documentation below,
	341	this operations is for the case where x is a parameter and y is a variable.
	342
	343	\copydetails forward_pow_op_0
	344	*/
	345
	346	template <class Base>
	347	inline void forward_powpv_op_0(
	348	size_t i_z ,
	349	const addr_t* arg ,
	350	const Base* parameter ,
	351	size_t cap_order ,
	352	Base* taylor )
	353	{
	354	// convert from final result to first result
	355	i_z -= 2; // NumRes(PowpvOp) - 1;
	356
	357	// check assumptions
	358	CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
	359	CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
271	360
272	361	// Paraemter value
273	362	Base x = parameter[ arg[0] ];
274	363
275	364	// Taylor coefficients corresponding to arguments and result
276		Base* y = taylor + arg[1] * nc_taylor;
277		Base* z_0 = taylor + i_z * nc_taylor;
278		Base* z_1 = z_0 + nc_taylor;
279		Base* z_2 = z_1 + nc_taylor;
	365	Base* y = taylor + arg[1] * cap_order;
	366	Base* z_0 = taylor + i_z * cap_order;
	367	Base* z_1 = z_0 + cap_order;
	368	Base* z_2 = z_1 + cap_order;
280	369
281	370	// z_0 = log(x)
282	371	z_0[0] = log(x);

308	397	size_t i_z ,
309	398	const addr_t* arg ,
310	399	const Base* parameter ,
311		size_t nc_taylor ,
	400	size_t cap_order ,
312	401	const Base* taylor ,
313	402	size_t nc_partial ,
314	403	Base* partial )

319	408	// check assumptions
320	409	CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
321	410	CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
322		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
323		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	411	CPPAD_ASSERT_UNKNOWN( d < cap_order );
324	412	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
325	413
326	414	// z_2 = exp(z_1)
327	415	reverse_exp_op(
328		d, i_z+2, i_z+1, nc_taylor, taylor, nc_partial, partial
	416	d, i_z+2, i_z+1, cap_order, taylor, nc_partial, partial
329	417	);
330	418
331	419	// z_1 = z_0 * y
332	420	addr_t adr[2];
333		adr[0] = i_z * nc_taylor; // offset of z_0[0] in taylor
	421	adr[0] = i_z * cap_order; // offset of z_0[0] in taylor
334	422	adr[1] = arg[1]; // index of y in taylor and partial
335	423	// use taylor both for parameter and variable values
336	424	reverse_mulpv_op(
337		d, i_z+1, adr, taylor, nc_taylor, taylor, nc_partial, partial
	425	d, i_z+1, adr, taylor, cap_order, taylor, nc_partial, partial
338	426	);
339	427
340	428	// z_0 = log(x)

343	431
344	432	// --------------------------- Powvp -----------------------------------------
345	433	/*!
346		Compute forward mode Taylor coefficients for result of op = PowvvOp.
	434	Compute forward mode Taylor coefficients for result of op = PowvpOp.
347	435
348	436	The C++ source code corresponding to this operation is
349	437	\verbatim

357	445
358	446	template <class Base>
359	447	inline void forward_powvp_op(
	448	size_t p ,
360	449	size_t q ,
361		size_t p ,
362		size_t i_z ,
363		const addr_t* arg ,
364		const Base* parameter ,
365		size_t nc_taylor ,
	450	size_t i_z ,
	451	const addr_t* arg ,
	452	const Base* parameter ,
	453	size_t cap_order ,
366	454	Base* taylor )
367	455	{
368	456	// convert from final result to first result

371	459	// check assumptions
372	460	CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
373	461	CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
374		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
375		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
376		CPPAD_ASSERT_UNKNOWN( q <= p );
377
378		// z_0 = log(x)
379		forward_log_op(q, p, i_z, arg[0], nc_taylor, taylor);
	462	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	463	CPPAD_ASSERT_UNKNOWN( p <= q );
	464
	465	// z_0 = log(x)
	466	forward_log_op(p, q, i_z, arg[0], cap_order, taylor);
380	467
381	468	// z_1 = y * z_0
382	469	addr_t adr[2];
383	470	adr[0] = arg[1];
384	471	adr[1] = i_z;
385		forward_mulpv_op(q, p, i_z+1, adr, parameter, nc_taylor, taylor);
	472	forward_mulpv_op(p, q, i_z+1, adr, parameter, cap_order, taylor);
386	473
387	474	// z_2 = exp(z_1)
388	475	// zero order case exactly same as Base type operation
389		if( q == 0 )
390		{ Base* z_2 = taylor + (i_z+2) * nc_taylor;
391		Base* x = taylor + arg[0] * nc_taylor;
	476	if( p == 0 )
	477	{ Base* z_2 = taylor + (i_z+2) * cap_order;
	478	Base* x = taylor + arg[0] * cap_order;
392	479	Base y = parameter[ arg[1] ];
393	480	z_2[0] = pow(x[0], y);
394		q++;
	481	p++;
395	482	}
396		if( q <= p )
397		forward_exp_op(q, p, i_z+2, i_z+1, nc_taylor, taylor);
398		}
399
400		/*!
401		Compute zero order forward mode Taylor coefficients for result of op = PowvvOp.
	483	if( p <= q )
	484	forward_exp_op(p, q, i_z+2, i_z+1, cap_order, taylor);
	485	}
	486	/*!
	487	Multiple directions forward mode Taylor coefficients for op = PowvpOp.
402	488
403	489	The C++ source code corresponding to this operation is
404	490	\verbatim

407	493	In the documentation below,
408	494	this operations is for the case where x is a variable and y is a parameter.
409	495
410		\copydetails forward_pow_op_0
411		*/
412
413		template <class Base>
414		inline void forward_powvp_op_0(
415		size_t i_z ,
416		const addr_t* arg ,
417		const Base* parameter ,
418		size_t nc_taylor ,
419		Base* taylor )
420		{
421		// convert from final result to first result
422		i_z -= 2; // NumRes(PowvpOp) - 1;
	496	\copydetails forward_pow_op_dir
	497	*/
	498
	499	template <class Base>
	500	inline void forward_powvp_op_dir(
	501	size_t q ,
	502	size_t r ,
	503	size_t i_z ,
	504	const addr_t* arg ,
	505	const Base* parameter ,
	506	size_t cap_order ,
	507	Base* taylor )
	508	{
	509	// convert from final result to first result
	510	i_z -= 2; // 2 = NumRes(PowvpOp) - 1
423	511
424	512	// check assumptions
425	513	CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
426	514	CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
427		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
	515	CPPAD_ASSERT_UNKNOWN( 0 < q );
	516	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	517
	518	// z_0 = log(x)
	519	forward_log_op_dir(q, r, i_z, arg[0], cap_order, taylor);
	520
	521	// z_1 = y * z_0
	522	addr_t adr[2];
	523	adr[0] = arg[1];
	524	adr[1] = i_z;
	525	forward_mulpv_op_dir(q, r, i_z+1, adr, parameter, cap_order, taylor);
	526
	527	// z_2 = exp(z_1)
	528	forward_exp_op_dir(q, r, i_z+2, i_z+1, cap_order, taylor);
	529	}
	530
	531	/*!
	532	Compute zero order forward mode Taylor coefficients for result of op = PowvpOp.
	533
	534	The C++ source code corresponding to this operation is
	535	\verbatim
	536	z = pow(x, y)
	537	\endverbatim
	538	In the documentation below,
	539	this operations is for the case where x is a variable and y is a parameter.
	540
	541	\copydetails forward_pow_op_0
	542	*/
	543
	544	template <class Base>
	545	inline void forward_powvp_op_0(
	546	size_t i_z ,
	547	const addr_t* arg ,
	548	const Base* parameter ,
	549	size_t cap_order ,
	550	Base* taylor )
	551	{
	552	// convert from final result to first result
	553	i_z -= 2; // NumRes(PowvpOp) - 1;
	554
	555	// check assumptions
	556	CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
	557	CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
428	558
429	559	// Paraemter value
430	560	Base y = parameter[ arg[1] ];
431	561
432	562	// Taylor coefficients corresponding to arguments and result
433		Base* x = taylor + arg[0] * nc_taylor;
434		Base* z_0 = taylor + i_z * nc_taylor;
435		Base* z_1 = z_0 + nc_taylor;
436		Base* z_2 = z_1 + nc_taylor;
	563	Base* x = taylor + arg[0] * cap_order;
	564	Base* z_0 = taylor + i_z * cap_order;
	565	Base* z_1 = z_0 + cap_order;
	566	Base* z_2 = z_1 + cap_order;
437	567
438	568	// z_0 = log(x)
439	569	z_0[0] = log(x[0]);

465	595	size_t i_z ,
466	596	const addr_t* arg ,
467	597	const Base* parameter ,
468		size_t nc_taylor ,
	598	size_t cap_order ,
469	599	const Base* taylor ,
470	600	size_t nc_partial ,
471	601	Base* partial )

476	606	// check assumptions
477	607	CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
478	608	CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
479		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
480		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	609	CPPAD_ASSERT_UNKNOWN( d < cap_order );
481	610	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
482	611
483	612	// z_2 = exp(z_1)
484	613	reverse_exp_op(
485		d, i_z+2, i_z+1, nc_taylor, taylor, nc_partial, partial
	614	d, i_z+2, i_z+1, cap_order, taylor, nc_partial, partial
486	615	);
487	616
488	617	// z_1 = y * z_0

490	619	adr[0] = arg[1];
491	620	adr[1] = i_z;
492	621	reverse_mulpv_op(
493		d, i_z+1, adr, parameter, nc_taylor, taylor, nc_partial, partial
	622	d, i_z+1, adr, parameter, cap_order, taylor, nc_partial, partial
494	623	);
495	624
496	625	// z_0 = log(x)
497	626	reverse_log_op(
498		d, i_z, arg[0], nc_taylor, taylor, nc_partial, partial
499		);
500		}
501
502		/! \} /
	627	d, i_z, arg[0], cap_order, taylor, nc_partial, partial
	628	);
	629	}
	630
503	631	} // END_CPPAD_NAMESPACE
504	632	# endif

-3

cppad/local/print_for.hpp less more

0		/* $Id: print_for.hpp 2859 2013-05-28 06:03:21Z bradbell $ */
	0	/* $Id: print_for.hpp 3170 2014-03-09 14:33:53Z bradbell $ */
1	1	# ifndef CPPAD_PRINT_FOR_INCLUDED
2	2	# define CPPAD_PRINT_FOR_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

41	41	%$$
42	42
43	43	$head Purpose$$
44		The $cref/zero order forward/ForwardZero/$$ mode command
	44	The $cref/zero order forward/forward_zero/$$ mode command
45	45	$codei%
46	46	%f%.Forward(0, %x%)
47	47	%$$

+10

-17

cppad/local/print_op.hpp less more

0		/* $Id: print_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: print_op.hpp 3323 2014-09-12 12:10:54Z bradbell $ */
1	1	# ifndef CPPAD_PRINT_OP_INCLUDED
2	2	# define CPPAD_PRINT_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

34	34	\param s_out
35	35	the results are printed on this output stream.
36	36
37		\param i_z
38		is the index of the next variable on the tape
39		(only used for error checking).
40
41	37	\param arg
42	38	\a arg[0] & 1
43	39	\n

51	47	\a arg[1]
52	48	\n
53	49	If \a pos is a parameter, <code>parameter[arg[1]]</code> is its value.
54		Othwise <code>taylor[ arg[1] * nc_taylor + 0 ]</code> is the zero
	50	Othwise <code>taylor[ arg[1] * cap_order + 0 ]</code> is the zero
55	51	order Taylor coefficient for \a pos.
56	52	\n
57	53	\n

64	60	\a arg[3]
65	61	\n
66	62	If \a var is a parameter, <code>parameter[arg[3]]</code> is its value.
67		Othwise <code>taylor[ arg[3] * nc_taylor + 0 ]</code> is the zero
	63	Othwise <code>taylor[ arg[3] * cap_order + 0 ]</code> is the zero
68	64	order Taylor coefficient for \a var.
69	65	\n
70	66	\n

88	84	\param parameter
89	85	Contains the value of parameters.
90	86
91		\param nc_taylor
	87	\param cap_order
92	88	number of colums in the matrix containing all the Taylor coefficients.
93	89
94	90	\param taylor

99	95	\li NumRes(PriOp) == 0
100	96	\li text != CPPAD_NULL
101	97	\li arg[1] < num_text
102		\li if \a pos is a variable, arg[1] < i_z, otherwise arg[1] < num_par
103		\li if \a var is a variable, arg[3] < i_z, otherwise arg[3] < num_par
	98	\li if \a pos is a parameter, arg[1] < num_par
	99	\li if \a var is a parameter, arg[3] < num_par
104	100	*/
105	101	template <class Base>
106	102	inline void forward_pri_0(
107	103	std::ostream& s_out ,
108		size_t i_z ,
109	104	const addr_t* arg ,
110	105	size_t num_text ,
111	106	const char* text ,
112	107	size_t num_par ,
113	108	const Base* parameter ,
114		size_t nc_taylor ,
	109	size_t cap_order ,
115	110	const Base* taylor )
116	111	{ Base pos, var;
117	112	const char* before;

120	115
121	116	// pos
122	117	if( arg[0] & 1 )
123		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= i_z );
124		pos = taylor[ arg[1] * nc_taylor + 0 ];
	118	{ pos = taylor[ arg[1] * cap_order + 0 ];
125	119	}
126	120	else
127	121	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );

134	128
135	129	// var
136	130	if( arg[0] & 2 )
137		{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) <= i_z );
138		var = taylor[ arg[3] * nc_taylor + 0 ];
	131	{ var = taylor[ arg[3] * cap_order + 0 ];
139	132	}
140	133	else
141	134	{ CPPAD_ASSERT_UNKNOWN( size_t(arg[3]) < num_par );

+545

-193

cppad/local/prototype_op.hpp less more

0		/* $Id: prototype_op.hpp 2921 2013-10-11 13:40:21Z bradbell $ */
	0	/* $Id: prototype_op.hpp 3321 2014-09-12 09:50:39Z bradbell $ */
1	1	# ifndef CPPAD_PROTOTYPE_OP_INCLUDED
2	2	# define CPPAD_PROTOTYPE_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup prototype_op_hpp prototype_op.hpp
19		\{
20	18	\file prototype_op.hpp
21	19	Documentation for generic cases (these generic cases are never used).
22	20	*/

32	30	using AD< \a Base > and computations by this routine are done using type
33	31	\a Base.
34	32
	33	\param p
	34	lowest order of the Taylor coefficient that we are computing.
	35
35	36	\param q
36		lowest order of the Taylor coefficient that we are computing.
37
38		\param p
39	37	highest order of the Taylor coefficient that we are computing.
40	38
41	39	\param i_z

46	44	variable index corresponding to the argument for this operator;
47	45	i.e. the row index in \a taylor corresponding to x.
48	46
49		\param nc_taylor
50		number of colums in the matrix containing all the Taylor coefficients.
51
52		\param taylor
53		\b Input: <code>taylor [ i_x * nc_taylor + k ]</code>,
54		for k = 0 , ... , p,
	47	\param cap_order
	48	maximum number of orders that will fit in the \c taylor array.
	49
	50	\param taylor
	51	\b Input: <code>taylor [ i_x * cap_order + k ]</code>,
	52	for k = 0 , ... , q,
55	53	is the k-th order Taylor coefficient corresponding to x.
56	54	\n
57		\b Input: <code>taylor [ i_z * nc_taylor + k ]</code>,
58		for k = 0 , ... , q-1,
	55	\b Input: <code>taylor [ i_z * cap_order + k ]</code>,
	56	for k = 0 , ... , p-1,
59	57	is the k-th order Taylor coefficient corresponding to z.
60	58	\n
61		\b Output: <code>taylor [ i_z * nc_taylor + k ]</code>,
62		for k = q , ... , p,
	59	\b Output: <code>taylor [ i_z * cap_order + k ]</code>,
	60	for k = p , ... , q,
63	61	is the k-th order Taylor coefficient corresponding to z.
64	62
65	63	\par Checked Assertions
66	64	\li NumArg(op) == 1
67	65	\li NumRes(op) == 1
68		\li i_x < i_z
69		\li p < nc_taylor
70		\li q <= p
	66	\li q < cap_order
	67	\li p <= q
71	68	*/
72	69	template <class Base>
73	70	inline void forward_unary1_op(
	71	size_t p ,
74	72	size_t q ,
75		size_t p ,
76	73	size_t i_z ,
77	74	size_t i_x ,
78		size_t nc_taylor ,
	75	size_t cap_order ,
79	76	Base* taylor )
80	77	{
81	78	// This routine is only for documentaiton, it should not be used

83	80	}
84	81
85	82	/*!
86		Prototype for zero order forward mode unary operator with one result (not used).
87		\tparam Base
88		base type for the operator; i.e., this operation was recorded
89		using AD< \a Base > and computations by this routine are done using type
90		\a Base .
91
92		\param i_z
93		variable index corresponding to the result for this operation;
	83	Prototype for multiple direction forward mode unary operator with one result
	84	(not used).
	85
	86	\tparam Base
	87	base type for the operator; i.e., this operation was recorded
	88	using AD< \a Base > and computations by this routine are done using type
	89	\a Base.
	90
	91	\param q
	92	order of the Taylor coefficients that we are computing.
	93
	94	\param r
	95	number of directions for Taylor coefficients that we are computing.
	96
	97	\param i_z
	98	variable index corresponding to the last (primary) result for this operation;
94	99	i.e. the row index in \a taylor corresponding to z.
	100	The auxillary result is called y has index \a i_z - 1.
95	101
96	102	\param i_x
97	103	variable index corresponding to the argument for this operator;
98	104	i.e. the row index in \a taylor corresponding to x.
99	105
100		\param nc_taylor
101		number of colums in the matrix containing all the Taylor coefficients.
102
103		\param taylor
104		\b Input: \a taylor [ \a i_x * \a nc_taylor + 0 ]
	106	\param cap_order
	107	maximum number of orders that will fit in the \c taylor array.
	108
	109	\par tpv
	110	We use the notation
	111	<code>tpv = (cap_order-1) * r + 1</code>
	112	which is the number of Taylor coefficients per variable
	113
	114	\param taylor
	115	\b Input: If x is a variable,
	116	<code>taylor [ arg[0] * tpv + 0 ]</code>,
	117	is the zero order Taylor coefficient for all directions and
	118	<code>taylor [ arg[0] * tpv + (k-1)*r + ell + 1 ]</code>,
	119	for k = 1 , ... , q,
	120	ell = 0, ..., r-1,
	121	is the k-th order Taylor coefficient
	122	corresponding to x and the ell-th direction.
	123	\n
	124	\b Input: <code>taylor [ i_z * tpv + 0 ]</code>,
	125	is the zero order Taylor coefficient for all directions and
	126	<code>taylor [ i_z * tpv + (k-1)*r + ell + 1 ]</code>,
	127	for k = 1 , ... , q-1,
	128	ell = 0, ..., r-1,
	129	is the k-th order Taylor coefficient
	130	corresponding to z and the ell-th direction.
	131	\n
	132	\b Output:
	133	<code>taylor [ i_z * tpv + (q-1)*r + ell + 1]</code>,
	134	ell = 0, ..., r-1,
	135	is the q-th order Taylor coefficient
	136	corresponding to z and the ell-th direction.
	137
	138	\par Checked Assertions
	139	\li NumArg(op) == 1
	140	\li NumRes(op) == 2
	141	\li i_x < i_z
	142	\li 0 < q
	143	\li q < cap_order
	144	*/
	145	template <class Base>
	146	inline void forward_unary1_op_dir(
	147	size_t q ,
	148	size_t r ,
	149	size_t i_z ,
	150	size_t i_x ,
	151	size_t cap_order ,
	152	Base* taylor )
	153	{
	154	// This routine is only for documentaiton, it should not be used
	155	CPPAD_ASSERT_UNKNOWN( false );
	156	}
	157
	158	/*!
	159	Prototype for zero order forward mode unary operator with one result (not used).
	160	\tparam Base
	161	base type for the operator; i.e., this operation was recorded
	162	using AD< \a Base > and computations by this routine are done using type
	163	\a Base .
	164
	165	\param i_z
	166	variable index corresponding to the result for this operation;
	167	i.e. the row index in \a taylor corresponding to z.
	168
	169	\param i_x
	170	variable index corresponding to the argument for this operator;
	171	i.e. the row index in \a taylor corresponding to x.
	172
	173	\param cap_order
	174	maximum number of orders that will fit in the \c taylor array.
	175
	176	\param taylor
	177	\b Input: \a taylor [ \a i_x * \a cap_order + 0 ]
105	178	is the zero order Taylor coefficient corresponding to x.
106	179	\n
107		\b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
	180	\b Output: \a taylor [ \a i_z * \a cap_order + 0 ]
108	181	is the zero order Taylor coefficient corresponding to z.
109	182
110	183	\par Checked Assertions
111	184	\li NumArg(op) == 1
112	185	\li NumRes(op) == 1
113	186	\li \a i_x < \a i_z
114		\li \a 0 < \a nc_taylor
	187	\li \a 0 < \a cap_order
115	188	*/
116	189	template <class Base>
117	190	inline void forward_unary1_op_0(
118	191	size_t i_z ,
119	192	size_t i_x ,
120		size_t nc_taylor ,
	193	size_t cap_order ,
121	194	Base* taylor )
122	195	{
123	196	// This routine is only for documentaiton, it should not be used

151	224	variable index corresponding to the argument for this operation;
152	225	i.e. the row index in \a taylor corresponding to x.
153	226
154		\param nc_taylor
155		number of colums in the matrix containing all the Taylor coefficients.
156
157		\param taylor
158		\a taylor [ \a i_x * \a nc_taylor + k ]
	227	\param cap_order
	228	maximum number of orders that will fit in the \c taylor array.
	229
	230	\param taylor
	231	\a taylor [ \a i_x * \a cap_order + k ]
159	232	for k = 0 , ... , \a d
160	233	is the k-th order Taylor coefficient corresponding to x.
161	234	\n
162		\a taylor [ \a i_z * \a nc_taylor + k ]
	235	\a taylor [ \a i_z * \a cap_order + k ]
163	236	for k = 0 , ... , \a d
164	237	is the k-th order Taylor coefficient corresponding to z.
165	238

191	264	\li NumArg(op) == 1
192	265	\li NumRes(op) == 1
193	266	\li \a i_x < \a i_z
194		\li \a d < \a nc_taylor
	267	\li \a d < \a cap_order
195	268	\li \a d < \a nc_partial
196	269	*/
197	270	template <class Base>

199	272	size_t d ,
200	273	size_t i_z ,
201	274	size_t i_x ,
202		size_t nc_taylor ,
	275	size_t cap_order ,
203	276	const Base* taylor ,
204	277	size_t nc_partial ,
205	278	Base* partial )

218	291	using AD< \a Base > and computations by this routine are done using type
219	292	\a Base.
220	293
	294	\param p
	295	lowest order of the Taylor coefficients that we are computing.
	296
221	297	\param q
222		lowest order of the Taylor coefficients that we are computing.
223
224		\param p
225	298	highest order of the Taylor coefficients that we are computing.
226	299
227	300	\param i_z

233	306	variable index corresponding to the argument for this operator;
234	307	i.e. the row index in \a taylor corresponding to x.
235	308
236		\param nc_taylor
237		number of colums in the matrix containing all the Taylor coefficients.
238
239		\param taylor
240		\b Input: <code>taylor [ i_x * nc_taylor + k ]</code>
241		for k = 0 , ... , p,
	309	\param cap_order
	310	maximum number of orders that will fit in the \c taylor array.
	311
	312	\param taylor
	313	\b Input: <code>taylor [ i_x * cap_order + k ]</code>
	314	for k = 0 , ... , q,
242	315	is the k-th order Taylor coefficient corresponding to x.
243	316	\n
244		\b Input: <code>taylor [ i_z * nc_taylor + k ]</code>
245		for k = 0 , ... , q - 1,
	317	\b Input: <code>taylor [ i_z * cap_order + k ]</code>
	318	for k = 0 , ... , p - 1,
246	319	is the k-th order Taylor coefficient corresponding to z.
247	320	\n
248		\b Input: <code>taylor [ ( i_z - 1) * nc_taylor + k ]</code>
249		for k = 0 , ... , q-1,
	321	\b Input: <code>taylor [ ( i_z - 1) * cap_order + k ]</code>
	322	for k = 0 , ... , p-1,
250	323	is the k-th order Taylor coefficient corresponding to the auxillary result y.
251	324	\n
252		\b Output: <code>taylor [ i_z * nc_taylor + k ]</code>,
253		for k = q , ... , p,
	325	\b Output: <code>taylor [ i_z * cap_order + k ]</code>,
	326	for k = p , ... , q,
254	327	is the k-th order Taylor coefficient corresponding to z.
255	328	\n
256		\b Output: <code>taylor [ ( i_z - 1 ) * nc_taylor + k ]</code>,
257		for k = q , ... , p,
	329	\b Output: <code>taylor [ ( i_z - 1 ) * cap_order + k ]</code>,
	330	for k = p , ... , q,
258	331	is the k-th order Taylor coefficient corresponding to
259	332	the autillary result y.
260	333

262	335	\li NumArg(op) == 1
263	336	\li NumRes(op) == 2
264	337	\li i_x + 1 < i_z
265		\li p < nc_taylor
266		\li q <= p
	338	\li q < cap_order
	339	\li p <= q
267	340	*/
268	341	template <class Base>
269	342	inline void forward_unary2_op(
	343	size_t p ,
270	344	size_t q ,
271		size_t p ,
272	345	size_t i_z ,
273	346	size_t i_x ,
274		size_t nc_taylor ,
	347	size_t cap_order ,
	348	Base* taylor )
	349	{
	350	// This routine is only for documentaiton, it should not be used
	351	CPPAD_ASSERT_UNKNOWN( false );
	352	}
	353
	354	/*!
	355	Prototype for multiple direction forward mode unary operator with two results
	356	(not used).
	357
	358	\tparam Base
	359	base type for the operator; i.e., this operation was recorded
	360	using AD< \a Base > and computations by this routine are done using type
	361	\a Base.
	362
	363	\param q
	364	order of the Taylor coefficients that we are computing.
	365
	366	\param r
	367	number of directions for Taylor coefficients that we are computing.
	368
	369	\param i_z
	370	variable index corresponding to the last (primary) result for this operation;
	371	i.e. the row index in \a taylor corresponding to z.
	372	The auxillary result is called y has index \a i_z - 1.
	373
	374	\param i_x
	375	variable index corresponding to the argument for this operator;
	376	i.e. the row index in \a taylor corresponding to x.
	377
	378	\param cap_order
	379	maximum number of orders that will fit in the \c taylor array.
	380
	381	\par tpv
	382	We use the notation
	383	<code>tpv = (cap_order-1) * r + 1</code>
	384	which is the number of Taylor coefficients per variable
	385
	386	\param taylor
	387	\b Input: <code>taylor [ i_x * tpv + 0 ]</code>
	388	is the zero order Taylor coefficient for all directions and
	389	<code>taylor [ i_x * tpv + (k-1)*r + ell + 1</code>
	390	for k = 1 , ... , q,
	391	ell = 0 , ..., r-1,
	392	is the k-th order Taylor coefficient
	393	corresponding to x and the ell-th direction.
	394	\n
	395	\b Input: <code>taylor [ i_z * tpv + 0 ]</code>,
	396	is the zero order Taylor coefficient for all directions and
	397	<code>taylor [ i_z * tpv + (k-1)*r + ell + 1 ]</code>,
	398	for k = 1 , ... , q-1,
	399	ell = 0, ..., r-1,
	400	is the k-th order Taylor coefficient
	401	corresponding to z and the ell-th direction.
	402	\n
	403	\b Input: <code>taylor [ (i_z-1) * tpv + 0 ]</code>,
	404	is the zero order Taylor coefficient for all directions and
	405	<code>taylor [ (i_z-1) * tpv + (k-1)*r + ell + 1 ]</code>,
	406	for k = 1 , ... , q-1,
	407	ell = 0, ..., r-1,
	408	is the k-th order Taylor coefficient
	409	corresponding to the auxillary result y and the ell-th direction.
	410	\n
	411	\b Output:
	412	<code>taylor [ i_z * tpv + (q-1)*r + ell + 1]</code>,
	413	ell = 0, ..., r-1,
	414	is the q-th order Taylor coefficient
	415	corresponding to z and the ell-th direction.
	416
	417	\par Checked Assertions
	418	\li NumArg(op) == 1
	419	\li NumRes(op) == 2
	420	\li i_x + 1 < i_z
	421	\li 0 < q
	422	\li q < cap_order
	423	*/
	424	template <class Base>
	425	inline void forward_unary2_op_dir(
	426	size_t q ,
	427	size_t r ,
	428	size_t i_z ,
	429	size_t i_x ,
	430	size_t cap_order ,
275	431	Base* taylor )
276	432	{
277	433	// This routine is only for documentaiton, it should not be used

294	450	variable index corresponding to the argument for this operator;
295	451	i.e. the row index in \a taylor corresponding to x.
296	452
297		\param nc_taylor
298		number of colums in the matrix containing all the Taylor coefficients.
299
300		\param taylor
301		\b Input: \a taylor [ \a i_x * \a nc_taylor + 0 ]
	453	\param cap_order
	454	maximum number of orders that will fit in the \c taylor array.
	455
	456	\param taylor
	457	\b Input: \a taylor [ \a i_x * \a cap_order + 0 ]
302	458	is the zero order Taylor coefficient corresponding to x.
303	459	\n
304		\b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
	460	\b Output: \a taylor [ \a i_z * \a cap_order + 0 ]
305	461	is the zero order Taylor coefficient corresponding to z.
306	462	\n
307		\b Output: \a taylor [ ( \a i_z - 1 ) * \a nc_taylor + j ]
	463	\b Output: \a taylor [ ( \a i_z - 1 ) * \a cap_order + j ]
308	464	is the j-th order Taylor coefficient corresponding to
309	465	the autillary result y.
310	466

312	468	\li NumArg(op) == 1
313	469	\li NumRes(op) == 2
314	470	\li \a i_x + 1 < \a i_z
315		\li \a j < \a nc_taylor
	471	\li \a j < \a cap_order
316	472	*/
317	473	template <class Base>
318	474	inline void forward_unary2_op_0(
319	475	size_t i_z ,
320	476	size_t i_x ,
321		size_t nc_taylor ,
	477	size_t cap_order ,
322	478	Base* taylor )
323	479	{
324	480	// This routine is only for documentaiton, it should not be used

353	509	variable index corresponding to the argument for this operation;
354	510	i.e. the row index in \a taylor corresponding to x.
355	511
356		\param nc_taylor
357		number of colums in the matrix containing all the Taylor coefficients.
358
359		\param taylor
360		\a taylor [ \a i_x * \a nc_taylor + k ]
	512	\param cap_order
	513	maximum number of orders that will fit in the \c taylor array.
	514
	515	\param taylor
	516	\a taylor [ \a i_x * \a cap_order + k ]
361	517	for k = 0 , ... , \a d
362	518	is the k-th order Taylor coefficient corresponding to x.
363	519	\n
364		\a taylor [ \a i_z * \a nc_taylor + k ]
	520	\a taylor [ \a i_z * \a cap_order + k ]
365	521	for k = 0 , ... , \a d
366	522	is the k-th order Taylor coefficient corresponding to z.
367	523	\n
368		\a taylor [ ( \a i_z - 1) * \a nc_taylor + k ]
	524	\a taylor [ ( \a i_z - 1) * \a cap_order + k ]
369	525	for k = 0 , ... , \a d
370	526	is the k-th order Taylor coefficient corresponding to
371	527	the auxillary variable y.

404	560	\li NumArg(op) == 1
405	561	\li NumRes(op) == 2
406	562	\li \a i_x + 1 < \a i_z
407		\li \a d < \a nc_taylor
	563	\li \a d < \a cap_order
408	564	\li \a d < \a nc_partial
409	565	*/
410	566	template <class Base>

412	568	size_t d ,
413	569	size_t i_z ,
414	570	size_t i_x ,
415		size_t nc_taylor ,
	571	size_t cap_order ,
416	572	const Base* taylor ,
417	573	size_t nc_partial ,
418	574	Base* partial )

430	586	using AD< \a Base > and computations by this routine are done using type
431	587	\a Base.
432	588
	589	\param p
	590	lowest order of the Taylor coefficient that we are computing.
	591
433	592	\param q
434		lowest order of the Taylor coefficient that we are computing.
435
436		\param p
437	593	highest order of the Taylor coefficient that we are computing.
438	594
439	595	\param i_z

456	612	If y is a parameter, \a parameter [ \a arg[1] ]
457	613	is the value corresponding to y.
458	614
459		\param nc_taylor
460		number of colums in the matrix containing all the Taylor coefficients.
	615	\param cap_order
	616	maximum number of orders that will fit in the \c taylor array.
461	617
462	618	\param taylor
463	619	\b Input: If x is a variable,
464		<code>taylor [ arg[0] * nc_taylor + k ]</code>,
465		for k = 0 , ... , p,
	620	<code>taylor [ arg[0] * cap_order + k ]</code>,
	621	for k = 0 , ... , q,
466	622	is the k-th order Taylor coefficient corresponding to x.
467	623	\n
468	624	\b Input: If y is a variable,
469		<code>taylor [ arg[1] * nc_taylor + k ]</code>,
470		for k = 0 , ... , p,
	625	<code>taylor [ arg[1] * cap_order + k ]</code>,
	626	for k = 0 , ... , q,
471	627	is the k-th order Taylor coefficient corresponding to y.
472	628	\n
473		\b Input: <code>taylor [ i_z * nc_taylor + k ]</code>,
474		for k = 0 , ... , q-1,
	629	\b Input: <code>taylor [ i_z * cap_order + k ]</code>,
	630	for k = 0 , ... , p-1,
475	631	is the k-th order Taylor coefficient corresponding to z.
476	632	\n
477		\b Output: <code>taylor [ i_z * nc_taylor + k ]</code>,
478		for k = q, ... , p,
	633	\b Output: <code>taylor [ i_z * cap_order + k ]</code>,
	634	for k = p, ... , q,
479	635	is the k-th order Taylor coefficient corresponding to z.
480	636
481	637	\par Checked Assertions
482	638	\li NumArg(op) == 2
483	639	\li NumRes(op) == 1
484		\li If x is a variable, arg[0] < i_z
485		\li If y is a variable, arg[1] < i_z
486		\li p < nc_taylor
487		\li q <= p
	640	\li q < cap_order
	641	\li p <= q
488	642	*/
489	643	template <class Base>
490	644	inline void forward_binary_op(
	645	size_t p ,
491	646	size_t q ,
492		size_t p ,
493	647	size_t i_z ,
494	648	const addr_t* arg ,
495	649	const Base* parameter ,
496		size_t nc_taylor ,
	650	size_t cap_order ,
497	651	Base* taylor )
498	652	{
499	653	// This routine is only for documentaiton, it should not be used
500	654	CPPAD_ASSERT_UNKNOWN( false );
501	655	}
502	656
503
504		/*!
505		Prototype zero order forward mode x op y (not used)
	657	/*!
	658	Prototype multiple direction forward mode x op y (not used)
506	659
507	660	\tparam Base
508	661	base type for the operator; i.e., this operation was recorded
509	662	using AD< \a Base > and computations by this routine are done using type
510	663	\a Base.
	664
	665	\param q
	666	is the order of the Taylor coefficients that we are computing.
	667
	668	\param r
	669	number of directions for Taylor coefficients that we are computing
511	670
512	671	\param i_z
513	672	variable index corresponding to the result for this operation;

529	688	If y is a parameter, \a parameter [ \a arg[1] ]
530	689	is the value corresponding to y.
531	690
532		\param nc_taylor
533		number of colums in the matrix containing all the Taylor coefficients.
534
535		\param taylor
536		\b Input: If x is a variable, \a taylor [ \a arg[0] * \a nc_taylor + 0 ]
537		is the zero order Taylor coefficient corresponding to x.
538		\n
539		\b Input: If y is a variable, \a taylor [ \a arg[1] * \a nc_taylor + 0 ]
540		is the zero order Taylor coefficient corresponding to y.
541		\n
542		\b Output: \a taylor [ \a i_z * \a nc_taylor + 0 ]
543		is the zero order Taylor coefficient corresponding to z.
	691	\param cap_order
	692	maximum number of orders that will fit in the \c taylor array.
	693
	694	\par tpv
	695	We use the notation
	696	<code>tpv = (cap_order-1) * r + 1</code>
	697	which is the number of Taylor coefficients per variable
	698
	699	\param taylor
	700	\b Input: If x is a variable,
	701	<code>taylor [ arg[0] * tpv + 0 ]</code>,
	702	is the zero order Taylor coefficient for all directions and
	703	<code>taylor [ arg[0] * tpv + (k-1)*r + ell + 1 ]</code>,
	704	for k = 1 , ... , q,
	705	ell = 0, ..., r-1,
	706	is the k-th order Taylor coefficient
	707	corresponding to x and the ell-th direction.
	708	\n
	709	\b Input: If y is a variable,
	710	<code>taylor [ arg[1] * tpv + 0 ]</code>,
	711	is the zero order Taylor coefficient for all directions and
	712	<code>taylor [ arg[1] * tpv + (k-1)*r + ell + 1 ]</code>,
	713	for k = 1 , ... , q,
	714	ell = 0, ..., r-1,
	715	is the k-th order Taylor coefficient
	716	corresponding to y and the ell-th direction.
	717	\n
	718	\b Input: <code>taylor [ i_z * tpv + 0 ]</code>,
	719	is the zero order Taylor coefficient for all directions and
	720	<code>taylor [ i_z * tpv + (k-1)*r + ell + 1 ]</code>,
	721	for k = 1 , ... , q-1,
	722	ell = 0, ..., r-1,
	723	is the k-th order Taylor coefficient
	724	corresponding to z and the ell-th direction.
	725	\n
	726	\b Output:
	727	<code>taylor [ i_z * tpv + (q-1)*r + ell + 1]</code>,
	728	ell = 0, ..., r-1,
	729	is the q-th order Taylor coefficient
	730	corresponding to z and the ell-th direction.
544	731
545	732	\par Checked Assertions
546	733	\li NumArg(op) == 2
547	734	\li NumRes(op) == 1
548		\li If x is a variable, \a arg[0] < \a i_z
549		\li If y is a variable, \a arg[1] < \a i_z
	735	\li 0 < q < cap_order
	736	*/
	737	template <class Base>
	738	inline void forward_binary_op_dir(
	739	size_t q ,
	740	size_t r ,
	741	size_t i_z ,
	742	const addr_t* arg ,
	743	const Base* parameter ,
	744	size_t cap_order ,
	745	Base* taylor )
	746	{
	747	// This routine is only for documentaiton, it should not be used
	748	CPPAD_ASSERT_UNKNOWN( false );
	749	}
	750
	751
	752	/*!
	753	Prototype zero order forward mode x op y (not used)
	754
	755	\tparam Base
	756	base type for the operator; i.e., this operation was recorded
	757	using AD< \a Base > and computations by this routine are done using type
	758	\a Base.
	759
	760	\param i_z
	761	variable index corresponding to the result for this operation;
	762	i.e. the row index in \a taylor corresponding to z.
	763
	764	\param arg
	765	\a arg[0]
	766	index corresponding to the left operand for this operator;
	767	i.e. the index corresponding to x.
	768	\n
	769	\a arg[1]
	770	index corresponding to the right operand for this operator;
	771	i.e. the index corresponding to y.
	772
	773	\param parameter
	774	If x is a parameter, \a parameter [ \a arg[0] ]
	775	is the value corresponding to x.
	776	\n
	777	If y is a parameter, \a parameter [ \a arg[1] ]
	778	is the value corresponding to y.
	779
	780	\param cap_order
	781	maximum number of orders that will fit in the \c taylor array.
	782
	783	\param taylor
	784	\b Input: If x is a variable, \a taylor [ \a arg[0] * \a cap_order + 0 ]
	785	is the zero order Taylor coefficient corresponding to x.
	786	\n
	787	\b Input: If y is a variable, \a taylor [ \a arg[1] * \a cap_order + 0 ]
	788	is the zero order Taylor coefficient corresponding to y.
	789	\n
	790	\b Output: \a taylor [ \a i_z * \a cap_order + 0 ]
	791	is the zero order Taylor coefficient corresponding to z.
	792
	793	\par Checked Assertions
	794	\li NumArg(op) == 2
	795	\li NumRes(op) == 1
550	796	*/
551	797	template <class Base>
552	798	inline void forward_binary_op_0(
553	799	size_t i_z ,
554	800	const addr_t* arg ,
555	801	const Base* parameter ,
556		size_t nc_taylor ,
	802	size_t cap_order ,
557	803	Base* taylor )
558	804	{
559	805	// This routine is only for documentaiton, it should not be used

599	845	If y is a parameter, \a parameter [ \a arg[1] ]
600	846	is the value corresponding to y.
601	847
602		\param nc_taylor
603		number of colums in the matrix containing all the Taylor coefficients.
604
605		\param taylor
606		\a taylor [ \a i_z * \a nc_taylor + k ]
	848	\param cap_order
	849	maximum number of orders that will fit in the \c taylor array.
	850
	851	\param taylor
	852	\a taylor [ \a i_z * \a cap_order + k ]
607	853	for k = 0 , ... , \a d
608	854	is the k-th order Taylor coefficient corresponding to z.
609	855	\n
610		If x is a variable, \a taylor [ \a arg[0] * \a nc_taylor + k ]
	856	If x is a variable, \a taylor [ \a arg[0] * \a cap_order + k ]
611	857	for k = 0 , ... , \a d
612	858	is the k-th order Taylor coefficient corresponding to x.
613	859	\n
614		If y is a variable, \a taylor [ \a arg[1] * \a nc_taylor + k ]
	860	If y is a variable, \a taylor [ \a arg[1] * \a cap_order + k ]
615	861	for k = 0 , ... , \a d
616	862	is the k-th order Taylor coefficient corresponding to y.
617	863

654	900	\li NumRes(op) == 1
655	901	\li \a If x is a variable, arg[0] < \a i_z
656	902	\li \a If y is a variable, arg[1] < \a i_z
657		\li \a d < \a nc_taylor
	903	\li \a d < \a cap_order
658	904	\li \a d < \a nc_partial
659	905	*/
660	906	template <class Base>

663	909	size_t i_z ,
664	910	addr_t* arg ,
665	911	const Base* parameter ,
666		size_t nc_taylor ,
	912	size_t cap_order ,
667	913	const Base* taylor ,
668	914	size_t nc_partial ,
669	915	Base* partial )

680	926	using AD< \a Base > and computations by this routine are done using type
681	927	\a Base.
682	928
	929	\param p
	930	lowest order of the Taylor coefficient that we are computing.
	931
683	932	\param q
684		lowest order of the Taylor coefficient that we are computing.
685
686		\param p
687	933	highest order of the Taylor coefficient that we are computing.
688	934
689	935	\param i_z

714	960	If y is a parameter, \a parameter [ \a arg[1] ]
715	961	is the value corresponding to y.
716	962
717		\param nc_taylor
718		number of colums in the matrix containing all the Taylor coefficients.
	963	\param cap_order
	964	maximum number of orders that will fit in the \c taylor array.
719	965
720	966	\param taylor
721	967	\b Input: If x is a variable,
722		<code>taylor [ arg[0] * nc_taylor + k ]</code>
723		for k = 0 , ... , p,
	968	<code>taylor [ arg[0] * cap_order + k ]</code>
	969	for k = 0 , ... , q,
724	970	is the k-th order Taylor coefficient corresponding to x.
725	971	\n
726	972	\b Input: If y is a variable,
727		<code>taylor [ arg[1] * nc_taylor + k ]</code>
728		for k = 0 , ... , p
	973	<code>taylor [ arg[1] * cap_order + k ]</code>
	974	for k = 0 , ... , q
729	975	is the k-th order Taylor coefficient corresponding to y.
730	976	\n
731		\b Input: <code>taylor [ (i_z-2+j) * nc_taylor + k ]</code>,
732		for j = 0, 1, 2 , for k = 0 , ... , q-1,
	977	\b Input: <code>taylor [ (i_z-2+j) * cap_order + k ]</code>,
	978	for j = 0, 1, 2 , for k = 0 , ... , p-1,
733	979	is the k-th order Taylor coefficient corresponding to z_j.
734	980	\n
735		\b Output: <code>taylor [ (i_z-2+j) * nc_taylor + k ]</code>,
	981	\b Output: <code>taylor [ (i_z-2+j) * cap_order + k ]</code>,
736	982	is the k-th order Taylor coefficient corresponding to z_j.
737	983
738	984	\par Checked Assertions

740	986	\li NumRes(op) == 3
741	987	\li If x is a variable, arg[0] < i_z - 2
742	988	\li If y is a variable, arg[1] < i_z - 2
743		\li p < nc_taylor
744		\li q <= p
	989	\li q < cap_order
	990	\li p <= q
745	991	*/
746	992	template <class Base>
747	993	inline void forward_pow_op(
	994	size_t p ,
748	995	size_t q ,
749		size_t p ,
750	996	size_t i_z ,
751	997	const addr_t* arg ,
752	998	const Base* parameter ,
753		size_t nc_taylor ,
	999	size_t cap_order ,
754	1000	Base* taylor )
755	1001	{
756	1002	// This routine is only for documentaiton, it should not be used
757	1003	CPPAD_ASSERT_UNKNOWN( false );
758	1004	}
759	1005	/*!
760		Prototype for zero order forward mode z = pow(x, y) (not used).
	1006	Prototype for multiple direction forward mode z = pow(x, y) (not used).
761	1007
762	1008	\tparam Base
763	1009	base type for the operator; i.e., this operation was recorded
764	1010	using AD< \a Base > and computations by this routine are done using type
765	1011	\a Base.
	1012
	1013	\param q
	1014	order of the Taylor coefficient that we are computing.
	1015
	1016	\param r
	1017	is the number of Taylor coefficient directions that we are computing
766	1018
767	1019	\param i_z
768	1020	variable index corresponding to the last (primary) result for this operation;

792	1044	If y is a parameter, \a parameter [ \a arg[1] ]
793	1045	is the value corresponding to y.
794	1046
795		\param nc_taylor
796		number of colums in the matrix containing all the Taylor coefficients.
797
798		\param taylor
799		\b Input: If x is a variable, \a taylor [ \a arg[0] * \a nc_taylor + 0 ]
800		is the zero order Taylor coefficient corresponding to x.
801		\n
802		\b Input: If y is a variable, \a taylor [ \a arg[1] * \a nc_taylor + 0 ]
803		is the k-th order Taylor coefficient corresponding to y.
804		\n
805		\b Output: \a taylor [ \a (i_z - 2 + j) * \a nc_taylor + 0 ]
806		is the zero order Taylor coefficient corresponding to z_j.
	1047	\param cap_order
	1048	maximum number of orders that will fit in the \c taylor array.
	1049
	1050	\par tpv
	1051	We use the notation
	1052	<code>tpv = (cap_order-1) * r + 1</code>
	1053	which is the number of Taylor coefficients per variable
	1054
	1055	\param taylor
	1056	\b Input: If x is a variable,
	1057	<code>taylor [ arg[0] * tpv + 0 ]</code>
	1058	is the zero order coefficient corresponding to x and
	1059	<code>taylor [ arg[0] * tpv + (k-1)*r+1+ell ]</code>
	1060	for k = 1 , ... , q,
	1061	ell = 0 , ... , r-1,
	1062	is the k-th order Taylor coefficient corresponding to x
	1063	for the ell-th direction.
	1064	\n
	1065	\n
	1066	\b Input: If y is a variable,
	1067	<code>taylor [ arg[1] * tpv + 0 ]</code>
	1068	is the zero order coefficient corresponding to y and
	1069	<code>taylor [ arg[1] * tpv + (k-1)*r+1+ell ]</code>
	1070	for k = 1 , ... , q,
	1071	ell = 0 , ... , r-1,
	1072	is the k-th order Taylor coefficient corresponding to y
	1073	for the ell-th direction.
	1074	\n
	1075	\n
	1076	\b Input:
	1077	<code>taylor [ (i_z-2+j) * tpv + 0 ]</code>,
	1078	is the zero order coefficient corresponding to z_j and
	1079	<code>taylor [ (i_z-2+j) * tpv + (k-1)*r+1+ell ]</code>,
	1080	for j = 0, 1, 2 , k = 0 , ... , q-1, ell = 0, ... , r-1,
	1081	is the k-th order Taylor coefficient corresponding to z_j
	1082	for the ell-th direction.
	1083	\n
	1084	\n
	1085	\b Output:
	1086	<code>taylor [ (i_z-2+j) * tpv + (q-1)*r+1+ell ]</code>,
	1087	for j = 0, 1, 2 , ell = 0, ... , r-1,
	1088	is the q-th order Taylor coefficient corresponding to z_j
	1089	for the ell-th direction.
807	1090
808	1091	\par Checked Assertions
809	1092	\li NumArg(op) == 2
810	1093	\li NumRes(op) == 3
811		\li If x is a variable, \a arg[0] < \a i_z - 2
812		\li If y is a variable, \a arg[1] < \a i_z - 2
813		*/
814		template <class Base>
815		inline void forward_pow_op_0(
	1094	\li If x is a variable, arg[0] < i_z - 2
	1095	\li If y is a variable, arg[1] < i_z - 2
	1096	\li 0 < q
	1097	\li q < cap_order
	1098	*/
	1099	template <class Base>
	1100	inline void forward_pow_op_dir(
	1101	size_t q ,
	1102	size_t r ,
816	1103	size_t i_z ,
817	1104	const addr_t* arg ,
818	1105	const Base* parameter ,
819		size_t nc_taylor ,
	1106	size_t cap_order ,
820	1107	Base* taylor )
821	1108	{
822	1109	// This routine is only for documentaiton, it should not be used
823	1110	CPPAD_ASSERT_UNKNOWN( false );
824	1111	}
825	1112	/*!
826		Prototype for reverse mode z = pow(x, y) (not used).
827
828		This routine is given the partial derivatives of a function
829		G( z , y , x , w , ... )
830		and it uses them to compute the partial derivatives of
831		\verbatim
832		H( y , x , w , u , ... ) = G[ pow(x , y) , y , x , w , u , ... ]
833		\endverbatim
834
835		\tparam Base
836		base type for the operator; i.e., this operation was recorded
837		using AD< \a Base > and computations by this routine are done using type
838		\a Base .
839
840		\param d
841		highest order Taylor coefficient that
842		we are computing the partial derivatives with respect to.
	1113	Prototype for zero order forward mode z = pow(x, y) (not used).
	1114
	1115	\tparam Base
	1116	base type for the operator; i.e., this operation was recorded
	1117	using AD< \a Base > and computations by this routine are done using type
	1118	\a Base.
843	1119
844	1120	\param i_z
845	1121	variable index corresponding to the last (primary) result for this operation;

869	1145	If y is a parameter, \a parameter [ \a arg[1] ]
870	1146	is the value corresponding to y.
871	1147
872		\param nc_taylor
873		number of colums in the matrix containing all the Taylor coefficients.
874
875		\param taylor
876		\a taylor [ \a (i_z - 2 + j) * \a nc_taylor + k ]
	1148	\param cap_order
	1149	maximum number of orders that will fit in the \c taylor array.
	1150
	1151	\param taylor
	1152	\b Input: If x is a variable, \a taylor [ \a arg[0] * \a cap_order + 0 ]
	1153	is the zero order Taylor coefficient corresponding to x.
	1154	\n
	1155	\b Input: If y is a variable, \a taylor [ \a arg[1] * \a cap_order + 0 ]
	1156	is the k-th order Taylor coefficient corresponding to y.
	1157	\n
	1158	\b Output: \a taylor [ \a (i_z - 2 + j) * \a cap_order + 0 ]
	1159	is the zero order Taylor coefficient corresponding to z_j.
	1160
	1161	\par Checked Assertions
	1162	\li NumArg(op) == 2
	1163	\li NumRes(op) == 3
	1164	\li If x is a variable, \a arg[0] < \a i_z - 2
	1165	\li If y is a variable, \a arg[1] < \a i_z - 2
	1166	*/
	1167	template <class Base>
	1168	inline void forward_pow_op_0(
	1169	size_t i_z ,
	1170	const addr_t* arg ,
	1171	const Base* parameter ,
	1172	size_t cap_order ,
	1173	Base* taylor )
	1174	{
	1175	// This routine is only for documentaiton, it should not be used
	1176	CPPAD_ASSERT_UNKNOWN( false );
	1177	}
	1178	/*!
	1179	Prototype for reverse mode z = pow(x, y) (not used).
	1180
	1181	This routine is given the partial derivatives of a function
	1182	G( z , y , x , w , ... )
	1183	and it uses them to compute the partial derivatives of
	1184	\verbatim
	1185	H( y , x , w , u , ... ) = G[ pow(x , y) , y , x , w , u , ... ]
	1186	\endverbatim
	1187
	1188	\tparam Base
	1189	base type for the operator; i.e., this operation was recorded
	1190	using AD< \a Base > and computations by this routine are done using type
	1191	\a Base .
	1192
	1193	\param d
	1194	highest order Taylor coefficient that
	1195	we are computing the partial derivatives with respect to.
	1196
	1197	\param i_z
	1198	variable index corresponding to the last (primary) result for this operation;
	1199	i.e. the row index in \a taylor corresponding to z.
	1200	Note that there are three results for this operation,
	1201	below they are referred to as z_0, z_1, z_2 and correspond to
	1202	\verbatim
	1203	z_0 = log(x)
	1204	z_1 = z0 * y
	1205	z_2 = exp(z1)
	1206	\endverbatim
	1207	It follows that the final result is equal to z; i.e., z = z_2 = pow(x, y).
	1208
	1209	\param arg
	1210	\a arg[0]
	1211	index corresponding to the left operand for this operator;
	1212	i.e. the index corresponding to x.
	1213	\n
	1214	\a arg[1]
	1215	index corresponding to the right operand for this operator;
	1216	i.e. the index corresponding to y.
	1217
	1218	\param parameter
	1219	If x is a parameter, \a parameter [ \a arg[0] ]
	1220	is the value corresponding to x.
	1221	\n
	1222	If y is a parameter, \a parameter [ \a arg[1] ]
	1223	is the value corresponding to y.
	1224
	1225	\param cap_order
	1226	maximum number of orders that will fit in the \c taylor array.
	1227
	1228	\param taylor
	1229	\a taylor [ \a (i_z - 2 + j) * \a cap_order + k ]
877	1230	for j = 0, 1, 2 and k = 0 , ... , \a d
878	1231	is the k-th order Taylor coefficient corresponding to z_j.
879	1232	\n
880		If x is a variable, \a taylor [ \a arg[0] * \a nc_taylor + k ]
	1233	If x is a variable, \a taylor [ \a arg[0] * \a cap_order + k ]
881	1234	for k = 0 , ... , \a d
882	1235	is the k-th order Taylor coefficient corresponding to x.
883	1236	\n
884		If y is a variable, \a taylor [ \a arg[1] * \a nc_taylor + k ]
	1237	If y is a variable, \a taylor [ \a arg[1] * \a cap_order + k ]
885	1238	for k = 0 , ... , \a d
886	1239	is the k-th order Taylor coefficient corresponding to y.
887	1240

924	1277	\li NumRes(op) == 3
925	1278	\li \a If x is a variable, arg[0] < \a i_z - 2
926	1279	\li \a If y is a variable, arg[1] < \a i_z - 2
927		\li \a d < \a nc_taylor
	1280	\li \a d < \a cap_order
928	1281	\li \a d < \a nc_partial
929	1282	*/
930	1283	template <class Base>

933	1286	size_t i_z ,
934	1287	addr_t* arg ,
935	1288	const Base* parameter ,
936		size_t nc_taylor ,
	1289	size_t cap_order ,
937	1290	const Base* taylor ,
938	1291	size_t nc_partial ,
939	1292	Base* partial )

1102	1455	}
1103	1456
1104	1457
1105		/! \} /
1106	1458	} // END_CPPAD_NAMESPACE
1107	1459	# endif

+149

-90

cppad/local/recorder.hpp less more

0		/* $Id: recorder.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: recorder.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_RECORDER_INCLUDED
2	2	# define CPPAD_RECORDER_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup recorder_hpp recorder.hpp
19		\{
20	18	\file recorder.hpp
21	19	File used to define the recorder class.
22	20	*/

38	36	const size_t thread_offset_;
39	37
40	38	/// Number of variables in the recording.
41		size_t num_rec_var_;
	39	size_t num_var_rec_;
	40
	41	/// Number vecad load operations (LdpOp or LdvOp) currently in recording.
	42	size_t num_load_op_rec_;
42	43
43	44	/// The operators in the recording.
44		pod_vector<CPPAD_OP_CODE_TYPE> rec_op_;
	45	pod_vector<CPPAD_OP_CODE_TYPE> op_rec_;
45	46
46	47	/// The VecAD indices in the recording.
47		pod_vector<addr_t> rec_vecad_ind_;
	48	pod_vector<addr_t> vecad_ind_rec_;
48	49
49	50	/// The argument indices in the recording
50		pod_vector<addr_t> rec_op_arg_;
	51	pod_vector<addr_t> op_arg_rec_;
51	52
52	53	/// The parameters in the recording.
53	54	/// Note that Base may not be plain old data, so use false in consructor.
54		pod_vector<Base> rec_par_;
	55	pod_vector<Base> par_rec_;
55	56
56	57	/// Character strings ('\\0' terminated) in the recording.
57		pod_vector<char> rec_text_;
	58	pod_vector<char> text_rec_;
58	59	// ---------------------- Public Functions -----------------------------------
59	60	public:
60	61	/// Default constructor
61	62	recorder(void) :
62	63	thread_offset_( thread_alloc::thread_num() * CPPAD_HASH_TABLE_SIZE ) ,
63		num_rec_var_(0) ,
64		rec_op_( std::numeric_limits<addr_t>::max() ) ,
65		rec_vecad_ind_( std::numeric_limits<addr_t>::max() ) ,
66		rec_op_arg_( std::numeric_limits<addr_t>::max() ) ,
67		rec_par_( std::numeric_limits<addr_t>::max() ) ,
68		rec_text_( std::numeric_limits<addr_t>::max() )
	64	num_var_rec_(0) ,
	65	num_load_op_rec_(0) ,
	66	op_rec_( std::numeric_limits<addr_t>::max() ) ,
	67	vecad_ind_rec_( std::numeric_limits<addr_t>::max() ) ,
	68	op_arg_rec_( std::numeric_limits<addr_t>::max() ) ,
	69	par_rec_( std::numeric_limits<addr_t>::max() ) ,
	70	text_rec_( std::numeric_limits<addr_t>::max() )
69	71	{ }
70	72
71	73	/// Destructor

81	83	to the system (so as to conserve on memory).
82	84	*/
83	85	void free(void)
84		{ num_rec_var_ = 0;
85		rec_op_.free();
86		rec_vecad_ind_.free();
87		rec_op_arg_.free();
88		rec_par_.free();
89		rec_text_.free();
	86	{ num_var_rec_ = 0;
	87	num_load_op_rec_ = 0;
	88	op_rec_.free();
	89	vecad_ind_rec_.free();
	90	op_arg_rec_.free();
	91	par_rec_.free();
	92	text_rec_.free();
90	93	}
91		/// Start recording the next operator in the operation sequence.
	94	/// Put next operator in the operation sequence.
92	95	inline size_t PutOp(OpCode op);
	96	/// Put a vecad load operator in the operation sequence (special case)
	97	inline size_t PutLoadOp(OpCode op);
93	98	/// Add a value to the end of the current vector of VecAD indices.
94	99	inline size_t PutVecInd(size_t vec_ind);
95	100	/// Find or add a parameter to the current vector of parameters.

119	124	inline size_t PutTxt(const char *text);
120	125
121	126	/// Number of variables currently stored in the recording.
122		size_t num_rec_var(void) const
123		{ return num_rec_var_; }
	127	size_t num_var_rec(void) const
	128	{ return num_var_rec_; }
	129
	130	/// Number of LdpOp and LdvOp operations currently in the recording.
	131	size_t num_load_op_rec(void) const
	132	{ return num_load_op_rec_; }
124	133
125	134	/// Number of operators currently stored in the recording.
126		size_t num_rec_op(void) const
127		{ return rec_op_.size(); }
	135	size_t num_op_rec(void) const
	136	{ return op_rec_.size(); }
128	137
129	138	/// Approximate amount of memory used by the recording
130	139	size_t Memory(void) const
131		{ return rec_op_.capacity() * sizeof(CPPAD_OP_CODE_TYPE)
132		+ rec_vecad_ind_.capacity() * sizeof(size_t)
133		+ rec_op_arg_.capacity() * sizeof(addr_t)
134		+ rec_par_.capacity() * sizeof(Base)
135		+ rec_text_.capacity() * sizeof(char);
	140	{ return op_rec_.capacity() * sizeof(CPPAD_OP_CODE_TYPE)
	141	+ vecad_ind_rec_.capacity() * sizeof(size_t)
	142	+ op_arg_rec_.capacity() * sizeof(addr_t)
	143	+ par_rec_.capacity() * sizeof(Base)
	144	+ text_rec_.capacity() * sizeof(char);
136	145	}
137	146	};
138	147
139	148	/*!
140		Start recording the next operator in the operation sequence.
	149	Put next operator in the operation sequence.
141	150
142	151	This sets the op code for the next operation in this recording.
143	152	This call must be followed by putting the corresponding

148	157
149	158	\param op
150	159	Is the op code corresponding to the the operation that is being
151		recorded.
	160	recorded (which must not be LdpOp or LdvOp).
152	161
153	162	\return
154	163	The return value is the index of the primary (last) variable

157	166	\verbatim
158	167	NumRes(op)
159	168	\endverbatim
160		With each call to PutOp
	169	With each call to PutOp or PutLoadOp,
161	170	the return index increases by the number of variables corresponding
162		to this call to PutOp.
	171	to the call.
163	172	This index starts at zero after the default constructor
164	173	and after each call to Erase.
165	174	*/
166	175	template <class Base>
167	176	inline size_t recorder<Base>::PutOp(OpCode op)
168		{ size_t i = rec_op_.extend(1);
169		rec_op_[i] = static_cast<CPPAD_OP_CODE_TYPE>(op);
170		CPPAD_ASSERT_UNKNOWN( rec_op_.size() == i + 1 );
	177	{ size_t i = op_rec_.extend(1);
	178	op_rec_[i] = static_cast<CPPAD_OP_CODE_TYPE>(op);
	179	CPPAD_ASSERT_UNKNOWN( op_rec_.size() == i + 1 );
	180	CPPAD_ASSERT_UNKNOWN( (op != LdpOp) & (op != LdvOp) );
171	181
172	182	// first operator should be a BeginOp and NumRes( BeginOp ) > 0
173		num_rec_var_ += NumRes(op);
174		CPPAD_ASSERT_UNKNOWN( num_rec_var_ > 0 );
175
176		return num_rec_var_ - 1;
	183	num_var_rec_ += NumRes(op);
	184	CPPAD_ASSERT_UNKNOWN( num_var_rec_ > 0 );
	185
	186	return num_var_rec_ - 1;
	187	}
	188
	189	/*!
	190	Put next LdpOp or LdvOp operator in operation sequence (special cases).
	191
	192	This sets the op code for the next operation in this recording.
	193	This call must be followed by putting the corresponding
	194	\verbatim
	195	NumArg(op)
	196	\endverbatim
	197	argument indices in the recording.
	198
	199	\param op
	200	Is the op code corresponding to the the operation that is being
	201	recorded (which must be LdpOp or LdvOp).
	202
	203	\return
	204	The return value is the index of the primary (last) variable
	205	corresponding to the result of this operation.
	206	The number of variables corresponding to the operation is given by
	207	\verbatim
	208	NumRes(op)
	209	\endverbatim
	210	which must be one for this operation.
	211	With each call to PutLoadOp or PutOp,
	212	the return index increases by the number of variables corresponding
	213	to this call to the call.
	214	This index starts at zero after the default constructor
	215	and after each call to Erase.
	216
	217	\par num_load_op_rec()
	218	The return value for <code>num_load_op_rec()</code>
	219	increases by one after each call to this function
	220	(and starts at zero after the default constructor or Erase).
	221	*/
	222	template <class Base>
	223	inline size_t recorder<Base>::PutLoadOp(OpCode op)
	224	{ size_t i = op_rec_.extend(1);
	225	op_rec_[i] = static_cast<CPPAD_OP_CODE_TYPE>(op);
	226	CPPAD_ASSERT_UNKNOWN( op_rec_.size() == i + 1 );
	227	CPPAD_ASSERT_UNKNOWN( (op == LdpOp) \| (op == LdvOp) );
	228
	229	// first operator should be a BeginOp and NumRes( BeginOp ) > 0
	230	num_var_rec_ += NumRes(op);
	231	CPPAD_ASSERT_UNKNOWN( num_var_rec_ > 0 );
	232
	233	// count this vecad load operation
	234	num_load_op_rec_++;
	235
	236	return num_var_rec_ - 1;
177	237	}
178	238
179	239	/*!

196	256	*/
197	257	template <class Base>
198	258	inline size_t recorder<Base>::PutVecInd(size_t vec_ind)
199		{ size_t i = rec_vecad_ind_.extend(1);
200		rec_vecad_ind_[i] = vec_ind;
201		CPPAD_ASSERT_UNKNOWN( rec_vecad_ind_.size() == i + 1 );
	259	{ size_t i = vecad_ind_rec_.extend(1);
	260	vecad_ind_rec_[i] = vec_ind;
	261	CPPAD_ASSERT_UNKNOWN( vecad_ind_rec_.size() == i + 1 );
202	262
203	263	return i;
204	264	}

232	292
233	293	// If we have a match, return the parameter index
234	294	i = hash_table[code + thread_offset_];
235		if( i < rec_par_.size() && IdenticalEqualPar(rec_par_[i], par) )
	295	if( i < par_rec_.size() && IdenticalEqualPar(par_rec_[i], par) )
236	296	return i;
237	297
238	298	// place a new value in the table
239		i = rec_par_.extend(1);
240		rec_par_[i] = par;
241		CPPAD_ASSERT_UNKNOWN( rec_par_.size() == i + 1 );
	299	i = par_rec_.extend(1);
	300	par_rec_[i] = par;
	301	CPPAD_ASSERT_UNKNOWN( par_rec_.size() == i + 1 );
242	302
243	303	// make the hash code point to this new value
244	304	hash_table[code + thread_offset_] = i;

286	346	template <class Base>
287	347	inline void recorder<Base>::PutArg(addr_t arg0)
288	348	{
289		size_t i = rec_op_arg_.extend(1);
290		rec_op_arg_[i] = static_cast<addr_t>( arg0 );
291		CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
	349	size_t i = op_arg_rec_.extend(1);
	350	op_arg_rec_[i] = static_cast<addr_t>( arg0 );
	351	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.size() == i + 1 );
292	352	}
293	353	/*!
294	354	Put two operation argument index in the recording

304	364	template <class Base>
305	365	inline void recorder<Base>::PutArg(addr_t arg0, addr_t arg1)
306	366	{
307		size_t i = rec_op_arg_.extend(2);
308		rec_op_arg_[i++] = static_cast<addr_t>( arg0 );
309		rec_op_arg_[i] = static_cast<addr_t>( arg1 );
310		CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
	367	size_t i = op_arg_rec_.extend(2);
	368	op_arg_rec_[i++] = static_cast<addr_t>( arg0 );
	369	op_arg_rec_[i] = static_cast<addr_t>( arg1 );
	370	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.size() == i + 1 );
311	371	}
312	372	/*!
313	373	Put three operation argument index in the recording

326	386	template <class Base>
327	387	inline void recorder<Base>::PutArg(addr_t arg0, addr_t arg1, addr_t arg2)
328	388	{
329		size_t i = rec_op_arg_.extend(3);
330		rec_op_arg_[i++] = static_cast<addr_t>( arg0 );
331		rec_op_arg_[i++] = static_cast<addr_t>( arg1 );
332		rec_op_arg_[i] = static_cast<addr_t>( arg2 );
333		CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
	389	size_t i = op_arg_rec_.extend(3);
	390	op_arg_rec_[i++] = static_cast<addr_t>( arg0 );
	391	op_arg_rec_[i++] = static_cast<addr_t>( arg1 );
	392	op_arg_rec_[i] = static_cast<addr_t>( arg2 );
	393	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.size() == i + 1 );
334	394	}
335	395	/*!
336	396	Put four operation argument index in the recording

353	413	inline void recorder<Base>::PutArg(addr_t arg0, addr_t arg1, addr_t arg2,
354	414	addr_t arg3)
355	415	{
356		size_t i = rec_op_arg_.extend(4);
357		rec_op_arg_[i++] = static_cast<addr_t>( arg0 );
358		rec_op_arg_[i++] = static_cast<addr_t>( arg1 );
359		rec_op_arg_[i++] = static_cast<addr_t>( arg2 );
360		rec_op_arg_[i] = static_cast<addr_t>( arg3 );
361		CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
	416	size_t i = op_arg_rec_.extend(4);
	417	op_arg_rec_[i++] = static_cast<addr_t>( arg0 );
	418	op_arg_rec_[i++] = static_cast<addr_t>( arg1 );
	419	op_arg_rec_[i++] = static_cast<addr_t>( arg2 );
	420	op_arg_rec_[i] = static_cast<addr_t>( arg3 );
	421	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.size() == i + 1 );
362	422
363	423	}
364	424	/*!

385	445	inline void recorder<Base>::PutArg(addr_t arg0, addr_t arg1, addr_t arg2,
386	446	addr_t arg3, addr_t arg4)
387	447	{
388		size_t i = rec_op_arg_.extend(5);
389		rec_op_arg_[i++] = static_cast<addr_t>( arg0 );
390		rec_op_arg_[i++] = static_cast<addr_t>( arg1 );
391		rec_op_arg_[i++] = static_cast<addr_t>( arg2 );
392		rec_op_arg_[i++] = static_cast<addr_t>( arg3 );
393		rec_op_arg_[i] = static_cast<addr_t>( arg4 );
394		CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
	448	size_t i = op_arg_rec_.extend(5);
	449	op_arg_rec_[i++] = static_cast<addr_t>( arg0 );
	450	op_arg_rec_[i++] = static_cast<addr_t>( arg1 );
	451	op_arg_rec_[i++] = static_cast<addr_t>( arg2 );
	452	op_arg_rec_[i++] = static_cast<addr_t>( arg3 );
	453	op_arg_rec_[i] = static_cast<addr_t>( arg4 );
	454	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.size() == i + 1 );
395	455
396	456	}
397	457	/*!

421	481	inline void recorder<Base>::PutArg(addr_t arg0, addr_t arg1, addr_t arg2,
422	482	addr_t arg3, addr_t arg4, addr_t arg5)
423	483	{
424		size_t i = rec_op_arg_.extend(6);
425		rec_op_arg_[i++] = static_cast<addr_t>( arg0 );
426		rec_op_arg_[i++] = static_cast<addr_t>( arg1 );
427		rec_op_arg_[i++] = static_cast<addr_t>( arg2 );
428		rec_op_arg_[i++] = static_cast<addr_t>( arg3 );
429		rec_op_arg_[i++] = static_cast<addr_t>( arg4 );
430		rec_op_arg_[i] = static_cast<addr_t>( arg5 );
431		CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + 1 );
	484	size_t i = op_arg_rec_.extend(6);
	485	op_arg_rec_[i++] = static_cast<addr_t>( arg0 );
	486	op_arg_rec_[i++] = static_cast<addr_t>( arg1 );
	487	op_arg_rec_[i++] = static_cast<addr_t>( arg2 );
	488	op_arg_rec_[i++] = static_cast<addr_t>( arg3 );
	489	op_arg_rec_[i++] = static_cast<addr_t>( arg4 );
	490	op_arg_rec_[i] = static_cast<addr_t>( arg5 );
	491	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.size() == i + 1 );
432	492	}
433	493	// --------------------------------------------------------------------------
434	494	/*!

444	504	template <class Base>
445	505	inline size_t recorder<Base>::ReserveArg(size_t n_arg)
446	506	{
447		size_t i = rec_op_arg_.extend(n_arg);
448		CPPAD_ASSERT_UNKNOWN( rec_op_arg_.size() == i + n_arg );
	507	size_t i = op_arg_rec_.extend(n_arg);
	508	CPPAD_ASSERT_UNKNOWN( op_arg_rec_.size() == i + n_arg );
449	509	return i;
450	510	}
451	511

462	522	*/
463	523	template <class Base>
464	524	inline void recorder<Base>::ReplaceArg(size_t i_arg, size_t value)
465		{ rec_op_arg_[i_arg] = static_cast<addr_t>( value ); }
	525	{ op_arg_rec_[i_arg] = static_cast<addr_t>( value ); }
466	526	// --------------------------------------------------------------------------
467	527	/*!
468	528	Put a character string in the text for this recording.

488	548	CPPAD_ASSERT_UNKNOWN( text[n-1] == '\0' );
489	549
490	550	// copy text including terminating '\0'
491		size_t i = rec_text_.extend(n);
	551	size_t i = text_rec_.extend(n);
492	552	size_t j;
493	553	for(j = 0; j < n; j++)
494		rec_text_[i + j] = text[j];
495		CPPAD_ASSERT_UNKNOWN( rec_text_.size() == i + n );
	554	text_rec_[i + j] = text[j];
	555	CPPAD_ASSERT_UNKNOWN( text_rec_.size() == i + n );
496	556
497	557	return i;
498	558	}
499	559	// -------------------------------------------------------------------------
500	560
501	561
502		/! \} /
503	562	} // END_CPPAD_NAMESPACE
504	563	# endif

+33

-21

cppad/local/rev_hes_sweep.hpp less more

0		/* $Id: rev_hes_sweep.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: rev_hes_sweep.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_REV_HES_SWEEP_INCLUDED
2	2	# define CPPAD_REV_HES_SWEEP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup rev_hes_sweep_hpp rev_hes_sweep.hpp
18		\{
19	17	\file rev_hes_sweep.hpp
20	18	Compute Reverse mode Hessian sparsity patterns.
21	19	*/

48	46
49	47	\param numvar
50	48	is the total number of variables on the tape; i.e.,
51		\a play->num_rec_var().
	49	\a play->num_var_rec().
52	50	This is also the number of rows in the entire sparsity pattern
53	51	\a rev_hes_sparse.
54	52

116	114	const addr_t* arg = CPPAD_NULL;
117	115
118	116	// length of the parameter vector (used by CppAD assert macros)
119		const size_t num_par = play->num_rec_par();
	117	const size_t num_par = play->num_par_rec();
120	118
121	119	size_t i, j, k;
122	120
123	121	// check numvar argument
124		CPPAD_ASSERT_UNKNOWN( play->num_rec_var() == numvar );
	122	CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
125	123	CPPAD_ASSERT_UNKNOWN( for_jac_sparse.n_set() == numvar );
126	124	CPPAD_ASSERT_UNKNOWN( rev_hes_sparse.n_set() == numvar );
127	125	CPPAD_ASSERT_UNKNOWN( numvar > 0 );

138	136	// vecad_sparsity contains a sparsity pattern for each VecAD object.
139	137	// vecad_ind maps a VecAD index (beginning of the VecAD object)
140	138	// to the index for the corresponding set in vecad_sparsity.
141		size_t num_vecad_ind = play->num_rec_vecad_ind();
142		size_t num_vecad_vec = play->num_rec_vecad_vec();
	139	size_t num_vecad_ind = play->num_vec_ind_rec();
	140	size_t num_vecad_vec = play->num_vecad_vec_rec();
143	141	Vector_set vecad_sparse;
144	142	vecad_sparse.resize(num_vecad_vec, limit);
145	143	pod_vector<size_t> vecad_ind;

162	160	// initialize this vector's reverse jacobian value
163	161	vecad_jac[i] = false;
164	162	}
165		CPPAD_ASSERT_UNKNOWN( j == play->num_rec_vecad_ind() );
	163	CPPAD_ASSERT_UNKNOWN( j == play->num_vec_ind_rec() );
166	164	}
167	165
168	166	// work space used by UserOp.

199	197
200	198
201	199	// Initialize
202		play->start_reverse(op, arg, i_op, i_var);
	200	play->reverse_start(op, arg, i_op, i_var);
203	201	CPPAD_ASSERT_UNKNOWN( op == EndOp );
204	202	# if CPPAD_REV_HES_SWEEP_TRACE
205	203	std::cout << std::endl;

210	208	while(more_operators)
211	209	{
212	210	// next op
213		play->next_reverse(op, arg, i_op, i_var);
	211	play->reverse_next(op, arg, i_op, i_var);
214	212	# ifndef NDEBUG
215	213	if( i_op <= n )
216	214	{ CPPAD_ASSERT_UNKNOWN((op == InvOp) \| (op == BeginOp));

280	278
281	279	case CSkipOp:
282	280	// CSkipOp has a variable number of arguments and
283		// next_reverse thinks it one has one argument.
284		// We must inform next_reverse of this special case.
	281	// reverse_next thinks it one has one argument.
	282	// We must inform reverse_next of this special case.
285	283	play->reverse_cskip(op, arg, i_op, i_var);
286	284	break;
287	285	// -------------------------------------------------
288	286
289	287	case CSumOp:
290	288	// CSumOp has a variable number of arguments and
291		// next_reverse thinks it one has one argument.
292		// We must inform next_reverse of this special case.
	289	// reverse_next thinks it one has one argument.
	290	// We must inform reverse_next of this special case.
293	291	play->reverse_csum(op, arg, i_op, i_var);
294	292	reverse_sparse_hessian_csum_op(
295	293	i_var, arg, RevJac, rev_hes_sparse

353	351	case DivvpOp:
354	352	CPPAD_ASSERT_NARG_NRES(op, 2, 1)
355	353	reverse_sparse_hessian_linear_unary_op(
	354	i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
	355	);
	356	break;
	357	// -------------------------------------------------
	358
	359	case ErfOp:
	360	CPPAD_ASSERT_NARG_NRES(op, 1, 1)
	361	reverse_sparse_hessian_nonlinear_unary_op(
356	362	i_var, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
357	363	);
358	364	break;

786	792	{ zh_value[j] = true;
787	793	j = rev_hes_sparse.next_element();
788	794	}
789		// should also print RevJac[i_var], but printOp does not
790		// yet allow for this.
791	795	printOp(
792	796	std::cout,
793	797	play,
794	798	i_op,
795	799	i_var,
796	800	op,
797		arg,
	801	arg
	802	);
	803	// should also print RevJac[i_var], but printOpResult does not
	804	// yet allow for this
	805	if( NumRes(op) > 0 && op != BeginOp ) printOpResult(
	806	std::cout,
798	807	1,
799	808	&zf_value,
800	809	1,
801	810	&zh_value
802	811	);
	812	std::cout << std::endl;
	813	}
	814	std::cout << std::endl;
	815	# else
	816	}
803	817	# endif
804		}
805	818	// values corresponding to BeginOp
806	819	CPPAD_ASSERT_UNKNOWN( i_op == 0 );
807	820	CPPAD_ASSERT_UNKNOWN( i_var == 0 );
808	821
809	822	return;
810	823	}
811		/! \} /
812	824	} // END_CPPAD_NAMESPACE
813	825
814	826	// preprocessor symbols that are local to this file

+51

-39

cppad/local/rev_jac_sweep.hpp less more

0		/* $Id: rev_jac_sweep.hpp 2994 2013-10-23 15:47:20Z bradbell $ */
	0	/* $Id: rev_jac_sweep.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_REV_JAC_SWEEP_INCLUDED
2	2	# define CPPAD_REV_JAC_SWEEP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8		the terms of the
	8	the terms of the
9	9	GNU General Public License Version 3.
10	10
11	11	A copy of this license is included in the COPYING file of this distribution.

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup rev_jac_sweep_hpp rev_jac_sweep.hpp
18		\{
19	17	\file rev_jac_sweep.hpp
20	18	Compute Reverse mode Jacobian sparsity patterns.
21	19	*/
22	20
23	21	/*!
24	22	\def CPPAD_REV_JAC_SWEEP_TRACE
25		This value is either zero or one.
	23	This value is either zero or one.
26	24	Zero is the normal operational value.
27	25	If it is one, a trace of every rev_jac_sweep computation is printed.
28	26	*/

39	37	\code
40	38	user_ok = user_atom->rev_sparse_jac
41	39	\endcode
42		This maco is undefined at the end of this file to facillitate is
	40	This maco is undefined at the end of this file to facillitate is
43	41	use with a different definition in other files.
44	42	*/
45	43	# ifdef NDEBUG

54	52
55	53	\tparam Base
56	54	base type for the operator; i.e., this operation sequence was recorded
57		using AD< \a Base > and computations by this routine are done using type
	55	using AD< \a Base > and computations by this routine are done using type
58	56	\a Base.
59	57
60	58	\tparam Vector_set

74	72
75	73	\param numvar
76	74	is the total number of variables on the tape; i.e.,
77		\a play->num_rec_var().
	75	\a play->num_var_rec().
78	76	This is also the number of rows in the entire sparsity pattern \a RevJac.
79	77
80	78	\param play

97	95	corresponds to the set with index i in \a var_sparsity.
98	96	\b
99	97	\b
100		\b Input:
	98	\b Input:
101	99	For i = 0 , ... , \a numvar - 1,
102	100	the forward Jacobian sparsity pattern for variable i is an input
103	101	if i corresponds to a dependent variable.
104		Otherwise the sparsity patten is empty.
	102	Otherwise the sparsity patten is empty.
105	103	\n
106	104	\n
107	105	\b Output: For j = 1 , ... , \a n,
108		the sparsity pattern for the dependent variable with index (j-1)
	106	the sparsity pattern for the dependent variable with index (j-1)
109	107	is given by the set with index index j in \a var_sparsity.
110	108	*/
111	109

127	125	size_t i, j, k;
128	126
129	127	// length of the parameter vector (used by CppAD assert macros)
130		const size_t num_par = play->num_rec_par();
	128	const size_t num_par = play->num_par_rec();
131	129
132	130	// check numvar argument
133	131	CPPAD_ASSERT_UNKNOWN( numvar > 0 );
134		CPPAD_ASSERT_UNKNOWN( play->num_rec_var() == numvar );
	132	CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
135	133	CPPAD_ASSERT_UNKNOWN( var_sparsity.n_set() == numvar );
136	134
137	135	// upper limit (exclusive) for elements in the set
138	136	size_t limit = var_sparsity.end();
139	137
140	138	// vecad_sparsity contains a sparsity pattern for each VecAD object.
141		// vecad_ind maps a VecAD index (beginning of the VecAD object)
142		// to the index of the corresponding set in vecad_sparsity.
143		size_t num_vecad_ind = play->num_rec_vecad_ind();
144		size_t num_vecad_vec = play->num_rec_vecad_vec();
	139	// vecad_ind maps a VecAD index (beginning of the VecAD object)
	140	// to the index of the corresponding set in vecad_sparsity.
	141	size_t num_vecad_ind = play->num_vec_ind_rec();
	142	size_t num_vecad_vec = play->num_vecad_vec_rec();
145	143	Vector_set vecad_sparsity;
146	144	vecad_sparsity.resize(num_vecad_vec, limit);
147	145	pod_vector<size_t> vecad_ind;

153	151	{ // length of this VecAD
154	152	length = play->GetVecInd(j);
155	153	// set to proper index for this VecAD
156		vecad_ind[j] = i;
	154	vecad_ind[j] = i;
157	155	for(k = 1; k <= length; k++)
158	156	vecad_ind[j+k] = num_vecad_vec; // invalid index
159	157	// start of next VecAD
160	158	j += length + 1;
161	159	}
162		CPPAD_ASSERT_UNKNOWN( j == play->num_rec_vecad_ind() );
	160	CPPAD_ASSERT_UNKNOWN( j == play->num_vec_ind_rec() );
163	161	}
164	162
165	163	// work space used by UserOp.

189	187	enum { user_start, user_arg, user_ret, user_end } user_state = user_end;
190	188
191	189	// Initialize
192		play->start_reverse(op, arg, i_op, i_var);
	190	play->reverse_start(op, arg, i_op, i_var);
193	191	CPPAD_ASSERT_UNKNOWN( op == EndOp );
194	192	# if CPPAD_REV_JAC_SWEEP_TRACE
195	193	std::cout << std::endl;
196		CppAD::vector<bool> z_value(limit);
	194	CppAD::vectorBool z_value(limit);
197	195	# endif
198	196	bool more_operators = true;
199	197	while(more_operators)
200	198	{
201	199	// next op
202		play->next_reverse(op, arg, i_op, i_var);
	200	play->reverse_next(op, arg, i_op, i_var);
203	201	# ifndef NDEBUG
204	202	if( i_op <= n )
205	203	{ CPPAD_ASSERT_UNKNOWN((op == InvOp) \| (op == BeginOp));

269	267
270	268	case CSkipOp:
271	269	// CSkipOp has a variable number of arguments and
272		// next_reverse thinks it one has one argument.
273		// We must inform next_reverse of this special case.
	270	// reverse_next thinks it one has one argument.
	271	// We must inform reverse_next of this special case.
274	272	play->reverse_cskip(op, arg, i_op, i_var);
275	273	break;
276	274	// -------------------------------------------------
277	275
278	276	case CSumOp:
279	277	// CSumOp has a variable number of arguments and
280		// next_reverse thinks it one has one argument.
281		// We must inform next_reverse of this special case.
	278	// reverse_next thinks it one has one argument.
	279	// We must inform reverse_next of this special case.
282	280	play->reverse_csum(op, arg, i_op, i_var);
283	281	reverse_sparse_jacobian_csum_op(
284	282	i_var, arg, var_sparsity

341	339
342	340	case DivvpOp:
343	341	CPPAD_ASSERT_NARG_NRES(op, 2, 1);
	342	reverse_sparse_jacobian_unary_op(
	343	i_var, arg[0], var_sparsity
	344	);
	345	break;
	346	// -------------------------------------------------
	347
	348	case ErfOp:
	349	CPPAD_ASSERT_NARG_NRES(op, 1, 1);
344	350	reverse_sparse_jacobian_unary_op(
345	351	i_var, arg[0], var_sparsity
346	352	);

565	571	user_atom = atomic_base<Base>::class_object(user_index);
566	572	# ifndef NDEBUG
567	573	if( user_atom == CPPAD_NULL )
568		{ std::string msg =
	574	{ std::string msg =
569	575	atomic_base<Base>::class_name(user_index)
570	576	+ ": atomic_base function has been deleted";
571	577	CPPAD_ASSERT_KNOWN(false, msg.c_str() );

602	608	CPPAD_ASSERT_UNKNOWN( user_m == size_t(arg[3]) );
603	609	# ifndef NDEBUG
604	610	if( ! user_ok )
605		{ std::string msg =
	611	{ std::string msg =
606	612	atomic_base<Base>::class_name(user_index)
607	613	+ ": atomic_base.rev_sparse_jac: returned false";
608	614	CPPAD_ASSERT_KNOWN(false, msg.c_str() );

658	664	if( user_i == 0 )
659	665	{ // call users function for this operation
660	666	user_atom->set_id(user_id);
661		if( user_bool)
	667	if( user_bool)
662	668	CPPAD_ATOMIC_CALL(
663	669	user_q, bool_r, bool_s
664	670	);

687	693	if( user_i == 0 )
688	694	{ // call users function for this operation
689	695	user_atom->set_id(user_id);
690		if( user_bool)
	696	if( user_bool)
691	697	CPPAD_ATOMIC_CALL(
692	698	user_q, bool_r, bool_s
693	699	);

713	719	j = var_sparsity.next_element();
714	720	}
715	721	printOp(
716		std::cout,
	722	std::cout,
717	723	play,
718	724	i_op,
719	725	i_var,
720		op,
721		arg,
722		0,
723		(CppAD::vector<bool> *) CPPAD_NULL,
724		1,
	726	op,
	727	arg
	728	);
	729	if( NumRes(op) > 0 && op != BeginOp ) printOpResult(
	730	std::cout,
	731	0,
	732	(CppAD::vectorBool *) CPPAD_NULL,
	733	1,
725	734	&z_value
726	735	);
	736	std::cout << std::endl;
	737	}
	738	std::cout << std::endl;
	739	# else
	740	}
727	741	# endif
728		}
729	742	// values corresponding to BeginOp
730	743	CPPAD_ASSERT_UNKNOWN( i_op == 0 );
731	744	CPPAD_ASSERT_UNKNOWN( i_var == 0 );
732	745
733	746	return;
734	747	}
735		/! \} /
736	748	} // END_CPPAD_NAMESPACE
737	749
738	750	// preprocessor symbols that are local to this file

+35

-44

cppad/local/rev_sparse_hes.hpp less more

0		/* $Id: rev_sparse_hes.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: rev_sparse_hes.hpp 3441 2014-12-03 14:46:44Z bradbell $ */
1	1	# ifndef CPPAD_REV_SPARSE_HES_INCLUDED
2	2	# define CPPAD_REV_SPARSE_HES_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

193	193
194	194	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
195	195	/*!
196		\defgroup rev_sparse_hes_hpp rev_sparse_hes.hpp
197		\{
198	196	\file rev_sparse_hes.hpp
199	197	Reverse mode Hessian sparsity patterns.
200	198	*/

212	210
213	211	\tparam VectorSet
214	212	is a simple vector with elements of type \c bool.
215
216		\tparam Sparsity
217		is either \c sparse_pack, \c sparse_set, or \c sparse_list.
218	213
219	214	\param transpose
220	215	is true (false) if \c is is equal to \f$ H(x) \f$ (\f$ H(x)^T \f$)

245	240	On output, \a h is the sparsity pattern for the matrix \f$ H(x) \f$
246	241	or \f$ H(x)^T \f$ depending on \c transpose.
247	242
248		\param total_num_var
	243	\param num_var
249	244	is the total number of variables in this recording.
250	245
251	246	\param dep_taddr

266	261	$latex R$$ for all of the variables on the tape.
267	262	*/
268	263
269		template <class Base, class VectorSet, class Sparsity>
	264	template <class Base, class VectorSet>
270	265	void RevSparseHesBool(
271	266	bool transpose ,
272	267	size_t q ,
273	268	const VectorSet& s ,
274	269	VectorSet& h ,
275		size_t total_num_var ,
	270	size_t num_var ,
276	271	CppAD::vector<size_t>& dep_taddr ,
277	272	CppAD::vector<size_t>& ind_taddr ,
278	273	CppAD::player<Base>& play ,
279		Sparsity& for_jac_sparsity )
	274	sparse_pack& for_jac_sparsity )
280	275	{
281	276	// temporary indices
282	277	size_t i, j;

302	297	// Array that will hold reverse Jacobian dependency flag.
303	298	// Initialize as true for the dependent variables.
304	299	pod_vector<bool> RevJac;
305		RevJac.extend(total_num_var);
306		for(i = 0; i < total_num_var; i++)
	300	RevJac.extend(num_var);
	301	for(i = 0; i < num_var; i++)
307	302	RevJac[i] = false;
308	303	for(i = 0; i < m; i++)
309		{ CPPAD_ASSERT_UNKNOWN( dep_taddr[i] < total_num_var );
	304	{ CPPAD_ASSERT_UNKNOWN( dep_taddr[i] < num_var );
310	305	RevJac[ dep_taddr[i] ] = s[i];
311	306	}
312	307
313	308	// vector of sets that will hold reverse Hessain values
314		Sparsity rev_hes_sparsity;
315		rev_hes_sparsity.resize(total_num_var, q);
	309	sparse_pack rev_hes_sparsity;
	310	rev_hes_sparsity.resize(num_var, q);
316	311
317	312	// compute the Hessian sparsity patterns
318	313	RevHesSweep(
319	314	n,
320		total_num_var,
	315	num_var,
321	316	&play,
322	317	for_jac_sparsity,
323	318	RevJac.data(),

336	331
337	332	// j is index corresponding to reverse mode partial
338	333	for(j = 0; j < n; j++)
339		{ CPPAD_ASSERT_UNKNOWN( ind_taddr[j] < total_num_var );
	334	{ CPPAD_ASSERT_UNKNOWN( ind_taddr[j] < num_var );
340	335
341	336	// ind_taddr[j] is operator taddr for j-th independent variable
342	337	CPPAD_ASSERT_UNKNOWN( ind_taddr[j] == j + 1 );

371	366	\tparam VectorSet
372	367	is a simple vector with elements of type \c std::set<size_t>.
373	368
374		\tparam Sparsity
375		is either \c sparse_pack, \c sparse_set, or \c sparse_list.
376
377	369	\param transpose
378	370	is true (false) if \c is is equal to \f$ H(x) \f$ (\f$ H(x)^T \f$)
379	371	where

404	396	On output, \a h is the sparsity pattern for the matrix \f$ H(x) \f$
405	397	or \f$ H(x)^T \f$ depending on \c transpose.
406	398
407		\param total_num_var
	399	\param num_var
408	400	is the total number of variables in this recording.
409	401
410	402	\param dep_taddr

425	417	$latex R$$ for all of the variables on the tape.
426	418	*/
427	419
428		template <class Base, class VectorSet, class Sparsity>
	420	template <class Base, class VectorSet>
429	421	void RevSparseHesSet(
430		bool transpose ,
431		size_t q ,
432		const VectorSet& s ,
433		VectorSet& h ,
434		size_t total_num_var ,
435		CppAD::vector<size_t>& dep_taddr ,
436		CppAD::vector<size_t>& ind_taddr ,
437		CppAD::player<Base>& play ,
438		Sparsity& for_jac_sparsity )
	422	bool transpose ,
	423	size_t q ,
	424	const VectorSet& s ,
	425	VectorSet& h ,
	426	size_t num_var ,
	427	CppAD::vector<size_t>& dep_taddr ,
	428	CppAD::vector<size_t>& ind_taddr ,
	429	CppAD::player<Base>& play ,
	430	CPPAD_INTERNAL_SPARSE_SET& for_jac_sparsity )
439	431	{
440	432	// temporary indices
441	433	size_t i, j;

465	457	// Array that will hold reverse Jacobian dependency flag.
466	458	// Initialize as true for the dependent variables.
467	459	pod_vector<bool> RevJac;
468		RevJac.extend(total_num_var);
469		for(i = 0; i < total_num_var; i++)
	460	RevJac.extend(num_var);
	461	for(i = 0; i < num_var; i++)
470	462	RevJac[i] = false;
471	463	itr = s[0].begin();
472	464	while( itr != s[0].end() )

476	468	"RevSparseHes: an element of the set s[0] has value "
477	469	"greater than or equal m"
478	470	);
479		CPPAD_ASSERT_UNKNOWN( dep_taddr[i] < total_num_var );
	471	CPPAD_ASSERT_UNKNOWN( dep_taddr[i] < num_var );
480	472	RevJac[ dep_taddr[i] ] = true;
481	473	}
482	474
483	475
484	476	// vector of sets that will hold reverse Hessain values
485		Sparsity rev_hes_sparsity;
486		rev_hes_sparsity.resize(total_num_var, q);
	477	CPPAD_INTERNAL_SPARSE_SET rev_hes_sparsity;
	478	rev_hes_sparsity.resize(num_var, q);
487	479
488	480	// compute the Hessian sparsity patterns
489	481	RevHesSweep(
490	482	n,
491		total_num_var,
	483	num_var,
492	484	&play,
493	485	for_jac_sparsity,
494	486	RevJac.data(),

500	492	CPPAD_ASSERT_UNKNOWN( size_t(h.size()) == q \|\| transpose );
501	493	CPPAD_ASSERT_UNKNOWN( size_t(h.size()) == n \|\| ! transpose );
502	494	for(j = 0; j < n; j++)
503		{ CPPAD_ASSERT_UNKNOWN( ind_taddr[j] < total_num_var );
	495	{ CPPAD_ASSERT_UNKNOWN( ind_taddr[j] < num_var );
504	496	CPPAD_ASSERT_UNKNOWN( ind_taddr[j] == j + 1 );
505	497	CPPAD_ASSERT_UNKNOWN( play.GetOp( ind_taddr[j] ) == InvOp );
506	498

632	624	"use bool for the elements of r."
633	625	);
634	626	CPPAD_ASSERT_UNKNOWN( for_jac_sparse_set_.n_set() == 0 );
635		CPPAD_ASSERT_UNKNOWN( for_jac_sparse_pack_.n_set() == total_num_var_ );
	627	CPPAD_ASSERT_UNKNOWN( for_jac_sparse_pack_.n_set() == num_var_tape_ );
636	628
637	629	// use sparse_pack for the calculation
638	630	CppAD::RevSparseHesBool(

640	632	q ,
641	633	s ,
642	634	h ,
643		total_num_var_ ,
	635	num_var_tape_ ,
644	636	dep_taddr_ ,
645	637	ind_taddr_ ,
646	638	play_ ,

690	682	"use std::set<size_t> for the elements of r."
691	683	);
692	684	CPPAD_ASSERT_UNKNOWN( for_jac_sparse_pack_.n_set() == 0 );
693		CPPAD_ASSERT_UNKNOWN( for_jac_sparse_set_.n_set() == total_num_var_ );
	685	CPPAD_ASSERT_UNKNOWN( for_jac_sparse_set_.n_set() == num_var_tape_ );
694	686
695	687	// use sparse_pack for the calculation
696	688	CppAD::RevSparseHesSet(

698	690	q ,
699	691	s ,
700	692	h ,
701		total_num_var_ ,
	693	num_var_tape_ ,
702	694	dep_taddr_ ,
703	695	ind_taddr_ ,
704	696	play_ ,

706	698	);
707	699	}
708	700
709		/! \} /
710	701	} // END_CPPAD_NAMESPACE
711	702	# endif

-7

cppad/local/rev_sparse_jac.hpp less more

0		/* $Id: rev_sparse_jac.hpp 2994 2013-10-23 15:47:20Z bradbell $ */
	0	/* $Id: rev_sparse_jac.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_REV_SPARSE_JAC_INCLUDED
2	2	# define CPPAD_REV_SPARSE_JAC_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

184	184
185	185	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
186	186	/*!
187		\defgroup rev_sparse_jac_hpp rev_sparse_jac.hpp
188		\{
189	187	\file rev_sparse_jac.hpp
190	188	Reverse mode Jacobian sparsity patterns.
191	189	*/

530	528	q ,
531	529	r ,
532	530	s ,
533		total_num_var_ ,
	531	num_var_tape_ ,
534	532	dep_taddr_ ,
535	533	ind_taddr_ ,
536	534	play_

585	583	q ,
586	584	r ,
587	585	s ,
588		total_num_var_ ,
	586	num_var_tape_ ,
589	587	dep_taddr_ ,
590	588	ind_taddr_ ,
591	589	play_

661	659	return s;
662	660	}
663	661
664		/! \} /
665	662	} // END_CPPAD_NAMESPACE
666	663	# endif

+62

-74

cppad/local/reverse.hpp less more

0		/* $Id: reverse.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: reverse.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_REVERSE_INCLUDED
2	2	# define CPPAD_REVERSE_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

12	12	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13	13	-------------------------------------------------------------------------- */
14	14
15		/*
16		$begin Reverse$$
17		$spell
18		typename
19		xk
20		xp
21		dw
22		Ind
23		uj
24		std
25		arg
26		const
27		taylor_
28		$$
29
30		$section Reverse Mode$$
31
32		$childtable%
33		omh/reverse.omh
34		%$$
35
36		$end
37		-----------------------------------------------------------------------------
38		*/
39	15	# include <algorithm>
40	16	# include <cppad/local/pod_vector.hpp>
41	17
42	18	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
43	19	/*!
44		\defgroup reverse_hpp reverse.hpp
45		\{
46	20	\file reverse.hpp
47	21	Compute derivatives using reverse mode.
48	22	*/

52	26	Use reverse mode to compute derivative of forward mode Taylor coefficients.
53	27
54	28	The function
55		\f$ X : {\rm R} \times {\rm R}^{n \times p} \rightarrow {\rm R} \f$
	29	\f$ X : {\rm R} \times {\rm R}^{n \times q} \rightarrow {\rm R} \f$
56	30	is defined by
57	31	\f[
58		X(t , u) = \sum_{k=0}^{p-1} u^{(k)} t^k
	32	X(t , u) = \sum_{k=0}^{q-1} u^{(k)} t^k
59	33	\f]
60	34	The function
61		\f$ Y : {\rm R} \times {\rm R}^{n \times p} \rightarrow {\rm R} \f$
	35	\f$ Y : {\rm R} \times {\rm R}^{n \times q} \rightarrow {\rm R} \f$
62	36	is defined by
63	37	\f[
64	38	Y(t , u) = F[ X(t, u) ]
65	39	\f]
66	40	The function
67		\f$ W : {\rm R}^{n \times p} \rightarrow {\rm R} \f$ is defined by
68		\f[
69		W(u) = \sum_{k=0}^{p-1} ( w^{(k)} )^{\rm T}
	41	\f$ W : {\rm R}^{n \times q} \rightarrow {\rm R} \f$ is defined by
	42	\f[
	43	W(u) = \sum_{k=0}^{q-1} ( w^{(k)} )^{\rm T}
70	44	\frac{1}{k !} \frac{ \partial^k } { t^k } Y(0, u)
71	45	\f]
72	46

78	52	\tparam VectorBase
79	53	is a Simple Vector class with elements of type \a Base.
80	54
81		\param p
	55	\param q
82	56	is the number of the number of Taylor coefficients that are being
83	57	differentiated (per variable).
84	58
85	59	\param w
86	60	is the weighting for each of the Taylor coefficients corresponding
87	61	to dependent variables.
88		If the argument \a w has size <tt>m * p </tt>,
89		for \f$ k = 0 , \ldots , p-1 \f$ and \f$ i = 0, \ldots , m-1 \f$,
90		\f[
91		w_i^{(k)} = w [ i * p + k ]
	62	If the argument \a w has size <tt>m * q </tt>,
	63	for \f$ k = 0 , \ldots , q-1 \f$ and \f$ i = 0, \ldots , m-1 \f$,
	64	\f[
	65	w_i^{(k)} = w [ i * q + k ]
92	66	\f]
93	67	If the argument \a w has size \c m ,
94		for \f$ k = 0 , \ldots , p-1 \f$ and \f$ i = 0, \ldots , m-1 \f$,
	68	for \f$ k = 0 , \ldots , q-1 \f$ and \f$ i = 0, \ldots , m-1 \f$,
95	69	\f[
96	70	w_i^{(k)} = \left\{ \begin{array}{ll}
97		w [ i ] & {\rm if} \; k = p-1
	71	w [ i ] & {\rm if} \; k = q-1
98	72	\\
99	73	0 & {\rm otherwise}
100	74	\end{array} \right.

103	77	\return
104	78	Is a vector \f$ dw \f$ such that
105	79	for \f$ j = 0 , \ldots , n-1 \f$ and
106		\f$ k = 0 , \ldots , p-1 \f$
	80	\f$ k = 0 , \ldots , q-1 \f$
107	81	\f[
108		dw[ j * p + k ] = W^{(1)} ( x )_{j,k}
	82	dw[ j * q + k ] = W^{(1)} ( x )_{j,k}
109	83	\f]
110	84	where the matrix \f$ x \f$ is the value for \f$ u \f$
111	85	that corresponding to the forward mode Taylor coefficients

114	88	*/
115	89	template <typename Base>
116	90	template <typename VectorBase>
117		VectorBase ADFun<Base>::Reverse(size_t p, const VectorBase &w)
	91	VectorBase ADFun<Base>::Reverse(size_t q, const VectorBase &w)
118	92	{ // constants
119	93	const Base zero(0);
120	94

128	102	size_t m = dep_taddr_.size();
129	103
130	104	pod_vector<Base> Partial;
131		Partial.extend(total_num_var_ * p);
	105	Partial.extend(num_var_tape_ * q);
132	106
133	107	// update maximum memory requirement
134	108	// memoryMax = std::max( memoryMax,
135		// Memory() + total_num_var_ * p * sizeof(Base)
	109	// Memory() + num_var_tape_ * q * sizeof(Base)
136	110	// );
137	111
138	112	// check VectorBase is Simple Vector class with Base type elements
139	113	CheckSimpleVector<Base, VectorBase>();
140	114
141	115	CPPAD_ASSERT_KNOWN(
142		size_t(w.size()) == m \|\| size_t(w.size()) == (m * p),
	116	size_t(w.size()) == m \|\| size_t(w.size()) == (m * q),
143	117	"Argument w to Reverse does not have length equal to\n"
144	118	"the dimension of the range for the corresponding ADFun."
145	119	);
146	120	CPPAD_ASSERT_KNOWN(
147		p > 0,
	121	q > 0,
148	122	"The first argument to Reverse must be greater than zero."
149	123	);
150	124	CPPAD_ASSERT_KNOWN(
151		taylor_per_var_ >= p,
152		"Less that p taylor_ coefficients are currently stored"
	125	num_order_taylor_ >= q,
	126	"Less that q taylor_ coefficients are currently stored"
153	127	" in this ADFun object."
154	128	);
155
	129	// special case where multiple forward directions have been computed,
	130	// but we are only using the one direction zero order results
	131	if( (q == 1) & (num_direction_taylor_ > 1) )
	132	{ num_order_taylor_ = 1; // number of orders to copy
	133	size_t c = cap_order_taylor_; // keep the same capacity setting
	134	size_t r = 1; // only keep one direction
	135	capacity_order(c, r);
	136	}
	137	CPPAD_ASSERT_KNOWN(
	138	num_direction_taylor_ == 1,
	139	"Reverse mode for Forward(q, r, xq) with more than one direction"
	140	"\n(r > 1) is not yet supported for q > 1."
	141	);
156	142	// initialize entire Partial matrix to zero
157		for(i = 0; i < total_num_var_; i++)
158		for(j = 0; j < p; j++)
159		Partial[i * p + j] = zero;
	143	for(i = 0; i < num_var_tape_; i++)
	144	for(j = 0; j < q; j++)
	145	Partial[i * q + j] = zero;
160	146
161	147	// set the dependent variable direction
162	148	// (use += because two dependent variables can point to same location)
163	149	for(i = 0; i < m; i++)
164		{ CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < total_num_var_ );
	150	{ CPPAD_ASSERT_UNKNOWN( dep_taddr_[i] < num_var_tape_ );
165	151	if( size_t(w.size()) == m )
166		Partial[dep_taddr_[i] * p + p - 1] += w[i];
	152	Partial[dep_taddr_[i] * q + q - 1] += w[i];
167	153	else
168		{ for(k = 0; k < p; k++)
	154	{ for(k = 0; k < q; k++)
169	155	// ? should use += here, first make test to demonstrate bug
170		Partial[ dep_taddr_[i] * p + k ] = w[i * p + k ];
	156	Partial[ dep_taddr_[i] * q + k ] = w[i * q + k ];
171	157	}
172	158	}
173	159
174	160	// evaluate the derivatives
	161	CPPAD_ASSERT_UNKNOWN( cskip_op_.size() == play_.num_op_rec() );
	162	CPPAD_ASSERT_UNKNOWN( load_op_.size() == play_.num_load_op_rec() );
175	163	ReverseSweep(
176		p - 1,
	164	q - 1,
177	165	n,
178		total_num_var_,
	166	num_var_tape_,
179	167	&play_,
180		taylor_col_dim_,
	168	cap_order_taylor_,
181	169	taylor_.data(),
182		p,
	170	q,
183	171	Partial.data(),
184		cskip_op_
	172	cskip_op_.data(),
	173	load_op_
185	174	);
186	175
187	176	// return the derivative values
188		VectorBase value(n * p);
	177	VectorBase value(n * q);
189	178	for(j = 0; j < n; j++)
190		{ CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < total_num_var_ );
	179	{ CPPAD_ASSERT_UNKNOWN( ind_taddr_[j] < num_var_tape_ );
191	180
192	181	// independent variable taddr equals its operator taddr
193	182	CPPAD_ASSERT_UNKNOWN( play_.GetOp( ind_taddr_[j] ) == InvOp );
194	183
195	184	// by the Reverse Identity Theorem
196	185	// partial of y^{(k)} w.r.t. u^{(0)} is equal to
197		// partial of y^{(p-1)} w.r.t. u^{(p - 1 - k)}
	186	// partial of y^{(q-1)} w.r.t. u^{(q - 1 - k)}
198	187	if( size_t(w.size()) == m )
199		{ for(k = 0; k < p; k++)
200		value[j * p + k ] =
201		Partial[ind_taddr_[j] * p + p - 1 - k];
	188	{ for(k = 0; k < q; k++)
	189	value[j * q + k ] =
	190	Partial[ind_taddr_[j] * q + q - 1 - k];
202	191	}
203	192	else
204		{ for(k = 0; k < p; k++)
205		value[j * p + k ] =
206		Partial[ind_taddr_[j] * p + k];
	193	{ for(k = 0; k < q; k++)
	194	value[j * q + k ] =
	195	Partial[ind_taddr_[j] * q + k];
207	196	}
208	197	}
209	198	CPPAD_ASSERT_KNOWN( ! ( hasnan(value) && check_for_nan_ ) ,
210		"dw = f.Reverse(p, w): has a nan,\n"
	199	"dw = f.Reverse(q, w): has a nan,\n"
211	200	"but none of its Taylor coefficents are nan."
212	201	);
213	202

215	204	}
216	205
217	206
218		/! \} /
219	207	} // END_CPPAD_NAMESPACE
220	208	# endif

+98

-53

cppad/local/reverse_sweep.hpp less more

0		/* $Id: reverse_sweep.hpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: reverse_sweep.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_REVERSE_SWEEP_INCLUDED
2	2	# define CPPAD_REVERSE_SWEEP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup reverse_sweep_hpp reverse_sweep.hpp
19		\{
20	18	\file reverse_sweep.hpp
21	19	Compute derivatives of arbitrary order Taylor coefficients.
22	20	*/

67	65	\param numvar
68	66	is the total number of variables on the tape.
69	67	This is also equal to the number of rows in the matrix \a Taylor; i.e.,
70		Rec->num_rec_var().
71
72		\param Rec
73		2DO: change this name from Rec to play (becuase it is a player
74		and not a recorder).
75		The information stored in \a Rec
	68	play->num_var_rec().
	69
	70	\param play
	71	The information stored in \a play
76	72	is a recording of the operations corresponding to the function
77	73	\f[
78	74	F : {\bf R}^n \rightarrow {\bf R}^m
79	75	\f]
80	76	where \f$ n \f$ is the number of independent variables and
81	77	\f$ m \f$ is the number of dependent variables.
	78	We define \f$ u^{(k)} \f$ as the value of <code>x_k</code> in the previous call
	79	of the form
	80	<code>
	81	f.Forward(k, x_k)
	82	</code>
	83	We define
	84	\f$ X : {\bf R}^{n \times d} \rightarrow {\bf R}^n \f$ by
	85	\f[
	86	X(t, u) = u^{(0)} + u^{(1)} t + \cdots + u^{(d)} t^d
	87	\f]
	88	We define
	89	\f$ Y : {\bf R}^{n \times d} \rightarrow {\bf R}^m \f$ by
	90	\f[
	91	Y(t, u) = F[ X(t, u) ]
	92	\f]
82	93	We define the function
83		\f$ G : {\bf R}^{n \times d} \rightarrow {\bf R} \f$ by
	94	\f$ W : {\bf R}^{n \times d} \rightarrow {\bf R} \f$ by
84	95	\f[
85		G( u ) = \frac{1}{d !} \frac{ \partial^d }{ \partial t^d }
86		\left[
87		\sum_{i=1}^m w_i F_i ( u^{(0)} + u^{(1)} t + \cdots + u^{(d)} t^d )
88		\right]_{t=0}
	96	W(u)
	97	=
	98	\sum_{k=0}^{d} ( w^{(k)} )^{\rm T}
	99	\frac{1}{k !} \frac{\partial^k}{\partial t^k} Y(0, u)
89	100	\f]
90		Note that the scale factor 1 / a d converts
91		the \a d-th partial derivative to the \a d-th order Taylor coefficient.
92		This routine computes the derivative of \f$ G(u) \f$
	101	(The matrix \f$ w \in {\bf R}^m \f$,
	102	is defined below under the heading Partial.)
	103	Note that the scale factor 1 / k converts
	104	the k-th partial derivative to the k-th order Taylor coefficient.
	105	This routine computes the derivative of \f$ W(u) \f$
93	106	with respect to all the Taylor coefficients
94	107	\f$ u^{(k)} \f$ for \f$ k = 0 , ... , d \f$.
95		The vector \f$ w \in {\bf R}^m \f$, and
96		value of \f$ u \in {\bf R}^{n \times d} \f$
97		at which the derivative is computed,
98		are defined below.
99	108	\n
100	109	\n
101		The object \a Rec is effectly constant.
	110	The object \a play is effectly constant.
102	111	There is an exception to this,
103	112	while palying back the tape
104		the object \a Rec holds information about the current location
	113	the object \a play holds information about the current location
105	114	with in the tape and this changes during palyback.
106	115
107	116	\param J

126	135	\param Partial
127	136	\b Input:
128	137	The last \f$ m \f$ rows of \a Partial are inputs.
129		The vector \f$ v \f$, used to define \f$ G(u) \f$,
	138	The matrix \f$ w \f$, used to define \f$ W(u) \f$,
130	139	is specified by these rows.
131		For i = 0 , ... , m - 1, \a Partial [ ( \a numvar - m + i ) * K + d ] = v_i.
132		For i = 0 , ... , m - 1 and for k = 0 , ... , d - 1,
133		\a Partial [ ( \a numvar - m + i ) * K + k ] = 0.
	140	For i = 0 , ... , m - 1,
	141	for k = 0 , ... , d,
	142	<code>Partial [ (numvar - m + i ) * K + k ] = w[i,k]</code>.
134	143	\n
135	144	\n
136	145	\b Temporary:

142	151	\b Output:
143	152	For j = 1 , ... , n and for k = 0 , ... , d,
144	153	\a Partial [ j * K + k ]
145		is the partial derivative of \f$ G( u ) \f$ with
	154	is the partial derivative of \f$ W( u ) \f$ with
146	155	respect to \f$ u_j^{(k)} \f$.
147	156
148	157	\param cskip_op
149		Is a vector with size Rec->num_rec_op().
	158	Is a vector with size play->num_op_rec().
150	159	If cskip_op[i] is true, the operator index i in the recording
151	160	does not affect any of the dependent variable (given the value
152	161	of the independent variables).
	162
	163	\param var_by_load_op
	164	is a vector with size play->num_load_op_rec().
	165	Is the variable index corresponding to each load instruction.
	166	In the case where the index is zero,
	167	the instruction corresponds to a parameter (not variable).
153	168
154	169	\par Assumptions
155	170	The first operator on the tape is a BeginOp,

161	176	size_t d,
162	177	size_t n,
163	178	size_t numvar,
164		player<Base>* Rec,
	179	player<Base>* play,
165	180	size_t J,
166	181	const Base* Taylor,
167	182	size_t K,
168	183	Base* Partial,
169		const CppAD::vector<bool>& cskip_op
	184	bool* cskip_op,
	185	const pod_vector<addr_t>& var_by_load_op
170	186	)
171	187	{
172	188	OpCode op;

176	192	const addr_t* arg = CPPAD_NULL;
177	193
178	194	// check numvar argument
179		CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
	195	CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
180	196	CPPAD_ASSERT_UNKNOWN( numvar > 0 );
181	197
182	198	// length of the parameter vector (used by CppAD assert macros)
183		const size_t num_par = Rec->num_rec_par();
	199	const size_t num_par = play->num_par_rec();
184	200
185	201	// pointer to the beginning of the parameter vector
186	202	const Base* parameter = CPPAD_NULL;
187	203	if( num_par > 0 )
188		parameter = Rec->GetPar();
	204	parameter = play->GetPar();
189	205
190	206	// work space used by UserOp.
191	207	const size_t user_k = d; // highest order we are differentiating

214	230	size_t j, ell;
215	231
216	232	// Initialize
217		Rec->start_reverse(op, arg, i_op, i_var);
	233	play->reverse_start(op, arg, i_op, i_var);
218	234	CPPAD_ASSERT_UNKNOWN( op == EndOp );
219	235	# if CPPAD_REVERSE_SWEEP_TRACE
220	236	std::cout << std::endl;

222	238	bool more_operators = true;
223	239	while(more_operators)
224	240	{ // next op
225		Rec->next_reverse(op, arg, i_op, i_var);
	241	play->reverse_next(op, arg, i_op, i_var);
226	242	CPPAD_ASSERT_UNKNOWN((i_op > n) \| (op == InvOp) \| (op == BeginOp));
227	243	CPPAD_ASSERT_UNKNOWN((i_op <= n) \| (op != InvOp) \| (op != BeginOp));
	244	CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
228	245
229	246	// check if we are skipping this operation
230	247	while( cskip_op[i_op] )
231	248	{ if( op == CSumOp )
232	249	{ // CSumOp has a variable number of arguments
233		Rec->reverse_csum(op, arg, i_op, i_var);
	250	play->reverse_csum(op, arg, i_op, i_var);
234	251	}
235		Rec->next_reverse(op, arg, i_op, i_var);
	252	CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
	253	// if( op == CSkipOp )
	254	// { // CSkip has a variable number of arguments
	255	// play->reverse_cskip(op, arg, i_op, i_var);
	256	// }
	257	CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
	258	play->reverse_next(op, arg, i_op, i_var);
236	259	}
237	260
238	261	// rest of informaiton depends on the case
239	262	# if CPPAD_REVERSE_SWEEP_TRACE
	263	if( op == CSumOp )
	264	{ // CSumOp has a variable number of arguments
	265	play->reverse_csum(op, arg, i_op, i_var);
	266	}
	267	if( op == CSkipOp )
	268	{ // CSkip has a variable number of arguments
	269	play->reverse_cskip(op, arg, i_op, i_var);
	270	}
240	271	size_t i_tmp = i_var;
241	272	const Base* Z_tmp = Taylor + i_var * J;
242	273	const Base* pZ_tmp = Partial + i_var * K;
243
244	274	printOp(
245	275	std::cout,
246		Rec,
	276	play,
247	277	i_op,
248	278	i_tmp,
249	279	op,
250		arg,
	280	arg
	281	);
	282	if( NumRes(op) > 0 && op != BeginOp ) printOpResult(
	283	std::cout,
251	284	d + 1,
252	285	Z_tmp,
253	286	d + 1,
254	287	pZ_tmp
255	288	);
256		# endif
257
	289	std::cout << std::endl;
	290	# endif
258	291	switch( op )
259	292	{
260	293

315	348
316	349	case CSkipOp:
317	350	// CSkipOp has a variable number of arguments and
318		// next_forward thinks it one has one argument.
319		// we must inform next_forward of this special case.
320		Rec->reverse_cskip(op, arg, i_op, i_var);
	351	// forward_next thinks it one has one argument.
	352	// we must inform reverse_next of this special case.
	353	# if ! CPPAD_REVERSE_SWEEP_TRACE
	354	play->reverse_cskip(op, arg, i_op, i_var);
	355	# endif
321	356	break;
322	357	// -------------------------------------------------
323	358
324	359	case CSumOp:
325	360	// CSumOp has a variable number of arguments and
326		// next_reverse thinks it one has one argument.
327		// We must inform next_reverse of this special case.
328		Rec->reverse_csum(op, arg, i_op, i_var);
	361	// reverse_next thinks it one has one argument.
	362	// We must inform reverse_next of this special case.
	363	# if ! CPPAD_REVERSE_SWEEP_TRACE
	364	play->reverse_csum(op, arg, i_op, i_var);
	365	# endif
329	366	reverse_csum_op(
330	367	d, i_var, arg, K, Partial
331	368	);

397	434	break;
398	435	// --------------------------------------------------
399	436
	437	# if CPPAD_COMPILER_HAS_ERF
	438	case ErfOp:
	439	reverse_erf_op(
	440	d, i_var, arg, parameter, J, Taylor, K, Partial
	441	);
	442	break;
	443	# endif
	444	// --------------------------------------------------
	445
400	446	case ExpOp:
401	447	reverse_exp_op(
402	448	d, i_var, arg[0], J, Taylor, K, Partial

405	451	// --------------------------------------------------
406	452	case LdpOp:
407	453	reverse_load_op(
408		op, d, i_var, arg, J, Taylor, K, Partial
	454	op, d, i_var, arg, J, Taylor, K, Partial, var_by_load_op.data()
409	455	);
410	456	break;
411	457	// -------------------------------------------------
412	458
413	459	case LdvOp:
414	460	reverse_load_op(
415		op, d, i_var, arg, J, Taylor, K, Partial
	461	op, d, i_var, arg, J, Taylor, K, Partial, var_by_load_op.data()
416	462	);
417	463	break;
418	464	// -------------------------------------------------

697	743	CPPAD_ASSERT_UNKNOWN( i_var == 0 );
698	744	}
699	745
700		/! \} /
701	746	} // END_CPPAD_NAMESPACE
702	747
703	748	// preprocessor symbols that are local to this file

+50

-23

cppad/local/sign_op.hpp less more

0		/* $Id: sign_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sign_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_SIGN_OP_INCLUDED
2	2	# define CPPAD_SIGN_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup sign_op_hpp sign_op.hpp
19		\{
20	18	\file sign_op.hpp
21	19	Forward and reverse mode calculations for z = sign(x).
22	20	*/

33	31	*/
34	32	template <class Base>
35	33	inline void forward_sign_op(
	34	size_t p ,
36	35	size_t q ,
37		size_t p ,
38	36	size_t i_z ,
39	37	size_t i_x ,
40		size_t nc_taylor ,
	38	size_t cap_order ,
41	39	Base* taylor )
42	40	{
43	41	// check assumptions
44	42	CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
45	43	CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
46		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
47		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
48		CPPAD_ASSERT_UNKNOWN( q <= p );
	44	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	45	CPPAD_ASSERT_UNKNOWN( p <= q );
49	46
50	47	// Taylor coefficients corresponding to argument and result
51		Base* x = taylor + i_x * nc_taylor;
52		Base* z = taylor + i_z * nc_taylor;
	48	Base* x = taylor + i_x * cap_order;
	49	Base* z = taylor + i_z * cap_order;
53	50
54		if( q == 0 )
	51	if( p == 0 )
55	52	{ z[0] = sign(x[0]);
56		q++;
	53	p++;
57	54	}
58		for(size_t j = q; j <= p; j++)
	55	for(size_t j = p; j <= q; j++)
59	56	z[j] = Base(0.);
	57	}
	58	/*!
	59	Multiple direction forward mode Taylor coefficient for op = SignOp.
	60
	61	The C++ source code corresponding to this operation is
	62	\verbatim
	63	z = sign(x)
	64	\endverbatim
	65
	66	\copydetails forward_unary1_op_dir
	67	*/
	68	template <class Base>
	69	inline void forward_sign_op_dir(
	70	size_t q ,
	71	size_t r ,
	72	size_t i_z ,
	73	size_t i_x ,
	74	size_t cap_order ,
	75	Base* taylor )
	76	{
	77	// check assumptions
	78	CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
	79	CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
	80	CPPAD_ASSERT_UNKNOWN( 0 < q );
	81	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	82
	83	// Taylor coefficients corresponding to argument and result
	84	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	85	size_t m = (q - 1) * r + 1;
	86	Base* z = taylor + i_z * num_taylor_per_var;
	87
	88	for(size_t ell = 0; ell < r; ell++)
	89	z[m+ell] = Base(0.);
60	90	}
61	91
62	92	/*!

73	103	inline void forward_sign_op_0(
74	104	size_t i_z ,
75	105	size_t i_x ,
76		size_t nc_taylor ,
	106	size_t cap_order ,
77	107	Base* taylor )
78	108	{
79	109
80	110	// check assumptions
81	111	CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
82	112	CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
83		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
84		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	113	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
85	114
86	115	// Taylor coefficients corresponding to argument and result
87		Base x0 = (taylor + i_x nc_taylor);
88		Base* z = taylor + i_z * nc_taylor;
	116	Base x0 = (taylor + i_x cap_order);
	117	Base* z = taylor + i_z * cap_order;
89	118
90	119	z[0] = sign(x0);
91	120	}

105	134	size_t d ,
106	135	size_t i_z ,
107	136	size_t i_x ,
108		size_t nc_taylor ,
	137	size_t cap_order ,
109	138	const Base* taylor ,
110	139	size_t nc_partial ,
111	140	Base* partial )

113	142	// check assumptions
114	143	CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
115	144	CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
116		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
117		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	145	CPPAD_ASSERT_UNKNOWN( d < cap_order );
118	146	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
119	147
120	148	// nothing to do because partials of sign are zero
121	149	return;
122	150	}
123	151
124		/! \} /
125	152	} // END_CPPAD_NAMESPACE
126	153	# endif

+77

-29

cppad/local/sin_op.hpp less more

0		/* $Id: sin_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sin_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_SIN_OP_INCLUDED
2	2	# define CPPAD_SIN_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup sin_op_hpp sin_op.hpp
19		\{
20	18	\file sin_op.hpp
21	19	Forward and reverse mode calculations for z = sin(x).
22	20	*/

40	38	*/
41	39	template <class Base>
42	40	inline void forward_sin_op(
	41	size_t p ,
43	42	size_t q ,
44		size_t p ,
45	43	size_t i_z ,
46	44	size_t i_x ,
47		size_t nc_taylor ,
	45	size_t cap_order ,
48	46	Base* taylor )
49	47	{
50	48	// check assumptions
51	49	CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
52	50	CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
53		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
54		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
55		CPPAD_ASSERT_UNKNOWN( q <= p );
	51	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	52	CPPAD_ASSERT_UNKNOWN( p <= q );
56	53
57	54	// Taylor coefficients corresponding to argument and result
58		Base* x = taylor + i_x * nc_taylor;
59		Base* s = taylor + i_z * nc_taylor;
60		Base* c = s - nc_taylor;
	55	Base* x = taylor + i_x * cap_order;
	56	Base* s = taylor + i_z * cap_order;
	57	Base* c = s - cap_order;
61	58
62	59	// rest of this routine is identical for the following cases:
63	60	// forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op.
	61	// (except that there is a sign difference for the hyperbolic case).
64	62	size_t k;
65		if( q == 0 )
	63	if( p == 0 )
66	64	{ s[0] = sin( x[0] );
67	65	c[0] = cos( x[0] );
68		q++;
69		}
70		for(size_t j = q; j <= p; j++)
	66	p++;
	67	}
	68	for(size_t j = p; j <= q; j++)
71	69	{
72	70	s[j] = Base(0);
73	71	c[j] = Base(0);

79	77	c[j] /= Base(j);
80	78	}
81	79	}
	80	/*!
	81	Compute forward mode Taylor coefficient for result of op = SinOp.
	82
	83	The C++ source code corresponding to this operation is
	84	\verbatim
	85	z = sin(x)
	86	\endverbatim
	87	The auxillary result is
	88	\verbatim
	89	y = cos(x)
	90	\endverbatim
	91	The value of y, and its derivatives, are computed along with the value
	92	and derivatives of z.
	93
	94	\copydetails forward_unary2_op_dir
	95	*/
	96	template <class Base>
	97	inline void forward_sin_op_dir(
	98	size_t q ,
	99	size_t r ,
	100	size_t i_z ,
	101	size_t i_x ,
	102	size_t cap_order ,
	103	Base* taylor )
	104	{
	105	// check assumptions
	106	CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
	107	CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
	108	CPPAD_ASSERT_UNKNOWN( 0 < q );
	109	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	110
	111	// Taylor coefficients corresponding to argument and result
	112	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	113	Base* x = taylor + i_x * num_taylor_per_var;
	114	Base* s = taylor + i_z * num_taylor_per_var;
	115	Base* c = s - num_taylor_per_var;
	116
	117
	118	// rest of this routine is identical for the following cases:
	119	// forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op
	120	// (except that there is a sign difference for the hyperbolic case).
	121	size_t m = (q-1) * r + 1;
	122	for(size_t ell = 0; ell < r; ell++)
	123	{ s[m+ell] = Base(q) * x[m + ell] * c[0];
	124	c[m+ell] = - Base(q) * x[m + ell] * s[0];
	125	for(size_t k = 1; k < q; k++)
	126	{ s[m+ell] += Base(k) * x[(k-1)r+1+ell] c[(q-k-1)*r+1+ell];
	127	c[m+ell] -= Base(k) * x[(k-1)r+1+ell] s[(q-k-1)*r+1+ell];
	128	}
	129	s[m+ell] /= Base(q);
	130	c[m+ell] /= Base(q);
	131	}
	132	}
82	133
83	134
84	135	/*!

100	151	inline void forward_sin_op_0(
101	152	size_t i_z ,
102	153	size_t i_x ,
103		size_t nc_taylor ,
	154	size_t cap_order ,
104	155	Base* taylor )
105	156	{
106	157	// check assumptions
107	158	CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
108	159	CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
109		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
110		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	160	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
111	161
112	162	// Taylor coefficients corresponding to argument and result
113		Base* x = taylor + i_x * nc_taylor;
114		Base* s = taylor + i_z * nc_taylor; // called z in documentation
115		Base* c = s - nc_taylor; // called y in documentation
	163	Base* x = taylor + i_x * cap_order;
	164	Base* s = taylor + i_z * cap_order; // called z in documentation
	165	Base* c = s - cap_order; // called y in documentation
116	166
117	167	s[0] = sin( x[0] );
118	168	c[0] = cos( x[0] );

139	189	size_t d ,
140	190	size_t i_z ,
141	191	size_t i_x ,
142		size_t nc_taylor ,
	192	size_t cap_order ,
143	193	const Base* taylor ,
144	194	size_t nc_partial ,
145	195	Base* partial )

147	197	// check assumptions
148	198	CPPAD_ASSERT_UNKNOWN( NumArg(SinOp) == 1 );
149	199	CPPAD_ASSERT_UNKNOWN( NumRes(SinOp) == 2 );
150		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
151		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	200	CPPAD_ASSERT_UNKNOWN( d < cap_order );
152	201	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
153	202
154	203	// Taylor coefficients and partials corresponding to argument
155		const Base* x = taylor + i_x * nc_taylor;
	204	const Base* x = taylor + i_x * cap_order;
156	205	Base* px = partial + i_x * nc_partial;
157	206
158	207	// Taylor coefficients and partials corresponding to first result
159		const Base* s = taylor + i_z * nc_taylor; // called z in doc
	208	const Base* s = taylor + i_z * cap_order; // called z in doc
160	209	Base* ps = partial + i_z * nc_partial;
161	210
162	211	// Taylor coefficients and partials corresponding to auxillary result
163		const Base* c = s - nc_taylor; // called y in documentation
	212	const Base* c = s - cap_order; // called y in documentation
164	213	Base* pc = ps - nc_partial;
165	214
166	215	// rest of this routine is identical for the following cases:

186	235	px[0] -= pc[0] * s[0];
187	236	}
188	237
189		/! \} /
190	238	} // END_CPPAD_NAMESPACE
191	239	# endif

+78

-30

cppad/local/sinh_op.hpp less more

0		/* $Id: sinh_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sinh_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_SINH_OP_INCLUDED
2	2	# define CPPAD_SINH_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup sinh_op_hpp sinh_op.hpp
19		\{
20	18	\file sinh_op.hpp
21	19	Forward and reverse mode calculations for z = sinh(x).
22	20	*/

40	38	*/
41	39	template <class Base>
42	40	inline void forward_sinh_op(
	41	size_t p ,
43	42	size_t q ,
44		size_t p ,
45	43	size_t i_z ,
46	44	size_t i_x ,
47		size_t nc_taylor ,
	45	size_t cap_order ,
48	46	Base* taylor )
49	47	{
50	48	// check assumptions
51	49	CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
52	50	CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
53		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
54		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
55		CPPAD_ASSERT_UNKNOWN( q <= p );
	51	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	52	CPPAD_ASSERT_UNKNOWN( p <= q );
56	53
57	54	// Taylor coefficients corresponding to argument and result
58		Base* x = taylor + i_x * nc_taylor;
59		Base* s = taylor + i_z * nc_taylor;
60		Base* c = s - nc_taylor;
	55	Base* x = taylor + i_x * cap_order;
	56	Base* s = taylor + i_z * cap_order;
	57	Base* c = s - cap_order;
61	58
62	59
63	60	// rest of this routine is identical for the following cases:
64		// forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op.
	61	// forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op
	62	// (except that there is a sign difference for hyperbolic case).
65	63	size_t k;
66		if( q == 0 )
	64	if( p == 0 )
67	65	{ s[0] = sinh( x[0] );
68	66	c[0] = cosh( x[0] );
69		q++;
70		}
71		for(size_t j = q; j <= p; j++)
	67	p++;
	68	}
	69	for(size_t j = p; j <= q; j++)
72	70	{
73	71	s[j] = Base(0);
74	72	c[j] = Base(0);

80	78	c[j] /= Base(j);
81	79	}
82	80	}
	81	/*!
	82	Compute forward mode Taylor coefficient for result of op = SinhOp.
	83
	84	The C++ source code corresponding to this operation is
	85	\verbatim
	86	z = sinh(x)
	87	\endverbatim
	88	The auxillary result is
	89	\verbatim
	90	y = cosh(x)
	91	\endverbatim
	92	The value of y, and its derivatives, are computed along with the value
	93	and derivatives of z.
	94
	95	\copydetails forward_unary2_op_dir
	96	*/
	97	template <class Base>
	98	inline void forward_sinh_op_dir(
	99	size_t q ,
	100	size_t r ,
	101	size_t i_z ,
	102	size_t i_x ,
	103	size_t cap_order ,
	104	Base* taylor )
	105	{
	106	// check assumptions
	107	CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
	108	CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
	109	CPPAD_ASSERT_UNKNOWN( 0 < q );
	110	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	111
	112	// Taylor coefficients corresponding to argument and result
	113	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	114	Base* x = taylor + i_x * num_taylor_per_var;
	115	Base* s = taylor + i_z * num_taylor_per_var;
	116	Base* c = s - num_taylor_per_var;
	117
	118
	119	// rest of this routine is identical for the following cases:
	120	// forward_sin_op, forward_cos_op, forward_sinh_op, forward_cosh_op
	121	// (except that there is a sign difference for the hyperbolic case).
	122	size_t m = (q-1) * r + 1;
	123	for(size_t ell = 0; ell < r; ell++)
	124	{ s[m+ell] = Base(q) * x[m + ell] * c[0];
	125	c[m+ell] = Base(q) * x[m + ell] * s[0];
	126	for(size_t k = 1; k < q; k++)
	127	{ s[m+ell] += Base(k) * x[(k-1)r+1+ell] c[(q-k-1)*r+1+ell];
	128	c[m+ell] += Base(k) * x[(k-1)r+1+ell] s[(q-k-1)*r+1+ell];
	129	}
	130	s[m+ell] /= Base(q);
	131	c[m+ell] /= Base(q);
	132	}
	133	}
83	134
84	135	/*!
85	136	Compute zero order forward mode Taylor coefficient for result of op = SinhOp.

100	151	inline void forward_sinh_op_0(
101	152	size_t i_z ,
102	153	size_t i_x ,
103		size_t nc_taylor ,
	154	size_t cap_order ,
104	155	Base* taylor )
105	156	{
106	157	// check assumptions
107	158	CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
108	159	CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
109		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
110		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	160	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
111	161
112	162	// Taylor coefficients corresponding to argument and result
113		Base* x = taylor + i_x * nc_taylor;
114		Base* s = taylor + i_z * nc_taylor; // called z in documentation
115		Base* c = s - nc_taylor; // called y in documentation
	163	Base* x = taylor + i_x * cap_order;
	164	Base* s = taylor + i_z * cap_order; // called z in documentation
	165	Base* c = s - cap_order; // called y in documentation
116	166
117	167	s[0] = sinh( x[0] );
118	168	c[0] = cosh( x[0] );

138	188	size_t d ,
139	189	size_t i_z ,
140	190	size_t i_x ,
141		size_t nc_taylor ,
	191	size_t cap_order ,
142	192	const Base* taylor ,
143	193	size_t nc_partial ,
144	194	Base* partial )

146	196	// check assumptions
147	197	CPPAD_ASSERT_UNKNOWN( NumArg(SinhOp) == 1 );
148	198	CPPAD_ASSERT_UNKNOWN( NumRes(SinhOp) == 2 );
149		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
150		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	199	CPPAD_ASSERT_UNKNOWN( d < cap_order );
151	200	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
152	201
153	202	// Taylor coefficients and partials corresponding to argument
154		const Base* x = taylor + i_x * nc_taylor;
	203	const Base* x = taylor + i_x * cap_order;
155	204	Base* px = partial + i_x * nc_partial;
156	205
157	206	// Taylor coefficients and partials corresponding to first result
158		const Base* s = taylor + i_z * nc_taylor; // called z in doc
	207	const Base* s = taylor + i_z * cap_order; // called z in doc
159	208	Base* ps = partial + i_z * nc_partial;
160	209
161	210	// Taylor coefficients and partials corresponding to auxillary result
162		const Base* c = s - nc_taylor; // called y in documentation
	211	const Base* c = s - cap_order; // called y in documentation
163	212	Base* pc = ps - nc_partial;
164	213
165	214	// rest of this routine is identical for the following cases:

185	234	px[0] += pc[0] * s[0];
186	235	}
187	236
188		/! \} /
189	237	} // END_CPPAD_NAMESPACE
190	238	# endif

-5

cppad/local/sparse_binary_op.hpp less more

0		/* $Id: sparse_binary_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sparse_binary_op.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_SPARSE_BINARY_OP_INCLUDED
2	2	# define CPPAD_SPARSE_BINARY_OP_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

13	13
14	14	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
15	15	/*!
16		\defgroup sparse_binary_op_hpp sparse_binary_op.hpp
17		\{
18	16	\file sparse_binary_op.hpp
19	17	Forward and reverse mode sparsity patterns for binary operators.
20	18	*/

325	323	return;
326	324	}
327	325
328		/! \} /
329	326	} // END_CPPAD_NAMESPACE
330	327	# endif

+161

-583

cppad/local/sparse_hessian.hpp less more

0		/* $Id: sparse_hessian.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sparse_hessian.hpp 3239 2014-04-28 23:00:17Z bradbell $ */
1	1	# ifndef CPPAD_SPARSE_HESSIAN_INCLUDED
2	2	# define CPPAD_SPARSE_HESSIAN_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

245	245
246	246	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
247	247	/*!
248		\defgroup sparse_hessian_hpp sparse_hessian.hpp
249		\{
250	248	\file sparse_hessian.hpp
251	249	Sparse Hessian driver routine and helper functions.
252	250	*/

257	255	*/
258	256	class sparse_hessian_work {
259	257	public:
260		/// version of user r array sorted by row or column
261		CppAD::vector<size_t> r_sort;
262		/// version of user c array sorted by row or column
263		CppAD::vector<size_t> c_sort;
264		/// mapping from sorted array indices to user array indices
265		CppAD::vector<size_t> k_sort;
	258	/// indices that sort the user row and col arrays by color
	259	CppAD::vector<size_t> order;
266	260	/// results of the coloring algorithm
267	261	CppAD::vector<size_t> color;
268	262	/// inform CppAD that this information needs to be recomputed
269	263	void clear(void)
270		{ r_sort.clear();
271		c_sort.clear();
272		k_sort.clear();
	264	{ order.clear();
273	265	color.clear();
274	266	}
275	267	};

278	270	Private helper function that does computation for all Sparse Hessian cases.
279	271
280	272	\tparam Base
281		See \c SparseHessian(x, w, p, row, col, hes, work).
	273	is the base type for the recording that is stored in this ADFun<Base object.
282	274
283	275	\tparam VectorBase
284		See \c SparseHessian(x, w, p, row, col, hes, work).
	276	is a simple vector class with elements of type \a Base.
285	277
286	278	\tparam VectorSet
287		is either \c sparse_pack, \c sparse_set or \c sparse_list.
288
289		\param x
290		See \c SparseHessian(x, w, p, row, col, hes, work).
291
292		\param w
293		See \c SparseHessian(x, w, p, row, col, hes, work).
294
295		\param sparsity
296		If <code>work.color.size() != 0</code>, then \c sparsity is not used.
297		Otherwise, it is a
298		sparsity pattern for the Hessian of this ADFun<Base> object.
299
300		\param hes
301		See \c SparseHessian(x, w, p, row, col, hes, work).
	279	is a simple vector class with elements of type
	280	\c bool or \c std::set<size_t>.
	281
	282	\tparam VectorSize
	283	is \c sparse_pack, \c sparse_set or \c sparse_list.
	284
	285	\param x [in]
	286	is a vector specifing the point at which to compute the Hessian.
	287
	288	\param w [in]
	289	is the weighting vector that defines a scalar valued function by
	290	a weighted sum of the components of the vector valued function
	291	$latex F(x)$$.
	292
	293	\param sparsity [in]
	294	is the sparsity pattern for the Hessian that we are calculating.
	295
	296	\param row [in]
	297	is the vector of row indices for the returned Hessian values.
	298
	299	\param col [in]
	300	is the vector of columns indices for the returned Hessian values.
	301	It must have the same size are r.
	302
	303	\param hes [out]
	304	is the vector of Hessian values.
	305	It must have the same size are r.
	306	The return value <code>hes[k]</code> is the second partial of
	307	\f$ w^{\rm T} F(x)\f$ with respect to the
	308	<code>row[k]</code> and <code>col[k]</code> component of \f$ x\f$.
302	309
303	310	\param work
304		See \c SparseHessian(x, w, p, row, col, hes, work).
	311	This structure contains information that is computed by \c SparseHessianCompute.
	312	If the sparsity pattern, \c row vector, or \c col vectors
	313	are not the same between calls to \c SparseHessianCompute,
	314	\c work.clear() must be called to reinitialize \c work.
305	315
306	316	\return
307		See \c SparseHessian(x, w, p, row, col, hes, work).
	317	Is the number of first order forward sweeps used to compute the
	318	requested Hessian values.
	319	(This is also equal to the number of second order reverse sweeps.)
	320	The total work, not counting the zero order
	321	forward sweep, or the time to combine computations, is proportional to this
	322	return value.
308	323	*/
309	324	template<class Base>
310		template <class VectorBase, class VectorSet>
	325	template <class VectorBase, class VectorSet, class VectorSize>
311	326	size_t ADFun<Base>::SparseHessianCompute(
312		const VectorBase& x ,
313		const VectorBase& w ,
314		VectorSet& sparsity ,
315		VectorBase& hes ,
316		sparse_hessian_work& work )
	327	const VectorBase& x ,
	328	const VectorBase& w ,
	329	VectorSet& sparsity ,
	330	const VectorSize& row ,
	331	const VectorSize& col ,
	332	VectorBase& hes ,
	333	sparse_hessian_work& work )
317	334	{
318	335	using CppAD::vectorBool;
319		size_t i, j, k, ell;
320
321		CppAD::vector<size_t>& row(work.r_sort);
322		CppAD::vector<size_t>& col(work.c_sort);
323		CppAD::vector<size_t>& user_k(work.k_sort);
	336	size_t i, k, ell;
	337
324	338	CppAD::vector<size_t>& color(work.color);
	339	CppAD::vector<size_t>& order(work.order);
325	340
326	341	size_t n = Domain();
327	342

337	352
338	353	// number of components of Hessian that are required
339	354	size_t K = hes.size();
340		CPPAD_ASSERT_UNKNOWN( row.size() == K+1 );
	355	CPPAD_ASSERT_UNKNOWN( row.size() == K );
341	356	CPPAD_ASSERT_UNKNOWN( col.size() == K );
342		CPPAD_ASSERT_UNKNOWN( row[K] == n );
343	357
344	358	// Point at which we are evaluating the Hessian
345	359	Forward(0, x);
	360
	361	// check for case where nothing (except Forward above) to do
	362	if( K == 0 )
	363	return 0;
346	364
347	365	// Rows of the Hessian (i below) correspond to the forward mode index
348	366	// and columns (j below) correspond to the reverse mode index.

351	369	CPPAD_ASSERT_UNKNOWN( sparsity.n_set() == n );
352	370	CPPAD_ASSERT_UNKNOWN( sparsity.end() == n );
353	371
354		// rows and columns that are in the returned hessian
355		VectorSet r_used, c_used;
356		r_used.resize(n, n);
357		c_used.resize(n, n);
358		k = 0;
359		while( k < K )
360		{ CPPAD_ASSERT_UNKNOWN( row[k] < n && col[k] < n );
361		CPPAD_ASSERT_UNKNOWN( k == 0 \|\| row[k-1] <= row[k] );
362		CPPAD_ASSERT_KNOWN(
363		sparsity.is_element(row[k], col[k]) ,
364		"SparseHessian: an (row, col) pair is not in sparsity pattern."
365		);
366		r_used.add_element(col[k], row[k]);
367		c_used.add_element(row[k], col[k]);
368		k++;
369		}
370
371		// given a column index, which rows are non-zero and not used
372		VectorSet not_used;
373		not_used.resize(n, n);
374		for(i = 0; i < n; i++)
375		{ sparsity.begin(i);
376		j = sparsity.next_element();
377		while( j != sparsity.end() )
378		{ if( ! r_used.is_element(j , i) )
379		not_used.add_element(j, i);
380		j = sparsity.next_element();
381		}
382		}
383
384		// initial coloring
	372	// execute coloring algorithm
385	373	color.resize(n);
386		for(i = 0; i < n; i++)
387		color[i] = i;
388
389		// See GreedyPartialD2Coloring Algorithm Section 3.6.2 of
390		// Graph Coloring in Optimization Revisited by
391		// Assefaw Gebremedhin, Fredrik Maane, Alex Pothen
392		vectorBool forbidden(n);
393		for(i = 1; i < n; i++)
394		{
395		// initial all colors as ok for this row
396		// (value of forbidden for ell > i does not matter)
397		for(ell = 0; ell <= i; ell++)
398		forbidden[ell] = false;
399
400		// -----------------------------------------------------
401		// Forbid colors that this row would destroy results for.
402		// for each column that is non-zero for this row
403		sparsity.begin(i);
404		j = sparsity.next_element();
405		while( j != sparsity.end() )
406		{ // for each row that this column uses
407		r_used.begin(j);
408		ell = r_used.next_element();
409		while( ell != r_used.end() )
410		{ // if this is not the same row, forbid its color
411		if( ell < i )
412		forbidden[ color[ell] ] = true;
413		ell = r_used.next_element();
414		}
415		j = sparsity.next_element();
416		}
417
418		// -------------------------------------------------------
419		// Forbid colors that would destroy the results for this row.
420		// for each column that this row used
421		c_used.begin(i);
422		j = c_used.next_element();
423		while( j != c_used.end() )
424		{ // For each row that is non-zero for this column
425		// (the used rows have already been checked above).
426		not_used.begin(j);
427		ell = not_used.next_element();
428		while( ell != not_used.end() )
429		{ // if this is not the same row, forbid its color
430		if( ell < i )
431		forbidden[ color[ell] ] = true;
432		ell = not_used.next_element();
433		}
434		j = c_used.next_element();
435		}
436
437		// pick the color with the smallest index
438		ell = 0;
439		while( forbidden[ell] )
440		{ ell++;
441		CPPAD_ASSERT_UNKNOWN( ell <= i );
442		}
443		color[i] = ell;
444		}
	374	color_general_cppad(sparsity, row, col, color);
	375
	376	// put sorting indices in color order
	377	VectorSize key(K);
	378	order.resize(K);
	379	for(k = 0; k < K; k++)
	380	key[k] = color[ row[k] ];
	381	index_sort(key, order);
	382
445	383	}
446	384	size_t n_color = 1;
447		for(ell = 0; ell < n; ell++)
	385	for(ell = 0; ell < n; ell++) if( color[ell] < n )
448	386	n_color = std::max(n_color, color[ell] + 1);
449	387
450	388	// direction vector for calls to forward (rows of the Hessian)

458	396	hes[k] = zero;
459	397
460	398	// loop over colors
461		size_t n_sweep = 0;
	399	k = 0;
462	400	for(ell = 0; ell < n_color; ell++)
463		{ bool any = false;
464		k = 0;
465		for(i = 0; i < n; i++) if( color[i] == ell )
466		{ // find first k such that row[k] has color ell
467		if( ! any )
468		{ while( row[k] < i )
469		k++;
470		any = row[k] == i;
471		}
	401	{ CPPAD_ASSERT_UNKNOWN( color[ row[ order[k] ] ] == ell );
	402
	403	// combine all rows with this color
	404	for(i = 0; i < n; i++)
	405	{ u[i] = zero;
	406	if( color[i] == ell )
	407	u[i] = one;
472	408	}
473		if( any )
474		{ n_sweep++;
475		// combine all rows with this color
476		for(i = 0; i < n; i++)
477		{ u[i] = zero;
478		if( color[i] == ell )
479		u[i] = one;
480		}
481		// call forward mode for all these rows at once
482		Forward(1, u);
483
484		// evaluate derivative of w^T * F'(x) * u
485		ddw = Reverse(2, w);
486
487		// set the corresponding components of the result
488		for(i = 0; i < n; i++) if( color[i] == ell )
489		{ // find first index in c for this column
490		while( row[k] < i )
491		k++;
492		// extract the results for this row
493		while( row[k] == i )
494		{ hes[ user_k[k] ] = ddw[ col[k] * 2 + 1 ];
495		k++;
496		}
497		}
498		}
499		}
500		return n_sweep;
501		}
502		// ===========================================================================
503		/*!
504		Private helper function for vector of \c bool sparsity pattern cases.
505
506		\tparam Base
507		See \c SparseHessian(x, w, p, row, col, hes, work).
508
509		\tparam VectorBase
510		See \c SparseHessian(x, w, p, row, col, hes, work).
511
512		\tparam VectorSet
513		is a simple vector with elements of type \c bool.
514
515		\param set_type
516		has element type for vector representing the sparsity sets.
517
518		\param x
519		See \c SparseHessian(x, w, p, row, col, hes, work).
520
521		\param w
522		See \c SparseHessian(x, w, p, row, col, hes, work).
523
524		\param p
525		Sparsity pattern for the Hessian of this ADFun<Base> object.
526
527		\param hes
528		See \c SparseHessian(x, w, p, row, col, hes, work).
529
530		\param work
531		See \c SparseHessian(x, w, p, row, col, hes, work).
532
533		\return
534		See \c SparseHessian(x, w, p, row, col, hes, work).
535		*/
536		template <class Base>
537		template <class VectorBase, class VectorSet>
538		size_t ADFun<Base>::SparseHessianCase(
539		bool set_type ,
540		const VectorBase& x ,
541		const VectorBase& w ,
542		const VectorSet& p ,
543		VectorBase& hes ,
544		sparse_hessian_work& work )
545		{
546		size_t n = Domain();
547
548		// check VectorSet is Simple Vector class with bool elements
549		CheckSimpleVector<bool, VectorSet>();
550
551		// check VectorBase is Simple Vector class with Base type elements
552		CheckSimpleVector<Base, VectorBase>();
553
554		CPPAD_ASSERT_UNKNOWN( size_t(x.size()) == n );
555		CPPAD_ASSERT_UNKNOWN( size_t(w.size()) == Range() );
556		CPPAD_ASSERT_KNOWN(
557		size_t(p.size()) == n * n,
558		"SparseHessian: using bool values for sparsity and p.size() "
559		"not equal square of domain dimension for f"
560		);
561
562		sparse_pack sparsity;
563		if( work.color.size() == 0 )
564		{ bool transpose = false;
565		sparsity_user2internal(sparsity, p, n, n, transpose);
566		}
567
568		// compute the Hessian
569		size_t n_sweep = SparseHessianCompute(x, w, sparsity, hes, work);
570
571		return n_sweep;
572		}
573		/*!
574		Private helper function for vector of std::set<size_t> sparsity pattern cases.
575
576		\tparam Base
577		See \c SparseHessian(x, w, p, row, col, hes, work).
578
579		\tparam VectorBase
580		See \c SparseHessian(x, w, p, row, col, hes, work).
581
582		\tparam VectorSet
583		is a simple vector with elements of type <code>std::set<size_t></code>.
584
585		\param set_type
586		has element type for vector representing the sparsity sets.
587
588		\param x
589		See \c SparseHessian(x, w, p, row, col, hes, work).
590
591		\param w
592		See \c SparseHessian(x, w, p, row, col, hes, work).
593
594		\param p
595		Sparsity pattern for the Hessian of this ADFun<Base> object.
596
597		\param hes
598		See \c SparseHessian(x, w, p, row, col, hes, work).
599
600		\param work
601		See \c SparseHessian(x, w, p, row, col, hes, work).
602
603		\return
604		See \c SparseHessian(x, w, p, row, col, hes, work).
605		*/
606		template <class Base>
607		template <class VectorBase, class VectorSet>
608		size_t ADFun<Base>::SparseHessianCase(
609		const std::set<size_t>& set_type ,
610		const VectorBase& x ,
611		const VectorBase& w ,
612		const VectorSet& p ,
613		VectorBase& hes ,
614		sparse_hessian_work& work )
615		{
616		size_t n = Domain();
617
618		// check VectorSet is Simple Vector class with std::set<size_t> elements
619		CheckSimpleVector<std::set<size_t>, VectorSet>(
620		one_element_std_set<size_t>(), two_element_std_set<size_t>()
621		);
622
623		// check VectorBase is Simple Vector class with Base type elements
624		CheckSimpleVector<Base, VectorBase>();
625
626		CPPAD_ASSERT_UNKNOWN( size_t(x.size()) == n );
627		CPPAD_ASSERT_UNKNOWN( size_t(w.size()) == Range() );
628		CPPAD_ASSERT_KNOWN(
629		size_t(p.size()) == n,
630		"SparseHessian: using std::set<size_t> for sparsity and p.size() "
631		"not equal domain dimension for f"
632		);
633
634		CPPAD_INTERNAL_SPARSE_SET sparsity;
635		if( work.color.size() == 0 )
636		{ bool transpose = false;
637		sparsity_user2internal(sparsity, p, n, n, transpose);
638		}
639
640		// compute the Hessian
641		size_t n_sweep = SparseHessianCompute(x, w, sparsity, hes, work);
642
643		return n_sweep;
644		}
645		// ===========================================================================
646		/*!
647		Private helper function for SparseHessian(x, w, p).
648
649		All of the description in the public member function SparseHessian(x, w, p)
650		applies.
651
652		\param set_type
653		is a \c bool value. This argument is used to dispatch to the proper source
654		code depending on the value of \c VectorSet::value_type.
655
656		\param x
657		See \c SparseHessian(x, w, p).
658
659		\param w
660		See \c SparseHessian(x, w, p).
661
662		\param p
663		See \c SparseHessian(x, w, p).
664
665		\param hes
666		is the return value for the corresponding call to \c SparseHessian(x, w, p).
667		On input, it must have size equal to the domain times range dimension
668		for this ADFun<Base> object.
669		On return, it will contain the Hessian.
670		*/
671
672		template <class Base>
673		template <class VectorBase, class VectorSet>
674		void ADFun<Base>::SparseHessianCase(
675		bool set_type ,
676		const VectorBase& x ,
677		const VectorBase& w ,
678		const VectorSet& p ,
679		VectorBase& hes )
680		{
681		size_t n = Domain();
682		size_t i, j, k;
683
684		// check Vector is Simple Vector class with bool elements
685		CheckSimpleVector<bool, VectorSet>();
686
687		// check Vector is Simple Vector class with Base type elements
688		CheckSimpleVector<Base, VectorBase>();
689
690		CPPAD_ASSERT_KNOWN(
691		size_t(x.size()) == n,
692		"SparseHessian: size of x not equal domain dimension for f"
693		);
694		CPPAD_ASSERT_KNOWN(
695		size_t(w.size()) == Range(),
696		"SparseHessian: size of w not equal range dimension for f"
697		);
698		CPPAD_ASSERT_KNOWN(
699		size_t(p.size()) == n * n,
700		"SparseHessian: using bool values and size of p "
701		"not equal square of domain dimension for f"
702		);
703		sparse_hessian_work work;
704		CppAD::vector<size_t>& row(work.r_sort);
705		CppAD::vector<size_t>& col(work.c_sort);
706		CppAD::vector<size_t>& user_k(work.k_sort);
707
708		k = 0;
709		for(i = 0; i < n; i++)
710		{ for(j = 0; j < n; j++)
711		if( p[i * n + j] )
712		k++;
713		}
714		size_t K = k;
715		VectorBase H(K);
716		row.resize(K+1);
717		col.resize(K);
718		user_k.resize(K);
719		k = 0;
720		for(i = 0; i < n; i++)
721		{ for(j = 0; j < n; j++)
722		if( p[i * n + j] )
723		{ row[k] = i;
724		col[k] = j;
725		user_k[k] = k;
726		k++;
727		}
728		}
729		row[K] = n;
730
731		SparseHessianCase(set_type, x, w, p, H, work);
732
733		Base zero(0);
734		for(i = 0; i < n; i++)
735		{ for(j = 0; j < n; j++)
736		hes[i * n + j] = zero;
737		}
738		for(k = 0; k < K; k++)
739		hes[row[k] * n + col[k]] = H[k];
740		}
741		/*!
742		Private helper function for SparseHessian(x, w, p).
743
744		All of the description in the public member function SparseHessian(x, w, p)
745		applies.
746
747		\param set_type
748		is a \c std::set<size_t> value.
749		This argument is used to dispatch to the proper source
750		code depending on the value of \c VectorSet::value_type.
751
752		\param x
753		See \c SparseHessian(x, w, p).
754
755		\param w
756		See \c SparseHessian(x, w, p).
757
758		\param p
759		See \c SparseHessian(x, w, p).
760
761		\param hes
762		is the return value for the corresponding call to \c SparseHessian(x, w, p).
763		On input, it must have size equal to the domain times range dimension
764		for this ADFun<Base> object.
765		On return, it will contain the Hessian.
766		*/
767
768		template <class Base>
769		template <class VectorBase, class VectorSet>
770		void ADFun<Base>::SparseHessianCase(
771		const std::set<size_t>& set_type ,
772		const VectorBase& x ,
773		const VectorBase& w ,
774		const VectorSet& p ,
775		VectorBase& hes )
776		{
777		size_t n = Domain();
778		size_t i, j, k;
779
780		// check VectorSet is Simple Vector class with sets for elements
781		CheckSimpleVector<std::set<size_t>, VectorSet>(
782		one_element_std_set<size_t>(), two_element_std_set<size_t>()
783		);
784
785		// check Vector is Simple Vector class with Base type elements
786		CheckSimpleVector<Base, VectorBase>();
787
788		CPPAD_ASSERT_KNOWN(
789		size_t(x.size()) == n,
790		"SparseHessian: size of x not equal domain dimension for f"
791		);
792		CPPAD_ASSERT_KNOWN(
793		size_t(w.size()) == Range(),
794		"SparseHessian: size of w not equal range dimension for f"
795		);
796		CPPAD_ASSERT_KNOWN(
797		size_t(p.size()) == n,
798		"SparseHessian: using size_t sets for sparsity pattern and p.size() "
799		"not equal domain dimension for f"
800		);
801		sparse_hessian_work work;
802		CppAD::vector<size_t>& row(work.r_sort);
803		CppAD::vector<size_t>& col(work.c_sort);
804		CppAD::vector<size_t>& user_k(work.k_sort);
805
806		k = 0;
807		std::set<size_t>::const_iterator itr;
808		for(i = 0; i < n; i++)
809		{ itr = p[i].begin();
810		while( itr != p[i].end() )
811		{ itr++;
	409	// call forward mode for all these rows at once
	410	Forward(1, u);
	411
	412	// evaluate derivative of w^T * F'(x) * u
	413	ddw = Reverse(2, w);
	414
	415	// set the corresponding components of the result
	416	while( k < K && color[ row[ order[k] ] ] == ell )
	417	{ hes[ order[k] ] = ddw[ col[ order[k] ] * 2 + 1 ];
812	418	k++;
813	419	}
814	420	}
815		size_t K = k;
816		VectorBase H(K);
817		row.resize(K+1);
818		col.resize(K);
819		user_k.resize(K);
820		k = 0;
821		for(i = 0; i < n; i++)
822		{ itr = p[i].begin();
823		while( itr != p[i].end() )
824		{ row[k] = i;
825		col[k] = *itr;
826		user_k[k] = k;
827		itr++;
828		k++;
829		}
830		}
831		row[K] = n;
832
833		SparseHessianCase(set_type, x, w, p, H, work);
834
835		Base zero(0);
836		for(i = 0; i < n; i++)
837		{ for(j = 0; j < n; j++)
838		hes[i * n + j] = zero;
839		}
840		for(k = 0; k < K; k++)
841		hes[row[k] * n + col[k]] = H[k];
	421	return n_color;
842	422	}
843	423	// ===========================================================================
844	424	// Public Member Functions

864	444	\tparam VectorSize
865	445	is a simple vector class with elements of type \c size_t.
866	446
867		\param x
	447	\param x [in]
868	448	is a vector specifing the point at which to compute the Hessian.
869	449
870		\param w
	450	\param w [in]
871	451	is the weighting vector that defines a scalar valued function by
872	452	a weighted sum of the components of the vector valued function
873	453	$latex F(x)$$.
874	454
875		\param p
	455	\param p [in]
876	456	is the sparsity pattern for the Hessian that we are calculating.
877	457
878		\param row
	458	\param row [in]
879	459	is the vector of row indices for the returned Hessian values.
880	460
881		\param col
	461	\param col [in]
882	462	is the vector of columns indices for the returned Hessian values.
883	463	It must have the same size are r.
884	464
885		\param hes
	465	\param hes [out]
886	466	is the vector of Hessian values.
887	467	It must have the same size are r.
888	468	The return value <code>hes[k]</code> is the second partial of

890	470	<code>row[k]</code> and <code>col[k]</code> component of \f$ x\f$.
891	471
892	472	\param work
893		contains information that depends on the function object, sparsity pattern,
894		\c row, and \c col vector.
895		If these values are the same, \c work does not need to be recomputed.
896		To be more specific,
897		\c r_sort is sorted copy of \c row ,
898		\c c_sort is sorted copy of \c col ,
899		<code>k_sort[k]</code> is the original index corresponding to the
900		values <code>r_sort[k]</code> and <code>c_sort[k]</code>.
901		The order for the sort is by columns.
902		Let \c n the domain dimension,
903		and \c K the size of \c row , \c col , and \c hes.
904		There is one extra entry
905		in the sorted row array and it has value <code>r_sort[K]=n</code>.
906		The \c color vector is set and used by \c SparseHessianCompute.
	473	This structure contains information that is computed by \c SparseHessianCompute.
	474	If the sparsity pattern, \c row vector, or \c col vectors
	475	are not the same between calls to \c SparseHessian,
	476	\c work.clear() must be called to reinitialize \c work.
907	477
908	478	\return
909	479	Is the number of first order forward sweeps used to compute the

924	494	VectorBase& hes ,
925	495	sparse_hessian_work& work )
926	496	{
927		size_t n = Domain();
	497	size_t n = Domain();
	498	# ifndef NDEBUG
928	499	size_t k, K = hes.size();
929		if( work.r_sort.size() == 0 )
930		{ // create version of (row, col, k) sorted by row value
931		work.c_sort.resize(K);
932		work.r_sort.resize(K+1);
933		work.k_sort.resize(K);
934
935		// put sorting indices in k_sort
936		index_sort(row, work.k_sort);
937
938		for(k = 0; k < K; k++)
939		{ work.r_sort[k] = row[ work.k_sort[k] ];
940		work.c_sort[k] = col[ work.k_sort[k] ];
941		}
942		work.r_sort[K] = n;
943		}
944		# ifndef NDEBUG
945	500	CPPAD_ASSERT_KNOWN(
946	501	size_t(x.size()) == n ,
947	502	"SparseHessian: size of x not equal domain dimension for f."

950	505	size_t(row.size()) == K && size_t(col.size()) == K ,
951	506	"SparseHessian: either r or c does not have the same size as ehs."
952	507	);
953		CPPAD_ASSERT_KNOWN(
954		work.r_sort.size() == K+1 &&
955		work.c_sort.size() == K &&
956		work.k_sort.size() == K ,
957		"SparseHessian: invalid value in work."
958		);
959	508	CPPAD_ASSERT_KNOWN(
960	509	work.color.size() == 0 \|\| work.color.size() == n,
961	510	"SparseHessian: invalid value in work."

969	518	col[k] < n,
970	519	"SparseHessian: invalid value in c."
971	520	);
972		CPPAD_ASSERT_KNOWN(
973		work.k_sort[k] < K,
974		"SparseHessian: invalid value in work."
975		);
976		CPPAD_ASSERT_KNOWN(
977		work.r_sort[k] == row[ work.k_sort[k] ] ,
978		"SparseHessian: invalid value in work."
979		);
980		CPPAD_ASSERT_KNOWN(
981		work.c_sort[k] == col[ work.k_sort[k] ],
982		"SparseHessian: invalid value in work."
983		);
984	521	}
985	522	if( work.color.size() != 0 )
986	523	for(size_t j = 0; j < n; j++) CPPAD_ASSERT_KNOWN(
987		work.color[j] < n,
	524	work.color[j] <= n,
988	525	"SparseHessian: invalid value in work."
989	526	);
990	527	# endif
991
992	528	typedef typename VectorSet::value_type Set_type;
993		size_t n_sweep = SparseHessianCase(Set_type(), x, w, p, hes, work);
	529	typedef typename internal_sparsity<Set_type>::pattern_type Pattern_type;
	530	Pattern_type s;
	531	if( work.color.size() == 0 )
	532	{ bool transpose = false;
	533	sparsity_user2internal(s, p, n, n, transpose);
	534	}
	535	size_t n_sweep = SparseHessianCompute(x, w, s, row, col, hes, work);
994	536	return n_sweep;
995	537	}
996	538	/*!

1013	555	is a simple vector class with elements of type
1014	556	\c bool or \c std::set<size_t>.
1015	557
1016		\param x
	558	\param x [in]
1017	559	is a vector specifing the point at which to compute the Hessian.
1018	560
1019		\param w
	561	\param w [in]
1020	562	The Hessian is computed for a weighted sum of the components
1021	563	of the function corresponding to this ADFun<Base> object.
1022	564	The argument \a w specifies the weights for each component.
1023	565	It must have size equal to the range dimension for this ADFun<Base> object.
1024	566
1025		\param p
	567	\param p [in]
1026	568	is a sparsity pattern for the Hessian.
1027	569
1028	570	\return

1035	577	VectorBase ADFun<Base>::SparseHessian(
1036	578	const VectorBase& x, const VectorBase& w, const VectorSet& p
1037	579	)
1038		{ size_t n = Domain();
	580	{ size_t i, j, k;
	581
	582	size_t n = Domain();
1039	583	VectorBase hes(n * n);
1040	584
	585	CPPAD_ASSERT_KNOWN(
	586	size_t(x.size()) == n,
	587	"SparseHessian: size of x not equal domain size for f."
	588	);
	589
1041	590	typedef typename VectorSet::value_type Set_type;
1042		SparseHessianCase(Set_type(), x, w, p, hes);
	591	typedef typename internal_sparsity<Set_type>::pattern_type Pattern_type;
	592
	593	// initialize the return value as zero
	594	Base zero(0);
	595	for(i = 0; i < n; i++)
	596	for(j = 0; j < n; j++)
	597	hes[i * n + j] = zero;
	598
	599	// arguments to SparseHessianCompute
	600	Pattern_type s;
	601	CppAD::vector<size_t> row;
	602	CppAD::vector<size_t> col;
	603	sparse_hessian_work work;
	604	bool transpose = false;
	605	sparsity_user2internal(s, p, n, n, transpose);
	606	k = 0;
	607	for(i = 0; i < n; i++)
	608	{ s.begin(i);
	609	j = s.next_element();
	610	while( j != s.end() )
	611	{ row.push_back(i);
	612	col.push_back(j);
	613	k++;
	614	j = s.next_element();
	615	}
	616	}
	617	size_t K = k;
	618	VectorBase H(K);
	619
	620	// now we have folded this into the following case
	621	SparseHessianCompute(x, w, s, row, col, H, work);
	622
	623	// now set the non-zero return values
	624	for(k = 0; k < K; k++)
	625	hes[ row[k] * n + col[k] ] = H[k];
1043	626
1044	627	return hes;
1045	628	}

1059	642	\tparam VectorBase
1060	643	is a simple vector class with elements of the \a Base.
1061	644
1062		\param x
	645	\param x [in]
1063	646	is a vector specifing the point at which to compute the Hessian.
1064	647
1065		\param w
	648	\param w [in]
1066	649	The Hessian is computed for a weighted sum of the components
1067	650	of the function corresponding to this ADFun<Base> object.
1068	651	The argument \a w specifies the weights for each component.

1097	680	VectorBool p = RevSparseHes(n, s);
1098	681
1099	682	// compute sparse Hessian
1100		VectorBase hes(n * n);
1101		bool set_type = true; // only used to dispatch compiler to proper case
1102		SparseHessianCase(set_type, x, w, p, hes);
1103
1104		return hes;
	683	return SparseHessian(x, w, p);
1105	684	}
1106	685
1107		/! \} /
1108	686	} // END_CPPAD_NAMESPACE
1109	687	# endif

+339

-519

cppad/local/sparse_jacobian.hpp less more

0		/* $Id: sparse_jacobian.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sparse_jacobian.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_SPARSE_JACOBIAN_INCLUDED
2	2	# define CPPAD_SPARSE_JACOBIAN_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

11	11	A copy of this license is included in the COPYING file of this distribution.
12	12	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13	13	-------------------------------------------------------------------------- */
	14
	15	// maximum number of sparse directions to compute at the same time
	16
	17	// # define CPPAD_SPARSE_JACOBIAN_MAX_MULTIPLE_DIRECTION 1
	18	# define CPPAD_SPARSE_JACOBIAN_MAX_MULTIPLE_DIRECTION 64
	19
14	20	/*
15	21	$begin sparse_jacobian$$
16	22	$spell
	23	cppad
	24	colpack
	25	cmake
17	26	recomputed
18	27	valarray
19	28	std

112	121	%$$
113	122	(see $cref/VectorSize/sparse_jacobian/VectorSize/$$ below).
114	123	They specify which rows and columns of $latex F^{(1)} (x)$$ are
115		returned and in what order.
	124	computes and in what order.
	125	Not all the non-zero entries in $latex F^{(1)} (x)$$ need be computed,
	126	but all the entries specified by $icode row$$ and $icode col$$
	127	must be possibly non-zero in the sparsity pattern.
116	128	We use $latex K$$ to denote the value $icode%jac%.size()%$$
117	129	which must also equal the size of $icode row$$ and $icode col$$.
118	130	Furthermore,
119	131	for $latex k = 0 , \ldots , K-1$$, it must hold that
120	132	$latex row[k] < m$$ and $latex col[k] < n$$.
121		In addition,
122		all of the $latex (row[k], col[k])$$ pairs must correspond to a true value
123		in the sparsity pattern $icode p$$.
124	133
125	134	$head jac$$
126	135	The result $icode jac$$ has prototype

166	175	you must first call $icode%work%.clear()%$$
167	176	to inform CppAD that this information needs to be recomputed.
168	177
	178	$subhead color_method$$
	179	The coloring algorithm determines which columns (forward mode)
	180	or rows (reverse mode) can be computed during the same sweep.
	181	This field has prototype
	182	$codep%
	183	std::string %work%.color_method
	184	%$$
	185	and its default value (after a constructor or $code clear()$$)
	186	is $code "cppad"$$.
	187	If $cref colpack_prefix$$ is specified on the
	188	$cref/cmake command/cmake/CMake Command/$$ line,
	189	you can set this method to $code "colpack"$$.
	190	This value only matters on the first call to $code sparse_jacobian$$
	191	after the $icode work$$ constructor or a call to $code clear$$.
	192
169	193	$head n_sweep$$
170	194	The return value $icode n_sweep$$ has prototype
171	195	$codei%

174	198	If $code SparseJacobianForward$$ ($code SparseJacobianReverse$$) is used,
175	199	$icode n_sweep$$ is the number of first order forward (reverse) sweeps
176	200	used to compute the requested Jacobian values.
	201	(This is also the number of colors determined by the coloring method
	202	mentioned above).
177	203	This is proportional to the total work that $code SparseJacobian$$ does,
178	204	not counting the zero order forward sweep,
179	205	or the work to combine multiple columns (rows) into a single sweep.

234	260	==============================================================================
235	261	*/
236	262	# include <cppad/local/std_set.hpp>
	263	# include <cppad/local/color_general.hpp>
237	264
238	265	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
239	266	/*!
240		\defgroup sparse_jacobian_hpp sparse_jacobian.hpp
241		\{
242	267	\file sparse_jacobian.hpp
243	268	Sparse Jacobian driver routine and helper functions.
244	269	*/

249	274	*/
250	275	class sparse_jacobian_work {
251	276	public:
252		/// version of user row array with the extra value m at end
253		CppAD::vector<size_t> user_row;
254		/// version of user col array with the extra value n at end
255		CppAD::vector<size_t> user_col;
256		/// indices that sort the user arrays by row
257		/// with the extra value K at the end
258		CppAD::vector<size_t> sort_row;
259		/// indices that sort the user arrays by column
260		/// with the extra value K at the end
261		CppAD::vector<size_t> sort_col;
	277	/// Coloring method: color_general_cppad or color_general_colpack
	278	/// (this field is set by user)
	279	std::string color_method;
	280	/// indices that sort the user row and col arrays by color
	281	CppAD::vector<size_t> order;
262	282	/// results of the coloring algorithm
263	283	CppAD::vector<size_t> color;
264		/// inform CppAD that this information needs to be recomputed
	284
	285	/// constructor
	286	sparse_jacobian_work(void) : color_method("cppad")
	287	{ }
	288	/// reset coloring method to its default and
	289	/// inform CppAD that color and order need to be recomputed
265	290	void clear(void)
266		{ user_row.clear();
267		user_col.clear();
268		sort_row.clear();
269		sort_col.clear();
	291	{ color_method = "cppad";
	292	order.clear();
270	293	color.clear();
271	294	}
272	295	};

275	298	Private helper function forward mode cases
276	299
277	300	\tparam Base
278		See \c SparseJacobianForward(x, p, row, col, jac, work).
	301	is the base type for the recording that is stored in this
	302	<code>ADFun<Base></code> object.
279	303
280	304	\tparam VectorBase
281		See \c SparseJacobianForward(x, p, row, col, jac, work).
	305	is a simple vector class with elements of type \a Base.
282	306
283	307	\tparam VectorSet
284	308	is either \c sparse_pack, \c sparse_set or \c sparse_list.
285	309
286		\param x
287		See \c SparseJacobianForward(x, p, row, col, jac, work).
288
289		\param p_transpose
	310	\tparam VectorSize
	311	is a simple vector class with elements of type \c size_t.
	312
	313	\param x [in]
	314	is a vector specifing the point at which to compute the Jacobian.
	315
	316	\param p_transpose [in]
290	317	If <code>work.color.size() != 0</code>,
291	318	then \c p_transpose is not used.
292	319	Otherwise, it is a

294	321	Note that we do not change the values in \c p_transpose,
295	322	but is not \c const because we use its iterator facility.
296	323
297
298		\param jac
299		See \c SparseJacobianForward(x, p, row, col, jac, work).
	324	\param row [in]
	325	is the vector of row indices for the returned Jacobian values.
	326
	327	\param col [in]
	328	is the vector of columns indices for the returned Jacobian values.
	329	It must have the same size as \c row.
	330
	331	\param jac [out]
	332	is the vector of Jacobian values. We use \c K to denote the size of \c jac.
	333	The return value <code>jac[k]</code> is the partial of the
	334	<code>row[k]</code> range component of the function with respect
	335	the the <code>col[k]</code> domain component of its argument.
300	336
301	337	\param work
302		See \c SparseJacobianForward(x, p, row, col, jac, work).
303		In addition, \c work.color contains information that is computed by
304		\c SparseJacobainFor.
305		If the sparsity pattern, \c row vector, and \c col vectors
306		are not the same between calls, \c work.clear() must be called
307		to reinitialize \c work.color.
	338	<code>work.color_method</code> is an input. The rest of
	339	this structure contains information that is computed by \c SparseJacobainFor.
	340	If the sparsity pattern, \c row vector, or \c col vectors
	341	are not the same between calls to \c SparseJacobianFor,
	342	\c work.clear() must be called to reinitialize \c work.
308	343
309	344	\return
310		See \c SparseJacobianForward(x, p, row, col, jac, work).
	345	Is the number of first order forward sweeps used to compute the
	346	requested Jacobian values. The total work, not counting the zero order
	347	forward sweep, or the time to combine computations, is proportional to this
	348	return value.
311	349	*/
312	350	template<class Base>
313		template <class VectorBase, class VectorSet>
	351	template <class VectorBase, class VectorSet, class VectorSize>
314	352	size_t ADFun<Base>::SparseJacobianFor(
315		const VectorBase& x ,
316		VectorSet& p_transpose ,
317		VectorBase& jac ,
318		sparse_jacobian_work& work )
	353	const VectorBase& x ,
	354	VectorSet& p_transpose ,
	355	const VectorSize& row ,
	356	const VectorSize& col ,
	357	VectorBase& jac ,
	358	sparse_jacobian_work& work )
319	359	{
320		using CppAD::vectorBool;
321		size_t i, j, k, ell;
322
323		CppAD::vector<size_t>& row(work.user_row);
324		CppAD::vector<size_t>& col(work.user_col);
325		CppAD::vector<size_t>& sort_col(work.sort_col);
	360	size_t j, k, ell;
	361
	362	CppAD::vector<size_t>& order(work.order);
326	363	CppAD::vector<size_t>& color(work.color);
327	364
328	365	size_t m = Range();

340	377
341	378	// number of components of Jacobian that are required
342	379	size_t K = size_t(jac.size());
343		CPPAD_ASSERT_UNKNOWN( row.size() == K+1 );
344		CPPAD_ASSERT_UNKNOWN( col.size() == K+1 );
345		CPPAD_ASSERT_UNKNOWN( row[K] == m );
346		CPPAD_ASSERT_UNKNOWN( col[K] == n );
	380	CPPAD_ASSERT_UNKNOWN( row.size() == K );
	381	CPPAD_ASSERT_UNKNOWN( col.size() == K );
347	382
348	383	// Point at which we are evaluating the Jacobian
349	384	Forward(0, x);
	385
	386	// check for case where nothing (except Forward above) to do
	387	if( K == 0 )
	388	return 0;
350	389
351	390	if( color.size() == 0 )
352	391	{
353	392	CPPAD_ASSERT_UNKNOWN( p_transpose.n_set() == n );
354	393	CPPAD_ASSERT_UNKNOWN( p_transpose.end() == m );
355	394
356		// rows and columns that are in the returned jacobian
357		VectorSet r_used, c_used;
358		r_used.resize(n, m);
359		c_used.resize(m, n);
360		k = 0;
361		while( k < K )
362		{ CPPAD_ASSERT_UNKNOWN(
363		row[sort_col[k]] < m && col[sort_col[k]] < n
	395	// execute coloring algorithm
	396	color.resize(n);
	397	if( work.color_method == "cppad" )
	398	color_general_cppad(p_transpose, col, row, color);
	399	else if( work.color_method == "colpack" )
	400	{
	401	# if CPPAD_HAS_COLPACK
	402	color_general_colpack(p_transpose, col, row, color);
	403	# else
	404	CPPAD_ASSERT_KNOWN(
	405	false,
	406	"SparseJacobianForward: work.color_method = colpack "
	407	"and colpack_prefix missing from cmake command line."
364	408	);
365		CPPAD_ASSERT_UNKNOWN(
366		k == 0 \|\| col[sort_col[k-1]] <= col[sort_col[k]]
367		);
368		CPPAD_ASSERT_KNOWN(
369		p_transpose.is_element(col[sort_col[k]], row[sort_col[k]]) ,
370		"SparseJacobianForward: "
371		"an (row, col) pair is not in sparsity pattern."
372		);
373		r_used.add_element(col[sort_col[k]], row[sort_col[k]]);
374		c_used.add_element(row[sort_col[k]], col[sort_col[k]]);
375		k++;
	409	# endif
376	410	}
377
378		// given a row index, which columns are non-zero and not used
379		VectorSet not_used;
380		not_used.resize(m, n);
381		for(j = 0; j < n; j++)
382		{ p_transpose.begin(j);
383		i = p_transpose.next_element();
384		while( i != p_transpose.end() )
385		{ if( ! c_used.is_element(i, j) )
386		not_used.add_element(i, j);
387		i = p_transpose.next_element();
388		}
389		}
390
391		// initial coloring
392		color.resize(n);
393		for(j = 0; j < n; j++)
394		color[j] = j;
395
396		// See GreedyPartialD2Coloring Algorithm Section 3.6.2 of
397		// Graph Coloring in Optimization Revisited by
398		// Assefaw Gebremedhin, Fredrik Maane, Alex Pothen
399		vectorBool forbidden(n);
400		for(j = 1; j < n; j++)
401		{
402		// initial all colors as ok for this column
403		// (value of forbidden for ell > j does not matter)
404		for(ell = 0; ell <= j; ell++)
405		forbidden[ell] = false;
406
407		// for each row that is non-zero for this column
408		p_transpose.begin(j);
409		i = p_transpose.next_element();
410		while( i != p_transpose.end() )
411		{ // for each column that this row uses
412		c_used.begin(i);
413		ell = c_used.next_element();
414		while( ell != c_used.end() )
415		{ // if this is not the same column, forbid its color
416		if( ell < j )
417		forbidden[ color[ell] ] = true;
418		ell = c_used.next_element();
419		}
420		i = p_transpose.next_element();
421		}
422
423		// for each row that this column uses
424		r_used.begin(j);
425		i = r_used.next_element();
426		while( i != r_used.end() )
427		{ // For each column that is non-zero for this row
428		// (the used columns have already been checked above).
429		not_used.begin(i);
430		ell = not_used.next_element();
431		while( ell != not_used.end() )
432		{ // if this is not the same column, forbid its color
433		if( ell < j )
434		forbidden[ color[ell] ] = true;
435		ell = not_used.next_element();
436		}
437		i = r_used.next_element();
438		}
439
440		// pick the color with smallest index
441		ell = 0;
442		while( forbidden[ell] )
443		{ ell++;
444		CPPAD_ASSERT_UNKNOWN( ell <= j );
445		}
446		color[j] = ell;
447		}
	411	else CPPAD_ASSERT_KNOWN(
	412	false,
	413	"SparseJacobianForward: work.color_method is not valid."
	414	);
	415
	416	// put sorting indices in color order
	417	VectorSize key(K);
	418	order.resize(K);
	419	for(k = 0; k < K; k++)
	420	key[k] = color[ col[k] ];
	421	index_sort(key, order);
448	422	}
449	423	size_t n_color = 1;
450		for(ell = 0; ell < n; ell++)
451		n_color = std::max(n_color, color[ell] + 1);
452
453		// direction vector for calls to forward
454		VectorBase dx(n);
455
456		// location for return values from forward
457		VectorBase dy(m);
	424	for(j = 0; j < n; j++) if( color[j] < n )
	425	n_color = std::max(n_color, color[j] + 1);
458	426
459	427	// initialize the return value
460	428	for(k = 0; k < K; k++)
461	429	jac[k] = zero;
462	430
	431	# if CPPAD_SPARSE_JACOBIAN_MAX_MULTIPLE_DIRECTION == 1
	432	// direction vector and return values for calls to forward
	433	VectorBase dx(n), dy(m);
	434
463	435	// loop over colors
464		size_t n_sweep = 0;
	436	k = 0;
465	437	for(ell = 0; ell < n_color; ell++)
466		{ bool any = false;
467		k = 0;
468		for(j = 0; j < n; j++) if( color[j] == ell )
469		{ // find first k such that col[sort_col[k]] has color ell
470		if( ! any )
471		{ while( col[sort_col[k]] < j )
472		k++;
473		any = col[sort_col[k]] == j;
	438	{ CPPAD_ASSERT_UNKNOWN( color[ col[ order[k] ] ] == ell );
	439
	440	// combine all columns with this color
	441	for(j = 0; j < n; j++)
	442	{ dx[j] = zero;
	443	if( color[j] == ell )
	444	dx[j] = one;
	445	}
	446	// call forward mode for all these columns at once
	447	dy = Forward(1, dx);
	448
	449	// set the corresponding components of the result
	450	while( k < K && color[ col[order[k]] ] == ell )
	451	{ jac[ order[k] ] = dy[row[order[k]]];
	452	k++;
	453	}
	454	}
	455	# else
	456	// abbreviation for this value
	457	size_t max_r = CPPAD_SPARSE_JACOBIAN_MAX_MULTIPLE_DIRECTION;
	458	CPPAD_ASSERT_UNKNOWN( max_r > 1 );
	459
	460	// count the number of colors done so far
	461	size_t count_color = 0;
	462	// count the sparse matrix entries done so far
	463	k = 0;
	464	while( count_color < n_color )
	465	{ // number of colors we will do this time
	466	size_t r = std::min(max_r , n_color - count_color);
	467	VectorBase dx(n * r), dy(m * r);
	468
	469	// loop over colors we will do this tme
	470	for(ell = 0; ell < r; ell++)
	471	{ // combine all columns with this color
	472	for(j = 0; j < n; j++)
	473	{ dx[j * r + ell] = zero;
	474	if( color[j] == ell + count_color )
	475	dx[j * r + ell] = one;
474	476	}
475	477	}
476		if( any )
477		{ n_sweep++;
478		// combine all columns with this color
479		for(j = 0; j < n; j++)
480		{ dx[j] = zero;
481		if( color[j] == ell )
482		dx[j] = one;
483		}
484		// call forward mode for all these columns at once
485		dy = Forward(1, dx);
486
487		// set the corresponding components of the result
488		for(j = 0; j < n; j++) if( color[j] == ell )
489		{ // find first index in c for this column
490		while( col[sort_col[k]] < j )
491		k++;
492		// extract the row results for this column
493		while( col[sort_col[k]] == j )
494		{ jac[ sort_col[k] ] = dy[row[sort_col[k]]];
495		k++;
496		}
	478	size_t q = 1;
	479	dy = Forward(q, r, dx);
	480
	481	// store results
	482	for(ell = 0; ell < r; ell++)
	483	{ // set the components of the result for this color
	484	while( k < K && color[ col[order[k]] ] == ell + count_color )
	485	{ jac[ order[k] ] = dy[ row[order[k]] * r + ell ];
	486	k++;
497	487	}
498	488	}
499		}
500		return n_sweep;
	489	count_color += r;
	490	}
	491	# endif
	492	return n_color;
501	493	}
502	494	/*!
503	495	Private helper function for reverse mode cases.
504	496
505	497	\tparam Base
506		See \c SparseJacobianForward(x, p, row, col, jac, work).
	498	is the base type for the recording that is stored in this
	499	<code>ADFun<Base></code> object.
507	500
508	501	\tparam VectorBase
509		See \c SparseJacobianForward(x, p, row, col, jac, work).
	502	is a simple vector class with elements of type \a Base.
510	503
511	504	\tparam VectorSet
512	505	is either \c sparse_pack, \c sparse_set or \c sparse_list.
513	506
514		\param x
515		See \c SparseJacobianForward(x, p, row, col, jac, work).
516
517		\param p
	507	\tparam VectorSize
	508	is a simple vector class with elements of type \c size_t.
	509
	510	\param x [in]
	511	is a vector specifing the point at which to compute the Jacobian.
	512
	513	\param p [in]
518	514	If <code>work.color.size() != 0</code>, then \c p is not used.
519	515	Otherwise, it is a
520	516	sparsity pattern for the Jacobian of this ADFun<Base> object.
521		Note that we do not change the values in \c p_transpose,
	517	Note that we do not change the values in \c p,
522	518	but is not \c const because we use its iterator facility.
523	519
524		\param jac
525		See \c SparseJacobianForward(x, p, row, col, jac, work).
	520	\param row [in]
	521	is the vector of row indices for the returned Jacobian values.
	522
	523	\param col [in]
	524	is the vector of columns indices for the returned Jacobian values.
	525	It must have the same size as \c row.
	526
	527	\param jac [out]
	528	is the vector of Jacobian values.
	529	It must have the same size as \c row.
	530	The return value <code>jac[k]</code> is the partial of the
	531	<code>row[k]</code> range component of the function with respect
	532	the the <code>col[k]</code> domain component of its argument.
526	533
527	534	\param work
528		See \c SparseJacobianReverse(x, p, row, col, jac, work).
529		In addition, \c work.color contains information that is computed by
530		\c SparseJacobainRev.
531		If the sparsity pattern, \c row vector, and \c col vectors
532		are not the same between calls, \c work.clear() must be called
533		to reinitialize \c work.color.
	535	<code>work.color_method</code> is an input. The rest of
	536	This structure contains information that is computed by \c SparseJacobainRev.
	537	If the sparsity pattern, \c row vector, or \c col vectors
	538	are not the same between calls to \c SparseJacobianRev,
	539	\c work.clear() must be called to reinitialize \c work.
534	540
535	541	\return
536		See \c SparseJacobianReverse(x, p, row, col, jac, work).
	542	Is the number of first order reverse sweeps used to compute the
	543	reverse Jacobian values. The total work, not counting the zero order
	544	forward sweep, or the time to combine computations, is proportional to this
	545	return value.
537	546	*/
538	547	template<class Base>
539		template <class VectorBase, class VectorSet>
	548	template <class VectorBase, class VectorSet, class VectorSize>
540	549	size_t ADFun<Base>::SparseJacobianRev(
541		const VectorBase& x ,
542		VectorSet& p ,
543		VectorBase& jac ,
544		sparse_jacobian_work& work )
	550	const VectorBase& x ,
	551	VectorSet& p ,
	552	const VectorSize& row ,
	553	const VectorSize& col ,
	554	VectorBase& jac ,
	555	sparse_jacobian_work& work )
545	556	{
546		using CppAD::vectorBool;
547		size_t i, j, k, ell;
548
549		CppAD::vector<size_t>& row(work.user_row);
550		CppAD::vector<size_t>& col(work.user_col);
551		CppAD::vector<size_t>& sort_row(work.sort_row);
	557	size_t i, k, ell;
	558
	559	CppAD::vector<size_t>& order(work.order);
552	560	CppAD::vector<size_t>& color(work.color);
553	561
554	562	size_t m = Range();

566	574
567	575	// number of components of Jacobian that are required
568	576	size_t K = size_t(jac.size());
569		CPPAD_ASSERT_UNKNOWN( row.size() == K+1 );
570		CPPAD_ASSERT_UNKNOWN( col.size() == K+1 );
571		CPPAD_ASSERT_UNKNOWN( row[K] == m );
572		CPPAD_ASSERT_UNKNOWN( col[K] == n );
	577	CPPAD_ASSERT_UNKNOWN( row.size() == K );
	578	CPPAD_ASSERT_UNKNOWN( col.size() == K );
573	579
574	580	// Point at which we are evaluating the Jacobian
575	581	Forward(0, x);
576	582
	583	// check for case where nothing (except Forward above) to do
	584	if( K == 0 )
	585	return 0;
	586
577	587	if( color.size() == 0 )
578		{ CPPAD_ASSERT_UNKNOWN( p.n_set() == m );
579		CPPAD_ASSERT_UNKNOWN( p.end() == n );
580
581		// rows and columns that are in the returned jacobian
582		VectorSet r_used, c_used;
583		r_used.resize(n, m);
584		c_used.resize(m, n);
585		k = 0;
586		while( k < K )
587		{ CPPAD_ASSERT_UNKNOWN(
588		row[sort_row[k]] < m && col[sort_row[k]] < n
	588	{
	589	CPPAD_ASSERT_UNKNOWN( p.n_set() == m );
	590	CPPAD_ASSERT_UNKNOWN( p.end() == n );
	591
	592	// execute the coloring algorithm
	593	color.resize(m);
	594	if( work.color_method == "cppad" )
	595	color_general_cppad(p, row, col, color);
	596	else if( work.color_method == "colpack" )
	597	{
	598	# if CPPAD_HAS_COLPACK
	599	color_general_colpack(p, row, col, color);
	600	# else
	601	CPPAD_ASSERT_KNOWN(
	602	false,
	603	"SparseJacobianReverse: work.color_method = colpack "
	604	"and colpack_prefix missing from cmake command line."
589	605	);
590		CPPAD_ASSERT_UNKNOWN(
591		k == 0 \|\| row[sort_row[k-1]] <= row[sort_row[k]]
592		);
593		CPPAD_ASSERT_KNOWN(
594		p.is_element(row[sort_row[k]], col[sort_row[k]]) ,
595		"SparseJacobianReverse: "
596		"an (row, col) pair is not in sparsity pattern."
597		);
598		r_used.add_element(col[sort_row[k]], row[sort_row[k]]);
599		c_used.add_element(row[sort_row[k]], col[sort_row[k]]);
600		k++;
	606	# endif
601	607	}
602
603		// given a column index, which rows are non-zero and not used
604		VectorSet not_used;
605		not_used.resize(n, m);
606		for(i = 0; i < m; i++)
607		{ p.begin(i);
608		j = p.next_element();
609		while( j != p.end() )
610		{ if( ! r_used.is_element(j , i) )
611		not_used.add_element(j, i);
612		j = p.next_element();
613		}
614		}
615
616		// initial coloring
617		color.resize(m);
618		for(i = 0; i < m; i++)
619		color[i] = i;
620
621		// See GreedyPartialD2Coloring Algorithm Section 3.6.2 of
622		// Graph Coloring in Optimization Revisited by
623		// Assefaw Gebremedhin, Fredrik Maane, Alex Pothen
624		vectorBool forbidden(m);
625		for(i = 1; i < m; i++)
626		{
627		// initial all colors as ok for this row
628		// (value of forbidden for ell > i does not matter)
629		for(ell = 0; ell <= i; ell++)
630		forbidden[ell] = false;
631
632		// -----------------------------------------------------
633		// Forbid colors for which this row would destroy results
634		// for each column that is non-zero for this row
635		p.begin(i);
636		j = p.next_element();
637		while( j != p.end() )
638		{ // for each row that this column uses
639		r_used.begin(j);
640		ell = r_used.next_element();
641		while( ell != r_used.end() )
642		{ // if this is not the same row, forbid its color
643		if( ell < i )
644		forbidden[ color[ell] ] = true;
645		ell = r_used.next_element();
646		}
647		j = p.next_element();
648		}
649
650
651		// -----------------------------------------------------
652		// Forbid colors that would destroy results for this row.
653		// for each column that this row uses
654		c_used.begin(i);
655		j = c_used.next_element();
656		while( j != c_used.end() )
657		{ // For each row that is non-zero for this column
658		// (the used rows have already been checked above).
659		not_used.begin(j);
660		ell = not_used.next_element();
661		while( ell != not_used.end() )
662		{ // if this is not the same row, forbid its color
663		if( ell < i )
664		forbidden[ color[ell] ] = true;
665		ell = not_used.next_element();
666		}
667		j = c_used.next_element();
668		}
669
670		// pick the color with smallest index
671		ell = 0;
672		while( forbidden[ell] )
673		{ ell++;
674		CPPAD_ASSERT_UNKNOWN( ell <= i );
675		}
676		color[i] = ell;
677		}
	608	else CPPAD_ASSERT_KNOWN(
	609	false,
	610	"SparseJacobianReverse: work.color_method is not valid."
	611	);
	612
	613	// put sorting indices in color order
	614	VectorSize key(K);
	615	order.resize(K);
	616	for(k = 0; k < K; k++)
	617	key[k] = color[ row[k] ];
	618	index_sort(key, order);
678	619	}
679	620	size_t n_color = 1;
680		for(ell = 0; ell < m; ell++)
681		n_color = std::max(n_color, color[ell] + 1);
	621	for(i = 0; i < m; i++) if( color[i] < m )
	622	n_color = std::max(n_color, color[i] + 1);
682	623
683	624	// weighting vector for calls to reverse
684	625	VectorBase w(m);

691	632	jac[k] = zero;
692	633
693	634	// loop over colors
694		size_t n_sweep = 0;
	635	k = 0;
695	636	for(ell = 0; ell < n_color; ell++)
696		{ bool any = false;
697		k = 0;
698		for(i = 0; i < m; i++) if( color[i] == ell )
699		{ // find first k such that row[sort_row[k]] has color ell
700		if( ! any )
701		{ while( row[sort_row[k]] < i )
702		k++;
703		any = row[sort_row[k]] == i;
704		}
	637	{ CPPAD_ASSERT_UNKNOWN( color[ row[ order[k] ] ] == ell );
	638
	639	// combine all the rows with this color
	640	for(i = 0; i < m; i++)
	641	{ w[i] = zero;
	642	if( color[i] == ell )
	643	w[i] = one;
705	644	}
706		if( any )
707		{ n_sweep++;
708		// combine all the rows with this color
709		for(i = 0; i < m; i++)
710		{ w[i] = zero;
711		if( color[i] == ell )
712		w[i] = one;
713		}
714		// call reverse mode for all these rows at once
715		dw = Reverse(1, w);
716
717		// set the corresponding components of the result
718		for(i = 0; i < m; i++) if( color[i] == ell )
719		{ // find first index in r for this row
720		while( row[sort_row[k]] < i )
721		k++;
722		// extract the row results for this row
723		while( row[sort_row[k]] == i )
724		{ jac[ sort_row[k] ] = dw[col[sort_row[k]]];
725		k++;
726		}
727		}
	645	// call reverse mode for all these rows at once
	646	dw = Reverse(1, w);
	647
	648	// set the corresponding components of the result
	649	while( k < K && color[ row[order[k]] ] == ell )
	650	{ jac[ order[k] ] = dw[col[order[k]]];
	651	k++;
728	652	}
729	653	}
730		return n_sweep;
	654	return n_color;
731	655	}
732	656	// ==========================================================================
733	657	// Public Member functions

742	666
743	667	\tparam Base
744	668	is the base type for the recording that is stored in this
745		ADFun<Base object.
	669	<code>ADFun<Base></code> object.
746	670
747	671	\tparam VectorBase
748	672	is a simple vector class with elements of type \a Base.

754	678	\tparam VectorSize
755	679	is a simple vector class with elements of type \c size_t.
756	680
757		\param x
	681	\param x [in]
758	682	is a vector specifing the point at which to compute the Jacobian.
759	683
760		\param p
	684	\param p [in]
761	685	is the sparsity pattern for the Jacobian that we are calculating.
762	686
763		\param row
	687	\param row [in]
764	688	is the vector of row indices for the returned Jacobian values.
765	689
766		\param col
	690	\param col [in]
767	691	is the vector of columns indices for the returned Jacobian values.
768		It must have the same size are r.
769
770		\param jac
	692	It must have the same size as \c row.
	693
	694	\param jac [out]
771	695	is the vector of Jacobian values.
772		It must have the same size are r.
	696	It must have the same size as \c row.
773	697	The return value <code>jac[k]</code> is the partial of the
774		<code>row[k]</code> component of the function with respect
775		the the <code>col[k]</code> of its argument.
776
777		\param work
778		\c work contains information that depends on the function object,
	698	<code>row[k]</code> range component of the function with respect
	699	the the <code>col[k]</code> domain component of its argument.
	700
	701	\param work [in,out]
	702	this structure contains information that depends on the function object,
779	703	sparsity pattern, \c row vector, and \c col vector.
780		These \c work values are computed by \c SparseJacobianForward.
781		If they are not the same between calls, \c work.clear() must be called
782		to reinitialize them.
783		To be more specific:
784		\c user_row is a copy of \c row with the value \c m at the end
785		(\c m is the range dimension),
786		\c user_col is a copy of \c col with the value \c n at the end
787		(\c n is the domain dimension),
788		\c sort_col is the index vector that sorts the \c user_col
789		vector with the extra value \c K at the end
790		(\c K is the size of \c jac).
	704	If they are not the same between calls to \c SparseJacobianForward,
	705	\c work.clear() must be called to reinitialize them.
791	706
792	707	\return
793	708	Is the number of first order forward sweeps used to compute the

807	722	{
808	723	size_t n = Domain();
809	724	size_t m = Range();
	725	# ifndef NDEBUG
810	726	size_t k, K = jac.size();
811		if( work.user_row.size() == 0 )
812		{ // create version of (row, col, k) sorted by column value
813		work.user_col.resize(K+1);
814		work.user_row.resize(K+1);
815		work.sort_col.resize(K+1);
816
817		// put sorted indices in user_row and user_col
818		for(k = 0; k < K; k++)
819		{ work.user_row[k] = row[k];
820		work.user_col[k] = col[k];
821		}
822		work.user_row[K] = m;
823		work.user_col[K] = n;
824
825		// put sorting indices in sort_col
826		index_sort(work.user_col, work.sort_col);
827		}
828		# ifndef NDEBUG
829	727	CPPAD_ASSERT_KNOWN(
830	728	size_t(x.size()) == n ,
831	729	"SparseJacobianForward: size of x not equal domain dimension for f."

835	733	"SparseJacobianForward: either r or c does not have "
836	734	"the same size as jac."
837	735	);
838		CPPAD_ASSERT_KNOWN(
839		work.user_row.size() == K+1 &&
840		work.user_col.size() == K+1 &&
841		work.sort_col.size() == K+1 ,
842		"SparseJacobianForward: invalid value in work."
843		);
844	736	CPPAD_ASSERT_KNOWN(
845	737	work.color.size() == 0 \|\| work.color.size() == n,
846	738	"SparseJacobianForward: invalid value in work."

854	746	col[k] < n,
855	747	"SparseJacobianForward: invalid value in c."
856	748	);
857		CPPAD_ASSERT_KNOWN(
858		work.sort_col[k] < K,
859		"SparseJacobianForward: invalid value in work."
860		);
861		CPPAD_ASSERT_KNOWN(
862		work.user_row[k] == row[k],
863		"SparseJacobianForward: invalid value in work."
864		);
865		CPPAD_ASSERT_KNOWN(
866		work.user_col[k] == col[k],
867		"SparseJacobianForward: invalid value in work."
868		);
869	749	}
870	750	if( work.color.size() != 0 )
871	751	for(size_t j = 0; j < n; j++) CPPAD_ASSERT_KNOWN(
872		work.color[j] < n,
	752	work.color[j] <= n,
873	753	"SparseJacobianForward: invalid value in work."
874	754	);
875	755	# endif

881	761	{ bool transpose = true;
882	762	sparsity_user2internal(s_transpose, p, m, n, transpose);
883	763	}
884		size_t n_sweep = SparseJacobianFor(x, s_transpose, jac, work);
	764	size_t n_sweep = SparseJacobianFor(x, s_transpose, row, col, jac, work);
885	765	return n_sweep;
886	766	}
887	767	/*!

893	773	\endverbatim
894	774
895	775	\tparam Base
896		See \c SparseJacobianForward(x, p, row, col, jac, work).
	776	is the base type for the recording that is stored in this
	777	<code>ADFun<Base></code> object.
897	778
898	779	\tparam VectorBase
899		See \c SparseJacobianForward(x, p, row, col, jac, work).
	780	is a simple vector class with elements of type \a Base.
900	781
901	782	\tparam VectorSet
902		See \c SparseJacobianForward(x, p, row, col, jac, work).
	783	is a simple vector class with elements of type
	784	\c bool or \c std::set<size_t>.
903	785
904	786	\tparam VectorSize
905		See \c SparseJacobianForward(x, p, row, col, jac, work).
906
907		\param x
908		See \c SparseJacobianForward(x, p, row, col, jac, work).
909
910		\param p
911		See \c SparseJacobianForward(x, p, row, col, jac, work).
912
913		\param row
914		See \c SparseJacobianForward(x, p, row, col, jac, work).
915
916		\param col
917		See \c SparseJacobianForward(x, p, row, col, jac, work).
918
919		\param jac
920		See \c SparseJacobianForward(x, p, row, col, jac, work).
921
922		\param work
923		\c work contains information that depends on the function object,
	787	is a simple vector class with elements of type \c size_t.
	788
	789	\param x [in]
	790	is a vector specifing the point at which to compute the Jacobian.
	791
	792	\param p [in]
	793	is the sparsity pattern for the Jacobian that we are calculating.
	794
	795	\param row [in]
	796	is the vector of row indices for the returned Jacobian values.
	797
	798	\param col [in]
	799	is the vector of columns indices for the returned Jacobian values.
	800	It must have the same size as \c row.
	801
	802	\param jac [out]
	803	is the vector of Jacobian values.
	804	It must have the same size as \c row.
	805	The return value <code>jac[k]</code> is the partial of the
	806	<code>row[k]</code> range component of the function with respect
	807	the the <code>col[k]</code> domain component of its argument.
	808
	809	\param work [in,out]
	810	this structure contains information that depends on the function object,
924	811	sparsity pattern, \c row vector, and \c col vector.
925		These \c work values are computed by \c SparseJacobianReverse.
926		If they are not the same between calls, \c work.clear() must be called
927		to reinitialize them.
928		To be more specific:
929		\c user_row is a copy of \c row with the value \c m at the end
930		(\c m is the range dimension),
931		\c user_col is a copy of \c col with the value \c n at the end
932		(\c n is the domain dimension),
933		\c sort_row is the index vector that sorts the \c user_row
934		vector with the extra value \c K at the end
935		(\c K is the size of \c jac).
	812	If they are not the same between calls to \c SparseJacobianReverse,
	813	\c work.clear() must be called to reinitialize them.
936	814
937	815	\return
938	816	Is the number of first order reverse sweeps used to compute the

952	830	{
953	831	size_t m = Range();
954	832	size_t n = Domain();
	833	# ifndef NDEBUG
955	834	size_t k, K = jac.size();
956		if( work.user_row.size() == 0 )
957		{ // create version of (row, col, k) sorted by row row value
958		work.user_col.resize(K+1);
959		work.user_row.resize(K+1);
960		work.sort_row.resize(K+1);
961
962		// put sorted indices in user_row and user_col
963		for(k = 0; k < K; k++)
964		{ work.user_row[k] = row[k];
965		work.user_col[k] = col[k];
966		}
967		work.user_row[K] = m;
968		work.user_col[K] = n;
969
970		// put sorting indices in sort_row
971		index_sort(work.user_row, work.sort_row);
972		}
973		# ifndef NDEBUG
974	835	CPPAD_ASSERT_KNOWN(
975	836	size_t(x.size()) == n ,
976	837	"SparseJacobianReverse: size of x not equal domain dimension for f."

980	841	"SparseJacobianReverse: either r or c does not have "
981	842	"the same size as jac."
982	843	);
983		CPPAD_ASSERT_KNOWN(
984		work.user_row.size() == K+1 &&
985		work.user_col.size() == K+1 &&
986		work.sort_row.size() == K+1 ,
987		"SparseJacobianReverse: invalid value in work."
988		);
989	844	CPPAD_ASSERT_KNOWN(
990	845	work.color.size() == 0 \|\| work.color.size() == m,
991	846	"SparseJacobianReverse: invalid value in work."

999	854	col[k] < n,
1000	855	"SparseJacobianReverse: invalid value in c."
1001	856	);
1002		CPPAD_ASSERT_KNOWN(
1003		work.sort_row[k] < K,
1004		"SparseJacobianReverse: invalid value in work."
1005		);
1006		CPPAD_ASSERT_KNOWN(
1007		work.user_row[k] == row[k],
1008		"SparseJacobianReverse: invalid value in work."
1009		);
1010		CPPAD_ASSERT_KNOWN(
1011		work.user_col[k] == col[k],
1012		"SparseJacobianReverse: invalid value in work."
1013		);
1014	857	}
1015	858	if( work.color.size() != 0 )
1016	859	for(size_t i = 0; i < m; i++) CPPAD_ASSERT_KNOWN(
1017		work.color[i] < m,
	860	work.color[i] <= m,
1018	861	"SparseJacobianReverse: invalid value in work."
1019	862	);
1020	863	# endif

1026	869	{ bool transpose = false;
1027	870	sparsity_user2internal(s, p, m, n, transpose);
1028	871	}
1029		size_t n_sweep = SparseJacobianRev(x, s, jac, work);
	872	size_t n_sweep = SparseJacobianRev(x, s, row, col, jac, work);
1030	873	return n_sweep;
1031	874	}
1032	875	/*!

1039	882
1040	883	\tparam Base
1041	884	is the base type for the recording that is stored in this
1042		ADFun<Base object.
	885	<code>ADFun<Base></code> object.
1043	886
1044	887	\tparam VectorBase
1045	888	is a simple vector class with elements of type \a Base.

1048	891	is a simple vector class with elements of type
1049	892	\c bool or \c std::set<size_t>.
1050	893
1051		\param x
	894	\param x [in]
1052	895	is a vector specifing the point at which to compute the Jacobian.
1053	896
1054		\param p
	897	\param p [in]
1055	898	is the sparsity pattern for the Jacobian that we are calculating.
1056	899
1057	900	\return

1085	928	jac[i * n + j] = zero;
1086	929
1087	930	sparse_jacobian_work work;
	931	CppAD::vector<size_t> row;
	932	CppAD::vector<size_t> col;
1088	933	if( n <= m )
1089		{ CppAD::vector<size_t>& row(work.user_row);
1090		CppAD::vector<size_t>& col(work.user_col);
1091		CppAD::vector<size_t>& sort_col(work.sort_col);
1092
1093		// forward mode, columns are sorted
1094		assert( row.size() == 0 );
1095		assert( col.size() == 0 );
1096		assert( sort_col.size() == 0 );
1097
	934	{
1098	935	// need an internal copy of sparsity pattern
1099	936	Pattern_type s_transpose;
1100	937	bool transpose = true;

1107	944	while( i != s_transpose.end() )
1108	945	{ row.push_back(i);
1109	946	col.push_back(j);
1110		sort_col.push_back(k);
1111	947	k++;
1112	948	i = s_transpose.next_element();
1113	949	}
1114	950	}
1115	951	size_t K = k;
1116	952	VectorBase J(K);
1117		row.push_back(m);
1118		col.push_back(n);
1119		sort_col.push_back(K);
1120	953
1121	954	// now we have folded this into the following case
1122		SparseJacobianFor(x, s_transpose, J, work);
	955	SparseJacobianFor(x, s_transpose, row, col, J, work);
1123	956
1124	957	// now set the non-zero return values
1125	958	for(k = 0; k < K; k++)
1126		jac[row[sort_col[k]] * n + col[sort_col[k]]] = J[k];
	959	jac[ row[k] * n + col[k] ] = J[k];
1127	960	}
1128	961	else
1129		{ CppAD::vector<size_t>& row(work.user_row);
1130		CppAD::vector<size_t>& col(work.user_col);
1131		CppAD::vector<size_t>& sort_row(work.sort_row);
1132
1133		// reverse mode, rows are sorted
1134		assert( row.size() == 0 );
1135		assert( col.size() == 0 );
1136		assert( sort_row.size() == 0 );
1137
	962	{
1138	963	// need an internal copy of sparsity pattern
1139	964	Pattern_type s;
1140	965	bool transpose = false;

1147	972	while( j != s.end() )
1148	973	{ row.push_back(i);
1149	974	col.push_back(j);
1150		sort_row.push_back(k);
1151	975	k++;
1152	976	j = s.next_element();
1153	977	}
1154	978	}
1155	979	size_t K = k;
1156	980	VectorBase J(K);
1157		row.push_back(m);
1158		col.push_back(n);
1159		sort_row.push_back(K);
1160	981
1161	982	// now we have folded this into the following case
1162		SparseJacobianRev(x, s, J, work);
	983	SparseJacobianRev(x, s, row, col, J, work);
1163	984
1164	985	// now set the non-zero return values
1165	986	for(k = 0; k < K; k++)
1166		jac[row[sort_row[k]] * n + col[sort_row[k]]] = J[k];
	987	jac[ row[k] * n + col[k] ] = J[k];
1167	988	}
1168	989
1169	990	return jac;

1179	1000
1180	1001	\tparam Base
1181	1002	is the base type for the recording that is stored in this
1182		ADFun<Base object.
	1003	<code>ADFun<Base></code> object.
1183	1004
1184	1005	\tparam VectorBase
1185	1006	is a simple vector class with elements of the \a Base.
1186	1007
1187		\param x
	1008	\param x [in]
1188	1009	is a vector specifing the point at which to compute the Jacobian.
1189	1010
1190	1011	\return

1229	1050	return SparseJacobian(x, p);
1230	1051	}
1231	1052
1232
1233		/! \} /
1234	1053	} // END_CPPAD_NAMESPACE
	1054	# undef CPPAD_SPARSE_JACOBIAN_MAX_MULTIPLE_DIRECTION
1235	1055	# endif

-5

cppad/local/sparse_list.hpp less more

0		/* $Id: sparse_list.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sparse_list.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_SPARSE_LIST_INCLUDED
2	2	# define CPPAD_SPARSE_LIST_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

16	16
17	17	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
18	18	/*!
19		\defgroup sparse_list_hpp sparse_list.hpp
20		\{
21	19	\file sparse_list.hpp
22	20	Vector of sets of positive integers stored as singly linked lists.
23	21	*/

423	421	}
424	422
425	423
426		/! \} /
427	424	} // END_CPPAD_NAMESPACE
428	425	# endif

-5

cppad/local/sparse_pack.hpp less more

0		// $Id: sparse_pack.hpp 2910 2013-10-07 13:27:58Z bradbell $
	0	// $Id: sparse_pack.hpp 3301 2014-05-24 05:20:21Z bradbell $
1	1	# ifndef CPPAD_SPARSE_PACK_INCLUDED
2	2	# define CPPAD_SPARSE_PACK_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

16	16
17	17	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
18	18	/*!
19		\defgroup sparse_pack_hpp sparse_pack.hpp
20		\{
21	19	\file sparse_pack.hpp
22	20	Vector of sets of positive integers stored as a packed array of bools.
23	21	*/

413	411	return;
414	412	}
415	413
416		/! \} /
417	414	} // END_CPPAD_NAMESPACE
418	415	# endif

-5

cppad/local/sparse_pattern.hpp less more

0		/* $Id: sparse_pattern.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sparse_pattern.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_SPARSE_PATTERN_INCLUDED
2	2	# define CPPAD_SPARSE_PATTERN_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

20	20
21	21	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
22	22	/*!
23		\defgroup sparse_pattern_hpp sparse_pattern.hpp
24		\{
25	23	\file sparse_pattern.hpp
26	24	Determine internal spasity pattern from correpsonding element type.
27	25	*/

55	53	typedef CPPAD_INTERNAL_SPARSE_SET pattern_type;
56	54	};
57	55
58		/! \} /
59	56	} // END_CPPAD_NAMESPACE
60	57
61	58	# endif

-5

cppad/local/sparse_set.hpp less more

0		// $Id: sparse_set.hpp 2910 2013-10-07 13:27:58Z bradbell $
	0	// $Id: sparse_set.hpp 3301 2014-05-24 05:20:21Z bradbell $
1	1	# ifndef CPPAD_SPARSE_SET_INCLUDED
2	2	# define CPPAD_SPARSE_SET_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

19	19
20	20	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
21	21	/*!
22		\defgroup sparse_set_hpp sparse_set.hpp
23		\{
24	22	\file sparse_set.hpp
25	23	Vector of sets of positive integers stored as std::set<size_t>.
26	24	*/

370	368	return;
371	369	}
372	370
373		/! \} /
374	371	} // END_CPPAD_NAMESPACE
375	372	# endif

+14

-17

cppad/local/sparse_unary_op.hpp less more

0		/* $Id: sparse_unary_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sparse_unary_op.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	# ifndef CPPAD_SPARSE_UNARY_OP_INCLUDED
2	2	# define CPPAD_SPARSE_UNARY_OP_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

13	13
14	14	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
15	15	/*!
16		\defgroup sparse_unary_op_hpp sparse_unary_op.hpp
17		\{
18	16	\file sparse_unary_op.hpp
19	17	Forward and reverse mode sparsity patterns for unary operators.
20	18	*/

29	27	\endverbatim
30	28	where fun is a C++ unary function, or it has the form
31	29	\verbatim
32		z = x op p
33		\endverbatim
34		where op is a C++ binary unary operator and p is a parameter.
	30	z = x op q
	31	\endverbatim
	32	where op is a C++ binary unary operator and q is a parameter.
35	33
36	34	\tparam Vector_set
37	35	is the type used for vectors of sets. It can be either

84	82	\endverbatim
85	83	where fun is a C++ unary function, or it has the form
86	84	\verbatim
87		z = x op p
88		\endverbatim
89		where op is a C++ bianry operator and p is a parameter.
	85	z = x op q
	86	\endverbatim
	87	where op is a C++ bianry operator and q is a parameter.
90	88
91	89	This routine is given the sparsity patterns
92	90	for a function G(z, y, ... )

148	146	\endverbatim
149	147	where fun is a linear functions; e.g. abs, or
150	148	\verbatim
151		z = x op p
152		\endverbatim
153		where op is a C++ binary operator and p is a parameter.
	149	z = x op q
	150	\endverbatim
	151	where op is a C++ binary operator and q is a parameter.
154	152
155	153	\copydetails reverse_sparse_hessian_unary_op
156	154	*/

180	178	\endverbatim
181	179	where fun is a non-linear functions; e.g. sin. or
182	180	\verbatim
183		z = p / x
184		\endverbatim
185		where p is a parameter.
	181	z = q / x
	182	\endverbatim
	183	where q is a parameter.
186	184
187	185
188	186	\copydetails reverse_sparse_hessian_unary_op

206	204	return;
207	205	}
208	206
209		/! \} /
210	207	} // END_CPPAD_NAMESPACE
211	208	# endif

+63

-24

cppad/local/sqrt_op.hpp less more

0		/* $Id: sqrt_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sqrt_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_SQRT_OP_INCLUDED
2	2	# define CPPAD_SQRT_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup sqrt_op_hpp sqrt_op.hpp
19		\{
20	18	\file sqrt_op.hpp
21	19	Forward and reverse mode calculations for z = sqrt(x).
22	20	*/

34	32	*/
35	33	template <class Base>
36	34	inline void forward_sqrt_op(
	35	size_t p ,
37	36	size_t q ,
38		size_t p ,
39	37	size_t i_z ,
40	38	size_t i_x ,
41		size_t nc_taylor ,
	39	size_t cap_order ,
42	40	Base* taylor )
43	41	{
44	42	// check assumptions
45	43	CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
46	44	CPPAD_ASSERT_UNKNOWN( NumRes(SqrtOp) == 1 );
47		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
48		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
49		CPPAD_ASSERT_UNKNOWN( q <= p );
	45	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	46	CPPAD_ASSERT_UNKNOWN( p <= q );
50	47
51	48	// Taylor coefficients corresponding to argument and result
52		Base* x = taylor + i_x * nc_taylor;
53		Base* z = taylor + i_z * nc_taylor;
	49	Base* x = taylor + i_x * cap_order;
	50	Base* z = taylor + i_z * cap_order;
54	51
55	52	size_t k;
56		if( q == 0 )
	53	if( p == 0 )
57	54	{ z[0] = sqrt( x[0] );
58		q++;
	55	p++;
59	56	}
60		for(size_t j = q; j <= p; j++)
	57	for(size_t j = p; j <= q; j++)
61	58	{
62	59	CPPAD_ASSERT_KNOWN(
63	60	x[0] != Base(0),

73	70	}
74	71
75	72	/*!
	73	Multiple direction forward mode Taylor coefficient for op = SqrtOp.
	74
	75	The C++ source code corresponding to this operation is
	76	\verbatim
	77	z = sqrt(x)
	78	\endverbatim
	79
	80	\copydetails forward_unary1_op_dir
	81	*/
	82	template <class Base>
	83	inline void forward_sqrt_op_dir(
	84	size_t q ,
	85	size_t r ,
	86	size_t i_z ,
	87	size_t i_x ,
	88	size_t cap_order ,
	89	Base* taylor )
	90	{
	91	// check assumptions
	92	CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
	93	CPPAD_ASSERT_UNKNOWN( NumRes(SqrtOp) == 1 );
	94	CPPAD_ASSERT_UNKNOWN( 0 < q );
	95	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	96
	97	// Taylor coefficients corresponding to argument and result
	98	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	99	Base* z = taylor + i_z * num_taylor_per_var;
	100	Base* x = taylor + i_x * num_taylor_per_var;
	101	CPPAD_ASSERT_KNOWN(
	102	x[0] != Base(0),
	103	"Forward: attempt to take derivatve of square root of zero"
	104	)
	105
	106	size_t m = (q-1) * r + 1;
	107	for(size_t ell = 0; ell < r; ell++)
	108	{ z[m+ell] = Base(0);
	109	for(size_t k = 1; k < q; k++)
	110	z[m+ell] -= Base(k) * z[(k-1)r+1+ell] z[(q-k-1)*r+1+ell];
	111	z[m+ell] /= Base(q);
	112	z[m+ell] += x[m+ell] / Base(2);
	113	z[m+ell] /= z[0];
	114	}
	115	}
	116
	117	/*!
76	118	Compute zero order forward mode Taylor coefficient for result of op = SqrtOp.
77	119
78	120	The C++ source code corresponding to this operation is

86	128	inline void forward_sqrt_op_0(
87	129	size_t i_z ,
88	130	size_t i_x ,
89		size_t nc_taylor ,
	131	size_t cap_order ,
90	132	Base* taylor )
91	133	{
92	134	// check assumptions
93	135	CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
94	136	CPPAD_ASSERT_UNKNOWN( NumRes(SqrtOp) == 1 );
95		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
96		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	137	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
97	138
98	139	// Taylor coefficients corresponding to argument and result
99		Base* x = taylor + i_x * nc_taylor;
100		Base* z = taylor + i_z * nc_taylor;
	140	Base* x = taylor + i_x * cap_order;
	141	Base* z = taylor + i_z * cap_order;
101	142
102	143	z[0] = sqrt( x[0] );
103	144	}

117	158	size_t d ,
118	159	size_t i_z ,
119	160	size_t i_x ,
120		size_t nc_taylor ,
	161	size_t cap_order ,
121	162	const Base* taylor ,
122	163	size_t nc_partial ,
123	164	Base* partial )

125	166	// check assumptions
126	167	CPPAD_ASSERT_UNKNOWN( NumArg(SqrtOp) == 1 );
127	168	CPPAD_ASSERT_UNKNOWN( NumRes(SqrtOp) == 1 );
128		CPPAD_ASSERT_UNKNOWN( i_x < i_z );
129		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	169	CPPAD_ASSERT_UNKNOWN( d < cap_order );
130	170	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
131	171
132	172	// Taylor coefficients and partials corresponding to argument
133	173	Base* px = partial + i_x * nc_partial;
134	174
135	175	// Taylor coefficients and partials corresponding to result
136		const Base* z = taylor + i_z * nc_taylor;
	176	const Base* z = taylor + i_z * cap_order;
137	177	Base* pz = partial + i_z * nc_partial;
138	178
139	179	CPPAD_ASSERT_KNOWN(

159	199	px[0] += pz[0] / (Base(2) * z[0]);
160	200	}
161	201
162		/! \} /
163	202	} // END_CPPAD_NAMESPACE
164	203	# endif

+40

-8

cppad/local/std_math_ad.hpp less more

0		/* $Id: std_math_ad.hpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: std_math_ad.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_STD_MATH_AD_INCLUDED
2	2	# define CPPAD_STD_MATH_AD_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

251	251	*/
252	252
253	253	/*!
254		\defgroup std_math_ad_hpp std_math_ad.hpp
255		\{
256	254	\file std_math_ad.hpp
257	255	Define AD<Base> standard math functions (using their Base versions)
258	256	*/

286	284	CPPAD_ASSERT_UNKNOWN( Parameter(result) ); \
287	285	\
288	286	if( Variable(*this) ) \
289		{ CPPAD_ASSERT_UNKNOWN( NumRes(Op) <= 2 ); \
290		CPPAD_ASSERT_UNKNOWN( NumArg(Op) == 1 ); \
	287	{ CPPAD_ASSERT_UNKNOWN( NumArg(Op) == 1 ); \
291	288	ADTape<Base> *tape = tape_this(); \
292	289	tape->Rec_.PutArg(taddr_); \
293	290	result.taddr_ = tape->Rec_.PutOp(Op); \
294		result.tape_id_ = tape->id_; \
	291	result.tape_id_ = tape->id_; \
295	292	} \
296	293	return result; \
297	294	} \

316	313	CPPAD_STANDARD_MATH_UNARY_AD(tan, TanOp)
317	314	CPPAD_STANDARD_MATH_UNARY_AD(tanh, TanhOp)
318	315
	316	# if CPPAD_COMPILER_HAS_ERF
	317	// Error function is a special case
	318	template <class Base>
	319	inline AD<Base> erf(const AD<Base> &x)
	320	{ return x.erf(); }
	321	template <class Base>
	322	inline AD<Base> AD<Base>::erf (void) const
	323	{
	324	AD<Base> result;
	325	result.value_ = CppAD::erf(value_);
	326	CPPAD_ASSERT_UNKNOWN( Parameter(result) );
	327
	328	if( Variable(*this) )
	329	{ CPPAD_ASSERT_UNKNOWN( NumArg(ErfOp) == 3 );
	330	ADTape<Base> *tape = tape_this();
	331	// arg[0] = argument to erf function
	332	tape->Rec_.PutArg(taddr_);
	333	// arg[1] = zero
	334	addr_t p = tape->Rec_.PutPar( Base(0) );
	335	tape->Rec_.PutArg(p);
	336	// arg[2] = 2 / sqrt(pi)
	337	p = tape->Rec_.PutPar(Base(
	338	1.0 / std::sqrt( std::atan(1.0) )
	339	));
	340	tape->Rec_.PutArg(p);
	341	//
	342	result.taddr_ = tape->Rec_.PutOp(ErfOp);
	343	result.tape_id_ = tape->id_;
	344	}
	345	return result;
	346	}
	347	template <class Base>
	348	inline AD<Base> erf(const VecAD_reference<Base> &x)
	349	{ return erf( x.ADBase() ); }
	350	# endif
	351
319	352	/*!
320	353	Compute the log of base 10 of x where has type AD<Base>
321	354

339	372
340	373	# undef CPPAD_STANDARD_MATH_UNARY_AD
341	374
342		/! \} /
343	375	# endif

-5

cppad/local/std_set.hpp less more

0		// $Id: std_set.hpp 2910 2013-10-07 13:27:58Z bradbell $
	0	// $Id: std_set.hpp 3232 2014-04-27 15:38:21Z bradbell $
1	1	# ifndef CPPAD_STD_SET_INCLUDED
2	2	# define CPPAD_STD_SET_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

19	19
20	20	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
21	21	/*!
22		\defgroup std_set_hpp std_set.hpp
23		\{
24	22	\file std_set.hpp
25	23	Two constant standard sets (currently used for concept checking).
26	24	*/

50	48	return two;
51	49	}
52	50
53		/! \} /
54	51	} // END_CPPAD_NAMESPACE
55	52	# endif

+70

-100

cppad/local/store_op.hpp less more

0		/* $Id: store_op.hpp 2921 2013-10-11 13:40:21Z bradbell $ */
	0	/* $Id: store_op.hpp 3322 2014-09-12 10:29:34Z bradbell $ */
1	1	# ifndef CPPAD_STORE_OP_INCLUDED
2	2	# define CPPAD_STORE_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup store_op_hpp store_op.hpp
18		\{
19	17	\file store_op.hpp
20	18	Changing the current value of a VecAD element.
21	19	*/

31	29	and y is AD<Base> or Base objects.
32	30	We define the index corresponding to v[x] by
33	31	\verbatim
34		i_v_x = combined[ arg[0] + i_vec ]
35		\endverbatim
36		where i_vec is defined under the heading \a arg[1] below:
	32	i_v_x = index_by_ind[ arg[0] + i_vec ]
	33	\endverbatim
	34	where i_vec is defined under the heading arg[1] below:
37	35
38	36	\tparam Base
39	37	base type for the operator; i.e., this operation was recorded
40		using AD< \a Base > and computations by this routine are done using type
41		\a Base.
	38	using AD<Base> and computations by this routine are done using type Base.
42	39
43	40	\param i_z
44	41	is the index corresponding to the previous variable on the tape

46	43
47	44	\param arg
48	45	\n
49		\a arg[0]
	46	arg[0]
	47	\n
50	48	is the offset of this VecAD vector relative to the beginning
51		of the \a combined VecAD array.
	49	of the isvar_by_ind and index_by_ind arrays.
52	50	\n
53	51	\n
54		\a arg[1]
55		\n
56		If this is a StppOp or StpvOp operation
57		(the index x is a parameter), i_vec is defined by
	52	arg[1]
	53	\n
	54	If this is a StppOp or StpvOp operation (if x is a parameter),
	55	i_vec is defined by
58	56	\verbatim
59	57	i_vec = arg[1]
60	58	\endverbatim
61		If this is a StvpOp or StvvOp operation
62		(the index x is a variable), i_vec is defined by
63		\verbatim
64		i_vec = floor( taylor[ arg[1] * nc_taylor + 0 ] )
	59	If this is a StvpOp or StvvOp operation (if x is a variable),
	60	i_vec is defined by
	61	\verbatim
	62	i_vec = floor( taylor[ arg[1] * cap_order + 0 ] )
65	63	\endverbatim
66	64	where floor(c) is the greatest integer less that or equal c.
67	65	\n
68	66	\n
69		\a arg[2]
	67	arg[2]
70	68	\n
71	69	index corresponding to the third operand for this operator;
72	70	i.e. the index corresponding to y.

75	73	is the total number of parameters on the tape
76	74	(only used for error checking).
77	75
78		\param nc_taylor
	76	\param cap_order
79	77	number of columns in the matrix containing the Taylor coefficients.
80	78
81	79	\param taylor
82		\b Input: in StvpOp and StvvOp cases, \a taylor[ arg[1] * nc_taylor + 0 ]
83		is used to compute the index in the definition of i_vec above
84
85		\param nc_combined
86		is the total number of elements in the combined VecAD array.
87
88		\param variable
89		\b Output: If y is a varable (StpvOp or StvvOp),
90		\a variable [ \a arg[0] + i_vec ] is set to true.
91		Otherwise y is a paraemter (StppOp or StvpOp) and
92		\a variable [ \a arg[0] + i_vec ] is set to false.
93
94		\param combined
95		\b Output: \a combined [ \a arg[0] + i_vec ]
96		is set equal to \a arg[2].
	80	In StvpOp and StvvOp cases, <code><taylor[ arg[1] * cap_order + 0 ]</code>
	81	is used to compute the index in the definition of i_vec above.
	82
	83	\param isvar_by_ind
	84	If y is a varable (StpvOp and StvvOp cases),
	85	<code>isvar_by_ind[ arg[0] + i_vec ] </code> is set to true.
	86	Otherwise y is a paraemter (StppOp and StvpOp cases) and
	87	<code>isvar_by_ind[ arg[0] + i_vec ] </code> is set to false.
	88
	89	\param index_by_ind
	90	<code>index_by_ind[ arg[0] - 1 ]</code>
	91	is the number of elements in the user vector containing this element.
	92	The value <code>index_by_ind[ arg[0] + i_vec]</code>
	93	is set equal to arg[2].
97	94
98	95	\par Check User Errors
99	96	\li Check that the index is with in range; i.e.
100		i_vec < combined[ \a arg[0] - 1 ]
101		Note that, if x is a parameter, is the corresponding vector index
102		and it does not change.
	97	<code>i_vec < index_by_ind[ arg[0] - 1 ]</code>
	98	Note that, if x is a parameter,
	99	the corresponding vector index and it does not change.
103	100	In this case, the error above should be detected during tape recording.
104	101
105	102	\par Checked Assertions
106		\li combined != CPPAD_NULL
107		\li variable != CPPAD_NULL
108	103	\li NumArg(op) == 3
109	104	\li NumRes(op) == 0
110		\li 0 < \a arg[0]
111		\li \a arg[0] + i_vec < nc_combined
	105	\li 0 < arg[0]
112	106	\li if y is a parameter, arg[2] < num_par
113		\li if x is a variable, arg[1] <= i_z
114		\li if y is a variable, arg[2] <= i_z
115	107	*/
116	108	template <class Base>
117	109	inline void forward_store_op_0(
118	110	size_t i_z ,
119	111	const addr_t* arg ,
120	112	size_t num_par ,
121		size_t nc_taylor ,
	113	size_t cap_order ,
122	114	Base* taylor ,
123		size_t nc_combined ,
124		bool* variable ,
125		size_t* combined )
	115	bool* isvar_by_ind ,
	116	size_t* index_by_ind )
126	117	{
127	118	// This routine is only for documentaiton, it should not be used
128	119	CPPAD_ASSERT_UNKNOWN( false );

223	214	size_t i_z ,
224	215	const addr_t* arg ,
225	216	size_t num_par ,
226		size_t nc_taylor ,
	217	size_t cap_order ,
227	218	Base* taylor ,
228		size_t nc_combined ,
229		bool* variable ,
230		size_t* combined )
	219	bool* isvar_by_ind ,
	220	size_t* index_by_ind )
231	221	{ size_t i_vec = arg[1];
232	222
233	223	// Because the index is a parameter, this indexing error should be
234	224	// caught and reported to the user when the tape is recording.
235		CPPAD_ASSERT_UNKNOWN( i_vec < combined[ arg[0] - 1 ] );
236
237		CPPAD_ASSERT_UNKNOWN( variable != CPPAD_NULL );
238		CPPAD_ASSERT_UNKNOWN( combined != CPPAD_NULL );
	225	CPPAD_ASSERT_UNKNOWN( i_vec < index_by_ind[ arg[0] - 1 ] );
	226
239	227	CPPAD_ASSERT_UNKNOWN( NumArg(StppOp) == 3 );
240	228	CPPAD_ASSERT_UNKNOWN( NumRes(StppOp) == 0 );
241	229	CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
242		CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
243	230	CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
244	231
245		variable[ arg[0] + i_vec ] = false;
246		combined[ arg[0] + i_vec ] = arg[2];
	232	isvar_by_ind[ arg[0] + i_vec ] = false;
	233	index_by_ind[ arg[0] + i_vec ] = arg[2];
247	234	}
248	235
249	236	/*!

256	243	size_t i_z ,
257	244	const addr_t* arg ,
258	245	size_t num_par ,
259		size_t nc_taylor ,
	246	size_t cap_order ,
260	247	Base* taylor ,
261		size_t nc_combined ,
262		bool* variable ,
263		size_t* combined )
	248	bool* isvar_by_ind ,
	249	size_t* index_by_ind )
264	250	{ size_t i_vec = arg[1];
265	251
266	252	// Because the index is a parameter, this indexing error should be
267	253	// caught and reported to the user when the tape is recording.
268		CPPAD_ASSERT_UNKNOWN( i_vec < combined[ arg[0] - 1 ] );
269
270		CPPAD_ASSERT_UNKNOWN( variable != CPPAD_NULL );
271		CPPAD_ASSERT_UNKNOWN( combined != CPPAD_NULL );
	254	CPPAD_ASSERT_UNKNOWN( i_vec < index_by_ind[ arg[0] - 1 ] );
	255
272	256	CPPAD_ASSERT_UNKNOWN( NumArg(StpvOp) == 3 );
273	257	CPPAD_ASSERT_UNKNOWN( NumRes(StpvOp) == 0 );
274	258	CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
275		CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
276		CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= i_z );
277
278		variable[ arg[0] + i_vec ] = true;
279		combined[ arg[0] + i_vec ] = arg[2];
	259
	260	isvar_by_ind[ arg[0] + i_vec ] = true;
	261	index_by_ind[ arg[0] + i_vec ] = arg[2];
280	262	}
281	263
282	264	/*!

289	271	size_t i_z ,
290	272	const addr_t* arg ,
291	273	size_t num_par ,
292		size_t nc_taylor ,
	274	size_t cap_order ,
293	275	Base* taylor ,
294		size_t nc_combined ,
295		bool* variable ,
296		size_t* combined )
	276	bool* isvar_by_ind ,
	277	size_t* index_by_ind )
297	278	{
298		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= i_z );
299		size_t i_vec = Integer( taylor[ arg[1] * nc_taylor + 0 ] );
	279	size_t i_vec = Integer( taylor[ arg[1] * cap_order + 0 ] );
300	280	CPPAD_ASSERT_KNOWN(
301		i_vec < combined[ arg[0] - 1 ] ,
	281	i_vec < index_by_ind[ arg[0] - 1 ] ,
302	282	"VecAD: index during zero order forward sweep is out of range"
303	283	);
304	284
305		CPPAD_ASSERT_UNKNOWN( variable != CPPAD_NULL );
306		CPPAD_ASSERT_UNKNOWN( combined != CPPAD_NULL );
307	285	CPPAD_ASSERT_UNKNOWN( NumArg(StvpOp) == 3 );
308	286	CPPAD_ASSERT_UNKNOWN( NumRes(StvpOp) == 0 );
309	287	CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
310		CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
311	288	CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) < num_par );
312	289
313		variable[ arg[0] + i_vec ] = false;
314		combined[ arg[0] + i_vec ] = arg[2];
	290	isvar_by_ind[ arg[0] + i_vec ] = false;
	291	index_by_ind[ arg[0] + i_vec ] = arg[2];
315	292	}
316	293
317	294	/*!

324	301	size_t i_z ,
325	302	const addr_t* arg ,
326	303	size_t num_par ,
327		size_t nc_taylor ,
	304	size_t cap_order ,
328	305	Base* taylor ,
329		size_t nc_combined ,
330		bool* variable ,
331		size_t* combined )
	306	bool* isvar_by_ind ,
	307	size_t* index_by_ind )
332	308	{
333		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) <= i_z );
334		size_t i_vec = Integer( taylor[ arg[1] * nc_taylor + 0 ] );
	309	size_t i_vec = Integer( taylor[ arg[1] * cap_order + 0 ] );
335	310	CPPAD_ASSERT_KNOWN(
336		i_vec < combined[ arg[0] - 1 ] ,
	311	i_vec < index_by_ind[ arg[0] - 1 ] ,
337	312	"VecAD: index during zero order forward sweep is out of range"
338	313	);
339	314
340		CPPAD_ASSERT_UNKNOWN( variable != CPPAD_NULL );
341		CPPAD_ASSERT_UNKNOWN( combined != CPPAD_NULL );
342	315	CPPAD_ASSERT_UNKNOWN( NumArg(StvpOp) == 3 );
343	316	CPPAD_ASSERT_UNKNOWN( NumRes(StvpOp) == 0 );
344	317	CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
345		CPPAD_ASSERT_UNKNOWN( arg[0] + i_vec < nc_combined );
346		CPPAD_ASSERT_UNKNOWN( size_t(arg[2]) <= i_z );
347
348		variable[ arg[0] + i_vec ] = true;
349		combined[ arg[0] + i_vec ] = arg[2];
	318
	319	isvar_by_ind[ arg[0] + i_vec ] = true;
	320	index_by_ind[ arg[0] + i_vec ] = arg[2];
350	321	}
351	322
352	323	/*!

592	563	return;
593	564	}
594	565
595		/! \} /
596	566	} // END_CPPAD_NAMESPACE
597	567	# endif

+217

-114

cppad/local/sub_op.hpp less more

0		/* $Id: sub_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: sub_op.hpp 3321 2014-09-12 09:50:39Z bradbell $ */
1	1	# ifndef CPPAD_SUB_OP_INCLUDED
2	2	# define CPPAD_SUB_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

14	14
15	15	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
16	16	/*!
17		\defgroup sub_op_hpp sub_op.hpp
18		\{
19	17	\file sub_op.hpp
20	18	Forward and reverse mode calculations for z = x - y.
21	19	*/

37	35
38	36	template <class Base>
39	37	inline void forward_subvv_op(
	38	size_t p ,
40	39	size_t q ,
41		size_t p ,
42		size_t i_z ,
43		const addr_t* arg ,
44		const Base* parameter ,
45		size_t nc_taylor ,
	40	size_t i_z ,
	41	const addr_t* arg ,
	42	const Base* parameter ,
	43	size_t cap_order ,
46	44	Base* taylor )
47	45	{
48	46	// check assumptions
49	47	CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
50	48	CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
51		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
52		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
53		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
54		CPPAD_ASSERT_UNKNOWN( q <= p );
55
56		// Taylor coefficients corresponding to arguments and result
57		Base* x = taylor + arg[0] * nc_taylor;
58		Base* y = taylor + arg[1] * nc_taylor;
59		Base* z = taylor + i_z * nc_taylor;
60
61		for(size_t d = q; d <= p; d++)
	49	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	50	CPPAD_ASSERT_UNKNOWN( p <= q );
	51
	52	// Taylor coefficients corresponding to arguments and result
	53	Base* x = taylor + arg[0] * cap_order;
	54	Base* y = taylor + arg[1] * cap_order;
	55	Base* z = taylor + i_z * cap_order;
	56
	57	for(size_t d = p; d <= q; d++)
62	58	z[d] = x[d] - y[d];
63	59	}
64
65		/*!
66		Compute zero order forward mode Taylor coefficients for result of op = SubvvOp.
	60	/*!
	61	Multiple directions forward mode Taylor coefficients for op = SubvvOp.
67	62
68	63	The C++ source code corresponding to this operation is
69	64	\verbatim

73	68	this operations is for the case where both x and y are variables
74	69	and the argument \a parameter is not used.
75	70
76		\copydetails forward_binary_op_0
77		*/
78
79		template <class Base>
80		inline void forward_subvv_op_0(
81		size_t i_z ,
82		const addr_t* arg ,
83		const Base* parameter ,
84		size_t nc_taylor ,
	71	\copydetails forward_binary_op_dir
	72	*/
	73
	74	template <class Base>
	75	inline void forward_subvv_op_dir(
	76	size_t q ,
	77	size_t r ,
	78	size_t i_z ,
	79	const addr_t* arg ,
	80	const Base* parameter ,
	81	size_t cap_order ,
85	82	Base* taylor )
86	83	{
87	84	// check assumptions
88	85	CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
89	86	CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
90		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
91		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
92
93		// Taylor coefficients corresponding to arguments and result
94		Base* x = taylor + arg[0] * nc_taylor;
95		Base* y = taylor + arg[1] * nc_taylor;
96		Base* z = taylor + i_z * nc_taylor;
97
98		z[0] = x[0] - y[0];
99		}
100
101		/*!
102		Compute reverse mode partial derivatives for result of op = SubvvOp.
	87	CPPAD_ASSERT_UNKNOWN( 0 < q );
	88	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	89
	90	// Taylor coefficients corresponding to arguments and result
	91	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	92	size_t m = (q-1) * r + 1;
	93	Base* x = taylor + arg[0] * num_taylor_per_var + m;
	94	Base* y = taylor + arg[1] * num_taylor_per_var + m;
	95	Base* z = taylor + i_z * num_taylor_per_var + m;
	96
	97	for(size_t ell = 0; ell < r; ell++)
	98	z[ell] = x[ell] - y[ell];
	99	}
	100
	101	/*!
	102	Compute zero order forward mode Taylor coefficients for result of op = SubvvOp.
103	103
104	104	The C++ source code corresponding to this operation is
105	105	\verbatim

109	109	this operations is for the case where both x and y are variables
110	110	and the argument \a parameter is not used.
111	111
	112	\copydetails forward_binary_op_0
	113	*/
	114
	115	template <class Base>
	116	inline void forward_subvv_op_0(
	117	size_t i_z ,
	118	const addr_t* arg ,
	119	const Base* parameter ,
	120	size_t cap_order ,
	121	Base* taylor )
	122	{
	123	// check assumptions
	124	CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
	125	CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
	126
	127	// Taylor coefficients corresponding to arguments and result
	128	Base* x = taylor + arg[0] * cap_order;
	129	Base* y = taylor + arg[1] * cap_order;
	130	Base* z = taylor + i_z * cap_order;
	131
	132	z[0] = x[0] - y[0];
	133	}
	134
	135	/*!
	136	Compute reverse mode partial derivatives for result of op = SubvvOp.
	137
	138	The C++ source code corresponding to this operation is
	139	\verbatim
	140	z = x - y
	141	\endverbatim
	142	In the documentation below,
	143	this operations is for the case where both x and y are variables
	144	and the argument \a parameter is not used.
	145
112	146	\copydetails reverse_binary_op
113	147	*/
114	148

118	152	size_t i_z ,
119	153	const addr_t* arg ,
120	154	const Base* parameter ,
121		size_t nc_taylor ,
	155	size_t cap_order ,
122	156	const Base* taylor ,
123	157	size_t nc_partial ,
124	158	Base* partial )

126	160	// check assumptions
127	161	CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
128	162	CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
129		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
130		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
131		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	163	CPPAD_ASSERT_UNKNOWN( d < cap_order );
132	164	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
133	165
134	166	// Partial derivatives corresponding to arguments and result

161	193
162	194	template <class Base>
163	195	inline void forward_subpv_op(
	196	size_t p ,
164	197	size_t q ,
165		size_t p ,
166		size_t i_z ,
167		const addr_t* arg ,
168		const Base* parameter ,
169		size_t nc_taylor ,
	198	size_t i_z ,
	199	const addr_t* arg ,
	200	const Base* parameter ,
	201	size_t cap_order ,
170	202	Base* taylor )
171	203	{
172	204	// check assumptions
173	205	CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
174	206	CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
175		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
176		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
177		CPPAD_ASSERT_UNKNOWN( q <= p );
178
179		// Taylor coefficients corresponding to arguments and result
180		Base* y = taylor + arg[1] * nc_taylor;
181		Base* z = taylor + i_z * nc_taylor;
	207	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	208	CPPAD_ASSERT_UNKNOWN( p <= q );
	209
	210	// Taylor coefficients corresponding to arguments and result
	211	Base* y = taylor + arg[1] * cap_order;
	212	Base* z = taylor + i_z * cap_order;
182	213
183	214	// Paraemter value
184	215	Base x = parameter[ arg[0] ];
185		if( q == 0 )
	216	if( p == 0 )
186	217	{ z[0] = x - y[0];
187		q++;
	218	p++;
188	219	}
189		for(size_t d = q; d <= p; d++)
	220	for(size_t d = p; d <= q; d++)
190	221	z[d] = - y[d];
191	222	}
192	223	/*!
193		Compute zero order forward mode Taylor coefficient for result of op = SubpvOp.
	224	Multiple directions forward mode Taylor coefficients for op = SubpvOp.
194	225
195	226	The C++ source code corresponding to this operation is
196	227	\verbatim

199	230	In the documentation below,
200	231	this operations is for the case where x is a parameter and y is a variable.
201	232
202		\copydetails forward_binary_op_0
203		*/
204
205		template <class Base>
206		inline void forward_subpv_op_0(
207		size_t i_z ,
208		const addr_t* arg ,
209		const Base* parameter ,
210		size_t nc_taylor ,
	233	\copydetails forward_binary_op_dir
	234	*/
	235
	236	template <class Base>
	237	inline void forward_subpv_op_dir(
	238	size_t q ,
	239	size_t r ,
	240	size_t i_z ,
	241	const addr_t* arg ,
	242	const Base* parameter ,
	243	size_t cap_order ,
211	244	Base* taylor )
212	245	{
213	246	// check assumptions
214	247	CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
215	248	CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
216		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
	249	CPPAD_ASSERT_UNKNOWN( 0 < q );
	250	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	251
	252	// Taylor coefficients corresponding to arguments and result
	253	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	254	size_t m = (q-1) * r + 1;
	255	Base* y = taylor + arg[1] * num_taylor_per_var + m;
	256	Base* z = taylor + i_z * num_taylor_per_var + m;
	257
	258	// Paraemter value
	259	for(size_t ell = 0; ell < r; ell++)
	260	z[ell] = - y[ell];
	261	}
	262	/*!
	263	Compute zero order forward mode Taylor coefficient for result of op = SubpvOp.
	264
	265	The C++ source code corresponding to this operation is
	266	\verbatim
	267	z = x - y
	268	\endverbatim
	269	In the documentation below,
	270	this operations is for the case where x is a parameter and y is a variable.
	271
	272	\copydetails forward_binary_op_0
	273	*/
	274
	275	template <class Base>
	276	inline void forward_subpv_op_0(
	277	size_t i_z ,
	278	const addr_t* arg ,
	279	const Base* parameter ,
	280	size_t cap_order ,
	281	Base* taylor )
	282	{
	283	// check assumptions
	284	CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
	285	CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
217	286
218	287	// Paraemter value
219	288	Base x = parameter[ arg[0] ];
220	289
221	290	// Taylor coefficients corresponding to arguments and result
222		Base* y = taylor + arg[1] * nc_taylor;
223		Base* z = taylor + i_z * nc_taylor;
	291	Base* y = taylor + arg[1] * cap_order;
	292	Base* z = taylor + i_z * cap_order;
224	293
225	294	z[0] = x - y[0];
226	295	}

244	313	size_t i_z ,
245	314	const addr_t* arg ,
246	315	const Base* parameter ,
247		size_t nc_taylor ,
	316	size_t cap_order ,
248	317	const Base* taylor ,
249	318	size_t nc_partial ,
250	319	Base* partial )

252	321	// check assumptions
253	322	CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
254	323	CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
255		CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
256		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	324	CPPAD_ASSERT_UNKNOWN( d < cap_order );
257	325	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
258	326
259	327	// Partial derivatives corresponding to arguments and result

284	352
285	353	template <class Base>
286	354	inline void forward_subvp_op(
	355	size_t p ,
287	356	size_t q ,
288		size_t p ,
289		size_t i_z ,
290		const addr_t* arg ,
291		const Base* parameter ,
292		size_t nc_taylor ,
	357	size_t i_z ,
	358	const addr_t* arg ,
	359	const Base* parameter ,
	360	size_t cap_order ,
293	361	Base* taylor )
294	362	{
295	363	// check assumptions
296	364	CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
297	365	CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
298		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
299		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
300		CPPAD_ASSERT_UNKNOWN( q <= p );
301
302		// Taylor coefficients corresponding to arguments and result
303		Base* x = taylor + arg[0] * nc_taylor;
304		Base* z = taylor + i_z * nc_taylor;
	366	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	367	CPPAD_ASSERT_UNKNOWN( p <= q );
	368
	369	// Taylor coefficients corresponding to arguments and result
	370	Base* x = taylor + arg[0] * cap_order;
	371	Base* z = taylor + i_z * cap_order;
305	372
306	373	// Parameter value
307	374	Base y = parameter[ arg[1] ];
308		if( q == 0 )
	375	if( p == 0 )
309	376	{ z[0] = x[0] - y;
310		q++;
	377	p++;
311	378	}
312		for(size_t d = q; d <= p; d++)
	379	for(size_t d = p; d <= q; d++)
313	380	z[d] = x[d];
314	381	}
315
316		/*!
317		Compute zero order forward mode Taylor coefficients for result of op = SubvvOp.
	382	/*!
	383	Multiple directions forward mode Taylor coefficients for op = SubvvOp.
318	384
319	385	The C++ source code corresponding to this operation is
320	386	\verbatim

323	389	In the documentation below,
324	390	this operations is for the case where x is a variable and y is a parameter.
325	391
326		\copydetails forward_binary_op_0
327		*/
328
329		template <class Base>
330		inline void forward_subvp_op_0(
331		size_t i_z ,
332		const addr_t* arg ,
333		const Base* parameter ,
334		size_t nc_taylor ,
	392	\copydetails forward_binary_op_dir
	393	*/
	394
	395	template <class Base>
	396	inline void forward_subvp_op_dir(
	397	size_t q ,
	398	size_t r ,
	399	size_t i_z ,
	400	const addr_t* arg ,
	401	const Base* parameter ,
	402	size_t cap_order ,
335	403	Base* taylor )
336	404	{
337	405	// check assumptions
338	406	CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
339	407	CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
340		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
	408	CPPAD_ASSERT_UNKNOWN( 0 < q );
	409	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	410
	411	// Taylor coefficients corresponding to arguments and result
	412	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	413	Base* x = taylor + arg[0] * num_taylor_per_var;
	414	Base* z = taylor + i_z * num_taylor_per_var;
	415
	416	// Parameter value
	417	size_t m = (q-1) * r + 1;
	418	for(size_t ell = 0; ell < r; ell++)
	419	z[m+ell] = x[m+ell];
	420	}
	421
	422	/*!
	423	Compute zero order forward mode Taylor coefficients for result of op = SubvvOp.
	424
	425	The C++ source code corresponding to this operation is
	426	\verbatim
	427	z = x - y
	428	\endverbatim
	429	In the documentation below,
	430	this operations is for the case where x is a variable and y is a parameter.
	431
	432	\copydetails forward_binary_op_0
	433	*/
	434
	435	template <class Base>
	436	inline void forward_subvp_op_0(
	437	size_t i_z ,
	438	const addr_t* arg ,
	439	const Base* parameter ,
	440	size_t cap_order ,
	441	Base* taylor )
	442	{
	443	// check assumptions
	444	CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
	445	CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
341	446
342	447	// Parameter value
343	448	Base y = parameter[ arg[1] ];
344	449
345	450	// Taylor coefficients corresponding to arguments and result
346		Base* x = taylor + arg[0] * nc_taylor;
347		Base* z = taylor + i_z * nc_taylor;
	451	Base* x = taylor + arg[0] * cap_order;
	452	Base* z = taylor + i_z * cap_order;
348	453
349	454	z[0] = x[0] - y;
350	455	}

368	473	size_t i_z ,
369	474	const addr_t* arg ,
370	475	const Base* parameter ,
371		size_t nc_taylor ,
	476	size_t cap_order ,
372	477	const Base* taylor ,
373	478	size_t nc_partial ,
374	479	Base* partial )

376	481	// check assumptions
377	482	CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
378	483	CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
379		CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
380		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	484	CPPAD_ASSERT_UNKNOWN( d < cap_order );
381	485	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
382	486
383	487	// Partial derivatives corresponding to arguments and result

392	496	}
393	497	}
394	498
395		/! \} /
396	499	} // END_CPPAD_NAMESPACE
397	500	# endif

+74

-29

cppad/local/tan_op.hpp less more

0		/* $Id: tan_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: tan_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_TAN_OP_INCLUDED
2	2	# define CPPAD_TAN_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup tan_op_hpp tan_op.hpp
19		\{
20	18	\file tan_op.hpp
21	19	Forward and reverse mode calculations for z = tan(x).
22	20	*/

40	38	*/
41	39	template <class Base>
42	40	inline void forward_tan_op(
	41	size_t p ,
43	42	size_t q ,
44		size_t p ,
45	43	size_t i_z ,
46	44	size_t i_x ,
47		size_t nc_taylor ,
	45	size_t cap_order ,
48	46	Base* taylor )
49	47	{
50	48	// check assumptions
51	49	CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
52	50	CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
53		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
54		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
55		CPPAD_ASSERT_UNKNOWN( q <= p );
	51	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	52	CPPAD_ASSERT_UNKNOWN( p <= q );
56	53
57	54	// Taylor coefficients corresponding to argument and result
58		Base* x = taylor + i_x * nc_taylor;
59		Base* z = taylor + i_z * nc_taylor;
60		Base* y = z - nc_taylor;
	55	Base* x = taylor + i_x * cap_order;
	56	Base* z = taylor + i_z * cap_order;
	57	Base* y = z - cap_order;
61	58
62	59	size_t k;
63		if( q == 0 )
	60	if( p == 0 )
64	61	{ z[0] = tan( x[0] );
65	62	y[0] = z[0] * z[0];
66		q++;
67		}
68		for(size_t j = q; j <= p; j++)
	63	p++;
	64	}
	65	for(size_t j = p; j <= q; j++)
69	66	{ Base base_j = static_cast<Base>(j);
70	67
71	68	z[j] = x[j];

78	75	}
79	76	}
80	77
	78	/*!
	79	Multiple directions forward mode Taylor coefficient for op = TanOp.
	80
	81	The C++ source code corresponding to this operation is
	82	\verbatim
	83	z = tan(x)
	84	\endverbatim
	85	The auxillary result is
	86	\verbatim
	87	y = tan(x)^2
	88	\endverbatim
	89	The value of y, and its derivatives, are computed along with the value
	90	and derivatives of z.
	91
	92	\copydetails forward_unary2_op_dir
	93	*/
	94	template <class Base>
	95	inline void forward_tan_op_dir(
	96	size_t q ,
	97	size_t r ,
	98	size_t i_z ,
	99	size_t i_x ,
	100	size_t cap_order ,
	101	Base* taylor )
	102	{
	103	// check assumptions
	104	CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
	105	CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
	106	CPPAD_ASSERT_UNKNOWN( 0 < q );
	107	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	108
	109	// Taylor coefficients corresponding to argument and result
	110	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	111	Base* x = taylor + i_x * num_taylor_per_var;
	112	Base* z = taylor + i_z * num_taylor_per_var;
	113	Base* y = z - num_taylor_per_var;
	114
	115	size_t k;
	116	size_t m = (q-1) * r + 1;
	117	for(size_t ell = 0; ell < r; ell++)
	118	{ z[m+ell] = Base(q) * ( x[m+ell] + x[m+ell] * y[0]);
	119	for(k = 1; k < q; k++)
	120	z[m+ell] += Base(k) * x[(k-1)r+1+ell] y[(q-k-1)*r+1+ell];
	121	z[m+ell] /= Base(q);
	122	//
	123	y[m+ell] = Base(2) * z[m+ell] * z[0];
	124	for(k = 1; k < q; k++)
	125	y[m+ell] += z[(k-1)r+1+ell] z[(q-k-1)*r+1+ell];
	126	}
	127	}
	128
81	129
82	130	/*!
83	131	Compute zero order forward mode Taylor coefficient for result of op = TanOp.

98	146	inline void forward_tan_op_0(
99	147	size_t i_z ,
100	148	size_t i_x ,
101		size_t nc_taylor ,
	149	size_t cap_order ,
102	150	Base* taylor )
103	151	{
104	152	// check assumptions
105	153	CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
106	154	CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
107		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
108		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	155	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
109	156
110	157	// Taylor coefficients corresponding to argument and result
111		Base* x = taylor + i_x * nc_taylor;
112		Base* z = taylor + i_z * nc_taylor; // called z in documentation
113		Base* y = z - nc_taylor; // called y in documentation
	158	Base* x = taylor + i_x * cap_order;
	159	Base* z = taylor + i_z * cap_order; // called z in documentation
	160	Base* y = z - cap_order; // called y in documentation
114	161
115	162	z[0] = tan( x[0] );
116	163	y[0] = z[0] * z[0];

137	184	size_t d ,
138	185	size_t i_z ,
139	186	size_t i_x ,
140		size_t nc_taylor ,
	187	size_t cap_order ,
141	188	const Base* taylor ,
142	189	size_t nc_partial ,
143	190	Base* partial )

145	192	// check assumptions
146	193	CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
147	194	CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
148		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
149		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	195	CPPAD_ASSERT_UNKNOWN( d < cap_order );
150	196	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
151	197
152	198	// Taylor coefficients and partials corresponding to argument
153		const Base* x = taylor + i_x * nc_taylor;
	199	const Base* x = taylor + i_x * cap_order;
154	200	Base* px = partial + i_x * nc_partial;
155	201
156	202	// Taylor coefficients and partials corresponding to first result
157		const Base* z = taylor + i_z * nc_taylor; // called z in doc
	203	const Base* z = taylor + i_z * cap_order; // called z in doc
158	204	Base* pz = partial + i_z * nc_partial;
159	205
160	206	// Taylor coefficients and partials corresponding to auxillary result
161		const Base* y = z - nc_taylor; // called y in documentation
	207	const Base* y = z - cap_order; // called y in documentation
162	208	Base* py = pz - nc_partial;
163	209
164	210	size_t j = d;

180	226	px[0] += pz[0] * (Base(1) + y[0]);
181	227	}
182	228
183		/! \} /
184	229	} // END_CPPAD_NAMESPACE
185	230	# endif

+73

-29

cppad/local/tanh_op.hpp less more

0		/* $Id: tanh_op.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: tanh_op.hpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	# ifndef CPPAD_TANH_OP_INCLUDED
2	2	# define CPPAD_TANH_OP_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15
16	16	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17	17	/*!
18		\defgroup tanh_op_hpp tanh_op.hpp
19		\{
20	18	\file tanh_op.hpp
21	19	Forward and reverse mode calculations for z = tanh(x).
22	20	*/

40	38	*/
41	39	template <class Base>
42	40	inline void forward_tanh_op(
	41	size_t p ,
43	42	size_t q ,
44		size_t p ,
45	43	size_t i_z ,
46	44	size_t i_x ,
47		size_t nc_taylor ,
	45	size_t cap_order ,
48	46	Base* taylor )
49	47	{
50	48	// check assumptions
51	49	CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
52	50	CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
53		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
54		CPPAD_ASSERT_UNKNOWN( p < nc_taylor );
55		CPPAD_ASSERT_UNKNOWN( q <= p );
	51	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	52	CPPAD_ASSERT_UNKNOWN( p <= q );
56	53
57	54	// Taylor coefficients corresponding to argument and result
58		Base* x = taylor + i_x * nc_taylor;
59		Base* z = taylor + i_z * nc_taylor;
60		Base* y = z - nc_taylor;
	55	Base* x = taylor + i_x * cap_order;
	56	Base* z = taylor + i_z * cap_order;
	57	Base* y = z - cap_order;
61	58
62	59	size_t k;
63		if( q == 0 )
	60	if( p == 0 )
64	61	{ z[0] = tanh( x[0] );
65	62	y[0] = z[0] * z[0];
66		q++;
67		}
68		for(size_t j = q; j <= p; j++)
	63	p++;
	64	}
	65	for(size_t j = p; j <= q; j++)
69	66	{ Base base_j = static_cast<Base>(j);
70	67
71	68	z[j] = x[j];

78	75	}
79	76	}
80	77
	78	/*!
	79	Multiple directions forward mode Taylor coefficient for op = TanOp.
	80
	81	The C++ source code corresponding to this operation is
	82	\verbatim
	83	z = tanh(x)
	84	\endverbatim
	85	The auxillary result is
	86	\verbatim
	87	y = tanh(x)^2
	88	\endverbatim
	89	The value of y, and its derivatives, are computed along with the value
	90	and derivatives of z.
	91
	92	\copydetails forward_unary2_op_dir
	93	*/
	94	template <class Base>
	95	inline void forward_tanh_op_dir(
	96	size_t q ,
	97	size_t r ,
	98	size_t i_z ,
	99	size_t i_x ,
	100	size_t cap_order ,
	101	Base* taylor )
	102	{
	103	// check assumptions
	104	CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
	105	CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
	106	CPPAD_ASSERT_UNKNOWN( 0 < q );
	107	CPPAD_ASSERT_UNKNOWN( q < cap_order );
	108
	109	// Taylor coefficients corresponding to argument and result
	110	size_t num_taylor_per_var = (cap_order-1) * r + 1;
	111	Base* x = taylor + i_x * num_taylor_per_var;
	112	Base* z = taylor + i_z * num_taylor_per_var;
	113	Base* y = z - num_taylor_per_var;
	114
	115	size_t k;
	116	size_t m = (q-1) * r + 1;
	117	for(size_t ell = 0; ell < r; ell++)
	118	{ z[m+ell] = Base(q) * ( x[m+ell] - x[m+ell] * y[0] );
	119	for(k = 1; k < q; k++)
	120	z[m+ell] -= Base(k) * x[(k-1)r+1+ell] y[(q-k-1)*r+1+ell];
	121	z[m+ell] /= Base(q);
	122	//
	123	y[m+ell] = Base(2) * z[m+ell] * z[0];
	124	for(k = 1; k < q; k++)
	125	y[m+ell] += z[(k-1)r+1+ell] z[(q-k-1)*r+1+ell];
	126	}
	127	}
81	128
82	129	/*!
83	130	Compute zero order forward mode Taylor coefficient for result of op = TanOp.

98	145	inline void forward_tanh_op_0(
99	146	size_t i_z ,
100	147	size_t i_x ,
101		size_t nc_taylor ,
	148	size_t cap_order ,
102	149	Base* taylor )
103	150	{
104	151	// check assumptions
105	152	CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
106	153	CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
107		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
108		CPPAD_ASSERT_UNKNOWN( 0 < nc_taylor );
	154	CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
109	155
110	156	// Taylor coefficients corresponding to argument and result
111		Base* x = taylor + i_x * nc_taylor;
112		Base* z = taylor + i_z * nc_taylor; // called z in documentation
113		Base* y = z - nc_taylor; // called y in documentation
	157	Base* x = taylor + i_x * cap_order;
	158	Base* z = taylor + i_z * cap_order; // called z in documentation
	159	Base* y = z - cap_order; // called y in documentation
114	160
115	161	z[0] = tanh( x[0] );
116	162	y[0] = z[0] * z[0];

137	183	size_t d ,
138	184	size_t i_z ,
139	185	size_t i_x ,
140		size_t nc_taylor ,
	186	size_t cap_order ,
141	187	const Base* taylor ,
142	188	size_t nc_partial ,
143	189	Base* partial )

145	191	// check assumptions
146	192	CPPAD_ASSERT_UNKNOWN( NumArg(TanOp) == 1 );
147	193	CPPAD_ASSERT_UNKNOWN( NumRes(TanOp) == 2 );
148		CPPAD_ASSERT_UNKNOWN( i_x + 1 < i_z );
149		CPPAD_ASSERT_UNKNOWN( d < nc_taylor );
	194	CPPAD_ASSERT_UNKNOWN( d < cap_order );
150	195	CPPAD_ASSERT_UNKNOWN( d < nc_partial );
151	196
152	197	// Taylor coefficients and partials corresponding to argument
153		const Base* x = taylor + i_x * nc_taylor;
	198	const Base* x = taylor + i_x * cap_order;
154	199	Base* px = partial + i_x * nc_partial;
155	200
156	201	// Taylor coefficients and partials corresponding to first result
157		const Base* z = taylor + i_z * nc_taylor; // called z in doc
	202	const Base* z = taylor + i_z * cap_order; // called z in doc
158	203	Base* pz = partial + i_z * nc_partial;
159	204
160	205	// Taylor coefficients and partials corresponding to auxillary result
161		const Base* y = z - nc_taylor; // called y in documentation
	206	const Base* y = z - cap_order; // called y in documentation
162	207	Base* py = pz - nc_partial;
163	208
164	209	size_t j = d;

180	225	px[0] += pz[0] * (Base(1) - y[0]);
181	226	}
182	227
183		/! \} /
184	228	} // END_CPPAD_NAMESPACE
185	229	# endif

-6

cppad/local/tape_link.hpp less more

0		/* $Id: tape_link.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: tape_link.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_TAPE_LINK_INCLUDED
2	2	# define CPPAD_TAPE_LINK_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

21	21
22	22	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
23	23	/*!
24		\defgroup tape_link_hpp tape_link.hpp
25		\{
26	24	\file tape_link.hpp
27		Routines that Link AD<Base> and ADTape<Base> Objects \ref tape_link_hpp.
	25	Routines that Link AD<Base> and ADTape<Base> Objects.
28	26
29	27	The routines that connect the AD<Base> class to the corresponding tapes
30	28	(one for each thread).

309	307	return *tape_handle(thread);
310	308	}
311	309
312		/! \} /
313	310	} // END_CPPAD_NAMESPACE
314	311	# endif

-4

cppad/local/undef.hpp less more

0		/* $Id: undef.hpp 3067 2013-12-29 17:35:34Z bradbell $ */
	0	// $Id: undef.hpp 3495 2014-12-24 01:16:15Z bradbell $
1	1	# ifndef CPPAD_UNDEF_INCLUDED
2	2	# define CPPAD_UNDEF_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

26	26	# undef CPPAD_BOOL_UNARY in user api
27	27	# undef CPPAD_DISCRETE_FUNCTION in user api
28	28	# undef CPPAD_EIGENVECTOR in user api
	29	# undef CPPAD_COMPILER_HAS_ERF in user api
29	30	# undef CPPAD_INTERNAL_SPARSE_SET in user api
30	31	# undef CPPAD_MAX_NUM_THREADS in user api
31	32	# undef CPPAD_NULL in user api

57	58	// Preprecessor definitions that do not presist
58	59	# undef CPPAD_ASSERT_NARG_NRES
59	60	# undef CPPAD_ASSERT_NOT_PARALLEL
	61	# undef CPPAD_ASSERT_ARG_BEFORE_RESULT
60	62	# undef CPPAD_BOOSTVECTOR
61	63	# undef CPPAD_COND_EXP
62	64	# undef CPPAD_COND_EXP_BASE_REL

66	68	# undef CPPAD_FOLD_ASSIGNMENT_OPERATOR
67	69	# undef CPPAD_FOLD_BOOL_VALUED_BINARY_OPERATOR
68	70	# undef CPPAD_FOR_JAC_SWEEP_TRACE
	71	# undef CPPAD_HAS_COLPACK
	72	# undef CPPAD_HAS_CSTDINT_8_TO_64
	73	# undef CPPAD_HAS_RVALUE
69	74	# undef CPPAD_HAS_GETTIMEOFDAY
70	75	# undef CPPAD_HAS_NULLPTR
71	76	# undef CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION

75	80	# undef CPPAD_REVERSE_SWEEP_TRACE
76	81	# undef CPPAD_REV_HES_SWEEP_TRACE
77	82	# undef CPPAD_REV_JAC_SWEEP_TRACE
78		# undef CPPAD_SIZE_T_SAME_UNSIGNED_INT
	83	# undef CPPAD_SIZE_T_NOT_UNSIGNED_INT
79	84	# undef CPPAD_STANDARD_MATH_UNARY
80	85	# undef CPPAD_STANDARD_MATH_UNARY_AD
81	86	# undef CPPAD_STDVECTOR
82	87	# undef CPPAD_TRACE_CAPACITY
83	88	# undef CPPAD_TRACE_THREAD
84	89	# undef CPPAD_TRACK_DEBUG
85		# undef CPPAD_USE_FORWARD0SWEEP
86	90	# undef CPPAD_USER_MACRO
87	91	# undef CPPAD_USER_MACRO_ONE
88	92	# undef CPPAD_USER_MACRO_TWO

+152

-97

cppad/local/vec_ad.hpp less more

0		/* $Id: vec_ad.hpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: vec_ad.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_VEC_AD_INCLUDED
2	2	# define CPPAD_VEC_AD_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

51	51	$$
52	52	$icode%r% = %v%[%x%]%$$
53	53
54
55	54	$head Purpose$$
56	55	If either $icode v$$ or $icode x$$ is a
57	56	$cref/variable/glossary/Variable/$$,
58	57	the indexing operation
59	58	$codei%
60		%y% = %v%[%x%]
	59	%r% = %v%[%x%]
61	60	%$$
62	61	is recorded in the corresponding
63	62	AD of $icode Base$$

87	86	$head VecAD<Base>::reference$$
88	87	$index VecAD<Base>::reference$$
89	88	$index reference, VecAD<Base>$$
90		The result $icode y$$ has type
	89	The result $icode r$$ has type
91	90	$codei%
92	91	VecAD<%Base%>::reference
93	92	%$$

96	95
97	96	$subhead Exceptions$$
98	97	$list number$$
99		The object $icode y$$ cannot be used with the
	98	The object $icode r$$ cannot be used with the
100	99	$cref Value$$ function to compute the corresponding $icode Base$$ value.
101		If $icode v$$ is not a $cref/variable/glossary/Variable/$$
102		$codei%
103		v[%i%]
	100	If $icode v$$ and $icode i$$ are not $cref/variables/glossary/Variable/$$
	101	$codei%
	102	%b% = v[%i%]
104	103	%$$
105	104	can be used to compute the corresponding $icode Base$$ value.
106	105
107	106	$lnext
108		The object $icode y$$ cannot be used
	107	The object $icode r$$ cannot be used
109	108	with the $cref/computed assignments operators/Arithmetic/$$
110	109	$code +=$$,
111	110	$code -=$$,

118	117	no matter what the types of $icode z$$.
119	118
120	119	$lnext
121		Assignment to $icode y$$ returns a $code void$$.
	120	Assignment to $icode r$$ returns a $code void$$.
122	121	For example, the following syntax is not valid:
123	122	$codei%
124	123	%z% = %v%[%x%] = %u%;

130	129	$codei%VecAD<%Base%>::reference%$$ arguments.
131	130	For example, the following syntax is not valid:
132	131	$codei%
133		CondExpGt(%y%, %z%, %u%, %v%)
	132	CondExpGt(%v%[%x%], %z%, %u%, %v%)
134	133	%$$
135	134	no matter what the types of $icode z$$, $icode u$$, and $icode v$$.
136	135
137	136	$lnext
138	137	The $cref/Parameter and Variable/ParVar/$$ functions cannot be used with
139		$codei%VecAD<%Base%>::reference%$$ arguments
140		(use the entire $codei%VecAD<%Base%>%$$ vector instead).
	138	$codei%VecAD<%Base%>::reference%$$ arguments like $icode r$$,
	139	use the entire $codei%VecAD<%Base%>%$$ vector instead; i.e. $icode v$$.
141	140
142	141	$lnext
143	142	The vectors passed to $cref Independent$$ must have elements

232	231	the number of elements in $icode v$$.
233	232
234	233	$subhead r$$
235		The result $icode y$$ has prototype
	234	The result $icode r$$ has prototype
236	235	$codei%
237	236	VecAD<%Base%>::reference %r%
238	237	%$$

276	275	The effect of this can be seen by executing the following steps:
277	276
278	277	$list number$$
279		In the file $code cppad/local/forward_sweep.h$$,
280		change the definition of $code CPPAD_FORWARD_SWEEP_TRACE$$ to
	278	In the file $code cppad/local/forward1sweep.h$$,
	279	change the definition of $code CPPAD_FORWARD1SWEEP_TRACE$$ to
281	280	$codep
282		# define CPPAD_FORWARD_SWEEP_TRACE 1
	281	# define CPPAD_FORWARD1SWEEP_TRACE 1
283	282	$$
284	283	$lnext
285	284	In the $code Example$$ directory, execute the command

308	307	*/
309	308	# include <cppad/local/pod_vector.hpp>
310	309
311		// Use this define to get around a bug in doxygen 1.7.5.
312		// To be explicit, the documentiion for the routines in tape_link.hpp
313		// you use this typedef in place of the macro below.
314		# define CPPAD_VEC_AD_TYPEDEF_ADBASE typedef AD<Base> AD_Base
315
	310	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
	311	/*!
	312	\file vec_ad.hpp
	313	Defines the VecAD<Base> class.
	314	*/
	315
	316	/*!
	317	\def CPPAD_VEC_AD_COMPUTED_ASSIGNMENT(op, name)
	318	Prints an error message if the correspinding computed assignment is used.
	319
	320	THis macro is used to print an error message if any of the
	321	computed assignments are used with the VecAD_reference class.
	322	The argument \c op is one of the following:
	323	+= , -= , *= , /=.
	324	The argument \c name, is a string literal with the name of the
	325	computed assignment \c op.
	326	*/
316	327	# define CPPAD_VEC_AD_COMPUTED_ASSIGNMENT(op, name) \
317	328	VecAD_reference& operator op (const VecAD_reference<Base> &right) \
318	329	{ CPPAD_ASSERT_KNOWN( \
319		0, \
	330	false, \
320	331	"Cannot use a ADVec element on left side of" name \
321	332	); \
322	333	return *this; \
323	334	} \
324	335	VecAD_reference& operator op (const AD<Base> &right) \
325	336	{ CPPAD_ASSERT_KNOWN( \
326		0, \
	337	false, \
327	338	"Cannot use a ADVec element on left side of" name \
328	339	); \
329	340	return *this; \
330	341	} \
331	342	VecAD_reference& operator op (const Base &right) \
332	343	{ CPPAD_ASSERT_KNOWN( \
333		0, \
	344	false, \
334	345	"Cannot use a ADVec element on left side of" name \
335	346	); \
336	347	return *this; \
337	348	}
338	349
339
340		// BEGIN CppAD namespace
341		namespace CppAD {
342
343		// Element of VecAD
	350	/*!
	351	Class used to hold a reference to an element of a VecAD object.
	352
	353	\tparam Base
	354	Elements of this class act like an AD<Base> (in a restricted sense),
	355	in addition they track (on the tape) the index they correspond to.
	356	*/
344	357	template <class Base>
345	358	class VecAD_reference {
346	359	friend bool Parameter<Base> (const VecAD<Base> &vec);

349	362	friend class ADTape<Base>;
350	363
351	364	private:
352		CPPAD_VEC_AD_TYPEDEF_ADBASE; // define ADBase as AD<Base>
353		VecAD<Base> *vec_; // pointer to entire vector
354		mutable AD_Base x_; // index for this element
	365	/// pointer to vecad vector that this is a element of
	366	VecAD<Base> *vec_;
	367	/// index in vecad vector that this element corresponds to
	368	AD<Base> ind_; // index for this element
355	369	public:
356		VecAD_reference(VecAD<Base> *v, const AD<Base> &x)
357		: vec_( v ) , x_(x)
	370	/*!
	371	consructor
	372
	373	\param vec
	374	value of vec_
	375
	376	\param ind
	377	value of ind_
	378	*/
	379	VecAD_reference(VecAD<Base> *vec, const AD<Base>& ind)
	380	: vec_( vec ) , ind_(ind)
358	381	{ }
359	382
360	383	// assignment operators

370	393	CPPAD_VEC_AD_COMPUTED_ASSIGNMENT( /= , " /= " )
371	394
372	395
373		// AD<Base> constructor
	396	/// Conversion from VecAD_reference to AD<Base>.
	397	/// puts the correspond vecad load instruction in the tape.
374	398	AD<Base> ADBase(void) const
375	399	{ AD<Base> result;
376	400
377		size_t i = static_cast<size_t>( Integer(x_) );
	401	size_t i = static_cast<size_t>( Integer(ind_) );
378	402	CPPAD_ASSERT_UNKNOWN( i < vec_->length_ );
379	403
380	404	// AD<Base> value corresponding to this element

392	416	CPPAD_ASSERT_UNKNOWN( tape != CPPAD_NULL );
393	417	CPPAD_ASSERT_UNKNOWN( vec_->offset_ > 0 );
394	418
395		if( IdenticalPar(x_) )
	419	size_t load_op_index = tape->Rec_.num_load_op_rec();
	420	if( IdenticalPar(ind_) )
396	421	{ CPPAD_ASSERT_UNKNOWN( NumRes(LdpOp) == 1 );
397	422	CPPAD_ASSERT_UNKNOWN( NumArg(LdpOp) == 3 );
398	423
399	424	// put operand addresses in tape
400		// (value of third arugment does not matter)
401	425	tape->Rec_.PutArg(
402		vec_->offset_, i, 0
	426	vec_->offset_, i, load_op_index
403	427	);
404		// put operator in the tape, x_ is a parameter
405		result.taddr_ = tape->Rec_.PutOp(LdpOp);
	428	// put operator in the tape, ind_ is a parameter
	429	result.taddr_ = tape->Rec_.PutLoadOp(LdpOp);
406	430	// change result to variable for this load
407	431	result.tape_id_ = tape->id_;
408	432	}
409	433	else
410	434	{ CPPAD_ASSERT_UNKNOWN( NumRes(LdvOp) == 1 );
411	435	CPPAD_ASSERT_UNKNOWN( NumArg(LdvOp) == 3 );
412
413		if( Parameter(x_) )
	436	addr_t ind_taddr;
	437	if( Parameter(ind_) )
414	438	{ // kludge that should not be needed
415		// if x_ instead of i is used for index
	439	// if ind_ instead of i is used for index
416	440	// in the tape
417		x_.tape_id_ = vec_->tape_id_;
418		x_.taddr_ = tape->RecordParOp(
419		x_.value_
	441	ind_taddr = tape->RecordParOp(
	442	ind_.value_
420	443	);
421	444	}
422		CPPAD_ASSERT_UNKNOWN( Variable(x_) );
423		CPPAD_ASSERT_UNKNOWN( x_.taddr_ > 0 );
	445	else ind_taddr = ind_.taddr_;
	446	CPPAD_ASSERT_UNKNOWN( ind_taddr > 0 );
424	447
425	448	// put operand addresses in tape
426	449	// (value of third arugment does not matter)
427	450	tape->Rec_.PutArg(
428		vec_->offset_, x_.taddr_, 0
	451	vec_->offset_, ind_taddr, load_op_index
429	452	);
430		// put operator in the tape, x_ is a variable
431		result.taddr_ = tape->Rec_.PutOp(LdvOp);
	453	// put operator in the tape, ind_ is a variable
	454	result.taddr_ = tape->Rec_.PutLoadOp(LdvOp);
432	455	// change result to variable for this load
433	456	result.tape_id_ = tape->id_;
434	457	}

437	460	}
438	461	};
439	462
440		// VecAD
	463	/*!
	464	Vector of AD objects that tracks indexing operations on the tape.
	465	*/
441	466	template <class Base>
442	467	class VecAD {
443	468	friend bool Parameter<Base> (const VecAD<Base> &vec);

448	473	friend std::ostream& operator << <Base>
449	474	(std::ostream &os, const VecAD<Base> &vec_);
450	475	private:
451		// size of this VecAD vector
	476	/// size of this VecAD vector
452	477	const size_t length_;
453	478
454		// elements of this vector
	479	/// elements of this vector
455	480	pod_vector<Base> data_;
456	481
457		// offset in cummulate vector corresponding to this object
	482	/// offset in cummulate vector corresponding to this object
458	483	size_t offset_;
459	484
460		// tape id corresponding to the offset
	485	/// tape id corresponding to the offset
461	486	tape_id_t tape_id_;
462	487	public:
463		// declare the user's view of this type here
	488	/// declare the user's view of this type here
464	489	typedef VecAD_reference<Base> reference;
465	490
466		// default constructor
467		// initialize tape_id_ same as for default constructor; see default.hpp
	491	/// default constructor
	492	/// initialize tape_id_ same as for default constructor; see default.hpp
468	493	VecAD(void)
469	494	: length_(0)
470	495	, offset_(0)
471	496	, tape_id_(0)
472	497	{ CPPAD_ASSERT_UNKNOWN( Parameter(*this) ); }
473	498
474		// constructor
475		// initialize tape_id_ same as for parameters; see ad_copy.hpp
	499	/// sizing constructor
	500	/// initialize tape_id_ same as for parameters; see ad_copy.hpp
476	501	VecAD(size_t n)
477	502	: length_(n)
478	503	, offset_(0)

491	516	CPPAD_ASSERT_UNKNOWN( Parameter(*this) );
492	517	}
493	518
494		// destructor
	519	/// destructor
495	520	~VecAD(void)
496	521	{ }
497	522
498		// size
	523	/// number of elements in the vector
499	524	size_t size(void)
500	525	{ return length_; }
501	526
502		// not taped element access
	527	/// element access (not taped)
	528	///
	529	/// \param i
	530	/// element index
503	531	Base &operator[](size_t i)
504	532	{
505	533	CPPAD_ASSERT_KNOWN(

515	543	return data_[i];
516	544	}
517	545
518		// taped elemement access
	546	/*! delayed taped elemement access
	547
	548	\param x
	549	element index
	550
	551	\par
	552	This operation may convert this vector from a parameter to a variable
	553	*/
519	554	VecAD_reference<Base> operator[](const AD<Base> &x)
520	555	{
521	556	CPPAD_ASSERT_KNOWN(

542	577	offset_ =
543	578	AD<Base>::tape_ptr(x.tape_id_)->AddVec(length_, data_);
544	579
545		// advance pointer by one so is always > 0
	580	// Advance pointer by one so starts at first component of this
	581	// vector; i.e., skip lenght at begining (so is always > 0)
546	582	offset_++;
547	583
548	584	// tape id corresponding to this offest

555	591	};
556	592
557	593
	594	/*!
	595	Taped setting of element to a value.
	596
	597	\param y
	598	value that element is set to.
	599	*/
558	600	template <class Base>
559	601	void VecAD_reference<Base>::operator=(const AD<Base> &y)
560	602	{

587	629
588	630
589	631	// index in vector for this element
590		size_t i = static_cast<size_t>( Integer(x_) );
	632	size_t i = static_cast<size_t>( Integer(ind_) );
591	633	CPPAD_ASSERT_UNKNOWN( i < vec_->length_ );
592	634
593	635	// assign value for this element (as an AD<Base> object)

595	637
596	638	// record the setting of this array element
597	639	CPPAD_ASSERT_UNKNOWN( vec_->offset_ > 0 );
598		if( Parameter(x_) )
	640	if( Parameter(ind_) )
599	641	{ CPPAD_ASSERT_UNKNOWN( NumArg(StpvOp) == 3 );
600	642	CPPAD_ASSERT_UNKNOWN( NumRes(StpvOp) == 0 );
601	643
602	644	// put operand addresses in tape
603	645	tape->Rec_.PutArg(vec_->offset_, i, y.taddr_);
604	646
605		// put operator in the tape, x_ is parameter, y is variable
	647	// put operator in the tape, ind_ is parameter, y is variable
606	648	tape->Rec_.PutOp(StpvOp);
607	649	}
608	650	else
609	651	{ CPPAD_ASSERT_UNKNOWN( NumArg(StvvOp) == 3 );
610	652	CPPAD_ASSERT_UNKNOWN( NumRes(StvvOp) == 0 );
611		CPPAD_ASSERT_UNKNOWN( x_.taddr_ > 0 );
	653	CPPAD_ASSERT_UNKNOWN( ind_.taddr_ > 0 );
612	654
613	655	// put operand addresses in tape
614		tape->Rec_.PutArg(vec_->offset_, x_.taddr_, y.taddr_);
615
616		// put operator in the tape, x_ is variable, y is variable
	656	tape->Rec_.PutArg(vec_->offset_, ind_.taddr_, y.taddr_);
	657
	658	// put operator in the tape, ind_ is variable, y is variable
617	659	tape->Rec_.PutOp(StvvOp);
618	660	}
619	661	}
620	662
	663
	664	/*!
	665	Taped setting of element to a value.
	666
	667	\param y
	668	value that element is set to.
	669	*/
621	670	template <class Base>
622	671	void VecAD_reference<Base>::operator=(const Base &y)
623	672	{
624		size_t i = static_cast<size_t>( Integer(x_) );
	673	size_t i = static_cast<size_t>( Integer(ind_) );
625	674	CPPAD_ASSERT_UNKNOWN( i < vec_->length_ );
626	675
627	676	// assign value for this element

639	688
640	689	// record the setting of this array element
641	690	CPPAD_ASSERT_UNKNOWN( vec_->offset_ > 0 );
642		if( Parameter(x_) )
	691	if( Parameter(ind_) )
643	692	{ CPPAD_ASSERT_UNKNOWN( NumArg(StppOp) == 3 );
644	693	CPPAD_ASSERT_UNKNOWN( NumRes(StppOp) == 0 );
645	694
646	695	// put operand addresses in tape
647	696	tape->Rec_.PutArg(vec_->offset_, i, p);
648	697
649		// put operator in the tape, x_ is parameter, y is parameter
	698	// put operator in the tape, ind_ is parameter, y is parameter
650	699	tape->Rec_.PutOp(StppOp);
651	700	}
652	701	else
653	702	{ CPPAD_ASSERT_UNKNOWN( NumArg(StvpOp) == 3 );
654	703	CPPAD_ASSERT_UNKNOWN( NumRes(StvpOp) == 0 );
655		CPPAD_ASSERT_UNKNOWN( x_.taddr_ > 0 );
	704	CPPAD_ASSERT_UNKNOWN( ind_.taddr_ > 0 );
656	705
657	706	// put operand addresses in tape
658		tape->Rec_.PutArg(vec_->offset_, x_.taddr_, p);
659
660		// put operator in the tape, x_ is variable, y is parameter
	707	tape->Rec_.PutArg(vec_->offset_, ind_.taddr_, p);
	708
	709	// put operator in the tape, ind_ is variable, y is parameter
661	710	tape->Rec_.PutOp(StvpOp);
662	711	}
663	712	}
664	713
665		// fold this case into AD<Base> case above
	714	/*!
	715	Taped setting of element to a value.
	716
	717	\param y
	718	value that element is set to.
	719
	720	\par
	721	this case gets folded into case where value is AD<Base>.
	722	*/
666	723	template <class Base>
667	724	inline void VecAD_reference<Base>::operator=
668	725	(const VecAD_reference<Base> &y)
669	726	{ *this = y.ADBase(); }
670	727
671		// fold this case into Base case above
	728	/*!
	729	Taped setting of element to a value.
	730
	731	\param y
	732	value that element is set to.
	733
	734	\par
	735	this case gets folded into case where value is Base.
	736	*/
672	737	template <class Base>
673	738	inline void VecAD_reference<Base>::operator=(int y)
674	739	{ *this = Base(y); }
675	740
676		template <class Base>
677		CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
678		std::ostream& operator << (std::ostream &os, const VecAD<Base> &v)
679		{
680		os << "vecAD( length = " << v.length_
681		<< ", offset = " << v.offset_ << ")";
682		return os;
683		}
684
685
686		} // END CppAD namespace
	741
	742	} // END_CPPAD_NAMESPACE
687	743
688	744	// preprocessor symbols that are local to this file
689	745	# undef CPPAD_VEC_AD_COMPUTED_ASSIGNMENT
690		# undef CPPAD_VEC_AD_TYPEDEF_ADBASE
691	746
692	747	# endif

-5

cppad/memory_leak.hpp less more

0		/* $Id: memory_leak.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: memory_leak.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_MEMORY_LEAK_INCLUDED
2	2	# define CPPAD_MEMORY_LEAK_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

118	118
119	119	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
120	120	/*!
121		\defgroup memory_leak_hpp memory_leak.hpp
122		\{
123	121	\file memory_leak.hpp
124	122	File that implements a memory check at end of a CppAD program
125	123	*/

213	211	return leak;
214	212	}
215	213
216		/! \} /
217	214	} // END_CPPAD_NAMESPACE
218	215	# endif

-1

cppad/nan.hpp less more

0		/* $Id: nan.hpp 3098 2014-02-18 03:19:39Z bradbell $ */
	0	/* $Id: nan.hpp 3097 2014-02-18 02:48:28Z bradbell $ */
1	1	# ifndef CPPAD_NAN_INCLUDED
2	2	# define CPPAD_NAN_INCLUDED
3	3

-1

cppad/speed/det_of_minor.hpp less more

0		/* $Id: det_of_minor.hpp 3062 2013-12-28 10:40:48Z bradbell $ */
	0	/* $Id: det_of_minor.hpp 3060 2013-12-27 20:38:57Z bradbell $ */
1	1	# ifndef CPPAD_DET_OF_MINOR_INCLUDED
2	2	# define CPPAD_DET_OF_MINOR_INCLUDED
3	3

+15

-6

cppad/thread_alloc.hpp less more

0		/* $Id: thread_alloc.hpp 2939 2013-10-14 11:06:18Z bradbell $ */
	0	/* $Id: thread_alloc.hpp 3408 2014-11-27 15:17:20Z bradbell $ */
1	1	# ifndef CPPAD_THREAD_ALLOC_INCLUDED
2	2	# define CPPAD_THREAD_ALLOC_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

28	28	# include <cppad/local/define.hpp>
29	29	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
30	30	/*!
31		\defgroup thread_alloc_hpp thread_alloc.hpp
32		\{
33	31	\file thread_alloc.hpp
34	32	File used to define the CppAD multi-threading allocaor class
35	33	*/

114	112	size_t extra_;
115	113	/// an index that uniquely idenfifies both thread and capacity
116	114	size_t tc_index_;
117		/// pointer to the next memory allocation with the the same tc_index_
	115	/// pointer to the next memory allocation with the same tc_index_
118	116	void* next_;
119	117	// -----------------------------------------------------------------
120	118	/// make default constructor private. It is only used by constructor

788	786	the previous $icode min_bytes$$ and previous $icode cap_bytes$$.
789	787	$lend
790	788
	789	$head Alignment$$
	790	We call a memory allocation aligned if the address is a multiple
	791	of the number of bytes in a $code size_t$$ value.
	792	If the system $code new$$ allocator is aligned, then $icode v_ptr$$
	793	pointer is also aligned.
	794
791	795	$head Example$$
792	796	$cref thread_alloc.cpp$$
793	797

1372	1376	if a previous allocation with $icode size_min$$ between its current value
1373	1377	and $icode size_out$$ is available.
1374	1378
	1379	$head Alignment$$
	1380	We call a memory allocation aligned if the address is a multiple
	1381	of the number of bytes in a $code size_t$$ value.
	1382	If the system $code new$$ allocator is aligned, then $icode array$$
	1383	pointer is also aligned.
	1384
1375	1385	$head Example$$
1376	1386	$cref thread_alloc.cpp$$
1377	1387

1567	1577	};
1568	1578
1569	1579
1570		/! \} /
1571	1580	} // END_CPPAD_NAMESPACE
1572	1581
1573	1582	// preprocessor symbols local to this file

-5

cppad/time_test.hpp less more

0		/* $Id: time_test.hpp 2910 2013-10-07 13:27:58Z bradbell $ */
	0	/* $Id: time_test.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_TIME_TEST_INCLUDED
2	2	# define CPPAD_TIME_TEST_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

145	145
146	146	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
147	147	/*!
148		\defgroup time_test_hpp time_test.hpp
149		\{
150	148	\file time_test.hpp
151	149	\brief Function that preforms one timing test (for speed of execution).
152	150	*/

220	218	return time;
221	219	}
222	220
223		/! \} /
224	221	} // END_CPPAD_NAMESPACE
225	222
226	223	// END PROGRAM

+95

-12

cppad/vector.hpp less more

0		/* $Id: vector.hpp 2945 2013-10-15 13:21:53Z bradbell $ */
	0	/* $Id: vector.hpp 3232 2014-04-27 15:38:21Z bradbell $ */
1	1	# ifndef CPPAD_VECTOR_INCLUDED
2	2	# define CPPAD_VECTOR_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

15	15	/*
16	16	$begin CppAD_vector$$
17	17	$spell
	18	rvalues
18	19	thread_alloc
19	20	cppad.hpp
20	21	Bool

94	95	%z% = %y% = %x%
95	96	%$$
96	97
	98	$subhead Move Semantics$$
	99	If the C++ compiler supports move semantic rvalues using the $code &&$$
	100	syntax, then it will be used during the vector assignment statement.
	101	This means that return values and other temporaries are not be copied,
	102	but rather pointers are transferred.
	103
97	104	$head Element Access$$
98	105	$index [], CppAD vector$$
99	106	$index vector, [] CppAD$$

130	137	extends the vector $icode x$$ so that its new size is $icode n$$ plus one
131	138	and $icode%x%[%n%]%$$ is equal to $icode s$$
132	139	(equal in the sense of the $icode Scalar$$ assignment operator).
133
134	140
135	141	$head push_vector$$
136	142	$index push_vector, CppAD$$

181	187	and when checking for memory leaks (and there are global vectors)
182	188	see the $cref/memory/CppAD_vector/Memory and Parallel Mode/$$ discussion.
183	189
	190	$head data$$
	191	$index data, CppAD vector$$
	192	$index vector, CppAD data$$
	193	If $icode x$$ is a $codei%CppAD::vector<%Scalar%>%$$ object
	194	$codei%
	195	%x%.data()
	196	%$$
	197	returns a pointer to a $icode Scalar$$ object such that for
	198	$codei%0 <= %i% < %x%.size()%$$,
	199	$icode%x%[%i%]%$$ and $icode%x%.data()[%i%]%$$
	200	are the same $icode Scalar$$ object.
	201	If $icode x$$ is $code const$$, the pointer is $code const$$.
	202	If $icode%x%.capacity()%$$ is zero, the value of the pointer is not defined.
	203	The pointer may no longer be valid after the following operations on
	204	$icode x$$:
	205	its destructor,
	206	$code clear$$,
	207	$code resize$$,
	208	$code push_back$$,
	209	$code push_vector$$,
	210	assignment to another vector when original size of $icode x$$ is zero.
	211
184	212	$head vectorBool$$
185	213	$index vectorBool$$
186	214	The file $code <cppad/vector.hpp>$$ also defines the class

192	220	The class $code vectorBool$$ conserves on memory
193	221	(on the other hand, $code CppAD::vector<bool>$$ is expected to be faster
194	222	than $code vectorBool$$).
	223
	224	$subhead data$$
	225	The $cref/data/CppAD_vector/data/$$ function is not supported by
	226	$code vectorBool$$.
195	227
196	228	$subhead Output$$
197	229	The $code CppAD::vectorBool$$ output operator

294	326
295	327	namespace CppAD { // BEGIN_CPPAD_NAMESPACE
296	328	/*!
297		\defgroup vector_hpp vector.hpp
298		\{
299	329	\file vector.hpp
300	330	File used to define CppAD::vector and CppAD::vectorBool
301	331	*/

320	350
321	351	/// default constructor sets capacity_ = length_ = data_ = 0
322	352	inline vector(void)
323		: capacity_(0), length_(0), data_(0)
	353	: capacity_(0), length_(0), data_(CPPAD_NULL)
324	354	{ }
325	355	/// sizing constructor
326	356	inline vector(
327	357	/// number of elements in this vector
328	358	size_t n
329		) : capacity_(0), length_(n), data_(0)
	359	) : capacity_(0), length_(n), data_(CPPAD_NULL)
330	360	{ if( length_ > 0 )
331	361	{ // set capacity and data
332	362	data_ = thread_alloc::create_array<Type>(length_, capacity_);

336	366	inline vector(
337	367	/// the *this vector will be a copy of \c x
338	368	const vector& x
339		) : capacity_(0), length_(x.length_), data_(0)
	369	) : capacity_(0), length_(x.length_), data_(CPPAD_NULL)
340	370	{ if( length_ > 0 )
341	371	{ // set capacity and data
342	372	data_ = thread_alloc::create_array<Type>(length_, capacity_);

360	390	/// number of elements currently in this vector.
361	391	inline size_t size(void) const
362	392	{ return length_; }
	393
	394	/// raw pointer to the data
	395	inline Type* data(void)
	396	{ return data_; }
	397
	398	/// const raw pointer to the data
	399	inline const Type* data(void) const
	400	{ return data_; }
363	401
364	402	/// change the number of elements in this vector.
365	403	inline void resize(

404	442	data_[i] = x.data_[i];
405	443	return *this;
406	444	}
	445	# if CPPAD_HAS_RVALUE
	446	/// vector assignment operator with move semantics
	447	inline vector& operator=(
	448	/// right hand size of the assingment operation
	449	vector&& x
	450	)
	451	{ CPPAD_ASSERT_KNOWN(
	452	length_ == x.length_ \|\| (length_ == 0),
	453	"vector: size miss match in assignment operation"
	454	);
	455	if( this != &x )
	456	{ clear();
	457	//
	458	length_ = x.length_;
	459	capacity_ = x.capacity_;
	460	data_ = x.data_;
	461	//
	462	x.length_ = 0;
	463	x.capacity_ = 0;
	464	x.data_ = CPPAD_NULL;
	465	}
	466	return *this;
	467	}
	468	# endif
407	469	/// non-constant element access; i.e., we can change this element value
408	470	Type& operator[](
409	471	/// element index, must be less than length

579	641	typedef bool value_type;
580	642
581	643	/// default constructor (sets all member data to zero)
582		inline vectorBool(void) : n_unit_(0), length_(0), data_(0)
	644	inline vectorBool(void) : n_unit_(0), length_(0), data_(CPPAD_NULL)
583	645	{ }
584	646	/// sizing constructor
585	647	inline vectorBool(
586	648	/// number of bits in this vector
587	649	size_t n
588		) : n_unit_(0), length_(n), data_(0)
	650	) : n_unit_(0), length_(n), data_(CPPAD_NULL)
589	651	{ if( length_ > 0 )
590	652	{ // set n_unit and data
591	653	size_t min_unit = unit_min();

596	658	inline vectorBool(
597	659	/// the *this vector will be a copy of \c v
598	660	const vectorBool& v
599		) : n_unit_(0), length_(v.length_), data_(0)
	661	) : n_unit_(0), length_(v.length_), data_(CPPAD_NULL)
600	662	{ if( length_ > 0 )
601	663	{ // set n_unit and data
602	664	size_t min_unit = unit_min();

666	728	data_[i] = v.data_[i];
667	729	return *this;
668	730	}
	731	# if CPPAD_HAS_RVALUE
	732	/// vector assignment operator with move semantics
	733	inline vectorBool& operator=(
	734	/// right hand size of the assingment operation
	735	vectorBool&& x
	736	)
	737	{ if( this != &x )
	738	{ clear();
	739	//
	740	length_ = x.length_;
	741	n_unit_ = x.n_unit_;
	742	data_ = x.data_;
	743	//
	744	x.length_ = 0;
	745	x.n_unit_ = 0;
	746	x.data_ = CPPAD_NULL;
	747	}
	748	return *this;
	749	}
	750	# endif
	751
	752
669	753	/// non-constant element access; i.e., we can change this element value
670	754	vectorBoolElement operator[](
671	755	/// element index, must be less than length

786	870	return os;
787	871	}
788	872
789		/! \} /
790	873	} // END_CPPAD_NAMESPACE
791	874	# endif

+13

-9

cppad_ipopt/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2683 2012-12-30 18:17:03Z bradbell $
	0	# $Id: CMakeLists.txt 3120 2014-02-25 14:04:02Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

11	11	# Build the cppad_ipopt/* directory tests
12	12	# Inherit environment from ../CMakeList.txt
13	13
	14	# colpack_prefix
	15	SET(sources ../../cppad/local/cppad_colpack.cpp)
	16	sources_libs_define(colpack "${sources}" ColPack "")
	17
14	18	# Initialize list of tests as empty
15		SET(list_ipopt_nlp "")
	19	SET(check_depends "")
16	20
17	21	# assert ipopt_prefix is defined
18	22	IF ( NOT ipopt_prefix )
19	23	MESSAGE(FATAL_ERROR
20		"cppad_ipopt/speed/CMakeLists.txt: ipopt_prefix = ${ipopt_prefix}"
	24	"cppad_ipopt/CMakeLists.txt: ipopt_prefix = ${ipopt_prefix}"
21	25	)
22	26	ENDIF ( NOT ipopt_prefix )
23	27

27	31	ADD_SUBDIRECTORY(src)
28	32	#
29	33	ADD_SUBDIRECTORY(example)
30		add_to_list(list_ipopt_nlp check_example_ipopt_nlp)
	34	add_to_list(check_depends check_cppad_ipopt_example)
31	35	#
32	36	ADD_SUBDIRECTORY(speed)
33		add_to_list(list_ipopt_nlp check_speed_ipopt_nlp)
	37	add_to_list(check_depends check_cppad_ipopt_speed)
34	38	#
35	39	ADD_SUBDIRECTORY(test)
36		add_to_list(list_ipopt_nlp check_test_more_ipopt_nlp)
	40	add_to_list(check_depends check_cppad_ipopt_test)
37	41
38		# Add the check_ipopt_nlp target
39		ADD_CUSTOM_TARGET(check_ipopt_nlp DEPENDS ${list_ipopt_nlp} )
	42	# Add the check_cppad_ipopt target
	43	ADD_CUSTOM_TARGET(check_cppad_ipopt DEPENDS ${check_depends} )

+13

-9

cppad_ipopt/example/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2683 2012-12-30 18:17:03Z bradbell $
	0	# $Id: CMakeLists.txt 3116 2014-02-24 21:44:26Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

24	24	# add_executable(<name> [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL]
25	25	# source1 source2 ... sourceN
26	26	# )
27		ADD_EXECUTABLE(example_ipopt_nlp EXCLUDE_FROM_ALL
	27	ADD_EXECUTABLE(cppad_ipopt_example EXCLUDE_FROM_ALL
28	28	example.cpp
29	29	get_started.cpp
30	30	ode_check.cpp

38	38	)
39	39
40	40	# Extra compiler flags
41		add_cppad_cxx_flags( example_ipopt_nlp )
	41	add_cppad_cxx_flags( cppad_ipopt_example )
42	42
43	43	# List of libraries to be linked into the specified target
44		TARGET_LINK_LIBRARIES(example_ipopt_nlp cppad_ipopt ${ipopt_LIBRARIES})
	44	TARGET_LINK_LIBRARIES(cppad_ipopt_example
	45	cppad_ipopt
	46	${ipopt_LIBRARIES}
	47	${colpack_libs}
	48	)
45	49
46		# Add the check_example_ipopt_nlp target
47		ADD_CUSTOM_TARGET(check_example_ipopt_nlp
48		example_ipopt_nlp
49		DEPENDS example_ipopt_nlp cppad_ipopt
	50	# Add the check_cppad_ipopt_example target
	51	ADD_CUSTOM_TARGET(check_cppad_ipopt_example
	52	cppad_ipopt_example
	53	DEPENDS cppad_ipopt_example cppad_ipopt
50	54	)

+148

-76

cppad_ipopt/example/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = example$(EXEEXT)
51	80	subdir = cppad_ipopt/example
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in \
53		$(srcdir)/test.sh.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(srcdir)/test.sh.in $(top_srcdir)/depcomp
54	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
55	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
56	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

66	95	am__DEPENDENCIES_1 =
67	96	example_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
68	97	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
	98	AM_V_P = $(am__v_P_@AM_V@)
	99	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	100	am__v_P_0 = false
	101	am__v_P_1 = :
	102	AM_V_GEN = $(am__v_GEN_@AM_V@)
	103	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	104	am__v_GEN_0 = @echo " GEN " $@;
	105	am__v_GEN_1 =
	106	AM_V_at = $(am__v_at_@AM_V@)
	107	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	108	am__v_at_0 = @
	109	am__v_at_1 =
69	110	DEFAULT_INCLUDES =
70	111	depcomp = $(SHELL) $(top_srcdir)/depcomp
71	112	am__depfiles_maybe = depfiles

74	115	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
75	116	AM_V_CXX = $(am__v_CXX_@AM_V@)
76	117	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
77		am__v_CXX_0 = @echo " CXX " $@;
78		AM_V_at = $(am__v_at_@AM_V@)
79		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
80		am__v_at_0 = @
	118	am__v_CXX_0 = @echo " CXX " $@;
	119	am__v_CXX_1 =
81	120	CXXLD = $(CXX)
82	121	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
83	122	-o $@
84	123	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
85	124	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
86		am__v_CXXLD_0 = @echo " CXXLD " $@;
	125	am__v_CXXLD_0 = @echo " CXXLD " $@;
	126	am__v_CXXLD_1 =
87	127	COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
88	128	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
89	129	AM_V_CC = $(am__v_CC_@AM_V@)
90	130	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
91		am__v_CC_0 = @echo " CC " $@;
	131	am__v_CC_0 = @echo " CC " $@;
	132	am__v_CC_1 =
92	133	CCLD = $(CC)
93	134	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
94	135	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
95	136	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
96		am__v_CCLD_0 = @echo " CCLD " $@;
97		AM_V_GEN = $(am__v_GEN_@AM_V@)
98		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
99		am__v_GEN_0 = @echo " GEN " $@;
	137	am__v_CCLD_0 = @echo " CCLD " $@;
	138	am__v_CCLD_1 =
100	139	SOURCES = $(example_SOURCES)
101	140	DIST_SOURCES = $(example_SOURCES)
102	141	am__can_run_installinfo = \

104	143	n\|no\|NO) false;; \
105	144	*) (install-info --version) >/dev/null 2>&1;; \
106	145	esac
	146	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	147	# Read a list of newline-separated strings from the standard input,
	148	# and print each of them once, without duplicates. Input order is
	149	# not preserved.
	150	am__uniquify_input = $(AWK) '\
	151	BEGIN { nonempty = 0; } \
	152	{ items[$$0] = 1; nonempty = 1; } \
	153	END { if (nonempty) { for (i in items) print i; }; } \
	154	'
	155	# Make sure the list of sources is unique. This is necessary because,
	156	# e.g., the same source file might be shared among _SOURCES variables
	157	# for different programs/libraries.
	158	am__define_uniq_tagged_files = \
	159	list='$(am__tagged_files)'; \
	160	unique=`for i in $$list; do \
	161	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	162	done \| $(am__uniquify_input)`
107	163	ETAGS = etags
108	164	CTAGS = ctags
109	165	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

113	169	ADOLC_DIR = @ADOLC_DIR@
114	170	AMTAR = @AMTAR@
115	171	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	172	AR = @AR@
116	173	AUTOCONF = @AUTOCONF@
117	174	AUTOHEADER = @AUTOHEADER@
118	175	AUTOMAKE = @AUTOMAKE@

135	192	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
136	193	CYGPATH_W = @CYGPATH_W@
137	194
138		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	195	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
139	196	# -----------------------------------------------------------------------------
140	197	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
141	198	#

202	259	abs_srcdir = @abs_srcdir@
203	260	abs_top_builddir = @abs_top_builddir@
204	261	abs_top_srcdir = @abs_top_srcdir@
	262	ac_ct_AR = @ac_ct_AR@
205	263	ac_ct_CC = @ac_ct_CC@
206	264	ac_ct_CXX = @ac_ct_CXX@
207	265	ac_ct_FC = @ac_ct_FC@

212	270	am__tar = @am__tar@
213	271	am__untar = @am__untar@
214	272	bindir = @bindir@
	273	build = @build@
215	274	build_alias = @build_alias@
	275	build_cpu = @build_cpu@
	276	build_os = @build_os@
	277	build_vendor = @build_vendor@
216	278	builddir = @builddir@
217	279	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
218	280	cppad_boostvector = @cppad_boostvector@
219	281	cppad_cflags = @cppad_cflags@
	282	cppad_compiler_has_erf = @cppad_compiler_has_erf@
220	283	cppad_cppadvector = @cppad_cppadvector@
221	284	cppad_description = @cppad_description@
222	285	cppad_eigenvector = @cppad_eigenvector@
	286	cppad_has_colpack = @cppad_has_colpack@
	287	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
223	288	cppad_has_gettimeofday = @cppad_has_gettimeofday@
224	289	cppad_has_nullptr = @cppad_has_nullptr@
	290	cppad_has_rvalue = @cppad_has_rvalue@
225	291	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
226	292	cppad_internal_sparse_set = @cppad_internal_sparse_set@
227	293	cppad_libs = @cppad_libs@
228	294	cppad_max_num_threads = @cppad_max_num_threads@
229	295	cppad_requires = @cppad_requires@
230		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	296	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
231	297	cppad_stdvector = @cppad_stdvector@
232	298	cppad_tape_addr_type = @cppad_tape_addr_type@
233	299	cppad_tape_id_type = @cppad_tape_id_type@

239	305	dvidir = @dvidir@
240	306	eigen_prefix = @eigen_prefix@
241	307	exec_prefix = @exec_prefix@
242		have_ar = @have_ar@
243	308	have_pkg_config = @have_pkg_config@
	309	host = @host@
244	310	host_alias = @host_alias@
	311	host_cpu = @host_cpu@
	312	host_os = @host_os@
	313	host_vendor = @host_vendor@
245	314	htmldir = @htmldir@
246	315	includedir = @includedir@
247	316	infodir = @infodir@

342	411
343	412	clean-checkPROGRAMS:
344	413	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	414
345	415	example$(EXEEXT): $(example_OBJECTS) $(example_DEPENDENCIES) $(EXTRA_example_DEPENDENCIES)
346	416	@rm -f example$(EXEEXT)
347	417	$(AM_V_CXXLD)$(CXXLINK) $(example_OBJECTS) $(example_LDADD) $(LIBS)

359	429	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ode_simple_check.Po@am__quote@
360	430
361	431	.cpp.o:
362		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
363		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	432	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	433	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	434	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
364	435	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
365	436	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
366	437	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
367	438
368	439	.cpp.obj:
369		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
370		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	440	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	441	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	442	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
371	443	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
372	444	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
373	445	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
374	446
375		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
376		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
377		unique=`for i in $$list; do \
378		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
379		done \| \
380		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
381		END { if (nonempty) { for (i in files) print i; }; }'`; \
382		mkid -fID $$unique
383		tags: TAGS
384
385		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
386		$(TAGS_FILES) $(LISP)
	447	ID: $(am__tagged_files)
	448	$(am__define_uniq_tagged_files); mkid -fID $$unique
	449	tags: tags-am
	450	TAGS: tags
	451
	452	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
387	453	set x; \
388	454	here=`pwd`; \
389		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
390		unique=`for i in $$list; do \
391		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
392		done \| \
393		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
394		END { if (nonempty) { for (i in files) print i; }; }'`; \
	455	$(am__define_uniq_tagged_files); \
395	456	shift; \
396	457	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
397	458	test -n "$$unique" \|\| unique=$$empty_fix; \

403	464	$$unique; \
404	465	fi; \
405	466	fi
406		ctags: CTAGS
407		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
408		$(TAGS_FILES) $(LISP)
409		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
410		unique=`for i in $$list; do \
411		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
412		done \| \
413		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
414		END { if (nonempty) { for (i in files) print i; }; }'`; \
	467	ctags: ctags-am
	468
	469	CTAGS: ctags
	470	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	471	$(am__define_uniq_tagged_files); \
415	472	test -z "$(CTAGS_ARGS)$$unique" \
416	473	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
417	474	$$unique

420	477	here=`$(am__cd) $(top_builddir) && pwd` \
421	478	&& $(am__cd) $(top_srcdir) \
422	479	&& gtags -i $(GTAGS_ARGS) "$$here"
	480	cscopelist: cscopelist-am
	481
	482	cscopelist-am: $(am__tagged_files)
	483	list='$(am__tagged_files)'; \
	484	case "$(srcdir)" in \
	485	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	486	*) sdir=$(subdir)/$(srcdir) ;; \
	487	esac; \
	488	for i in $$list; do \
	489	if test -f "$$i"; then \
	490	echo "$(subdir)/$$i"; \
	491	else \
	492	echo "$$sdir/$$i"; \
	493	fi; \
	494	done >> $(top_builddir)/cscope.files
423	495
424	496	distclean-tags:
425	497	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

560	632
561	633	.MAKE: check-am install-am install-strip
562	634
563		.PHONY: CTAGS GTAGS all all-am check check-am clean \
564		clean-checkPROGRAMS clean-generic ctags distclean \
565		distclean-compile distclean-generic distclean-tags distdir dvi \
566		dvi-am html html-am info info-am install install-am \
567		install-data install-data-am install-dvi install-dvi-am \
568		install-exec install-exec-am install-html install-html-am \
569		install-info install-info-am install-man install-pdf \
570		install-pdf-am install-ps install-ps-am install-strip \
571		installcheck installcheck-am installdirs maintainer-clean \
572		maintainer-clean-generic mostlyclean mostlyclean-compile \
573		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
574		uninstall-am
	635	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	636	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	637	distclean distclean-compile distclean-generic distclean-tags \
	638	distdir dvi dvi-am html html-am info info-am install \
	639	install-am install-data install-data-am install-dvi \
	640	install-dvi-am install-exec install-exec-am install-html \
	641	install-html-am install-info install-info-am install-man \
	642	install-pdf install-pdf-am install-ps install-ps-am \
	643	install-strip installcheck installcheck-am installdirs \
	644	maintainer-clean maintainer-clean-generic mostlyclean \
	645	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	646	tags tags-am uninstall uninstall-am
575	647
576	648
577	649	test: check

+14

-9

cppad_ipopt/speed/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2683 2012-12-30 18:17:03Z bradbell $
	0	# $Id: CMakeLists.txt 3116 2014-02-24 21:44:26Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

26	26	# source1 source2 ... sourceN
27	27	# )
28	28	# Include source for cppad_ipopt library so we build it without debugging
29		ADD_EXECUTABLE(speed_ipopt_nlp EXCLUDE_FROM_ALL
	29	ADD_EXECUTABLE(cppad_ipopt_speed EXCLUDE_FROM_ALL
30	30	speed.cpp
31	31	../src/cppad_ipopt_nlp.cpp
32	32	../src/fun_record.hpp

38	38	)
39	39
40	40	# Add extra compiler flags
41		add_cppad_cxx_flags( speed_ipopt_nlp )
	41	add_cppad_cxx_flags( cppad_ipopt_speed )
42	42
43	43	# List of libraries to be linked into the specified target
44		TARGET_LINK_LIBRARIES(speed_ipopt_nlp cppad_ipopt ${ipopt_LIBRARIES})
	44	TARGET_LINK_LIBRARIES(
	45	cppad_ipopt_speed
	46	cppad_ipopt
	47	${ipopt_LIBRARIES}
	48	${colpack_libs}
	49	)
45	50
46		# Add the check_speed_ipopt_nlp target
47		ADD_CUSTOM_TARGET(check_speed_ipopt_nlp
48		speed_ipopt_nlp
49		DEPENDS speed_ipopt_nlp cppad_ipopt
	51	# Add the check_cppad_ipopt_speed target
	52	ADD_CUSTOM_TARGET(check_cppad_ipopt_speed
	53	cppad_ipopt_speed
	54	DEPENDS cppad_ipopt_speed cppad_ipopt
50	55	)

+179

-160

cppad_ipopt/speed/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = speed$(EXEEXT)
51	80	subdir = cppad_ipopt/speed
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in \
53		$(srcdir)/test.sh.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(srcdir)/test.sh.in $(top_srcdir)/depcomp
54	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
55	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
56	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

58	87	mkinstalldirs = $(install_sh) -d
59	88	CONFIG_CLEAN_FILES = test.sh
60	89	CONFIG_CLEAN_VPATH_FILES =
61		am_speed_OBJECTS = speed.$(OBJEXT) cppad_ipopt_nlp.$(OBJEXT) \
62		hes_fg_map.$(OBJEXT) jac_g_map.$(OBJEXT) \
63		sparse_map2vec.$(OBJEXT) vec_fun_pattern.$(OBJEXT) \
64		ode_speed.$(OBJEXT)
	90	am__dirstamp = $(am__leading_dot)dirstamp
	91	am_speed_OBJECTS = speed.$(OBJEXT) ../src/cppad_ipopt_nlp.$(OBJEXT) \
	92	../src/hes_fg_map.$(OBJEXT) ../src/jac_g_map.$(OBJEXT) \
	93	../src/sparse_map2vec.$(OBJEXT) \
	94	../src/vec_fun_pattern.$(OBJEXT) ode_speed.$(OBJEXT)
65	95	speed_OBJECTS = $(am_speed_OBJECTS)
66	96	speed_LDADD = $(LDADD)
67	97	am__DEPENDENCIES_1 =
68	98	speed_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
69	99	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
	100	AM_V_P = $(am__v_P_@AM_V@)
	101	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	102	am__v_P_0 = false
	103	am__v_P_1 = :
	104	AM_V_GEN = $(am__v_GEN_@AM_V@)
	105	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	106	am__v_GEN_0 = @echo " GEN " $@;
	107	am__v_GEN_1 =
	108	AM_V_at = $(am__v_at_@AM_V@)
	109	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	110	am__v_at_0 = @
	111	am__v_at_1 =
70	112	DEFAULT_INCLUDES =
71	113	depcomp = $(SHELL) $(top_srcdir)/depcomp
72	114	am__depfiles_maybe = depfiles
73	115	am__mv = mv -f
74		AM_V_lt = $(am__v_lt_@AM_V@)
75		am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
76		am__v_lt_0 = --silent
77	116	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
78	117	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
79	118	AM_V_CXX = $(am__v_CXX_@AM_V@)
80	119	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
81		am__v_CXX_0 = @echo " CXX " $@;
82		AM_V_at = $(am__v_at_@AM_V@)
83		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
84		am__v_at_0 = @
	120	am__v_CXX_0 = @echo " CXX " $@;
	121	am__v_CXX_1 =
85	122	CXXLD = $(CXX)
86	123	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
87	124	-o $@
88	125	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
89	126	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
90		am__v_CXXLD_0 = @echo " CXXLD " $@;
	127	am__v_CXXLD_0 = @echo " CXXLD " $@;
	128	am__v_CXXLD_1 =
91	129	COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
92	130	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
93	131	AM_V_CC = $(am__v_CC_@AM_V@)
94	132	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
95		am__v_CC_0 = @echo " CC " $@;
	133	am__v_CC_0 = @echo " CC " $@;
	134	am__v_CC_1 =
96	135	CCLD = $(CC)
97	136	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
98	137	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
99	138	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
100		am__v_CCLD_0 = @echo " CCLD " $@;
101		AM_V_GEN = $(am__v_GEN_@AM_V@)
102		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
103		am__v_GEN_0 = @echo " GEN " $@;
	139	am__v_CCLD_0 = @echo " CCLD " $@;
	140	am__v_CCLD_1 =
104	141	SOURCES = $(speed_SOURCES)
105	142	DIST_SOURCES = $(speed_SOURCES)
106	143	am__can_run_installinfo = \

108	145	n\|no\|NO) false;; \
109	146	*) (install-info --version) >/dev/null 2>&1;; \
110	147	esac
	148	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	149	# Read a list of newline-separated strings from the standard input,
	150	# and print each of them once, without duplicates. Input order is
	151	# not preserved.
	152	am__uniquify_input = $(AWK) '\
	153	BEGIN { nonempty = 0; } \
	154	{ items[$$0] = 1; nonempty = 1; } \
	155	END { if (nonempty) { for (i in items) print i; }; } \
	156	'
	157	# Make sure the list of sources is unique. This is necessary because,
	158	# e.g., the same source file might be shared among _SOURCES variables
	159	# for different programs/libraries.
	160	am__define_uniq_tagged_files = \
	161	list='$(am__tagged_files)'; \
	162	unique=`for i in $$list; do \
	163	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	164	done \| $(am__uniquify_input)`
111	165	ETAGS = etags
112	166	CTAGS = ctags
113	167	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

117	171	ADOLC_DIR = @ADOLC_DIR@
118	172	AMTAR = @AMTAR@
119	173	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	174	AR = @AR@
120	175	AUTOCONF = @AUTOCONF@
121	176	AUTOHEADER = @AUTOHEADER@
122	177	AUTOMAKE = @AUTOMAKE@

139	194	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
140	195	CYGPATH_W = @CYGPATH_W@
141	196
142		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	197	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
143	198	# -----------------------------------------------------------------------------
144	199	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
145	200	#

206	261	abs_srcdir = @abs_srcdir@
207	262	abs_top_builddir = @abs_top_builddir@
208	263	abs_top_srcdir = @abs_top_srcdir@
	264	ac_ct_AR = @ac_ct_AR@
209	265	ac_ct_CC = @ac_ct_CC@
210	266	ac_ct_CXX = @ac_ct_CXX@
211	267	ac_ct_FC = @ac_ct_FC@

216	272	am__tar = @am__tar@
217	273	am__untar = @am__untar@
218	274	bindir = @bindir@
	275	build = @build@
219	276	build_alias = @build_alias@
	277	build_cpu = @build_cpu@
	278	build_os = @build_os@
	279	build_vendor = @build_vendor@
220	280	builddir = @builddir@
221	281	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
222	282	cppad_boostvector = @cppad_boostvector@
223	283	cppad_cflags = @cppad_cflags@
	284	cppad_compiler_has_erf = @cppad_compiler_has_erf@
224	285	cppad_cppadvector = @cppad_cppadvector@
225	286	cppad_description = @cppad_description@
226	287	cppad_eigenvector = @cppad_eigenvector@
	288	cppad_has_colpack = @cppad_has_colpack@
	289	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
227	290	cppad_has_gettimeofday = @cppad_has_gettimeofday@
228	291	cppad_has_nullptr = @cppad_has_nullptr@
	292	cppad_has_rvalue = @cppad_has_rvalue@
229	293	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
230	294	cppad_internal_sparse_set = @cppad_internal_sparse_set@
231	295	cppad_libs = @cppad_libs@
232	296	cppad_max_num_threads = @cppad_max_num_threads@
233	297	cppad_requires = @cppad_requires@
234		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	298	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
235	299	cppad_stdvector = @cppad_stdvector@
236	300	cppad_tape_addr_type = @cppad_tape_addr_type@
237	301	cppad_tape_id_type = @cppad_tape_id_type@

243	307	dvidir = @dvidir@
244	308	eigen_prefix = @eigen_prefix@
245	309	exec_prefix = @exec_prefix@
246		have_ar = @have_ar@
247	310	have_pkg_config = @have_pkg_config@
	311	host = @host@
248	312	host_alias = @host_alias@
	313	host_cpu = @host_cpu@
	314	host_os = @host_os@
	315	host_vendor = @host_vendor@
249	316	htmldir = @htmldir@
250	317	includedir = @includedir@
251	318	infodir = @infodir@

348	415
349	416	clean-checkPROGRAMS:
350	417	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	418	../src/$(am__dirstamp):
	419	@$(MKDIR_P) ../src
	420	@: > ../src/$(am__dirstamp)
	421	../src/$(DEPDIR)/$(am__dirstamp):
	422	@$(MKDIR_P) ../src/$(DEPDIR)
	423	@: > ../src/$(DEPDIR)/$(am__dirstamp)
	424	../src/cppad_ipopt_nlp.$(OBJEXT): ../src/$(am__dirstamp) \
	425	../src/$(DEPDIR)/$(am__dirstamp)
	426	../src/hes_fg_map.$(OBJEXT): ../src/$(am__dirstamp) \
	427	../src/$(DEPDIR)/$(am__dirstamp)
	428	../src/jac_g_map.$(OBJEXT): ../src/$(am__dirstamp) \
	429	../src/$(DEPDIR)/$(am__dirstamp)
	430	../src/sparse_map2vec.$(OBJEXT): ../src/$(am__dirstamp) \
	431	../src/$(DEPDIR)/$(am__dirstamp)
	432	../src/vec_fun_pattern.$(OBJEXT): ../src/$(am__dirstamp) \
	433	../src/$(DEPDIR)/$(am__dirstamp)
	434
351	435	speed$(EXEEXT): $(speed_OBJECTS) $(speed_DEPENDENCIES) $(EXTRA_speed_DEPENDENCIES)
352	436	@rm -f speed$(EXEEXT)
353	437	$(AM_V_CXXLD)$(CXXLINK) $(speed_OBJECTS) $(speed_LDADD) $(LIBS)
354	438
355	439	mostlyclean-compile:
356	440	-rm -f *.$(OBJEXT)
	441	-rm -f ../src/*.$(OBJEXT)
357	442
358	443	distclean-compile:
359	444	-rm -f *.tab.c
360	445
361		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cppad_ipopt_nlp.Po@am__quote@
362		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hes_fg_map.Po@am__quote@
363		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jac_g_map.Po@am__quote@
	446	@AMDEP_TRUE@@am__include@ @am__quote@../src/$(DEPDIR)/cppad_ipopt_nlp.Po@am__quote@
	447	@AMDEP_TRUE@@am__include@ @am__quote@../src/$(DEPDIR)/hes_fg_map.Po@am__quote@
	448	@AMDEP_TRUE@@am__include@ @am__quote@../src/$(DEPDIR)/jac_g_map.Po@am__quote@
	449	@AMDEP_TRUE@@am__include@ @am__quote@../src/$(DEPDIR)/sparse_map2vec.Po@am__quote@
	450	@AMDEP_TRUE@@am__include@ @am__quote@../src/$(DEPDIR)/vec_fun_pattern.Po@am__quote@
364	451	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ode_speed.Po@am__quote@
365		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_map2vec.Po@am__quote@
366	452	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/speed.Po@am__quote@
367		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vec_fun_pattern.Po@am__quote@
368	453
369	454	.cpp.o:
370		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
371		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	455	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	456	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	457	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
372	458	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
373	459	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
374	460	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
375	461
376	462	.cpp.obj:
377		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
378		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	463	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	464	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	465	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
379	466	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
380	467	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
381	468	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
382	469
383		cppad_ipopt_nlp.o: ../src/cppad_ipopt_nlp.cpp
384		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT cppad_ipopt_nlp.o -MD -MP -MF $(DEPDIR)/cppad_ipopt_nlp.Tpo -c -o cppad_ipopt_nlp.o `test -f '../src/cppad_ipopt_nlp.cpp' \|\| echo '$(srcdir)/'`../src/cppad_ipopt_nlp.cpp
385		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/cppad_ipopt_nlp.Tpo $(DEPDIR)/cppad_ipopt_nlp.Po
386		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/cppad_ipopt_nlp.cpp' object='cppad_ipopt_nlp.o' libtool=no @AMDEPBACKSLASH@
387		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
388		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o cppad_ipopt_nlp.o `test -f '../src/cppad_ipopt_nlp.cpp' \|\| echo '$(srcdir)/'`../src/cppad_ipopt_nlp.cpp
389
390		cppad_ipopt_nlp.obj: ../src/cppad_ipopt_nlp.cpp
391		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT cppad_ipopt_nlp.obj -MD -MP -MF $(DEPDIR)/cppad_ipopt_nlp.Tpo -c -o cppad_ipopt_nlp.obj `if test -f '../src/cppad_ipopt_nlp.cpp'; then $(CYGPATH_W) '../src/cppad_ipopt_nlp.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/cppad_ipopt_nlp.cpp'; fi`
392		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/cppad_ipopt_nlp.Tpo $(DEPDIR)/cppad_ipopt_nlp.Po
393		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/cppad_ipopt_nlp.cpp' object='cppad_ipopt_nlp.obj' libtool=no @AMDEPBACKSLASH@
394		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
395		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o cppad_ipopt_nlp.obj `if test -f '../src/cppad_ipopt_nlp.cpp'; then $(CYGPATH_W) '../src/cppad_ipopt_nlp.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/cppad_ipopt_nlp.cpp'; fi`
396
397		hes_fg_map.o: ../src/hes_fg_map.cpp
398		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT hes_fg_map.o -MD -MP -MF $(DEPDIR)/hes_fg_map.Tpo -c -o hes_fg_map.o `test -f '../src/hes_fg_map.cpp' \|\| echo '$(srcdir)/'`../src/hes_fg_map.cpp
399		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/hes_fg_map.Tpo $(DEPDIR)/hes_fg_map.Po
400		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/hes_fg_map.cpp' object='hes_fg_map.o' libtool=no @AMDEPBACKSLASH@
401		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
402		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o hes_fg_map.o `test -f '../src/hes_fg_map.cpp' \|\| echo '$(srcdir)/'`../src/hes_fg_map.cpp
403
404		hes_fg_map.obj: ../src/hes_fg_map.cpp
405		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT hes_fg_map.obj -MD -MP -MF $(DEPDIR)/hes_fg_map.Tpo -c -o hes_fg_map.obj `if test -f '../src/hes_fg_map.cpp'; then $(CYGPATH_W) '../src/hes_fg_map.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/hes_fg_map.cpp'; fi`
406		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/hes_fg_map.Tpo $(DEPDIR)/hes_fg_map.Po
407		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/hes_fg_map.cpp' object='hes_fg_map.obj' libtool=no @AMDEPBACKSLASH@
408		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
409		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o hes_fg_map.obj `if test -f '../src/hes_fg_map.cpp'; then $(CYGPATH_W) '../src/hes_fg_map.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/hes_fg_map.cpp'; fi`
410
411		jac_g_map.o: ../src/jac_g_map.cpp
412		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT jac_g_map.o -MD -MP -MF $(DEPDIR)/jac_g_map.Tpo -c -o jac_g_map.o `test -f '../src/jac_g_map.cpp' \|\| echo '$(srcdir)/'`../src/jac_g_map.cpp
413		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/jac_g_map.Tpo $(DEPDIR)/jac_g_map.Po
414		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/jac_g_map.cpp' object='jac_g_map.o' libtool=no @AMDEPBACKSLASH@
415		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
416		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o jac_g_map.o `test -f '../src/jac_g_map.cpp' \|\| echo '$(srcdir)/'`../src/jac_g_map.cpp
417
418		jac_g_map.obj: ../src/jac_g_map.cpp
419		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT jac_g_map.obj -MD -MP -MF $(DEPDIR)/jac_g_map.Tpo -c -o jac_g_map.obj `if test -f '../src/jac_g_map.cpp'; then $(CYGPATH_W) '../src/jac_g_map.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/jac_g_map.cpp'; fi`
420		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/jac_g_map.Tpo $(DEPDIR)/jac_g_map.Po
421		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/jac_g_map.cpp' object='jac_g_map.obj' libtool=no @AMDEPBACKSLASH@
422		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
423		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o jac_g_map.obj `if test -f '../src/jac_g_map.cpp'; then $(CYGPATH_W) '../src/jac_g_map.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/jac_g_map.cpp'; fi`
424
425		sparse_map2vec.o: ../src/sparse_map2vec.cpp
426		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT sparse_map2vec.o -MD -MP -MF $(DEPDIR)/sparse_map2vec.Tpo -c -o sparse_map2vec.o `test -f '../src/sparse_map2vec.cpp' \|\| echo '$(srcdir)/'`../src/sparse_map2vec.cpp
427		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/sparse_map2vec.Tpo $(DEPDIR)/sparse_map2vec.Po
428		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/sparse_map2vec.cpp' object='sparse_map2vec.o' libtool=no @AMDEPBACKSLASH@
429		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
430		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o sparse_map2vec.o `test -f '../src/sparse_map2vec.cpp' \|\| echo '$(srcdir)/'`../src/sparse_map2vec.cpp
431
432		sparse_map2vec.obj: ../src/sparse_map2vec.cpp
433		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT sparse_map2vec.obj -MD -MP -MF $(DEPDIR)/sparse_map2vec.Tpo -c -o sparse_map2vec.obj `if test -f '../src/sparse_map2vec.cpp'; then $(CYGPATH_W) '../src/sparse_map2vec.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/sparse_map2vec.cpp'; fi`
434		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/sparse_map2vec.Tpo $(DEPDIR)/sparse_map2vec.Po
435		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/sparse_map2vec.cpp' object='sparse_map2vec.obj' libtool=no @AMDEPBACKSLASH@
436		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
437		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o sparse_map2vec.obj `if test -f '../src/sparse_map2vec.cpp'; then $(CYGPATH_W) '../src/sparse_map2vec.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/sparse_map2vec.cpp'; fi`
438
439		vec_fun_pattern.o: ../src/vec_fun_pattern.cpp
440		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vec_fun_pattern.o -MD -MP -MF $(DEPDIR)/vec_fun_pattern.Tpo -c -o vec_fun_pattern.o `test -f '../src/vec_fun_pattern.cpp' \|\| echo '$(srcdir)/'`../src/vec_fun_pattern.cpp
441		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/vec_fun_pattern.Tpo $(DEPDIR)/vec_fun_pattern.Po
442		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/vec_fun_pattern.cpp' object='vec_fun_pattern.o' libtool=no @AMDEPBACKSLASH@
443		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
444		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vec_fun_pattern.o `test -f '../src/vec_fun_pattern.cpp' \|\| echo '$(srcdir)/'`../src/vec_fun_pattern.cpp
445
446		vec_fun_pattern.obj: ../src/vec_fun_pattern.cpp
447		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT vec_fun_pattern.obj -MD -MP -MF $(DEPDIR)/vec_fun_pattern.Tpo -c -o vec_fun_pattern.obj `if test -f '../src/vec_fun_pattern.cpp'; then $(CYGPATH_W) '../src/vec_fun_pattern.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/vec_fun_pattern.cpp'; fi`
448		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/vec_fun_pattern.Tpo $(DEPDIR)/vec_fun_pattern.Po
449		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/vec_fun_pattern.cpp' object='vec_fun_pattern.obj' libtool=no @AMDEPBACKSLASH@
450		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
451		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o vec_fun_pattern.obj `if test -f '../src/vec_fun_pattern.cpp'; then $(CYGPATH_W) '../src/vec_fun_pattern.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/vec_fun_pattern.cpp'; fi`
452
453		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
454		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
455		unique=`for i in $$list; do \
456		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
457		done \| \
458		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
459		END { if (nonempty) { for (i in files) print i; }; }'`; \
460		mkid -fID $$unique
461		tags: TAGS
462
463		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
464		$(TAGS_FILES) $(LISP)
	470	ID: $(am__tagged_files)
	471	$(am__define_uniq_tagged_files); mkid -fID $$unique
	472	tags: tags-am
	473	TAGS: tags
	474
	475	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
465	476	set x; \
466	477	here=`pwd`; \
467		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
468		unique=`for i in $$list; do \
469		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
470		done \| \
471		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
472		END { if (nonempty) { for (i in files) print i; }; }'`; \
	478	$(am__define_uniq_tagged_files); \
473	479	shift; \
474	480	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
475	481	test -n "$$unique" \|\| unique=$$empty_fix; \

481	487	$$unique; \
482	488	fi; \
483	489	fi
484		ctags: CTAGS
485		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
486		$(TAGS_FILES) $(LISP)
487		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
488		unique=`for i in $$list; do \
489		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
490		done \| \
491		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
492		END { if (nonempty) { for (i in files) print i; }; }'`; \
	490	ctags: ctags-am
	491
	492	CTAGS: ctags
	493	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	494	$(am__define_uniq_tagged_files); \
493	495	test -z "$(CTAGS_ARGS)$$unique" \
494	496	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
495	497	$$unique

498	500	here=`$(am__cd) $(top_builddir) && pwd` \
499	501	&& $(am__cd) $(top_srcdir) \
500	502	&& gtags -i $(GTAGS_ARGS) "$$here"
	503	cscopelist: cscopelist-am
	504
	505	cscopelist-am: $(am__tagged_files)
	506	list='$(am__tagged_files)'; \
	507	case "$(srcdir)" in \
	508	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	509	*) sdir=$(subdir)/$(srcdir) ;; \
	510	esac; \
	511	for i in $$list; do \
	512	if test -f "$$i"; then \
	513	echo "$(subdir)/$$i"; \
	514	else \
	515	echo "$$sdir/$$i"; \
	516	fi; \
	517	done >> $(top_builddir)/cscope.files
501	518
502	519	distclean-tags:
503	520	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

563	580	distclean-generic:
564	581	-test -z "$(CONFIG_CLEAN_FILES)" \|\| rm -f $(CONFIG_CLEAN_FILES)
565	582	-test . = "$(srcdir)" \|\| test -z "$(CONFIG_CLEAN_VPATH_FILES)" \|\| rm -f $(CONFIG_CLEAN_VPATH_FILES)
	583	-rm -f ../src/$(DEPDIR)/$(am__dirstamp)
	584	-rm -f ../src/$(am__dirstamp)
566	585
567	586	maintainer-clean-generic:
568	587	@echo "This command is intended for maintainers to use"

572	591	clean-am: clean-checkPROGRAMS clean-generic mostlyclean-am
573	592
574	593	distclean: distclean-am
575		-rm -rf ./$(DEPDIR)
	594	-rm -rf ../src/$(DEPDIR) ./$(DEPDIR)
576	595	-rm -f makefile
577	596	distclean-am: clean-am distclean-compile distclean-generic \
578	597	distclean-tags

618	637	installcheck-am:
619	638
620	639	maintainer-clean: maintainer-clean-am
621		-rm -rf ./$(DEPDIR)
	640	-rm -rf ../src/$(DEPDIR) ./$(DEPDIR)
622	641	-rm -f makefile
623	642	maintainer-clean-am: distclean-am maintainer-clean-generic
624	643

638	657
639	658	.MAKE: check-am install-am install-strip
640	659
641		.PHONY: CTAGS GTAGS all all-am check check-am clean \
642		clean-checkPROGRAMS clean-generic ctags distclean \
643		distclean-compile distclean-generic distclean-tags distdir dvi \
644		dvi-am html html-am info info-am install install-am \
645		install-data install-data-am install-dvi install-dvi-am \
646		install-exec install-exec-am install-html install-html-am \
647		install-info install-info-am install-man install-pdf \
648		install-pdf-am install-ps install-ps-am install-strip \
649		installcheck installcheck-am installdirs maintainer-clean \
650		maintainer-clean-generic mostlyclean mostlyclean-compile \
651		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
652		uninstall-am
	660	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	661	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	662	distclean distclean-compile distclean-generic distclean-tags \
	663	distdir dvi dvi-am html html-am info info-am install \
	664	install-am install-data install-data-am install-dvi \
	665	install-dvi-am install-exec install-exec-am install-html \
	666	install-html-am install-info install-info-am install-man \
	667	install-pdf install-pdf-am install-ps install-ps-am \
	668	install-strip installcheck installcheck-am installdirs \
	669	maintainer-clean maintainer-clean-generic mostlyclean \
	670	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	671	tags tags-am uninstall uninstall-am
653	672
654	673
655	674	test: check

-2

cppad_ipopt/src/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2595 2012-11-20 17:39:25Z bradbell $
	0	# $Id: CMakeLists.txt 3116 2014-02-24 21:44:26Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

24	24	jac_g_map.cpp
25	25	sparse_map2vec.cpp
26	26	vec_fun_pattern.cpp
	27	${colpack_sources}
27	28	)
28	29
29	30	# Add extra compiler flags

-4

cppad_ipopt/src/cppad_ipopt_nlp.cpp less more

0		/* $Id: cppad_ipopt_nlp.cpp 2683 2012-12-30 18:17:03Z bradbell $ */
	0	/* $Id: cppad_ipopt_nlp.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

29	29	namespace cppad_ipopt {
30	30	// ---------------------------------------------------------------------------
31	31	/*!
32		\defgroup cppad_ipopt_nlp_cpp cppad_ipopt_nlp.cpp
33	32	\{
34	33	\file cppad_ipopt_nlp.cpp
35	34	\brief Member functions for the cppad_ipopt_nlp class.

1140	1139	}
1141	1140
1142	1141	// ---------------------------------------------------------------------------
1143		/! \} /
1144	1142	} // end namespace cppad_ipopt
1145	1143	// ---------------------------------------------------------------------------

-4

cppad_ipopt/src/fun_record.hpp less more

0		/* $Id: fun_record.hpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: fun_record.hpp 3223 2014-03-19 15:13:26Z bradbell $ */
1	1	# ifndef CPPAD_FUN_RECORD_INCLUDED
2	2	# define CPPAD_FUN_RECORD_INCLUDED
3	3	/* --------------------------------------------------------------------------
4		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	4	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
5	5
6	6	CppAD is distributed under multiple licenses. This distribution is under
7	7	the terms of the

16	16	namespace cppad_ipopt {
17	17	// ---------------------------------------------------------------------------
18	18	/*!
19		\defgroup fun_record_hpp fun_record.hpp
20	19	\{
21	20	\file fun_record.hpp
22	21	\brief Records operation sequence for r_k (u)

110	109	r_fun[k].Dependent(u, r_k);
111	110	}
112	111	// ---------------------------------------------------------------------------
113		/! \} /
114	112	} // end namespace cppad_ipopt
115	113	// ---------------------------------------------------------------------------
116	114	# endif

-4

cppad_ipopt/src/hes_fg_map.cpp less more

0		/* $Id: hes_fg_map.cpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: hes_fg_map.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

15	15	namespace cppad_ipopt {
16	16	// ---------------------------------------------------------------------------
17	17	/*!
18		\defgroup hes_fg_map_cpp hes_fg_map.cpp
19	18	\{
20	19	\file hes_fg_map.cpp
21	20	\brief Creates a mapping between two representations for Hessian of fg.

173	172	}
174	173
175	174	// ---------------------------------------------------------------------------
176		/! \} /
177	175	} // end namespace cppad_ipopt
178	176	// ---------------------------------------------------------------------------

-4

cppad_ipopt/src/jac_g_map.cpp less more

0		/* $Id: jac_g_map.cpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: jac_g_map.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

14	14	namespace cppad_ipopt {
15	15	// ---------------------------------------------------------------------------
16	16	/*!
17		\defgroup jac_g_map_cpp jac_g_map.cpp
18	17	\{
19	18	\file jac_g_map.cpp
20	19	\brief Creates a mapping between two representations for Jacobian of g.

164	163	}
165	164
166	165	// ---------------------------------------------------------------------------
167		/! \} /
168	166	} // end namespace cppad_ipopt
169	167	// ---------------------------------------------------------------------------

+150

-77

cppad_ipopt/src/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

15	14	@SET_MAKE@
16	15
17	16	VPATH = @srcdir@
18		am__make_dryrun = \
19		{ \
20		am__dry=no; \
	17	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	18	am__make_running_with_option = \
	19	case $${target_option-} in \
	20	?) ;; \
	21	*) echo "am__make_running_with_option: internal error: invalid" \
	22	"target option '$${target_option-}' specified" >&2; \
	23	exit 1;; \
	24	esac; \
	25	has_opt=no; \
	26	sane_makeflags=$$MAKEFLAGS; \
	27	if $(am__is_gnu_make); then \
	28	sane_makeflags=$$MFLAGS; \
	29	else \
21	30	case $$MAKEFLAGS in \
22	31	\\[\ \ ]) \
23		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
24		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
25		*) \
26		for am__flg in $$MAKEFLAGS; do \
27		case $$am__flg in \
28		=\|--*) ;; \
29		n) am__dry=yes; break;; \
30		esac; \
31		done;; \
	32	bs=\\; \
	33	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	34	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
32	35	esac; \
33		test $$am__dry = yes; \
34		}
	36	fi; \
	37	skip_next=no; \
	38	strip_trailopt () \
	39	{ \
	40	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	41	}; \
	42	for flg in $$sane_makeflags; do \
	43	test $$skip_next = yes && { skip_next=no; continue; }; \
	44	case $$flg in \
	45	=\|--*) continue;; \
	46	-*I) strip_trailopt 'I'; skip_next=yes;; \
	47	-I?) strip_trailopt 'I';; \
	48	-*O) strip_trailopt 'O'; skip_next=yes;; \
	49	-O?) strip_trailopt 'O';; \
	50	-*l) strip_trailopt 'l'; skip_next=yes;; \
	51	-l?) strip_trailopt 'l';; \
	52	-[dEDm]) skip_next=yes;; \
	53	-[JT]) skip_next=yes;; \
	54	esac; \
	55	case $$flg in \
	56	$$target_option) has_opt=yes; break;; \
	57	esac; \
	58	done; \
	59	test $$has_opt = yes
	60	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	61	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
35	62	pkgdatadir = $(datadir)/@PACKAGE@
36	63	pkgincludedir = $(includedir)/@PACKAGE@
37	64	pkglibdir = $(libdir)/@PACKAGE@

48	75	NORMAL_UNINSTALL = :
49	76	PRE_UNINSTALL = :
50	77	POST_UNINSTALL = :
	78	build_triplet = @build@
	79	host_triplet = @host@
51	80	subdir = cppad_ipopt/src
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

86	116	}
87	117	am__installdirs = "$(DESTDIR)$(libdir)"
88	118	LIBRARIES = $(lib_LIBRARIES)
89		AR = ar
90	119	ARFLAGS = cru
91	120	AM_V_AR = $(am__v_AR_@AM_V@)
92	121	am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
93		am__v_AR_0 = @echo " AR " $@;
94		AM_V_at = $(am__v_at_@AM_V@)
95		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
96		am__v_at_0 = @
	122	am__v_AR_0 = @echo " AR " $@;
	123	am__v_AR_1 =
97	124	libcppad_ipopt_a_AR = $(AR) $(ARFLAGS)
98	125	libcppad_ipopt_a_LIBADD =
99	126	am__libcppad_ipopt_a_SOURCES_DIST = cppad_ipopt_nlp.cpp \

106	133	@CppAD_IPOPT_TRUE@ sparse_map2vec.$(OBJEXT) \
107	134	@CppAD_IPOPT_TRUE@ vec_fun_pattern.$(OBJEXT)
108	135	libcppad_ipopt_a_OBJECTS = $(am_libcppad_ipopt_a_OBJECTS)
	136	AM_V_P = $(am__v_P_@AM_V@)
	137	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	138	am__v_P_0 = false
	139	am__v_P_1 = :
	140	AM_V_GEN = $(am__v_GEN_@AM_V@)
	141	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	142	am__v_GEN_0 = @echo " GEN " $@;
	143	am__v_GEN_1 =
	144	AM_V_at = $(am__v_at_@AM_V@)
	145	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	146	am__v_at_0 = @
	147	am__v_at_1 =
109	148	DEFAULT_INCLUDES =
110	149	depcomp = $(SHELL) $(top_srcdir)/depcomp
111	150	am__depfiles_maybe = depfiles

114	153	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
115	154	AM_V_CXX = $(am__v_CXX_@AM_V@)
116	155	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
117		am__v_CXX_0 = @echo " CXX " $@;
	156	am__v_CXX_0 = @echo " CXX " $@;
	157	am__v_CXX_1 =
118	158	CXXLD = $(CXX)
119	159	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
120	160	-o $@
121	161	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
122	162	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
123		am__v_CXXLD_0 = @echo " CXXLD " $@;
	163	am__v_CXXLD_0 = @echo " CXXLD " $@;
	164	am__v_CXXLD_1 =
124	165	COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
125	166	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
126	167	AM_V_CC = $(am__v_CC_@AM_V@)
127	168	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
128		am__v_CC_0 = @echo " CC " $@;
	169	am__v_CC_0 = @echo " CC " $@;
	170	am__v_CC_1 =
129	171	CCLD = $(CC)
130	172	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
131	173	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
132	174	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
133		am__v_CCLD_0 = @echo " CCLD " $@;
134		AM_V_GEN = $(am__v_GEN_@AM_V@)
135		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
136		am__v_GEN_0 = @echo " GEN " $@;
	175	am__v_CCLD_0 = @echo " CCLD " $@;
	176	am__v_CCLD_1 =
137	177	SOURCES = $(libcppad_ipopt_a_SOURCES)
138	178	DIST_SOURCES = $(am__libcppad_ipopt_a_SOURCES_DIST)
139	179	am__can_run_installinfo = \

141	181	n\|no\|NO) false;; \
142	182	*) (install-info --version) >/dev/null 2>&1;; \
143	183	esac
	184	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	185	# Read a list of newline-separated strings from the standard input,
	186	# and print each of them once, without duplicates. Input order is
	187	# not preserved.
	188	am__uniquify_input = $(AWK) '\
	189	BEGIN { nonempty = 0; } \
	190	{ items[$$0] = 1; nonempty = 1; } \
	191	END { if (nonempty) { for (i in items) print i; }; } \
	192	'
	193	# Make sure the list of sources is unique. This is necessary because,
	194	# e.g., the same source file might be shared among _SOURCES variables
	195	# for different programs/libraries.
	196	am__define_uniq_tagged_files = \
	197	list='$(am__tagged_files)'; \
	198	unique=`for i in $$list; do \
	199	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	200	done \| $(am__uniquify_input)`
144	201	ETAGS = etags
145	202	CTAGS = ctags
146	203	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

150	207	ADOLC_DIR = @ADOLC_DIR@
151	208	AMTAR = @AMTAR@
152	209	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	210	AR = @AR@
153	211	AUTOCONF = @AUTOCONF@
154	212	AUTOHEADER = @AUTOHEADER@
155	213	AUTOMAKE = @AUTOMAKE@

172	230	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
173	231	CYGPATH_W = @CYGPATH_W@
174	232
175		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	233	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
176	234	# -----------------------------------------------------------------------------
177	235	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
178	236	#

239	297	abs_srcdir = @abs_srcdir@
240	298	abs_top_builddir = @abs_top_builddir@
241	299	abs_top_srcdir = @abs_top_srcdir@
	300	ac_ct_AR = @ac_ct_AR@
242	301	ac_ct_CC = @ac_ct_CC@
243	302	ac_ct_CXX = @ac_ct_CXX@
244	303	ac_ct_FC = @ac_ct_FC@

249	308	am__tar = @am__tar@
250	309	am__untar = @am__untar@
251	310	bindir = @bindir@
	311	build = @build@
252	312	build_alias = @build_alias@
	313	build_cpu = @build_cpu@
	314	build_os = @build_os@
	315	build_vendor = @build_vendor@
253	316	builddir = @builddir@
254	317	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
255	318	cppad_boostvector = @cppad_boostvector@
256	319	cppad_cflags = @cppad_cflags@
	320	cppad_compiler_has_erf = @cppad_compiler_has_erf@
257	321	cppad_cppadvector = @cppad_cppadvector@
258	322	cppad_description = @cppad_description@
259	323	cppad_eigenvector = @cppad_eigenvector@
	324	cppad_has_colpack = @cppad_has_colpack@
	325	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
260	326	cppad_has_gettimeofday = @cppad_has_gettimeofday@
261	327	cppad_has_nullptr = @cppad_has_nullptr@
	328	cppad_has_rvalue = @cppad_has_rvalue@
262	329	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
263	330	cppad_internal_sparse_set = @cppad_internal_sparse_set@
264	331	cppad_libs = @cppad_libs@
265	332	cppad_max_num_threads = @cppad_max_num_threads@
266	333	cppad_requires = @cppad_requires@
267		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	334	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
268	335	cppad_stdvector = @cppad_stdvector@
269	336	cppad_tape_addr_type = @cppad_tape_addr_type@
270	337	cppad_tape_id_type = @cppad_tape_id_type@

276	343	dvidir = @dvidir@
277	344	eigen_prefix = @eigen_prefix@
278	345	exec_prefix = @exec_prefix@
279		have_ar = @have_ar@
280	346	have_pkg_config = @have_pkg_config@
	347	host = @host@
281	348	host_alias = @host_alias@
	349	host_cpu = @host_cpu@
	350	host_os = @host_os@
	351	host_vendor = @host_vendor@
282	352	htmldir = @htmldir@
283	353	includedir = @includedir@
284	354	infodir = @infodir@

395	465
396	466	clean-libLIBRARIES:
397	467	-test -z "$(lib_LIBRARIES)" \|\| rm -f $(lib_LIBRARIES)
	468
398	469	libcppad_ipopt.a: $(libcppad_ipopt_a_OBJECTS) $(libcppad_ipopt_a_DEPENDENCIES) $(EXTRA_libcppad_ipopt_a_DEPENDENCIES)
399	470	$(AM_V_at)-rm -f libcppad_ipopt.a
400	471	$(AM_V_AR)$(libcppad_ipopt_a_AR) libcppad_ipopt.a $(libcppad_ipopt_a_OBJECTS) $(libcppad_ipopt_a_LIBADD)

413	484	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vec_fun_pattern.Po@am__quote@
414	485
415	486	.cpp.o:
416		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
417		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	487	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	488	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	489	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
418	490	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
419	491	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
420	492	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
421	493
422	494	.cpp.obj:
423		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
424		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	495	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	496	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	497	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
425	498	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
426	499	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
427	500	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
428	501
429		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
430		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
431		unique=`for i in $$list; do \
432		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
433		done \| \
434		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
435		END { if (nonempty) { for (i in files) print i; }; }'`; \
436		mkid -fID $$unique
437		tags: TAGS
438
439		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
440		$(TAGS_FILES) $(LISP)
	502	ID: $(am__tagged_files)
	503	$(am__define_uniq_tagged_files); mkid -fID $$unique
	504	tags: tags-am
	505	TAGS: tags
	506
	507	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
441	508	set x; \
442	509	here=`pwd`; \
443		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
444		unique=`for i in $$list; do \
445		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
446		done \| \
447		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
448		END { if (nonempty) { for (i in files) print i; }; }'`; \
	510	$(am__define_uniq_tagged_files); \
449	511	shift; \
450	512	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
451	513	test -n "$$unique" \|\| unique=$$empty_fix; \

457	519	$$unique; \
458	520	fi; \
459	521	fi
460		ctags: CTAGS
461		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
462		$(TAGS_FILES) $(LISP)
463		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
464		unique=`for i in $$list; do \
465		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
466		done \| \
467		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
468		END { if (nonempty) { for (i in files) print i; }; }'`; \
	522	ctags: ctags-am
	523
	524	CTAGS: ctags
	525	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	526	$(am__define_uniq_tagged_files); \
469	527	test -z "$(CTAGS_ARGS)$$unique" \
470	528	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
471	529	$$unique

474	532	here=`$(am__cd) $(top_builddir) && pwd` \
475	533	&& $(am__cd) $(top_srcdir) \
476	534	&& gtags -i $(GTAGS_ARGS) "$$here"
	535	cscopelist: cscopelist-am
	536
	537	cscopelist-am: $(am__tagged_files)
	538	list='$(am__tagged_files)'; \
	539	case "$(srcdir)" in \
	540	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	541	*) sdir=$(subdir)/$(srcdir) ;; \
	542	esac; \
	543	for i in $$list; do \
	544	if test -f "$$i"; then \
	545	echo "$(subdir)/$$i"; \
	546	else \
	547	echo "$$sdir/$$i"; \
	548	fi; \
	549	done >> $(top_builddir)/cscope.files
477	550
478	551	distclean-tags:
479	552	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

616	689
617	690	.MAKE: install-am install-strip
618	691
619		.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
620		clean-libLIBRARIES ctags distclean distclean-compile \
621		distclean-generic distclean-tags distdir dvi dvi-am html \
622		html-am info info-am install install-am install-data \
623		install-data-am install-dvi install-dvi-am install-exec \
624		install-exec-am install-html install-html-am install-info \
625		install-info-am install-libLIBRARIES install-man install-pdf \
626		install-pdf-am install-ps install-ps-am install-strip \
627		installcheck installcheck-am installdirs maintainer-clean \
628		maintainer-clean-generic mostlyclean mostlyclean-compile \
629		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
630		uninstall-am uninstall-libLIBRARIES
	692	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
	693	clean-libLIBRARIES cscopelist-am ctags ctags-am distclean \
	694	distclean-compile distclean-generic distclean-tags distdir dvi \
	695	dvi-am html html-am info info-am install install-am \
	696	install-data install-data-am install-dvi install-dvi-am \
	697	install-exec install-exec-am install-html install-html-am \
	698	install-info install-info-am install-libLIBRARIES install-man \
	699	install-pdf install-pdf-am install-ps install-ps-am \
	700	install-strip installcheck installcheck-am installdirs \
	701	maintainer-clean maintainer-clean-generic mostlyclean \
	702	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	703	tags tags-am uninstall uninstall-am uninstall-libLIBRARIES
631	704
632	705
633	706	# Tell versions [3.59,3.63) of GNU make to not export all variables.

-4

cppad_ipopt/src/sparse_map2vec.cpp less more

0		/* $Id: sparse_map2vec.cpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: sparse_map2vec.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

15	15	namespace cppad_ipopt {
16	16	// ---------------------------------------------------------------------------
17	17	/*!
18		\defgroup sparse_map2vec_cpp sparse_map2vec.cpp
19	18	\{
20	19	\file sparse_map2vec.cpp
21	20	\brief Create a two vector sparsity representation from a vector of maps.

93	92	}
94	93
95	94	// ---------------------------------------------------------------------------
96		/! \} /
97	95	} // end namespace cppad_ipopt
98	96	// ---------------------------------------------------------------------------

-4

cppad_ipopt/src/vec_fun_pattern.cpp less more

0		/* $Id: vec_fun_pattern.cpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: vec_fun_pattern.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

14	14	namespace cppad_ipopt {
15	15	// ---------------------------------------------------------------------------
16	16	/*!
17		\defgroup vec_fun_pattern_cpp vec_fun_pattern.cpp
18	17	\{
19	18	\file vec_fun_pattern.cpp
20	19	\brief Determine a sparsity pattern for a vector of AD function objects.

139	138	}
140	139	}
141	140	// ---------------------------------------------------------------------------
142		/! \} /
143	141	} // end namespace cppad_ipopt
144	142	// ---------------------------------------------------------------------------

+13

-9

cppad_ipopt/test/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2754 2013-02-21 04:55:55Z bradbell $
	0	# $Id: CMakeLists.txt 3116 2014-02-24 21:44:26Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

24	24	# add_executable(<name> [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL]
25	25	# source1 source2 ... sourceN
26	26	# )
27		ADD_EXECUTABLE(test_more_ipopt_nlp EXCLUDE_FROM_ALL test_more.cpp
	27	ADD_EXECUTABLE(cppad_ipopt_test EXCLUDE_FROM_ALL test_more.cpp
28	28	k_gt_one.cpp
29	29	multiple_solution.cpp
30	30	retape_k1_l1.cpp
31	31	retape_k1_l2.cpp
32	32	)
33		add_cppad_cxx_flags(test_more_ipopt_nlp)
	33	add_cppad_cxx_flags(cppad_ipopt_test)
34	34
35	35	# List of libraries to be linked into the specified target
36		TARGET_LINK_LIBRARIES(test_more_ipopt_nlp cppad_ipopt ${ipopt_LIBRARIES})
	36	TARGET_LINK_LIBRARIES(cppad_ipopt_test
	37	cppad_ipopt
	38	${ipopt_LIBRARIES}
	39	${colpack_libs}
	40	)
37	41
38		# Add the check_test_more_ipopt_nlp target
39		ADD_CUSTOM_TARGET(check_test_more_ipopt_nlp
40		test_more_ipopt_nlp
41		DEPENDS test_more_ipopt_nlp cppad_ipopt
	42	# Add the check_cppad_ipopt_test target
	43	ADD_CUSTOM_TARGET(check_cppad_ipopt_test
	44	cppad_ipopt_test
	45	DEPENDS cppad_ipopt_test cppad_ipopt
42	46	)

+144

-74

cppad_ipopt/test/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = test_more$(EXEEXT)
51	80	subdir = cppad_ipopt/test
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in \
53		$(srcdir)/test.sh.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(srcdir)/test.sh.in $(top_srcdir)/depcomp
54	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
55	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
56	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

66	95	am__DEPENDENCIES_1 =
67	96	test_more_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
68	97	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
	98	AM_V_P = $(am__v_P_@AM_V@)
	99	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	100	am__v_P_0 = false
	101	am__v_P_1 = :
	102	AM_V_GEN = $(am__v_GEN_@AM_V@)
	103	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	104	am__v_GEN_0 = @echo " GEN " $@;
	105	am__v_GEN_1 =
	106	AM_V_at = $(am__v_at_@AM_V@)
	107	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	108	am__v_at_0 = @
	109	am__v_at_1 =
69	110	DEFAULT_INCLUDES =
70	111	depcomp = $(SHELL) $(top_srcdir)/depcomp
71	112	am__depfiles_maybe = depfiles

74	115	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
75	116	AM_V_CXX = $(am__v_CXX_@AM_V@)
76	117	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
77		am__v_CXX_0 = @echo " CXX " $@;
78		AM_V_at = $(am__v_at_@AM_V@)
79		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
80		am__v_at_0 = @
	118	am__v_CXX_0 = @echo " CXX " $@;
	119	am__v_CXX_1 =
81	120	CXXLD = $(CXX)
82	121	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
83	122	-o $@
84	123	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
85	124	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
86		am__v_CXXLD_0 = @echo " CXXLD " $@;
87		AM_V_GEN = $(am__v_GEN_@AM_V@)
88		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
89		am__v_GEN_0 = @echo " GEN " $@;
	125	am__v_CXXLD_0 = @echo " CXXLD " $@;
	126	am__v_CXXLD_1 =
90	127	SOURCES = $(test_more_SOURCES)
91	128	DIST_SOURCES = $(test_more_SOURCES)
92	129	am__can_run_installinfo = \

94	131	n\|no\|NO) false;; \
95	132	*) (install-info --version) >/dev/null 2>&1;; \
96	133	esac
	134	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	135	# Read a list of newline-separated strings from the standard input,
	136	# and print each of them once, without duplicates. Input order is
	137	# not preserved.
	138	am__uniquify_input = $(AWK) '\
	139	BEGIN { nonempty = 0; } \
	140	{ items[$$0] = 1; nonempty = 1; } \
	141	END { if (nonempty) { for (i in items) print i; }; } \
	142	'
	143	# Make sure the list of sources is unique. This is necessary because,
	144	# e.g., the same source file might be shared among _SOURCES variables
	145	# for different programs/libraries.
	146	am__define_uniq_tagged_files = \
	147	list='$(am__tagged_files)'; \
	148	unique=`for i in $$list; do \
	149	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	150	done \| $(am__uniquify_input)`
97	151	ETAGS = etags
98	152	CTAGS = ctags
99	153	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

103	157	ADOLC_DIR = @ADOLC_DIR@
104	158	AMTAR = @AMTAR@
105	159	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	160	AR = @AR@
106	161	AUTOCONF = @AUTOCONF@
107	162	AUTOHEADER = @AUTOHEADER@
108	163	AUTOMAKE = @AUTOMAKE@

125	180	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
126	181	CYGPATH_W = @CYGPATH_W@
127	182
128		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	183	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
129	184	# -----------------------------------------------------------------------------
130	185	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
131	186	#

192	247	abs_srcdir = @abs_srcdir@
193	248	abs_top_builddir = @abs_top_builddir@
194	249	abs_top_srcdir = @abs_top_srcdir@
	250	ac_ct_AR = @ac_ct_AR@
195	251	ac_ct_CC = @ac_ct_CC@
196	252	ac_ct_CXX = @ac_ct_CXX@
197	253	ac_ct_FC = @ac_ct_FC@

202	258	am__tar = @am__tar@
203	259	am__untar = @am__untar@
204	260	bindir = @bindir@
	261	build = @build@
205	262	build_alias = @build_alias@
	263	build_cpu = @build_cpu@
	264	build_os = @build_os@
	265	build_vendor = @build_vendor@
206	266	builddir = @builddir@
207	267	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
208	268	cppad_boostvector = @cppad_boostvector@
209	269	cppad_cflags = @cppad_cflags@
	270	cppad_compiler_has_erf = @cppad_compiler_has_erf@
210	271	cppad_cppadvector = @cppad_cppadvector@
211	272	cppad_description = @cppad_description@
212	273	cppad_eigenvector = @cppad_eigenvector@
	274	cppad_has_colpack = @cppad_has_colpack@
	275	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
213	276	cppad_has_gettimeofday = @cppad_has_gettimeofday@
214	277	cppad_has_nullptr = @cppad_has_nullptr@
	278	cppad_has_rvalue = @cppad_has_rvalue@
215	279	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
216	280	cppad_internal_sparse_set = @cppad_internal_sparse_set@
217	281	cppad_libs = @cppad_libs@
218	282	cppad_max_num_threads = @cppad_max_num_threads@
219	283	cppad_requires = @cppad_requires@
220		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	284	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
221	285	cppad_stdvector = @cppad_stdvector@
222	286	cppad_tape_addr_type = @cppad_tape_addr_type@
223	287	cppad_tape_id_type = @cppad_tape_id_type@

229	293	dvidir = @dvidir@
230	294	eigen_prefix = @eigen_prefix@
231	295	exec_prefix = @exec_prefix@
232		have_ar = @have_ar@
233	296	have_pkg_config = @have_pkg_config@
	297	host = @host@
234	298	host_alias = @host_alias@
	299	host_cpu = @host_cpu@
	300	host_os = @host_os@
	301	host_vendor = @host_vendor@
235	302	htmldir = @htmldir@
236	303	includedir = @includedir@
237	304	infodir = @infodir@

324	391
325	392	clean-checkPROGRAMS:
326	393	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	394
327	395	test_more$(EXEEXT): $(test_more_OBJECTS) $(test_more_DEPENDENCIES) $(EXTRA_test_more_DEPENDENCIES)
328	396	@rm -f test_more$(EXEEXT)
329	397	$(AM_V_CXXLD)$(CXXLINK) $(test_more_OBJECTS) $(test_more_LDADD) $(LIBS)

341	409	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_more.Po@am__quote@
342	410
343	411	.cpp.o:
344		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
345		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	412	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	413	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	414	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
346	415	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
347	416	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
348	417	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
349	418
350	419	.cpp.obj:
351		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
352		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	420	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	421	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	422	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
353	423	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
354	424	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
355	425	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
356	426
357		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
358		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
359		unique=`for i in $$list; do \
360		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
361		done \| \
362		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
363		END { if (nonempty) { for (i in files) print i; }; }'`; \
364		mkid -fID $$unique
365		tags: TAGS
366
367		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
368		$(TAGS_FILES) $(LISP)
	427	ID: $(am__tagged_files)
	428	$(am__define_uniq_tagged_files); mkid -fID $$unique
	429	tags: tags-am
	430	TAGS: tags
	431
	432	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
369	433	set x; \
370	434	here=`pwd`; \
371		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
372		unique=`for i in $$list; do \
373		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
374		done \| \
375		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
376		END { if (nonempty) { for (i in files) print i; }; }'`; \
	435	$(am__define_uniq_tagged_files); \
377	436	shift; \
378	437	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
379	438	test -n "$$unique" \|\| unique=$$empty_fix; \

385	444	$$unique; \
386	445	fi; \
387	446	fi
388		ctags: CTAGS
389		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
390		$(TAGS_FILES) $(LISP)
391		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
392		unique=`for i in $$list; do \
393		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
394		done \| \
395		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
396		END { if (nonempty) { for (i in files) print i; }; }'`; \
	447	ctags: ctags-am
	448
	449	CTAGS: ctags
	450	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	451	$(am__define_uniq_tagged_files); \
397	452	test -z "$(CTAGS_ARGS)$$unique" \
398	453	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
399	454	$$unique

402	457	here=`$(am__cd) $(top_builddir) && pwd` \
403	458	&& $(am__cd) $(top_srcdir) \
404	459	&& gtags -i $(GTAGS_ARGS) "$$here"
	460	cscopelist: cscopelist-am
	461
	462	cscopelist-am: $(am__tagged_files)
	463	list='$(am__tagged_files)'; \
	464	case "$(srcdir)" in \
	465	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	466	*) sdir=$(subdir)/$(srcdir) ;; \
	467	esac; \
	468	for i in $$list; do \
	469	if test -f "$$i"; then \
	470	echo "$(subdir)/$$i"; \
	471	else \
	472	echo "$$sdir/$$i"; \
	473	fi; \
	474	done >> $(top_builddir)/cscope.files
405	475
406	476	distclean-tags:
407	477	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

542	612
543	613	.MAKE: check-am install-am install-strip
544	614
545		.PHONY: CTAGS GTAGS all all-am check check-am clean \
546		clean-checkPROGRAMS clean-generic ctags distclean \
547		distclean-compile distclean-generic distclean-tags distdir dvi \
548		dvi-am html html-am info info-am install install-am \
549		install-data install-data-am install-dvi install-dvi-am \
550		install-exec install-exec-am install-html install-html-am \
551		install-info install-info-am install-man install-pdf \
552		install-pdf-am install-ps install-ps-am install-strip \
553		installcheck installcheck-am installdirs maintainer-clean \
554		maintainer-clean-generic mostlyclean mostlyclean-compile \
555		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
556		uninstall-am
	615	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	616	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	617	distclean distclean-compile distclean-generic distclean-tags \
	618	distdir dvi dvi-am html html-am info info-am install \
	619	install-am install-data install-data-am install-dvi \
	620	install-dvi-am install-exec install-exec-am install-html \
	621	install-html-am install-info install-info-am install-man \
	622	install-pdf install-pdf-am install-ps install-ps-am \
	623	install-strip installcheck installcheck-am installdirs \
	624	maintainer-clean maintainer-clean-generic mostlyclean \
	625	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	626	tags tags-am uninstall uninstall-am
557	627
558	628
559	629	test: check

+271

-188

depcomp less more

0	0	#! /bin/sh
1	1	# depcomp - compile a program generating dependencies as side-effects
2	2
3		scriptversion=2012-03-27.16; # UTC
4
5		# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009, 2010,
6		# 2011, 2012 Free Software Foundation, Inc.
	3	scriptversion=2013-05-30.07; # UTC
	4
	5	# Copyright (C) 1999-2013 Free Software Foundation, Inc.
7	6
8	7	# This program is free software; you can redistribute it and/or modify
9	8	# it under the terms of the GNU General Public License as published by

27	26
28	27	case $1 in
29	28	'')
30		echo "$0: No command. Try '$0 --help' for more information." 1>&2
31		exit 1;
32		;;
	29	echo "$0: No command. Try '$0 --help' for more information." 1>&2
	30	exit 1;
	31	;;
33	32	-h \| --h*)
34	33	cat <<\EOF
35	34	Usage: depcomp [--help] [--version] PROGRAM [ARGS]

56	55	;;
57	56	esac
58	57
	58	# Get the directory component of the given path, and save it in the
	59	# global variables '$dir'. Note that this directory component will
	60	# be either empty or ending with a '/' character. This is deliberate.
	61	set_dir_from ()
	62	{
	63	case $1 in
	64	/) dir=`echo "$1" \| sed -e 's\|/[^/]*$\|/\|'`;;
	65	*) dir=;;
	66	esac
	67	}
	68
	69	# Get the suffix-stripped basename of the given path, and save it the
	70	# global variable '$base'.
	71	set_base_from ()
	72	{
	73	base=`echo "$1" \| sed -e 's\|^./\|\|' -e 's/\.[^.]$//'`
	74	}
	75
	76	# If no dependency file was actually created by the compiler invocation,
	77	# we still have to create a dummy depfile, to avoid errors with the
	78	# Makefile "include basename.Plo" scheme.
	79	make_dummy_depfile ()
	80	{
	81	echo "#dummy" > "$depfile"
	82	}
	83
	84	# Factor out some common post-processing of the generated depfile.
	85	# Requires the auxiliary global variable '$tmpdepfile' to be set.
	86	aix_post_process_depfile ()
	87	{
	88	# If the compiler actually managed to produce a dependency file,
	89	# post-process it.
	90	if test -f "$tmpdepfile"; then
	91	# Each line is of the form 'foo.o: dependency.h'.
	92	# Do two passes, one to just change these to
	93	# $object: dependency.h
	94	# and one to simply output
	95	# dependency.h:
	96	# which is needed to avoid the deleted-header problem.
	97	{ sed -e "s,^.\.[$lower]:,$object:," < "$tmpdepfile"
	98	sed -e "s,^.\.[$lower]:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
	99	} > "$depfile"
	100	rm -f "$tmpdepfile"
	101	else
	102	make_dummy_depfile
	103	fi
	104	}
	105
59	106	# A tabulation character.
60	107	tab=' '
61	108	# A newline character.
62	109	nl='
63	110	'
	111	# Character ranges might be problematic outside the C locale.
	112	# These definitions help.
	113	upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
	114	lower=abcdefghijklmnopqrstuvwxyz
	115	digits=0123456789
	116	alpha=${upper}${lower}
64	117
65	118	if test -z "$depmode" \|\| test -z "$source" \|\| test -z "$object"; then
66	119	echo "depcomp: Variables source, object and depmode must be set" 1>&2

73	126	tmpdepfile=${tmpdepfile-`echo "$depfile" \| sed 's/\.$[^.]*$$/.T\1/'`}
74	127
75	128	rm -f "$tmpdepfile"
	129
	130	# Avoid interferences from the environment.
	131	gccflag= dashmflag=
76	132
77	133	# Some modes work just like other modes, but use different flags. We
78	134	# parameterize here, but still list the modes in the big case below,

85	141	fi
86	142
87	143	if test "$depmode" = dashXmstdout; then
88		# This is just like dashmstdout with a different argument.
89		dashmflag=-xM
90		depmode=dashmstdout
	144	# This is just like dashmstdout with a different argument.
	145	dashmflag=-xM
	146	depmode=dashmstdout
91	147	fi
92	148
93	149	cygpath_u="cygpath -u -f -"
94	150	if test "$depmode" = msvcmsys; then
95		# This is just like msvisualcpp but w/o cygpath translation.
96		# Just convert the backslash-escaped backslashes to single forward
97		# slashes to satisfy depend.m4
98		cygpath_u='sed s,\\\\,/,g'
99		depmode=msvisualcpp
	151	# This is just like msvisualcpp but w/o cygpath translation.
	152	# Just convert the backslash-escaped backslashes to single forward
	153	# slashes to satisfy depend.m4
	154	cygpath_u='sed s,\\\\,/,g'
	155	depmode=msvisualcpp
100	156	fi
101	157
102	158	if test "$depmode" = msvc7msys; then
103		# This is just like msvc7 but w/o cygpath translation.
104		# Just convert the backslash-escaped backslashes to single forward
105		# slashes to satisfy depend.m4
106		cygpath_u='sed s,\\\\,/,g'
107		depmode=msvc7
	159	# This is just like msvc7 but w/o cygpath translation.
	160	# Just convert the backslash-escaped backslashes to single forward
	161	# slashes to satisfy depend.m4
	162	cygpath_u='sed s,\\\\,/,g'
	163	depmode=msvc7
108	164	fi
109	165
110	166	if test "$depmode" = xlc; then
111		# IBM C/C++ Compilers xlc/xlC can output gcc-like dependency informations.
112		gccflag=-qmakedep=gcc,-MF
113		depmode=gcc
	167	# IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
	168	gccflag=-qmakedep=gcc,-MF
	169	depmode=gcc
114	170	fi
115	171
116	172	case "$depmode" in

133	189	done
134	190	"$@"
135	191	stat=$?
136		if test $stat -eq 0; then :
137		else
	192	if test $stat -ne 0; then
138	193	rm -f "$tmpdepfile"
139	194	exit $stat
140	195	fi

142	197	;;
143	198
144	199	gcc)
	200	## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
	201	## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
	202	## (see the conditional assignment to $gccflag above).
145	203	## There are various ways to get dependency output from gcc. Here's
146	204	## why we pick this rather obscure method:
147	205	## - Don't want to use -MD because we'd like the dependencies to end
148	206	## up in a subdir. Having to rename by hand is ugly.
149	207	## (We might end up doing this anyway to support other compilers.)
150	208	## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
151		## -MM, not -M (despite what the docs say).
	209	## -MM, not -M (despite what the docs say). Also, it might not be
	210	## supported by the other compilers which use the 'gcc' depmode.
152	211	## - Using -M directly means running the compiler twice (even worse
153	212	## than renaming).
154	213	if test -z "$gccflag"; then

156	215	fi
157	216	"$@" -Wp,"$gccflag$tmpdepfile"
158	217	stat=$?
159		if test $stat -eq 0; then :
160		else
	218	if test $stat -ne 0; then
161	219	rm -f "$tmpdepfile"
162	220	exit $stat
163	221	fi
164	222	rm -f "$depfile"
165	223	echo "$object : \\" > "$depfile"
166		alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
167		## The second -e expression handles DOS-style file names with drive letters.
	224	# The second -e expression handles DOS-style file names with drive
	225	# letters.
168	226	sed -e 's/^[^:]*: / /' \
169	227	-e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
170	228	## This next piece of magic avoids the "deleted header file" problem.

173	231	## typically no way to rebuild the header). We avoid this by adding
174	232	## dummy dependencies for each header file. Too bad gcc doesn't do
175	233	## this for us directly.
176		tr ' ' "$nl" < "$tmpdepfile" \|
177	234	## Some versions of gcc put a space before the ':'. On the theory
178	235	## that the space means something, we add a space to the output as
179	236	## well. hp depmode also adds that space, but also prefixes the VPATH
180	237	## to the object. Take care to not repeat it in the output.
181	238	## Some versions of the HPUX 10.20 sed can't process this invocation
182	239	## correctly. Breaking it into two sed invocations is a workaround.
183		sed -e 's/^\\$//' -e '/^$/d' -e "s\|.*$object$\|\|" -e '/:$/d' \
184		\| sed -e 's/$/ :/' >> "$depfile"
	240	tr ' ' "$nl" < "$tmpdepfile" \
	241	\| sed -e 's/^\\$//' -e '/^$/d' -e "s\|.*$object$\|\|" -e '/:$/d' \
	242	\| sed -e 's/$/ :/' >> "$depfile"
185	243	rm -f "$tmpdepfile"
186	244	;;
187	245

199	257	"$@" -MDupdate "$tmpdepfile"
200	258	fi
201	259	stat=$?
202		if test $stat -eq 0; then :
203		else
	260	if test $stat -ne 0; then
204	261	rm -f "$tmpdepfile"
205	262	exit $stat
206	263	fi

208	265
209	266	if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
210	267	echo "$object : \\" > "$depfile"
211
212	268	# Clip off the initial element (the dependent). Don't try to be
213	269	# clever and replace this with sed code, as IRIX sed won't handle
214	270	# lines with more than a fixed number of characters (4096 in

216	272	# the IRIX cc adds comments like '#:fec' to the end of the
217	273	# dependency line.
218	274	tr ' ' "$nl" < "$tmpdepfile" \
219		\| sed -e 's/^.\.o://' -e 's/#.$//' -e '/^$/ d' \| \
220		tr "$nl" ' ' >> "$depfile"
	275	\| sed -e 's/^.\.o://' -e 's/#.$//' -e '/^$/ d' \
	276	\| tr "$nl" ' ' >> "$depfile"
221	277	echo >> "$depfile"
222
223	278	# The second pass generates a dummy entry for each header file.
224	279	tr ' ' "$nl" < "$tmpdepfile" \
225		\| sed -e 's/^.\.o://' -e 's/#.$//' -e '/^$/ d' -e 's/$/:/' \
226		>> "$depfile"
	280	\| sed -e 's/^.\.o://' -e 's/#.$//' -e '/^$/ d' -e 's/$/:/' \
	281	>> "$depfile"
227	282	else
228		# The sourcefile does not contain any dependencies, so just
229		# store a dummy comment line, to avoid errors with the Makefile
230		# "include basename.Plo" scheme.
231		echo "#dummy" > "$depfile"
	283	make_dummy_depfile
232	284	fi
233	285	rm -f "$tmpdepfile"
234	286	;;

246	298	# current directory. Also, the AIX compiler puts '$object:' at the
247	299	# start of each line; $object doesn't have directory information.
248	300	# Version 6 uses the directory in both cases.
249		dir=`echo "$object" \| sed -e 's\|/[^/]*$\|/\|'`
250		test "x$dir" = "x$object" && dir=
251		base=`echo "$object" \| sed -e 's\|^.*/\|\|' -e 's/\.o$//' -e 's/\.lo$//'`
	301	set_dir_from "$object"
	302	set_base_from "$object"
252	303	if test "$libtool" = yes; then
253	304	tmpdepfile1=$dir$base.u
254	305	tmpdepfile2=$base.u

261	312	"$@" -M
262	313	fi
263	314	stat=$?
264
265		if test $stat -eq 0; then :
266		else
	315	if test $stat -ne 0; then
267	316	rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
268	317	exit $stat
269	318	fi

272	321	do
273	322	test -f "$tmpdepfile" && break
274	323	done
275		if test -f "$tmpdepfile"; then
276		# Each line is of the form 'foo.o: dependent.h'.
277		# Do two passes, one to just change these to
278		# '$object: dependent.h' and one to simply 'dependent.h:'.
279		sed -e "s,^.\.[a-z]:,$object:," < "$tmpdepfile" > "$depfile"
280		sed -e 's,^.\.[a-z]:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
281		else
282		# The sourcefile does not contain any dependencies, so just
283		# store a dummy comment line, to avoid errors with the Makefile
284		# "include basename.Plo" scheme.
285		echo "#dummy" > "$depfile"
286		fi
	324	aix_post_process_depfile
	325	;;
	326
	327	tcc)
	328	# tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
	329	# FIXME: That version still under development at the moment of writing.
	330	# Make that this statement remains true also for stable, released
	331	# versions.
	332	# It will wrap lines (doesn't matter whether long or short) with a
	333	# trailing '\', as in:
	334	#
	335	# foo.o : \
	336	# foo.c \
	337	# foo.h \
	338	#
	339	# It will put a trailing '\' even on the last line, and will use leading
	340	# spaces rather than leading tabs (at least since its commit 0394caf7
	341	# "Emit spaces for -MD").
	342	"$@" -MD -MF "$tmpdepfile"
	343	stat=$?
	344	if test $stat -ne 0; then
	345	rm -f "$tmpdepfile"
	346	exit $stat
	347	fi
	348	rm -f "$depfile"
	349	# Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
	350	# We have to change lines of the first kind to '$object: \'.
	351	sed -e "s\|.*:\|$object :\|" < "$tmpdepfile" > "$depfile"
	352	# And for each line of the second kind, we have to emit a 'dep.h:'
	353	# dummy dependency, to avoid the deleted-header problem.
	354	sed -n -e 's\|^ $.$ *\\$\|\1:\|p' < "$tmpdepfile" >> "$depfile"
287	355	rm -f "$tmpdepfile"
288	356	;;
289	357
290		icc)
291		# Intel's C compiler anf tcc (Tiny C Compiler) understand '-MD -MF file'.
292		# However on
293		# $CC -MD -MF foo.d -c -o sub/foo.o sub/foo.c
294		# ICC 7.0 will fill foo.d with something like
295		# foo.o: sub/foo.c
296		# foo.o: sub/foo.h
297		# which is wrong. We want
298		# sub/foo.o: sub/foo.c
299		# sub/foo.o: sub/foo.h
300		# sub/foo.c:
301		# sub/foo.h:
302		# ICC 7.1 will output
	358	## The order of this option in the case statement is important, since the
	359	## shell code in configure will try each of these formats in the order
	360	## listed in this file. A plain '-MD' option would be understood by many
	361	## compilers, so we must ensure this comes after the gcc and icc options.
	362	pgcc)
	363	# Portland's C compiler understands '-MD'.
	364	# Will always output deps to 'file.d' where file is the root name of the
	365	# source file under compilation, even if file resides in a subdirectory.
	366	# The object file name does not affect the name of the '.d' file.
	367	# pgcc 10.2 will output
303	368	# foo.o: sub/foo.c sub/foo.h
304		# and will wrap long lines using '\':
	369	# and will wrap long lines using '\' :
305	370	# foo.o: sub/foo.c ... \
306	371	# sub/foo.h ... \
307	372	# ...
308		# tcc 0.9.26 (FIXME still under development at the moment of writing)
309		# will emit a similar output, but also prepend the continuation lines
310		# with horizontal tabulation characters.
311		"$@" -MD -MF "$tmpdepfile"
312		stat=$?
313		if test $stat -eq 0; then :
314		else
	373	set_dir_from "$object"
	374	# Use the source, not the object, to determine the base name, since
	375	# that's sadly what pgcc will do too.
	376	set_base_from "$source"
	377	tmpdepfile=$base.d
	378
	379	# For projects that build the same source file twice into different object
	380	# files, the pgcc approach of using the source file root name can cause
	381	# problems in parallel builds. Use a locking strategy to avoid stomping on
	382	# the same $tmpdepfile.
	383	lockdir=$base.d-lock
	384	trap "
	385	echo '$0: caught signal, cleaning up...' >&2
	386	rmdir '$lockdir'
	387	exit 1
	388	" 1 2 13 15
	389	numtries=100
	390	i=$numtries
	391	while test $i -gt 0; do
	392	# mkdir is a portable test-and-set.
	393	if mkdir "$lockdir" 2>/dev/null; then
	394	# This process acquired the lock.
	395	"$@" -MD
	396	stat=$?
	397	# Release the lock.
	398	rmdir "$lockdir"
	399	break
	400	else
	401	# If the lock is being held by a different process, wait
	402	# until the winning process is done or we timeout.
	403	while test -d "$lockdir" && test $i -gt 0; do
	404	sleep 1
	405	i=`expr $i - 1`
	406	done
	407	fi
	408	i=`expr $i - 1`
	409	done
	410	trap - 1 2 13 15
	411	if test $i -le 0; then
	412	echo "$0: failed to acquire lock after $numtries attempts" >&2
	413	echo "$0: check lockdir '$lockdir'" >&2
	414	exit 1
	415	fi
	416
	417	if test $stat -ne 0; then
315	418	rm -f "$tmpdepfile"
316	419	exit $stat
317	420	fi
318	421	rm -f "$depfile"
319		# Each line is of the form 'foo.o: dependent.h',
320		# or 'foo.o: dep1.h dep2.h \', or ' dep3.h dep4.h \'.
	422	# Each line is of the form `foo.o: dependent.h',
	423	# or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
321	424	# Do two passes, one to just change these to
322		# '$object: dependent.h' and one to simply 'dependent.h:'.
323		sed -e "s/^[ $tab][ $tab]/ /" -e "s,^[^:]:,$object :," \
324		< "$tmpdepfile" > "$depfile"
325		sed '
326		s/[ '"$tab"'][ '"$tab"']*/ /g
327		s/^ *//
328		s/ \\$//
329		s/^[^:]: //
330		/^$/d
331		/:$/d
332		s/$/ :/
333		' < "$tmpdepfile" >> "$depfile"
	425	# `$object: dependent.h' and one to simply `dependent.h:'.
	426	sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
	427	# Some versions of the HPUX 10.20 sed can't process this invocation
	428	# correctly. Breaking it into two sed invocations is a workaround.
	429	sed 's,^[^:]: $.$$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
	430	\| sed -e 's/$/ :/' >> "$depfile"
334	431	rm -f "$tmpdepfile"
335	432	;;
336	433

341	438	# 'foo.d', which lands next to the object file, wherever that
342	439	# happens to be.
343	440	# Much of this is similar to the tru64 case; see comments there.
344		dir=`echo "$object" \| sed -e 's\|/[^/]*$\|/\|'`
345		test "x$dir" = "x$object" && dir=
346		base=`echo "$object" \| sed -e 's\|^.*/\|\|' -e 's/\.o$//' -e 's/\.lo$//'`
	441	set_dir_from "$object"
	442	set_base_from "$object"
347	443	if test "$libtool" = yes; then
348	444	tmpdepfile1=$dir$base.d
349	445	tmpdepfile2=$dir.libs/$base.d

354	450	"$@" +Maked
355	451	fi
356	452	stat=$?
357		if test $stat -eq 0; then :
358		else
	453	if test $stat -ne 0; then
359	454	rm -f "$tmpdepfile1" "$tmpdepfile2"
360	455	exit $stat
361	456	fi

365	460	test -f "$tmpdepfile" && break
366	461	done
367	462	if test -f "$tmpdepfile"; then
368		sed -e "s,^.\.[a-z]:,$object:," "$tmpdepfile" > "$depfile"
	463	sed -e "s,^.\.[$lower]:,$object:," "$tmpdepfile" > "$depfile"
369	464	# Add 'dependent.h:' lines.
370	465	sed -ne '2,${
371		s/^ *//
372		s/ \\*$//
373		s/$/:/
374		p
375		}' "$tmpdepfile" >> "$depfile"
	466	s/^ *//
	467	s/ \\*$//
	468	s/$/:/
	469	p
	470	}' "$tmpdepfile" >> "$depfile"
376	471	else
377		echo "#dummy" > "$depfile"
	472	make_dummy_depfile
378	473	fi
379	474	rm -f "$tmpdepfile" "$tmpdepfile2"
380	475	;;
381	476
382	477	tru64)
383		# The Tru64 compiler uses -MD to generate dependencies as a side
384		# effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
385		# At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
386		# dependencies in 'foo.d' instead, so we check for that too.
387		# Subdirectories are respected.
388		dir=`echo "$object" \| sed -e 's\|/[^/]*$\|/\|'`
389		test "x$dir" = "x$object" && dir=
390		base=`echo "$object" \| sed -e 's\|^.*/\|\|' -e 's/\.o$//' -e 's/\.lo$//'`
391
392		if test "$libtool" = yes; then
393		# With Tru64 cc, shared objects can also be used to make a
394		# static library. This mechanism is used in libtool 1.4 series to
395		# handle both shared and static libraries in a single compilation.
396		# With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
397		#
398		# With libtool 1.5 this exception was removed, and libtool now
399		# generates 2 separate objects for the 2 libraries. These two
400		# compilations output dependencies in $dir.libs/$base.o.d and
401		# in $dir$base.o.d. We have to check for both files, because
402		# one of the two compilations can be disabled. We should prefer
403		# $dir$base.o.d over $dir.libs/$base.o.d because the latter is
404		# automatically cleaned when .libs/ is deleted, while ignoring
405		# the former would cause a distcleancheck panic.
406		tmpdepfile1=$dir.libs/$base.lo.d # libtool 1.4
407		tmpdepfile2=$dir$base.o.d # libtool 1.5
408		tmpdepfile3=$dir.libs/$base.o.d # libtool 1.5
409		tmpdepfile4=$dir.libs/$base.d # Compaq CCC V6.2-504
410		"$@" -Wc,-MD
411		else
412		tmpdepfile1=$dir$base.o.d
413		tmpdepfile2=$dir$base.d
414		tmpdepfile3=$dir$base.d
415		tmpdepfile4=$dir$base.d
416		"$@" -MD
417		fi
418
419		stat=$?
420		if test $stat -eq 0; then :
421		else
422		rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
423		exit $stat
424		fi
425
426		for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
427		do
428		test -f "$tmpdepfile" && break
429		done
430		if test -f "$tmpdepfile"; then
431		sed -e "s,^.\.[a-z]:,$object:," < "$tmpdepfile" > "$depfile"
432		sed -e 's,^.\.[a-z]:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
433		else
434		echo "#dummy" > "$depfile"
435		fi
436		rm -f "$tmpdepfile"
437		;;
	478	# The Tru64 compiler uses -MD to generate dependencies as a side
	479	# effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
	480	# At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
	481	# dependencies in 'foo.d' instead, so we check for that too.
	482	# Subdirectories are respected.
	483	set_dir_from "$object"
	484	set_base_from "$object"
	485
	486	if test "$libtool" = yes; then
	487	# Libtool generates 2 separate objects for the 2 libraries. These
	488	# two compilations output dependencies in $dir.libs/$base.o.d and
	489	# in $dir$base.o.d. We have to check for both files, because
	490	# one of the two compilations can be disabled. We should prefer
	491	# $dir$base.o.d over $dir.libs/$base.o.d because the latter is
	492	# automatically cleaned when .libs/ is deleted, while ignoring
	493	# the former would cause a distcleancheck panic.
	494	tmpdepfile1=$dir$base.o.d # libtool 1.5
	495	tmpdepfile2=$dir.libs/$base.o.d # Likewise.
	496	tmpdepfile3=$dir.libs/$base.d # Compaq CCC V6.2-504
	497	"$@" -Wc,-MD
	498	else
	499	tmpdepfile1=$dir$base.d
	500	tmpdepfile2=$dir$base.d
	501	tmpdepfile3=$dir$base.d
	502	"$@" -MD
	503	fi
	504
	505	stat=$?
	506	if test $stat -ne 0; then
	507	rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
	508	exit $stat
	509	fi
	510
	511	for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
	512	do
	513	test -f "$tmpdepfile" && break
	514	done
	515	# Same post-processing that is required for AIX mode.
	516	aix_post_process_depfile
	517	;;
438	518
439	519	msvc7)
440	520	if test "$libtool" = yes; then

445	525	"$@" $showIncludes > "$tmpdepfile"
446	526	stat=$?
447	527	grep -v '^Note: including file: ' "$tmpdepfile"
448		if test "$stat" = 0; then :
449		else
	528	if test $stat -ne 0; then
450	529	rm -f "$tmpdepfile"
451	530	exit $stat
452	531	fi

472	551	G
473	552	p
474	553	}' >> "$depfile"
	554	echo >> "$depfile" # make sure the fragment doesn't end with a backslash
475	555	rm -f "$tmpdepfile"
476	556	;;
477	557

523	603	# in the target name. This is to cope with DOS-style filenames:
524	604	# a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
525	605	"$@" $dashmflag \|
526		sed 's:^['"$tab"' ][^:'"$tab"' ][^:][^:]\:['"$tab"' ]*:'"$object"'\: :' > "$tmpdepfile"
	606	sed "s\|^[$tab ][^:$tab ][^:][^:]:[$tab ]*\|$object: \|" > "$tmpdepfile"
527	607	rm -f "$depfile"
528	608	cat < "$tmpdepfile" > "$depfile"
529		tr ' ' "$nl" < "$tmpdepfile" \| \
530		## Some versions of the HPUX 10.20 sed can't process this invocation
531		## correctly. Breaking it into two sed invocations is a workaround.
532		sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \| sed -e 's/$/ :/' >> "$depfile"
	609	# Some versions of the HPUX 10.20 sed can't process this sed invocation
	610	# correctly. Breaking it into two sed invocations is a workaround.
	611	tr ' ' "$nl" < "$tmpdepfile" \
	612	\| sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
	613	\| sed -e 's/$/ :/' >> "$depfile"
533	614	rm -f "$tmpdepfile"
534	615	;;
535	616

582	663	# makedepend may prepend the VPATH from the source file name to the object.
583	664	# No need to regex-escape $object, excess matching of '.' is harmless.
584	665	sed "s\|^.$$object :$\|\1\|" "$tmpdepfile" > "$depfile"
585		sed '1,2d' "$tmpdepfile" \| tr ' ' "$nl" \| \
586		## Some versions of the HPUX 10.20 sed can't process this invocation
587		## correctly. Breaking it into two sed invocations is a workaround.
588		sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \| sed -e 's/$/ :/' >> "$depfile"
	666	# Some versions of the HPUX 10.20 sed can't process the last invocation
	667	# correctly. Breaking it into two sed invocations is a workaround.
	668	sed '1,2d' "$tmpdepfile" \
	669	\| tr ' ' "$nl" \
	670	\| sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
	671	\| sed -e 's/$/ :/' >> "$depfile"
589	672	rm -f "$tmpdepfile" "$tmpdepfile".bak
590	673	;;
591	674

621	704	esac
622	705	done
623	706
624		"$@" -E \|
625		sed -n -e '/^# [0-9][0-9]* "$[^"]$"./ s:: \1 \\:p' \
626		-e '/^#line [0-9][0-9]* "$[^"]$"./ s:: \1 \\:p' \|
627		sed '$ s: \\$::' > "$tmpdepfile"
	707	"$@" -E \
	708	\| sed -n -e '/^# [0-9][0-9]* "$[^"]$"./ s:: \1 \\:p' \
	709	-e '/^#line [0-9][0-9]* "$[^"]$"./ s:: \1 \\:p' \
	710	\| sed '$ s: \\$::' > "$tmpdepfile"
628	711	rm -f "$depfile"
629	712	echo "$object : \\" > "$depfile"
630	713	cat < "$tmpdepfile" >> "$depfile"

656	739	shift
657	740	;;
658	741	"-Gm"\|"/Gm"\|"-Gi"\|"/Gi"\|"-ZI"\|"/ZI")
659		set fnord "$@"
660		shift
661		shift
662		;;
	742	set fnord "$@"
	743	shift
	744	shift
	745	;;
663	746	*)
664		set fnord "$@" "$arg"
665		shift
666		shift
667		;;
	747	set fnord "$@" "$arg"
	748	shift
	749	shift
	750	;;
668	751	esac
669	752	done
670	753	"$@" -E 2>/dev/null \|

-0

doc/__index_xml.js less more

45	45	'_index.xml#U',
46	46	'_index.xml#V',
47	47	'_index.xml#W',
	48	'_index.xml#X',
	49	'_index.xml#Y',
48	50	'_index.xml#Z'
49	51	];
50	52	function choose_across0(item)

-1

doc/_acosforward_xml.js less more

36	36	'atanforward.xml',
37	37	'asinforward.xml',
38	38	'acosforward.xml',
39		'tan_forward.xml'
	39	'tan_forward.xml',
	40	'erf_forward.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-1

doc/_acosreverse_xml.js less more

36	36	'atanreverse.xml',
37	37	'asinreverse.xml',
38	38	'acosreverse.xml',
39		'tan_reverse.xml'
	39	'tan_reverse.xml',
	40	'erf_reverse.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-1

doc/_adolc_prefix_xml.js less more

26	26	var list_down2 = [
27	27	'download.xml',
28	28	'cmake.xml',
29		'cppad_test.xml',
	29	'cmake_check.xml',
30	30	'pkgconfig.xml',
31	31	'installunix.xml'
32	32	];
33	33	var list_down1 = [
34	34	'adolc_prefix.xml',
	35	'colpack_prefix.xml',
35	36	'eigen_prefix.xml',
36	37	'fadbad_prefix.xml',
37	38	'ipopt_prefix.xml',

-1

doc/_asinforward_xml.js less more

36	36	'atanforward.xml',
37	37	'asinforward.xml',
38	38	'acosforward.xml',
39		'tan_forward.xml'
	39	'tan_forward.xml',
	40	'erf_forward.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-1

doc/_asinreverse_xml.js less more

36	36	'atanreverse.xml',
37	37	'asinreverse.xml',
38	38	'acosreverse.xml',
39		'tan_reverse.xml'
	39	'tan_reverse.xml',
	40	'erf_reverse.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-1

doc/_atanforward_xml.js less more

36	36	'atanforward.xml',
37	37	'asinforward.xml',
38	38	'acosforward.xml',
39		'tan_forward.xml'
	39	'tan_forward.xml',
	40	'erf_forward.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-1

doc/_atanreverse_xml.js less more

36	36	'atanreverse.xml',
37	37	'asinreverse.xml',
38	38	'acosreverse.xml',
39		'tan_reverse.xml'
	39	'tan_reverse.xml',
	40	'erf_reverse.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-0

doc/_atomic_afun_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-0

doc/_atomic_base_clear_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-0

doc/_atomic_base_xml.js less more

46	46	'atomic_norm_sq.cpp.xml',
47	47	'atomic_reciprocal.cpp.xml',
48	48	'atomic_tangent.cpp.xml',
	49	'atomic_hes_sparse.cpp.xml',
49	50	'atomic_mat_mul.cpp.xml'
50	51	];
51	52	var list_current0 = [

57	58	'atomic_base.xml#Examples.Getting Started',
58	59	'atomic_base.xml#Examples.Scalar Function',
59	60	'atomic_base.xml#Examples.Vector Range',
	61	'atomic_base.xml#Examples.Hessian Sparsity Patterns',
60	62	'atomic_base.xml#General Case'
61	63	];
62	64	function choose_across0(item)

-0

doc/_atomic_ctor_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-0

doc/_atomic_for_sparse_jac_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-1

doc/_atomic_forward_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [
44	45	'atomic_forward.xml#Syntax',
45	46	'atomic_forward.xml#Purpose',
46	47	'atomic_forward.xml#Implementation',
	48	'atomic_forward.xml#p',
47	49	'atomic_forward.xml#q',
48		'atomic_forward.xml#p',
49	50	'atomic_forward.xml#vx',
50	51	'atomic_forward.xml#vy',
51	52	'atomic_forward.xml#tx',

-0

doc/_atomic_get_started.cpp_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

+96

-0

doc/_atomic_hes_sparse.cpp_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'ad.xml',
	10	'advalued.xml',
	11	'atomic.xml',
	12	'atomic_base.xml',
	13	'atomic_hes_sparse.cpp.xml'
	14	];
	15	var list_down3 = [
	16	'arithmetic.xml',
	17	'std_math_ad.xml',
	18	'mathother.xml',
	19	'condexp.xml',
	20	'discrete.xml',
	21	'atomic.xml'
	22	];
	23	var list_down2 = [
	24	'checkpoint.xml',
	25	'atomic_base.xml'
	26	];
	27	var list_down1 = [
	28	'atomic_ctor.xml',
	29	'atomic_option.xml',
	30	'atomic_afun.xml',
	31	'atomic_forward.xml',
	32	'atomic_reverse.xml',
	33	'atomic_for_sparse_jac.xml',
	34	'atomic_rev_sparse_jac.xml',
	35	'atomic_rev_sparse_hes.xml',
	36	'atomic_base_clear.xml',
	37	'atomic_get_started.cpp.xml',
	38	'atomic_norm_sq.cpp.xml',
	39	'atomic_reciprocal.cpp.xml',
	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
	42	'atomic_mat_mul.cpp.xml'
	43	];
	44	var list_current0 = [
	45	'atomic_hes_sparse.cpp.xml#Purpose',
	46	'atomic_hes_sparse.cpp.xml#Start Class Definition',
	47	'atomic_hes_sparse.cpp.xml#Constructor',
	48	'atomic_hes_sparse.cpp.xml#forward',
	49	'atomic_hes_sparse.cpp.xml#for_sparse_jac',
	50	'atomic_hes_sparse.cpp.xml#rev_sparse_hes',
	51	'atomic_hes_sparse.cpp.xml#Use Atomic Function',
	52	'atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter'
	53	];
	54	function choose_across0(item)
	55	{ var index = item.selectedIndex;
	56	item.selectedIndex = 0;
	57	if(index > 0)
	58	document.location = list_across0[index-1];
	59	}
	60	function choose_up0(item)
	61	{ var index = item.selectedIndex;
	62	item.selectedIndex = 0;
	63	if(index > 0)
	64	document.location = list_up0[index-1];
	65	}
	66	function choose_down3(item)
	67	{ var index = item.selectedIndex;
	68	item.selectedIndex = 0;
	69	if(index > 0)
	70	document.location = list_down3[index-1];
	71	}
	72	function choose_down2(item)
	73	{ var index = item.selectedIndex;
	74	item.selectedIndex = 0;
	75	if(index > 0)
	76	document.location = list_down2[index-1];
	77	}
	78	function choose_down1(item)
	79	{ var index = item.selectedIndex;
	80	item.selectedIndex = 0;
	81	if(index > 0)
	82	document.location = list_down1[index-1];
	83	}
	84	function choose_down0(item)
	85	{ var index = item.selectedIndex;
	86	item.selectedIndex = 0;
	87	if(index > 0)
	88	document.location = list_down0[index-1];
	89	}
	90	function choose_current0(item)
	91	{ var index = item.selectedIndex;
	92	item.selectedIndex = 0;
	93	if(index > 0)
	94	document.location = list_current0[index-1];
	95	}

-0

doc/_atomic_mat_mul.cpp_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_down0 = [

-0

doc/_atomic_matrix_mul.hpp_xml.js less more

31	31	'atomic_norm_sq.cpp.xml',
32	32	'atomic_reciprocal.cpp.xml',
33	33	'atomic_tangent.cpp.xml',
	34	'atomic_hes_sparse.cpp.xml',
34	35	'atomic_mat_mul.cpp.xml'
35	36	];
36	37	var list_down1 = [

-0

doc/_atomic_norm_sq.cpp_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-0

doc/_atomic_option_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-0

doc/_atomic_reciprocal.cpp_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-0

doc/_atomic_rev_sparse_hes_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-0

doc/_atomic_rev_sparse_jac_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-1

doc/_atomic_reverse_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [
44	45	'atomic_reverse.xml#Syntax',
45	46	'atomic_reverse.xml#Purpose',
46	47	'atomic_reverse.xml#Implementation',
47		'atomic_reverse.xml#p',
	48	'atomic_reverse.xml#q',
48	49	'atomic_reverse.xml#tx',
49	50	'atomic_reverse.xml#ty',
50	51	'atomic_reverse.xml#F, G, H',

-0

doc/_atomic_tangent.cpp_xml.js less more

38	38	'atomic_norm_sq.cpp.xml',
39	39	'atomic_reciprocal.cpp.xml',
40	40	'atomic_tangent.cpp.xml',
	41	'atomic_hes_sparse.cpp.xml',
41	42	'atomic_mat_mul.cpp.xml'
42	43	];
43	44	var list_current0 = [

-0

doc/_base_adolc.hpp_xml.js less more

49	49	'base_adolc.hpp.xml#Integer',
50	50	'base_adolc.hpp.xml#Ordered',
51	51	'base_adolc.hpp.xml#Unary Standard Math',
	52	'base_adolc.hpp.xml#erf',
52	53	'base_adolc.hpp.xml#sign',
53	54	'base_adolc.hpp.xml#abs',
54	55	'base_adolc.hpp.xml#pow',

-0

doc/_base_alloc.hpp_xml.js less more

51	51	'base_alloc.hpp.xml#Integer',
52	52	'base_alloc.hpp.xml#Ordered',
53	53	'base_alloc.hpp.xml#Unary Standard Math',
	54	'base_alloc.hpp.xml#erf',
54	55	'base_alloc.hpp.xml#sign',
55	56	'base_alloc.hpp.xml#pow',
56	57	'base_alloc.hpp.xml#limits'

-0

doc/_base_complex.hpp_xml.js less more

49	49	'base_complex.hpp.xml#EqualOpSeq',
50	50	'base_complex.hpp.xml#Identical',
51	51	'base_complex.hpp.xml#Ordered',
	52	'base_complex.hpp.xml#erf',
52	53	'base_complex.hpp.xml#Integer',
53	54	'base_complex.hpp.xml#isnan',
54	55	'base_complex.hpp.xml#Valid Unary Math',

-0

doc/_base_std_math_xml.js less more

44	44	'base_std_math.xml#Purpose',
45	45	'base_std_math.xml#Unary Standard Math',
46	46	'base_std_math.xml#CPPAD_STANDARD_MATH_UNARY',
	47	'base_std_math.xml#erf',
47	48	'base_std_math.xml#sign',
48	49	'base_std_math.xml#pow',
49	50	'base_std_math.xml#isnan',

+76

-0

doc/_capacity_order.cpp_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'capacity_order.xml',
	13	'capacity_order.cpp.xml'
	14	];
	15	var list_down3 = [
	16	'forward.xml',
	17	'reverse.xml',
	18	'sparse.xml'
	19	];
	20	var list_down2 = [
	21	'forward_zero.xml',
	22	'forward_one.xml',
	23	'forward_two.xml',
	24	'forward_order.xml',
	25	'forward_dir.xml',
	26	'size_order.xml',
	27	'comparechange.xml',
	28	'capacity_order.xml',
	29	'number_skip.xml'
	30	];
	31	var list_down1 = [
	32	'capacity_order.cpp.xml'
	33	];
	34	function choose_across0(item)
	35	{ var index = item.selectedIndex;
	36	item.selectedIndex = 0;
	37	if(index > 0)
	38	document.location = list_across0[index-1];
	39	}
	40	function choose_up0(item)
	41	{ var index = item.selectedIndex;
	42	item.selectedIndex = 0;
	43	if(index > 0)
	44	document.location = list_up0[index-1];
	45	}
	46	function choose_down3(item)
	47	{ var index = item.selectedIndex;
	48	item.selectedIndex = 0;
	49	if(index > 0)
	50	document.location = list_down3[index-1];
	51	}
	52	function choose_down2(item)
	53	{ var index = item.selectedIndex;
	54	item.selectedIndex = 0;
	55	if(index > 0)
	56	document.location = list_down2[index-1];
	57	}
	58	function choose_down1(item)
	59	{ var index = item.selectedIndex;
	60	item.selectedIndex = 0;
	61	if(index > 0)
	62	document.location = list_down1[index-1];
	63	}
	64	function choose_down0(item)
	65	{ var index = item.selectedIndex;
	66	item.selectedIndex = 0;
	67	if(index > 0)
	68	document.location = list_down0[index-1];
	69	}
	70	function choose_current0(item)
	71	{ var index = item.selectedIndex;
	72	item.selectedIndex = 0;
	73	if(index > 0)
	74	document.location = list_current0[index-1];
	75	}

+98

-0

doc/_capacity_order_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'capacity_order.xml'
	13	];
	14	var list_down3 = [
	15	'independent.xml',
	16	'funconstruct.xml',
	17	'dependent.xml',
	18	'abort_recording.xml',
	19	'seq_property.xml',
	20	'funeval.xml',
	21	'drivers.xml',
	22	'funcheck.xml',
	23	'optimize.xml',
	24	'check_for_nan.xml'
	25	];
	26	var list_down2 = [
	27	'forward.xml',
	28	'reverse.xml',
	29	'sparse.xml'
	30	];
	31	var list_down1 = [
	32	'forward_zero.xml',
	33	'forward_one.xml',
	34	'forward_two.xml',
	35	'forward_order.xml',
	36	'forward_dir.xml',
	37	'size_order.xml',
	38	'comparechange.xml',
	39	'capacity_order.xml',
	40	'number_skip.xml'
	41	];
	42	var list_down0 = [
	43	'capacity_order.cpp.xml'
	44	];
	45	var list_current0 = [
	46	'capacity_order.xml#Syntax',
	47	'capacity_order.xml#Syntax.See Also',
	48	'capacity_order.xml#Purpose',
	49	'capacity_order.xml#f',
	50	'capacity_order.xml#c',
	51	'capacity_order.xml#c.Pre-Allocating Memory',
	52	'capacity_order.xml#c.Freeing Memory',
	53	'capacity_order.xml#Original State',
	54	'capacity_order.xml#Example'
	55	];
	56	function choose_across0(item)
	57	{ var index = item.selectedIndex;
	58	item.selectedIndex = 0;
	59	if(index > 0)
	60	document.location = list_across0[index-1];
	61	}
	62	function choose_up0(item)
	63	{ var index = item.selectedIndex;
	64	item.selectedIndex = 0;
	65	if(index > 0)
	66	document.location = list_up0[index-1];
	67	}
	68	function choose_down3(item)
	69	{ var index = item.selectedIndex;
	70	item.selectedIndex = 0;
	71	if(index > 0)
	72	document.location = list_down3[index-1];
	73	}
	74	function choose_down2(item)
	75	{ var index = item.selectedIndex;
	76	item.selectedIndex = 0;
	77	if(index > 0)
	78	document.location = list_down2[index-1];
	79	}
	80	function choose_down1(item)
	81	{ var index = item.selectedIndex;
	82	item.selectedIndex = 0;
	83	if(index > 0)
	84	document.location = list_down1[index-1];
	85	}
	86	function choose_down0(item)
	87	{ var index = item.selectedIndex;
	88	item.selectedIndex = 0;
	89	if(index > 0)
	90	document.location = list_down0[index-1];
	91	}
	92	function choose_current0(item)
	93	{ var index = item.selectedIndex;
	94	item.selectedIndex = 0;
	95	if(index > 0)
	96	document.location = list_current0[index-1];
	97	}

-76

~~doc/_capacity_taylor.cpp_xml.js~~ less more

0		var list_across0 = [
1		'_contents_xml.htm',
2		'_reference.xml',
3		'_index.xml',
4		'_search_xml.htm',
5		'_external.xml'
6		];
7		var list_up0 = [
8		'cppad.xml',
9		'adfun.xml',
10		'funeval.xml',
11		'forward.xml',
12		'capacity_taylor.xml',
13		'capacity_taylor.cpp.xml'
14		];
15		var list_down3 = [
16		'forward.xml',
17		'reverse.xml',
18		'sparse.xml'
19		];
20		var list_down2 = [
21		'forwardzero.xml',
22		'forwardone.xml',
23		'forwardany.xml',
24		'size_taylor.xml',
25		'comparechange.xml',
26		'capacity_taylor.xml',
27		'number_skip.xml',
28		'forward.cpp.xml',
29		'forward_mul.cpp.xml'
30		];
31		var list_down1 = [
32		'capacity_taylor.cpp.xml'
33		];
34		function choose_across0(item)
35		{ var index = item.selectedIndex;
36		item.selectedIndex = 0;
37		if(index > 0)
38		document.location = list_across0[index-1];
39		}
40		function choose_up0(item)
41		{ var index = item.selectedIndex;
42		item.selectedIndex = 0;
43		if(index > 0)
44		document.location = list_up0[index-1];
45		}
46		function choose_down3(item)
47		{ var index = item.selectedIndex;
48		item.selectedIndex = 0;
49		if(index > 0)
50		document.location = list_down3[index-1];
51		}
52		function choose_down2(item)
53		{ var index = item.selectedIndex;
54		item.selectedIndex = 0;
55		if(index > 0)
56		document.location = list_down2[index-1];
57		}
58		function choose_down1(item)
59		{ var index = item.selectedIndex;
60		item.selectedIndex = 0;
61		if(index > 0)
62		document.location = list_down1[index-1];
63		}
64		function choose_down0(item)
65		{ var index = item.selectedIndex;
66		item.selectedIndex = 0;
67		if(index > 0)
68		document.location = list_down0[index-1];
69		}
70		function choose_current0(item)
71		{ var index = item.selectedIndex;
72		item.selectedIndex = 0;
73		if(index > 0)
74		document.location = list_current0[index-1];
75		}

-98

~~doc/_capacity_taylor_xml.js~~ less more

0		var list_across0 = [
1		'_contents_xml.htm',
2		'_reference.xml',
3		'_index.xml',
4		'_search_xml.htm',
5		'_external.xml'
6		];
7		var list_up0 = [
8		'cppad.xml',
9		'adfun.xml',
10		'funeval.xml',
11		'forward.xml',
12		'capacity_taylor.xml'
13		];
14		var list_down3 = [
15		'independent.xml',
16		'funconstruct.xml',
17		'dependent.xml',
18		'abort_recording.xml',
19		'seq_property.xml',
20		'funeval.xml',
21		'drivers.xml',
22		'funcheck.xml',
23		'optimize.xml',
24		'check_for_nan.xml'
25		];
26		var list_down2 = [
27		'forward.xml',
28		'reverse.xml',
29		'sparse.xml'
30		];
31		var list_down1 = [
32		'forwardzero.xml',
33		'forwardone.xml',
34		'forwardany.xml',
35		'size_taylor.xml',
36		'comparechange.xml',
37		'capacity_taylor.xml',
38		'number_skip.xml',
39		'forward.cpp.xml',
40		'forward_mul.cpp.xml'
41		];
42		var list_down0 = [
43		'capacity_taylor.cpp.xml'
44		];
45		var list_current0 = [
46		'capacity_taylor.xml#Syntax',
47		'capacity_taylor.xml#Syntax.See Also',
48		'capacity_taylor.xml#Purpose',
49		'capacity_taylor.xml#f',
50		'capacity_taylor.xml#c',
51		'capacity_taylor.xml#c.Pre-Allocating Memory',
52		'capacity_taylor.xml#c.Freeing Memory',
53		'capacity_taylor.xml#Original State',
54		'capacity_taylor.xml#Example'
55		];
56		function choose_across0(item)
57		{ var index = item.selectedIndex;
58		item.selectedIndex = 0;
59		if(index > 0)
60		document.location = list_across0[index-1];
61		}
62		function choose_up0(item)
63		{ var index = item.selectedIndex;
64		item.selectedIndex = 0;
65		if(index > 0)
66		document.location = list_up0[index-1];
67		}
68		function choose_down3(item)
69		{ var index = item.selectedIndex;
70		item.selectedIndex = 0;
71		if(index > 0)
72		document.location = list_down3[index-1];
73		}
74		function choose_down2(item)
75		{ var index = item.selectedIndex;
76		item.selectedIndex = 0;
77		if(index > 0)
78		document.location = list_down2[index-1];
79		}
80		function choose_down1(item)
81		{ var index = item.selectedIndex;
82		item.selectedIndex = 0;
83		if(index > 0)
84		document.location = list_down1[index-1];
85		}
86		function choose_down0(item)
87		{ var index = item.selectedIndex;
88		item.selectedIndex = 0;
89		if(index > 0)
90		document.location = list_down0[index-1];
91		}
92		function choose_current0(item)
93		{ var index = item.selectedIndex;
94		item.selectedIndex = 0;
95		if(index > 0)
96		document.location = list_current0[index-1];
97		}

-0

doc/_check_for_nan_xml.js less more

42	42	'check_for_nan.xml#Purpose',
43	43	'check_for_nan.xml#f',
44	44	'check_for_nan.xml#b',
	45	'check_for_nan.xml#Default',
45	46	'check_for_nan.xml#Example'
46	47	];
47	48	function choose_across0(item)

+73

-0

doc/_cmake_check_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'install.xml',
	10	'cmake_check.xml'
	11	];
	12	var list_down2 = [
	13	'install.xml',
	14	'introduction.xml',
	15	'ad.xml',
	16	'adfun.xml',
	17	'preprocessor.xml',
	18	'multi_thread.xml',
	19	'library.xml',
	20	'ipopt_solve.xml',
	21	'example.xml',
	22	'speed.xml',
	23	'appendix.xml'
	24	];
	25	var list_down1 = [
	26	'download.xml',
	27	'cmake.xml',
	28	'cmake_check.xml',
	29	'pkgconfig.xml',
	30	'installunix.xml'
	31	];
	32	var list_current0 = [
	33	'cmake_check.xml#Purpose',
	34	'cmake_check.xml#Check All',
	35	'cmake_check.xml#Subsets'
	36	];
	37	function choose_across0(item)
	38	{ var index = item.selectedIndex;
	39	item.selectedIndex = 0;
	40	if(index > 0)
	41	document.location = list_across0[index-1];
	42	}
	43	function choose_up0(item)
	44	{ var index = item.selectedIndex;
	45	item.selectedIndex = 0;
	46	if(index > 0)
	47	document.location = list_up0[index-1];
	48	}
	49	function choose_down2(item)
	50	{ var index = item.selectedIndex;
	51	item.selectedIndex = 0;
	52	if(index > 0)
	53	document.location = list_down2[index-1];
	54	}
	55	function choose_down1(item)
	56	{ var index = item.selectedIndex;
	57	item.selectedIndex = 0;
	58	if(index > 0)
	59	document.location = list_down1[index-1];
	60	}
	61	function choose_down0(item)
	62	{ var index = item.selectedIndex;
	63	item.selectedIndex = 0;
	64	if(index > 0)
	65	document.location = list_down0[index-1];
	66	}
	67	function choose_current0(item)
	68	{ var index = item.selectedIndex;
	69	item.selectedIndex = 0;
	70	if(index > 0)
	71	document.location = list_current0[index-1];
	72	}

-2

doc/_cmake_xml.js less more

25	25	var list_down1 = [
26	26	'download.xml',
27	27	'cmake.xml',
28		'cppad_test.xml',
	28	'cmake_check.xml',
29	29	'pkgconfig.xml',
30	30	'installunix.xml'
31	31	];
32	32	var list_down0 = [
33	33	'adolc_prefix.xml',
	34	'colpack_prefix.xml',
34	35	'eigen_prefix.xml',
35	36	'fadbad_prefix.xml',
36	37	'ipopt_prefix.xml',

40	41	var list_current0 = [
41	42	'cmake.xml#The CMake Program',
42	43	'cmake.xml#CMake Command',
	44	'cmake.xml#CMake Command.Build Directory',
43	45	'cmake.xml#generator',
44	46	'cmake.xml#cmake_install_prefix',
45	47	'cmake.xml#cmake_install_includedirs',
46	48	'cmake.xml#cmake_install_datadir',
	49	'cmake.xml#cmake_install_docdir',
47	50	'cmake.xml#cmake_install_libdirs',
48	51	'cmake.xml#cmake_install_postfix',
49	52	'cmake.xml#package_prefix',
50	53	'cmake.xml#cppad_cxx_flags',
51		'cmake.xml#cppad_documentation',
52	54	'cmake.xml#cppad_testvector',
53	55	'cmake.xml#cppad_max_num_threads',
54	56	'cmake.xml#cppad_sparse_list',
55	57	'cmake.xml#cppad_tape_id_type',
	58	'cmake.xml#cppad_tape_id_type.cstdint',
56	59	'cmake.xml#cppad_tape_addr_type',
	60	'cmake.xml#cppad_tape_addr_type.cstdint',
57	61	'cmake.xml#cppad_implicit_ctor_from_any_type'
58	62	];
59	63	function choose_across0(item)

+76

-0

doc/_colpack.cpp_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'install.xml',
	10	'cmake.xml',
	11	'colpack_prefix.xml',
	12	'colpack.cpp.xml'
	13	];
	14	var list_down3 = [
	15	'download.xml',
	16	'cmake.xml',
	17	'cmake_check.xml',
	18	'pkgconfig.xml',
	19	'installunix.xml'
	20	];
	21	var list_down2 = [
	22	'adolc_prefix.xml',
	23	'colpack_prefix.xml',
	24	'eigen_prefix.xml',
	25	'fadbad_prefix.xml',
	26	'ipopt_prefix.xml',
	27	'sacado_prefix.xml',
	28	'cppad_testvector.xml'
	29	];
	30	var list_down1 = [
	31	'colpack.cpp.xml',
	32	'get_colpack.sh.xml'
	33	];
	34	function choose_across0(item)
	35	{ var index = item.selectedIndex;
	36	item.selectedIndex = 0;
	37	if(index > 0)
	38	document.location = list_across0[index-1];
	39	}
	40	function choose_up0(item)
	41	{ var index = item.selectedIndex;
	42	item.selectedIndex = 0;
	43	if(index > 0)
	44	document.location = list_up0[index-1];
	45	}
	46	function choose_down3(item)
	47	{ var index = item.selectedIndex;
	48	item.selectedIndex = 0;
	49	if(index > 0)
	50	document.location = list_down3[index-1];
	51	}
	52	function choose_down2(item)
	53	{ var index = item.selectedIndex;
	54	item.selectedIndex = 0;
	55	if(index > 0)
	56	document.location = list_down2[index-1];
	57	}
	58	function choose_down1(item)
	59	{ var index = item.selectedIndex;
	60	item.selectedIndex = 0;
	61	if(index > 0)
	62	document.location = list_down1[index-1];
	63	}
	64	function choose_down0(item)
	65	{ var index = item.selectedIndex;
	66	item.selectedIndex = 0;
	67	if(index > 0)
	68	document.location = list_down0[index-1];
	69	}
	70	function choose_current0(item)
	71	{ var index = item.selectedIndex;
	72	item.selectedIndex = 0;
	73	if(index > 0)
	74	document.location = list_current0[index-1];
	75	}

+95

-0

doc/_colpack_prefix_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'install.xml',
	10	'cmake.xml',
	11	'colpack_prefix.xml'
	12	];
	13	var list_down3 = [
	14	'install.xml',
	15	'introduction.xml',
	16	'ad.xml',
	17	'adfun.xml',
	18	'preprocessor.xml',
	19	'multi_thread.xml',
	20	'library.xml',
	21	'ipopt_solve.xml',
	22	'example.xml',
	23	'speed.xml',
	24	'appendix.xml'
	25	];
	26	var list_down2 = [
	27	'download.xml',
	28	'cmake.xml',
	29	'cmake_check.xml',
	30	'pkgconfig.xml',
	31	'installunix.xml'
	32	];
	33	var list_down1 = [
	34	'adolc_prefix.xml',
	35	'colpack_prefix.xml',
	36	'eigen_prefix.xml',
	37	'fadbad_prefix.xml',
	38	'ipopt_prefix.xml',
	39	'sacado_prefix.xml',
	40	'cppad_testvector.xml'
	41	];
	42	var list_down0 = [
	43	'colpack.cpp.xml',
	44	'get_colpack.sh.xml'
	45	];
	46	var list_current0 = [
	47	'colpack_prefix.xml#Purpose',
	48	'colpack_prefix.xml#colpack_prefix',
	49	'colpack_prefix.xml#cppad_colpack.cpp',
	50	'colpack_prefix.xml#Example',
	51	'colpack_prefix.xml#get_colpack'
	52	];
	53	function choose_across0(item)
	54	{ var index = item.selectedIndex;
	55	item.selectedIndex = 0;
	56	if(index > 0)
	57	document.location = list_across0[index-1];
	58	}
	59	function choose_up0(item)
	60	{ var index = item.selectedIndex;
	61	item.selectedIndex = 0;
	62	if(index > 0)
	63	document.location = list_up0[index-1];
	64	}
	65	function choose_down3(item)
	66	{ var index = item.selectedIndex;
	67	item.selectedIndex = 0;
	68	if(index > 0)
	69	document.location = list_down3[index-1];
	70	}
	71	function choose_down2(item)
	72	{ var index = item.selectedIndex;
	73	item.selectedIndex = 0;
	74	if(index > 0)
	75	document.location = list_down2[index-1];
	76	}
	77	function choose_down1(item)
	78	{ var index = item.selectedIndex;
	79	item.selectedIndex = 0;
	80	if(index > 0)
	81	document.location = list_down1[index-1];
	82	}
	83	function choose_down0(item)
	84	{ var index = item.selectedIndex;
	85	item.selectedIndex = 0;
	86	if(index > 0)
	87	document.location = list_down0[index-1];
	88	}
	89	function choose_current0(item)
	90	{ var index = item.selectedIndex;
	91	item.selectedIndex = 0;
	92	if(index > 0)
	93	document.location = list_current0[index-1];
	94	}

-8

doc/_compare_change.cpp_xml.js less more

18	18	'sparse.xml'
19	19	];
20	20	var list_down2 = [
21		'forwardzero.xml',
22		'forwardone.xml',
23		'forwardany.xml',
24		'size_taylor.xml',
	21	'forward_zero.xml',
	22	'forward_one.xml',
	23	'forward_two.xml',
	24	'forward_order.xml',
	25	'forward_dir.xml',
	26	'size_order.xml',
25	27	'comparechange.xml',
26		'capacity_taylor.xml',
27		'number_skip.xml',
28		'forward.cpp.xml',
29		'forward_mul.cpp.xml'
	28	'capacity_order.xml',
	29	'number_skip.xml'
30	30	];
31	31	var list_down1 = [
32	32	'compare_change.cpp.xml'

-8

doc/_comparechange_xml.js less more

29	29	'sparse.xml'
30	30	];
31	31	var list_down1 = [
32		'forwardzero.xml',
33		'forwardone.xml',
34		'forwardany.xml',
35		'size_taylor.xml',
	32	'forward_zero.xml',
	33	'forward_one.xml',
	34	'forward_two.xml',
	35	'forward_order.xml',
	36	'forward_dir.xml',
	37	'size_order.xml',
36	38	'comparechange.xml',
37		'capacity_taylor.xml',
38		'number_skip.xml',
39		'forward.cpp.xml',
40		'forward_mul.cpp.xml'
	39	'capacity_order.xml',
	40	'number_skip.xml'
41	41	];
42	42	var list_down0 = [
43	43	'compare_change.cpp.xml'

-1

doc/_contents.js less more

0	0	var Cookie = document.cookie;
1	1	var Open = '';
2		var SectionCount = 540 ;
	2	var SectionCount = 548 ;
3	3	var ImagesInitialized = false;
4	4	Children = new Array();
5	5	Initialize();

+1171

-1138

doc/_contents_xml.htm less more

0	0	<html>
1	1	<head>
2	2	<title>Table of Contents</title>
	3	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
3	4	<meta name="description" id="description" content="Table of Contents"/>
4	5	<style type='text/css'>
5	6	body { color : black }

62	63	onmouseover='MouseOver(1)'
63	64	onmouseout='MouseOut(1)'
64	65	><img src='_close.gif' name='folder1' align='middle' />
65		<u>cppad-20140000.3: A Package for Differentiation of C++ Algorithms</u></a>
	66	<u>cppad-20150000.0: A Package for Differentiation of C++ Algorithms</u></a>
66	67
67	68	<span id='children1'>
68		<br/><a href="cppad.xml" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms</a>
	69	<br/><a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a>
69	70
70	71	<br/>    <a href="_contents_xml.htm" target="_top">Table of Contents</a>
71	72

98	99	<span id='children6'>
99	100	<br/>            <a href="adolc_prefix.xml" target="_top">Including the ADOL-C Examples and Tests</a>
100	101
101		<br/>                <a onclick='Select(7)'
102		onmouseover='MouseOver(7)'
103		onmouseout='MouseOut(7)'
104		><img src='_close.gif' name='folder7' align='middle' />
105		<u>Download and Install Adolc in Build Directory</u></a>
106
107		<span id='children7'>
108	102	<br/>                <a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a>
109
110		<br/>                    <a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a>
111		</span>
112		</span>
113
114		<br/>            <a onclick='Select(9)'
115		onmouseover='MouseOver(9)'
116		onmouseout='MouseOut(9)'
117		><img src='_close.gif' name='folder9' align='middle' />
118		<u>Including the Eigen Examples and Tests</u></a>
119
120		<span id='children9'>
121		<br/>            <a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a>
122
123		<br/>                <a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a>
	103	</span>
	104
	105	<br/>            <a onclick='Select(8)'
	106	onmouseover='MouseOver(8)'
	107	onmouseout='MouseOut(8)'
	108	><img src='_close.gif' name='folder8' align='middle' />
	109	<u>Including the ColPack Sparsity Calculations</u></a>
	110
	111	<span id='children8'>
	112	<br/>            <a href="colpack_prefix.xml" target="_top">Including the ColPack Sparsity Calculations</a>
	113
	114	<br/>                <a href="colpack.cpp.xml" target="_top">Using ColPack: Example and Test</a>
	115
	116	<br/>                <a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a>
124	117	</span>
125	118
126	119	<br/>            <a onclick='Select(11)'
127	120	onmouseover='MouseOver(11)'
128	121	onmouseout='MouseOut(11)'
129	122	><img src='_close.gif' name='folder11' align='middle' />
130		<u>Including the FADBAD Speed Tests</u></a>
	123	<u>Including the Eigen Examples and Tests</u></a>
131	124
132	125	<span id='children11'>
133		<br/>            <a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a>
134
135		<br/>                <a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a>
	126	<br/>            <a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a>
	127
	128	<br/>                <a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a>
136	129	</span>
137	130
138	131	<br/>            <a onclick='Select(13)'
139	132	onmouseover='MouseOver(13)'
140	133	onmouseout='MouseOut(13)'
141	134	><img src='_close.gif' name='folder13' align='middle' />
142		<u>Including the cppad_ipopt Library and Tests</u></a>
	135	<u>Including the FADBAD Speed Tests</u></a>
143	136
144	137	<span id='children13'>
145		<br/>            <a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a>
146
147		<br/>                <a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a>
	138	<br/>            <a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a>
	139
	140	<br/>                <a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a>
148	141	</span>
149	142
150	143	<br/>            <a onclick='Select(15)'
151	144	onmouseover='MouseOver(15)'
152	145	onmouseout='MouseOut(15)'
153	146	><img src='_close.gif' name='folder15' align='middle' />
	147	<u>Including the cppad_ipopt Library and Tests</u></a>
	148
	149	<span id='children15'>
	150	<br/>            <a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a>
	151
	152	<br/>                <a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a>
	153	</span>
	154
	155	<br/>            <a onclick='Select(17)'
	156	onmouseover='MouseOver(17)'
	157	onmouseout='MouseOut(17)'
	158	><img src='_close.gif' name='folder17' align='middle' />
154	159	<u>Including the Sacado Speed Tests</u></a>
155	160
156		<span id='children15'>
	161	<span id='children17'>
157	162	<br/>            <a href="sacado_prefix.xml" target="_top">Including the Sacado Speed Tests</a>
158	163
159	164	<br/>                <a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a>

162	167	<br/>            <a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a>
163	168	</span>
164	169
165		<br/>        <a href="cppad_test.xml" target="_top">Running the CppAD Examples and Tests</a>
	170	<br/>        <a href="cmake_check.xml" target="_top">Checking the CppAD Examples and Tests</a>
166	171
167	172	<br/>        <a href="pkgconfig.xml" target="_top">CppAD pkg-config Files</a>
168	173
169		<br/>        <a href="installunix.xml" target="_top">Unix Test and Installation</a>
170		</span>
171
172		<br/>    <a onclick='Select(21)'
173		onmouseover='MouseOver(21)'
174		onmouseout='MouseOut(21)'
175		><img src='_close.gif' name='folder21' align='middle' />
176		<u>An Introduction by Example to Algorithmic Differentiation</u></a>
177
178		<span id='children21'>
179		<br/>    <a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a>
180
181		<br/>        <a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a>
182
183		<br/>        <a onclick='Select(23)'
	174	<br/>        <a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a>
	175	</span>
	176
	177	<br/>    <a onclick='Select(23)'
184	178	onmouseover='MouseOver(23)'
185	179	onmouseout='MouseOut(23)'
186	180	><img src='_close.gif' name='folder23' align='middle' />
	181	<u>An Introduction by Example to Algorithmic Differentiation</u></a>
	182
	183	<span id='children23'>
	184	<br/>    <a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a>
	185
	186	<br/>        <a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a>
	187
	188	<br/>        <a onclick='Select(25)'
	189	onmouseover='MouseOver(25)'
	190	onmouseout='MouseOut(25)'
	191	><img src='_close.gif' name='folder25' align='middle' />
187	192	<u>Second Order Exponential Approximation</u></a>
188	193
189		<span id='children23'>
	194	<span id='children25'>
190	195	<br/>        <a href="exp_2.xml" target="_top">Second Order Exponential Approximation</a>
191	196
192	197	<br/>            <a href="exp_2.hpp.xml" target="_top">exp_2: Implementation</a>
193	198
194	199	<br/>            <a href="exp_2.cpp.xml" target="_top">exp_2: Test</a>
195
196		<br/>            <a onclick='Select(26)'
197		onmouseover='MouseOver(26)'
198		onmouseout='MouseOut(26)'
199		><img src='_close.gif' name='folder26' align='middle' />
200		<u>exp_2: Operation Sequence and Zero Order Forward Mode</u></a>
201
202		<span id='children26'>
203		<br/>            <a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a>
204
205		<br/>                <a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a>
206		</span>
207	200
208	201	<br/>            <a onclick='Select(28)'
209	202	onmouseover='MouseOver(28)'
210	203	onmouseout='MouseOut(28)'
211	204	><img src='_close.gif' name='folder28' align='middle' />
212		<u>exp_2: First Order Forward Mode</u></a>
	205	<u>exp_2: Operation Sequence and Zero Order Forward Mode</u></a>
213	206
214	207	<span id='children28'>
215		<br/>            <a href="exp_2_for1.xml" target="_top">exp_2: First Order Forward Mode</a>
216
217		<br/>                <a href="exp_2_for1.cpp.xml" target="_top">exp_2: Verify First Order Forward Sweep</a>
	208	<br/>            <a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a>
	209
	210	<br/>                <a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a>
218	211	</span>
219	212
220	213	<br/>            <a onclick='Select(30)'
221	214	onmouseover='MouseOver(30)'
222	215	onmouseout='MouseOut(30)'
223	216	><img src='_close.gif' name='folder30' align='middle' />
224		<u>exp_2: First Order Reverse Mode</u></a>
	217	<u>exp_2: First Order Forward Mode</u></a>
225	218
226	219	<span id='children30'>
227		<br/>            <a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a>
228
229		<br/>                <a href="exp_2_rev1.cpp.xml" target="_top">exp_2: Verify First Order Reverse Sweep</a>
	220	<br/>            <a href="exp_2_for1.xml" target="_top">exp_2: First Order Forward Mode</a>
	221
	222	<br/>                <a href="exp_2_for1.cpp.xml" target="_top">exp_2: Verify First Order Forward Sweep</a>
230	223	</span>
231	224
232	225	<br/>            <a onclick='Select(32)'
233	226	onmouseover='MouseOver(32)'
234	227	onmouseout='MouseOut(32)'
235	228	><img src='_close.gif' name='folder32' align='middle' />
236		<u>exp_2: Second Order Forward Mode</u></a>
	229	<u>exp_2: First Order Reverse Mode</u></a>
237	230
238	231	<span id='children32'>
239		<br/>            <a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a>
240
241		<br/>                <a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a>
	232	<br/>            <a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a>
	233
	234	<br/>                <a href="exp_2_rev1.cpp.xml" target="_top">exp_2: Verify First Order Reverse Sweep</a>
242	235	</span>
243	236
244	237	<br/>            <a onclick='Select(34)'
245	238	onmouseover='MouseOver(34)'
246	239	onmouseout='MouseOut(34)'
247	240	><img src='_close.gif' name='folder34' align='middle' />
	241	<u>exp_2: Second Order Forward Mode</u></a>
	242
	243	<span id='children34'>
	244	<br/>            <a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a>
	245
	246	<br/>                <a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a>
	247	</span>
	248
	249	<br/>            <a onclick='Select(36)'
	250	onmouseover='MouseOver(36)'
	251	onmouseout='MouseOut(36)'
	252	><img src='_close.gif' name='folder36' align='middle' />
248	253	<u>exp_2: Second Order Reverse Mode</u></a>
249	254
250		<span id='children34'>
	255	<span id='children36'>
251	256	<br/>            <a href="exp_2_rev2.xml" target="_top">exp_2: Second Order Reverse Mode</a>
252	257
253	258	<br/>                <a href="exp_2_rev2.cpp.xml" target="_top">exp_2: Verify Second Order Reverse Sweep</a>

256	261	<br/>            <a href="exp_2_cppad.xml" target="_top">exp_2: CppAD Forward and Reverse Sweeps</a>
257	262	</span>
258	263
259		<br/>        <a onclick='Select(37)'
260		onmouseover='MouseOver(37)'
261		onmouseout='MouseOut(37)'
262		><img src='_close.gif' name='folder37' align='middle' />
	264	<br/>        <a onclick='Select(39)'
	265	onmouseover='MouseOver(39)'
	266	onmouseout='MouseOut(39)'
	267	><img src='_close.gif' name='folder39' align='middle' />
263	268	<u>An Epsilon Accurate Exponential Approximation</u></a>
264	269
265		<span id='children37'>
	270	<span id='children39'>
266	271	<br/>        <a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a>
267	272
268	273	<br/>            <a href="exp_eps.hpp.xml" target="_top">exp_eps: Implementation</a>
269	274
270	275	<br/>            <a href="exp_eps.cpp.xml" target="_top">exp_eps: Test of exp_eps</a>
271
272		<br/>            <a onclick='Select(40)'
273		onmouseover='MouseOver(40)'
274		onmouseout='MouseOut(40)'
275		><img src='_close.gif' name='folder40' align='middle' />
276		<u>exp_eps: Operation Sequence and Zero Order Forward Sweep</u></a>
277
278		<span id='children40'>
279		<br/>            <a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a>
280
281		<br/>                <a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a>
282		</span>
283	276
284	277	<br/>            <a onclick='Select(42)'
285	278	onmouseover='MouseOver(42)'
286	279	onmouseout='MouseOut(42)'
287	280	><img src='_close.gif' name='folder42' align='middle' />
288		<u>exp_eps: First Order Forward Sweep</u></a>
	281	<u>exp_eps: Operation Sequence and Zero Order Forward Sweep</u></a>
289	282
290	283	<span id='children42'>
291		<br/>            <a href="exp_eps_for1.xml" target="_top">exp_eps: First Order Forward Sweep</a>
292
293		<br/>                <a href="exp_eps_for1.cpp.xml" target="_top">exp_eps: Verify First Order Forward Sweep</a>
	284	<br/>            <a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a>
	285
	286	<br/>                <a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a>
294	287	</span>
295	288
296	289	<br/>            <a onclick='Select(44)'
297	290	onmouseover='MouseOver(44)'
298	291	onmouseout='MouseOut(44)'
299	292	><img src='_close.gif' name='folder44' align='middle' />
300		<u>exp_eps: First Order Reverse Sweep</u></a>
	293	<u>exp_eps: First Order Forward Sweep</u></a>
301	294
302	295	<span id='children44'>
303		<br/>            <a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a>
304
305		<br/>                <a href="exp_eps_rev1.cpp.xml" target="_top">exp_eps: Verify First Order Reverse Sweep</a>
	296	<br/>            <a href="exp_eps_for1.xml" target="_top">exp_eps: First Order Forward Sweep</a>
	297
	298	<br/>                <a href="exp_eps_for1.cpp.xml" target="_top">exp_eps: Verify First Order Forward Sweep</a>
306	299	</span>
307	300
308	301	<br/>            <a onclick='Select(46)'
309	302	onmouseover='MouseOver(46)'
310	303	onmouseout='MouseOut(46)'
311	304	><img src='_close.gif' name='folder46' align='middle' />
312		<u>exp_eps: Second Order Forward Mode</u></a>
	305	<u>exp_eps: First Order Reverse Sweep</u></a>
313	306
314	307	<span id='children46'>
315		<br/>            <a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a>
316
317		<br/>                <a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a>
	308	<br/>            <a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a>
	309
	310	<br/>                <a href="exp_eps_rev1.cpp.xml" target="_top">exp_eps: Verify First Order Reverse Sweep</a>
318	311	</span>
319	312
320	313	<br/>            <a onclick='Select(48)'
321	314	onmouseover='MouseOver(48)'
322	315	onmouseout='MouseOut(48)'
323	316	><img src='_close.gif' name='folder48' align='middle' />
	317	<u>exp_eps: Second Order Forward Mode</u></a>
	318
	319	<span id='children48'>
	320	<br/>            <a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a>
	321
	322	<br/>                <a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a>
	323	</span>
	324
	325	<br/>            <a onclick='Select(50)'
	326	onmouseover='MouseOver(50)'
	327	onmouseout='MouseOut(50)'
	328	><img src='_close.gif' name='folder50' align='middle' />
324	329	<u>exp_eps: Second Order Reverse Sweep</u></a>
325	330
326		<span id='children48'>
	331	<span id='children50'>
327	332	<br/>            <a href="exp_eps_rev2.xml" target="_top">exp_eps: Second Order Reverse Sweep</a>
328	333
329	334	<br/>                <a href="exp_eps_rev2.cpp.xml" target="_top">exp_eps: Verify Second Order Reverse Sweep</a>

335	340	<br/>        <a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a>
336	341	</span>
337	342
338		<br/>    <a onclick='Select(52)'
339		onmouseover='MouseOver(52)'
340		onmouseout='MouseOut(52)'
341		><img src='_close.gif' name='folder52' align='middle' />
	343	<br/>    <a onclick='Select(54)'
	344	onmouseover='MouseOver(54)'
	345	onmouseout='MouseOut(54)'
	346	><img src='_close.gif' name='folder54' align='middle' />
342	347	<u>AD Objects</u></a>
343	348
344		<span id='children52'>
	349	<span id='children54'>
345	350	<br/>    <a href="ad.xml" target="_top">AD Objects</a>
346
347		<br/>        <a onclick='Select(53)'
348		onmouseover='MouseOver(53)'
349		onmouseout='MouseOut(53)'
350		><img src='_close.gif' name='folder53' align='middle' />
351		<u>AD Constructors</u></a>
352
353		<span id='children53'>
354		<br/>        <a href="ad_ctor.xml" target="_top">AD Constructors</a>
355
356		<br/>            <a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a>
357		</span>
358	351
359	352	<br/>        <a onclick='Select(55)'
360	353	onmouseover='MouseOver(55)'
361	354	onmouseout='MouseOut(55)'
362	355	><img src='_close.gif' name='folder55' align='middle' />
363		<u>AD Assignment Operator</u></a>
	356	<u>AD Constructors</u></a>
364	357
365	358	<span id='children55'>
366		<br/>        <a href="ad_assign.xml" target="_top">AD Assignment Operator</a>
367
368		<br/>            <a href="ad_assign.cpp.xml" target="_top">AD Assignment: Example and Test</a>
	359	<br/>        <a href="ad_ctor.xml" target="_top">AD Constructors</a>
	360
	361	<br/>            <a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a>
369	362	</span>
370	363
371	364	<br/>        <a onclick='Select(57)'
372	365	onmouseover='MouseOver(57)'
373	366	onmouseout='MouseOut(57)'
374	367	><img src='_close.gif' name='folder57' align='middle' />
	368	<u>AD Assignment Operator</u></a>
	369
	370	<span id='children57'>
	371	<br/>        <a href="ad_assign.xml" target="_top">AD Assignment Operator</a>
	372
	373	<br/>            <a href="ad_assign.cpp.xml" target="_top">AD Assignment: Example and Test</a>
	374	</span>
	375
	376	<br/>        <a onclick='Select(59)'
	377	onmouseover='MouseOver(59)'
	378	onmouseout='MouseOut(59)'
	379	><img src='_close.gif' name='folder59' align='middle' />
375	380	<u>Conversion and I/O of AD Objects</u></a>
376	381
377		<span id='children57'>
	382	<span id='children59'>
378	383	<br/>        <a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a>
379
380		<br/>            <a onclick='Select(58)'
381		onmouseover='MouseOver(58)'
382		onmouseout='MouseOut(58)'
383		><img src='_close.gif' name='folder58' align='middle' />
384		<u>Convert From an AD Type to its Base Type</u></a>
385
386		<span id='children58'>
387		<br/>            <a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a>
388
389		<br/>                <a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a>
390		</span>
391	384
392	385	<br/>            <a onclick='Select(60)'
393	386	onmouseover='MouseOver(60)'
394	387	onmouseout='MouseOut(60)'
395	388	><img src='_close.gif' name='folder60' align='middle' />
396		<u>Convert From AD to Integer</u></a>
	389	<u>Convert From an AD Type to its Base Type</u></a>
397	390
398	391	<span id='children60'>
399		<br/>            <a href="integer.xml" target="_top">Convert From AD to Integer</a>
400
401		<br/>                <a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a>
	392	<br/>            <a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a>
	393
	394	<br/>                <a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a>
402	395	</span>
403	396
404	397	<br/>            <a onclick='Select(62)'
405	398	onmouseover='MouseOver(62)'
406	399	onmouseout='MouseOut(62)'
407	400	><img src='_close.gif' name='folder62' align='middle' />
408		<u>AD Output Stream Operator</u></a>
	401	<u>Convert From AD to Integer</u></a>
409	402
410	403	<span id='children62'>
411		<br/>            <a href="ad_input.xml" target="_top">AD Output Stream Operator</a>
412
413		<br/>                <a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a>
	404	<br/>            <a href="integer.xml" target="_top">Convert From AD to Integer</a>
	405
	406	<br/>                <a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a>
414	407	</span>
415	408
416	409	<br/>            <a onclick='Select(64)'

420	413	<u>AD Output Stream Operator</u></a>
421	414
422	415	<span id='children64'>
423		<br/>            <a href="ad_output.xml" target="_top">AD Output Stream Operator</a>
424
425		<br/>                <a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a>
	416	<br/>            <a href="ad_input.xml" target="_top">AD Output Stream Operator</a>
	417
	418	<br/>                <a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a>
426	419	</span>
427	420
428	421	<br/>            <a onclick='Select(66)'
429	422	onmouseover='MouseOver(66)'
430	423	onmouseout='MouseOut(66)'
431	424	><img src='_close.gif' name='folder66' align='middle' />
	425	<u>AD Output Stream Operator</u></a>
	426
	427	<span id='children66'>
	428	<br/>            <a href="ad_output.xml" target="_top">AD Output Stream Operator</a>
	429
	430	<br/>                <a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a>
	431	</span>
	432
	433	<br/>            <a onclick='Select(68)'
	434	onmouseover='MouseOver(68)'
	435	onmouseout='MouseOut(68)'
	436	><img src='_close.gif' name='folder68' align='middle' />
432	437	<u>Printing AD Values During Forward Mode</u></a>
433	438
434		<span id='children66'>
	439	<span id='children68'>
435	440	<br/>            <a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a>
436	441
437	442	<br/>                <a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a>

439	444	<br/>                <a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a>
440	445	</span>
441	446
442		<br/>            <a onclick='Select(69)'
443		onmouseover='MouseOver(69)'
444		onmouseout='MouseOut(69)'
445		><img src='_close.gif' name='folder69' align='middle' />
446		<u>Convert an AD Variable to a Parameter</u></a>
447
448		<span id='children69'>
449		<br/>            <a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a>
450
451		<br/>                <a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a>
452		</span>
453		</span>
454
455		<br/>        <a onclick='Select(71)'
	447	<br/>            <a onclick='Select(71)'
456	448	onmouseover='MouseOver(71)'
457	449	onmouseout='MouseOut(71)'
458	450	><img src='_close.gif' name='folder71' align='middle' />
459		<u>AD Valued Operations and Functions</u></a>
	451	<u>Convert an AD Variable to a Parameter</u></a>
460	452
461	453	<span id='children71'>
462		<br/>        <a href="advalued.xml" target="_top">AD Valued Operations and Functions</a>
463
464		<br/>            <a onclick='Select(72)'
465		onmouseover='MouseOver(72)'
466		onmouseout='MouseOut(72)'
467		><img src='_close.gif' name='folder72' align='middle' />
468		<u>AD Arithmetic Operators and Computed Assignments</u></a>
469
470		<span id='children72'>
471		<br/>            <a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a>
472
473		<br/>                <a onclick='Select(73)'
	454	<br/>            <a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a>
	455
	456	<br/>                <a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a>
	457	</span>
	458	</span>
	459
	460	<br/>        <a onclick='Select(73)'
474	461	onmouseover='MouseOver(73)'
475	462	onmouseout='MouseOut(73)'
476	463	><img src='_close.gif' name='folder73' align='middle' />
477		<u>AD Unary Plus Operator</u></a>
	464	<u>AD Valued Operations and Functions</u></a>
478	465
479	466	<span id='children73'>
480		<br/>                <a href="unaryplus.xml" target="_top">AD Unary Plus Operator</a>
481
482		<br/>                    <a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a>
483		</span>
	467	<br/>        <a href="advalued.xml" target="_top">AD Valued Operations and Functions</a>
	468
	469	<br/>            <a onclick='Select(74)'
	470	onmouseover='MouseOver(74)'
	471	onmouseout='MouseOut(74)'
	472	><img src='_close.gif' name='folder74' align='middle' />
	473	<u>AD Arithmetic Operators and Computed Assignments</u></a>
	474
	475	<span id='children74'>
	476	<br/>            <a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a>
484	477
485	478	<br/>                <a onclick='Select(75)'
486	479	onmouseover='MouseOver(75)'
487	480	onmouseout='MouseOut(75)'
488	481	><img src='_close.gif' name='folder75' align='middle' />
489		<u>AD Unary Minus Operator</u></a>
	482	<u>AD Unary Plus Operator</u></a>
490	483
491	484	<span id='children75'>
492		<br/>                <a href="unaryminus.xml" target="_top">AD Unary Minus Operator</a>
493
494		<br/>                    <a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a>
	485	<br/>                <a href="unaryplus.xml" target="_top">AD Unary Plus Operator</a>
	486
	487	<br/>                    <a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a>
495	488	</span>
496	489
497	490	<br/>                <a onclick='Select(77)'
498	491	onmouseover='MouseOver(77)'
499	492	onmouseout='MouseOut(77)'
500	493	><img src='_close.gif' name='folder77' align='middle' />
	494	<u>AD Unary Minus Operator</u></a>
	495
	496	<span id='children77'>
	497	<br/>                <a href="unaryminus.xml" target="_top">AD Unary Minus Operator</a>
	498
	499	<br/>                    <a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a>
	500	</span>
	501
	502	<br/>                <a onclick='Select(79)'
	503	onmouseover='MouseOver(79)'
	504	onmouseout='MouseOut(79)'
	505	><img src='_close.gif' name='folder79' align='middle' />
501	506	<u>AD Binary Arithmetic Operators</u></a>
502	507
503		<span id='children77'>
	508	<span id='children79'>
504	509	<br/>                <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a>
505	510
506	511	<br/>                    <a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a>

512	517	<br/>                    <a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a>
513	518	</span>
514	519
515		<br/>                <a onclick='Select(82)'
516		onmouseover='MouseOver(82)'
517		onmouseout='MouseOut(82)'
518		><img src='_close.gif' name='folder82' align='middle' />
	520	<br/>                <a onclick='Select(84)'
	521	onmouseover='MouseOver(84)'
	522	onmouseout='MouseOut(84)'
	523	><img src='_close.gif' name='folder84' align='middle' />
519	524	<u>AD Computed Assignment Operators</u></a>
520	525
521		<span id='children82'>
	526	<span id='children84'>
522	527	<br/>                <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a>
523	528
524	529	<br/>                    <a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a>

531	536	</span>
532	537	</span>
533	538
534		<br/>            <a onclick='Select(87)'
535		onmouseover='MouseOver(87)'
536		onmouseout='MouseOut(87)'
537		><img src='_close.gif' name='folder87' align='middle' />
	539	<br/>            <a onclick='Select(89)'
	540	onmouseover='MouseOver(89)'
	541	onmouseout='MouseOut(89)'
	542	><img src='_close.gif' name='folder89' align='middle' />
538	543	<u>AD Standard Math Unary Functions</u></a>
539	544
540		<span id='children87'>
	545	<span id='children89'>
541	546	<br/>            <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a>
542	547
543	548	<br/>                <a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a>

567	572	<br/>                <a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a>
568	573	</span>
569	574
570		<br/>            <a onclick='Select(101)'
571		onmouseover='MouseOver(101)'
572		onmouseout='MouseOut(101)'
573		><img src='_close.gif' name='folder101' align='middle' />
	575	<br/>            <a onclick='Select(103)'
	576	onmouseover='MouseOver(103)'
	577	onmouseout='MouseOut(103)'
	578	><img src='_close.gif' name='folder103' align='middle' />
574	579	<u>Other AD Math Functions</u></a>
575	580
576		<span id='children101'>
	581	<span id='children103'>
577	582	<br/>            <a href="mathother.xml" target="_top">Other AD Math Functions</a>
578
579		<br/>                <a onclick='Select(102)'
580		onmouseover='MouseOver(102)'
581		onmouseout='MouseOut(102)'
582		><img src='_close.gif' name='folder102' align='middle' />
583		<u>AD Absolute Value Function</u></a>
584
585		<span id='children102'>
586		<br/>                <a href="abs.xml" target="_top">AD Absolute Value Function</a>
587
588		<br/>                    <a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a>
589		</span>
590	583
591	584	<br/>                <a onclick='Select(104)'
592	585	onmouseover='MouseOver(104)'
593	586	onmouseout='MouseOut(104)'
594	587	><img src='_close.gif' name='folder104' align='middle' />
595		<u>Sign Function</u></a>
	588	<u>AD Absolute Value Function</u></a>
596	589
597	590	<span id='children104'>
598		<br/>                <a href="sign.xml" target="_top">Sign Function</a>
599
600		<br/>                    <a href="sign.cpp.xml" target="_top">Sign Function: Example and Test</a>
	591	<br/>                <a href="abs.xml" target="_top">AD Absolute Value Function</a>
	592
	593	<br/>                    <a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a>
601	594	</span>
602	595
603	596	<br/>                <a onclick='Select(106)'
604	597	onmouseover='MouseOver(106)'
605	598	onmouseout='MouseOut(106)'
606	599	><img src='_close.gif' name='folder106' align='middle' />
607		<u>AD Two Argument Inverse Tangent Function</u></a>
	600	<u>Sign Function</u></a>
608	601
609	602	<span id='children106'>
610		<br/>                <a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a>
611
612		<br/>                    <a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a>
	603	<br/>                <a href="sign.xml" target="_top">Sign Function</a>
	604
	605	<br/>                    <a href="sign.cpp.xml" target="_top">Sign Function: Example and Test</a>
613	606	</span>
614	607
615	608	<br/>                <a onclick='Select(108)'
616	609	onmouseover='MouseOver(108)'
617	610	onmouseout='MouseOut(108)'
618	611	><img src='_close.gif' name='folder108' align='middle' />
619		<u>The AD Error Function</u></a>
	612	<u>AD Two Argument Inverse Tangent Function</u></a>
620	613
621	614	<span id='children108'>
622		<br/>                <a href="erf.xml" target="_top">The AD Error Function</a>
623
624		<br/>                    <a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a>
	615	<br/>                <a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a>
	616
	617	<br/>                    <a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a>
625	618	</span>
626	619
627	620	<br/>                <a onclick='Select(110)'
628	621	onmouseover='MouseOver(110)'
629	622	onmouseout='MouseOut(110)'
630	623	><img src='_close.gif' name='folder110' align='middle' />
631		<u>The AD Power Function</u></a>
	624	<u>The AD Error Function</u></a>
632	625
633	626	<span id='children110'>
634		<br/>                <a href="pow.xml" target="_top">The AD Power Function</a>
635
636		<br/>                    <a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a>
	627	<br/>                <a href="erf.xml" target="_top">The AD Error Function</a>
	628
	629	<br/>                    <a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a>
637	630	</span>
638	631
639	632	<br/>                <a onclick='Select(112)'
640	633	onmouseover='MouseOver(112)'
641	634	onmouseout='MouseOut(112)'
642	635	><img src='_close.gif' name='folder112' align='middle' />
643		<u>Numeric Limits For an AD and Base Types</u></a>
	636	<u>The AD Power Function</u></a>
644	637
645	638	<span id='children112'>
646		<br/>                <a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a>
647
648		<br/>                    <a href="limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a>
649		</span>
650		</span>
651
652		<br/>            <a onclick='Select(114)'
	639	<br/>                <a href="pow.xml" target="_top">The AD Power Function</a>
	640
	641	<br/>                    <a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a>
	642	</span>
	643
	644	<br/>                <a onclick='Select(114)'
653	645	onmouseover='MouseOver(114)'
654	646	onmouseout='MouseOut(114)'
655	647	><img src='_close.gif' name='folder114' align='middle' />
656		<u>AD Conditional Expressions</u></a>
	648	<u>Numeric Limits For an AD and Base Types</u></a>
657	649
658	650	<span id='children114'>
659		<br/>            <a href="condexp.xml" target="_top">AD Conditional Expressions</a>
660
661		<br/>                <a href="cond_exp.cpp.xml" target="_top">Conditional Expressions: Example and Test</a>
	651	<br/>                <a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a>
	652
	653	<br/>                    <a href="limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a>
	654	</span>
662	655	</span>
663	656
664	657	<br/>            <a onclick='Select(116)'
665	658	onmouseover='MouseOver(116)'
666	659	onmouseout='MouseOut(116)'
667	660	><img src='_close.gif' name='folder116' align='middle' />
	661	<u>AD Conditional Expressions</u></a>
	662
	663	<span id='children116'>
	664	<br/>            <a href="condexp.xml" target="_top">AD Conditional Expressions</a>
	665
	666	<br/>                <a href="cond_exp.cpp.xml" target="_top">Conditional Expressions: Example and Test</a>
	667	</span>
	668
	669	<br/>            <a onclick='Select(118)'
	670	onmouseover='MouseOver(118)'
	671	onmouseout='MouseOut(118)'
	672	><img src='_close.gif' name='folder118' align='middle' />
668	673	<u>Discrete AD Functions</u></a>
669	674
670		<span id='children116'>
	675	<span id='children118'>
671	676	<br/>            <a href="discrete.xml" target="_top">Discrete AD Functions</a>
672	677
673	678	<br/>                <a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a>

677	682	<br/>                <a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a>
678	683	</span>
679	684
680		<br/>            <a onclick='Select(120)'
681		onmouseover='MouseOver(120)'
682		onmouseout='MouseOut(120)'
683		><img src='_close.gif' name='folder120' align='middle' />
	685	<br/>            <a onclick='Select(122)'
	686	onmouseover='MouseOver(122)'
	687	onmouseout='MouseOut(122)'
	688	><img src='_close.gif' name='folder122' align='middle' />
684	689	<u>Atomic AD Functions</u></a>
685	690
686		<span id='children120'>
	691	<span id='children122'>
687	692	<br/>            <a href="atomic.xml" target="_top">Atomic AD Functions</a>
688
689		<br/>                <a onclick='Select(121)'
690		onmouseover='MouseOver(121)'
691		onmouseout='MouseOut(121)'
692		><img src='_close.gif' name='folder121' align='middle' />
693		<u>Checkpointing Functions</u></a>
694
695		<span id='children121'>
696		<br/>                <a href="checkpoint.xml" target="_top">Checkpointing Functions</a>
697
698		<br/>                    <a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a>
699		</span>
700	693
701	694	<br/>                <a onclick='Select(123)'
702	695	onmouseover='MouseOver(123)'
703	696	onmouseout='MouseOut(123)'
704	697	><img src='_close.gif' name='folder123' align='middle' />
	698	<u>Checkpointing Functions</u></a>
	699
	700	<span id='children123'>
	701	<br/>                <a href="checkpoint.xml" target="_top">Checkpointing Functions</a>
	702
	703	<br/>                    <a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a>
	704	</span>
	705
	706	<br/>                <a onclick='Select(125)'
	707	onmouseover='MouseOver(125)'
	708	onmouseout='MouseOut(125)'
	709	><img src='_close.gif' name='folder125' align='middle' />
705	710	<u>User Defined Atomic AD Functions</u></a>
706	711
707		<span id='children123'>
	712	<span id='children125'>
708	713	<br/>                <a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a>
709	714
710	715	<br/>                    <a href="atomic_ctor.xml" target="_top">Atomic Function Constructor</a>

733	738
734	739	<br/>                    <a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a>
735	740
736		<br/>                    <a onclick='Select(137)'
737		onmouseover='MouseOver(137)'
738		onmouseout='MouseOut(137)'
739		><img src='_close.gif' name='folder137' align='middle' />
740		<u>User Atomic Matrix Multiply: Example and Test</u></a>
741
742		<span id='children137'>
743		<br/>                    <a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a>
744
745		<br/>                        <a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a>
746		</span>
747		</span>
748		</span>
749		</span>
750
751		<br/>        <a onclick='Select(139)'
752		onmouseover='MouseOver(139)'
753		onmouseout='MouseOut(139)'
754		><img src='_close.gif' name='folder139' align='middle' />
755		<u>Bool Valued Operations and Functions with AD Arguments</u></a>
756
757		<span id='children139'>
758		<br/>        <a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a>
759
760		<br/>            <a onclick='Select(140)'
	741	<br/>                    <a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a>
	742
	743	<br/>                    <a onclick='Select(140)'
761	744	onmouseover='MouseOver(140)'
762	745	onmouseout='MouseOut(140)'
763	746	><img src='_close.gif' name='folder140' align='middle' />
764		<u>AD Binary Comparison Operators</u></a>
	747	<u>User Atomic Matrix Multiply: Example and Test</u></a>
765	748
766	749	<span id='children140'>
767		<br/>            <a href="compare.xml" target="_top">AD Binary Comparison Operators</a>
768
769		<br/>                <a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a>
770		</span>
771
772		<br/>            <a onclick='Select(142)'
	750	<br/>                    <a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a>
	751
	752	<br/>                        <a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a>
	753	</span>
	754	</span>
	755	</span>
	756	</span>
	757
	758	<br/>        <a onclick='Select(142)'
773	759	onmouseover='MouseOver(142)'
774	760	onmouseout='MouseOut(142)'
775	761	><img src='_close.gif' name='folder142' align='middle' />
	762	<u>Bool Valued Operations and Functions with AD Arguments</u></a>
	763
	764	<span id='children142'>
	765	<br/>        <a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a>
	766
	767	<br/>            <a onclick='Select(143)'
	768	onmouseover='MouseOver(143)'
	769	onmouseout='MouseOut(143)'
	770	><img src='_close.gif' name='folder143' align='middle' />
	771	<u>AD Binary Comparison Operators</u></a>
	772
	773	<span id='children143'>
	774	<br/>            <a href="compare.xml" target="_top">AD Binary Comparison Operators</a>
	775
	776	<br/>                <a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a>
	777	</span>
	778
	779	<br/>            <a onclick='Select(145)'
	780	onmouseover='MouseOver(145)'
	781	onmouseout='MouseOut(145)'
	782	><img src='_close.gif' name='folder145' align='middle' />
776	783	<u>Compare AD and Base Objects for Nearly Equal</u></a>
777	784
778		<span id='children142'>
	785	<span id='children145'>
779	786	<br/>            <a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a>
780	787
781	788	<br/>                <a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a>
782	789	</span>
783	790
784		<br/>            <a onclick='Select(144)'
785		onmouseover='MouseOver(144)'
786		onmouseout='MouseOut(144)'
787		><img src='_close.gif' name='folder144' align='middle' />
	791	<br/>            <a onclick='Select(147)'
	792	onmouseover='MouseOver(147)'
	793	onmouseout='MouseOut(147)'
	794	><img src='_close.gif' name='folder147' align='middle' />
788	795	<u>AD Boolean Functions</u></a>
789	796
790		<span id='children144'>
	797	<span id='children147'>
791	798	<br/>            <a href="boolfun.xml" target="_top">AD Boolean Functions</a>
792	799
793	800	<br/>                <a href="bool_fun.cpp.xml" target="_top">AD Boolean Functions: Example and Test</a>
794	801	</span>
795	802
796		<br/>            <a onclick='Select(146)'
797		onmouseover='MouseOver(146)'
798		onmouseout='MouseOut(146)'
799		><img src='_close.gif' name='folder146' align='middle' />
	803	<br/>            <a onclick='Select(149)'
	804	onmouseover='MouseOver(149)'
	805	onmouseout='MouseOut(149)'
	806	><img src='_close.gif' name='folder149' align='middle' />
800	807	<u>Is an AD Object a Parameter or Variable</u></a>
801	808
802		<span id='children146'>
	809	<span id='children149'>
803	810	<br/>            <a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a>
804	811
805	812	<br/>                <a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a>
806	813	</span>
807	814
808		<br/>            <a onclick='Select(148)'
809		onmouseover='MouseOver(148)'
810		onmouseout='MouseOut(148)'
811		><img src='_close.gif' name='folder148' align='middle' />
	815	<br/>            <a onclick='Select(151)'
	816	onmouseover='MouseOver(151)'
	817	onmouseout='MouseOut(151)'
	818	><img src='_close.gif' name='folder151' align='middle' />
812	819	<u>Check if Two Value are Identically Equal</u></a>
813	820
814		<span id='children148'>
	821	<span id='children151'>
815	822	<br/>            <a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a>
816	823
817	824	<br/>                <a href="equal_op_seq.cpp.xml" target="_top">EqualOpSeq: Example and Test</a>
818	825	</span>
819	826	</span>
820	827
821		<br/>        <a onclick='Select(150)'
822		onmouseover='MouseOver(150)'
823		onmouseout='MouseOut(150)'
824		><img src='_close.gif' name='folder150' align='middle' />
	828	<br/>        <a onclick='Select(153)'
	829	onmouseover='MouseOver(153)'
	830	onmouseout='MouseOut(153)'
	831	><img src='_close.gif' name='folder153' align='middle' />
825	832	<u>AD Vectors that Record Index Operations</u></a>
826	833
827		<span id='children150'>
	834	<span id='children153'>
828	835	<br/>        <a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a>
829	836
830	837	<br/>            <a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a>
831	838	</span>
832	839
833		<br/>        <a onclick='Select(152)'
834		onmouseover='MouseOver(152)'
835		onmouseout='MouseOut(152)'
836		><img src='_close.gif' name='folder152' align='middle' />
	840	<br/>        <a onclick='Select(155)'
	841	onmouseover='MouseOver(155)'
	842	onmouseout='MouseOut(155)'
	843	><img src='_close.gif' name='folder155' align='middle' />
837	844	<u>AD<Base> Requirements for Base Type</u></a>
838	845
839		<span id='children152'>
	846	<span id='children155'>
840	847	<br/>        <a href="base_require.xml" target="_top">AD<Base> Requirements for Base Type</a>
841	848
842	849	<br/>            <a href="base_member.xml" target="_top">Required Base Class Member Functions</a>

849	856
850	857	<br/>            <a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a>
851	858
852		<br/>            <a onclick='Select(158)'
853		onmouseover='MouseOver(158)'
854		onmouseout='MouseOut(158)'
855		><img src='_close.gif' name='folder158' align='middle' />
856		<u>Example AD Base Types That are not AD<OtherBase></u></a>
857
858		<span id='children158'>
859		<br/>            <a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a>
860
861		<br/>                <a href="base_alloc.hpp.xml" target="_top">Example AD<Base> Where Base Constructor Allocates Memory</a>
862
863		<br/>                <a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a>
864
865		<br/>                <a onclick='Select(161)'
	859	<br/>            <a onclick='Select(161)'
866	860	onmouseover='MouseOver(161)'
867	861	onmouseout='MouseOut(161)'
868	862	><img src='_close.gif' name='folder161' align='middle' />
	863	<u>Example AD Base Types That are not AD<OtherBase></u></a>
	864
	865	<span id='children161'>
	866	<br/>            <a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a>
	867
	868	<br/>                <a href="base_alloc.hpp.xml" target="_top">Example AD<Base> Where Base Constructor Allocates Memory</a>
	869
	870	<br/>                <a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a>
	871
	872	<br/>                <a onclick='Select(164)'
	873	onmouseover='MouseOver(164)'
	874	onmouseout='MouseOut(164)'
	875	><img src='_close.gif' name='folder164' align='middle' />
869	876	<u>Enable use of AD<Base> where Base is Adolc's adouble Type</u></a>
870	877
871		<span id='children161'>
	878	<span id='children164'>
872	879	<br/>                <a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a>
873	880
874	881	<br/>                    <a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a>

878	885
879	886	<br/>                <a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a>
880	887
881		<br/>                <a onclick='Select(165)'
882		onmouseover='MouseOver(165)'
883		onmouseout='MouseOut(165)'
884		><img src='_close.gif' name='folder165' align='middle' />
885		<u>Enable use of AD<Base> where Base is std::complex<double></u></a>
886
887		<span id='children165'>
888		<br/>                <a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a>
889
890		<br/>                    <a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a>
891
892		<br/>                    <a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a>
893		</span>
894		</span>
895		</span>
896		</span>
897
898		<br/>    <a onclick='Select(168)'
	888	<br/>                <a onclick='Select(168)'
899	889	onmouseover='MouseOver(168)'
900	890	onmouseout='MouseOut(168)'
901	891	><img src='_close.gif' name='folder168' align='middle' />
902		<u>ADFun Objects</u></a>
	892	<u>Enable use of AD<Base> where Base is std::complex<double></u></a>
903	893
904	894	<span id='children168'>
905		<br/>    <a href="adfun.xml" target="_top">ADFun Objects</a>
906
907		<br/>        <a onclick='Select(169)'
908		onmouseover='MouseOver(169)'
909		onmouseout='MouseOut(169)'
910		><img src='_close.gif' name='folder169' align='middle' />
911		<u>Declare Independent Variables and Start Recording</u></a>
912
913		<span id='children169'>
914		<br/>        <a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a>
915
916		<br/>            <a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a>
917		</span>
918
919		<br/>        <a onclick='Select(171)'
	895	<br/>                <a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a>
	896
	897	<br/>                    <a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a>
	898
	899	<br/>                    <a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a>
	900	</span>
	901	</span>
	902	</span>
	903	</span>
	904
	905	<br/>    <a onclick='Select(171)'
920	906	onmouseover='MouseOver(171)'
921	907	onmouseout='MouseOut(171)'
922	908	><img src='_close.gif' name='folder171' align='middle' />
923		<u>Construct an ADFun Object and Stop Recording</u></a>
	909	<u>ADFun Objects</u></a>
924	910
925	911	<span id='children171'>
926		<br/>        <a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a>
927
928		<br/>            <a href="fun_assign.cpp.xml" target="_top">ADFun Assignment: Example and Test</a>
929		</span>
930
931		<br/>        <a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a>
	912	<br/>    <a href="adfun.xml" target="_top">ADFun Objects</a>
	913
	914	<br/>        <a onclick='Select(172)'
	915	onmouseover='MouseOver(172)'
	916	onmouseout='MouseOut(172)'
	917	><img src='_close.gif' name='folder172' align='middle' />
	918	<u>Declare Independent Variables and Start Recording</u></a>
	919
	920	<span id='children172'>
	921	<br/>        <a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a>
	922
	923	<br/>            <a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a>
	924	</span>
932	925
933	926	<br/>        <a onclick='Select(174)'
934	927	onmouseover='MouseOver(174)'
935	928	onmouseout='MouseOut(174)'
936	929	><img src='_close.gif' name='folder174' align='middle' />
	930	<u>Construct an ADFun Object and Stop Recording</u></a>
	931
	932	<span id='children174'>
	933	<br/>        <a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a>
	934
	935	<br/>            <a href="fun_assign.cpp.xml" target="_top">ADFun Assignment: Example and Test</a>
	936	</span>
	937
	938	<br/>        <a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a>
	939
	940	<br/>        <a onclick='Select(177)'
	941	onmouseover='MouseOver(177)'
	942	onmouseout='MouseOut(177)'
	943	><img src='_close.gif' name='folder177' align='middle' />
937	944	<u>Abort Recording of an Operation Sequence</u></a>
938	945
939		<span id='children174'>
	946	<span id='children177'>
940	947	<br/>        <a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a>
941	948
942	949	<br/>            <a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a>
943	950	</span>
944	951
945		<br/>        <a onclick='Select(176)'
946		onmouseover='MouseOver(176)'
947		onmouseout='MouseOut(176)'
948		><img src='_close.gif' name='folder176' align='middle' />
949		<u>ADFun Sequence Properties</u></a>
950
951		<span id='children176'>
952		<br/>        <a href="seq_property.xml" target="_top">ADFun Sequence Properties</a>
953
954		<br/>            <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a>
955		</span>
956
957		<br/>        <a onclick='Select(178)'
958		onmouseover='MouseOver(178)'
959		onmouseout='MouseOut(178)'
960		><img src='_close.gif' name='folder178' align='middle' />
961		<u>Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</u></a>
962
963		<span id='children178'>
964		<br/>        <a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a>
965
966		<br/>            <a onclick='Select(179)'
	952	<br/>        <a onclick='Select(179)'
967	953	onmouseover='MouseOver(179)'
968	954	onmouseout='MouseOut(179)'
969	955	><img src='_close.gif' name='folder179' align='middle' />
	956	<u>ADFun Sequence Properties</u></a>
	957
	958	<span id='children179'>
	959	<br/>        <a href="seq_property.xml" target="_top">ADFun Sequence Properties</a>
	960
	961	<br/>            <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a>
	962	</span>
	963
	964	<br/>        <a onclick='Select(181)'
	965	onmouseover='MouseOver(181)'
	966	onmouseout='MouseOut(181)'
	967	><img src='_close.gif' name='folder181' align='middle' />
	968	<u>Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</u></a>
	969
	970	<span id='children181'>
	971	<br/>        <a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a>
	972
	973	<br/>            <a onclick='Select(182)'
	974	onmouseover='MouseOver(182)'
	975	onmouseout='MouseOut(182)'
	976	><img src='_close.gif' name='folder182' align='middle' />
970	977	<u>Forward Mode</u></a>
971	978
972		<span id='children179'>
	979	<span id='children182'>
973	980	<br/>            <a href="forward.xml" target="_top">Forward Mode</a>
974	981
975		<br/>                <a href="forwardzero.xml" target="_top">Zero Order Forward Mode: Function Values</a>
976
977		<br/>                <a href="forwardone.xml" target="_top">First Order Forward Mode: Derivative Values</a>
978
979		<br/>                <a href="forwardany.xml" target="_top">Any Order Forward Mode</a>
980
981		<br/>                <a href="size_taylor.xml" target="_top">Number Taylor Coefficients, Per Variable, Currently Stored</a>
982
983		<br/>                <a onclick='Select(184)'
984		onmouseover='MouseOver(184)'
985		onmouseout='MouseOut(184)'
986		><img src='_close.gif' name='folder184' align='middle' />
987		<u>Comparison Changes During Zero Order Forward Mode</u></a>
988
989		<span id='children184'>
990		<br/>                <a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a>
991
992		<br/>                    <a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a>
993		</span>
	982	<br/>                <a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a>
	983
	984	<br/>                <a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a>
	985
	986	<br/>                <a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a>
994	987
995	988	<br/>                <a onclick='Select(186)'
996	989	onmouseover='MouseOver(186)'
997	990	onmouseout='MouseOut(186)'
998	991	><img src='_close.gif' name='folder186' align='middle' />
999		<u>Controlling Taylor Coefficients Memory Allocation</u></a>
	992	<u>Multiple Order Forward Mode</u></a>
1000	993
1001	994	<span id='children186'>
1002		<br/>                <a href="capacity_taylor.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a>
1003
1004		<br/>                    <a href="capacity_taylor.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a>
1005		</span>
1006
1007		<br/>                <a onclick='Select(188)'
1008		onmouseover='MouseOver(188)'
1009		onmouseout='MouseOut(188)'
1010		><img src='_close.gif' name='folder188' align='middle' />
1011		<u>Number of Variables that Can be Skipped</u></a>
1012
1013		<span id='children188'>
1014		<br/>                <a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a>
1015
1016		<br/>                    <a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a>
1017		</span>
1018
1019		<br/>                <a href="forward.cpp.xml" target="_top">Forward Mode: Example and Test</a>
1020
1021		<br/>                <a href="forward_mul.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a>
1022		</span>
1023
1024		<br/>            <a onclick='Select(192)'
	995	<br/>                <a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a>
	996
	997	<br/>                    <a href="forward.cpp.xml" target="_top">Forward Mode: Example and Test</a>
	998
	999	<br/>                    <a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a>
	1000	</span>
	1001
	1002	<br/>                <a onclick='Select(189)'
	1003	onmouseover='MouseOver(189)'
	1004	onmouseout='MouseOut(189)'
	1005	><img src='_close.gif' name='folder189' align='middle' />
	1006	<u>Multiple Directions Forward Mode</u></a>
	1007
	1008	<span id='children189'>
	1009	<br/>                <a href="forward_dir.xml" target="_top">Multiple Directions Forward Mode</a>
	1010
	1011	<br/>                    <a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a>
	1012	</span>
	1013
	1014	<br/>                <a href="size_order.xml" target="_top">Number Taylor Coefficient Orders Currently Stored</a>
	1015
	1016	<br/>                <a onclick='Select(192)'
1025	1017	onmouseover='MouseOver(192)'
1026	1018	onmouseout='MouseOut(192)'
1027	1019	><img src='_close.gif' name='folder192' align='middle' />
1028		<u>Reverse Mode</u></a>
	1020	<u>Comparison Changes During Zero Order Forward Mode</u></a>
1029	1021
1030	1022	<span id='children192'>
1031		<br/>            <a href="reverse.xml" target="_top">Reverse Mode</a>
1032
1033		<br/>                <a onclick='Select(193)'
1034		onmouseover='MouseOver(193)'
1035		onmouseout='MouseOut(193)'
1036		><img src='_close.gif' name='folder193' align='middle' />
1037		<u>First Order Reverse Mode</u></a>
1038
1039		<span id='children193'>
1040		<br/>                <a href="reverse_one.xml" target="_top">First Order Reverse Mode</a>
1041
1042		<br/>                    <a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a>
1043		</span>
1044
1045		<br/>                <a onclick='Select(195)'
1046		onmouseover='MouseOver(195)'
1047		onmouseout='MouseOut(195)'
1048		><img src='_close.gif' name='folder195' align='middle' />
1049		<u>Second Order Reverse Mode</u></a>
1050
1051		<span id='children195'>
1052		<br/>                <a href="reverse_two.xml" target="_top">Second Order Reverse Mode</a>
1053
1054		<br/>                    <a href="reverse_two.cpp.xml" target="_top">Second Order Reverse ModeExample and Test</a>
1055
1056		<br/>                    <a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a>
1057		</span>
1058
1059		<br/>                <a onclick='Select(198)'
	1023	<br/>                <a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a>
	1024
	1025	<br/>                    <a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a>
	1026	</span>
	1027
	1028	<br/>                <a onclick='Select(194)'
	1029	onmouseover='MouseOver(194)'
	1030	onmouseout='MouseOut(194)'
	1031	><img src='_close.gif' name='folder194' align='middle' />
	1032	<u>Controlling Taylor Coefficients Memory Allocation</u></a>
	1033
	1034	<span id='children194'>
	1035	<br/>                <a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a>
	1036
	1037	<br/>                    <a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a>
	1038	</span>
	1039
	1040	<br/>                <a onclick='Select(196)'
	1041	onmouseover='MouseOver(196)'
	1042	onmouseout='MouseOut(196)'
	1043	><img src='_close.gif' name='folder196' align='middle' />
	1044	<u>Number of Variables that Can be Skipped</u></a>
	1045
	1046	<span id='children196'>
	1047	<br/>                <a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a>
	1048
	1049	<br/>                    <a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a>
	1050	</span>
	1051	</span>
	1052
	1053	<br/>            <a onclick='Select(198)'
1060	1054	onmouseover='MouseOver(198)'
1061	1055	onmouseout='MouseOut(198)'
1062	1056	><img src='_close.gif' name='folder198' align='middle' />
1063		<u>Any Order Reverse Mode</u></a>
	1057	<u>Reverse Mode</u></a>
1064	1058
1065	1059	<span id='children198'>
1066		<br/>                <a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a>
1067
1068		<br/>                    <a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a>
1069
1070		<br/>                    <a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a>
1071		</span>
1072		</span>
1073
1074		<br/>            <a onclick='Select(201)'
	1060	<br/>            <a href="reverse.xml" target="_top">Reverse Mode</a>
	1061
	1062	<br/>                <a onclick='Select(199)'
	1063	onmouseover='MouseOver(199)'
	1064	onmouseout='MouseOut(199)'
	1065	><img src='_close.gif' name='folder199' align='middle' />
	1066	<u>First Order Reverse Mode</u></a>
	1067
	1068	<span id='children199'>
	1069	<br/>                <a href="reverse_one.xml" target="_top">First Order Reverse Mode</a>
	1070
	1071	<br/>                    <a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a>
	1072	</span>
	1073
	1074	<br/>                <a onclick='Select(201)'
1075	1075	onmouseover='MouseOver(201)'
1076	1076	onmouseout='MouseOut(201)'
1077	1077	><img src='_close.gif' name='folder201' align='middle' />
1078		<u>Calculating Sparsity Patterns</u></a>
	1078	<u>Second Order Reverse Mode</u></a>
1079	1079
1080	1080	<span id='children201'>
1081		<br/>            <a href="sparse.xml" target="_top">Calculating Sparsity Patterns</a>
1082
1083		<br/>                <a onclick='Select(202)'
1084		onmouseover='MouseOver(202)'
1085		onmouseout='MouseOut(202)'
1086		><img src='_close.gif' name='folder202' align='middle' />
1087		<u>Jacobian Sparsity Pattern: Forward Mode</u></a>
1088
1089		<span id='children202'>
1090		<br/>                <a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a>
1091
1092		<br/>                    <a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a>
	1081	<br/>                <a href="reverse_two.xml" target="_top">Second Order Reverse Mode</a>
	1082
	1083	<br/>                    <a href="reverse_two.cpp.xml" target="_top">Second Order Reverse ModeExample and Test</a>
	1084
	1085	<br/>                    <a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a>
1093	1086	</span>
1094	1087
1095	1088	<br/>                <a onclick='Select(204)'
1096	1089	onmouseover='MouseOver(204)'
1097	1090	onmouseout='MouseOut(204)'
1098	1091	><img src='_close.gif' name='folder204' align='middle' />
1099		<u>Jacobian Sparsity Pattern: Reverse Mode</u></a>
	1092	<u>Any Order Reverse Mode</u></a>
1100	1093
1101	1094	<span id='children204'>
1102		<br/>                <a href="revsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Reverse Mode</a>
1103
1104		<br/>                    <a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a>
1105		</span>
1106
1107		<br/>                <a onclick='Select(206)'
1108		onmouseover='MouseOver(206)'
1109		onmouseout='MouseOut(206)'
1110		><img src='_close.gif' name='folder206' align='middle' />
1111		<u>Hessian Sparsity Pattern: Reverse Mode</u></a>
1112
1113		<span id='children206'>
1114		<br/>                <a href="revsparsehes.xml" target="_top">Hessian Sparsity Pattern: Reverse Mode</a>
1115
1116		<br/>                    <a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a>
1117		</span>
1118		</span>
1119		</span>
1120
1121		<br/>        <a onclick='Select(208)'
	1095	<br/>                <a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a>
	1096
	1097	<br/>                    <a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a>
	1098
	1099	<br/>                    <a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a>
	1100	</span>
	1101	</span>
	1102
	1103	<br/>            <a onclick='Select(207)'
	1104	onmouseover='MouseOver(207)'
	1105	onmouseout='MouseOut(207)'
	1106	><img src='_close.gif' name='folder207' align='middle' />
	1107	<u>Calculating Sparsity Patterns</u></a>
	1108
	1109	<span id='children207'>
	1110	<br/>            <a href="sparse.xml" target="_top">Calculating Sparsity Patterns</a>
	1111
	1112	<br/>                <a onclick='Select(208)'
1122	1113	onmouseover='MouseOver(208)'
1123	1114	onmouseout='MouseOut(208)'
1124	1115	><img src='_close.gif' name='folder208' align='middle' />
	1116	<u>Jacobian Sparsity Pattern: Forward Mode</u></a>
	1117
	1118	<span id='children208'>
	1119	<br/>                <a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a>
	1120
	1121	<br/>                    <a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a>
	1122	</span>
	1123
	1124	<br/>                <a onclick='Select(210)'
	1125	onmouseover='MouseOver(210)'
	1126	onmouseout='MouseOut(210)'
	1127	><img src='_close.gif' name='folder210' align='middle' />
	1128	<u>Jacobian Sparsity Pattern: Reverse Mode</u></a>
	1129
	1130	<span id='children210'>
	1131	<br/>                <a href="revsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Reverse Mode</a>
	1132
	1133	<br/>                    <a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a>
	1134	</span>
	1135
	1136	<br/>                <a onclick='Select(212)'
	1137	onmouseover='MouseOver(212)'
	1138	onmouseout='MouseOut(212)'
	1139	><img src='_close.gif' name='folder212' align='middle' />
	1140	<u>Hessian Sparsity Pattern: Reverse Mode</u></a>
	1141
	1142	<span id='children212'>
	1143	<br/>                <a href="revsparsehes.xml" target="_top">Hessian Sparsity Pattern: Reverse Mode</a>
	1144
	1145	<br/>                    <a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a>
	1146	</span>
	1147	</span>
	1148	</span>
	1149
	1150	<br/>        <a onclick='Select(214)'
	1151	onmouseover='MouseOver(214)'
	1152	onmouseout='MouseOut(214)'
	1153	><img src='_close.gif' name='folder214' align='middle' />
1125	1154	<u>First and Second Derivatives: Easy Drivers</u></a>
1126	1155
1127		<span id='children208'>
	1156	<span id='children214'>
1128	1157	<br/>        <a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a>
1129
1130		<br/>            <a onclick='Select(209)'
1131		onmouseover='MouseOver(209)'
1132		onmouseout='MouseOut(209)'
1133		><img src='_close.gif' name='folder209' align='middle' />
1134		<u>Jacobian: Driver Routine</u></a>
1135
1136		<span id='children209'>
1137		<br/>            <a href="jacobian.xml" target="_top">Jacobian: Driver Routine</a>
1138
1139		<br/>                <a href="jacobian.cpp.xml" target="_top">Jacobian: Example and Test</a>
1140		</span>
1141
1142		<br/>            <a onclick='Select(211)'
1143		onmouseover='MouseOver(211)'
1144		onmouseout='MouseOut(211)'
1145		><img src='_close.gif' name='folder211' align='middle' />
1146		<u>First Order Partial Derivative: Driver Routine</u></a>
1147
1148		<span id='children211'>
1149		<br/>            <a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a>
1150
1151		<br/>                <a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a>
1152		</span>
1153
1154		<br/>            <a onclick='Select(213)'
1155		onmouseover='MouseOver(213)'
1156		onmouseout='MouseOut(213)'
1157		><img src='_close.gif' name='folder213' align='middle' />
1158		<u>First Order Derivative: Driver Routine</u></a>
1159
1160		<span id='children213'>
1161		<br/>            <a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a>
1162
1163		<br/>                <a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a>
1164		</span>
1165	1158
1166	1159	<br/>            <a onclick='Select(215)'
1167	1160	onmouseover='MouseOver(215)'
1168	1161	onmouseout='MouseOut(215)'
1169	1162	><img src='_close.gif' name='folder215' align='middle' />
	1163	<u>Jacobian: Driver Routine</u></a>
	1164
	1165	<span id='children215'>
	1166	<br/>            <a href="jacobian.xml" target="_top">Jacobian: Driver Routine</a>
	1167
	1168	<br/>                <a href="jacobian.cpp.xml" target="_top">Jacobian: Example and Test</a>
	1169	</span>
	1170
	1171	<br/>            <a onclick='Select(217)'
	1172	onmouseover='MouseOver(217)'
	1173	onmouseout='MouseOut(217)'
	1174	><img src='_close.gif' name='folder217' align='middle' />
	1175	<u>First Order Partial Derivative: Driver Routine</u></a>
	1176
	1177	<span id='children217'>
	1178	<br/>            <a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a>
	1179
	1180	<br/>                <a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a>
	1181	</span>
	1182
	1183	<br/>            <a onclick='Select(219)'
	1184	onmouseover='MouseOver(219)'
	1185	onmouseout='MouseOut(219)'
	1186	><img src='_close.gif' name='folder219' align='middle' />
	1187	<u>First Order Derivative: Driver Routine</u></a>
	1188
	1189	<span id='children219'>
	1190	<br/>            <a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a>
	1191
	1192	<br/>                <a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a>
	1193	</span>
	1194
	1195	<br/>            <a onclick='Select(221)'
	1196	onmouseover='MouseOver(221)'
	1197	onmouseout='MouseOut(221)'
	1198	><img src='_close.gif' name='folder221' align='middle' />
1170	1199	<u>Hessian: Easy Driver</u></a>
1171	1200
1172		<span id='children215'>
	1201	<span id='children221'>
1173	1202	<br/>            <a href="hessian.xml" target="_top">Hessian: Easy Driver</a>
1174	1203
1175	1204	<br/>                <a href="hessian.cpp.xml" target="_top">Hessian: Example and Test</a>
1176	1205
1177	1206	<br/>                <a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and ADFun Default Constructor: Example and Test</a>
1178		</span>
1179
1180		<br/>            <a onclick='Select(218)'
1181		onmouseover='MouseOver(218)'
1182		onmouseout='MouseOut(218)'
1183		><img src='_close.gif' name='folder218' align='middle' />
1184		<u>Forward Mode Second Partial Derivative Driver</u></a>
1185
1186		<span id='children218'>
1187		<br/>            <a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a>
1188
1189		<br/>                <a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a>
1190		</span>
1191
1192		<br/>            <a onclick='Select(220)'
1193		onmouseover='MouseOver(220)'
1194		onmouseout='MouseOut(220)'
1195		><img src='_close.gif' name='folder220' align='middle' />
1196		<u>Reverse Mode Second Partial Derivative Driver</u></a>
1197
1198		<span id='children220'>
1199		<br/>            <a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a>
1200
1201		<br/>                <a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a>
1202		</span>
1203
1204		<br/>            <a onclick='Select(222)'
1205		onmouseover='MouseOver(222)'
1206		onmouseout='MouseOut(222)'
1207		><img src='_close.gif' name='folder222' align='middle' />
1208		<u>Sparse Jacobian: Easy Driver</u></a>
1209
1210		<span id='children222'>
1211		<br/>            <a href="sparse_jacobian.xml" target="_top">Sparse Jacobian: Easy Driver</a>
1212
1213		<br/>                <a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a>
1214	1207	</span>
1215	1208
1216	1209	<br/>            <a onclick='Select(224)'
1217	1210	onmouseover='MouseOver(224)'
1218	1211	onmouseout='MouseOut(224)'
1219	1212	><img src='_close.gif' name='folder224' align='middle' />
1220		<u>Sparse Hessian: Easy Driver</u></a>
	1213	<u>Forward Mode Second Partial Derivative Driver</u></a>
1221	1214
1222	1215	<span id='children224'>
1223		<br/>            <a href="sparse_hessian.xml" target="_top">Sparse Hessian: Easy Driver</a>
1224
1225		<br/>                <a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a>
1226		</span>
1227		</span>
1228
1229		<br/>        <a onclick='Select(226)'
	1216	<br/>            <a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a>
	1217
	1218	<br/>                <a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a>
	1219	</span>
	1220
	1221	<br/>            <a onclick='Select(226)'
1230	1222	onmouseover='MouseOver(226)'
1231	1223	onmouseout='MouseOut(226)'
1232	1224	><img src='_close.gif' name='folder226' align='middle' />
1233		<u>Check an ADFun Sequence of Operations</u></a>
	1225	<u>Reverse Mode Second Partial Derivative Driver</u></a>
1234	1226
1235	1227	<span id='children226'>
1236		<br/>        <a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a>
1237
1238		<br/>            <a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a>
1239		</span>
1240
1241		<br/>        <a onclick='Select(228)'
	1228	<br/>            <a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a>
	1229
	1230	<br/>                <a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a>
	1231	</span>
	1232
	1233	<br/>            <a onclick='Select(228)'
1242	1234	onmouseover='MouseOver(228)'
1243	1235	onmouseout='MouseOut(228)'
1244	1236	><img src='_close.gif' name='folder228' align='middle' />
1245		<u>Optimize an ADFun Object Tape</u></a>
	1237	<u>Sparse Jacobian: Easy Driver</u></a>
1246	1238
1247	1239	<span id='children228'>
1248		<br/>        <a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a>
1249
1250		<br/>            <a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a>
1251		</span>
1252
1253		<br/>        <a onclick='Select(230)'
	1240	<br/>            <a href="sparse_jacobian.xml" target="_top">Sparse Jacobian: Easy Driver</a>
	1241
	1242	<br/>                <a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a>
	1243	</span>
	1244
	1245	<br/>            <a onclick='Select(230)'
1254	1246	onmouseover='MouseOver(230)'
1255	1247	onmouseout='MouseOut(230)'
1256	1248	><img src='_close.gif' name='folder230' align='middle' />
	1249	<u>Sparse Hessian: Easy Driver</u></a>
	1250
	1251	<span id='children230'>
	1252	<br/>            <a href="sparse_hessian.xml" target="_top">Sparse Hessian: Easy Driver</a>
	1253
	1254	<br/>                <a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a>
	1255	</span>
	1256	</span>
	1257
	1258	<br/>        <a onclick='Select(232)'
	1259	onmouseover='MouseOver(232)'
	1260	onmouseout='MouseOut(232)'
	1261	><img src='_close.gif' name='folder232' align='middle' />
	1262	<u>Check an ADFun Sequence of Operations</u></a>
	1263
	1264	<span id='children232'>
	1265	<br/>        <a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a>
	1266
	1267	<br/>            <a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a>
	1268	</span>
	1269
	1270	<br/>        <a onclick='Select(234)'
	1271	onmouseover='MouseOver(234)'
	1272	onmouseout='MouseOut(234)'
	1273	><img src='_close.gif' name='folder234' align='middle' />
	1274	<u>Optimize an ADFun Object Tape</u></a>
	1275
	1276	<span id='children234'>
	1277	<br/>        <a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a>
	1278
	1279	<br/>            <a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a>
	1280	</span>
	1281
	1282	<br/>        <a onclick='Select(236)'
	1283	onmouseover='MouseOver(236)'
	1284	onmouseout='MouseOut(236)'
	1285	><img src='_close.gif' name='folder236' align='middle' />
1257	1286	<u>Check an ADFun Object For Nan</u></a>
1258	1287
1259		<span id='children230'>
	1288	<span id='children236'>
1260	1289	<br/>        <a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan</a>
1261	1290
1262	1291	<br/>            <a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a>

1265	1294
1266	1295	<br/>    <a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a>
1267	1296
1268		<br/>    <a onclick='Select(233)'
1269		onmouseover='MouseOver(233)'
1270		onmouseout='MouseOut(233)'
1271		><img src='_close.gif' name='folder233' align='middle' />
	1297	<br/>    <a onclick='Select(239)'
	1298	onmouseover='MouseOver(239)'
	1299	onmouseout='MouseOut(239)'
	1300	><img src='_close.gif' name='folder239' align='middle' />
1272	1301	<u>Using CppAD in a Multi-Threading Environment</u></a>
1273	1302
1274		<span id='children233'>
	1303	<span id='children239'>
1275	1304	<br/>    <a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a>
1276	1305
1277	1306	<br/>        <a href="parallel_ad.xml" target="_top">Enable AD Calculations During Parallel Mode</a>
1278	1307
1279		<br/>        <a onclick='Select(235)'
1280		onmouseover='MouseOver(235)'
1281		onmouseout='MouseOut(235)'
1282		><img src='_close.gif' name='folder235' align='middle' />
	1308	<br/>        <a onclick='Select(241)'
	1309	onmouseover='MouseOver(241)'
	1310	onmouseout='MouseOut(241)'
	1311	><img src='_close.gif' name='folder241' align='middle' />
1283	1312	<u>Run Multi-Threading Examples and Speed Tests</u></a>
1284	1313
1285		<span id='children235'>
	1314	<span id='children241'>
1286	1315	<br/>        <a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a>
1287	1316
1288	1317	<br/>            <a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a>

1298	1327	<br/>            <a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a>
1299	1328
1300	1329	<br/>            <a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a>
1301
1302		<br/>            <a onclick='Select(243)'
1303		onmouseover='MouseOver(243)'
1304		onmouseout='MouseOut(243)'
1305		><img src='_close.gif' name='folder243' align='middle' />
1306		<u>Multi-Threaded Implementation of Summation of 1/i</u></a>
1307
1308		<span id='children243'>
1309		<br/>            <a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a>
1310
1311		<br/>                <a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a>
1312
1313		<br/>                <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a>
1314		</span>
1315
1316		<br/>            <a onclick='Select(246)'
1317		onmouseover='MouseOver(246)'
1318		onmouseout='MouseOut(246)'
1319		><img src='_close.gif' name='folder246' align='middle' />
1320		<u>A Multi-Threaded Newton's Method</u></a>
1321
1322		<span id='children246'>
1323		<br/>            <a href="multi_newton.cpp.xml" target="_top">A Multi-Threaded Newton's Method</a>
1324
1325		<br/>                <a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a>
1326
1327		<br/>                <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a>
1328		</span>
1329	1330
1330	1331	<br/>            <a onclick='Select(249)'
1331	1332	onmouseover='MouseOver(249)'
1332	1333	onmouseout='MouseOut(249)'
1333	1334	><img src='_close.gif' name='folder249' align='middle' />
	1335	<u>Multi-Threaded Implementation of Summation of 1/i</u></a>
	1336
	1337	<span id='children249'>
	1338	<br/>            <a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a>
	1339
	1340	<br/>                <a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a>
	1341
	1342	<br/>                <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a>
	1343	</span>
	1344
	1345	<br/>            <a onclick='Select(252)'
	1346	onmouseover='MouseOver(252)'
	1347	onmouseout='MouseOut(252)'
	1348	><img src='_close.gif' name='folder252' align='middle' />
	1349	<u>A Multi-Threaded Newton's Method</u></a>
	1350
	1351	<span id='children252'>
	1352	<br/>            <a href="multi_newton.cpp.xml" target="_top">A Multi-Threaded Newton's Method</a>
	1353
	1354	<br/>                <a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a>
	1355
	1356	<br/>                <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a>
	1357	</span>
	1358
	1359	<br/>            <a onclick='Select(255)'
	1360	onmouseover='MouseOver(255)'
	1361	onmouseout='MouseOut(255)'
	1362	><img src='_close.gif' name='folder255' align='middle' />
1334	1363	<u>Specifications for A Team of AD Threads</u></a>
1335	1364
1336		<span id='children249'>
	1365	<span id='children255'>
1337	1366	<br/>            <a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a>
1338	1367
1339	1368	<br/>                <a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a>

1345	1374	</span>
1346	1375	</span>
1347	1376
1348		<br/>    <a onclick='Select(253)'
1349		onmouseover='MouseOver(253)'
1350		onmouseout='MouseOut(253)'
1351		><img src='_close.gif' name='folder253' align='middle' />
1352		<u>The CppAD General Purpose Library</u></a>
1353
1354		<span id='children253'>
1355		<br/>    <a href="library.xml" target="_top">The CppAD General Purpose Library</a>
1356
1357		<br/>        <a onclick='Select(254)'
1358		onmouseover='MouseOver(254)'
1359		onmouseout='MouseOut(254)'
1360		><img src='_close.gif' name='folder254' align='middle' />
1361		<u>Replacing the CppAD Error Handler</u></a>
1362
1363		<span id='children254'>
1364		<br/>        <a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a>
1365
1366		<br/>            <a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a>
1367
1368		<br/>            <a href="cppad_assert.xml" target="_top">CppAD Assertions During Execution</a>
1369		</span>
1370
1371		<br/>        <a onclick='Select(257)'
1372		onmouseover='MouseOver(257)'
1373		onmouseout='MouseOut(257)'
1374		><img src='_close.gif' name='folder257' align='middle' />
1375		<u>Determine if Two Values Are Nearly Equal</u></a>
1376
1377		<span id='children257'>
1378		<br/>        <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a>
1379
1380		<br/>            <a href="near_equal.cpp.xml" target="_top">NearEqual Function: Example and Test</a>
1381		</span>
1382
1383		<br/>        <a onclick='Select(259)'
	1377	<br/>    <a onclick='Select(259)'
1384	1378	onmouseover='MouseOver(259)'
1385	1379	onmouseout='MouseOut(259)'
1386	1380	><img src='_close.gif' name='folder259' align='middle' />
1387		<u>Run One Speed Test and Return Results</u></a>
	1381	<u>The CppAD General Purpose Library</u></a>
1388	1382
1389	1383	<span id='children259'>
1390		<br/>        <a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a>
1391
1392		<br/>            <a href="speed_test.cpp.xml" target="_top">speed_test: Example and test</a>
1393		</span>
1394
1395		<br/>        <a onclick='Select(261)'
1396		onmouseover='MouseOver(261)'
1397		onmouseout='MouseOut(261)'
1398		><img src='_close.gif' name='folder261' align='middle' />
1399		<u>Run One Speed Test and Print Results</u></a>
1400
1401		<span id='children261'>
1402		<br/>        <a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a>
1403
1404		<br/>            <a href="speed_program.cpp.xml" target="_top">Example Use of SpeedTest</a>
	1384	<br/>    <a href="library.xml" target="_top">The CppAD General Purpose Library</a>
	1385
	1386	<br/>        <a onclick='Select(260)'
	1387	onmouseover='MouseOver(260)'
	1388	onmouseout='MouseOut(260)'
	1389	><img src='_close.gif' name='folder260' align='middle' />
	1390	<u>Replacing the CppAD Error Handler</u></a>
	1391
	1392	<span id='children260'>
	1393	<br/>        <a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a>
	1394
	1395	<br/>            <a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a>
	1396
	1397	<br/>            <a href="cppad_assert.xml" target="_top">CppAD Assertions During Execution</a>
1405	1398	</span>
1406	1399
1407	1400	<br/>        <a onclick='Select(263)'
1408	1401	onmouseover='MouseOver(263)'
1409	1402	onmouseout='MouseOut(263)'
1410	1403	><img src='_close.gif' name='folder263' align='middle' />
1411		<u>Determine Amount of Time to Execute a Test</u></a>
	1404	<u>Determine if Two Values Are Nearly Equal</u></a>
1412	1405
1413	1406	<span id='children263'>
1414		<br/>        <a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a>
1415
1416		<br/>            <a onclick='Select(264)'
1417		onmouseover='MouseOver(264)'
1418		onmouseout='MouseOut(264)'
1419		><img src='_close.gif' name='folder264' align='middle' />
1420		<u>Returns Elapsed Number of Seconds</u></a>
1421
1422		<span id='children264'>
1423		<br/>            <a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a>
1424
1425		<br/>                <a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a>
1426		</span>
1427
1428		<br/>            <a href="time_test.cpp.xml" target="_top">time_test: Example and test</a>
	1407	<br/>        <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a>
	1408
	1409	<br/>            <a href="near_equal.cpp.xml" target="_top">NearEqual Function: Example and Test</a>
	1410	</span>
	1411
	1412	<br/>        <a onclick='Select(265)'
	1413	onmouseover='MouseOver(265)'
	1414	onmouseout='MouseOut(265)'
	1415	><img src='_close.gif' name='folder265' align='middle' />
	1416	<u>Run One Speed Test and Return Results</u></a>
	1417
	1418	<span id='children265'>
	1419	<br/>        <a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a>
	1420
	1421	<br/>            <a href="speed_test.cpp.xml" target="_top">speed_test: Example and test</a>
1429	1422	</span>
1430	1423
1431	1424	<br/>        <a onclick='Select(267)'
1432	1425	onmouseover='MouseOver(267)'
1433	1426	onmouseout='MouseOut(267)'
1434	1427	><img src='_close.gif' name='folder267' align='middle' />
1435		<u>Definition of a Numeric Type</u></a>
	1428	<u>Run One Speed Test and Print Results</u></a>
1436	1429
1437	1430	<span id='children267'>
1438		<br/>        <a href="numerictype.xml" target="_top">Definition of a Numeric Type</a>
1439
1440		<br/>            <a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a>
	1431	<br/>        <a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a>
	1432
	1433	<br/>            <a href="speed_program.cpp.xml" target="_top">Example Use of SpeedTest</a>
1441	1434	</span>
1442	1435
1443	1436	<br/>        <a onclick='Select(269)'
1444	1437	onmouseover='MouseOver(269)'
1445	1438	onmouseout='MouseOut(269)'
1446	1439	><img src='_close.gif' name='folder269' align='middle' />
1447		<u>Check NumericType Class Concept</u></a>
	1440	<u>Determine Amount of Time to Execute a Test</u></a>
1448	1441
1449	1442	<span id='children269'>
1450		<br/>        <a href="checknumerictype.xml" target="_top">Check NumericType Class Concept</a>
1451
1452		<br/>            <a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a>
1453		</span>
1454
1455		<br/>        <a onclick='Select(271)'
1456		onmouseover='MouseOver(271)'
1457		onmouseout='MouseOut(271)'
1458		><img src='_close.gif' name='folder271' align='middle' />
1459		<u>Definition of a Simple Vector</u></a>
1460
1461		<span id='children271'>
1462		<br/>        <a href="simplevector.xml" target="_top">Definition of a Simple Vector</a>
1463
1464		<br/>            <a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a>
	1443	<br/>        <a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a>
	1444
	1445	<br/>            <a onclick='Select(270)'
	1446	onmouseover='MouseOver(270)'
	1447	onmouseout='MouseOut(270)'
	1448	><img src='_close.gif' name='folder270' align='middle' />
	1449	<u>Returns Elapsed Number of Seconds</u></a>
	1450
	1451	<span id='children270'>
	1452	<br/>            <a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a>
	1453
	1454	<br/>                <a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a>
	1455	</span>
	1456
	1457	<br/>            <a href="time_test.cpp.xml" target="_top">time_test: Example and test</a>
1465	1458	</span>
1466	1459
1467	1460	<br/>        <a onclick='Select(273)'
1468	1461	onmouseover='MouseOver(273)'
1469	1462	onmouseout='MouseOut(273)'
1470	1463	><img src='_close.gif' name='folder273' align='middle' />
1471		<u>Check Simple Vector Concept</u></a>
	1464	<u>Definition of a Numeric Type</u></a>
1472	1465
1473	1466	<span id='children273'>
1474		<br/>        <a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a>
1475
1476		<br/>            <a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a>
	1467	<br/>        <a href="numerictype.xml" target="_top">Definition of a Numeric Type</a>
	1468
	1469	<br/>            <a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a>
1477	1470	</span>
1478	1471
1479	1472	<br/>        <a onclick='Select(275)'
1480	1473	onmouseover='MouseOver(275)'
1481	1474	onmouseout='MouseOut(275)'
1482	1475	><img src='_close.gif' name='folder275' align='middle' />
1483		<u>Obtain Nan or Determine if a Value is Nan</u></a>
	1476	<u>Check NumericType Class Concept</u></a>
1484	1477
1485	1478	<span id='children275'>
1486		<br/>        <a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a>
1487
1488		<br/>            <a href="nan.cpp.xml" target="_top">nan: Example and Test</a>
	1479	<br/>        <a href="checknumerictype.xml" target="_top">Check NumericType Class Concept</a>
	1480
	1481	<br/>            <a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a>
1489	1482	</span>
1490	1483
1491	1484	<br/>        <a onclick='Select(277)'
1492	1485	onmouseover='MouseOver(277)'
1493	1486	onmouseout='MouseOut(277)'
1494	1487	><img src='_close.gif' name='folder277' align='middle' />
1495		<u>The Integer Power Function</u></a>
	1488	<u>Definition of a Simple Vector</u></a>
1496	1489
1497	1490	<span id='children277'>
1498		<br/>        <a href="pow_int.xml" target="_top">The Integer Power Function</a>
1499
1500		<br/>            <a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a>
	1491	<br/>        <a href="simplevector.xml" target="_top">Definition of a Simple Vector</a>
	1492
	1493	<br/>            <a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a>
1501	1494	</span>
1502	1495
1503	1496	<br/>        <a onclick='Select(279)'
1504	1497	onmouseover='MouseOver(279)'
1505	1498	onmouseout='MouseOut(279)'
1506	1499	><img src='_close.gif' name='folder279' align='middle' />
1507		<u>Evaluate a Polynomial or its Derivative</u></a>
	1500	<u>Check Simple Vector Concept</u></a>
1508	1501
1509	1502	<span id='children279'>
1510		<br/>        <a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a>
1511
1512		<br/>            <a href="poly.cpp.xml" target="_top">Polynomial Evaluation: Example and Test</a>
1513
1514		<br/>            <a href="poly.hpp.xml" target="_top">Source: Poly</a>
1515		</span>
1516
1517		<br/>        <a onclick='Select(282)'
1518		onmouseover='MouseOver(282)'
1519		onmouseout='MouseOut(282)'
1520		><img src='_close.gif' name='folder282' align='middle' />
1521		<u>Compute Determinants and Solve Equations by LU Factorization</u></a>
1522
1523		<span id='children282'>
1524		<br/>        <a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a>
1525
1526		<br/>            <a onclick='Select(283)'
	1503	<br/>        <a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a>
	1504
	1505	<br/>            <a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a>
	1506	</span>
	1507
	1508	<br/>        <a onclick='Select(281)'
	1509	onmouseover='MouseOver(281)'
	1510	onmouseout='MouseOut(281)'
	1511	><img src='_close.gif' name='folder281' align='middle' />
	1512	<u>Obtain Nan or Determine if a Value is Nan</u></a>
	1513
	1514	<span id='children281'>
	1515	<br/>        <a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a>
	1516
	1517	<br/>            <a href="nan.cpp.xml" target="_top">nan: Example and Test</a>
	1518	</span>
	1519
	1520	<br/>        <a onclick='Select(283)'
1527	1521	onmouseover='MouseOver(283)'
1528	1522	onmouseout='MouseOut(283)'
1529	1523	><img src='_close.gif' name='folder283' align='middle' />
1530		<u>Compute Determinant and Solve Linear Equations</u></a>
	1524	<u>The Integer Power Function</u></a>
1531	1525
1532	1526	<span id='children283'>
1533		<br/>            <a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a>
1534
1535		<br/>                <a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a>
1536
1537		<br/>                <a href="lu_solve.hpp.xml" target="_top">Source: LuSolve</a>
1538		</span>
1539
1540		<br/>            <a onclick='Select(286)'
1541		onmouseover='MouseOver(286)'
1542		onmouseout='MouseOut(286)'
1543		><img src='_close.gif' name='folder286' align='middle' />
1544		<u>LU Factorization of A Square Matrix</u></a>
1545
1546		<span id='children286'>
1547		<br/>            <a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a>
1548
1549		<br/>                <a href="lu_factor.cpp.xml" target="_top">LuFactor: Example and Test</a>
1550
1551		<br/>                <a href="lu_factor.hpp.xml" target="_top">Source: LuFactor</a>
1552		</span>
	1527	<br/>        <a href="pow_int.xml" target="_top">The Integer Power Function</a>
	1528
	1529	<br/>            <a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a>
	1530	</span>
	1531
	1532	<br/>        <a onclick='Select(285)'
	1533	onmouseover='MouseOver(285)'
	1534	onmouseout='MouseOut(285)'
	1535	><img src='_close.gif' name='folder285' align='middle' />
	1536	<u>Evaluate a Polynomial or its Derivative</u></a>
	1537
	1538	<span id='children285'>
	1539	<br/>        <a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a>
	1540
	1541	<br/>            <a href="poly.cpp.xml" target="_top">Polynomial Evaluation: Example and Test</a>
	1542
	1543	<br/>            <a href="poly.hpp.xml" target="_top">Source: Poly</a>
	1544	</span>
	1545
	1546	<br/>        <a onclick='Select(288)'
	1547	onmouseover='MouseOver(288)'
	1548	onmouseout='MouseOut(288)'
	1549	><img src='_close.gif' name='folder288' align='middle' />
	1550	<u>Compute Determinants and Solve Equations by LU Factorization</u></a>
	1551
	1552	<span id='children288'>
	1553	<br/>        <a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a>
1553	1554
1554	1555	<br/>            <a onclick='Select(289)'
1555	1556	onmouseover='MouseOver(289)'
1556	1557	onmouseout='MouseOut(289)'
1557	1558	><img src='_close.gif' name='folder289' align='middle' />
1558		<u>Invert an LU Factored Equation</u></a>
	1559	<u>Compute Determinant and Solve Linear Equations</u></a>
1559	1560
1560	1561	<span id='children289'>
1561		<br/>            <a href="luinvert.xml" target="_top">Invert an LU Factored Equation</a>
1562
1563		<br/>                <a href="lu_invert.cpp.xml" target="_top">LuInvert: Example and Test</a>
1564
1565		<br/>                <a href="lu_invert.hpp.xml" target="_top">Source: LuInvert</a>
1566		</span>
1567		</span>
1568
1569		<br/>        <a onclick='Select(292)'
	1562	<br/>            <a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a>
	1563
	1564	<br/>                <a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a>
	1565
	1566	<br/>                <a href="lu_solve.hpp.xml" target="_top">Source: LuSolve</a>
	1567	</span>
	1568
	1569	<br/>            <a onclick='Select(292)'
1570	1570	onmouseover='MouseOver(292)'
1571	1571	onmouseout='MouseOut(292)'
1572	1572	><img src='_close.gif' name='folder292' align='middle' />
	1573	<u>LU Factorization of A Square Matrix</u></a>
	1574
	1575	<span id='children292'>
	1576	<br/>            <a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a>
	1577
	1578	<br/>                <a href="lu_factor.cpp.xml" target="_top">LuFactor: Example and Test</a>
	1579
	1580	<br/>                <a href="lu_factor.hpp.xml" target="_top">Source: LuFactor</a>
	1581	</span>
	1582
	1583	<br/>            <a onclick='Select(295)'
	1584	onmouseover='MouseOver(295)'
	1585	onmouseout='MouseOut(295)'
	1586	><img src='_close.gif' name='folder295' align='middle' />
	1587	<u>Invert an LU Factored Equation</u></a>
	1588
	1589	<span id='children295'>
	1590	<br/>            <a href="luinvert.xml" target="_top">Invert an LU Factored Equation</a>
	1591
	1592	<br/>                <a href="lu_invert.cpp.xml" target="_top">LuInvert: Example and Test</a>
	1593
	1594	<br/>                <a href="lu_invert.hpp.xml" target="_top">Source: LuInvert</a>
	1595	</span>
	1596	</span>
	1597
	1598	<br/>        <a onclick='Select(298)'
	1599	onmouseover='MouseOver(298)'
	1600	onmouseout='MouseOut(298)'
	1601	><img src='_close.gif' name='folder298' align='middle' />
1573	1602	<u>One DimensionalRomberg Integration</u></a>
1574	1603
1575		<span id='children292'>
	1604	<span id='children298'>
1576	1605	<br/>        <a href="rombergone.xml" target="_top">One DimensionalRomberg Integration</a>
1577	1606
1578	1607	<br/>            <a href="romberg_one.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a>
1579	1608	</span>
1580	1609
1581		<br/>        <a onclick='Select(294)'
1582		onmouseover='MouseOver(294)'
1583		onmouseout='MouseOut(294)'
1584		><img src='_close.gif' name='folder294' align='middle' />
	1610	<br/>        <a onclick='Select(300)'
	1611	onmouseover='MouseOver(300)'
	1612	onmouseout='MouseOut(300)'
	1613	><img src='_close.gif' name='folder300' align='middle' />
1585	1614	<u>Multi-dimensional Romberg Integration</u></a>
1586	1615
1587		<span id='children294'>
	1616	<span id='children300'>
1588	1617	<br/>        <a href="rombergmul.xml" target="_top">Multi-dimensional Romberg Integration</a>
1589	1618
1590	1619	<br/>            <a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a>
1591	1620	</span>
1592	1621
1593		<br/>        <a onclick='Select(296)'
1594		onmouseover='MouseOver(296)'
1595		onmouseout='MouseOut(296)'
1596		><img src='_close.gif' name='folder296' align='middle' />
	1622	<br/>        <a onclick='Select(302)'
	1623	onmouseover='MouseOver(302)'
	1624	onmouseout='MouseOut(302)'
	1625	><img src='_close.gif' name='folder302' align='middle' />
1597	1626	<u>An Embedded 4th and 5th Order Runge-Kutta ODE Solver</u></a>
1598	1627
1599		<span id='children296'>
	1628	<span id='children302'>
1600	1629	<br/>        <a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a>
1601	1630
1602	1631	<br/>            <a href="runge45_1.cpp.xml" target="_top">Runge45: Example and Test</a>

1604	1633	<br/>            <a href="runge45_2.cpp.xml" target="_top">Runge45: Example and Test</a>
1605	1634	</span>
1606	1635
1607		<br/>        <a onclick='Select(299)'
1608		onmouseover='MouseOver(299)'
1609		onmouseout='MouseOut(299)'
1610		><img src='_close.gif' name='folder299' align='middle' />
	1636	<br/>        <a onclick='Select(305)'
	1637	onmouseover='MouseOver(305)'
	1638	onmouseout='MouseOut(305)'
	1639	><img src='_close.gif' name='folder305' align='middle' />
1611	1640	<u>A 3rd and 4th Order Rosenbrock ODE Solver</u></a>
1612	1641
1613		<span id='children299'>
	1642	<span id='children305'>
1614	1643	<br/>        <a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a>
1615	1644
1616	1645	<br/>            <a href="rosen_34.cpp.xml" target="_top">Rosen34: Example and Test</a>
1617	1646	</span>
1618	1647
1619		<br/>        <a onclick='Select(301)'
1620		onmouseover='MouseOver(301)'
1621		onmouseout='MouseOut(301)'
1622		><img src='_close.gif' name='folder301' align='middle' />
	1648	<br/>        <a onclick='Select(307)'
	1649	onmouseover='MouseOver(307)'
	1650	onmouseout='MouseOut(307)'
	1651	><img src='_close.gif' name='folder307' align='middle' />
1623	1652	<u>An Error Controller for ODE Solvers</u></a>
1624	1653
1625		<span id='children301'>
	1654	<span id='children307'>
1626	1655	<br/>        <a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a>
1627	1656
1628	1657	<br/>            <a href="ode_err_control.cpp.xml" target="_top">OdeErrControl: Example and Test</a>

1630	1659	<br/>            <a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a>
1631	1660	</span>
1632	1661
1633		<br/>        <a onclick='Select(304)'
1634		onmouseover='MouseOver(304)'
1635		onmouseout='MouseOut(304)'
1636		><img src='_close.gif' name='folder304' align='middle' />
	1662	<br/>        <a onclick='Select(310)'
	1663	onmouseover='MouseOver(310)'
	1664	onmouseout='MouseOut(310)'
	1665	><img src='_close.gif' name='folder310' align='middle' />
1637	1666	<u>An Arbitrary Order Gear Method</u></a>
1638	1667
1639		<span id='children304'>
	1668	<span id='children310'>
1640	1669	<br/>        <a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a>
1641	1670
1642	1671	<br/>            <a href="ode_gear.cpp.xml" target="_top">OdeGear: Example and Test</a>
1643	1672	</span>
1644	1673
1645		<br/>        <a onclick='Select(306)'
1646		onmouseover='MouseOver(306)'
1647		onmouseout='MouseOut(306)'
1648		><img src='_close.gif' name='folder306' align='middle' />
	1674	<br/>        <a onclick='Select(312)'
	1675	onmouseover='MouseOver(312)'
	1676	onmouseout='MouseOut(312)'
	1677	><img src='_close.gif' name='folder312' align='middle' />
1649	1678	<u>An Error Controller for Gear's Ode Solvers</u></a>
1650	1679
1651		<span id='children306'>
	1680	<span id='children312'>
1652	1681	<br/>        <a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a>
1653	1682
1654	1683	<br/>            <a href="ode_gear_control.cpp.xml" target="_top">OdeGearControl: Example and Test</a>
1655	1684	</span>
1656	1685
1657		<br/>        <a onclick='Select(308)'
1658		onmouseover='MouseOver(308)'
1659		onmouseout='MouseOut(308)'
1660		><img src='_close.gif' name='folder308' align='middle' />
	1686	<br/>        <a onclick='Select(314)'
	1687	onmouseover='MouseOver(314)'
	1688	onmouseout='MouseOut(314)'
	1689	><img src='_close.gif' name='folder314' align='middle' />
1661	1690	<u>The CppAD::vector Template Class</u></a>
1662	1691
1663		<span id='children308'>
	1692	<span id='children314'>
1664	1693	<br/>        <a href="cppad_vector.xml" target="_top">The CppAD::vector Template Class</a>
1665	1694
1666	1695	<br/>            <a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a>

1668	1697	<br/>            <a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a>
1669	1698	</span>
1670	1699
1671		<br/>        <a onclick='Select(311)'
1672		onmouseover='MouseOver(311)'
1673		onmouseout='MouseOut(311)'
1674		><img src='_close.gif' name='folder311' align='middle' />
	1700	<br/>        <a onclick='Select(317)'
	1701	onmouseover='MouseOver(317)'
	1702	onmouseout='MouseOut(317)'
	1703	><img src='_close.gif' name='folder317' align='middle' />
1675	1704	<u>A Fast Multi-Threading Memory Allocator</u></a>
1676	1705
1677		<span id='children311'>
	1706	<span id='children317'>
1678	1707	<br/>        <a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a>
1679	1708
1680	1709	<br/>            <a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a>

1704	1733	<br/>            <a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a>
1705	1734
1706	1735	<br/>            <a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a>
1707		</span>
1708
1709		<br/>        <a onclick='Select(326)'
1710		onmouseover='MouseOver(326)'
1711		onmouseout='MouseOut(326)'
1712		><img src='_close.gif' name='folder326' align='middle' />
1713		<u>Returns Indices that Sort a Vector</u></a>
1714
1715		<span id='children326'>
1716		<br/>        <a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a>
1717
1718		<br/>            <a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a>
1719		</span>
1720
1721		<br/>        <a onclick='Select(328)'
1722		onmouseover='MouseOver(328)'
1723		onmouseout='MouseOut(328)'
1724		><img src='_close.gif' name='folder328' align='middle' />
1725		<u>Computing Jacobian and Hessian of Bender's Reduced Objective</u></a>
1726
1727		<span id='children328'>
1728		<br/>        <a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a>
1729
1730		<br/>            <a href="bender_quad.cpp.xml" target="_top">BenderQuad: Example and Test</a>
1731		</span>
1732
1733		<br/>        <a onclick='Select(330)'
1734		onmouseover='MouseOver(330)'
1735		onmouseout='MouseOut(330)'
1736		><img src='_close.gif' name='folder330' align='middle' />
1737		<u>Jacobian and Hessian of Optimal Values</u></a>
1738
1739		<span id='children330'>
1740		<br/>        <a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a>
1741
1742		<br/>            <a href="opt_val_hes.cpp.xml" target="_top">opt_val_hes: Example and Test</a>
1743	1736	</span>
1744	1737
1745	1738	<br/>        <a onclick='Select(332)'
1746	1739	onmouseover='MouseOver(332)'
1747	1740	onmouseout='MouseOut(332)'
1748	1741	><img src='_close.gif' name='folder332' align='middle' />
1749		<u>LU Factorization of A Square Matrix and Stability Calculation</u></a>
	1742	<u>Returns Indices that Sort a Vector</u></a>
1750	1743
1751	1744	<span id='children332'>
1752		<br/>        <a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a>
1753
1754		<br/>            <a href="lu_ratio.cpp.xml" target="_top">LuRatio: Example and Test</a>
1755		</span>
1756		</span>
1757
1758		<br/>    <a onclick='Select(334)'
	1745	<br/>        <a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a>
	1746
	1747	<br/>            <a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a>
	1748	</span>
	1749
	1750	<br/>        <a onclick='Select(334)'
1759	1751	onmouseover='MouseOver(334)'
1760	1752	onmouseout='MouseOut(334)'
1761	1753	><img src='_close.gif' name='folder334' align='middle' />
1762		<u>Use Ipopt to Solve a Nonlinear Programming Problem</u></a>
	1754	<u>Computing Jacobian and Hessian of Bender's Reduced Objective</u></a>
1763	1755
1764	1756	<span id='children334'>
1765		<br/>    <a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a>
1766
1767		<br/>        <a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a>
1768
1769		<br/>        <a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a>
1770
1771		<br/>        <a href="ipopt_solve_ode_inverse.cpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a>
1772		</span>
1773
1774		<br/>    <a onclick='Select(338)'
	1757	<br/>        <a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a>
	1758
	1759	<br/>            <a href="bender_quad.cpp.xml" target="_top">BenderQuad: Example and Test</a>
	1760	</span>
	1761
	1762	<br/>        <a onclick='Select(336)'
	1763	onmouseover='MouseOver(336)'
	1764	onmouseout='MouseOut(336)'
	1765	><img src='_close.gif' name='folder336' align='middle' />
	1766	<u>Jacobian and Hessian of Optimal Values</u></a>
	1767
	1768	<span id='children336'>
	1769	<br/>        <a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a>
	1770
	1771	<br/>            <a href="opt_val_hes.cpp.xml" target="_top">opt_val_hes: Example and Test</a>
	1772	</span>
	1773
	1774	<br/>        <a onclick='Select(338)'
1775	1775	onmouseover='MouseOver(338)'
1776	1776	onmouseout='MouseOut(338)'
1777	1777	><img src='_close.gif' name='folder338' align='middle' />
	1778	<u>LU Factorization of A Square Matrix and Stability Calculation</u></a>
	1779
	1780	<span id='children338'>
	1781	<br/>        <a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a>
	1782
	1783	<br/>            <a href="lu_ratio.cpp.xml" target="_top">LuRatio: Example and Test</a>
	1784	</span>
	1785	</span>
	1786
	1787	<br/>    <a onclick='Select(340)'
	1788	onmouseover='MouseOver(340)'
	1789	onmouseout='MouseOut(340)'
	1790	><img src='_close.gif' name='folder340' align='middle' />
	1791	<u>Use Ipopt to Solve a Nonlinear Programming Problem</u></a>
	1792
	1793	<span id='children340'>
	1794	<br/>    <a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a>
	1795
	1796	<br/>        <a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a>
	1797
	1798	<br/>        <a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a>
	1799
	1800	<br/>        <a href="ipopt_solve_ode_inverse.cpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a>
	1801	</span>
	1802
	1803	<br/>    <a onclick='Select(344)'
	1804	onmouseover='MouseOver(344)'
	1805	onmouseout='MouseOut(344)'
	1806	><img src='_close.gif' name='folder344' align='middle' />
1778	1807	<u>Examples</u></a>
1779	1808
1780		<span id='children338'>
	1809	<span id='children344'>
1781	1810	<br/>    <a href="example.xml" target="_top">Examples</a>
1782	1811
1783		<br/>        <a onclick='Select(339)'
1784		onmouseover='MouseOver(339)'
1785		onmouseout='MouseOut(339)'
1786		><img src='_close.gif' name='folder339' align='middle' />
	1812	<br/>        <a onclick='Select(345)'
	1813	onmouseover='MouseOver(345)'
	1814	onmouseout='MouseOut(345)'
	1815	><img src='_close.gif' name='folder345' align='middle' />
1787	1816	<u>General Examples</u></a>
1788	1817
1789		<span id='children339'>
	1818	<span id='children345'>
1790	1819	<br/>        <a href="general.xml" target="_top">General Examples</a>
1791	1820
1792	1821	<br/>            <a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a>

1795	1824
1796	1825	<br/>            <a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a>
1797	1826
1798		<br/>            <a onclick='Select(343)'
1799		onmouseover='MouseOver(343)'
1800		onmouseout='MouseOut(343)'
1801		><img src='_close.gif' name='folder343' align='middle' />
	1827	<br/>            <a onclick='Select(349)'
	1828	onmouseover='MouseOver(349)'
	1829	onmouseout='MouseOut(349)'
	1830	><img src='_close.gif' name='folder349' align='middle' />
1802	1831	<u>Enable Use of Eigen Linear Algebra Package with CppAD</u></a>
1803	1832
1804		<span id='children343'>
	1833	<span id='children349'>
1805	1834	<br/>            <a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a>
1806	1835
1807	1836	<br/>                <a href="eigen_plugin.hpp.xml" target="_top">Source Code for eigen_plugin.hpp</a>

1821	1850
1822	1851	<br/>            <a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a>
1823	1852
1824		<br/>            <a onclick='Select(352)'
1825		onmouseover='MouseOver(352)'
1826		onmouseout='MouseOut(352)'
1827		><img src='_close.gif' name='folder352' align='middle' />
	1853	<br/>            <a onclick='Select(358)'
	1854	onmouseover='MouseOver(358)'
	1855	onmouseout='MouseOut(358)'
	1856	><img src='_close.gif' name='folder358' align='middle' />
1828	1857	<u>Using Multiple Levels of AD</u></a>
1829	1858
1830		<span id='children352'>
	1859	<span id='children358'>
1831	1860	<br/>            <a href="mul_level.xml" target="_top">Using Multiple Levels of AD</a>
1832	1861
1833	1862	<br/>                <a href="mul_level.cpp.xml" target="_top">Multiple Tapes: Example and Test</a>

1846	1875	<br/>            <a href="stack_machine.cpp.xml" target="_top">Example Differentiating a Stack Machine Interpreter</a>
1847	1876	</span>
1848	1877
1849		<br/>        <a onclick='Select(360)'
1850		onmouseover='MouseOver(360)'
1851		onmouseout='MouseOut(360)'
1852		><img src='_close.gif' name='folder360' align='middle' />
	1878	<br/>        <a onclick='Select(366)'
	1879	onmouseover='MouseOver(366)'
	1880	onmouseout='MouseOut(366)'
	1881	><img src='_close.gif' name='folder366' align='middle' />
1853	1882	<u>Utility Routines used by CppAD Examples</u></a>
1854	1883
1855		<span id='children360'>
	1884	<span id='children366'>
1856	1885	<br/>        <a href="exampleutility.xml" target="_top">Utility Routines used by CppAD Examples</a>
1857	1886
1858	1887	<br/>            <a href="example.cpp.xml" target="_top">CppAD Examples and Tests</a>
1859	1888
1860	1889	<br/>            <a href="speed_example.cpp.xml" target="_top">Run the Speed Examples</a>
1861	1890
1862		<br/>            <a onclick='Select(363)'
1863		onmouseover='MouseOver(363)'
1864		onmouseout='MouseOut(363)'
1865		><img src='_close.gif' name='folder363' align='middle' />
	1891	<br/>            <a onclick='Select(369)'
	1892	onmouseover='MouseOver(369)'
	1893	onmouseout='MouseOut(369)'
	1894	><img src='_close.gif' name='folder369' align='middle' />
1866	1895	<u>Lu Factor and Solve with Recorded Pivoting</u></a>
1867	1896
1868		<span id='children363'>
	1897	<span id='children369'>
1869	1898	<br/>            <a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a>
1870	1899
1871	1900	<br/>                <a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a>

1877	1906	<br/>        <a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a>
1878	1907	</span>
1879	1908
1880		<br/>    <a onclick='Select(367)'
1881		onmouseover='MouseOver(367)'
1882		onmouseout='MouseOut(367)'
1883		><img src='_close.gif' name='folder367' align='middle' />
1884		<u>AD Speed Test Routines</u></a>
1885
1886		<span id='children367'>
1887		<br/>    <a href="speed.xml" target="_top">AD Speed Test Routines</a>
1888
1889		<br/>        <a onclick='Select(368)'
1890		onmouseover='MouseOver(368)'
1891		onmouseout='MouseOut(368)'
1892		><img src='_close.gif' name='folder368' align='middle' />
1893		<u>Speed Testing Main Program</u></a>
1894
1895		<span id='children368'>
1896		<br/>        <a href="speed_main.xml" target="_top">Speed Testing Main Program</a>
	1909	<br/>    <a onclick='Select(373)'
	1910	onmouseover='MouseOver(373)'
	1911	onmouseout='MouseOut(373)'
	1912	><img src='_close.gif' name='folder373' align='middle' />
	1913	<u>Speed Test an Operator Overloading AD Package</u></a>
	1914
	1915	<span id='children373'>
	1916	<br/>    <a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a>
	1917
	1918	<br/>        <a onclick='Select(374)'
	1919	onmouseover='MouseOver(374)'
	1920	onmouseout='MouseOut(374)'
	1921	><img src='_close.gif' name='folder374' align='middle' />
	1922	<u>Running the Speed Test Program</u></a>
	1923
	1924	<span id='children374'>
	1925	<br/>        <a href="speed_main.xml" target="_top">Running the Speed Test Program</a>
1897	1926
1898	1927	<br/>            <a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a>
1899	1928

1912	1941	<br/>            <a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a>
1913	1942	</span>
1914	1943
1915		<br/>        <a onclick='Select(377)'
1916		onmouseover='MouseOver(377)'
1917		onmouseout='MouseOut(377)'
1918		><img src='_close.gif' name='folder377' align='middle' />
	1944	<br/>        <a onclick='Select(383)'
	1945	onmouseover='MouseOver(383)'
	1946	onmouseout='MouseOut(383)'
	1947	><img src='_close.gif' name='folder383' align='middle' />
1919	1948	<u>Speed Testing Utilities</u></a>
1920	1949
1921		<span id='children377'>
	1950	<span id='children383'>
1922	1951	<br/>        <a href="speed_utility.xml" target="_top">Speed Testing Utilities</a>
1923
1924		<br/>            <a onclick='Select(378)'
1925		onmouseover='MouseOver(378)'
1926		onmouseout='MouseOut(378)'
1927		><img src='_close.gif' name='folder378' align='middle' />
1928		<u>Determinant Using Expansion by Lu Factorization</u></a>
1929
1930		<span id='children378'>
1931		<br/>            <a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a>
1932
1933		<br/>                <a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a>
1934
1935		<br/>                <a href="det_by_lu.hpp.xml" target="_top">Source: det_by_lu</a>
1936		</span>
1937
1938		<br/>            <a onclick='Select(381)'
1939		onmouseover='MouseOver(381)'
1940		onmouseout='MouseOut(381)'
1941		><img src='_close.gif' name='folder381' align='middle' />
1942		<u>Determinant of a Minor</u></a>
1943
1944		<span id='children381'>
1945		<br/>            <a href="det_of_minor.xml" target="_top">Determinant of a Minor</a>
1946
1947		<br/>                <a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a>
1948
1949		<br/>                <a href="det_of_minor.hpp.xml" target="_top">Source: det_of_minor</a>
1950		</span>
1951	1952
1952	1953	<br/>            <a onclick='Select(384)'
1953	1954	onmouseover='MouseOver(384)'
1954	1955	onmouseout='MouseOut(384)'
1955	1956	><img src='_close.gif' name='folder384' align='middle' />
1956		<u>Determinant Using Expansion by Minors</u></a>
	1957	<u>Determinant Using Expansion by Lu Factorization</u></a>
1957	1958
1958	1959	<span id='children384'>
1959		<br/>            <a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a>
1960
1961		<br/>                <a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a>
1962
1963		<br/>                <a href="det_by_minor.hpp.xml" target="_top">Source: det_by_minor</a>
	1960	<br/>            <a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a>
	1961
	1962	<br/>                <a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a>
	1963
	1964	<br/>                <a href="det_by_lu.hpp.xml" target="_top">Source: det_by_lu</a>
1964	1965	</span>
1965	1966
1966	1967	<br/>            <a onclick='Select(387)'
1967	1968	onmouseover='MouseOver(387)'
1968	1969	onmouseout='MouseOut(387)'
1969	1970	><img src='_close.gif' name='folder387' align='middle' />
	1971	<u>Determinant of a Minor</u></a>
	1972
	1973	<span id='children387'>
	1974	<br/>            <a href="det_of_minor.xml" target="_top">Determinant of a Minor</a>
	1975
	1976	<br/>                <a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a>
	1977
	1978	<br/>                <a href="det_of_minor.hpp.xml" target="_top">Source: det_of_minor</a>
	1979	</span>
	1980
	1981	<br/>            <a onclick='Select(390)'
	1982	onmouseover='MouseOver(390)'
	1983	onmouseout='MouseOut(390)'
	1984	><img src='_close.gif' name='folder390' align='middle' />
	1985	<u>Determinant Using Expansion by Minors</u></a>
	1986
	1987	<span id='children390'>
	1988	<br/>            <a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a>
	1989
	1990	<br/>                <a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a>
	1991
	1992	<br/>                <a href="det_by_minor.hpp.xml" target="_top">Source: det_by_minor</a>
	1993	</span>
	1994
	1995	<br/>            <a onclick='Select(393)'
	1996	onmouseover='MouseOver(393)'
	1997	onmouseout='MouseOut(393)'
	1998	><img src='_close.gif' name='folder393' align='middle' />
1970	1999	<u>Check Determinant of 3 by 3 matrix</u></a>
1971	2000
1972		<span id='children387'>
	2001	<span id='children393'>
1973	2002	<br/>            <a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a>
1974	2003
1975	2004	<br/>                <a href="det_33.hpp.xml" target="_top">Source: det_33</a>
1976	2005	</span>
1977	2006
1978		<br/>            <a onclick='Select(389)'
1979		onmouseover='MouseOver(389)'
1980		onmouseout='MouseOut(389)'
1981		><img src='_close.gif' name='folder389' align='middle' />
	2007	<br/>            <a onclick='Select(395)'
	2008	onmouseover='MouseOver(395)'
	2009	onmouseout='MouseOut(395)'
	2010	><img src='_close.gif' name='folder395' align='middle' />
1982	2011	<u>Check Gradient of Determinant of 3 by 3 matrix</u></a>
1983	2012
1984		<span id='children389'>
	2013	<span id='children395'>
1985	2014	<br/>            <a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a>
1986	2015
1987	2016	<br/>                <a href="det_grad_33.hpp.xml" target="_top">Source: det_grad_33</a>
1988		</span>
1989
1990		<br/>            <a onclick='Select(391)'
1991		onmouseover='MouseOver(391)'
1992		onmouseout='MouseOut(391)'
1993		><img src='_close.gif' name='folder391' align='middle' />
1994		<u>Sum Elements of a Matrix Times Itself</u></a>
1995
1996		<span id='children391'>
1997		<br/>            <a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a>
1998
1999		<br/>                <a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a>
2000
2001		<br/>                <a href="mat_sum_sq.hpp.xml" target="_top">Source: mat_sum_sq</a>
2002		</span>
2003
2004		<br/>            <a onclick='Select(394)'
2005		onmouseover='MouseOver(394)'
2006		onmouseout='MouseOut(394)'
2007		><img src='_close.gif' name='folder394' align='middle' />
2008		<u>Evaluate a Function Defined in Terms of an ODE</u></a>
2009
2010		<span id='children394'>
2011		<br/>            <a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a>
2012
2013		<br/>                <a href="ode_evaluate.cpp.xml" target="_top">ode_evaluate: Example and test</a>
2014
2015		<br/>                <a href="ode_evaluate.hpp.xml" target="_top">Source: ode_evaluate</a>
2016	2017	</span>
2017	2018
2018	2019	<br/>            <a onclick='Select(397)'
2019	2020	onmouseover='MouseOver(397)'
2020	2021	onmouseout='MouseOut(397)'
2021	2022	><img src='_close.gif' name='folder397' align='middle' />
2022		<u>Evaluate a Function That Has a Sparse Jacobian</u></a>
	2023	<u>Sum Elements of a Matrix Times Itself</u></a>
2023	2024
2024	2025	<span id='children397'>
2025		<br/>            <a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a>
2026
2027		<br/>                <a href="sparse_jac_fun.cpp.xml" target="_top">sparse_jac_fun: Example and test</a>
2028
2029		<br/>                <a href="sparse_jac_fun.hpp.xml" target="_top">Source: sparse_jac_fun</a>
	2026	<br/>            <a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a>
	2027
	2028	<br/>                <a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a>
	2029
	2030	<br/>                <a href="mat_sum_sq.hpp.xml" target="_top">Source: mat_sum_sq</a>
2030	2031	</span>
2031	2032
2032	2033	<br/>            <a onclick='Select(400)'
2033	2034	onmouseover='MouseOver(400)'
2034	2035	onmouseout='MouseOut(400)'
2035	2036	><img src='_close.gif' name='folder400' align='middle' />
2036		<u>Evaluate a Function That Has a Sparse Hessian</u></a>
	2037	<u>Evaluate a Function Defined in Terms of an ODE</u></a>
2037	2038
2038	2039	<span id='children400'>
2039		<br/>            <a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a>
2040
2041		<br/>                <a href="sparse_hes_fun.cpp.xml" target="_top">sparse_hes_fun: Example and test</a>
2042
2043		<br/>                <a href="sparse_hes_fun.hpp.xml" target="_top">Source: sparse_hes_fun</a>
	2040	<br/>            <a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a>
	2041
	2042	<br/>                <a href="ode_evaluate.cpp.xml" target="_top">ode_evaluate: Example and test</a>
	2043
	2044	<br/>                <a href="ode_evaluate.hpp.xml" target="_top">Source: ode_evaluate</a>
2044	2045	</span>
2045	2046
2046	2047	<br/>            <a onclick='Select(403)'
2047	2048	onmouseover='MouseOver(403)'
2048	2049	onmouseout='MouseOut(403)'
2049	2050	><img src='_close.gif' name='folder403' align='middle' />
	2051	<u>Evaluate a Function That Has a Sparse Jacobian</u></a>
	2052
	2053	<span id='children403'>
	2054	<br/>            <a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a>
	2055
	2056	<br/>                <a href="sparse_jac_fun.cpp.xml" target="_top">sparse_jac_fun: Example and test</a>
	2057
	2058	<br/>                <a href="sparse_jac_fun.hpp.xml" target="_top">Source: sparse_jac_fun</a>
	2059	</span>
	2060
	2061	<br/>            <a onclick='Select(406)'
	2062	onmouseover='MouseOver(406)'
	2063	onmouseout='MouseOut(406)'
	2064	><img src='_close.gif' name='folder406' align='middle' />
	2065	<u>Evaluate a Function That Has a Sparse Hessian</u></a>
	2066
	2067	<span id='children406'>
	2068	<br/>            <a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a>
	2069
	2070	<br/>                <a href="sparse_hes_fun.cpp.xml" target="_top">sparse_hes_fun: Example and test</a>
	2071
	2072	<br/>                <a href="sparse_hes_fun.hpp.xml" target="_top">Source: sparse_hes_fun</a>
	2073	</span>
	2074
	2075	<br/>            <a onclick='Select(409)'
	2076	onmouseover='MouseOver(409)'
	2077	onmouseout='MouseOut(409)'
	2078	><img src='_close.gif' name='folder409' align='middle' />
2050	2079	<u>Simulate a [0,1] Uniform Random Variate</u></a>
2051	2080
2052		<span id='children403'>
	2081	<span id='children409'>
2053	2082	<br/>            <a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a>
2054	2083
2055	2084	<br/>                <a href="uniform_01.hpp.xml" target="_top">Source: uniform_01</a>
2056	2085	</span>
2057	2086	</span>
2058	2087
2059		<br/>        <a onclick='Select(405)'
2060		onmouseover='MouseOver(405)'
2061		onmouseout='MouseOut(405)'
2062		><img src='_close.gif' name='folder405' align='middle' />
	2088	<br/>        <a onclick='Select(411)'
	2089	onmouseover='MouseOver(411)'
	2090	onmouseout='MouseOut(411)'
	2091	><img src='_close.gif' name='folder411' align='middle' />
2063	2092	<u>Speed Test of Functions in Double</u></a>
2064	2093
2065		<span id='children405'>
	2094	<span id='children411'>
2066	2095	<br/>        <a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a>
2067	2096
2068	2097	<br/>            <a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a>

2080	2109	<br/>            <a href="double_sparse_jacobian.cpp.xml" target="_top">Double Speed: Sparse Jacobian</a>
2081	2110	</span>
2082	2111
2083		<br/>        <a onclick='Select(413)'
2084		onmouseover='MouseOver(413)'
2085		onmouseout='MouseOut(413)'
2086		><img src='_close.gif' name='folder413' align='middle' />
	2112	<br/>        <a onclick='Select(419)'
	2113	onmouseover='MouseOver(419)'
	2114	onmouseout='MouseOut(419)'
	2115	><img src='_close.gif' name='folder419' align='middle' />
2087	2116	<u>Speed Test of Derivatives Using Adolc</u></a>
2088	2117
2089		<span id='children413'>
	2118	<span id='children419'>
2090	2119	<br/>        <a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a>
2091	2120
2092	2121	<br/>            <a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a>

2106	2135	<br/>            <a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a>
2107	2136	</span>
2108	2137
2109		<br/>        <a onclick='Select(422)'
2110		onmouseover='MouseOver(422)'
2111		onmouseout='MouseOut(422)'
2112		><img src='_close.gif' name='folder422' align='middle' />
	2138	<br/>        <a onclick='Select(428)'
	2139	onmouseover='MouseOver(428)'
	2140	onmouseout='MouseOut(428)'
	2141	><img src='_close.gif' name='folder428' align='middle' />
2113	2142	<u>Speed Test Derivatives Using CppAD</u></a>
2114	2143
2115		<span id='children422'>
	2144	<span id='children428'>
2116	2145	<br/>        <a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a>
2117	2146
2118	2147	<br/>            <a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a>

2128	2157	<br/>            <a href="cppad_sparse_hessian.cpp.xml" target="_top">CppAD Speed: Sparse Hessian</a>
2129	2158
2130	2159	<br/>            <a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a>
2131
2132		<br/>            <a href="cppad_print_optimize.xml" target="_top">Speed Test Utility: Optimize Operation Sequences and Print Results</a>
2133		</span>
2134
2135		<br/>        <a onclick='Select(431)'
2136		onmouseover='MouseOver(431)'
2137		onmouseout='MouseOut(431)'
2138		><img src='_close.gif' name='folder431' align='middle' />
	2160	</span>
	2161
	2162	<br/>        <a onclick='Select(436)'
	2163	onmouseover='MouseOver(436)'
	2164	onmouseout='MouseOut(436)'
	2165	><img src='_close.gif' name='folder436' align='middle' />
2139	2166	<u>Speed Test Derivatives Using Fadbad</u></a>
2140	2167
2141		<span id='children431'>
	2168	<span id='children436'>
2142	2169	<br/>        <a href="speed_fadbad.xml" target="_top">Speed Test Derivatives Using Fadbad</a>
2143	2170
2144	2171	<br/>            <a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a>

2156	2183	<br/>            <a href="fadbad_sparse_jacobian.cpp.xml" target="_top">fadbad Speed: sparse_jacobian</a>
2157	2184	</span>
2158	2185
2159		<br/>        <a onclick='Select(439)'
2160		onmouseover='MouseOver(439)'
2161		onmouseout='MouseOut(439)'
2162		><img src='_close.gif' name='folder439' align='middle' />
	2186	<br/>        <a onclick='Select(444)'
	2187	onmouseover='MouseOver(444)'
	2188	onmouseout='MouseOut(444)'
	2189	><img src='_close.gif' name='folder444' align='middle' />
2163	2190	<u>Speed Test Derivatives Using Sacado</u></a>
2164	2191
2165		<span id='children439'>
	2192	<span id='children444'>
2166	2193	<br/>        <a href="speed_sacado.xml" target="_top">Speed Test Derivatives Using Sacado</a>
2167	2194
2168	2195	<br/>            <a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a>

2181	2208	</span>
2182	2209	</span>
2183	2210
2184		<br/>    <a onclick='Select(447)'
2185		onmouseover='MouseOver(447)'
2186		onmouseout='MouseOut(447)'
2187		><img src='_close.gif' name='folder447' align='middle' />
	2211	<br/>    <a onclick='Select(452)'
	2212	onmouseover='MouseOver(452)'
	2213	onmouseout='MouseOut(452)'
	2214	><img src='_close.gif' name='folder452' align='middle' />
2188	2215	<u>Appendix</u></a>
2189	2216
2190		<span id='children447'>
	2217	<span id='children452'>
2191	2218	<br/>    <a href="appendix.xml" target="_top">Appendix</a>
2192	2219
2193	2220	<br/>        <a href="faq.xml" target="_top">Frequently Asked Questions and Answers</a>
2194	2221
2195		<br/>        <a onclick='Select(449)'
2196		onmouseover='MouseOver(449)'
2197		onmouseout='MouseOut(449)'
2198		><img src='_close.gif' name='folder449' align='middle' />
	2222	<br/>        <a onclick='Select(454)'
	2223	onmouseover='MouseOver(454)'
	2224	onmouseout='MouseOut(454)'
	2225	><img src='_close.gif' name='folder454' align='middle' />
2199	2226	<u>The Theory of Derivative Calculations</u></a>
2200	2227
2201		<span id='children449'>
	2228	<span id='children454'>
2202	2229	<br/>        <a href="theory.xml" target="_top">The Theory of Derivative Calculations</a>
2203	2230
2204		<br/>            <a onclick='Select(450)'
2205		onmouseover='MouseOver(450)'
2206		onmouseout='MouseOut(450)'
2207		><img src='_close.gif' name='folder450' align='middle' />
	2231	<br/>            <a onclick='Select(455)'
	2232	onmouseover='MouseOver(455)'
	2233	onmouseout='MouseOut(455)'
	2234	><img src='_close.gif' name='folder455' align='middle' />
2208	2235	<u>The Theory of Forward Mode</u></a>
2209	2236
2210		<span id='children450'>
	2237	<span id='children455'>
2211	2238	<br/>            <a href="forwardtheory.xml" target="_top">The Theory of Forward Mode</a>
2212	2239
2213	2240	<br/>                <a href="expforward.xml" target="_top">Exponential Function Forward Taylor Polynomial Theory</a>

2225	2252	<br/>                <a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a>
2226	2253
2227	2254	<br/>                <a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a>
2228		</span>
2229
2230		<br/>            <a onclick='Select(459)'
2231		onmouseover='MouseOver(459)'
2232		onmouseout='MouseOut(459)'
2233		><img src='_close.gif' name='folder459' align='middle' />
	2255
	2256	<br/>                <a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a>
	2257	</span>
	2258
	2259	<br/>            <a onclick='Select(465)'
	2260	onmouseover='MouseOver(465)'
	2261	onmouseout='MouseOut(465)'
	2262	><img src='_close.gif' name='folder465' align='middle' />
2234	2263	<u>The Theory of Reverse Mode</u></a>
2235	2264
2236		<span id='children459'>
	2265	<span id='children465'>
2237	2266	<br/>            <a href="reversetheory.xml" target="_top">The Theory of Reverse Mode</a>
2238	2267
2239	2268	<br/>                <a href="expreverse.xml" target="_top">Exponential Function Reverse Mode Theory</a>

2251	2280	<br/>                <a href="acosreverse.xml" target="_top">Arccosine Function Reverse Mode Theory</a>
2252	2281
2253	2282	<br/>                <a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a>
	2283
	2284	<br/>                <a href="erf_reverse.xml" target="_top">Error Function Reverse Mode Theory</a>
2254	2285	</span>
2255	2286
2256	2287	<br/>            <a href="reverse_identity.xml" target="_top">An Important Reverse Mode Identity</a>

2264	2295
2265	2296	<br/>        <a href="wishlist.xml" target="_top">The CppAD Wish List</a>
2266	2297
2267		<br/>        <a onclick='Select(473)'
2268		onmouseover='MouseOver(473)'
2269		onmouseout='MouseOut(473)'
2270		><img src='_close.gif' name='folder473' align='middle' />
	2298	<br/>        <a onclick='Select(480)'
	2299	onmouseover='MouseOver(480)'
	2300	onmouseout='MouseOut(480)'
	2301	><img src='_close.gif' name='folder480' align='middle' />
2271	2302	<u>Changes and Additions to CppAD</u></a>
2272	2303
2273		<span id='children473'>
	2304	<span id='children480'>
2274	2305	<br/>        <a href="whats_new.xml" target="_top">Changes and Additions to CppAD</a>
2275	2306
	2307	<br/>            <a href="whats_new_14.xml" target="_top">CppAD Changes and Additions During 2014</a>
	2308
2276	2309	<br/>            <a href="whats_new_13.xml" target="_top">CppAD Changes and Additions During 2013</a>
2277	2310
2278	2311	<br/>            <a href="whats_new_12.xml" target="_top">CppAD Changes and Additions During 2012</a>

2296	2329	<br/>            <a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a>
2297	2330	</span>
2298	2331
2299		<br/>        <a onclick='Select(485)'
2300		onmouseover='MouseOver(485)'
2301		onmouseout='MouseOut(485)'
2302		><img src='_close.gif' name='folder485' align='middle' />
	2332	<br/>        <a onclick='Select(493)'
	2333	onmouseover='MouseOver(493)'
	2334	onmouseout='MouseOut(493)'
	2335	><img src='_close.gif' name='folder493' align='middle' />
2303	2336	<u>CppAD Deprecated API Features</u></a>
2304	2337
2305		<span id='children485'>
	2338	<span id='children493'>
2306	2339	<br/>        <a href="deprecated.xml" target="_top">CppAD Deprecated API Features</a>
2307	2340
2308	2341	<br/>            <a href="include_deprecated.xml" target="_top">Deprecated Include Files</a>

2311	2344
2312	2345	<br/>            <a href="omp_max_thread.xml" target="_top">OpenMP Parallel Setup</a>
2313	2346
2314		<br/>            <a onclick='Select(489)'
2315		onmouseover='MouseOver(489)'
2316		onmouseout='MouseOut(489)'
2317		><img src='_close.gif' name='folder489' align='middle' />
	2347	<br/>            <a onclick='Select(497)'
	2348	onmouseover='MouseOver(497)'
	2349	onmouseout='MouseOut(497)'
	2350	><img src='_close.gif' name='folder497' align='middle' />
2318	2351	<u>Routines That Track Use of New and Delete</u></a>
2319	2352
2320		<span id='children489'>
	2353	<span id='children497'>
2321	2354	<br/>            <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a>
2322	2355
2323	2356	<br/>                <a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a>
2324	2357	</span>
2325	2358
2326		<br/>            <a onclick='Select(491)'
2327		onmouseover='MouseOver(491)'
2328		onmouseout='MouseOut(491)'
2329		><img src='_close.gif' name='folder491' align='middle' />
	2359	<br/>            <a onclick='Select(499)'
	2360	onmouseover='MouseOver(499)'
	2361	onmouseout='MouseOut(499)'
	2362	><img src='_close.gif' name='folder499' align='middle' />
2330	2363	<u>A Quick OpenMP Memory Allocator Used by CppAD</u></a>
2331	2364
2332		<span id='children491'>
	2365	<span id='children499'>
2333	2366	<br/>            <a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a>
2334	2367
2335	2368	<br/>                <a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a>

2365	2398
2366	2399	<br/>            <a href="test_vector.xml" target="_top">Choosing The Vector Testing Template Class</a>
2367	2400
2368		<br/>            <a onclick='Select(508)'
2369		onmouseover='MouseOver(508)'
2370		onmouseout='MouseOut(508)'
2371		><img src='_close.gif' name='folder508' align='middle' />
	2401	<br/>            <a onclick='Select(516)'
	2402	onmouseover='MouseOver(516)'
	2403	onmouseout='MouseOut(516)'
	2404	><img src='_close.gif' name='folder516' align='middle' />
2372	2405	<u>Nonlinear Programming Using the CppAD Interface to Ipopt</u></a>
2373	2406
2374		<span id='children508'>
	2407	<span id='children516'>
2375	2408	<br/>            <a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a>
2376	2409
2377	2410	<br/>                <a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a>
2378	2411
2379		<br/>                <a onclick='Select(510)'
2380		onmouseover='MouseOver(510)'
2381		onmouseout='MouseOut(510)'
2382		><img src='_close.gif' name='folder510' align='middle' />
	2412	<br/>                <a onclick='Select(518)'
	2413	onmouseover='MouseOver(518)'
	2414	onmouseout='MouseOut(518)'
	2415	><img src='_close.gif' name='folder518' align='middle' />
2383	2416	<u>Example Simultaneous Solution of Forward and Inverse Problem</u></a>
2384	2417
2385		<span id='children510'>
	2418	<span id='children518'>
2386	2419	<br/>                <a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a>
2387	2420
2388		<br/>                    <a onclick='Select(511)'
2389		onmouseover='MouseOver(511)'
2390		onmouseout='MouseOut(511)'
2391		><img src='_close.gif' name='folder511' align='middle' />
	2421	<br/>                    <a onclick='Select(519)'
	2422	onmouseover='MouseOver(519)'
	2423	onmouseout='MouseOut(519)'
	2424	><img src='_close.gif' name='folder519' align='middle' />
2392	2425	<u>An ODE Inverse Problem Example</u></a>
2393	2426
2394		<span id='children511'>
	2427	<span id='children519'>
2395	2428	<br/>                    <a href="ipopt_nlp_ode_problem.xml" target="_top">An ODE Inverse Problem Example</a>
2396	2429
2397	2430	<br/>                        <a href="ipopt_nlp_ode_problem.hpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a>
2398	2431	</span>
2399	2432
2400		<br/>                    <a onclick='Select(513)'
2401		onmouseover='MouseOver(513)'
2402		onmouseout='MouseOut(513)'
2403		><img src='_close.gif' name='folder513' align='middle' />
	2433	<br/>                    <a onclick='Select(521)'
	2434	onmouseover='MouseOver(521)'
	2435	onmouseout='MouseOut(521)'
	2436	><img src='_close.gif' name='folder521' align='middle' />
2404	2437	<u>ODE Fitting Using Simple Representation</u></a>
2405	2438
2406		<span id='children513'>
	2439	<span id='children521'>
2407	2440	<br/>                    <a href="ipopt_nlp_ode_simple.xml" target="_top">ODE Fitting Using Simple Representation</a>
2408	2441
2409	2442	<br/>                        <a href="ipopt_nlp_ode_simple.hpp.xml" target="_top">ODE Fitting Using Simple Representation</a>
2410	2443	</span>
2411	2444
2412		<br/>                    <a onclick='Select(515)'
2413		onmouseover='MouseOver(515)'
2414		onmouseout='MouseOut(515)'
2415		><img src='_close.gif' name='folder515' align='middle' />
	2445	<br/>                    <a onclick='Select(523)'
	2446	onmouseover='MouseOver(523)'
	2447	onmouseout='MouseOut(523)'
	2448	><img src='_close.gif' name='folder523' align='middle' />
2416	2449	<u>ODE Fitting Using Fast Representation</u></a>
2417	2450
2418		<span id='children515'>
	2451	<span id='children523'>
2419	2452	<br/>                    <a href="ipopt_nlp_ode_fast.xml" target="_top">ODE Fitting Using Fast Representation</a>
2420	2453
2421	2454	<br/>                        <a href="ipopt_nlp_ode_fast.hpp.xml" target="_top">ODE Fitting Using Fast Representation</a>

2429	2462	<br/>                <a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a>
2430	2463	</span>
2431	2464
2432		<br/>            <a onclick='Select(520)'
2433		onmouseover='MouseOver(520)'
2434		onmouseout='MouseOut(520)'
2435		><img src='_close.gif' name='folder520' align='middle' />
	2465	<br/>            <a onclick='Select(528)'
	2466	onmouseover='MouseOver(528)'
	2467	onmouseout='MouseOut(528)'
	2468	><img src='_close.gif' name='folder528' align='middle' />
2436	2469	<u>User Defined Atomic AD Functions</u></a>
2437	2470
2438		<span id='children520'>
	2471	<span id='children528'>
2439	2472	<br/>            <a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a>
2440	2473
2441	2474	<br/>                <a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a>

2446	2479
2447	2480	<br/>                <a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a>
2448	2481
2449		<br/>                <a onclick='Select(525)'
2450		onmouseover='MouseOver(525)'
2451		onmouseout='MouseOut(525)'
2452		><img src='_close.gif' name='folder525' align='middle' />
	2482	<br/>                <a onclick='Select(533)'
	2483	onmouseover='MouseOver(533)'
	2484	onmouseout='MouseOut(533)'
	2485	><img src='_close.gif' name='folder533' align='middle' />
2453	2486	<u>Matrix Multiply as a User Atomic Operation: Example and Test</u></a>
2454	2487
2455		<span id='children525'>
	2488	<span id='children533'>
2456	2489	<br/>                <a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a>
2457	2490
2458	2491	<br/>                    <a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a>

2460	2493	</span>
2461	2494	</span>
2462	2495
2463		<br/>        <a onclick='Select(527)'
2464		onmouseover='MouseOver(527)'
2465		onmouseout='MouseOut(527)'
2466		><img src='_close.gif' name='folder527' align='middle' />
	2496	<br/>        <a onclick='Select(535)'
	2497	onmouseover='MouseOver(535)'
	2498	onmouseout='MouseOut(535)'
	2499	><img src='_close.gif' name='folder535' align='middle' />
2467	2500	<u>Compare Speed of C and C++</u></a>
2468	2501
2469		<span id='children527'>
	2502	<span id='children535'>
2470	2503	<br/>        <a href="compare_c.xml" target="_top">Compare Speed of C and C++</a>
2471	2504
2472	2505	<br/>            <a href="det_of_minor_c.xml" target="_top">Determinant of a Minor</a>

-2

doc/_cppad_det_lu.cpp_xml.js less more

39	39	'cppad_ode.cpp.xml',
40	40	'cppad_poly.cpp.xml',
41	41	'cppad_sparse_hessian.cpp.xml',
42		'cppad_sparse_jacobian.cpp.xml',
43		'cppad_print_optimize.xml'
	42	'cppad_sparse_jacobian.cpp.xml'
44	43	];
45	44	var list_current0 = [
46	45	'cppad_det_lu.cpp.xml#Specifications',

-2

doc/_cppad_det_minor.cpp_xml.js less more

39	39	'cppad_ode.cpp.xml',
40	40	'cppad_poly.cpp.xml',
41	41	'cppad_sparse_hessian.cpp.xml',
42		'cppad_sparse_jacobian.cpp.xml',
43		'cppad_print_optimize.xml'
	42	'cppad_sparse_jacobian.cpp.xml'
44	43	];
45	44	var list_current0 = [
46	45	'cppad_det_minor.cpp.xml#Specifications',

-2

doc/_cppad_mat_mul.cpp_xml.js less more

39	39	'cppad_ode.cpp.xml',
40	40	'cppad_poly.cpp.xml',
41	41	'cppad_sparse_hessian.cpp.xml',
42		'cppad_sparse_jacobian.cpp.xml',
43		'cppad_print_optimize.xml'
	42	'cppad_sparse_jacobian.cpp.xml'
44	43	];
45	44	var list_current0 = [
46	45	'cppad_mat_mul.cpp.xml#Specifications',

-2

doc/_cppad_ode.cpp_xml.js less more

39	39	'cppad_ode.cpp.xml',
40	40	'cppad_poly.cpp.xml',
41	41	'cppad_sparse_hessian.cpp.xml',
42		'cppad_sparse_jacobian.cpp.xml',
43		'cppad_print_optimize.xml'
	42	'cppad_sparse_jacobian.cpp.xml'
44	43	];
45	44	var list_current0 = [
46	45	'cppad_ode.cpp.xml#Specifications',

-2

doc/_cppad_poly.cpp_xml.js less more

39	39	'cppad_ode.cpp.xml',
40	40	'cppad_poly.cpp.xml',
41	41	'cppad_sparse_hessian.cpp.xml',
42		'cppad_sparse_jacobian.cpp.xml',
43		'cppad_print_optimize.xml'
	42	'cppad_sparse_jacobian.cpp.xml'
44	43	];
45	44	var list_current0 = [
46	45	'cppad_poly.cpp.xml#Specifications',

-95

~~doc/_cppad_print_optimize_xml.js~~ less more

0		var list_across0 = [
1		'_contents_xml.htm',
2		'_reference.xml',
3		'_index.xml',
4		'_search_xml.htm',
5		'_external.xml'
6		];
7		var list_up0 = [
8		'cppad.xml',
9		'speed.xml',
10		'speed_cppad.xml',
11		'cppad_print_optimize.xml'
12		];
13		var list_down3 = [
14		'install.xml',
15		'introduction.xml',
16		'ad.xml',
17		'adfun.xml',
18		'preprocessor.xml',
19		'multi_thread.xml',
20		'library.xml',
21		'ipopt_solve.xml',
22		'example.xml',
23		'speed.xml',
24		'appendix.xml'
25		];
26		var list_down2 = [
27		'speed_main.xml',
28		'speed_utility.xml',
29		'speed_double.xml',
30		'speed_adolc.xml',
31		'speed_cppad.xml',
32		'speed_fadbad.xml',
33		'speed_sacado.xml'
34		];
35		var list_down1 = [
36		'cppad_det_minor.cpp.xml',
37		'cppad_det_lu.cpp.xml',
38		'cppad_mat_mul.cpp.xml',
39		'cppad_ode.cpp.xml',
40		'cppad_poly.cpp.xml',
41		'cppad_sparse_hessian.cpp.xml',
42		'cppad_sparse_jacobian.cpp.xml',
43		'cppad_print_optimize.xml'
44		];
45		var list_current0 = [
46		'cppad_print_optimize.xml#Syntax',
47		'cppad_print_optimize.xml#Purpose',
48		'cppad_print_optimize.xml#f',
49		'cppad_print_optimize.xml#print',
50		'cppad_print_optimize.xml#label',
51		'cppad_print_optimize.xml#test_id'
52		];
53		function choose_across0(item)
54		{ var index = item.selectedIndex;
55		item.selectedIndex = 0;
56		if(index > 0)
57		document.location = list_across0[index-1];
58		}
59		function choose_up0(item)
60		{ var index = item.selectedIndex;
61		item.selectedIndex = 0;
62		if(index > 0)
63		document.location = list_up0[index-1];
64		}
65		function choose_down3(item)
66		{ var index = item.selectedIndex;
67		item.selectedIndex = 0;
68		if(index > 0)
69		document.location = list_down3[index-1];
70		}
71		function choose_down2(item)
72		{ var index = item.selectedIndex;
73		item.selectedIndex = 0;
74		if(index > 0)
75		document.location = list_down2[index-1];
76		}
77		function choose_down1(item)
78		{ var index = item.selectedIndex;
79		item.selectedIndex = 0;
80		if(index > 0)
81		document.location = list_down1[index-1];
82		}
83		function choose_down0(item)
84		{ var index = item.selectedIndex;
85		item.selectedIndex = 0;
86		if(index > 0)
87		document.location = list_down0[index-1];
88		}
89		function choose_current0(item)
90		{ var index = item.selectedIndex;
91		item.selectedIndex = 0;
92		if(index > 0)
93		document.location = list_current0[index-1];
94		}

-2

doc/_cppad_sparse_hessian.cpp_xml.js less more

39	39	'cppad_ode.cpp.xml',
40	40	'cppad_poly.cpp.xml',
41	41	'cppad_sparse_hessian.cpp.xml',
42		'cppad_sparse_jacobian.cpp.xml',
43		'cppad_print_optimize.xml'
	42	'cppad_sparse_jacobian.cpp.xml'
44	43	];
45	44	var list_current0 = [
46	45	'cppad_sparse_hessian.cpp.xml#Specifications',

-2

doc/_cppad_sparse_jacobian.cpp_xml.js less more

39	39	'cppad_ode.cpp.xml',
40	40	'cppad_poly.cpp.xml',
41	41	'cppad_sparse_hessian.cpp.xml',
42		'cppad_sparse_jacobian.cpp.xml',
43		'cppad_print_optimize.xml'
	42	'cppad_sparse_jacobian.cpp.xml'
44	43	];
45	44	var list_current0 = [
46	45	'cppad_sparse_jacobian.cpp.xml#Specifications',

-73

~~doc/_cppad_test_xml.js~~ less more

0		var list_across0 = [
1		'_contents_xml.htm',
2		'_reference.xml',
3		'_index.xml',
4		'_search_xml.htm',
5		'_external.xml'
6		];
7		var list_up0 = [
8		'cppad.xml',
9		'install.xml',
10		'cppad_test.xml'
11		];
12		var list_down2 = [
13		'install.xml',
14		'introduction.xml',
15		'ad.xml',
16		'adfun.xml',
17		'preprocessor.xml',
18		'multi_thread.xml',
19		'library.xml',
20		'ipopt_solve.xml',
21		'example.xml',
22		'speed.xml',
23		'appendix.xml'
24		];
25		var list_down1 = [
26		'download.xml',
27		'cmake.xml',
28		'cppad_test.xml',
29		'pkgconfig.xml',
30		'installunix.xml'
31		];
32		var list_current0 = [
33		'cppad_test.xml#Purpose',
34		'cppad_test.xml#Run All',
35		'cppad_test.xml#Subsets'
36		];
37		function choose_across0(item)
38		{ var index = item.selectedIndex;
39		item.selectedIndex = 0;
40		if(index > 0)
41		document.location = list_across0[index-1];
42		}
43		function choose_up0(item)
44		{ var index = item.selectedIndex;
45		item.selectedIndex = 0;
46		if(index > 0)
47		document.location = list_up0[index-1];
48		}
49		function choose_down2(item)
50		{ var index = item.selectedIndex;
51		item.selectedIndex = 0;
52		if(index > 0)
53		document.location = list_down2[index-1];
54		}
55		function choose_down1(item)
56		{ var index = item.selectedIndex;
57		item.selectedIndex = 0;
58		if(index > 0)
59		document.location = list_down1[index-1];
60		}
61		function choose_down0(item)
62		{ var index = item.selectedIndex;
63		item.selectedIndex = 0;
64		if(index > 0)
65		document.location = list_down0[index-1];
66		}
67		function choose_current0(item)
68		{ var index = item.selectedIndex;
69		item.selectedIndex = 0;
70		if(index > 0)
71		document.location = list_current0[index-1];
72		}

-1

doc/_cppad_testvector_xml.js less more

26	26	var list_down2 = [
27	27	'download.xml',
28	28	'cmake.xml',
29		'cppad_test.xml',
	29	'cmake_check.xml',
30	30	'pkgconfig.xml',
31	31	'installunix.xml'
32	32	];
33	33	var list_down1 = [
34	34	'adolc_prefix.xml',
	35	'colpack_prefix.xml',
35	36	'eigen_prefix.xml',
36	37	'fadbad_prefix.xml',
37	38	'ipopt_prefix.xml',

-0

doc/_cppad_vector_xml.js less more

62	62	'cppad_vector.xml#Assignment',
63	63	'cppad_vector.xml#Assignment.Check Size',
64	64	'cppad_vector.xml#Assignment.Return Reference',
	65	'cppad_vector.xml#Assignment.Move Semantics',
65	66	'cppad_vector.xml#Element Access',
66	67	'cppad_vector.xml#push_back',
67	68	'cppad_vector.xml#push_vector',
68	69	'cppad_vector.xml#Output',
69	70	'cppad_vector.xml#resize',
70	71	'cppad_vector.xml#clear',
	72	'cppad_vector.xml#data',
71	73	'cppad_vector.xml#vectorBool',
72	74	'cppad_vector.xml#vectorBool.Memory',
	75	'cppad_vector.xml#vectorBool.data',
73	76	'cppad_vector.xml#vectorBool.Output',
74	77	'cppad_vector.xml#vectorBool.Element Type',
75	78	'cppad_vector.xml#Memory and Parallel Mode',

-1

doc/_download_xml.js less more

25	25	var list_down1 = [
26	26	'download.xml',
27	27	'cmake.xml',
28		'cppad_test.xml',
	28	'cmake_check.xml',
29	29	'pkgconfig.xml',
30	30	'installunix.xml'
31	31	];

-1

doc/_eigen_prefix_xml.js less more

26	26	var list_down2 = [
27	27	'download.xml',
28	28	'cmake.xml',
29		'cppad_test.xml',
	29	'cmake_check.xml',
30	30	'pkgconfig.xml',
31	31	'installunix.xml'
32	32	];
33	33	var list_down1 = [
34	34	'adolc_prefix.xml',
	35	'colpack_prefix.xml',
35	36	'eigen_prefix.xml',
36	37	'fadbad_prefix.xml',
37	38	'ipopt_prefix.xml',

+88

-0

doc/_erf_forward_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'appendix.xml',
	10	'theory.xml',
	11	'forwardtheory.xml',
	12	'erf_forward.xml'
	13	];
	14	var list_down3 = [
	15	'faq.xml',
	16	'theory.xml',
	17	'glossary.xml',
	18	'bib.xml',
	19	'bugs.xml',
	20	'wishlist.xml',
	21	'whats_new.xml',
	22	'deprecated.xml',
	23	'compare_c.xml',
	24	'license.xml'
	25	];
	26	var list_down2 = [
	27	'forwardtheory.xml',
	28	'reversetheory.xml',
	29	'reverse_identity.xml'
	30	];
	31	var list_down1 = [
	32	'expforward.xml',
	33	'logforward.xml',
	34	'sqrtforward.xml',
	35	'sincosforward.xml',
	36	'atanforward.xml',
	37	'asinforward.xml',
	38	'acosforward.xml',
	39	'tan_forward.xml',
	40	'erf_forward.xml'
	41	];
	42	var list_current0 = [
	43	'erf_forward.xml#Derivatives',
	44	'erf_forward.xml#Taylor Coefficients Recursion'
	45	];
	46	function choose_across0(item)
	47	{ var index = item.selectedIndex;
	48	item.selectedIndex = 0;
	49	if(index > 0)
	50	document.location = list_across0[index-1];
	51	}
	52	function choose_up0(item)
	53	{ var index = item.selectedIndex;
	54	item.selectedIndex = 0;
	55	if(index > 0)
	56	document.location = list_up0[index-1];
	57	}
	58	function choose_down3(item)
	59	{ var index = item.selectedIndex;
	60	item.selectedIndex = 0;
	61	if(index > 0)
	62	document.location = list_down3[index-1];
	63	}
	64	function choose_down2(item)
	65	{ var index = item.selectedIndex;
	66	item.selectedIndex = 0;
	67	if(index > 0)
	68	document.location = list_down2[index-1];
	69	}
	70	function choose_down1(item)
	71	{ var index = item.selectedIndex;
	72	item.selectedIndex = 0;
	73	if(index > 0)
	74	document.location = list_down1[index-1];
	75	}
	76	function choose_down0(item)
	77	{ var index = item.selectedIndex;
	78	item.selectedIndex = 0;
	79	if(index > 0)
	80	document.location = list_down0[index-1];
	81	}
	82	function choose_current0(item)
	83	{ var index = item.selectedIndex;
	84	item.selectedIndex = 0;
	85	if(index > 0)
	86	document.location = list_current0[index-1];
	87	}

+89

-0

doc/_erf_reverse_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'appendix.xml',
	10	'theory.xml',
	11	'reversetheory.xml',
	12	'erf_reverse.xml'
	13	];
	14	var list_down3 = [
	15	'faq.xml',
	16	'theory.xml',
	17	'glossary.xml',
	18	'bib.xml',
	19	'bugs.xml',
	20	'wishlist.xml',
	21	'whats_new.xml',
	22	'deprecated.xml',
	23	'compare_c.xml',
	24	'license.xml'
	25	];
	26	var list_down2 = [
	27	'forwardtheory.xml',
	28	'reversetheory.xml',
	29	'reverse_identity.xml'
	30	];
	31	var list_down1 = [
	32	'expreverse.xml',
	33	'logreverse.xml',
	34	'sqrtreverse.xml',
	35	'sincosreverse.xml',
	36	'atanreverse.xml',
	37	'asinreverse.xml',
	38	'acosreverse.xml',
	39	'tan_reverse.xml',
	40	'erf_reverse.xml'
	41	];
	42	var list_current0 = [
	43	'erf_reverse.xml#Notation',
	44	'erf_reverse.xml#Positive Orders Z(t)',
	45	'erf_reverse.xml#Order Zero Z(t)'
	46	];
	47	function choose_across0(item)
	48	{ var index = item.selectedIndex;
	49	item.selectedIndex = 0;
	50	if(index > 0)
	51	document.location = list_across0[index-1];
	52	}
	53	function choose_up0(item)
	54	{ var index = item.selectedIndex;
	55	item.selectedIndex = 0;
	56	if(index > 0)
	57	document.location = list_up0[index-1];
	58	}
	59	function choose_down3(item)
	60	{ var index = item.selectedIndex;
	61	item.selectedIndex = 0;
	62	if(index > 0)
	63	document.location = list_down3[index-1];
	64	}
	65	function choose_down2(item)
	66	{ var index = item.selectedIndex;
	67	item.selectedIndex = 0;
	68	if(index > 0)
	69	document.location = list_down2[index-1];
	70	}
	71	function choose_down1(item)
	72	{ var index = item.selectedIndex;
	73	item.selectedIndex = 0;
	74	if(index > 0)
	75	document.location = list_down1[index-1];
	76	}
	77	function choose_down0(item)
	78	{ var index = item.selectedIndex;
	79	item.selectedIndex = 0;
	80	if(index > 0)
	81	document.location = list_down0[index-1];
	82	}
	83	function choose_current0(item)
	84	{ var index = item.selectedIndex;
	85	item.selectedIndex = 0;
	86	if(index > 0)
	87	document.location = list_current0[index-1];
	88	}

-0

doc/_erf_xml.js less more

45	45	'erf.xml#x',
46	46	'erf.xml#Operation Sequence',
47	47	'erf.xml#Method',
	48	'erf.xml#Method.CPPAD_COMPILER_HAS_ERF',
	49	'erf.xml#Method.Other',
48	50	'erf.xml#Example'
49	51	];
50	52	function choose_across0(item)

-1

doc/_expforward_xml.js less more

36	36	'atanforward.xml',
37	37	'asinforward.xml',
38	38	'acosforward.xml',
39		'tan_forward.xml'
	39	'tan_forward.xml',
	40	'erf_forward.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-1

doc/_expreverse_xml.js less more

36	36	'atanreverse.xml',
37	37	'asinreverse.xml',
38	38	'acosreverse.xml',
39		'tan_reverse.xml'
	39	'tan_reverse.xml',
	40	'erf_reverse.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-8

doc/_external.xml less more

3	3	>
4	4	<head>
5	5	<title>External Internet References</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="External Internet References"/>
7	8	<style type='text/css'>
8	9	body { color : black }

62	63	<b>Reference</b></td><td>
63	64	<b>Location</b></td></tr>
64	65
65		<tr valign="top"><td><a href="cppad-20140000.3.epl.tgz" target="_top">cppad-20140000.3.epl.tgz</a></td><td><a href="download.xml#Compressed Tar File.Current Version" target="_top">download#Compressed Tar File.Current Version</a></td></tr>
66
67		<tr valign="top"><td><a href="cppad-20140000.3.gpl.tgz" target="_top">cppad-20140000.3.gpl.tgz</a></td><td><a href="download.xml#Compressed Tar File.Current Version" target="_top">download#Compressed Tar File.Current Version</a></td></tr>
68
69	66	<tr valign="top"><td><a href="http://cygwin.com/setup.html#naming" target="_top">http://cygwin.com/setup.html#naming</a></td><td><a href="whats_new_06.xml#11-30" target="_top">whats_new_06#11-30</a></td></tr>
70	67
71	68	<tr valign="top"><td><a href="http://eigen.tuxfamily.org" target="_top">http://eigen.tuxfamily.org</a></td><td><a href="eigen_prefix.xml#Purpose" target="_top">eigen_prefix#Purpose</a></td></tr>

86	83
87	84	<tr valign="top"><td><a href="http://en.wikipedia.org/wiki/Automatic_differentiation" target="_top">http://en.wikipedia.org/wiki/Automatic_differentiation</a></td><td><a href="cppad.xml#Introduction" target="_top">CppAD#Introduction</a></td></tr>
88	85
	86	<tr valign="top"><td><a href="http://http://cscapes.cs.purdue.edu/coloringpage/" target="_top">http://http://cscapes.cs.purdue.edu/coloringpage/</a></td><td><a href="colpack_prefix.xml#Purpose" target="_top">colpack_prefix#Purpose</a></td></tr>
	87
89	88	<tr valign="top"><td><a href="http://list.coin-or.org/mailman/listinfo/cppad" target="_top">http://list.coin-or.org/mailman/listinfo/cppad</a></td><td><a href="faq.xml#Bugs" target="_top">Faq#Bugs</a></td></tr>
90	89
91	90	<tr valign="top"><td><a href="http://list.coin-or.org/mailman/listinfo/cppad" target="_top">http://list.coin-or.org/mailman/listinfo/cppad</a></td><td><a href="faq.xml#Math Functions" target="_top">Faq#Math Functions</a></td></tr>

168	167
169	168	<tr valign="top"><td><a href="http://www.coin-or.org/download/source/CppAD/" target="_top">http://www.coin-or.org/download/source/CppAD/</a></td><td><a href="whats_new_09.xml#06-25" target="_top">whats_new_09#06-25</a></td></tr>
170	169
	170	<tr valign="top"><td><a href="http://www.coin-or.org/download/source/CppAD/cppad-20150000.0.epl.tgz" target="_top">http://www.coin-or.org/download/source/CppAD/cppad-20150000.0.epl.tgz</a></td><td><a href="download.xml#Compressed Tar File.Current Version" target="_top">download#Compressed Tar File.Current Version</a></td></tr>
	171
	172	<tr valign="top"><td><a href="http://www.coin-or.org/download/source/CppAD/cppad-20150000.0.gpl.tgz" target="_top">http://www.coin-or.org/download/source/CppAD/cppad-20150000.0.gpl.tgz</a></td><td><a href="download.xml#Compressed Tar File.Current Version" target="_top">download#Compressed Tar File.Current Version</a></td></tr>
	173
171	174	<tr valign="top"><td><a href="http://www.coin-or.org/foundation.html" target="_top">http://www.coin-or.org/foundation.html</a></td><td><a href="cppad.xml#Introduction" target="_top">CppAD#Introduction</a></td></tr>
172	175
173	176	<tr valign="top"><td><a href="http://www.coin-or.org/projects/Ipopt.xml" target="_top">http://www.coin-or.org/projects/Ipopt.xml</a></td><td><a href="ipopt_prefix.xml#ipopt_prefix" target="_top">ipopt_prefix#ipopt_prefix</a></td></tr>

182	185
183	186	<tr valign="top"><td><a href="http://www.cs.odu.edu/~dnguyen/dox/colpack/html/" target="_top">http://www.cs.odu.edu/~dnguyen/dox/colpack/html/</a></td><td><a href="get_colpack.sh.xml#Purpose" target="_top">get_colpack.sh#Purpose</a></td></tr>
184	187
185		<tr valign="top"><td><a href="http://www.cygwin.com" target="_top">http://www.cygwin.com</a></td><td><a href="speed.xml#Windows" target="_top">speed#Windows</a></td></tr>
186
187	188	<tr valign="top"><td><a href="http://www.cygwin.com/ml/cygwin-apps/2005-06/msg00159.html" target="_top">http://www.cygwin.com/ml/cygwin-apps/2005-06/msg00159.html</a></td><td><a href="bugs.xml#gcc 3.4.4 -O2.Adolc" target="_top">Bugs#gcc 3.4.4 -O2.Adolc</a></td></tr>
188	189
189	190	<tr valign="top"><td><a href="http://www.fadbad.com" target="_top">http://www.fadbad.com</a></td><td><a href="fadbad_prefix.xml#Purpose" target="_top">fadbad_prefix#Purpose</a></td></tr>

199	200	<tr valign="top"><td><a href="http://www.imm.dtu.dk/fadbad.html/" target="_top">http://www.imm.dtu.dk/fadbad.html/</a></td><td><a href="speed.xml#Purpose" target="_top">speed#Purpose</a></td></tr>
200	201
201	202	<tr valign="top"><td><a href="http://www.math.tu-dresden.de/~adol-c/" target="_top">http://www.math.tu-dresden.de/~adol-c/</a></td><td><a href="installunix.xml#adolc_dir" target="_top">InstallUnix#adolc_dir</a></td></tr>
202
203		<tr valign="top"><td><a href="http://www.mingw.org" target="_top">http://www.mingw.org</a></td><td><a href="speed.xml#Windows" target="_top">speed#Windows</a></td></tr>
204	203
205	204	<tr valign="top"><td><a href="http://www.mingw.org" target="_top">http://www.mingw.org</a></td><td><a href="whats_new_03.xml#12-22" target="_top">whats_new_03#12-22</a></td></tr>
206	205

-1

doc/_fadbad_prefix_xml.js less more

26	26	var list_down2 = [
27	27	'download.xml',
28	28	'cmake.xml',
29		'cppad_test.xml',
	29	'cmake_check.xml',
30	30	'pkgconfig.xml',
31	31	'installunix.xml'
32	32	];
33	33	var list_down1 = [
34	34	'adolc_prefix.xml',
	35	'colpack_prefix.xml',
35	36	'eigen_prefix.xml',
36	37	'fadbad_prefix.xml',
37	38	'ipopt_prefix.xml',

+13

-20

doc/_forward.cpp_xml.js less more

9	9	'adfun.xml',
10	10	'funeval.xml',
11	11	'forward.xml',
	12	'forward_order.xml',
12	13	'forward.cpp.xml'
13	14	];
14	15	var list_down3 = [
15		'independent.xml',
16		'funconstruct.xml',
17		'dependent.xml',
18		'abort_recording.xml',
19		'seq_property.xml',
20		'funeval.xml',
21		'drivers.xml',
22		'funcheck.xml',
23		'optimize.xml',
24		'check_for_nan.xml'
25		];
26		var list_down2 = [
27	16	'forward.xml',
28	17	'reverse.xml',
29	18	'sparse.xml'
30	19	];
	20	var list_down2 = [
	21	'forward_zero.xml',
	22	'forward_one.xml',
	23	'forward_two.xml',
	24	'forward_order.xml',
	25	'forward_dir.xml',
	26	'size_order.xml',
	27	'comparechange.xml',
	28	'capacity_order.xml',
	29	'number_skip.xml'
	30	];
31	31	var list_down1 = [
32		'forwardzero.xml',
33		'forwardone.xml',
34		'forwardany.xml',
35		'size_taylor.xml',
36		'comparechange.xml',
37		'capacity_taylor.xml',
38		'number_skip.xml',
39	32	'forward.cpp.xml',
40		'forward_mul.cpp.xml'
	33	'forward_order.cpp.xml'
41	34	];
42	35	function choose_across0(item)
43	36	{ var index = item.selectedIndex;

+76

-0

doc/_forward_dir.cpp_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'forward_dir.xml',
	13	'forward_dir.cpp.xml'
	14	];
	15	var list_down3 = [
	16	'forward.xml',
	17	'reverse.xml',
	18	'sparse.xml'
	19	];
	20	var list_down2 = [
	21	'forward_zero.xml',
	22	'forward_one.xml',
	23	'forward_two.xml',
	24	'forward_order.xml',
	25	'forward_dir.xml',
	26	'size_order.xml',
	27	'comparechange.xml',
	28	'capacity_order.xml',
	29	'number_skip.xml'
	30	];
	31	var list_down1 = [
	32	'forward_dir.cpp.xml'
	33	];
	34	function choose_across0(item)
	35	{ var index = item.selectedIndex;
	36	item.selectedIndex = 0;
	37	if(index > 0)
	38	document.location = list_across0[index-1];
	39	}
	40	function choose_up0(item)
	41	{ var index = item.selectedIndex;
	42	item.selectedIndex = 0;
	43	if(index > 0)
	44	document.location = list_up0[index-1];
	45	}
	46	function choose_down3(item)
	47	{ var index = item.selectedIndex;
	48	item.selectedIndex = 0;
	49	if(index > 0)
	50	document.location = list_down3[index-1];
	51	}
	52	function choose_down2(item)
	53	{ var index = item.selectedIndex;
	54	item.selectedIndex = 0;
	55	if(index > 0)
	56	document.location = list_down2[index-1];
	57	}
	58	function choose_down1(item)
	59	{ var index = item.selectedIndex;
	60	item.selectedIndex = 0;
	61	if(index > 0)
	62	document.location = list_down1[index-1];
	63	}
	64	function choose_down0(item)
	65	{ var index = item.selectedIndex;
	66	item.selectedIndex = 0;
	67	if(index > 0)
	68	document.location = list_down0[index-1];
	69	}
	70	function choose_current0(item)
	71	{ var index = item.selectedIndex;
	72	item.selectedIndex = 0;
	73	if(index > 0)
	74	document.location = list_current0[index-1];
	75	}

+105

-0

doc/_forward_dir_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'forward_dir.xml'
	13	];
	14	var list_down3 = [
	15	'independent.xml',
	16	'funconstruct.xml',
	17	'dependent.xml',
	18	'abort_recording.xml',
	19	'seq_property.xml',
	20	'funeval.xml',
	21	'drivers.xml',
	22	'funcheck.xml',
	23	'optimize.xml',
	24	'check_for_nan.xml'
	25	];
	26	var list_down2 = [
	27	'forward.xml',
	28	'reverse.xml',
	29	'sparse.xml'
	30	];
	31	var list_down1 = [
	32	'forward_zero.xml',
	33	'forward_one.xml',
	34	'forward_two.xml',
	35	'forward_order.xml',
	36	'forward_dir.xml',
	37	'size_order.xml',
	38	'comparechange.xml',
	39	'capacity_order.xml',
	40	'number_skip.xml'
	41	];
	42	var list_down0 = [
	43	'forward_dir.cpp.xml'
	44	];
	45	var list_current0 = [
	46	'forward_dir.xml#Syntax',
	47	'forward_dir.xml#Purpose',
	48	'forward_dir.xml#Notation',
	49	'forward_dir.xml#Notation.n',
	50	'forward_dir.xml#Notation.m',
	51	'forward_dir.xml#f',
	52	'forward_dir.xml#q',
	53	'forward_dir.xml#r',
	54	'forward_dir.xml#xq',
	55	'forward_dir.xml#Zero Order',
	56	'forward_dir.xml#Non-Zero Lower Orders',
	57	'forward_dir.xml#X(t)',
	58	'forward_dir.xml#Y(t)',
	59	'forward_dir.xml#yq',
	60	'forward_dir.xml#Vector',
	61	'forward_dir.xml#Example'
	62	];
	63	function choose_across0(item)
	64	{ var index = item.selectedIndex;
	65	item.selectedIndex = 0;
	66	if(index > 0)
	67	document.location = list_across0[index-1];
	68	}
	69	function choose_up0(item)
	70	{ var index = item.selectedIndex;
	71	item.selectedIndex = 0;
	72	if(index > 0)
	73	document.location = list_up0[index-1];
	74	}
	75	function choose_down3(item)
	76	{ var index = item.selectedIndex;
	77	item.selectedIndex = 0;
	78	if(index > 0)
	79	document.location = list_down3[index-1];
	80	}
	81	function choose_down2(item)
	82	{ var index = item.selectedIndex;
	83	item.selectedIndex = 0;
	84	if(index > 0)
	85	document.location = list_down2[index-1];
	86	}
	87	function choose_down1(item)
	88	{ var index = item.selectedIndex;
	89	item.selectedIndex = 0;
	90	if(index > 0)
	91	document.location = list_down1[index-1];
	92	}
	93	function choose_down0(item)
	94	{ var index = item.selectedIndex;
	95	item.selectedIndex = 0;
	96	if(index > 0)
	97	document.location = list_down0[index-1];
	98	}
	99	function choose_current0(item)
	100	{ var index = item.selectedIndex;
	101	item.selectedIndex = 0;
	102	if(index > 0)
	103	document.location = list_current0[index-1];
	104	}

-84

~~doc/_forward_mul.cpp_xml.js~~ less more

0		var list_across0 = [
1		'_contents_xml.htm',
2		'_reference.xml',
3		'_index.xml',
4		'_search_xml.htm',
5		'_external.xml'
6		];
7		var list_up0 = [
8		'cppad.xml',
9		'adfun.xml',
10		'funeval.xml',
11		'forward.xml',
12		'forward_mul.cpp.xml'
13		];
14		var list_down3 = [
15		'independent.xml',
16		'funconstruct.xml',
17		'dependent.xml',
18		'abort_recording.xml',
19		'seq_property.xml',
20		'funeval.xml',
21		'drivers.xml',
22		'funcheck.xml',
23		'optimize.xml',
24		'check_for_nan.xml'
25		];
26		var list_down2 = [
27		'forward.xml',
28		'reverse.xml',
29		'sparse.xml'
30		];
31		var list_down1 = [
32		'forwardzero.xml',
33		'forwardone.xml',
34		'forwardany.xml',
35		'size_taylor.xml',
36		'comparechange.xml',
37		'capacity_taylor.xml',
38		'number_skip.xml',
39		'forward.cpp.xml',
40		'forward_mul.cpp.xml'
41		];
42		function choose_across0(item)
43		{ var index = item.selectedIndex;
44		item.selectedIndex = 0;
45		if(index > 0)
46		document.location = list_across0[index-1];
47		}
48		function choose_up0(item)
49		{ var index = item.selectedIndex;
50		item.selectedIndex = 0;
51		if(index > 0)
52		document.location = list_up0[index-1];
53		}
54		function choose_down3(item)
55		{ var index = item.selectedIndex;
56		item.selectedIndex = 0;
57		if(index > 0)
58		document.location = list_down3[index-1];
59		}
60		function choose_down2(item)
61		{ var index = item.selectedIndex;
62		item.selectedIndex = 0;
63		if(index > 0)
64		document.location = list_down2[index-1];
65		}
66		function choose_down1(item)
67		{ var index = item.selectedIndex;
68		item.selectedIndex = 0;
69		if(index > 0)
70		document.location = list_down1[index-1];
71		}
72		function choose_down0(item)
73		{ var index = item.selectedIndex;
74		item.selectedIndex = 0;
75		if(index > 0)
76		document.location = list_down0[index-1];
77		}
78		function choose_current0(item)
79		{ var index = item.selectedIndex;
80		item.selectedIndex = 0;
81		if(index > 0)
82		document.location = list_current0[index-1];
83		}

+94

-0

doc/_forward_one_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'forward_one.xml'
	13	];
	14	var list_down3 = [
	15	'independent.xml',
	16	'funconstruct.xml',
	17	'dependent.xml',
	18	'abort_recording.xml',
	19	'seq_property.xml',
	20	'funeval.xml',
	21	'drivers.xml',
	22	'funcheck.xml',
	23	'optimize.xml',
	24	'check_for_nan.xml'
	25	];
	26	var list_down2 = [
	27	'forward.xml',
	28	'reverse.xml',
	29	'sparse.xml'
	30	];
	31	var list_down1 = [
	32	'forward_zero.xml',
	33	'forward_one.xml',
	34	'forward_two.xml',
	35	'forward_order.xml',
	36	'forward_dir.xml',
	37	'size_order.xml',
	38	'comparechange.xml',
	39	'capacity_order.xml',
	40	'number_skip.xml'
	41	];
	42	var list_current0 = [
	43	'forward_one.xml#Syntax',
	44	'forward_one.xml#Purpose',
	45	'forward_one.xml#f',
	46	'forward_one.xml#x0',
	47	'forward_one.xml#x1',
	48	'forward_one.xml#Vector',
	49	'forward_one.xml#Example',
	50	'forward_one.xml#Special Case'
	51	];
	52	function choose_across0(item)
	53	{ var index = item.selectedIndex;
	54	item.selectedIndex = 0;
	55	if(index > 0)
	56	document.location = list_across0[index-1];
	57	}
	58	function choose_up0(item)
	59	{ var index = item.selectedIndex;
	60	item.selectedIndex = 0;
	61	if(index > 0)
	62	document.location = list_up0[index-1];
	63	}
	64	function choose_down3(item)
	65	{ var index = item.selectedIndex;
	66	item.selectedIndex = 0;
	67	if(index > 0)
	68	document.location = list_down3[index-1];
	69	}
	70	function choose_down2(item)
	71	{ var index = item.selectedIndex;
	72	item.selectedIndex = 0;
	73	if(index > 0)
	74	document.location = list_down2[index-1];
	75	}
	76	function choose_down1(item)
	77	{ var index = item.selectedIndex;
	78	item.selectedIndex = 0;
	79	if(index > 0)
	80	document.location = list_down1[index-1];
	81	}
	82	function choose_down0(item)
	83	{ var index = item.selectedIndex;
	84	item.selectedIndex = 0;
	85	if(index > 0)
	86	document.location = list_down0[index-1];
	87	}
	88	function choose_current0(item)
	89	{ var index = item.selectedIndex;
	90	item.selectedIndex = 0;
	91	if(index > 0)
	92	document.location = list_current0[index-1];
	93	}

+77

-0

doc/_forward_order.cpp_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'forward_order.xml',
	13	'forward_order.cpp.xml'
	14	];
	15	var list_down3 = [
	16	'forward.xml',
	17	'reverse.xml',
	18	'sparse.xml'
	19	];
	20	var list_down2 = [
	21	'forward_zero.xml',
	22	'forward_one.xml',
	23	'forward_two.xml',
	24	'forward_order.xml',
	25	'forward_dir.xml',
	26	'size_order.xml',
	27	'comparechange.xml',
	28	'capacity_order.xml',
	29	'number_skip.xml'
	30	];
	31	var list_down1 = [
	32	'forward.cpp.xml',
	33	'forward_order.cpp.xml'
	34	];
	35	function choose_across0(item)
	36	{ var index = item.selectedIndex;
	37	item.selectedIndex = 0;
	38	if(index > 0)
	39	document.location = list_across0[index-1];
	40	}
	41	function choose_up0(item)
	42	{ var index = item.selectedIndex;
	43	item.selectedIndex = 0;
	44	if(index > 0)
	45	document.location = list_up0[index-1];
	46	}
	47	function choose_down3(item)
	48	{ var index = item.selectedIndex;
	49	item.selectedIndex = 0;
	50	if(index > 0)
	51	document.location = list_down3[index-1];
	52	}
	53	function choose_down2(item)
	54	{ var index = item.selectedIndex;
	55	item.selectedIndex = 0;
	56	if(index > 0)
	57	document.location = list_down2[index-1];
	58	}
	59	function choose_down1(item)
	60	{ var index = item.selectedIndex;
	61	item.selectedIndex = 0;
	62	if(index > 0)
	63	document.location = list_down1[index-1];
	64	}
	65	function choose_down0(item)
	66	{ var index = item.selectedIndex;
	67	item.selectedIndex = 0;
	68	if(index > 0)
	69	document.location = list_down0[index-1];
	70	}
	71	function choose_current0(item)
	72	{ var index = item.selectedIndex;
	73	item.selectedIndex = 0;
	74	if(index > 0)
	75	document.location = list_current0[index-1];
	76	}

+115

-0

doc/_forward_order_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'forward_order.xml'
	13	];
	14	var list_down3 = [
	15	'independent.xml',
	16	'funconstruct.xml',
	17	'dependent.xml',
	18	'abort_recording.xml',
	19	'seq_property.xml',
	20	'funeval.xml',
	21	'drivers.xml',
	22	'funcheck.xml',
	23	'optimize.xml',
	24	'check_for_nan.xml'
	25	];
	26	var list_down2 = [
	27	'forward.xml',
	28	'reverse.xml',
	29	'sparse.xml'
	30	];
	31	var list_down1 = [
	32	'forward_zero.xml',
	33	'forward_one.xml',
	34	'forward_two.xml',
	35	'forward_order.xml',
	36	'forward_dir.xml',
	37	'size_order.xml',
	38	'comparechange.xml',
	39	'capacity_order.xml',
	40	'number_skip.xml'
	41	];
	42	var list_down0 = [
	43	'forward.cpp.xml',
	44	'forward_order.cpp.xml'
	45	];
	46	var list_current0 = [
	47	'forward_order.xml#Syntax',
	48	'forward_order.xml#Purpose',
	49	'forward_order.xml#Purpose.Function Values',
	50	'forward_order.xml#Purpose.Derivative Values',
	51	'forward_order.xml#Notation',
	52	'forward_order.xml#Notation.n',
	53	'forward_order.xml#Notation.m',
	54	'forward_order.xml#f',
	55	'forward_order.xml#One Order',
	56	'forward_order.xml#q',
	57	'forward_order.xml#xq',
	58	'forward_order.xml#xq.One Order',
	59	'forward_order.xml#xq.Multiple Orders',
	60	'forward_order.xml#xq.Restrictions',
	61	'forward_order.xml#s',
	62	'forward_order.xml#X(t)',
	63	'forward_order.xml#Y(t)',
	64	'forward_order.xml#yq',
	65	'forward_order.xml#yq.One Order',
	66	'forward_order.xml#yq.Multiple Orders',
	67	'forward_order.xml#Vector',
	68	'forward_order.xml#Zero Order',
	69	'forward_order.xml#First Order',
	70	'forward_order.xml#Second Order',
	71	'forward_order.xml#Example'
	72	];
	73	function choose_across0(item)
	74	{ var index = item.selectedIndex;
	75	item.selectedIndex = 0;
	76	if(index > 0)
	77	document.location = list_across0[index-1];
	78	}
	79	function choose_up0(item)
	80	{ var index = item.selectedIndex;
	81	item.selectedIndex = 0;
	82	if(index > 0)
	83	document.location = list_up0[index-1];
	84	}
	85	function choose_down3(item)
	86	{ var index = item.selectedIndex;
	87	item.selectedIndex = 0;
	88	if(index > 0)
	89	document.location = list_down3[index-1];
	90	}
	91	function choose_down2(item)
	92	{ var index = item.selectedIndex;
	93	item.selectedIndex = 0;
	94	if(index > 0)
	95	document.location = list_down2[index-1];
	96	}
	97	function choose_down1(item)
	98	{ var index = item.selectedIndex;
	99	item.selectedIndex = 0;
	100	if(index > 0)
	101	document.location = list_down1[index-1];
	102	}
	103	function choose_down0(item)
	104	{ var index = item.selectedIndex;
	105	item.selectedIndex = 0;
	106	if(index > 0)
	107	document.location = list_down0[index-1];
	108	}
	109	function choose_current0(item)
	110	{ var index = item.selectedIndex;
	111	item.selectedIndex = 0;
	112	if(index > 0)
	113	document.location = list_current0[index-1];
	114	}

+96

-0

doc/_forward_two_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'forward_two.xml'
	13	];
	14	var list_down3 = [
	15	'independent.xml',
	16	'funconstruct.xml',
	17	'dependent.xml',
	18	'abort_recording.xml',
	19	'seq_property.xml',
	20	'funeval.xml',
	21	'drivers.xml',
	22	'funcheck.xml',
	23	'optimize.xml',
	24	'check_for_nan.xml'
	25	];
	26	var list_down2 = [
	27	'forward.xml',
	28	'reverse.xml',
	29	'sparse.xml'
	30	];
	31	var list_down1 = [
	32	'forward_zero.xml',
	33	'forward_one.xml',
	34	'forward_two.xml',
	35	'forward_order.xml',
	36	'forward_dir.xml',
	37	'size_order.xml',
	38	'comparechange.xml',
	39	'capacity_order.xml',
	40	'number_skip.xml'
	41	];
	42	var list_current0 = [
	43	'forward_two.xml#Syntax',
	44	'forward_two.xml#Purpose',
	45	'forward_two.xml#f',
	46	'forward_two.xml#x0',
	47	'forward_two.xml#x1',
	48	'forward_two.xml#x2',
	49	'forward_two.xml#y2',
	50	'forward_two.xml#Vector',
	51	'forward_two.xml#Example',
	52	'forward_two.xml#Special Case'
	53	];
	54	function choose_across0(item)
	55	{ var index = item.selectedIndex;
	56	item.selectedIndex = 0;
	57	if(index > 0)
	58	document.location = list_across0[index-1];
	59	}
	60	function choose_up0(item)
	61	{ var index = item.selectedIndex;
	62	item.selectedIndex = 0;
	63	if(index > 0)
	64	document.location = list_up0[index-1];
	65	}
	66	function choose_down3(item)
	67	{ var index = item.selectedIndex;
	68	item.selectedIndex = 0;
	69	if(index > 0)
	70	document.location = list_down3[index-1];
	71	}
	72	function choose_down2(item)
	73	{ var index = item.selectedIndex;
	74	item.selectedIndex = 0;
	75	if(index > 0)
	76	document.location = list_down2[index-1];
	77	}
	78	function choose_down1(item)
	79	{ var index = item.selectedIndex;
	80	item.selectedIndex = 0;
	81	if(index > 0)
	82	document.location = list_down1[index-1];
	83	}
	84	function choose_down0(item)
	85	{ var index = item.selectedIndex;
	86	item.selectedIndex = 0;
	87	if(index > 0)
	88	document.location = list_down0[index-1];
	89	}
	90	function choose_current0(item)
	91	{ var index = item.selectedIndex;
	92	item.selectedIndex = 0;
	93	if(index > 0)
	94	document.location = list_current0[index-1];
	95	}

-8

doc/_forward_xml.js less more

41	41	'sparse.xml'
42	42	];
43	43	var list_down0 = [
44		'forwardzero.xml',
45		'forwardone.xml',
46		'forwardany.xml',
47		'size_taylor.xml',
	44	'forward_zero.xml',
	45	'forward_one.xml',
	46	'forward_two.xml',
	47	'forward_order.xml',
	48	'forward_dir.xml',
	49	'size_order.xml',
48	50	'comparechange.xml',
49		'capacity_taylor.xml',
50		'number_skip.xml',
51		'forward.cpp.xml',
52		'forward_mul.cpp.xml'
	51	'capacity_order.xml',
	52	'number_skip.xml'
53	53	];
54	54	var list_current0 = [
55	55	'forward.xml#Contents'

+95

-0

doc/_forward_zero_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'forward_zero.xml'
	13	];
	14	var list_down3 = [
	15	'independent.xml',
	16	'funconstruct.xml',
	17	'dependent.xml',
	18	'abort_recording.xml',
	19	'seq_property.xml',
	20	'funeval.xml',
	21	'drivers.xml',
	22	'funcheck.xml',
	23	'optimize.xml',
	24	'check_for_nan.xml'
	25	];
	26	var list_down2 = [
	27	'forward.xml',
	28	'reverse.xml',
	29	'sparse.xml'
	30	];
	31	var list_down1 = [
	32	'forward_zero.xml',
	33	'forward_one.xml',
	34	'forward_two.xml',
	35	'forward_order.xml',
	36	'forward_dir.xml',
	37	'size_order.xml',
	38	'comparechange.xml',
	39	'capacity_order.xml',
	40	'number_skip.xml'
	41	];
	42	var list_current0 = [
	43	'forward_zero.xml#Syntax',
	44	'forward_zero.xml#Purpose',
	45	'forward_zero.xml#f',
	46	'forward_zero.xml#x0',
	47	'forward_zero.xml#s',
	48	'forward_zero.xml#y0',
	49	'forward_zero.xml#Vector',
	50	'forward_zero.xml#Example',
	51	'forward_zero.xml#Special Case'
	52	];
	53	function choose_across0(item)
	54	{ var index = item.selectedIndex;
	55	item.selectedIndex = 0;
	56	if(index > 0)
	57	document.location = list_across0[index-1];
	58	}
	59	function choose_up0(item)
	60	{ var index = item.selectedIndex;
	61	item.selectedIndex = 0;
	62	if(index > 0)
	63	document.location = list_up0[index-1];
	64	}
	65	function choose_down3(item)
	66	{ var index = item.selectedIndex;
	67	item.selectedIndex = 0;
	68	if(index > 0)
	69	document.location = list_down3[index-1];
	70	}
	71	function choose_down2(item)
	72	{ var index = item.selectedIndex;
	73	item.selectedIndex = 0;
	74	if(index > 0)
	75	document.location = list_down2[index-1];
	76	}
	77	function choose_down1(item)
	78	{ var index = item.selectedIndex;
	79	item.selectedIndex = 0;
	80	if(index > 0)
	81	document.location = list_down1[index-1];
	82	}
	83	function choose_down0(item)
	84	{ var index = item.selectedIndex;
	85	item.selectedIndex = 0;
	86	if(index > 0)
	87	document.location = list_down0[index-1];
	88	}
	89	function choose_current0(item)
	90	{ var index = item.selectedIndex;
	91	item.selectedIndex = 0;
	92	if(index > 0)
	93	document.location = list_current0[index-1];
	94	}

-107

~~doc/_forwardany_xml.js~~ less more

0		var list_across0 = [
1		'_contents_xml.htm',
2		'_reference.xml',
3		'_index.xml',
4		'_search_xml.htm',
5		'_external.xml'
6		];
7		var list_up0 = [
8		'cppad.xml',
9		'adfun.xml',
10		'funeval.xml',
11		'forward.xml',
12		'forwardany.xml'
13		];
14		var list_down3 = [
15		'independent.xml',
16		'funconstruct.xml',
17		'dependent.xml',
18		'abort_recording.xml',
19		'seq_property.xml',
20		'funeval.xml',
21		'drivers.xml',
22		'funcheck.xml',
23		'optimize.xml',
24		'check_for_nan.xml'
25		];
26		var list_down2 = [
27		'forward.xml',
28		'reverse.xml',
29		'sparse.xml'
30		];
31		var list_down1 = [
32		'forwardzero.xml',
33		'forwardone.xml',
34		'forwardany.xml',
35		'size_taylor.xml',
36		'comparechange.xml',
37		'capacity_taylor.xml',
38		'number_skip.xml',
39		'forward.cpp.xml',
40		'forward_mul.cpp.xml'
41		];
42		var list_current0 = [
43		'forwardany.xml#Syntax',
44		'forwardany.xml#Purpose',
45		'forwardany.xml#Purpose.Function Values',
46		'forwardany.xml#Purpose.Derivative Values',
47		'forwardany.xml#X(t)',
48		'forwardany.xml#Y(t)',
49		'forwardany.xml#f',
50		'forwardany.xml#p',
51		'forwardany.xml#x_p',
52		'forwardany.xml#x_p.Restrictions',
53		'forwardany.xml#x_p.One Order',
54		'forwardany.xml#x_p.Multiple Orders',
55		'forwardany.xml#s',
56		'forwardany.xml#y_p',
57		'forwardany.xml#y_p.One Order',
58		'forwardany.xml#y_p.Multiple Orders',
59		'forwardany.xml#Vector',
60		'forwardany.xml#Zero Order',
61		'forwardany.xml#First Order',
62		'forwardany.xml#Second Order',
63		'forwardany.xml#Example'
64		];
65		function choose_across0(item)
66		{ var index = item.selectedIndex;
67		item.selectedIndex = 0;
68		if(index > 0)
69		document.location = list_across0[index-1];
70		}
71		function choose_up0(item)
72		{ var index = item.selectedIndex;
73		item.selectedIndex = 0;
74		if(index > 0)
75		document.location = list_up0[index-1];
76		}
77		function choose_down3(item)
78		{ var index = item.selectedIndex;
79		item.selectedIndex = 0;
80		if(index > 0)
81		document.location = list_down3[index-1];
82		}
83		function choose_down2(item)
84		{ var index = item.selectedIndex;
85		item.selectedIndex = 0;
86		if(index > 0)
87		document.location = list_down2[index-1];
88		}
89		function choose_down1(item)
90		{ var index = item.selectedIndex;
91		item.selectedIndex = 0;
92		if(index > 0)
93		document.location = list_down1[index-1];
94		}
95		function choose_down0(item)
96		{ var index = item.selectedIndex;
97		item.selectedIndex = 0;
98		if(index > 0)
99		document.location = list_down0[index-1];
100		}
101		function choose_current0(item)
102		{ var index = item.selectedIndex;
103		item.selectedIndex = 0;
104		if(index > 0)
105		document.location = list_current0[index-1];
106		}

-95

~~doc/_forwardone_xml.js~~ less more

0		var list_across0 = [
1		'_contents_xml.htm',
2		'_reference.xml',
3		'_index.xml',
4		'_search_xml.htm',
5		'_external.xml'
6		];
7		var list_up0 = [
8		'cppad.xml',
9		'adfun.xml',
10		'funeval.xml',
11		'forward.xml',
12		'forwardone.xml'
13		];
14		var list_down3 = [
15		'independent.xml',
16		'funconstruct.xml',
17		'dependent.xml',
18		'abort_recording.xml',
19		'seq_property.xml',
20		'funeval.xml',
21		'drivers.xml',
22		'funcheck.xml',
23		'optimize.xml',
24		'check_for_nan.xml'
25		];
26		var list_down2 = [
27		'forward.xml',
28		'reverse.xml',
29		'sparse.xml'
30		];
31		var list_down1 = [
32		'forwardzero.xml',
33		'forwardone.xml',
34		'forwardany.xml',
35		'size_taylor.xml',
36		'comparechange.xml',
37		'capacity_taylor.xml',
38		'number_skip.xml',
39		'forward.cpp.xml',
40		'forward_mul.cpp.xml'
41		];
42		var list_current0 = [
43		'forwardone.xml#Syntax',
44		'forwardone.xml#Purpose',
45		'forwardone.xml#f',
46		'forwardone.xml#x',
47		'forwardone.xml#dx',
48		'forwardone.xml#s',
49		'forwardone.xml#dy',
50		'forwardone.xml#Vector',
51		'forwardone.xml#Example'
52		];
53		function choose_across0(item)
54		{ var index = item.selectedIndex;
55		item.selectedIndex = 0;
56		if(index > 0)
57		document.location = list_across0[index-1];
58		}
59		function choose_up0(item)
60		{ var index = item.selectedIndex;
61		item.selectedIndex = 0;
62		if(index > 0)
63		document.location = list_up0[index-1];
64		}
65		function choose_down3(item)
66		{ var index = item.selectedIndex;
67		item.selectedIndex = 0;
68		if(index > 0)
69		document.location = list_down3[index-1];
70		}
71		function choose_down2(item)
72		{ var index = item.selectedIndex;
73		item.selectedIndex = 0;
74		if(index > 0)
75		document.location = list_down2[index-1];
76		}
77		function choose_down1(item)
78		{ var index = item.selectedIndex;
79		item.selectedIndex = 0;
80		if(index > 0)
81		document.location = list_down1[index-1];
82		}
83		function choose_down0(item)
84		{ var index = item.selectedIndex;
85		item.selectedIndex = 0;
86		if(index > 0)
87		document.location = list_down0[index-1];
88		}
89		function choose_current0(item)
90		{ var index = item.selectedIndex;
91		item.selectedIndex = 0;
92		if(index > 0)
93		document.location = list_current0[index-1];
94		}

-1

doc/_forwardtheory_xml.js less more

48	48	'atanforward.xml',
49	49	'asinforward.xml',
50	50	'acosforward.xml',
51		'tan_forward.xml'
	51	'tan_forward.xml',
	52	'erf_forward.xml'
52	53	];
53	54	var list_current0 = [
54	55	'forwardtheory.xml#Taylor Notation',

-94

~~doc/_forwardzero_xml.js~~ less more

0		var list_across0 = [
1		'_contents_xml.htm',
2		'_reference.xml',
3		'_index.xml',
4		'_search_xml.htm',
5		'_external.xml'
6		];
7		var list_up0 = [
8		'cppad.xml',
9		'adfun.xml',
10		'funeval.xml',
11		'forward.xml',
12		'forwardzero.xml'
13		];
14		var list_down3 = [
15		'independent.xml',
16		'funconstruct.xml',
17		'dependent.xml',
18		'abort_recording.xml',
19		'seq_property.xml',
20		'funeval.xml',
21		'drivers.xml',
22		'funcheck.xml',
23		'optimize.xml',
24		'check_for_nan.xml'
25		];
26		var list_down2 = [
27		'forward.xml',
28		'reverse.xml',
29		'sparse.xml'
30		];
31		var list_down1 = [
32		'forwardzero.xml',
33		'forwardone.xml',
34		'forwardany.xml',
35		'size_taylor.xml',
36		'comparechange.xml',
37		'capacity_taylor.xml',
38		'number_skip.xml',
39		'forward.cpp.xml',
40		'forward_mul.cpp.xml'
41		];
42		var list_current0 = [
43		'forwardzero.xml#Syntax',
44		'forwardzero.xml#Purpose',
45		'forwardzero.xml#f',
46		'forwardzero.xml#x',
47		'forwardzero.xml#s',
48		'forwardzero.xml#y',
49		'forwardzero.xml#Vector',
50		'forwardzero.xml#Example'
51		];
52		function choose_across0(item)
53		{ var index = item.selectedIndex;
54		item.selectedIndex = 0;
55		if(index > 0)
56		document.location = list_across0[index-1];
57		}
58		function choose_up0(item)
59		{ var index = item.selectedIndex;
60		item.selectedIndex = 0;
61		if(index > 0)
62		document.location = list_up0[index-1];
63		}
64		function choose_down3(item)
65		{ var index = item.selectedIndex;
66		item.selectedIndex = 0;
67		if(index > 0)
68		document.location = list_down3[index-1];
69		}
70		function choose_down2(item)
71		{ var index = item.selectedIndex;
72		item.selectedIndex = 0;
73		if(index > 0)
74		document.location = list_down2[index-1];
75		}
76		function choose_down1(item)
77		{ var index = item.selectedIndex;
78		item.selectedIndex = 0;
79		if(index > 0)
80		document.location = list_down1[index-1];
81		}
82		function choose_down0(item)
83		{ var index = item.selectedIndex;
84		item.selectedIndex = 0;
85		if(index > 0)
86		document.location = list_down0[index-1];
87		}
88		function choose_current0(item)
89		{ var index = item.selectedIndex;
90		item.selectedIndex = 0;
91		if(index > 0)
92		document.location = list_current0[index-1];
93		}

-1

doc/_fundeprecated_xml.js less more

61	61	'fundeprecated.xml#taylor_size',
62	62	'fundeprecated.xml#taylor_size.Deprecated',
63	63	'fundeprecated.xml#use_VecAD',
64		'fundeprecated.xml#use_VecAD.Deprecated'
	64	'fundeprecated.xml#use_VecAD.Deprecated',
	65	'fundeprecated.xml#size_taylor',
	66	'fundeprecated.xml#size_taylor.Deprecated',
	67	'fundeprecated.xml#capacity_taylor',
	68	'fundeprecated.xml#capacity_taylor.Deprecated'
65	69	];
66	70	function choose_across0(item)
67	71	{ var index = item.selectedIndex;

-4

doc/_get_adolc.sh_xml.js less more

14	14	var list_down3 = [
15	15	'download.xml',
16	16	'cmake.xml',
17		'cppad_test.xml',
	17	'cmake_check.xml',
18	18	'pkgconfig.xml',
19	19	'installunix.xml'
20	20	];
21	21	var list_down2 = [
22	22	'adolc_prefix.xml',
	23	'colpack_prefix.xml',
23	24	'eigen_prefix.xml',
24	25	'fadbad_prefix.xml',
25	26	'ipopt_prefix.xml',

28	29	];
29	30	var list_down1 = [
30	31	'get_adolc.sh.xml'
31		];
32		var list_down0 = [
33		'get_colpack.sh.xml'
34	32	];
35	33	var list_current0 = [
36	34	'get_adolc.sh.xml#Syntax',

+10

-5

doc/_get_colpack.sh_xml.js less more

8	8	'cppad.xml',
9	9	'install.xml',
10	10	'cmake.xml',
11		'adolc_prefix.xml',
12		'get_adolc.sh.xml',
	11	'colpack_prefix.xml',
13	12	'get_colpack.sh.xml'
14	13	];
15	14	var list_down3 = [
	15	'download.xml',
	16	'cmake.xml',
	17	'cmake_check.xml',
	18	'pkgconfig.xml',
	19	'installunix.xml'
	20	];
	21	var list_down2 = [
16	22	'adolc_prefix.xml',
	23	'colpack_prefix.xml',
17	24	'eigen_prefix.xml',
18	25	'fadbad_prefix.xml',
19	26	'ipopt_prefix.xml',
20	27	'sacado_prefix.xml',
21	28	'cppad_testvector.xml'
22	29	];
23		var list_down2 = [
24		'get_adolc.sh.xml'
25		];
26	30	var list_down1 = [
	31	'colpack.cpp.xml',
27	32	'get_colpack.sh.xml'
28	33	];
29	34	var list_current0 = [

-1

doc/_get_eigen.sh_xml.js less more

14	14	var list_down3 = [
15	15	'download.xml',
16	16	'cmake.xml',
17		'cppad_test.xml',
	17	'cmake_check.xml',
18	18	'pkgconfig.xml',
19	19	'installunix.xml'
20	20	];
21	21	var list_down2 = [
22	22	'adolc_prefix.xml',
	23	'colpack_prefix.xml',
23	24	'eigen_prefix.xml',
24	25	'fadbad_prefix.xml',
25	26	'ipopt_prefix.xml',

-1

doc/_get_fadbad.sh_xml.js less more

14	14	var list_down3 = [
15	15	'download.xml',
16	16	'cmake.xml',
17		'cppad_test.xml',
	17	'cmake_check.xml',
18	18	'pkgconfig.xml',
19	19	'installunix.xml'
20	20	];
21	21	var list_down2 = [
22	22	'adolc_prefix.xml',
	23	'colpack_prefix.xml',
23	24	'eigen_prefix.xml',
24	25	'fadbad_prefix.xml',
25	26	'ipopt_prefix.xml',

-1

doc/_get_ipopt.sh_xml.js less more

14	14	var list_down3 = [
15	15	'download.xml',
16	16	'cmake.xml',
17		'cppad_test.xml',
	17	'cmake_check.xml',
18	18	'pkgconfig.xml',
19	19	'installunix.xml'
20	20	];
21	21	var list_down2 = [
22	22	'adolc_prefix.xml',
	23	'colpack_prefix.xml',
23	24	'eigen_prefix.xml',
24	25	'fadbad_prefix.xml',
25	26	'ipopt_prefix.xml',

-1

doc/_get_sacado.sh_xml.js less more

14	14	var list_down3 = [
15	15	'download.xml',
16	16	'cmake.xml',
17		'cppad_test.xml',
	17	'cmake_check.xml',
18	18	'pkgconfig.xml',
19	19	'installunix.xml'
20	20	];
21	21	var list_down2 = [
22	22	'adolc_prefix.xml',
	23	'colpack_prefix.xml',
23	24	'eigen_prefix.xml',
24	25	'fadbad_prefix.xml',
25	26	'ipopt_prefix.xml',

+7736

-378

doc/_index.xml less more

3	3	>
4	4	<head>
5	5	<title>Keyword Index</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Keyword Index"/>
7	8	<style type='text/css'>
8	9	body { color : black }

81	82	<option>U</option>
82	83	<option>V</option>
83	84	<option>W</option>
	85	<option>X</option>
	86	<option>Y</option>
84	87	<option>Z</option>
85	88	</select>
86	89	</td>

89	92	<b>!=</b><br/>
90	93	AD<b> </b>operator <a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
91	94	example <a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
	95	<b>(</b>double <a href="double_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication (Double Version)</a><br/>
92	96	<b>*</b><br/>
93	97	AD<b> </b>example <a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
94	98	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>

107	111	AD<b> </b>unary<b> </b>operator <a href="unaryminus.xml" target="_top">AD Unary Minus Operator</a><br/>
108	112	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
109	113	computed<b> </b>assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
	114	<b>--</b>with<b>-</b>documentation <a href="installunix.xml#--with-Documentation" target="_top">Deprecated Unix Test and Installation: --with-Documentation</a><br/>
	115	<b>--</b>with<b>-</b>implicit<b>_</b>ctor <a href="installunix.xml#--with-implicit_ctor" target="_top">Deprecated Unix Test and Installation: --with-implicit_ctor</a><br/>
	116	<b>--</b>with<b>-</b>sparse<b>_</b>option <a href="installunix.xml#--with-sparse_option" target="_top">Deprecated Unix Test and Installation: --with-sparse_option</a><br/>
	117	<b>--</b>with<b>-</b>testvector <a href="installunix.xml#--with-testvector" target="_top">Deprecated Unix Test and Installation: --with-testvector</a><br/>
110	118	<b>-=</b><br/>
111	119	AD<b> </b>example <a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
	120	<b>-</b>o2 <a href="bugs.xml#gcc 3.4.4 -O2" target="_top">Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2</a><br/>
112	121	<b>/</b><br/>
113	122	AD<b> </b>example <a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
114	123	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
115	124	computed<b> </b>assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
116	125	<b>/=</b><br/>
117	126	AD<b> </b>example <a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
	127	0 <a href="ode_evaluate.xml#p.p == 0" target="_top">Evaluate a Function Defined in Terms of an ODE: p.p == 0</a><br/>
	128	01<b>-</b>02 <a href="whats_new_06.xml#01-02" target="_top">Changes and Additions to CppAD During 2006: 01-02</a><br/>
	129	<a href="whats_new_12.xml#01-02" target="_top">CppAD Changes and Additions During 2012: 01-02</a><br/>
	130	01<b>-</b>04 <a href="whats_new_10.xml#01-04" target="_top">Changes and Additions to CppAD During 2010: 01-04</a><br/>
	131	01<b>-</b>05 <a href="whats_new_06.xml#01-05" target="_top">Changes and Additions to CppAD During 2006: 01-05</a><br/>
	132	01<b>-</b>06 <a href="whats_new_09.xml#01-06" target="_top">Changes and Additions to CppAD During 2009: 01-06</a><br/>
	133	01<b>-</b>07 <a href="whats_new_06.xml#01-07" target="_top">Changes and Additions to CppAD During 2006: 01-07</a><br/>
	134	<a href="whats_new_12.xml#01-07" target="_top">CppAD Changes and Additions During 2012: 01-07</a><br/>
	135	01<b>-</b>08 <a href="whats_new_05.xml#01-08" target="_top">Changes and Additions to CppAD During 2005: 01-08</a><br/>
	136	<a href="whats_new_06.xml#01-08" target="_top">Changes and Additions to CppAD During 2006: 01-08</a><br/>
	137	<a href="whats_new_08.xml#01-08" target="_top">Changes and Additions to CppAD During 2008: 01-08</a><br/>
	138	01<b>-</b>09 <a href="whats_new_11.xml#01-09" target="_top">Changes and Additions to CppAD During 2011: 01-09</a><br/>
	139	01<b>-</b>10 <a href="whats_new_14.xml#01-10" target="_top">CppAD Changes and Additions During 2014: 01-10</a><br/>
	140	01<b>-</b>11 <a href="whats_new_08.xml#01-11" target="_top">Changes and Additions to CppAD During 2008: 01-11</a><br/>
	141	01<b>-</b>12 <a href="whats_new_12.xml#01-12" target="_top">CppAD Changes and Additions During 2012: 01-12</a><br/>
	142	01<b>-</b>15 <a href="whats_new_12.xml#01-15" target="_top">CppAD Changes and Additions During 2012: 01-15</a><br/>
	143	01<b>-</b>16 <a href="whats_new_11.xml#01-16" target="_top">Changes and Additions to CppAD During 2011: 01-16</a><br/>
	144	<a href="whats_new_12.xml#01-16" target="_top">CppAD Changes and Additions During 2012: 01-16</a><br/>
	145	01<b>-</b>18 <a href="whats_new_06.xml#01-18" target="_top">Changes and Additions to CppAD During 2006: 01-18</a><br/>
	146	<a href="whats_new_09.xml#01-18" target="_top">Changes and Additions to CppAD During 2009: 01-18</a><br/>
	147	<a href="whats_new_10.xml#01-18" target="_top">Changes and Additions to CppAD During 2010: 01-18</a><br/>
	148	01<b>-</b>19 <a href="whats_new_11.xml#01-19" target="_top">Changes and Additions to CppAD During 2011: 01-19</a><br/>
	149	<a href="whats_new_12.xml#01-19" target="_top">CppAD Changes and Additions During 2012: 01-19</a><br/>
	150	01<b>-</b>20 <a href="whats_new_06.xml#01-20" target="_top">Changes and Additions to CppAD During 2006: 01-20</a><br/>
	151	<a href="whats_new_08.xml#01-20" target="_top">Changes and Additions to CppAD During 2008: 01-20</a><br/>
	152	<a href="whats_new_10.xml#01-20" target="_top">Changes and Additions to CppAD During 2010: 01-20</a><br/>
	153	<a href="whats_new_12.xml#01-20" target="_top">CppAD Changes and Additions During 2012: 01-20</a><br/>
	154	01<b>-</b>21 <a href="whats_new_08.xml#01-21" target="_top">Changes and Additions to CppAD During 2008: 01-21</a><br/>
	155	<a href="whats_new_14.xml#01-21" target="_top">CppAD Changes and Additions During 2014: 01-21</a><br/>
	156	01<b>-</b>22 <a href="whats_new_04.xml#01-22" target="_top">Changes and Additions to CppAD During 2004: 01-22</a><br/>
	157	01<b>-</b>23 <a href="whats_new_10.xml#01-23" target="_top">Changes and Additions to CppAD During 2010: 01-23</a><br/>
	158	<a href="whats_new_12.xml#01-23" target="_top">CppAD Changes and Additions During 2012: 01-23</a><br/>
	159	01<b>-</b>24 <a href="whats_new_08.xml#01-24" target="_top">Changes and Additions to CppAD During 2008: 01-24</a><br/>
	160	<a href="whats_new_10.xml#01-24" target="_top">Changes and Additions to CppAD During 2010: 01-24</a><br/>
	161	<a href="whats_new_12.xml#01-24" target="_top">CppAD Changes and Additions During 2012: 01-24</a><br/>
	162	01<b>-</b>26 <a href="whats_new_08.xml#01-26" target="_top">Changes and Additions to CppAD During 2008: 01-26</a><br/>
	163	<a href="whats_new_10.xml#01-26" target="_top">Changes and Additions to CppAD During 2010: 01-26</a><br/>
	164	<a href="whats_new_14.xml#01-26" target="_top">CppAD Changes and Additions During 2014: 01-26</a><br/>
	165	01<b>-</b>27 <a href="whats_new_12.xml#01-27" target="_top">CppAD Changes and Additions During 2012: 01-27</a><br/>
	166	01<b>-</b>28 <a href="whats_new_04.xml#01-28" target="_top">Changes and Additions to CppAD During 2004: 01-28</a><br/>
	167	01<b>-</b>29 <a href="whats_new_04.xml#01-29" target="_top">Changes and Additions to CppAD During 2004: 01-29</a><br/>
	168	<a href="whats_new_07.xml#01-29" target="_top">Changes and Additions to CppAD During 2007: 01-29</a><br/>
	169	01<b>-</b>30 <a href="whats_new_12.xml#01-30" target="_top">CppAD Changes and Additions During 2012: 01-30</a><br/>
	170	01<b>-</b>31 <a href="whats_new_09.xml#01-31" target="_top">Changes and Additions to CppAD During 2009: 01-31</a><br/>
	171	02<b>-</b>01 <a href="whats_new_04.xml#02-01" target="_top">Changes and Additions to CppAD During 2004: 02-01</a><br/>
	172	<a href="whats_new_07.xml#02-01" target="_top">Changes and Additions to CppAD During 2007: 02-01</a><br/>
	173	<a href="whats_new_09.xml#02-01" target="_top">Changes and Additions to CppAD During 2009: 02-01</a><br/>
	174	<a href="whats_new_11.xml#02-01" target="_top">Changes and Additions to CppAD During 2011: 02-01</a><br/>
	175	02<b>-</b>02 <a href="whats_new_07.xml#02-02" target="_top">Changes and Additions to CppAD During 2007: 02-02</a><br/>
	176	<a href="whats_new_11.xml#02-02" target="_top">Changes and Additions to CppAD During 2011: 02-02</a><br/>
	177	02<b>-</b>03 <a href="whats_new_07.xml#02-03" target="_top">Changes and Additions to CppAD During 2007: 02-03</a><br/>
	178	<a href="whats_new_08.xml#02-03" target="_top">Changes and Additions to CppAD During 2008: 02-03</a><br/>
	179	<a href="whats_new_10.xml#02-03" target="_top">Changes and Additions to CppAD During 2010: 02-03</a><br/>
	180	02<b>-</b>04 <a href="whats_new_06.xml#02-04" target="_top">Changes and Additions to CppAD During 2006: 02-04</a><br/>
	181	<a href="whats_new_07.xml#02-04" target="_top">Changes and Additions to CppAD During 2007: 02-04</a><br/>
	182	02<b>-</b>05 <a href="whats_new_08.xml#02-05" target="_top">Changes and Additions to CppAD During 2008: 02-05</a><br/>
	183	<a href="whats_new_10.xml#02-05" target="_top">Changes and Additions to CppAD During 2010: 02-05</a><br/>
	184	02<b>-</b>06 <a href="whats_new_07.xml#02-06" target="_top">Changes and Additions to CppAD During 2007: 02-06</a><br/>
	185	<a href="whats_new_10.xml#02-06" target="_top">Changes and Additions to CppAD During 2010: 02-06</a><br/>
	186	<a href="whats_new_11.xml#02-06" target="_top">Changes and Additions to CppAD During 2011: 02-06</a><br/>
	187	02<b>-</b>08 <a href="whats_new_10.xml#02-08" target="_top">Changes and Additions to CppAD During 2010: 02-08</a><br/>
	188	02<b>-</b>09 <a href="whats_new_11.xml#02-09" target="_top">Changes and Additions to CppAD During 2011: 02-09</a><br/>
	189	<a href="whats_new_12.xml#02-09" target="_top">CppAD Changes and Additions During 2012: 02-09</a><br/>
	190	02<b>-</b>10 <a href="whats_new_06.xml#02-10" target="_top">Changes and Additions to CppAD During 2006: 02-10</a><br/>
	191	<a href="whats_new_12.xml#02-10" target="_top">CppAD Changes and Additions During 2012: 02-10</a><br/>
	192	02<b>-</b>11 <a href="whats_new_06.xml#02-11" target="_top">Changes and Additions to CppAD During 2006: 02-11</a><br/>
	193	<a href="whats_new_10.xml#02-11" target="_top">Changes and Additions to CppAD During 2010: 02-11</a><br/>
	194	<a href="whats_new_12.xml#02-11" target="_top">CppAD Changes and Additions During 2012: 02-11</a><br/>
	195	02<b>-</b>12 <a href="whats_new_04.xml#02-12" target="_top">Changes and Additions to CppAD During 2004: 02-12</a><br/>
	196	02<b>-</b>13 <a href="whats_new_06.xml#02-13" target="_top">Changes and Additions to CppAD During 2006: 02-13</a><br/>
	197	02<b>-</b>14 <a href="whats_new_06.xml#02-14" target="_top">Changes and Additions to CppAD During 2006: 02-14</a><br/>
	198	02<b>-</b>15 <a href="whats_new_04.xml#02-15" target="_top">Changes and Additions to CppAD During 2004: 02-15</a><br/>
	199	<a href="whats_new_06.xml#02-15" target="_top">Changes and Additions to CppAD During 2006: 02-15</a><br/>
	200	<a href="whats_new_07.xml#03-09.02-15" target="_top">Changes and Additions to CppAD During 2007: 03-09.02-15</a><br/>
	201	<a href="whats_new_09.xml#02-15" target="_top">Changes and Additions to CppAD During 2009: 02-15</a><br/>
	202	<a href="whats_new_11.xml#02-15" target="_top">Changes and Additions to CppAD During 2011: 02-15</a><br/>
	203	<a href="whats_new_14.xml#02-15" target="_top">CppAD Changes and Additions During 2014: 02-15</a><br/>
	204	02<b>-</b>16 <a href="whats_new_04.xml#02-16" target="_top">Changes and Additions to CppAD During 2004: 02-16</a><br/>
	205	<a href="whats_new_07.xml#03-09.02-16" target="_top">Changes and Additions to CppAD During 2007: 03-09.02-16</a><br/>
	206	02<b>-</b>17 <a href="whats_new_04.xml#02-17" target="_top">Changes and Additions to CppAD During 2004: 02-17</a><br/>
	207	<a href="whats_new_07.xml#03-09.02-17" target="_top">Changes and Additions to CppAD During 2007: 03-09.02-17</a><br/>
	208	<a href="whats_new_11.xml#02-17" target="_top">Changes and Additions to CppAD During 2011: 02-17</a><br/>
	209	<a href="whats_new_14.xml#02-17" target="_top">CppAD Changes and Additions During 2014: 02-17</a><br/>
	210	02<b>-</b>19 <a href="whats_new_11.xml#02-19" target="_top">Changes and Additions to CppAD During 2011: 02-19</a><br/>
	211	02<b>-</b>20 <a href="whats_new_04.xml#02-20" target="_top">Changes and Additions to CppAD During 2004: 02-20</a><br/>
	212	<a href="whats_new_09.xml#02-20" target="_top">Changes and Additions to CppAD During 2009: 02-20</a><br/>
	213	02<b>-</b>21 <a href="whats_new_04.xml#02-21" target="_top">Changes and Additions to CppAD During 2004: 02-21</a><br/>
	214	<a href="whats_new_06.xml#02-21" target="_top">Changes and Additions to CppAD During 2006: 02-21</a><br/>
	215	02<b>-</b>22 <a href="whats_new_07.xml#03-09.02-22" target="_top">Changes and Additions to CppAD During 2007: 03-09.02-22</a><br/>
	216	<a href="whats_new_11.xml#02-22" target="_top">Changes and Additions to CppAD During 2011: 02-22</a><br/>
	217	<a href="whats_new_14.xml#02-22" target="_top">CppAD Changes and Additions During 2014: 02-22</a><br/>
	218	02<b>-</b>23 <a href="whats_new_06.xml#02-23" target="_top">Changes and Additions to CppAD During 2006: 02-23</a><br/>
	219	<a href="whats_new_14.xml#02-23" target="_top">CppAD Changes and Additions During 2014: 02-23</a><br/>
	220	02<b>-</b>24 <a href="whats_new_05.xml#02-24" target="_top">Changes and Additions to CppAD During 2005: 02-24</a><br/>
	221	<a href="whats_new_06.xml#02-24" target="_top">Changes and Additions to CppAD During 2006: 02-24</a><br/>
	222	02<b>-</b>25 <a href="whats_new_06.xml#02-25" target="_top">Changes and Additions to CppAD During 2006: 02-25</a><br/>
	223	02<b>-</b>26 <a href="whats_new_14.xml#02-26" target="_top">CppAD Changes and Additions During 2014: 02-26</a><br/>
	224	02<b>-</b>27 <a href="whats_new_07.xml#03-09.02-27" target="_top">Changes and Additions to CppAD During 2007: 03-09.02-27</a><br/>
	225	<a href="whats_new_14.xml#02-27" target="_top">CppAD Changes and Additions During 2014: 02-27</a><br/>
	226	02<b>-</b>28 <a href="whats_new_04.xml#02-28" target="_top">Changes and Additions to CppAD During 2004: 02-28</a><br/>
	227	<a href="whats_new_06.xml#02-28" target="_top">Changes and Additions to CppAD During 2006: 02-28</a><br/>
	228	<a href="whats_new_14.xml#02-28" target="_top">CppAD Changes and Additions During 2014: 02-28</a><br/>
	229	02<b>-</b>29 <a href="whats_new_04.xml#02-29" target="_top">Changes and Additions to CppAD During 2004: 02-29</a><br/>
	230	03<b>-</b>01 <a href="whats_new_04.xml#03-01" target="_top">Changes and Additions to CppAD During 2004: 03-01</a><br/>
	231	<a href="whats_new_05.xml#03-01" target="_top">Changes and Additions to CppAD During 2005: 03-01</a><br/>
	232	<a href="whats_new_14.xml#03-01" target="_top">CppAD Changes and Additions During 2014: 03-01</a><br/>
	233	03<b>-</b>02 <a href="whats_new_12.xml#03-02" target="_top">CppAD Changes and Additions During 2012: 03-02</a><br/>
	234	<a href="whats_new_14.xml#03-02" target="_top">CppAD Changes and Additions During 2014: 03-02</a><br/>
	235	03<b>-</b>03 <a href="whats_new_04.xml#03-03" target="_top">Changes and Additions to CppAD During 2004: 03-03</a><br/>
	236	<a href="whats_new_10.xml#03-03" target="_top">Changes and Additions to CppAD During 2010: 03-03</a><br/>
	237	<a href="whats_new_12.xml#03-03" target="_top">CppAD Changes and Additions During 2012: 03-03</a><br/>
	238	03<b>-</b>04 <a href="whats_new_04.xml#03-04" target="_top">Changes and Additions to CppAD During 2004: 03-04</a><br/>
	239	<a href="whats_new_05.xml#03-04" target="_top">Changes and Additions to CppAD During 2005: 03-04</a><br/>
	240	03<b>-</b>05 <a href="whats_new_04.xml#03-05" target="_top">Changes and Additions to CppAD During 2004: 03-05</a><br/>
	241	<a href="whats_new_06.xml#03-05" target="_top">Changes and Additions to CppAD During 2006: 03-05</a><br/>
	242	<a href="whats_new_11.xml#03-05" target="_top">Changes and Additions to CppAD During 2011: 03-05</a><br/>
	243	<a href="whats_new_14.xml#03-05" target="_top">CppAD Changes and Additions During 2014: 03-05</a><br/>
	244	03<b>-</b>06 <a href="whats_new_04.xml#03-06" target="_top">Changes and Additions to CppAD During 2004: 03-06</a><br/>
	245	03<b>-</b>07 <a href="whats_new_04.xml#03-07" target="_top">Changes and Additions to CppAD During 2004: 03-07</a><br/>
	246	<a href="whats_new_06.xml#03-07" target="_top">Changes and Additions to CppAD During 2006: 03-07</a><br/>
	247	03<b>-</b>09 <a href="whats_new_04.xml#03-09" target="_top">Changes and Additions to CppAD During 2004: 03-09</a><br/>
	248	<a href="whats_new_05.xml#03-09" target="_top">Changes and Additions to CppAD During 2005: 03-09</a><br/>
	249	<a href="whats_new_06.xml#03-09" target="_top">Changes and Additions to CppAD During 2006: 03-09</a><br/>
	250	<a href="whats_new_07.xml#03-09" target="_top">Changes and Additions to CppAD During 2007: 03-09</a><br/>
	251	<a href="whats_new_10.xml#03-09" target="_top">Changes and Additions to CppAD During 2010: 03-09</a><br/>
	252	<a href="whats_new_14.xml#03-09" target="_top">CppAD Changes and Additions During 2014: 03-09</a><br/>
	253	03<b>-</b>10 <a href="whats_new_06.xml#03-10" target="_top">Changes and Additions to CppAD During 2006: 03-10</a><br/>
	254	<a href="whats_new_10.xml#03-10" target="_top">Changes and Additions to CppAD During 2010: 03-10</a><br/>
	255	03<b>-</b>11 <a href="whats_new_04.xml#03-11" target="_top">Changes and Additions to CppAD During 2004: 03-11</a><br/>
	256	<a href="whats_new_06.xml#03-11" target="_top">Changes and Additions to CppAD During 2006: 03-11</a><br/>
	257	<a href="whats_new_10.xml#03-11" target="_top">Changes and Additions to CppAD During 2010: 03-11</a><br/>
	258	<a href="whats_new_11.xml#03-11" target="_top">Changes and Additions to CppAD During 2011: 03-11</a><br/>
	259	<a href="whats_new_12.xml#03-11" target="_top">CppAD Changes and Additions During 2012: 03-11</a><br/>
	260	03<b>-</b>12 <a href="whats_new_04.xml#03-12" target="_top">Changes and Additions to CppAD During 2004: 03-12</a><br/>
	261	03<b>-</b>13 <a href="whats_new_07.xml#03-15.03-13" target="_top">Changes and Additions to CppAD During 2007: 03-15.03-13</a><br/>
	262	03<b>-</b>14 <a href="whats_new_07.xml#03-15.03-14" target="_top">Changes and Additions to CppAD During 2007: 03-15.03-14</a><br/>
	263	03<b>-</b>15 <a href="whats_new_04.xml#03-15" target="_top">Changes and Additions to CppAD During 2004: 03-15</a><br/>
	264	<a href="whats_new_06.xml#03-15" target="_top">Changes and Additions to CppAD During 2006: 03-15</a><br/>
	265	<a href="whats_new_07.xml#03-15.03-15" target="_top">Changes and Additions to CppAD During 2007: 03-15.03-15</a><br/>
	266	<a href="whats_new_07.xml#03-15" target="_top">Changes and Additions to CppAD During 2007: 03-15</a><br/>
	267	03<b>-</b>16 <a href="whats_new_06.xml#03-16" target="_top">Changes and Additions to CppAD During 2006: 03-16</a><br/>
	268	03<b>-</b>17 <a href="whats_new_04.xml#03-17" target="_top">Changes and Additions to CppAD During 2004: 03-17</a><br/>
	269	<a href="whats_new_06.xml#03-17" target="_top">Changes and Additions to CppAD During 2006: 03-17</a><br/>
	270	<a href="whats_new_12.xml#03-17" target="_top">CppAD Changes and Additions During 2012: 03-17</a><br/>
	271	<a href="whats_new_14.xml#03-17" target="_top">CppAD Changes and Additions During 2014: 03-17</a><br/>
	272	03<b>-</b>18 <a href="whats_new_04.xml#03-18" target="_top">Changes and Additions to CppAD During 2004: 03-18</a><br/>
	273	<a href="whats_new_06.xml#03-18" target="_top">Changes and Additions to CppAD During 2006: 03-18</a><br/>
	274	<a href="whats_new_14.xml#03-18" target="_top">CppAD Changes and Additions During 2014: 03-18</a><br/>
	275	03<b>-</b>19 <a href="whats_new_11.xml#03-19" target="_top">Changes and Additions to CppAD During 2011: 03-19</a><br/>
	276	03<b>-</b>20 <a href="whats_new_07.xml#03-20" target="_top">Changes and Additions to CppAD During 2007: 03-20</a><br/>
	277	03<b>-</b>21 <a href="whats_new_12.xml#03-21" target="_top">CppAD Changes and Additions During 2012: 03-21</a><br/>
	278	03<b>-</b>22 <a href="whats_new_05.xml#03-22" target="_top">Changes and Additions to CppAD During 2005: 03-22</a><br/>
	279	<a href="whats_new_06.xml#03-22" target="_top">Changes and Additions to CppAD During 2006: 03-22</a><br/>
	280	03<b>-</b>23 <a href="whats_new_05.xml#03-23" target="_top">Changes and Additions to CppAD During 2005: 03-23</a><br/>
	281	<a href="whats_new_06.xml#03-23" target="_top">Changes and Additions to CppAD During 2006: 03-23</a><br/>
	282	<a href="whats_new_12.xml#03-23" target="_top">CppAD Changes and Additions During 2012: 03-23</a><br/>
	283	03<b>-</b>24 <a href="whats_new_06.xml#03-24" target="_top">Changes and Additions to CppAD During 2006: 03-24</a><br/>
	284	<a href="whats_new_09.xml#03-24" target="_top">Changes and Additions to CppAD During 2009: 03-24</a><br/>
	285	03<b>-</b>25 <a href="whats_new_04.xml#03-25" target="_top">Changes and Additions to CppAD During 2004: 03-25</a><br/>
	286	03<b>-</b>26 <a href="whats_new_05.xml#03-26" target="_top">Changes and Additions to CppAD During 2005: 03-26</a><br/>
	287	<a href="whats_new_06.xml#03-26" target="_top">Changes and Additions to CppAD During 2006: 03-26</a><br/>
	288	<a href="whats_new_12.xml#03-26" target="_top">CppAD Changes and Additions During 2012: 03-26</a><br/>
	289	03<b>-</b>27 <a href="whats_new_06.xml#03-27" target="_top">Changes and Additions to CppAD During 2006: 03-27</a><br/>
	290	<a href="whats_new_08.xml#03-27" target="_top">Changes and Additions to CppAD During 2008: 03-27</a><br/>
	291	<a href="whats_new_12.xml#03-27" target="_top">CppAD Changes and Additions During 2012: 03-27</a><br/>
	292	03<b>-</b>28 <a href="whats_new_04.xml#03-28" target="_top">Changes and Additions to CppAD During 2004: 03-28</a><br/>
	293	<a href="whats_new_06.xml#03-28" target="_top">Changes and Additions to CppAD During 2006: 03-28</a><br/>
	294	<a href="whats_new_07.xml#03-09.03-28" target="_top">Changes and Additions to CppAD During 2007: 03-09.03-28</a><br/>
	295	03<b>-</b>29 <a href="whats_new_06.xml#03-29" target="_top">Changes and Additions to CppAD During 2006: 03-29</a><br/>
	296	<a href="whats_new_07.xml#03-29" target="_top">Changes and Additions to CppAD During 2007: 03-29</a><br/>
	297	03<b>-</b>30 <a href="whats_new_04.xml#03-30" target="_top">Changes and Additions to CppAD During 2004: 03-30</a><br/>
	298	<a href="whats_new_06.xml#03-30" target="_top">Changes and Additions to CppAD During 2006: 03-30</a><br/>
	299	<a href="whats_new_07.xml#03-31.03-30" target="_top">Changes and Additions to CppAD During 2007: 03-31.03-30</a><br/>
	300	03<b>-</b>31 <a href="whats_new_06.xml#03-31" target="_top">Changes and Additions to CppAD During 2006: 03-31</a><br/>
	301	<a href="whats_new_07.xml#03-31.03-31" target="_top">Changes and Additions to CppAD During 2007: 03-31.03-31</a><br/>
	302	<a href="whats_new_07.xml#03-31" target="_top">Changes and Additions to CppAD During 2007: 03-31</a><br/>
	303	04<b>-</b>01 <a href="whats_new_04.xml#04-01" target="_top">Changes and Additions to CppAD During 2004: 04-01</a><br/>
	304	<a href="whats_new_06.xml#04-01" target="_top">Changes and Additions to CppAD During 2006: 04-01</a><br/>
	305	<a href="whats_new_10.xml#04-01" target="_top">Changes and Additions to CppAD During 2010: 04-01</a><br/>
	306	<a href="whats_new_12.xml#04-01" target="_top">CppAD Changes and Additions During 2012: 04-01</a><br/>
	307	04<b>-</b>02 <a href="whats_new_04.xml#04-02" target="_top">Changes and Additions to CppAD During 2004: 04-02</a><br/>
	308	<a href="whats_new_06.xml#04-02" target="_top">Changes and Additions to CppAD During 2006: 04-02</a><br/>
	309	04<b>-</b>03 <a href="whats_new_04.xml#04-03" target="_top">Changes and Additions to CppAD During 2004: 04-03</a><br/>
	310	<a href="whats_new_06.xml#04-03" target="_top">Changes and Additions to CppAD During 2006: 04-03</a><br/>
	311	04<b>-</b>04 <a href="whats_new_06.xml#04-04" target="_top">Changes and Additions to CppAD During 2006: 04-04</a><br/>
	312	<a href="whats_new_08.xml#04-04" target="_top">Changes and Additions to CppAD During 2008: 04-04</a><br/>
	313	04<b>-</b>05 <a href="whats_new_06.xml#04-05" target="_top">Changes and Additions to CppAD During 2006: 04-05</a><br/>
	314	<a href="whats_new_07.xml#04-11.04-05" target="_top">Changes and Additions to CppAD During 2007: 04-11.04-05</a><br/>
	315	<a href="whats_new_12.xml#04-05" target="_top">CppAD Changes and Additions During 2012: 04-05</a><br/>
	316	04<b>-</b>06 <a href="whats_new_06.xml#04-06" target="_top">Changes and Additions to CppAD During 2006: 04-06</a><br/>
	317	<a href="whats_new_07.xml#04-11.04-06" target="_top">Changes and Additions to CppAD During 2007: 04-11.04-06</a><br/>
	318	<a href="whats_new_08.xml#04-06" target="_top">Changes and Additions to CppAD During 2008: 04-06</a><br/>
	319	<a href="whats_new_12.xml#04-06" target="_top">CppAD Changes and Additions During 2012: 04-06</a><br/>
	320	04<b>-</b>07 <a href="whats_new_04.xml#04-07" target="_top">Changes and Additions to CppAD During 2004: 04-07</a><br/>
	321	<a href="whats_new_07.xml#04-11.04-07" target="_top">Changes and Additions to CppAD During 2007: 04-11.04-07</a><br/>
	322	04<b>-</b>08 <a href="whats_new_04.xml#04-08" target="_top">Changes and Additions to CppAD During 2004: 04-08</a><br/>
	323	<a href="whats_new_06.xml#04-08" target="_top">Changes and Additions to CppAD During 2006: 04-08</a><br/>
	324	04<b>-</b>09 <a href="whats_new_04.xml#04-09" target="_top">Changes and Additions to CppAD During 2004: 04-09</a><br/>
	325	04<b>-</b>10 <a href="whats_new_07.xml#04-11.04-10" target="_top">Changes and Additions to CppAD During 2007: 04-11.04-10</a><br/>
	326	<a href="whats_new_08.xml#04-10" target="_top">Changes and Additions to CppAD During 2008: 04-10</a><br/>
	327	<a href="whats_new_12.xml#04-10" target="_top">CppAD Changes and Additions During 2012: 04-10</a><br/>
	328	04<b>-</b>11 <a href="whats_new_07.xml#04-11.04-11" target="_top">Changes and Additions to CppAD During 2007: 04-11.04-11</a><br/>
	329	<a href="whats_new_07.xml#04-11" target="_top">Changes and Additions to CppAD During 2007: 04-11</a><br/>
	330	04<b>-</b>13 <a href="whats_new_06.xml#04-13" target="_top">Changes and Additions to CppAD During 2006: 04-13</a><br/>
	331	04<b>-</b>14 <a href="whats_new_06.xml#04-14" target="_top">Changes and Additions to CppAD During 2006: 04-14</a><br/>
	332	<a href="whats_new_07.xml#04-14" target="_top">Changes and Additions to CppAD During 2007: 04-14</a><br/>
	333	04<b>-</b>15 <a href="whats_new_06.xml#04-15" target="_top">Changes and Additions to CppAD During 2006: 04-15</a><br/>
	334	04<b>-</b>17 <a href="whats_new_06.xml#04-17" target="_top">Changes and Additions to CppAD During 2006: 04-17</a><br/>
	335	<a href="whats_new_07.xml#04-17" target="_top">Changes and Additions to CppAD During 2007: 04-17</a><br/>
	336	<a href="whats_new_12.xml#04-17" target="_top">CppAD Changes and Additions During 2012: 04-17</a><br/>
	337	04<b>-</b>18 <a href="whats_new_06.xml#04-18" target="_top">Changes and Additions to CppAD During 2006: 04-18</a><br/>
	338	<a href="whats_new_08.xml#04-18" target="_top">Changes and Additions to CppAD During 2008: 04-18</a><br/>
	339	<a href="whats_new_12.xml#04-18" target="_top">CppAD Changes and Additions During 2012: 04-18</a><br/>
	340	04<b>-</b>19 <a href="whats_new_04.xml#04-19" target="_top">Changes and Additions to CppAD During 2004: 04-19</a><br/>
	341	<a href="whats_new_05.xml#04-19" target="_top">Changes and Additions to CppAD During 2005: 04-19</a><br/>
	342	<a href="whats_new_06.xml#04-19" target="_top">Changes and Additions to CppAD During 2006: 04-19</a><br/>
	343	<a href="whats_new_07.xml#04-19" target="_top">Changes and Additions to CppAD During 2007: 04-19</a><br/>
	344	<a href="whats_new_11.xml#04-19" target="_top">Changes and Additions to CppAD During 2011: 04-19</a><br/>
	345	<a href="whats_new_12.xml#04-19" target="_top">CppAD Changes and Additions During 2012: 04-19</a><br/>
	346	04<b>-</b>20 <a href="whats_new_04.xml#04-20" target="_top">Changes and Additions to CppAD During 2004: 04-20</a><br/>
	347	<a href="whats_new_05.xml#04-20" target="_top">Changes and Additions to CppAD During 2005: 04-20</a><br/>
	348	<a href="whats_new_08.xml#04-20" target="_top">Changes and Additions to CppAD During 2008: 04-20</a><br/>
	349	<a href="whats_new_11.xml#04-20" target="_top">Changes and Additions to CppAD During 2011: 04-20</a><br/>
	350	04<b>-</b>21 <a href="whats_new_04.xml#04-21" target="_top">Changes and Additions to CppAD During 2004: 04-21</a><br/>
	351	<a href="whats_new_05.xml#04-21" target="_top">Changes and Additions to CppAD During 2005: 04-21</a><br/>
	352	04<b>-</b>22 <a href="whats_new_04.xml#04-22" target="_top">Changes and Additions to CppAD During 2004: 04-22</a><br/>
	353	04<b>-</b>24 <a href="whats_new_04.xml#04-24" target="_top">Changes and Additions to CppAD During 2004: 04-24</a><br/>
	354	<a href="whats_new_10.xml#04-24" target="_top">Changes and Additions to CppAD During 2010: 04-24</a><br/>
	355	04<b>-</b>25 <a href="whats_new_04.xml#04-25" target="_top">Changes and Additions to CppAD During 2004: 04-25</a><br/>
	356	<a href="whats_new_06.xml#04-25" target="_top">Changes and Additions to CppAD During 2006: 04-25</a><br/>
	357	04<b>-</b>26 <a href="whats_new_06.xml#04-26" target="_top">Changes and Additions to CppAD During 2006: 04-26</a><br/>
	358	<a href="whats_new_10.xml#04-26" target="_top">Changes and Additions to CppAD During 2010: 04-26</a><br/>
	359	<a href="whats_new_13.xml#04-26" target="_top">CppAD Changes and Additions During 2013: 04-26</a><br/>
	360	04<b>-</b>27 <a href="whats_new_13.xml#04-27" target="_top">CppAD Changes and Additions During 2013: 04-27</a><br/>
	361	04<b>-</b>28 <a href="whats_new_04.xml#04-28" target="_top">Changes and Additions to CppAD During 2004: 04-28</a><br/>
	362	<a href="whats_new_06.xml#04-28" target="_top">Changes and Additions to CppAD During 2006: 04-28</a><br/>
	363	<a href="whats_new_10.xml#04-28" target="_top">Changes and Additions to CppAD During 2010: 04-28</a><br/>
	364	<a href="whats_new_13.xml#04-28" target="_top">CppAD Changes and Additions During 2013: 04-28</a><br/>
	365	04<b>-</b>29 <a href="whats_new_04.xml#04-29" target="_top">Changes and Additions to CppAD During 2004: 04-29</a><br/>
	366	<a href="whats_new_06.xml#04-29" target="_top">Changes and Additions to CppAD During 2006: 04-29</a><br/>
	367	<a href="whats_new_11.xml#04-29" target="_top">Changes and Additions to CppAD During 2011: 04-29</a><br/>
	368	05<b>-</b>01 <a href="whats_new_05.xml#05-01" target="_top">Changes and Additions to CppAD During 2005: 05-01</a><br/>
	369	05<b>-</b>03 <a href="whats_new_04.xml#05-03" target="_top">Changes and Additions to CppAD During 2004: 05-03</a><br/>
	370	<a href="whats_new_06.xml#05-03" target="_top">Changes and Additions to CppAD During 2006: 05-03</a><br/>
	371	<a href="whats_new_08.xml#05-03" target="_top">Changes and Additions to CppAD During 2008: 05-03</a><br/>
	372	<a href="whats_new_11.xml#05-03" target="_top">Changes and Additions to CppAD During 2011: 05-03</a><br/>
	373	05<b>-</b>04 <a href="whats_new_04.xml#05-04" target="_top">Changes and Additions to CppAD During 2004: 05-04</a><br/>
	374	<a href="whats_new_13.xml#05-04" target="_top">CppAD Changes and Additions During 2013: 05-04</a><br/>
	375	05<b>-</b>05 <a href="whats_new_07.xml#05-05" target="_top">Changes and Additions to CppAD During 2007: 05-05</a><br/>
	376	05<b>-</b>06 <a href="whats_new_05.xml#05-06" target="_top">Changes and Additions to CppAD During 2005: 05-06</a><br/>
	377	05<b>-</b>07 <a href="whats_new_04.xml#05-07" target="_top">Changes and Additions to CppAD During 2004: 05-07</a><br/>
	378	05<b>-</b>08 <a href="whats_new_07.xml#05-08" target="_top">Changes and Additions to CppAD During 2007: 05-08</a><br/>
	379	<a href="whats_new_08.xml#05-08" target="_top">Changes and Additions to CppAD During 2008: 05-08</a><br/>
	380	05<b>-</b>09 <a href="whats_new_04.xml#05-09" target="_top">Changes and Additions to CppAD During 2004: 05-09</a><br/>
	381	05<b>-</b>11 <a href="whats_new_11.xml#05-11" target="_top">Changes and Additions to CppAD During 2011: 05-11</a><br/>
	382	<a href="whats_new_13.xml#05-11" target="_top">CppAD Changes and Additions During 2013: 05-11</a><br/>
	383	05<b>-</b>12 <a href="whats_new_04.xml#05-12" target="_top">Changes and Additions to CppAD During 2004: 05-12</a><br/>
	384	<a href="whats_new_05.xml#05-12" target="_top">Changes and Additions to CppAD During 2005: 05-12</a><br/>
	385	<a href="whats_new_13.xml#05-12" target="_top">CppAD Changes and Additions During 2013: 05-12</a><br/>
	386	05<b>-</b>14 <a href="whats_new_04.xml#05-14" target="_top">Changes and Additions to CppAD During 2004: 05-14</a><br/>
	387	<a href="whats_new_13.xml#05-14" target="_top">CppAD Changes and Additions During 2013: 05-14</a><br/>
	388	<a href="whats_new_14.xml#05-14" target="_top">CppAD Changes and Additions During 2014: 05-14</a><br/>
	389	05<b>-</b>15 <a href="whats_new_13.xml#05-15" target="_top">CppAD Changes and Additions During 2013: 05-15</a><br/>
	390	05<b>-</b>16 <a href="whats_new_05.xml#05-16" target="_top">Changes and Additions to CppAD During 2005: 05-16</a><br/>
	391	<a href="whats_new_14.xml#05-16" target="_top">CppAD Changes and Additions During 2014: 05-16</a><br/>
	392	05<b>-</b>17 <a href="whats_new_13.xml#05-17" target="_top">CppAD Changes and Additions During 2013: 05-17</a><br/>
	393	05<b>-</b>18 <a href="whats_new_05.xml#05-18" target="_top">Changes and Additions to CppAD During 2005: 05-18</a><br/>
	394	05<b>-</b>19 <a href="whats_new_05.xml#05-19" target="_top">Changes and Additions to CppAD During 2005: 05-19</a><br/>
	395	<a href="whats_new_14.xml#05-19" target="_top">CppAD Changes and Additions During 2014: 05-19</a><br/>
	396	05<b>-</b>20 <a href="whats_new_09.xml#05-20" target="_top">Changes and Additions to CppAD During 2009: 05-20</a><br/>
	397	<a href="whats_new_14.xml#05-20" target="_top">CppAD Changes and Additions During 2014: 05-20</a><br/>
	398	05<b>-</b>21 <a href="whats_new_13.xml#05-21" target="_top">CppAD Changes and Additions During 2013: 05-21</a><br/>
	399	05<b>-</b>22 <a href="whats_new_07.xml#05-22" target="_top">Changes and Additions to CppAD During 2007: 05-22</a><br/>
	400	<a href="whats_new_11.xml#05-22" target="_top">Changes and Additions to CppAD During 2011: 05-22</a><br/>
	401	<a href="whats_new_14.xml#05-22" target="_top">CppAD Changes and Additions During 2014: 05-22</a><br/>
	402	05<b>-</b>23 <a href="whats_new_14.xml#05-23" target="_top">CppAD Changes and Additions During 2014: 05-23</a><br/>
	403	05<b>-</b>24 <a href="whats_new_07.xml#05-24" target="_top">Changes and Additions to CppAD During 2007: 05-24</a><br/>
	404	<a href="whats_new_12.xml#05-24" target="_top">CppAD Changes and Additions During 2012: 05-24</a><br/>
	405	05<b>-</b>25 <a href="whats_new_04.xml#05-25" target="_top">Changes and Additions to CppAD During 2004: 05-25</a><br/>
	406	<a href="whats_new_07.xml#05-25" target="_top">Changes and Additions to CppAD During 2007: 05-25</a><br/>
	407	05<b>-</b>26 <a href="whats_new_04.xml#05-26" target="_top">Changes and Additions to CppAD During 2004: 05-26</a><br/>
	408	<a href="whats_new_07.xml#05-26" target="_top">Changes and Additions to CppAD During 2007: 05-26</a><br/>
	409	<a href="whats_new_11.xml#05-26" target="_top">Changes and Additions to CppAD During 2011: 05-26</a><br/>
	410	05<b>-</b>27 <a href="whats_new_06.xml#05-27" target="_top">Changes and Additions to CppAD During 2006: 05-27</a><br/>
	411	<a href="whats_new_12.xml#05-27" target="_top">CppAD Changes and Additions During 2012: 05-27</a><br/>
	412	<a href="whats_new_14.xml#05-27" target="_top">CppAD Changes and Additions During 2014: 05-27</a><br/>
	413	05<b>-</b>28 <a href="whats_new_11.xml#05-28" target="_top">Changes and Additions to CppAD During 2011: 05-28</a><br/>
	414	<a href="whats_new_13.xml#05-28" target="_top">CppAD Changes and Additions During 2013: 05-28</a><br/>
	415	<a href="whats_new_14.xml#05-28" target="_top">CppAD Changes and Additions During 2014: 05-28</a><br/>
	416	05<b>-</b>29 <a href="whats_new_04.xml#05-29" target="_top">Changes and Additions to CppAD During 2004: 05-29</a><br/>
	417	<a href="whats_new_06.xml#05-29" target="_top">Changes and Additions to CppAD During 2006: 05-29</a><br/>
	418	<a href="whats_new_11.xml#05-29" target="_top">Changes and Additions to CppAD During 2011: 05-29</a><br/>
	419	<a href="whats_new_12.xml#05-29" target="_top">CppAD Changes and Additions During 2012: 05-29</a><br/>
	420	05<b>-</b>30 <a href="whats_new_04.xml#05-30" target="_top">Changes and Additions to CppAD During 2004: 05-30</a><br/>
	421	<a href="whats_new_12.xml#05-30" target="_top">CppAD Changes and Additions During 2012: 05-30</a><br/>
	422	05<b>-</b>31 <a href="whats_new_06.xml#05-31" target="_top">Changes and Additions to CppAD During 2006: 05-31</a><br/>
	423	<a href="whats_new_12.xml#05-31" target="_top">CppAD Changes and Additions During 2012: 05-31</a><br/>
	424	06<b>-</b>01 <a href="whats_new_04.xml#06-01" target="_top">Changes and Additions to CppAD During 2004: 06-01</a><br/>
	425	<a href="whats_new_10.xml#06-01" target="_top">Changes and Additions to CppAD During 2010: 06-01</a><br/>
	426	<a href="whats_new_12.xml#06-01" target="_top">CppAD Changes and Additions During 2012: 06-01</a><br/>
	427	06<b>-</b>02 <a href="whats_new_06.xml#06-02" target="_top">Changes and Additions to CppAD During 2006: 06-02</a><br/>
	428	<a href="whats_new_12.xml#06-02" target="_top">CppAD Changes and Additions During 2012: 06-02</a><br/>
	429	06<b>-</b>03 <a href="whats_new_04.xml#06-03" target="_top">Changes and Additions to CppAD During 2004: 06-03</a><br/>
	430	<a href="whats_new_12.xml#06-03" target="_top">CppAD Changes and Additions During 2012: 06-03</a><br/>
	431	06<b>-</b>04 <a href="whats_new_04.xml#06-04" target="_top">Changes and Additions to CppAD During 2004: 06-04</a><br/>
	432	<a href="whats_new_12.xml#06-04" target="_top">CppAD Changes and Additions During 2012: 06-04</a><br/>
	433	06<b>-</b>05 <a href="whats_new_06.xml#06-05" target="_top">Changes and Additions to CppAD During 2006: 06-05</a><br/>
	434	<a href="whats_new_12.xml#06-05" target="_top">CppAD Changes and Additions During 2012: 06-05</a><br/>
	435	06<b>-</b>06 <a href="whats_new_05.xml#06-06" target="_top">Changes and Additions to CppAD During 2005: 06-06</a><br/>
	436	<a href="whats_new_09.xml#06-06" target="_top">Changes and Additions to CppAD During 2009: 06-06</a><br/>
	437	06<b>-</b>07 <a href="whats_new_06.xml#06-07" target="_top">Changes and Additions to CppAD During 2006: 06-07</a><br/>
	438	<a href="whats_new_12.xml#06-07" target="_top">CppAD Changes and Additions During 2012: 06-07</a><br/>
	439	06<b>-</b>08 <a href="whats_new_12.xml#06-08" target="_top">CppAD Changes and Additions During 2012: 06-08</a><br/>
	440	06<b>-</b>09 <a href="whats_new_06.xml#06-09" target="_top">Changes and Additions to CppAD During 2006: 06-09</a><br/>
	441	<a href="whats_new_12.xml#06-09" target="_top">CppAD Changes and Additions During 2012: 06-09</a><br/>
	442	06<b>-</b>10 <a href="whats_new_08.xml#06-10" target="_top">Changes and Additions to CppAD During 2008: 06-10</a><br/>
	443	<a href="whats_new_12.xml#06-10" target="_top">CppAD Changes and Additions During 2012: 06-10</a><br/>
	444	06<b>-</b>11 <a href="whats_new_08.xml#06-11" target="_top">Changes and Additions to CppAD During 2008: 06-11</a><br/>
	445	06<b>-</b>12 <a href="whats_new_04.xml#06-12" target="_top">Changes and Additions to CppAD During 2004: 06-12</a><br/>
	446	<a href="whats_new_12.xml#06-12" target="_top">CppAD Changes and Additions During 2012: 06-12</a><br/>
	447	06<b>-</b>13 <a href="whats_new_05.xml#06-13" target="_top">Changes and Additions to CppAD During 2005: 06-13</a><br/>
	448	06<b>-</b>14 <a href="whats_new_05.xml#06-14" target="_top">Changes and Additions to CppAD During 2005: 06-14</a><br/>
	449	<a href="whats_new_07.xml#06-14" target="_top">Changes and Additions to CppAD During 2007: 06-14</a><br/>
	450	06<b>-</b>15 <a href="whats_new_06.xml#06-15" target="_top">Changes and Additions to CppAD During 2006: 06-15</a><br/>
	451	<a href="whats_new_08.xml#06-15" target="_top">Changes and Additions to CppAD During 2008: 06-15</a><br/>
	452	<a href="whats_new_12.xml#06-15" target="_top">CppAD Changes and Additions During 2012: 06-15</a><br/>
	453	06<b>-</b>16 <a href="whats_new_12.xml#06-16" target="_top">CppAD Changes and Additions During 2012: 06-16</a><br/>
	454	06<b>-</b>17 <a href="whats_new_06.xml#06-17" target="_top">Changes and Additions to CppAD During 2006: 06-17</a><br/>
	455	<a href="whats_new_06.xml#06-19.06-17" target="_top">Changes and Additions to CppAD During 2006: 06-19.06-17</a><br/>
	456	<a href="whats_new_12.xml#06-17" target="_top">CppAD Changes and Additions During 2012: 06-17</a><br/>
	457	06<b>-</b>18 <a href="whats_new_05.xml#06-18" target="_top">Changes and Additions to CppAD During 2005: 06-18</a><br/>
	458	<a href="whats_new_06.xml#06-19.06-18" target="_top">Changes and Additions to CppAD During 2006: 06-19.06-18</a><br/>
	459	<a href="whats_new_08.xml#06-18" target="_top">Changes and Additions to CppAD During 2008: 06-18</a><br/>
	460	<a href="whats_new_11.xml#06-18" target="_top">Changes and Additions to CppAD During 2011: 06-18</a><br/>
	461	06<b>-</b>19 <a href="whats_new_06.xml#06-19" target="_top">Changes and Additions to CppAD During 2006: 06-19</a><br/>
	462	06<b>-</b>20 <a href="whats_new_07.xml#06-20" target="_top">Changes and Additions to CppAD During 2007: 06-20</a><br/>
	463	<a href="whats_new_09.xml#06-20" target="_top">Changes and Additions to CppAD During 2009: 06-20</a><br/>
	464	06<b>-</b>21 <a href="whats_new_09.xml#06-21" target="_top">Changes and Additions to CppAD During 2009: 06-21</a><br/>
	465	<a href="whats_new_11.xml#06-21" target="_top">Changes and Additions to CppAD During 2011: 06-21</a><br/>
	466	06<b>-</b>22 <a href="whats_new_06.xml#06-22" target="_top">Changes and Additions to CppAD During 2006: 06-22</a><br/>
	467	<a href="whats_new_07.xml#06-22" target="_top">Changes and Additions to CppAD During 2007: 06-22</a><br/>
	468	<a href="whats_new_09.xml#06-22" target="_top">Changes and Additions to CppAD During 2009: 06-22</a><br/>
	469	06<b>-</b>23 <a href="whats_new_11.xml#06-23" target="_top">Changes and Additions to CppAD During 2011: 06-23</a><br/>
	470	06<b>-</b>24 <a href="whats_new_05.xml#06-24" target="_top">Changes and Additions to CppAD During 2005: 06-24</a><br/>
	471	06<b>-</b>25 <a href="whats_new_04.xml#06-25" target="_top">Changes and Additions to CppAD During 2004: 06-25</a><br/>
	472	<a href="whats_new_05.xml#06-25" target="_top">Changes and Additions to CppAD During 2005: 06-25</a><br/>
	473	<a href="whats_new_09.xml#06-25" target="_top">Changes and Additions to CppAD During 2009: 06-25</a><br/>
	474	06<b>-</b>28 <a href="whats_new_09.xml#07-04.06-28" target="_top">Changes and Additions to CppAD During 2009: 07-04.06-28</a><br/>
	475	06<b>-</b>29 <a href="whats_new_04.xml#06-29" target="_top">Changes and Additions to CppAD During 2004: 06-29</a><br/>
	476	<a href="whats_new_06.xml#06-29" target="_top">Changes and Additions to CppAD During 2006: 06-29</a><br/>
	477	<a href="whats_new_09.xml#07-04.06-29" target="_top">Changes and Additions to CppAD During 2009: 07-04.06-29</a><br/>
	478	06<b>-</b>30 <a href="whats_new_09.xml#07-04.06-30" target="_top">Changes and Additions to CppAD During 2009: 07-04.06-30</a><br/>
	479	07<b>-</b>01 <a href="whats_new_05.xml#07-01" target="_top">Changes and Additions to CppAD During 2005: 07-01</a><br/>
	480	<a href="whats_new_09.xml#07-04.07-01" target="_top">Changes and Additions to CppAD During 2009: 07-04.07-01</a><br/>
	481	<a href="whats_new_12.xml#07-01" target="_top">CppAD Changes and Additions During 2012: 07-01</a><br/>
	482	07<b>-</b>02 <a href="whats_new_04.xml#07-02" target="_top">Changes and Additions to CppAD During 2004: 07-02</a><br/>
	483	<a href="whats_new_05.xml#07-02" target="_top">Changes and Additions to CppAD During 2005: 07-02</a><br/>
	484	<a href="whats_new_08.xml#07-02" target="_top">Changes and Additions to CppAD During 2008: 07-02</a><br/>
	485	<a href="whats_new_09.xml#07-04.07-02" target="_top">Changes and Additions to CppAD During 2009: 07-04.07-02</a><br/>
	486	<a href="whats_new_12.xml#07-02" target="_top">CppAD Changes and Additions During 2012: 07-02</a><br/>
	487	07<b>-</b>03 <a href="whats_new_04.xml#07-03" target="_top">Changes and Additions to CppAD During 2004: 07-03</a><br/>
	488	<a href="whats_new_05.xml#07-03" target="_top">Changes and Additions to CppAD During 2005: 07-03</a><br/>
	489	<a href="whats_new_09.xml#07-04.07-03" target="_top">Changes and Additions to CppAD During 2009: 07-04.07-03</a><br/>
	490	<a href="whats_new_12.xml#07-03" target="_top">CppAD Changes and Additions During 2012: 07-03</a><br/>
	491	07<b>-</b>04 <a href="whats_new_05.xml#07-04" target="_top">Changes and Additions to CppAD During 2005: 07-04</a><br/>
	492	<a href="whats_new_09.xml#07-04.07-04" target="_top">Changes and Additions to CppAD During 2009: 07-04.07-04</a><br/>
	493	<a href="whats_new_09.xml#07-04" target="_top">Changes and Additions to CppAD During 2009: 07-04</a><br/>
	494	<a href="whats_new_12.xml#07-04" target="_top">CppAD Changes and Additions During 2012: 07-04</a><br/>
	495	07<b>-</b>05 <a href="whats_new_05.xml#07-05" target="_top">Changes and Additions to CppAD During 2005: 07-05</a><br/>
	496	<a href="whats_new_12.xml#07-05" target="_top">CppAD Changes and Additions During 2012: 07-05</a><br/>
	497	07<b>-</b>06 <a href="whats_new_09.xml#07-23.07-06" target="_top">Changes and Additions to CppAD During 2009: 07-23.07-06</a><br/>
	498	07<b>-</b>07 <a href="whats_new_04.xml#07-07" target="_top">Changes and Additions to CppAD During 2004: 07-07</a><br/>
	499	<a href="whats_new_11.xml#07-07" target="_top">Changes and Additions to CppAD During 2011: 07-07</a><br/>
	500	<a href="whats_new_12.xml#07-07" target="_top">CppAD Changes and Additions During 2012: 07-07</a><br/>
	501	07<b>-</b>08 <a href="whats_new_04.xml#07-08" target="_top">Changes and Additions to CppAD During 2004: 07-08</a><br/>
	502	<a href="whats_new_05.xml#07-08" target="_top">Changes and Additions to CppAD During 2005: 07-08</a><br/>
	503	<a href="whats_new_12.xml#07-08" target="_top">CppAD Changes and Additions During 2012: 07-08</a><br/>
	504	07<b>-</b>09 <a href="whats_new_11.xml#07-09" target="_top">Changes and Additions to CppAD During 2011: 07-09</a><br/>
	505	07<b>-</b>10 <a href="whats_new_11.xml#07-10" target="_top">Changes and Additions to CppAD During 2011: 07-10</a><br/>
	506	07<b>-</b>11 <a href="whats_new_05.xml#07-11" target="_top">Changes and Additions to CppAD During 2005: 07-11</a><br/>
	507	<a href="whats_new_10.xml#07-11" target="_top">Changes and Additions to CppAD During 2010: 07-11</a><br/>
	508	<a href="whats_new_11.xml#07-11" target="_top">Changes and Additions to CppAD During 2011: 07-11</a><br/>
	509	07<b>-</b>12 <a href="whats_new_06.xml#07-12" target="_top">Changes and Additions to CppAD During 2006: 07-12</a><br/>
	510	07<b>-</b>13 <a href="whats_new_07.xml#07-13" target="_top">Changes and Additions to CppAD During 2007: 07-13</a><br/>
	511	<a href="whats_new_11.xml#07-13" target="_top">Changes and Additions to CppAD During 2011: 07-13</a><br/>
	512	07<b>-</b>14 <a href="whats_new_03.xml#07-14" target="_top">Changes and Additions to CppAD During 2003: 07-14</a><br/>
	513	<a href="whats_new_06.xml#07-14" target="_top">Changes and Additions to CppAD During 2006: 07-14</a><br/>
	514	<a href="whats_new_07.xml#07-14" target="_top">Changes and Additions to CppAD During 2007: 07-14</a><br/>
	515	<a href="whats_new_10.xml#07-14" target="_top">Changes and Additions to CppAD During 2010: 07-14</a><br/>
	516	<a href="whats_new_11.xml#07-14" target="_top">Changes and Additions to CppAD During 2011: 07-14</a><br/>
	517	07<b>-</b>15 <a href="whats_new_05.xml#07-15" target="_top">Changes and Additions to CppAD During 2005: 07-15</a><br/>
	518	07<b>-</b>16 <a href="whats_new_03.xml#07-16" target="_top">Changes and Additions to CppAD During 2003: 07-16</a><br/>
	519	07<b>-</b>17 <a href="whats_new_11.xml#07-17" target="_top">Changes and Additions to CppAD During 2011: 07-17</a><br/>
	520	07<b>-</b>18 <a href="whats_new_03.xml#07-18" target="_top">Changes and Additions to CppAD During 2003: 07-18</a><br/>
	521	<a href="whats_new_07.xml#07-18" target="_top">Changes and Additions to CppAD During 2007: 07-18</a><br/>
	522	<a href="whats_new_11.xml#07-18" target="_top">Changes and Additions to CppAD During 2011: 07-18</a><br/>
	523	07<b>-</b>19 <a href="whats_new_05.xml#07-19" target="_top">Changes and Additions to CppAD During 2005: 07-19</a><br/>
	524	<a href="whats_new_07.xml#07-19" target="_top">Changes and Additions to CppAD During 2007: 07-19</a><br/>
	525	07<b>-</b>20 <a href="whats_new_03.xml#07-20" target="_top">Changes and Additions to CppAD During 2003: 07-20</a><br/>
	526	<a href="whats_new_07.xml#07-20" target="_top">Changes and Additions to CppAD During 2007: 07-20</a><br/>
	527	07<b>-</b>21 <a href="whats_new_05.xml#07-21" target="_top">Changes and Additions to CppAD During 2005: 07-21</a><br/>
	528	<a href="whats_new_07.xml#07-21" target="_top">Changes and Additions to CppAD During 2007: 07-21</a><br/>
	529	07<b>-</b>22 <a href="whats_new_03.xml#07-22" target="_top">Changes and Additions to CppAD During 2003: 07-22</a><br/>
	530	<a href="whats_new_07.xml#07-22" target="_top">Changes and Additions to CppAD During 2007: 07-22</a><br/>
	531	07<b>-</b>23 <a href="whats_new_07.xml#07-23" target="_top">Changes and Additions to CppAD During 2007: 07-23</a><br/>
	532	<a href="whats_new_09.xml#07-23" target="_top">Changes and Additions to CppAD During 2009: 07-23</a><br/>
	533	07<b>-</b>24 <a href="whats_new_09.xml#07-24" target="_top">Changes and Additions to CppAD During 2009: 07-24</a><br/>
	534	07<b>-</b>25 <a href="whats_new_07.xml#07-26.07-25" target="_top">Changes and Additions to CppAD During 2007: 07-26.07-25</a><br/>
	535	<a href="whats_new_09.xml#07-25" target="_top">Changes and Additions to CppAD During 2009: 07-25</a><br/>
	536	<a href="whats_new_11.xml#07-25" target="_top">Changes and Additions to CppAD During 2011: 07-25</a><br/>
	537	07<b>-</b>26 <a href="whats_new_03.xml#07-26" target="_top">Changes and Additions to CppAD During 2003: 07-26</a><br/>
	538	<a href="whats_new_07.xml#07-26.07-26" target="_top">Changes and Additions to CppAD During 2007: 07-26.07-26</a><br/>
	539	<a href="whats_new_07.xml#07-26" target="_top">Changes and Additions to CppAD During 2007: 07-26</a><br/>
	540	<a href="whats_new_09.xml#07-26" target="_top">Changes and Additions to CppAD During 2009: 07-26</a><br/>
	541	<a href="whats_new_13.xml#07-26" target="_top">CppAD Changes and Additions During 2013: 07-26</a><br/>
	542	07<b>-</b>27 <a href="whats_new_11.xml#07-27" target="_top">Changes and Additions to CppAD During 2011: 07-27</a><br/>
	543	07<b>-</b>28 <a href="whats_new_07.xml#07-28" target="_top">Changes and Additions to CppAD During 2007: 07-28</a><br/>
	544	<a href="whats_new_11.xml#07-28" target="_top">Changes and Additions to CppAD During 2011: 07-28</a><br/>
	545	07<b>-</b>29 <a href="whats_new_03.xml#07-29" target="_top">Changes and Additions to CppAD During 2003: 07-29</a><br/>
	546	<a href="whats_new_07.xml#07-29" target="_top">Changes and Additions to CppAD During 2007: 07-29</a><br/>
	547	<a href="whats_new_11.xml#07-29" target="_top">Changes and Additions to CppAD During 2011: 07-29</a><br/>
	548	07<b>-</b>30 <a href="whats_new_03.xml#07-30" target="_top">Changes and Additions to CppAD During 2003: 07-30</a><br/>
	549	<a href="whats_new_07.xml#07-30" target="_top">Changes and Additions to CppAD During 2007: 07-30</a><br/>
	550	<a href="whats_new_12.xml#07-30" target="_top">CppAD Changes and Additions During 2012: 07-30</a><br/>
	551	07<b>-</b>31 <a href="whats_new_04.xml#07-31" target="_top">Changes and Additions to CppAD During 2004: 07-31</a><br/>
	552	<a href="whats_new_09.xml#07-31" target="_top">Changes and Additions to CppAD During 2009: 07-31</a><br/>
	553	<a href="whats_new_11.xml#07-31" target="_top">Changes and Additions to CppAD During 2011: 07-31</a><br/>
	554	08<b>-</b>01 <a href="whats_new_03.xml#08-01" target="_top">Changes and Additions to CppAD During 2003: 08-01</a><br/>
	555	<a href="whats_new_09.xml#08-01" target="_top">Changes and Additions to CppAD During 2009: 08-01</a><br/>
	556	08<b>-</b>02 <a href="whats_new_09.xml#08-02" target="_top">Changes and Additions to CppAD During 2009: 08-02</a><br/>
	557	<a href="whats_new_11.xml#08-02" target="_top">Changes and Additions to CppAD During 2011: 08-02</a><br/>
	558	08<b>-</b>03 <a href="whats_new_03.xml#08-03" target="_top">Changes and Additions to CppAD During 2003: 08-03</a><br/>
	559	<a href="whats_new_11.xml#08-03" target="_top">Changes and Additions to CppAD During 2011: 08-03</a><br/>
	560	08<b>-</b>04 <a href="whats_new_03.xml#08-04" target="_top">Changes and Additions to CppAD During 2003: 08-04</a><br/>
	561	<a href="whats_new_11.xml#08-11.08-04" target="_top">Changes and Additions to CppAD During 2011: 08-11.08-04</a><br/>
	562	08<b>-</b>05 <a href="whats_new_03.xml#08-05" target="_top">Changes and Additions to CppAD During 2003: 08-05</a><br/>
	563	<a href="whats_new_12.xml#08-05" target="_top">CppAD Changes and Additions During 2012: 08-05</a><br/>
	564	08<b>-</b>06 <a href="whats_new_03.xml#08-06" target="_top">Changes and Additions to CppAD During 2003: 08-06</a><br/>
	565	<a href="whats_new_09.xml#08-06" target="_top">Changes and Additions to CppAD During 2009: 08-06</a><br/>
	566	<a href="whats_new_11.xml#08-11.08-06" target="_top">Changes and Additions to CppAD During 2011: 08-11.08-06</a><br/>
	567	<a href="whats_new_13.xml#08-06" target="_top">CppAD Changes and Additions During 2013: 08-06</a><br/>
	568	08<b>-</b>07 <a href="whats_new_03.xml#08-07" target="_top">Changes and Additions to CppAD During 2003: 08-07</a><br/>
	569	<a href="whats_new_05.xml#08-07" target="_top">Changes and Additions to CppAD During 2005: 08-07</a><br/>
	570	<a href="whats_new_07.xml#08-07" target="_top">Changes and Additions to CppAD During 2007: 08-07</a><br/>
	571	<a href="whats_new_11.xml#08-11.08-07" target="_top">Changes and Additions to CppAD During 2011: 08-11.08-07</a><br/>
	572	08<b>-</b>08 <a href="whats_new_08.xml#08-08" target="_top">Changes and Additions to CppAD During 2008: 08-08</a><br/>
	573	<a href="whats_new_11.xml#08-11.08-08" target="_top">Changes and Additions to CppAD During 2011: 08-11.08-08</a><br/>
	574	08<b>-</b>09 <a href="whats_new_07.xml#08-09" target="_top">Changes and Additions to CppAD During 2007: 08-09</a><br/>
	575	<a href="whats_new_09.xml#08_13.08-09" target="_top">Changes and Additions to CppAD During 2009: 08_13.08-09</a><br/>
	576	<a href="whats_new_11.xml#08-11.08-09" target="_top">Changes and Additions to CppAD During 2011: 08-11.08-09</a><br/>
	577	08<b>-</b>10 <a href="whats_new_03.xml#08-10" target="_top">Changes and Additions to CppAD During 2003: 08-10</a><br/>
	578	<a href="whats_new_09.xml#08_13.08-10" target="_top">Changes and Additions to CppAD During 2009: 08_13.08-10</a><br/>
	579	<a href="whats_new_11.xml#08-11.08-10" target="_top">Changes and Additions to CppAD During 2011: 08-11.08-10</a><br/>
	580	08<b>-</b>11 <a href="whats_new_03.xml#08-11" target="_top">Changes and Additions to CppAD During 2003: 08-11</a><br/>
	581	<a href="whats_new_09.xml#08_13.08-11" target="_top">Changes and Additions to CppAD During 2009: 08_13.08-11</a><br/>
	582	<a href="whats_new_11.xml#08-11" target="_top">Changes and Additions to CppAD During 2011: 08-11</a><br/>
	583	<a href="whats_new_13.xml#08-11" target="_top">CppAD Changes and Additions During 2013: 08-11</a><br/>
	584	08<b>-</b>12 <a href="whats_new_04.xml#08-12" target="_top">Changes and Additions to CppAD During 2004: 08-12</a><br/>
	585	<a href="whats_new_13.xml#08-12" target="_top">CppAD Changes and Additions During 2013: 08-12</a><br/>
	586	08<b>-</b>13 <a href="whats_new_05.xml#08-13" target="_top">Changes and Additions to CppAD During 2005: 08-13</a><br/>
	587	<a href="whats_new_09.xml#08_13.08-13" target="_top">Changes and Additions to CppAD During 2009: 08_13.08-13</a><br/>
	588	08<b>-</b>14 <a href="whats_new_05.xml#08-14" target="_top">Changes and Additions to CppAD During 2005: 08-14</a><br/>
	589	<a href="whats_new_09.xml#08-14" target="_top">Changes and Additions to CppAD During 2009: 08-14</a><br/>
	590	08<b>-</b>15 <a href="whats_new_05.xml#08-15" target="_top">Changes and Additions to CppAD During 2005: 08-15</a><br/>
	591	08<b>-</b>16 <a href="whats_new_03.xml#08-16" target="_top">Changes and Additions to CppAD During 2003: 08-16</a><br/>
	592	08<b>-</b>17 <a href="whats_new_03.xml#08-17" target="_top">Changes and Additions to CppAD During 2003: 08-17</a><br/>
	593	<a href="whats_new_06.xml#08-17" target="_top">Changes and Additions to CppAD During 2006: 08-17</a><br/>
	594	08<b>-</b>19 <a href="whats_new_03.xml#08-19" target="_top">Changes and Additions to CppAD During 2003: 08-19</a><br/>
	595	<a href="whats_new_05.xml#08-19" target="_top">Changes and Additions to CppAD During 2005: 08-19</a><br/>
	596	<a href="whats_new_08.xml#08-19" target="_top">Changes and Additions to CppAD During 2008: 08-19</a><br/>
	597	08<b>-</b>20 <a href="whats_new_05.xml#08-20" target="_top">Changes and Additions to CppAD During 2005: 08-20</a><br/>
	598	08<b>-</b>21 <a href="whats_new_10.xml#08-21" target="_top">Changes and Additions to CppAD During 2010: 08-21</a><br/>
	599	<a href="whats_new_11.xml#09-01.08-21" target="_top">Changes and Additions to CppAD During 2011: 09-01.08-21</a><br/>
	600	08<b>-</b>22 <a href="whats_new_03.xml#08-22" target="_top">Changes and Additions to CppAD During 2003: 08-22</a><br/>
	601	08<b>-</b>23 <a href="whats_new_03.xml#08-23" target="_top">Changes and Additions to CppAD During 2003: 08-23</a><br/>
	602	<a href="whats_new_11.xml#09-01.08-23" target="_top">Changes and Additions to CppAD During 2011: 09-01.08-23</a><br/>
	603	08<b>-</b>24 <a href="whats_new_04.xml#08-24" target="_top">Changes and Additions to CppAD During 2004: 08-24</a><br/>
	604	<a href="whats_new_05.xml#08-24" target="_top">Changes and Additions to CppAD During 2005: 08-24</a><br/>
	605	08<b>-</b>25 <a href="whats_new_04.xml#08-25" target="_top">Changes and Additions to CppAD During 2004: 08-25</a><br/>
	606	<a href="whats_new_09.xml#08-25" target="_top">Changes and Additions to CppAD During 2009: 08-25</a><br/>
	607	<a href="whats_new_11.xml#09-01.08-25" target="_top">Changes and Additions to CppAD During 2011: 09-01.08-25</a><br/>
	608	08<b>-</b>27 <a href="whats_new_04.xml#08-27" target="_top">Changes and Additions to CppAD During 2004: 08-27</a><br/>
	609	08<b>-</b>29 <a href="whats_new_08.xml#08-29" target="_top">Changes and Additions to CppAD During 2008: 08-29</a><br/>
	610	08<b>-</b>30 <a href="whats_new_05.xml#08-30" target="_top">Changes and Additions to CppAD During 2005: 08-30</a><br/>
	611	<a href="whats_new_11.xml#09-01.08-30" target="_top">Changes and Additions to CppAD During 2011: 09-01.08-30</a><br/>
	612	08<b>-</b>31 <a href="whats_new_11.xml#09-01.08-31" target="_top">Changes and Additions to CppAD During 2011: 09-01.08-31</a><br/>
	613	08<b>_</b>13 <a href="whats_new_09.xml#08_13" target="_top">Changes and Additions to CppAD During 2009: 08_13</a><br/>
	614	09<b>-</b>01 <a href="whats_new_08.xml#09-01" target="_top">Changes and Additions to CppAD During 2008: 09-01</a><br/>
	615	<a href="whats_new_11.xml#09-01" target="_top">Changes and Additions to CppAD During 2011: 09-01</a><br/>
	616	09<b>-</b>02 <a href="whats_new_04.xml#09-02" target="_top">Changes and Additions to CppAD During 2004: 09-02</a><br/>
	617	<a href="whats_new_11.xml#09-02" target="_top">Changes and Additions to CppAD During 2011: 09-02</a><br/>
	618	09<b>-</b>03 <a href="whats_new_03.xml#09-03" target="_top">Changes and Additions to CppAD During 2003: 09-03</a><br/>
	619	<a href="whats_new_08.xml#09-03" target="_top">Changes and Additions to CppAD During 2008: 09-03</a><br/>
	620	09<b>-</b>04 <a href="whats_new_03.xml#09-04" target="_top">Changes and Additions to CppAD During 2003: 09-04</a><br/>
	621	<a href="whats_new_04.xml#09-04" target="_top">Changes and Additions to CppAD During 2004: 09-04</a><br/>
	622	<a href="whats_new_08.xml#09-04" target="_top">Changes and Additions to CppAD During 2008: 09-04</a><br/>
	623	09<b>-</b>05 <a href="whats_new_03.xml#09-05" target="_top">Changes and Additions to CppAD During 2003: 09-05</a><br/>
	624	<a href="whats_new_08.xml#09-05" target="_top">Changes and Additions to CppAD During 2008: 09-05</a><br/>
	625	<a href="whats_new_11.xml#09-05" target="_top">Changes and Additions to CppAD During 2011: 09-05</a><br/>
	626	09<b>-</b>06 <a href="whats_new_03.xml#09-06" target="_top">Changes and Additions to CppAD During 2003: 09-06</a><br/>
	627	<a href="whats_new_07.xml#09-06" target="_top">Changes and Additions to CppAD During 2007: 09-06</a><br/>
	628	<a href="whats_new_08.xml#09-06" target="_top">Changes and Additions to CppAD During 2008: 09-06</a><br/>
	629	<a href="whats_new_11.xml#09-06" target="_top">Changes and Additions to CppAD During 2011: 09-06</a><br/>
	630	09<b>-</b>07 <a href="whats_new_04.xml#09-07" target="_top">Changes and Additions to CppAD During 2004: 09-07</a><br/>
	631	<a href="whats_new_05.xml#09-07" target="_top">Changes and Additions to CppAD During 2005: 09-07</a><br/>
	632	<a href="whats_new_08.xml#09-07" target="_top">Changes and Additions to CppAD During 2008: 09-07</a><br/>
	633	<a href="whats_new_13.xml#09-07" target="_top">CppAD Changes and Additions During 2013: 09-07</a><br/>
	634	09<b>-</b>09 <a href="whats_new_04.xml#09-09" target="_top">Changes and Additions to CppAD During 2004: 09-09</a><br/>
	635	<a href="whats_new_05.xml#09-09" target="_top">Changes and Additions to CppAD During 2005: 09-09</a><br/>
	636	<a href="whats_new_08.xml#09-09" target="_top">Changes and Additions to CppAD During 2008: 09-09</a><br/>
	637	09<b>-</b>10 <a href="whats_new_04.xml#09-10" target="_top">Changes and Additions to CppAD During 2004: 09-10</a><br/>
	638	<a href="whats_new_08.xml#09-10" target="_top">Changes and Additions to CppAD During 2008: 09-10</a><br/>
	639	09<b>-</b>11 <a href="whats_new_12.xml#09-11" target="_top">CppAD Changes and Additions During 2012: 09-11</a><br/>
	640	09<b>-</b>12 <a href="whats_new_08.xml#09-12" target="_top">Changes and Additions to CppAD During 2008: 09-12</a><br/>
	641	09<b>-</b>13 <a href="whats_new_03.xml#09-13" target="_top">Changes and Additions to CppAD During 2003: 09-13</a><br/>
	642	<a href="whats_new_04.xml#09-13" target="_top">Changes and Additions to CppAD During 2004: 09-13</a><br/>
	643	09<b>-</b>14 <a href="whats_new_03.xml#09-14" target="_top">Changes and Additions to CppAD During 2003: 09-14</a><br/>
	644	<a href="whats_new_05.xml#09-14" target="_top">Changes and Additions to CppAD During 2005: 09-14</a><br/>
	645	09<b>-</b>15 <a href="whats_new_03.xml#09-15" target="_top">Changes and Additions to CppAD During 2003: 09-15</a><br/>
	646	09<b>-</b>16 <a href="whats_new_08.xml#09-16" target="_top">Changes and Additions to CppAD During 2008: 09-16</a><br/>
	647	09<b>-</b>17 <a href="whats_new_08.xml#09-17" target="_top">Changes and Additions to CppAD During 2008: 09-17</a><br/>
	648	09<b>-</b>18 <a href="whats_new_03.xml#09-18" target="_top">Changes and Additions to CppAD During 2003: 09-18</a><br/>
	649	<a href="whats_new_08.xml#09-18" target="_top">Changes and Additions to CppAD During 2008: 09-18</a><br/>
	650	<a href="whats_new_09.xml#09-18" target="_top">Changes and Additions to CppAD During 2009: 09-18</a><br/>
	651	<a href="whats_new_13.xml#09-18" target="_top">CppAD Changes and Additions During 2013: 09-18</a><br/>
	652	09<b>-</b>19 <a href="whats_new_03.xml#09-19" target="_top">Changes and Additions to CppAD During 2003: 09-19</a><br/>
	653	<a href="whats_new_09.xml#09-19" target="_top">Changes and Additions to CppAD During 2009: 09-19</a><br/>
	654	<a href="whats_new_13.xml#09-19" target="_top">CppAD Changes and Additions During 2013: 09-19</a><br/>
	655	09<b>-</b>20 <a href="whats_new_03.xml#09-20" target="_top">Changes and Additions to CppAD During 2003: 09-20</a><br/>
	656	<a href="whats_new_05.xml#09-20" target="_top">Changes and Additions to CppAD During 2005: 09-20</a><br/>
	657	<a href="whats_new_09.xml#09-20" target="_top">Changes and Additions to CppAD During 2009: 09-20</a><br/>
	658	<a href="whats_new_13.xml#09-20" target="_top">CppAD Changes and Additions During 2013: 09-20</a><br/>
	659	09<b>-</b>21 <a href="whats_new_04.xml#09-21" target="_top">Changes and Additions to CppAD During 2004: 09-21</a><br/>
	660	<a href="whats_new_14.xml#09-21" target="_top">CppAD Changes and Additions During 2014: 09-21</a><br/>
	661	09<b>-</b>22 <a href="whats_new_10.xml#09-22" target="_top">Changes and Additions to CppAD During 2010: 09-22</a><br/>
	662	09<b>-</b>23 <a href="whats_new_04.xml#09-23" target="_top">Changes and Additions to CppAD During 2004: 09-23</a><br/>
	663	09<b>-</b>24 <a href="whats_new_05.xml#09-24" target="_top">Changes and Additions to CppAD During 2005: 09-24</a><br/>
	664	<a href="whats_new_12.xml#09-24" target="_top">CppAD Changes and Additions During 2012: 09-24</a><br/>
	665	09<b>-</b>25 <a href="whats_new_14.xml#09-25" target="_top">CppAD Changes and Additions During 2014: 09-25</a><br/>
	666	09<b>-</b>26 <a href="whats_new_04.xml#09-26" target="_top">Changes and Additions to CppAD During 2004: 09-26</a><br/>
	667	<a href="whats_new_08.xml#09-26" target="_top">Changes and Additions to CppAD During 2008: 09-26</a><br/>
	668	<a href="whats_new_09.xml#09-26" target="_top">Changes and Additions to CppAD During 2009: 09-26</a><br/>
	669	<a href="whats_new_10.xml#09-26" target="_top">Changes and Additions to CppAD During 2010: 09-26</a><br/>
	670	09<b>-</b>27 <a href="whats_new_05.xml#09-27" target="_top">Changes and Additions to CppAD During 2005: 09-27</a><br/>
	671	<a href="whats_new_14.xml#09-27" target="_top">CppAD Changes and Additions During 2014: 09-27</a><br/>
	672	09<b>-</b>28 <a href="whats_new_09.xml#09-28" target="_top">Changes and Additions to CppAD During 2009: 09-28</a><br/>
	673	<a href="whats_new_14.xml#09-28" target="_top">CppAD Changes and Additions During 2014: 09-28</a><br/>
	674	09<b>-</b>29 <a href="whats_new_04.xml#09-29" target="_top">Changes and Additions to CppAD During 2004: 09-29</a><br/>
	675	<a href="whats_new_05.xml#09-29" target="_top">Changes and Additions to CppAD During 2005: 09-29</a><br/>
	676	<a href="whats_new_09.xml#09-29" target="_top">Changes and Additions to CppAD During 2009: 09-29</a><br/>
	677	09<b>-</b>30 <a href="whats_new_03.xml#09-30" target="_top">Changes and Additions to CppAD During 2003: 09-30</a><br/>
	678	<a href="whats_new_06.xml#09-30" target="_top">Changes and Additions to CppAD During 2006: 09-30</a><br/>
	679	<a href="whats_new_08.xml#09-30" target="_top">Changes and Additions to CppAD During 2008: 09-30</a><br/>
	680	<a href="whats_new_09.xml#09-30" target="_top">Changes and Additions to CppAD During 2009: 09-30</a><br/>
	681	1 <a href="ode_evaluate.xml#p.p = 1" target="_top">Evaluate a Function Defined in Terms of an ODE: p.p = 1</a><br/>
	682	1<b>/</b>i <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
	683	<a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
	684	<a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
	685	10<b>-</b>02 <a href="whats_new_07.xml#10-02" target="_top">Changes and Additions to CppAD During 2007: 10-02</a><br/>
	686	<a href="whats_new_12.xml#10-02" target="_top">CppAD Changes and Additions During 2012: 10-02</a><br/>
	687	10<b>-</b>03 <a href="whats_new_09.xml#10-03" target="_top">Changes and Additions to CppAD During 2009: 10-03</a><br/>
	688	<a href="whats_new_12.xml#10-03" target="_top">CppAD Changes and Additions During 2012: 10-03</a><br/>
	689	10<b>-</b>04 <a href="whats_new_12.xml#10-04" target="_top">CppAD Changes and Additions During 2012: 10-04</a><br/>
	690	10<b>-</b>05 <a href="whats_new_03.xml#10-05" target="_top">Changes and Additions to CppAD During 2003: 10-05</a><br/>
	691	<a href="whats_new_07.xml#10-05" target="_top">Changes and Additions to CppAD During 2007: 10-05</a><br/>
	692	10<b>-</b>06 <a href="whats_new_03.xml#10-06" target="_top">Changes and Additions to CppAD During 2003: 10-06</a><br/>
	693	<a href="whats_new_04.xml#10-06" target="_top">Changes and Additions to CppAD During 2004: 10-06</a><br/>
	694	<a href="whats_new_05.xml#10-06" target="_top">Changes and Additions to CppAD During 2005: 10-06</a><br/>
	695	10<b>-</b>10 <a href="whats_new_03.xml#10-10" target="_top">Changes and Additions to CppAD During 2003: 10-10</a><br/>
	696	<a href="whats_new_06.xml#10-10" target="_top">Changes and Additions to CppAD During 2006: 10-10</a><br/>
	697	10<b>-</b>12 <a href="whats_new_05.xml#10-12" target="_top">Changes and Additions to CppAD During 2005: 10-12</a><br/>
	698	<a href="whats_new_11.xml#10-12" target="_top">Changes and Additions to CppAD During 2011: 10-12</a><br/>
	699	<a href="whats_new_12.xml#10-12" target="_top">CppAD Changes and Additions During 2012: 10-12</a><br/>
	700	<a href="whats_new_13.xml#10-12" target="_top">CppAD Changes and Additions During 2013: 10-12</a><br/>
	701	10<b>-</b>13 <a href="whats_new_07.xml#10-13" target="_top">Changes and Additions to CppAD During 2007: 10-13</a><br/>
	702	<a href="whats_new_13.xml#10-13" target="_top">CppAD Changes and Additions During 2013: 10-13</a><br/>
	703	10<b>-</b>14 <a href="whats_new_03.xml#10-14" target="_top">Changes and Additions to CppAD During 2003: 10-14</a><br/>
	704	<a href="whats_new_05.xml#10-14" target="_top">Changes and Additions to CppAD During 2005: 10-14</a><br/>
	705	<a href="whats_new_09.xml#10-14" target="_top">Changes and Additions to CppAD During 2009: 10-14</a><br/>
	706	<a href="whats_new_11.xml#10-14" target="_top">Changes and Additions to CppAD During 2011: 10-14</a><br/>
	707	<a href="whats_new_13.xml#10-14" target="_top">CppAD Changes and Additions During 2013: 10-14</a><br/>
	708	10<b>-</b>15 <a href="whats_new_13.xml#10-15" target="_top">CppAD Changes and Additions During 2013: 10-15</a><br/>
	709	10<b>-</b>16 <a href="whats_new_03.xml#10-16" target="_top">Changes and Additions to CppAD During 2003: 10-16</a><br/>
	710	<a href="whats_new_04.xml#10-16" target="_top">Changes and Additions to CppAD During 2004: 10-16</a><br/>
	711	<a href="whats_new_06.xml#10-16" target="_top">Changes and Additions to CppAD During 2006: 10-16</a><br/>
	712	<a href="whats_new_07.xml#10-16" target="_top">Changes and Additions to CppAD During 2007: 10-16</a><br/>
	713	<a href="whats_new_08.xml#10-16" target="_top">Changes and Additions to CppAD During 2008: 10-16</a><br/>
	714	<a href="whats_new_09.xml#10-16" target="_top">Changes and Additions to CppAD During 2009: 10-16</a><br/>
	715	<a href="whats_new_13.xml#10-16" target="_top">CppAD Changes and Additions During 2013: 10-16</a><br/>
	716	10<b>-</b>17 <a href="whats_new_08.xml#10-17" target="_top">Changes and Additions to CppAD During 2008: 10-17</a><br/>
	717	10<b>-</b>18 <a href="whats_new_05.xml#10-18" target="_top">Changes and Additions to CppAD During 2005: 10-18</a><br/>
	718	<a href="whats_new_06.xml#10-18" target="_top">Changes and Additions to CppAD During 2006: 10-18</a><br/>
	719	10<b>-</b>19 <a href="whats_new_04.xml#10-19" target="_top">Changes and Additions to CppAD During 2004: 10-19</a><br/>
	720	10<b>-</b>20 <a href="whats_new_05.xml#10-20" target="_top">Changes and Additions to CppAD During 2005: 10-20</a><br/>
	721	10<b>-</b>21 <a href="whats_new_03.xml#10-21" target="_top">Changes and Additions to CppAD During 2003: 10-21</a><br/>
	722	<a href="whats_new_04.xml#10-21" target="_top">Changes and Additions to CppAD During 2004: 10-21</a><br/>
	723	<a href="whats_new_09.xml#10-21" target="_top">Changes and Additions to CppAD During 2009: 10-21</a><br/>
	724	10<b>-</b>22 <a href="whats_new_07.xml#10-22" target="_top">Changes and Additions to CppAD During 2007: 10-22</a><br/>
	725	<a href="whats_new_13.xml#10-22" target="_top">CppAD Changes and Additions During 2013: 10-22</a><br/>
	726	10<b>-</b>23 <a href="whats_new_07.xml#10-23" target="_top">Changes and Additions to CppAD During 2007: 10-23</a><br/>
	727	<a href="whats_new_09.xml#10-23" target="_top">Changes and Additions to CppAD During 2009: 10-23</a><br/>
	728	<a href="whats_new_13.xml#10-23" target="_top">CppAD Changes and Additions During 2013: 10-23</a><br/>
	729	10<b>-</b>24 <a href="whats_new_09.xml#10-24" target="_top">Changes and Additions to CppAD During 2009: 10-24</a><br/>
	730	<a href="whats_new_12.xml#10-24" target="_top">CppAD Changes and Additions During 2012: 10-24</a><br/>
	731	10<b>-</b>25 <a href="whats_new_06.xml#10-25" target="_top">Changes and Additions to CppAD During 2006: 10-25</a><br/>
	732	<a href="whats_new_12.xml#10-25" target="_top">CppAD Changes and Additions During 2012: 10-25</a><br/>
	733	10<b>-</b>26 <a href="whats_new_06.xml#10-26" target="_top">Changes and Additions to CppAD During 2006: 10-26</a><br/>
	734	10<b>-</b>27 <a href="whats_new_04.xml#10-27" target="_top">Changes and Additions to CppAD During 2004: 10-27</a><br/>
	735	<a href="whats_new_06.xml#10-27" target="_top">Changes and Additions to CppAD During 2006: 10-27</a><br/>
	736	<a href="whats_new_07.xml#10-27" target="_top">Changes and Additions to CppAD During 2007: 10-27</a><br/>
	737	<a href="whats_new_08.xml#10-27" target="_top">Changes and Additions to CppAD During 2008: 10-27</a><br/>
	738	<a href="whats_new_09.xml#10-27" target="_top">Changes and Additions to CppAD During 2009: 10-27</a><br/>
	739	10<b>-</b>28 <a href="whats_new_04.xml#10-28" target="_top">Changes and Additions to CppAD During 2004: 10-28</a><br/>
	740	<a href="whats_new_06.xml#10-28" target="_top">Changes and Additions to CppAD During 2006: 10-28</a><br/>
	741	<a href="whats_new_09.xml#10-28" target="_top">Changes and Additions to CppAD During 2009: 10-28</a><br/>
	742	10<b>-</b>29 <a href="whats_new_04.xml#10-29" target="_top">Changes and Additions to CppAD During 2004: 10-29</a><br/>
	743	<a href="whats_new_06.xml#10-29" target="_top">Changes and Additions to CppAD During 2006: 10-29</a><br/>
	744	<a href="whats_new_09.xml#10-29" target="_top">Changes and Additions to CppAD During 2009: 10-29</a><br/>
	745	<a href="whats_new_11.xml#10-29" target="_top">Changes and Additions to CppAD During 2011: 10-29</a><br/>
	746	<a href="whats_new_13.xml#10-29" target="_top">CppAD Changes and Additions During 2013: 10-29</a><br/>
	747	10<b>-</b>30 <a href="whats_new_07.xml#10-30" target="_top">Changes and Additions to CppAD During 2007: 10-30</a><br/>
	748	<a href="whats_new_09.xml#10-30" target="_top">Changes and Additions to CppAD During 2009: 10-30</a><br/>
	749	<a href="whats_new_11.xml#10-30" target="_top">Changes and Additions to CppAD During 2011: 10-30</a><br/>
	750	<a href="whats_new_12.xml#10-30" target="_top">CppAD Changes and Additions During 2012: 10-30</a><br/>
	751	10<b>-</b>31 <a href="whats_new_06.xml#10-31" target="_top">Changes and Additions to CppAD During 2006: 10-31</a><br/>
	752	<a href="whats_new_12.xml#10-31" target="_top">CppAD Changes and Additions During 2012: 10-31</a><br/>
	753	11<b>-</b>01 <a href="whats_new_04.xml#11-01" target="_top">Changes and Additions to CppAD During 2004: 11-01</a><br/>
	754	<a href="whats_new_05.xml#11-01" target="_top">Changes and Additions to CppAD During 2005: 11-01</a><br/>
	755	<a href="whats_new_06.xml#11-01" target="_top">Changes and Additions to CppAD During 2006: 11-01</a><br/>
	756	<a href="whats_new_07.xml#11-01" target="_top">Changes and Additions to CppAD During 2007: 11-01</a><br/>
	757	<a href="whats_new_11.xml#11-01" target="_top">Changes and Additions to CppAD During 2011: 11-01</a><br/>
	758	11<b>-</b>02 <a href="whats_new_03.xml#11-02" target="_top">Changes and Additions to CppAD During 2003: 11-02</a><br/>
	759	<a href="whats_new_04.xml#11-02" target="_top">Changes and Additions to CppAD During 2004: 11-02</a><br/>
	760	<a href="whats_new_06.xml#11-02" target="_top">Changes and Additions to CppAD During 2006: 11-02</a><br/>
	761	<a href="whats_new_07.xml#11-02" target="_top">Changes and Additions to CppAD During 2007: 11-02</a><br/>
	762	11<b>-</b>03 <a href="whats_new_07.xml#11-03" target="_top">Changes and Additions to CppAD During 2007: 11-03</a><br/>
	763	11<b>-</b>04 <a href="whats_new_03.xml#11-04" target="_top">Changes and Additions to CppAD During 2003: 11-04</a><br/>
	764	<a href="whats_new_04.xml#11-04" target="_top">Changes and Additions to CppAD During 2004: 11-04</a><br/>
	765	<a href="whats_new_06.xml#11-04" target="_top">Changes and Additions to CppAD During 2006: 11-04</a><br/>
	766	<a href="whats_new_07.xml#11-04" target="_top">Changes and Additions to CppAD During 2007: 11-04</a><br/>
	767	<a href="whats_new_11.xml#11-04" target="_top">Changes and Additions to CppAD During 2011: 11-04</a><br/>
	768	<a href="whats_new_12.xml#11-04" target="_top">CppAD Changes and Additions During 2012: 11-04</a><br/>
	769	11<b>-</b>05 <a href="whats_new_06.xml#11-05" target="_top">Changes and Additions to CppAD During 2006: 11-05</a><br/>
	770	<a href="whats_new_07.xml#11-05" target="_top">Changes and Additions to CppAD During 2007: 11-05</a><br/>
	771	11<b>-</b>06 <a href="whats_new_03.xml#11-06" target="_top">Changes and Additions to CppAD During 2003: 11-06</a><br/>
	772	<a href="whats_new_05.xml#11-06" target="_top">Changes and Additions to CppAD During 2005: 11-06</a><br/>
	773	<a href="whats_new_06.xml#11-06" target="_top">Changes and Additions to CppAD During 2006: 11-06</a><br/>
	774	<a href="whats_new_07.xml#11-06" target="_top">Changes and Additions to CppAD During 2007: 11-06</a><br/>
	775	<a href="whats_new_11.xml#11-06" target="_top">Changes and Additions to CppAD During 2011: 11-06</a><br/>
	776	<a href="whats_new_12.xml#11-06" target="_top">CppAD Changes and Additions During 2012: 11-06</a><br/>
	777	11<b>-</b>07 <a href="whats_new_05.xml#11-07" target="_top">Changes and Additions to CppAD During 2005: 11-07</a><br/>
	778	<a href="whats_new_11.xml#11-07" target="_top">Changes and Additions to CppAD During 2011: 11-07</a><br/>
	779	11<b>-</b>08 <a href="whats_new_06.xml#11-08" target="_top">Changes and Additions to CppAD During 2006: 11-08</a><br/>
	780	11<b>-</b>09 <a href="whats_new_05.xml#11-09" target="_top">Changes and Additions to CppAD During 2005: 11-09</a><br/>
	781	<a href="whats_new_11.xml#11-09" target="_top">Changes and Additions to CppAD During 2011: 11-09</a><br/>
	782	<a href="whats_new_12.xml#11-09" target="_top">CppAD Changes and Additions During 2012: 11-09</a><br/>
	783	11<b>-</b>10 <a href="whats_new_04.xml#11-10" target="_top">Changes and Additions to CppAD During 2004: 11-10</a><br/>
	784	11<b>-</b>11 <a href="whats_new_03.xml#11-11" target="_top">Changes and Additions to CppAD During 2003: 11-11</a><br/>
	785	11<b>-</b>12 <a href="whats_new_03.xml#11-12" target="_top">Changes and Additions to CppAD During 2003: 11-12</a><br/>
	786	<a href="whats_new_04.xml#11-12" target="_top">Changes and Additions to CppAD During 2004: 11-12</a><br/>
	787	<a href="whats_new_05.xml#11-12" target="_top">Changes and Additions to CppAD During 2005: 11-12</a><br/>
	788	<a href="whats_new_06.xml#11-12" target="_top">Changes and Additions to CppAD During 2006: 11-12</a><br/>
	789	<a href="whats_new_13.xml#11-12" target="_top">CppAD Changes and Additions During 2013: 11-12</a><br/>
	790	11<b>-</b>13 <a href="whats_new_04.xml#11-13" target="_top">Changes and Additions to CppAD During 2004: 11-13</a><br/>
	791	<a href="whats_new_13.xml#11-13" target="_top">CppAD Changes and Additions During 2013: 11-13</a><br/>
	792	11<b>-</b>14 <a href="whats_new_03.xml#11-14" target="_top">Changes and Additions to CppAD During 2003: 11-14</a><br/>
	793	<a href="whats_new_04.xml#11-14" target="_top">Changes and Additions to CppAD During 2004: 11-14</a><br/>
	794	<a href="whats_new_12.xml#11-14" target="_top">CppAD Changes and Additions During 2012: 11-14</a><br/>
	795	11<b>-</b>15 <a href="whats_new_03.xml#11-15" target="_top">Changes and Additions to CppAD During 2003: 11-15</a><br/>
	796	<a href="whats_new_04.xml#11-15" target="_top">Changes and Additions to CppAD During 2004: 11-15</a><br/>
	797	<a href="whats_new_05.xml#11-15" target="_top">Changes and Additions to CppAD During 2005: 11-15</a><br/>
	798	11<b>-</b>16 <a href="whats_new_03.xml#11-16" target="_top">Changes and Additions to CppAD During 2003: 11-16</a><br/>
	799	<a href="whats_new_04.xml#11-16" target="_top">Changes and Additions to CppAD During 2004: 11-16</a><br/>
	800	<a href="whats_new_12.xml#11-16" target="_top">CppAD Changes and Additions During 2012: 11-16</a><br/>
	801	11<b>-</b>17 <a href="whats_new_04.xml#11-17" target="_top">Changes and Additions to CppAD During 2004: 11-17</a><br/>
	802	<a href="whats_new_11.xml#11-17" target="_top">Changes and Additions to CppAD During 2011: 11-17</a><br/>
	803	<a href="whats_new_12.xml#11-17" target="_top">CppAD Changes and Additions During 2012: 11-17</a><br/>
	804	11<b>-</b>18 <a href="whats_new_06.xml#11-18" target="_top">Changes and Additions to CppAD During 2006: 11-18</a><br/>
	805	<a href="whats_new_07.xml#11-18" target="_top">Changes and Additions to CppAD During 2007: 11-18</a><br/>
	806	<a href="whats_new_11.xml#11-18" target="_top">Changes and Additions to CppAD During 2011: 11-18</a><br/>
	807	11<b>-</b>19 <a href="whats_new_05.xml#11-19" target="_top">Changes and Additions to CppAD During 2005: 11-19</a><br/>
	808	11<b>-</b>20 <a href="whats_new_03.xml#11-20" target="_top">Changes and Additions to CppAD During 2003: 11-20</a><br/>
	809	<a href="whats_new_05.xml#11-20" target="_top">Changes and Additions to CppAD During 2005: 11-20</a><br/>
	810	<a href="whats_new_08.xml#11-20" target="_top">Changes and Additions to CppAD During 2008: 11-20</a><br/>
	811	<a href="whats_new_11.xml#11-20" target="_top">Changes and Additions to CppAD During 2011: 11-20</a><br/>
	812	<a href="whats_new_12.xml#11-20" target="_top">CppAD Changes and Additions During 2012: 11-20</a><br/>
	813	11<b>-</b>21 <a href="whats_new_03.xml#11-21" target="_top">Changes and Additions to CppAD During 2003: 11-21</a><br/>
	814	<a href="whats_new_08.xml#11-21" target="_top">Changes and Additions to CppAD During 2008: 11-21</a><br/>
	815	<a href="whats_new_11.xml#11-21" target="_top">Changes and Additions to CppAD During 2011: 11-21</a><br/>
	816	<a href="whats_new_12.xml#11-21" target="_top">CppAD Changes and Additions During 2012: 11-21</a><br/>
	817	11<b>-</b>22 <a href="whats_new_05.xml#11-22" target="_top">Changes and Additions to CppAD During 2005: 11-22</a><br/>
	818	<a href="whats_new_08.xml#11-22" target="_top">Changes and Additions to CppAD During 2008: 11-22</a><br/>
	819	11<b>-</b>23 <a href="whats_new_05.xml#11-23" target="_top">Changes and Additions to CppAD During 2005: 11-23</a><br/>
	820	<a href="whats_new_06.xml#11-23" target="_top">Changes and Additions to CppAD During 2006: 11-23</a><br/>
	821	<a href="whats_new_07.xml#11-23" target="_top">Changes and Additions to CppAD During 2007: 11-23</a><br/>
	822	11<b>-</b>24 <a href="whats_new_11.xml#11-24" target="_top">Changes and Additions to CppAD During 2011: 11-24</a><br/>
	823	11<b>-</b>26 <a href="whats_new_09.xml#11-26" target="_top">Changes and Additions to CppAD During 2009: 11-26</a><br/>
	824	11<b>-</b>27 <a href="whats_new_09.xml#11-27" target="_top">Changes and Additions to CppAD During 2009: 11-27</a><br/>
	825	<a href="whats_new_10.xml#11-27" target="_top">Changes and Additions to CppAD During 2010: 11-27</a><br/>
	826	<a href="whats_new_11.xml#11-27" target="_top">Changes and Additions to CppAD During 2011: 11-27</a><br/>
	827	<a href="whats_new_13.xml#11-27" target="_top">CppAD Changes and Additions During 2013: 11-27</a><br/>
	828	<a href="whats_new_14.xml#11-27" target="_top">CppAD Changes and Additions During 2014: 11-27</a><br/>
	829	11<b>-</b>28 <a href="whats_new_06.xml#11-28" target="_top">Changes and Additions to CppAD During 2006: 11-28</a><br/>
	830	<a href="whats_new_09.xml#11-28" target="_top">Changes and Additions to CppAD During 2009: 11-28</a><br/>
	831	<a href="whats_new_12.xml#11-28" target="_top">CppAD Changes and Additions During 2012: 11-28</a><br/>
	832	<a href="whats_new_14.xml#11-28" target="_top">CppAD Changes and Additions During 2014: 11-28</a><br/>
	833	11<b>-</b>29 <a href="whats_new_06.xml#11-29" target="_top">Changes and Additions to CppAD During 2006: 11-29</a><br/>
	834	<a href="whats_new_07.xml#11-29" target="_top">Changes and Additions to CppAD During 2007: 11-29</a><br/>
	835	<a href="whats_new_11.xml#11-29" target="_top">Changes and Additions to CppAD During 2011: 11-29</a><br/>
	836	11<b>-</b>30 <a href="whats_new_06.xml#11-30" target="_top">Changes and Additions to CppAD During 2006: 11-30</a><br/>
	837	12<b>-</b>01 <a href="whats_new_03.xml#12-01" target="_top">Changes and Additions to CppAD During 2003: 12-01</a><br/>
	838	<a href="whats_new_05.xml#12-01" target="_top">Changes and Additions to CppAD During 2005: 12-01</a><br/>
	839	<a href="whats_new_06.xml#12-01" target="_top">Changes and Additions to CppAD During 2006: 12-01</a><br/>
	840	12<b>-</b>02 <a href="whats_new_05.xml#12-02" target="_top">Changes and Additions to CppAD During 2005: 12-02</a><br/>
	841	<a href="whats_new_06.xml#12-02" target="_top">Changes and Additions to CppAD During 2006: 12-02</a><br/>
	842	<a href="whats_new_07.xml#12-02" target="_top">Changes and Additions to CppAD During 2007: 12-02</a><br/>
	843	<a href="whats_new_09.xml#12-02" target="_top">Changes and Additions to CppAD During 2009: 12-02</a><br/>
	844	12<b>-</b>03 <a href="whats_new_04.xml#12-03" target="_top">Changes and Additions to CppAD During 2004: 12-03</a><br/>
	845	<a href="whats_new_05.xml#12-03" target="_top">Changes and Additions to CppAD During 2005: 12-03</a><br/>
	846	<a href="whats_new_06.xml#12-03" target="_top">Changes and Additions to CppAD During 2006: 12-03</a><br/>
	847	<a href="whats_new_07.xml#12-03" target="_top">Changes and Additions to CppAD During 2007: 12-03</a><br/>
	848	12<b>-</b>04 <a href="whats_new_07.xml#12-04" target="_top">Changes and Additions to CppAD During 2007: 12-04</a><br/>
	849	<a href="whats_new_08.xml#12-04" target="_top">Changes and Additions to CppAD During 2008: 12-04</a><br/>
	850	<a href="whats_new_09.xml#12-04" target="_top">Changes and Additions to CppAD During 2009: 12-04</a><br/>
	851	12<b>-</b>05 <a href="whats_new_03.xml#12-05" target="_top">Changes and Additions to CppAD During 2003: 12-05</a><br/>
	852	<a href="whats_new_05.xml#12-05" target="_top">Changes and Additions to CppAD During 2005: 12-05</a><br/>
	853	<a href="whats_new_06.xml#12-05" target="_top">Changes and Additions to CppAD During 2006: 12-05</a><br/>
	854	<a href="whats_new_07.xml#12-05" target="_top">Changes and Additions to CppAD During 2007: 12-05</a><br/>
	855	12<b>-</b>06 <a href="whats_new_05.xml#12-06" target="_top">Changes and Additions to CppAD During 2005: 12-06</a><br/>
	856	12<b>-</b>07 <a href="whats_new_05.xml#12-07" target="_top">Changes and Additions to CppAD During 2005: 12-07</a><br/>
	857	<a href="whats_new_06.xml#12-07" target="_top">Changes and Additions to CppAD During 2006: 12-07</a><br/>
	858	12<b>-</b>08 <a href="whats_new_05.xml#12-08" target="_top">Changes and Additions to CppAD During 2005: 12-08</a><br/>
	859	<a href="whats_new_07.xml#12-08" target="_top">Changes and Additions to CppAD During 2007: 12-08</a><br/>
	860	12<b>-</b>09 <a href="whats_new_04.xml#12-09" target="_top">Changes and Additions to CppAD During 2004: 12-09</a><br/>
	861	<a href="whats_new_06.xml#12-09" target="_top">Changes and Additions to CppAD During 2006: 12-09</a><br/>
	862	12<b>-</b>10 <a href="whats_new_03.xml#12-10" target="_top">Changes and Additions to CppAD During 2003: 12-10</a><br/>
	863	<a href="whats_new_06.xml#12-10" target="_top">Changes and Additions to CppAD During 2006: 12-10</a><br/>
	864	12<b>-</b>11 <a href="whats_new_04.xml#12-11" target="_top">Changes and Additions to CppAD During 2004: 12-11</a><br/>
	865	<a href="whats_new_05.xml#12-11" target="_top">Changes and Additions to CppAD During 2005: 12-11</a><br/>
	866	<a href="whats_new_06.xml#12-11" target="_top">Changes and Additions to CppAD During 2006: 12-11</a><br/>
	867	12<b>-</b>12 <a href="whats_new_03.xml#12-12" target="_top">Changes and Additions to CppAD During 2003: 12-12</a><br/>
	868	<a href="whats_new_06.xml#12-12" target="_top">Changes and Additions to CppAD During 2006: 12-12</a><br/>
	869	<a href="whats_new_09.xml#12-12" target="_top">Changes and Additions to CppAD During 2009: 12-12</a><br/>
	870	12<b>-</b>13 <a href="whats_new_03.xml#12-13" target="_top">Changes and Additions to CppAD During 2003: 12-13</a><br/>
	871	<a href="whats_new_06.xml#12-13" target="_top">Changes and Additions to CppAD During 2006: 12-13</a><br/>
	872	<a href="whats_new_12.xml#12-13" target="_top">CppAD Changes and Additions During 2012: 12-13</a><br/>
	873	12<b>-</b>14 <a href="whats_new_03.xml#12-14" target="_top">Changes and Additions to CppAD During 2003: 12-14</a><br/>
	874	<a href="whats_new_05.xml#12-14" target="_top">Changes and Additions to CppAD During 2005: 12-14</a><br/>
	875	<a href="whats_new_08.xml#12-14" target="_top">Changes and Additions to CppAD During 2008: 12-14</a><br/>
	876	<a href="whats_new_12.xml#12-14" target="_top">CppAD Changes and Additions During 2012: 12-14</a><br/>
	877	12<b>-</b>15 <a href="whats_new_05.xml#12-15" target="_top">Changes and Additions to CppAD During 2005: 12-15</a><br/>
	878	<a href="whats_new_06.xml#12-15" target="_top">Changes and Additions to CppAD During 2006: 12-15</a><br/>
	879	<a href="whats_new_12.xml#12-15" target="_top">CppAD Changes and Additions During 2012: 12-15</a><br/>
	880	<a href="whats_new_14.xml#12-15" target="_top">CppAD Changes and Additions During 2014: 12-15</a><br/>
	881	12<b>-</b>16 <a href="whats_new_05.xml#12-16" target="_top">Changes and Additions to CppAD During 2005: 12-16</a><br/>
	882	<a href="whats_new_14.xml#12-16" target="_top">CppAD Changes and Additions During 2014: 12-16</a><br/>
	883	12<b>-</b>17 <a href="whats_new_06.xml#12-17" target="_top">Changes and Additions to CppAD During 2006: 12-17</a><br/>
	884	<a href="whats_new_12.xml#12-17" target="_top">CppAD Changes and Additions During 2012: 12-17</a><br/>
	885	<a href="whats_new_14.xml#12-17" target="_top">CppAD Changes and Additions During 2014: 12-17</a><br/>
	886	12<b>-</b>18 <a href="whats_new_06.xml#12-18" target="_top">Changes and Additions to CppAD During 2006: 12-18</a><br/>
	887	<a href="whats_new_09.xml#12-18" target="_top">Changes and Additions to CppAD During 2009: 12-18</a><br/>
	888	12<b>-</b>19 <a href="whats_new_05.xml#12-19" target="_top">Changes and Additions to CppAD During 2005: 12-19</a><br/>
	889	<a href="whats_new_06.xml#12-19" target="_top">Changes and Additions to CppAD During 2006: 12-19</a><br/>
	890	<a href="whats_new_08.xml#12-19" target="_top">Changes and Additions to CppAD During 2008: 12-19</a><br/>
	891	<a href="whats_new_12.xml#12-19" target="_top">CppAD Changes and Additions During 2012: 12-19</a><br/>
	892	12<b>-</b>20 <a href="whats_new_05.xml#12-20" target="_top">Changes and Additions to CppAD During 2005: 12-20</a><br/>
	893	<a href="whats_new_11.xml#12-20" target="_top">Changes and Additions to CppAD During 2011: 12-20</a><br/>
	894	<a href="whats_new_12.xml#12-20" target="_top">CppAD Changes and Additions During 2012: 12-20</a><br/>
	895	12<b>-</b>21 <a href="whats_new_06.xml#12-21" target="_top">Changes and Additions to CppAD During 2006: 12-21</a><br/>
	896	<a href="whats_new_07.xml#12-21" target="_top">Changes and Additions to CppAD During 2007: 12-21</a><br/>
	897	<a href="whats_new_11.xml#12-21" target="_top">Changes and Additions to CppAD During 2011: 12-21</a><br/>
	898	12<b>-</b>22 <a href="whats_new_03.xml#12-22" target="_top">Changes and Additions to CppAD During 2003: 12-22</a><br/>
	899	<a href="whats_new_05.xml#12-22" target="_top">Changes and Additions to CppAD During 2005: 12-22</a><br/>
	900	<a href="whats_new_06.xml#12-22" target="_top">Changes and Additions to CppAD During 2006: 12-22</a><br/>
	901	<a href="whats_new_09.xml#12-22" target="_top">Changes and Additions to CppAD During 2009: 12-22</a><br/>
	902	<a href="whats_new_12.xml#12-22" target="_top">CppAD Changes and Additions During 2012: 12-22</a><br/>
	903	<a href="whats_new_14.xml#12-22" target="_top">CppAD Changes and Additions During 2014: 12-22</a><br/>
	904	12<b>-</b>23 <a href="whats_new_05.xml#12-23" target="_top">Changes and Additions to CppAD During 2005: 12-23</a><br/>
	905	<a href="whats_new_06.xml#12-23" target="_top">Changes and Additions to CppAD During 2006: 12-23</a><br/>
	906	<a href="whats_new_09.xml#12-23" target="_top">Changes and Additions to CppAD During 2009: 12-23</a><br/>
	907	<a href="whats_new_12.xml#12-23" target="_top">CppAD Changes and Additions During 2012: 12-23</a><br/>
	908	<a href="whats_new_14.xml#12-23" target="_top">CppAD Changes and Additions During 2014: 12-23</a><br/>
	909	12<b>-</b>24 <a href="whats_new_03.xml#12-24" target="_top">Changes and Additions to CppAD During 2003: 12-24</a><br/>
	910	<a href="whats_new_05.xml#12-24" target="_top">Changes and Additions to CppAD During 2005: 12-24</a><br/>
	911	<a href="whats_new_06.xml#12-24" target="_top">Changes and Additions to CppAD During 2006: 12-24</a><br/>
	912	<a href="whats_new_13.xml#12-24" target="_top">CppAD Changes and Additions During 2013: 12-24</a><br/>
	913	12<b>-</b>25 <a href="whats_new_07.xml#12-25" target="_top">Changes and Additions to CppAD During 2007: 12-25</a><br/>
	914	<a href="whats_new_14.xml#12-25" target="_top">CppAD Changes and Additions During 2014: 12-25</a><br/>
	915	12<b>-</b>26 <a href="whats_new_12.xml#12-26" target="_top">CppAD Changes and Additions During 2012: 12-26</a><br/>
	916	<a href="whats_new_13.xml#12-26" target="_top">CppAD Changes and Additions During 2013: 12-26</a><br/>
	917	<a href="whats_new_14.xml#12-26" target="_top">CppAD Changes and Additions During 2014: 12-26</a><br/>
	918	12<b>-</b>27 <a href="whats_new_12.xml#12-27" target="_top">CppAD Changes and Additions During 2012: 12-27</a><br/>
	919	<a href="whats_new_13.xml#12-27" target="_top">CppAD Changes and Additions During 2013: 12-27</a><br/>
	920	<a href="whats_new_14.xml#12-27" target="_top">CppAD Changes and Additions During 2014: 12-27</a><br/>
	921	12<b>-</b>28 <a href="whats_new_11.xml#12-28" target="_top">Changes and Additions to CppAD During 2011: 12-28</a><br/>
	922	<a href="whats_new_12.xml#12-28" target="_top">CppAD Changes and Additions During 2012: 12-28</a><br/>
	923	12<b>-</b>29 <a href="whats_new_07.xml#12-29" target="_top">Changes and Additions to CppAD During 2007: 12-29</a><br/>
	924	<a href="whats_new_12.xml#12-29" target="_top">CppAD Changes and Additions During 2012: 12-29</a><br/>
	925	<a href="whats_new_13.xml#12-29" target="_top">CppAD Changes and Additions During 2013: 12-29</a><br/>
	926	12<b>-</b>30 <a href="whats_new_11.xml#12-30" target="_top">Changes and Additions to CppAD During 2011: 12-30</a><br/>
	927	<a href="whats_new_12.xml#12-30" target="_top">CppAD Changes and Additions During 2012: 12-30</a><br/>
	928	12<b>-</b>31 <a href="whats_new_10.xml#12-31" target="_top">Changes and Additions to CppAD During 2010: 12-31</a><br/>
	929	1<b>:</b> <a href="install.xml#Instructions.Step 1: Download" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 1: Download</a><br/>
	930	2003 <a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a><br/>
	931	2004 <a href="whats_new_04.xml" target="_top">Changes and Additions to CppAD During 2004</a><br/>
	932	2005 <a href="whats_new_05.xml" target="_top">Changes and Additions to CppAD During 2005</a><br/>
	933	2006 <a href="whats_new_06.xml" target="_top">Changes and Additions to CppAD During 2006</a><br/>
	934	2007 <a href="whats_new_07.xml" target="_top">Changes and Additions to CppAD During 2007</a><br/>
	935	2008 <a href="whats_new_08.xml" target="_top">Changes and Additions to CppAD During 2008</a><br/>
	936	2009 <a href="whats_new_09.xml" target="_top">Changes and Additions to CppAD During 2009</a><br/>
	937	2010 <a href="whats_new_10.xml" target="_top">Changes and Additions to CppAD During 2010</a><br/>
	938	2011 <a href="whats_new_11.xml" target="_top">Changes and Additions to CppAD During 2011</a><br/>
	939	2012 <a href="whats_new_12.xml" target="_top">CppAD Changes and Additions During 2012</a><br/>
	940	2013 <a href="whats_new_13.xml" target="_top">CppAD Changes and Additions During 2013</a><br/>
	941	2014 <a href="whats_new_14.xml" target="_top">CppAD Changes and Additions During 2014</a><br/>
	942	2<b>:</b> <a href="exp_eps_rev2.xml#Index 2: f_1" target="_top">exp_eps: Second Order Reverse Sweep: Index 2: f_1</a><br/>
	943	<a href="exp_eps_rev1.xml#Index 2: f_1" target="_top">exp_eps: First Order Reverse Sweep: Index 2: f_1</a><br/>
	944	<a href="exp_2_rev2.xml#Index 2: f_1" target="_top">exp_2: Second Order Reverse Mode: Index 2: f_1</a><br/>
	945	<a href="exp_2_rev1.xml#Index 2: f_1" target="_top">exp_2: First Order Reverse Mode: Index 2: f_1</a><br/>
	946	<a href="install.xml#Instructions.Step 2: Cmake" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 2: Cmake</a><br/>
	947	3 <a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	948	<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	949	<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
	950	<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
	951	3<b>.</b>4<b>.</b>4 <a href="bugs.xml#gcc 3.4.4 -O2" target="_top">Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2</a><br/>
	952	3<b>:</b> <a href="exp_eps_rev2.xml#Index 3: f_2" target="_top">exp_eps: Second Order Reverse Sweep: Index 3: f_2</a><br/>
	953	<a href="exp_eps_rev1.xml#Index 3: f_2" target="_top">exp_eps: First Order Reverse Sweep: Index 3: f_2</a><br/>
	954	<a href="exp_2_rev2.xml#Index 3: f_2" target="_top">exp_2: Second Order Reverse Mode: Index 3: f_2</a><br/>
	955	<a href="exp_2_rev1.xml#Index 3: f_2" target="_top">exp_2: First Order Reverse Mode: Index 3: f_2</a><br/>
	956	<a href="install.xml#Instructions.Step 3: Check" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 3: Check</a><br/>
	957	3rd <a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
	958	4<b>:</b> <a href="exp_eps_rev2.xml#Index 4: f_3" target="_top">exp_eps: Second Order Reverse Sweep: Index 4: f_3</a><br/>
	959	<a href="exp_eps_rev1.xml#Index 4: f_3" target="_top">exp_eps: First Order Reverse Sweep: Index 4: f_3</a><br/>
	960	<a href="exp_2_rev2.xml#Index 4: f_3" target="_top">exp_2: Second Order Reverse Mode: Index 4: f_3</a><br/>
	961	<a href="exp_2_rev1.xml#Index 4: f_3" target="_top">exp_2: First Order Reverse Mode: Index 4: f_3</a><br/>
	962	<a href="install.xml#Instructions.Step 4: Install" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 4: Install</a><br/>
	963	4th <a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
	964	<a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
	965	5<b>:</b> <a href="exp_eps_rev2.xml#Index 5: f_4" target="_top">exp_eps: Second Order Reverse Sweep: Index 5: f_4</a><br/>
	966	<a href="exp_eps_rev1.xml#Index 5: f_4" target="_top">exp_eps: First Order Reverse Sweep: Index 5: f_4</a><br/>
	967	<a href="exp_2_rev2.xml#Index 5: f_4" target="_top">exp_2: Second Order Reverse Mode: Index 5: f_4</a><br/>
	968	<a href="exp_2_rev1.xml#Index 5: f_4" target="_top">exp_2: First Order Reverse Mode: Index 5: f_4</a><br/>
	969	5th <a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
	970	6<b>:</b> <a href="exp_eps_rev2.xml#Index 6: f_5" target="_top">exp_eps: Second Order Reverse Sweep: Index 6: f_5</a><br/>
	971	<a href="exp_eps_rev1.xml#Index 6: f_5" target="_top">exp_eps: First Order Reverse Sweep: Index 6: f_5</a><br/>
	972	7<b>:</b> <a href="exp_eps_rev2.xml#Index 7: f_6" target="_top">exp_eps: Second Order Reverse Sweep: Index 7: f_6</a><br/>
	973	<a href="exp_eps_rev1.xml#Index 7: f_6" target="_top">exp_eps: First Order Reverse Sweep: Index 7: f_6</a><br/>
118	974	<b><</b><br/>
119	975	AD<b> </b>operator <a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
120	976	example <a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
121	977	<b><<</b><br/>
	978	AD<b> </b>example <a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
122	979	AD<b> </b>example <a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
123		AD<b> </b>example <a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
124	980	AD<b> </b>output <a href="ad_output.xml" target="_top">AD Output Stream Operator</a><br/>
125	981	<b><=</b><br/>
126	982	AD<b> </b>operator <a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
127	983	example <a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
128		<b>==</b><br/>
	984	<b>=</b> <a href="ode_evaluate.xml#p.p = 1" target="_top">Evaluate a Function Defined in Terms of an ODE: p.p = 1</a><br/>
	985	<b>==</b> <a href="ode_evaluate.xml#p.p == 0" target="_top">Evaluate a Function Defined in Terms of an ODE: p.p == 0</a><br/>
129	986	AD<b> </b>operator <a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
130	987	example <a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
131	988	<b>></b><br/>

136	993	example <a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
137	994	<b>>></b><br/>
138	995	AD<b> </b>input <a href="ad_input.xml" target="_top">AD Output Stream Operator</a><br/>
	996	<b>[</b>0<br/>
	997	1<b>]</b> <a href="uniform_01_c.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	998	1<b>]</b> <a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
139	999	<b>[]</b><br/>
140	1000	CppAD<b> </b>vector <a href="cppad_vector.xml#Element Access" target="_top">The CppAD::vector Template Class: Element Access</a><br/>
141	1001	vector <a href="simplevector.xml#Element Access" target="_top">Definition of a Simple Vector: Element Access</a><br/>

146	1006	boost<b> </b>thread<b> </b>example <a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
147	1007	OpenMP<b> </b>example <a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
148	1008	OpenMP<b> </b>example <a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
149		AD <a href="cppad.xml" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms</a><br/>
	1009	AD <a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
150	1010	arithmetic<b> </b>operator <a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
151	1011	assignment <a href="ad_assign.xml" target="_top">AD Assignment Operator</a><br/>
152	1012	binary<b> </b>compare<b> </b>operator <a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>

185	1045	assignment<b> </b>example <a href="fun_assign.cpp.xml" target="_top">ADFun Assignment: Example and Test</a><br/>
186	1046	assignment<b> </b>operator <a href="funconstruct.xml#Assignment Operator" target="_top">Construct an ADFun Object and Stop Recording: Assignment Operator</a><br/>
187	1047	CompareChange <a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
	1048	capacity<b>_</b>taylor <a href="fundeprecated.xml#capacity_taylor" target="_top">ADFun Object Deprecated Member Functions: capacity_taylor</a><br/>
188	1049	check <a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
189	1050	check<b> </b>nan <a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan</a><br/>
190	1051	construct <a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>

205	1066	Size <a href="fundeprecated.xml#Size" target="_top">ADFun Object Deprecated Member Functions: Size</a><br/>
206	1067	sequence<b> </b>constructor <a href="funconstruct.xml#Sequence Constructor" target="_top">Construct an ADFun Object and Stop Recording: Sequence Constructor</a><br/>
207	1068	size<b>_</b>par <a href="seq_property.xml#size_par" target="_top">ADFun Sequence Properties: size_par</a><br/>
	1069	size<b>_</b>taylor <a href="fundeprecated.xml#size_taylor" target="_top">ADFun Object Deprecated Member Functions: size_taylor</a><br/>
208	1070	size<b>_</b>VecAD <a href="seq_property.xml#size_VecAD" target="_top">ADFun Sequence Properties: size_VecAD</a><br/>
209	1071	size<b>_</b>var <a href="seq_property.xml#size_var" target="_top">ADFun Sequence Properties: size_var</a><br/>
210	1072	taylor<b>_</b>size <a href="fundeprecated.xml#taylor_size" target="_top">ADFun Object Deprecated Member Functions: taylor_size</a><br/>

213	1075	adouble<b> </b>as<b> </b>Base <a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
214	1076	multiple<b> </b>level <a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
215	1077	ODE <a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
216		unix <a href="installunix.xml#adolc_dir" target="_top">Unix Test and Installation: adolc_dir</a><br/>
	1078	unix <a href="installunix.xml#adolc_dir" target="_top">Deprecated Unix Test and Installation: adolc_dir</a><br/>
217	1079	Algorithmic<b> </b>Differentiation<br/>
218	1080	introduction <a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
219	1081	Automatic<b> </b>Differentiation<br/>
220	1082	introduction <a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
221		abort<br/>
	1083	a <a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
	1084	<a href="uniform_01_c.xml#a" target="_top">Simulate a [0,1] Uniform Random Variate: a</a><br/>
	1085	<a href="uniform_01_c.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	1086	<a href="det_by_minor_c.xml#a" target="_top">Compute Determinant using Expansion by Minors: a</a><br/>
	1087	<a href="det_of_minor_c.xml#a" target="_top">Determinant of a Minor: a</a><br/>
	1088	<a href="det_of_minor_c.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
	1089	<a href="det_of_minor_c.xml" target="_top">Determinant of a Minor</a><br/>
	1090	<a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
	1091	<a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	1092	<a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
	1093	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	1094	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	1095	<a href="omp_create_array.xml" target="_top">Allocate Memory and Create A Raw Array</a><br/>
	1096	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	1097	<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	1098	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	1099	<a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	1100	<a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
	1101	<a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
	1102	<a href="fadbad_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
	1103	<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
	1104	<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
	1105	<a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>
	1106	<a href="double_poly.cpp.xml" target="_top">Double Speed: Evaluate a Polynomial</a><br/>
	1107	<a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	1108	<a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
	1109	<a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
	1110	<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
	1111	<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
	1112	<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
	1113	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	1114	<a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
	1115	<a href="det_by_minor.xml#det.a" target="_top">Determinant Using Expansion by Minors: det.a</a><br/>
	1116	<a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
	1117	<a href="det_of_minor.xml#a" target="_top">Determinant of a Minor: a</a><br/>
	1118	<a href="det_of_minor.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
	1119	<a href="det_of_minor.xml" target="_top">Determinant of a Minor</a><br/>
	1120	<a href="det_by_lu.xml#det.a" target="_top">Determinant Using Expansion by Lu Factorization: det.a</a><br/>
	1121	<a href="link_poly.xml#a" target="_top">Speed Testing Second Derivative of a Polynomial: a</a><br/>
	1122	<a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
	1123	<a href="stack_machine.cpp.xml" target="_top">Example Differentiating a Stack Machine Interpreter</a><br/>
	1124	<a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
	1125	<a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
	1126	<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
	1127	<a href="luratio.xml#LU.A" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU.A</a><br/>
	1128	<a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
	1129	<a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a><br/>
	1130	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	1131	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	1132	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	1133	<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	1134	<a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a><br/>
	1135	<a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
	1136	<a href="rombergmul.xml#a" target="_top">Multi-dimensional Romberg Integration: a</a><br/>
	1137	<a href="rombergone.xml#a" target="_top">One DimensionalRomberg Integration: a</a><br/>
	1138	<a href="luinvert.xml#LU.A" target="_top">Invert an LU Factored Equation: LU.A</a><br/>
	1139	<a href="lufactor.xml#LU.A" target="_top">LU Factorization of A Square Matrix: LU.A</a><br/>
	1140	<a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
	1141	<a href="lusolve.xml#A" target="_top">Compute Determinant and Solve Linear Equations: A</a><br/>
	1142	<a href="poly.xml#a" target="_top">Evaluate a Polynomial or its Derivative: a</a><br/>
	1143	<a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
	1144	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	1145	<a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
	1146	<a href="numerictype.xml" target="_top">Definition of a Numeric Type</a><br/>
	1147	<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
	1148	<a href="nearequal.xml#a" target="_top">Determine if Two Values Are Nearly Equal: a</a><br/>
	1149	<a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
	1150	<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
	1151	<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
	1152	<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
	1153	<a href="multi_newton.cpp.xml" target="_top">A Multi-Threaded Newton's Method</a><br/>
	1154	<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
	1155	<a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
	1156	<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
	1157	<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
	1158	<a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
	1159	<a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
	1160	<a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
	1161	<a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
	1162	<a href="funcheck.xml#a" target="_top">Check an ADFun Sequence of Operations: a</a><br/>
	1163	<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	1164	<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
	1165	<a href="nearequalext.xml#a" target="_top">Compare AD and Base Objects for Nearly Equal: a</a><br/>
	1166	<a href="atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Test with x_1 Both a Variable and a Parameter</a><br/>
	1167	<a href="atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Test with x_1 Both a Variable and a Parameter</a><br/>
	1168	<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	1169	<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
	1170	<a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1171	a11c <a href="thread_test.cpp.xml#a11c" target="_top">Run Multi-Threading Examples and Speed Tests: a11c</a><br/>
	1172	abort <a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
	1173	<a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
222	1174	example <a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
223	1175	operation<b> </b>sequence <a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
224	1176	recording <a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
225	1177	above <a href="glossary.xml#AD Levels Above Base" target="_top">Glossary: AD Levels Above Base</a><br/>
226		abs<br/>
	1178	<a href="forwardtheory.xml#Standard Math Functions.Cases that Apply Recursion Above" target="_top">The Theory of Forward Mode: Standard Math Functions.Cases that Apply Recursion Above</a><br/>
	1179	abramowitz <a href="bib.xml#Abramowitz and Stegun" target="_top">Bibliography: Abramowitz and Stegun</a><br/>
	1180	abs <a href="base_adolc.hpp.xml#abs" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: abs</a><br/>
227	1181	AD <a href="abs.xml" target="_top">AD Absolute Value Function</a><br/>
228	1182	example <a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
229		absolute<br/>
	1183	absgeq <a href="lufactor.xml#AbsGeq" target="_top">LU Factorization of A Square Matrix: AbsGeq</a><br/>
	1184	<a href="lusolve.xml#AbsGeq" target="_top">Compute Determinant and Solve Linear Equations: AbsGeq</a><br/>
	1185	absolute <a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
	1186	<a href="abs.xml" target="_top">AD Absolute Value Function</a><br/>
230	1187	AD<b> </b>value <a href="abs.xml" target="_top">AD Absolute Value Function</a><br/>
231	1188	difference <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
	1189	access <a href="cppad_vector.xml#Element Access" target="_top">The CppAD::vector Template Class: Element Access</a><br/>
	1190	<a href="simplevector.xml#Element Access" target="_top">Definition of a Simple Vector: Element Access</a><br/>
	1191	accurate <a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
232	1192	aclocal <a href="whats_new_06.xml#01-08" target="_top">Changes and Additions to CppAD During 2006: 01-08</a><br/>
233		acos<br/>
	1193	acos <a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
	1194	<a href="std_math_ad.xml#Derivatives.acos" target="_top">AD Standard Math Unary Functions: Derivatives.acos</a><br/>
234	1195	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
235	1196	AD<b> </b>example <a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
236	1197	forward<b> </b>theory <a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a><br/>
237	1198	reverse<b> </b>theory <a href="acosreverse.xml" target="_top">Arccosine Function Reverse Mode Theory</a><br/>
238	1199	active <a href="glossary.xml#Tape.Active" target="_top">Glossary: Tape.Active</a><br/>
239		ad <a href="glossary.xml#AD Levels Above Base" target="_top">Glossary: AD Levels Above Base</a><br/>
	1200	ad <a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	1201	<a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	1202	<a href="old_atomic.xml#Example.Use AD" target="_top">User Defined Atomic AD Functions: Example.Use AD</a><br/>
	1203	<a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	1204	<a href="epsilon.xml" target="_top">Machine Epsilon For AD Types</a><br/>
	1205	<a href="glossary.xml#AD Levels Above Base" target="_top">Glossary: AD Levels Above Base</a><br/>
240	1206	<a href="glossary.xml#AD of Base" target="_top">Glossary: AD of Base</a><br/>
241	1207	<a href="glossary.xml#AD Function" target="_top">Glossary: AD Function</a><br/>
	1208	<a href="speed_main.xml#package.AD Package" target="_top">Running the Speed Test Program: package.AD Package</a><br/>
	1209	<a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
	1210	<a href="mul_level_adolc_ode.cpp.xml#Taylor's Method Using AD" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Taylor's Method Using AD</a><br/>
	1211	<a href="mul_level_ode.cpp.xml#Taylor's Method Using AD" target="_top">Taylor's Ode Solver: An Example and Test: Taylor's Method Using AD</a><br/>
	1212	<a href="mul_level.xml" target="_top">Using Multiple Levels of AD</a><br/>
	1213	<a href="library.xml#Numerical AD Library" target="_top">The CppAD General Purpose Library: Numerical AD Library</a><br/>
	1214	<a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
	1215	<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
	1216	<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
	1217	<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
	1218	<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
	1219	<a href="parallel_ad.xml" target="_top">Enable AD Calculations During Parallel Mode</a><br/>
	1220	<a href="multi_thread.xml#Parallel AD" target="_top">Using CppAD in a Multi-Threading Environment: Parallel AD</a><br/>
	1221	<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	1222	<a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a><br/>
	1223	<a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
	1224	<a href="vecad.xml#AD Indexing" target="_top">AD Vectors that Record Index Operations: AD Indexing</a><br/>
	1225	<a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
	1226	<a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
	1227	<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
	1228	<a href="bool_fun.cpp.xml" target="_top">AD Boolean Functions: Example and Test</a><br/>
	1229	<a href="boolfun.xml" target="_top">AD Boolean Functions</a><br/>
	1230	<a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a><br/>
	1231	<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
	1232	<a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
	1233	<a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
	1234	<a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
	1235	<a href="atomic_afun.xml" target="_top">Using AD Version of Atomic Function</a><br/>
	1236	<a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	1237	<a href="atomic.xml" target="_top">Atomic AD Functions</a><br/>
	1238	<a href="discrete.xml#Create AD Version" target="_top">Discrete AD Functions: Create AD Version</a><br/>
	1239	<a href="discrete.xml" target="_top">Discrete AD Functions</a><br/>
	1240	<a href="condexp.xml" target="_top">AD Conditional Expressions</a><br/>
	1241	<a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
	1242	<a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a><br/>
	1243	<a href="pow.xml" target="_top">The AD Power Function</a><br/>
	1244	<a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a><br/>
	1245	<a href="erf.xml" target="_top">The AD Error Function</a><br/>
	1246	<a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a><br/>
	1247	<a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a><br/>
	1248	<a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
	1249	<a href="abs.xml" target="_top">AD Absolute Value Function</a><br/>
	1250	<a href="mathother.xml" target="_top">Other AD Math Functions</a><br/>
	1251	<a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a><br/>
	1252	<a href="tan.cpp.xml" target="_top">The AD tan Function: Example and Test</a><br/>
	1253	<a href="sqrt.cpp.xml" target="_top">The AD sqrt Function: Example and Test</a><br/>
	1254	<a href="sinh.cpp.xml" target="_top">The AD sinh Function: Example and Test</a><br/>
	1255	<a href="sin.cpp.xml" target="_top">The AD sin Function: Example and Test</a><br/>
	1256	<a href="log10.cpp.xml" target="_top">The AD log10 Function: Example and Test</a><br/>
	1257	<a href="log.cpp.xml" target="_top">The AD log Function: Example and Test</a><br/>
	1258	<a href="exp.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
	1259	<a href="cosh.cpp.xml" target="_top">The AD cosh Function: Example and Test</a><br/>
	1260	<a href="cos.cpp.xml" target="_top">The AD cos Function: Example and Test</a><br/>
	1261	<a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
	1262	<a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>
	1263	<a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
	1264	<a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
	1265	<a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
	1266	<a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
	1267	<a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
	1268	<a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
	1269	<a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
	1270	<a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
	1271	<a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
	1272	<a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
	1273	<a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
	1274	<a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
	1275	<a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a><br/>
	1276	<a href="unaryminus.xml" target="_top">AD Unary Minus Operator</a><br/>
	1277	<a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a><br/>
	1278	<a href="unaryplus.xml" target="_top">AD Unary Plus Operator</a><br/>
	1279	<a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
	1280	<a href="advalued.xml" target="_top">AD Valued Operations and Functions</a><br/>
	1281	<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	1282	<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
	1283	<a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
	1284	<a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	1285	<a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	1286	<a href="ad_output.xml" target="_top">AD Output Stream Operator</a><br/>
	1287	<a href="ad_input.xml" target="_top">AD Output Stream Operator</a><br/>
	1288	<a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
	1289	<a href="integer.xml#x.AD Types" target="_top">Convert From AD to Integer: x.AD Types</a><br/>
	1290	<a href="integer.xml" target="_top">Convert From AD to Integer</a><br/>
	1291	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	1292	<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
	1293	<a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a><br/>
	1294	<a href="ad_assign.cpp.xml" target="_top">AD Assignment: Example and Test</a><br/>
	1295	<a href="ad_assign.xml" target="_top">AD Assignment Operator</a><br/>
	1296	<a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a><br/>
	1297	<a href="ad_ctor.xml" target="_top">AD Constructors</a><br/>
	1298	<a href="ad.xml" target="_top">AD Objects</a><br/>
242	1299	atomic<b> </b>function <a href="atomic.xml" target="_top">Atomic AD Functions</a><br/>
	1300	ad<b>:</b> <a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
	1301	<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
	1302	<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
	1303	ad<b><</b>base<b>></b> <a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
	1304	<a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
	1305	<a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
	1306	<a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
	1307	<a href="base_alloc.hpp.xml" target="_top">Example AD<Base> Where Base Constructor Allocates Memory</a><br/>
	1308	<a href="base_require.xml" target="_top">AD<Base> Requirements for Base Type</a><br/>
	1309	ad<b><</b>otherbase<b>></b> <a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a><br/>
	1310	adbasetape <a href="mul_level.xml#General Procedure.Start ADBaseTape" target="_top">Using Multiple Levels of AD: General Procedure.Start ADBaseTape</a><br/>
243	1311	add<br/>
244	1312	<b>*= </b>example <a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
245	1313	<b>+= </b>example <a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>

248	1316	AD<b> </b>example <a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
249	1317	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
250	1318	computed<b> </b>assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
	1319	add<b>_</b>static <a href="memory_leak.xml#add_static" target="_top">Memory Leak Detection: add_static</a><br/>
	1320	addbasetape <a href="mul_level.xml#General Procedure.Start ADDBaseTape" target="_top">Using Multiple Levels of AD: General Procedure.Start ADDBaseTape</a><br/>
	1321	addition <a href="reversetheory.xml#Binary Operators.Addition" target="_top">The Theory of Reverse Mode: Binary Operators.Addition</a><br/>
	1322	<a href="forwardtheory.xml#Binary Operators.Addition" target="_top">The Theory of Forward Mode: Binary Operators.Addition</a><br/>
	1323	<a href="compute_assign.xml#Derivative.Addition" target="_top">AD Computed Assignment Operators: Derivative.Addition</a><br/>
	1324	<a href="ad_binary.xml#Derivative.Addition" target="_top">AD Binary Arithmetic Operators: Derivative.Addition</a><br/>
	1325	addition<b>:</b> <a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
	1326	<a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
	1327	additions <a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a><br/>
	1328	<a href="whats_new_04.xml" target="_top">Changes and Additions to CppAD During 2004</a><br/>
	1329	<a href="whats_new_05.xml" target="_top">Changes and Additions to CppAD During 2005</a><br/>
	1330	<a href="whats_new_06.xml" target="_top">Changes and Additions to CppAD During 2006</a><br/>
	1331	<a href="whats_new_07.xml" target="_top">Changes and Additions to CppAD During 2007</a><br/>
	1332	<a href="whats_new_08.xml" target="_top">Changes and Additions to CppAD During 2008</a><br/>
	1333	<a href="whats_new_09.xml" target="_top">Changes and Additions to CppAD During 2009</a><br/>
	1334	<a href="whats_new_10.xml" target="_top">Changes and Additions to CppAD During 2010</a><br/>
	1335	<a href="whats_new_11.xml" target="_top">Changes and Additions to CppAD During 2011</a><br/>
	1336	<a href="whats_new_12.xml" target="_top">CppAD Changes and Additions During 2012</a><br/>
	1337	<a href="whats_new_13.xml" target="_top">CppAD Changes and Additions During 2013</a><br/>
	1338	<a href="whats_new_14.xml" target="_top">CppAD Changes and Additions During 2014</a><br/>
	1339	<a href="whats_new.xml" target="_top">Changes and Additions to CppAD</a><br/>
	1340	adfun <a href="fundeprecated.xml" target="_top">ADFun Object Deprecated Member Functions</a><br/>
	1341	<a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
	1342	<a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
	1343	<a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan</a><br/>
	1344	<a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>
	1345	<a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
	1346	<a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
	1347	<a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
	1348	<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	1349	<a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a><br/>
	1350	<a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
	1351	<a href="seq_property.xml" target="_top">ADFun Sequence Properties</a><br/>
	1352	<a href="fun_assign.cpp.xml" target="_top">ADFun Assignment: Example and Test</a><br/>
	1353	<a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
	1354	<a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a><br/>
	1355	<a href="adfun.xml" target="_top">ADFun Objects</a><br/>
	1356	adnumber <a href="cppad_ipopt_nlp.xml#ADNumber" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: ADNumber</a><br/>
	1357	adol<b>-</b>c <a href="adolc_prefix.xml" target="_top">Including the ADOL-C Examples and Tests</a><br/>
251	1358	adolc <a href="wishlist.xml#Adolc" target="_top">The CppAD Wish List: Adolc</a><br/>
	1359	<a href="wishlist.xml#Adolc" target="_top">The CppAD Wish List: Adolc</a><br/>
	1360	<a href="bugs.xml#gcc 3.4.4 -O2.Adolc" target="_top">Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2.Adolc</a><br/>
	1361	<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
	1362	<a href="adolc_sparse_jacobian.cpp.xml" target="_top">adolc Speed: Sparse Jacobian</a><br/>
	1363	<a href="adolc_sparse_hessian.cpp.xml" target="_top">Adolc Speed: Sparse Hessian</a><br/>
	1364	<a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>
	1365	<a href="adolc_ode.cpp.xml" target="_top">Adolc Speed: Ode</a><br/>
	1366	<a href="adolc_mat_mul.cpp.xml" target="_top">Adolc Speed: Matrix Multiplication</a><br/>
	1367	<a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	1368	<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
	1369	<a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
	1370	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	1371	<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
	1372	<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
252	1373	cygwin <a href="adolc_prefix.xml#Cygwin" target="_top">Including the ADOL-C Examples and Tests: Cygwin</a><br/>
253	1374	download<b> </b>and<b> </b>install <a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
254	1375	example <a href="adolc_prefix.xml" target="_top">Including the ADOL-C Examples and Tests</a><br/>

272	1393	speed <a href="adolc_prefix.xml#Speed Tests" target="_top">Including the ADOL-C Examples and Tests: Speed Tests</a><br/>
273	1394	speed<b> </b>test <a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
274	1395	unix <a href="adolc_prefix.xml#Unix" target="_top">Including the ADOL-C Examples and Tests: Unix</a><br/>
	1396	adolc<b>'</b>s <a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
275	1397	adolc<b>_</b>alloc<b>_</b>mat <a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
276		adouble<br/>
	1398	adolc<b>_</b>dir <a href="installunix.xml#adolc_dir" target="_top">Deprecated Unix Test and Installation: adolc_dir</a><br/>
	1399	adolc<b>_</b>prefix <a href="speed_adolc.xml#adolc_prefix" target="_top">Speed Test of Derivatives Using Adolc: adolc_prefix</a><br/>
	1400	<a href="adolc_prefix.xml#adolc_prefix" target="_top">Including the ADOL-C Examples and Tests: adolc_prefix</a><br/>
	1401	adouble <a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
277	1402	as<b> </b>Base <a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
278		algorithm<br/>
	1403	advector <a href="cppad_ipopt_nlp.xml#ADVector" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: ADVector</a><br/>
	1404	<a href="ipopt_solve.xml#fg_eval.ADvector" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: fg_eval.ADvector</a><br/>
	1405	<a href="luratio.xml#ADvector" target="_top">LU Factorization of A Square Matrix and Stability Calculation: ADvector</a><br/>
	1406	<a href="benderquad.xml#ADvector" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: ADvector</a><br/>
	1407	<a href="dependent.xml#ADvector" target="_top">Stop Recording and Store Operation Sequence: ADvector</a><br/>
	1408	<a href="atomic_afun.xml#ADVector" target="_top">Using AD Version of Atomic Function: ADVector</a><br/>
	1409	<a href="checkpoint.xml#ADVector" target="_top">Checkpointing Functions: ADVector</a><br/>
	1410	after <a href="printfor.xml#after" target="_top">Printing AD Values During Forward Mode: after</a><br/>
	1411	afun <a href="old_atomic.xml#afun" target="_top">User Defined Atomic AD Functions: afun</a><br/>
	1412	<a href="atomic_afun.xml#afun" target="_top">Using AD Version of Atomic Function: afun</a><br/>
	1413	<a href="atomic_ctor.xml#atomic_user.afun" target="_top">Atomic Function Constructor: atomic_user.afun</a><br/>
	1414	<a href="checkpoint.xml#afun" target="_top">Checkpointing Functions: afun</a><br/>
	1415	algebra <a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
	1416	algo <a href="checkpoint.xml#algo" target="_top">Checkpointing Functions: algo</a><br/>
	1417	algorithm <a href="conj_grad.cpp.xml#Algorithm" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test: Algorithm</a><br/>
279	1418	example <a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
280	1419	example <a href="exp_2.xml" target="_top">Second Order Exponential Approximation</a><br/>
281		algorithmic<br/>
	1420	algorithm<b>:</b> <a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
	1421	algorithmic <a href="introduction.xml#Preface.Algorithmic Differentiation" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Algorithmic Differentiation</a><br/>
	1422	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
282	1423	C<b> </b>differentiation <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
283		algorithmic<b> </b>differentiation <a href="cppad.xml" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms</a><br/>
284		alloc<br/>
	1424	algorithmic<b> </b>differentiation <a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1425	algorithms <a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1426	alignment <a href="ta_create_array.xml#Alignment" target="_top">Allocate An Array and Call Default Constructor for its Elements: Alignment</a><br/>
	1427	<a href="ta_get_memory.xml#Alignment" target="_top">Get At Least A Specified Amount of Memory: Alignment</a><br/>
	1428	all <a href="listallexamples.xml" target="_top">List of All the CppAD Examples</a><br/>
	1429	<a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	1430	<a href="cmake_check.xml#Check All" target="_top">Checking the CppAD Examples and Tests: Check All</a><br/>
	1431	alloc <a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
285	1432	adolc <a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
286		allocate<br/>
	1433	allocate <a href="omp_create_array.xml" target="_top">Allocate Memory and Create A Raw Array</a><br/>
	1434	<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
	1435	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
287	1436	array <a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
288	1437	array <a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
289	1438	memory <a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
290		allocation<br/>
	1439	allocated <a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	1440	allocates <a href="base_alloc.hpp.xml" target="_top">Example AD<Base> Where Base Constructor Allocates Memory</a><br/>
	1441	allocation <a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
	1442	<a href="omp_get_memory.xml#Allocation Speed" target="_top">Get At Least A Specified Amount of Memory: Allocation Speed</a><br/>
	1443	<a href="faq.xml#Speed.Memory Allocation" target="_top">Frequently Asked Questions and Answers: Speed.Memory Allocation</a><br/>
	1444	<a href="ta_get_memory.xml#Allocation Speed" target="_top">Get At Least A Specified Amount of Memory: Allocation Speed</a><br/>
	1445	<a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
291	1446	multi<b>-</b>threading <a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
292	1447	multi<b>-</b>threading <a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a><br/>
293		any<br/>
	1448	allocation<b>:</b> <a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	1449	allocator <a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
	1450	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
	1451	<a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
	1452	<a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a><br/>
	1453	allocator<b>:</b> <a href="omp_alloc.cpp.xml" target="_top">OpenMP Memory Allocator: Example and Test</a><br/>
	1454	<a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
	1455	also <a href="opt_val_hes.xml#See Also" target="_top">Jacobian and Hessian of Optimal Values: See Also</a><br/>
	1456	<a href="benderquad.xml#See Also" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: See Also</a><br/>
	1457	<a href="pow_int.xml#See Also" target="_top">The Integer Power Function: See Also</a><br/>
	1458	<a href="number_skip.xml#Syntax.See Also" target="_top">Number of Variables that Can be Skipped: Syntax.See Also</a><br/>
	1459	<a href="capacity_order.xml#Syntax.See Also" target="_top">Controlling Taylor Coefficients Memory Allocation: Syntax.See Also</a><br/>
	1460	<a href="size_order.xml#Syntax.See Also" target="_top">Number Taylor Coefficient Orders Currently Stored: Syntax.See Also</a><br/>
	1461	<a href="seq_property.xml#Syntax.See Also" target="_top">ADFun Sequence Properties: Syntax.See Also</a><br/>
	1462	<a href="not_complex_ad.cpp.xml#See Also" target="_top">Not Complex Differentiable: Example and Test: See Also</a><br/>
	1463	<a href="complex_poly.cpp.xml#See Also" target="_top">Complex Polynomial: Example and Test: See Also</a><br/>
	1464	<a href="base_complex.hpp.xml#See Also" target="_top">Enable use of AD<Base> where Base is std::complex<double>: See Also</a><br/>
	1465	<a href="interp_retape.cpp.xml#See Also" target="_top">Interpolation With Retaping: Example and Test: See Also</a><br/>
	1466	<a href="interp_onetape.cpp.xml#See Also" target="_top">Interpolation With Out Retaping: Example and Test: See Also</a><br/>
	1467	<a href="pow.xml#See Also" target="_top">The AD Power Function: See Also</a><br/>
	1468	alternative <a href="printfor.xml#Alternative" target="_top">Printing AD Values During Forward Mode: Alternative</a><br/>
	1469	alternatives <a href="vecad.xml#Alternatives" target="_top">AD Vectors that Record Index Operations: Alternatives</a><br/>
	1470	amount <a href="time_det_by_minor_c.xml" target="_top">Determine Amount of Time to Execute det_by_minor</a><br/>
	1471	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	1472	<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	1473	<a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	1474	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	1475	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	1476	<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	1477	<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
	1478	an <a href="ipopt_nlp_ode_problem.xml" target="_top">An ODE Inverse Problem Example</a><br/>
	1479	<a href="reverse_identity.xml" target="_top">An Important Reverse Mode Identity</a><br/>
	1480	<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
	1481	<a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
	1482	<a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	1483	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	1484	<a href="mul_level_ode.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	1485	<a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
	1486	<a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
	1487	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	1488	<a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
	1489	<a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
	1490	<a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
	1491	<a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
	1492	<a href="luinvert.xml" target="_top">Invert an LU Factored Equation</a><br/>
	1493	<a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan</a><br/>
	1494	<a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
	1495	<a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
	1496	<a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
	1497	<a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
	1498	<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
	1499	<a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a><br/>
	1500	<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
	1501	<a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
	1502	<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	1503	<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
	1504	<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
	1505	<a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
	1506	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
	1507	analytic <a href="ipopt_nlp_ode_problem.xml#Measurements.Simulation Analytic Solution" target="_top">An ODE Inverse Problem Example: Measurements.Simulation Analytic Solution</a><br/>
	1508	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements.Simulation Analytic Solution" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements.Simulation Analytic Solution</a><br/>
	1509	and <a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
	1510	<a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
	1511	<a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	1512	<a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	1513	<a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	1514	<a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
	1515	<a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
	1516	<a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
	1517	<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
	1518	<a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	1519	<a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	1520	<a href="omp_alloc.cpp.xml" target="_top">OpenMP Memory Allocator: Example and Test</a><br/>
	1521	<a href="omp_create_array.xml" target="_top">Allocate Memory and Create A Raw Array</a><br/>
	1522	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
	1523	<a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
	1524	<a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
	1525	<a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
	1526	<a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a><br/>
	1527	<a href="whats_new_04.xml" target="_top">Changes and Additions to CppAD During 2004</a><br/>
	1528	<a href="whats_new_05.xml" target="_top">Changes and Additions to CppAD During 2005</a><br/>
	1529	<a href="whats_new_06.xml" target="_top">Changes and Additions to CppAD During 2006</a><br/>
	1530	<a href="whats_new_07.xml" target="_top">Changes and Additions to CppAD During 2007</a><br/>
	1531	<a href="whats_new_08.xml" target="_top">Changes and Additions to CppAD During 2008</a><br/>
	1532	<a href="whats_new_09.xml" target="_top">Changes and Additions to CppAD During 2009</a><br/>
	1533	<a href="whats_new_10.xml" target="_top">Changes and Additions to CppAD During 2010</a><br/>
	1534	<a href="whats_new_11.xml" target="_top">Changes and Additions to CppAD During 2011</a><br/>
	1535	<a href="whats_new_12.xml" target="_top">CppAD Changes and Additions During 2012</a><br/>
	1536	<a href="whats_new_13.xml" target="_top">CppAD Changes and Additions During 2013</a><br/>
	1537	<a href="whats_new_14.xml" target="_top">CppAD Changes and Additions During 2014</a><br/>
	1538	<a href="whats_new.xml" target="_top">Changes and Additions to CppAD</a><br/>
	1539	<a href="bugs.xml" target="_top">Know Bugs and Problems Using CppAD</a><br/>
	1540	<a href="bib.xml#Abramowitz and Stegun" target="_top">Bibliography: Abramowitz and Stegun</a><br/>
	1541	<a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
	1542	<a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
	1543	<a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
	1544	<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
	1545	<a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
	1546	<a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
	1547	<a href="faq.xml#Assignment and Independent" target="_top">Frequently Asked Questions and Answers: Assignment and Independent</a><br/>
	1548	<a href="faq.xml" target="_top">Frequently Asked Questions and Answers</a><br/>
	1549	<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
	1550	<a href="sparse_hes_fun.cpp.xml" target="_top">sparse_hes_fun: Example and test</a><br/>
	1551	<a href="sparse_jac_fun.cpp.xml" target="_top">sparse_jac_fun: Example and test</a><br/>
	1552	<a href="ode_evaluate.cpp.xml" target="_top">ode_evaluate: Example and test</a><br/>
	1553	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	1554	<a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
	1555	<a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
	1556	<a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a><br/>
	1557	<a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	1558	<a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	1559	<a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
	1560	<a href="example.cpp.xml" target="_top">CppAD Examples and Tests</a><br/>
	1561	<a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	1562	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	1563	<a href="mul_level_ode.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	1564	<a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
	1565	<a href="mul_level.cpp.xml" target="_top">Multiple Tapes: Example and Test</a><br/>
	1566	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	1567	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	1568	<a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
	1569	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
	1570	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	1571	<a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
	1572	<a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
	1573	<a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
	1574	<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	1575	<a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a><br/>
	1576	<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	1577	<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	1578	<a href="lu_ratio.cpp.xml" target="_top">LuRatio: Example and Test</a><br/>
	1579	<a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
	1580	<a href="opt_val_hes.cpp.xml" target="_top">opt_val_hes: Example and Test</a><br/>
	1581	<a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
	1582	<a href="bender_quad.cpp.xml" target="_top">BenderQuad: Example and Test</a><br/>
	1583	<a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
	1584	<a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a><br/>
	1585	<a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
	1586	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	1587	<a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
	1588	<a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
	1589	<a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
	1590	<a href="cppad_vector.xml#Memory and Parallel Mode" target="_top">The CppAD::vector Template Class: Memory and Parallel Mode</a><br/>
	1591	<a href="ode_gear_control.cpp.xml" target="_top">OdeGearControl: Example and Test</a><br/>
	1592	<a href="ode_gear.cpp.xml" target="_top">OdeGear: Example and Test</a><br/>
	1593	<a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a><br/>
	1594	<a href="ode_err_control.cpp.xml" target="_top">OdeErrControl: Example and Test</a><br/>
	1595	<a href="rosen_34.cpp.xml" target="_top">Rosen34: Example and Test</a><br/>
	1596	<a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
	1597	<a href="runge45_2.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
	1598	<a href="runge45_1.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
	1599	<a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
	1600	<a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	1601	<a href="romberg_one.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	1602	<a href="lu_invert.cpp.xml" target="_top">LuInvert: Example and Test</a><br/>
	1603	<a href="lu_factor.cpp.xml" target="_top">LuFactor: Example and Test</a><br/>
	1604	<a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
	1605	<a href="lusolve.xml#Factor and Invert" target="_top">Compute Determinant and Solve Linear Equations: Factor and Invert</a><br/>
	1606	<a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
	1607	<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
	1608	<a href="poly.cpp.xml" target="_top">Polynomial Evaluation: Example and Test</a><br/>
	1609	<a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a><br/>
	1610	<a href="nan.cpp.xml" target="_top">nan: Example and Test</a><br/>
	1611	<a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a><br/>
	1612	<a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a><br/>
	1613	<a href="simplevector.xml#Element Constructor and Destructor" target="_top">Definition of a Simple Vector: Element Constructor and Destructor</a><br/>
	1614	<a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>
	1615	<a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a><br/>
	1616	<a href="time_test.cpp.xml" target="_top">time_test: Example and test</a><br/>
	1617	<a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a><br/>
	1618	<a href="speed_test.cpp.xml" target="_top">speed_test: Example and test</a><br/>
	1619	<a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
	1620	<a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
	1621	<a href="near_equal.cpp.xml" target="_top">NearEqual Function: Example and Test</a><br/>
	1622	<a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
	1623	<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
	1624	<a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
	1625	<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
	1626	<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
	1627	<a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
	1628	<a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
	1629	<a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
	1630	<a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
	1631	<a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
	1632	<a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>
	1633	<a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
	1634	<a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
	1635	<a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a><br/>
	1636	<a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a><br/>
	1637	<a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a><br/>
	1638	<a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
	1639	<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	1640	<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	1641	<a href="hessian.cpp.xml" target="_top">Hessian: Example and Test</a><br/>
	1642	<a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a><br/>
	1643	<a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a><br/>
	1644	<a href="jacobian.cpp.xml" target="_top">Jacobian: Example and Test</a><br/>
	1645	<a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
	1646	<a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>
	1647	<a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
	1648	<a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
	1649	<a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a><br/>
	1650	<a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a><br/>
	1651	<a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a><br/>
	1652	<a href="reverse_two.cpp.xml" target="_top">Second Order Reverse ModeExample and Test</a><br/>
	1653	<a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a><br/>
	1654	<a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	1655	<a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	1656	<a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
	1657	<a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
	1658	<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	1659	<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	1660	<a href="forward.cpp.xml" target="_top">Forward Mode: Example and Test</a><br/>
	1661	<a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a><br/>
	1662	<a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
	1663	<a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
	1664	<a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
	1665	<a href="fun_assign.cpp.xml" target="_top">ADFun Assignment: Example and Test</a><br/>
	1666	<a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
	1667	<a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a><br/>
	1668	<a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a><br/>
	1669	<a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
	1670	<a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
	1671	<a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
	1672	<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
	1673	<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	1674	<a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
	1675	<a href="vecad.xml#Speed and Memory" target="_top">AD Vectors that Record Index Operations: Speed and Memory</a><br/>
	1676	<a href="equal_op_seq.cpp.xml" target="_top">EqualOpSeq: Example and Test</a><br/>
	1677	<a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
	1678	<a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
	1679	<a href="bool_fun.cpp.xml" target="_top">AD Boolean Functions: Example and Test</a><br/>
	1680	<a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a><br/>
	1681	<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
	1682	<a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
	1683	<a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
	1684	<a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>
	1685	<a href="atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Test with x_1 Both a Variable and a Parameter</a><br/>
	1686	<a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
	1687	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	1688	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	1689	<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
	1690	<a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>
	1691	<a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	1692	<a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a><br/>
	1693	<a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
	1694	<a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
	1695	<a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
	1696	<a href="cond_exp.cpp.xml" target="_top">Conditional Expressions: Example and Test</a><br/>
	1697	<a href="limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a><br/>
	1698	<a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
	1699	<a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a><br/>
	1700	<a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a><br/>
	1701	<a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a><br/>
	1702	<a href="sign.cpp.xml" target="_top">Sign Function: Example and Test</a><br/>
	1703	<a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
	1704	<a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a><br/>
	1705	<a href="tan.cpp.xml" target="_top">The AD tan Function: Example and Test</a><br/>
	1706	<a href="sqrt.cpp.xml" target="_top">The AD sqrt Function: Example and Test</a><br/>
	1707	<a href="sinh.cpp.xml" target="_top">The AD sinh Function: Example and Test</a><br/>
	1708	<a href="sin.cpp.xml" target="_top">The AD sin Function: Example and Test</a><br/>
	1709	<a href="log10.cpp.xml" target="_top">The AD log10 Function: Example and Test</a><br/>
	1710	<a href="log.cpp.xml" target="_top">The AD log Function: Example and Test</a><br/>
	1711	<a href="exp.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
	1712	<a href="cosh.cpp.xml" target="_top">The AD cosh Function: Example and Test</a><br/>
	1713	<a href="cos.cpp.xml" target="_top">The AD cos Function: Example and Test</a><br/>
	1714	<a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
	1715	<a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>
	1716	<a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
	1717	<a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
	1718	<a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
	1719	<a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
	1720	<a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
	1721	<a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
	1722	<a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
	1723	<a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
	1724	<a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
	1725	<a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a><br/>
	1726	<a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a><br/>
	1727	<a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
	1728	<a href="advalued.xml" target="_top">AD Valued Operations and Functions</a><br/>
	1729	<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	1730	<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
	1731	<a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
	1732	<a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	1733	<a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	1734	<a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
	1735	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	1736	<a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a><br/>
	1737	<a href="ad_assign.cpp.xml" target="_top">AD Assignment: Example and Test</a><br/>
	1738	<a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a><br/>
	1739	<a href="exp_eps_cppad.xml" target="_top">exp_eps: CppAD Forward and Reverse Sweeps</a><br/>
	1740	<a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
	1741	<a href="exp_2_cppad.xml" target="_top">exp_2: CppAD Forward and Reverse Sweeps</a><br/>
	1742	<a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
	1743	<a href="installunix.xml#make.Examples and Tests" target="_top">Deprecated Unix Test and Installation: make.Examples and Tests</a><br/>
	1744	<a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a><br/>
	1745	<a href="cmake_check.xml" target="_top">Checking the CppAD Examples and Tests</a><br/>
	1746	<a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
	1747	<a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
	1748	<a href="ipopt_prefix.xml#Examples and Tests" target="_top">Including the cppad_ipopt Library and Tests: Examples and Tests</a><br/>
	1749	<a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>
	1750	<a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
	1751	<a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
	1752	<a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a><br/>
	1753	<a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
	1754	<a href="colpack.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
	1755	<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
	1756	<a href="adolc_prefix.xml" target="_top">Including the ADOL-C Examples and Tests</a><br/>
	1757	<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
	1758	another <a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
	1759	answers <a href="faq.xml" target="_top">Frequently Asked Questions and Answers</a><br/>
	1760	any <a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a><br/>
294	1761	order<b> </b>reverse<b> </b>mode <a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a><br/>
295		arithmetic<br/>
	1762	api <a href="deprecated.xml" target="_top">CppAD Deprecated API Features</a><br/>
	1763	<a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a><br/>
	1764	appendix <a href="appendix.xml" target="_top">Appendix</a><br/>
	1765	apply <a href="forwardtheory.xml#Standard Math Functions.Cases that Apply Recursion Above" target="_top">The Theory of Forward Mode: Standard Math Functions.Cases that Apply Recursion Above</a><br/>
	1766	approximation <a href="ipopt_nlp_ode_fast.xml#Trapezoidal Approximation" target="_top">ODE Fitting Using Fast Representation: Trapezoidal Approximation</a><br/>
	1767	<a href="ipopt_nlp_ode_simple.xml#Trapezoidal Approximation Constraint" target="_top">ODE Fitting Using Simple Representation: Trapezoidal Approximation Constraint</a><br/>
	1768	<a href="ipopt_nlp_ode_problem.xml#Trapezoidal Approximation" target="_top">An ODE Inverse Problem Example: Trapezoidal Approximation</a><br/>
	1769	<a href="ipopt_solve_ode_inverse.cpp.xml#Trapezoidal Approximation" target="_top">ODE Inverse Problem Definitions: Source Code: Trapezoidal Approximation</a><br/>
	1770	<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
	1771	<a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
	1772	<a href="exp_2.xml" target="_top">Second Order Exponential Approximation</a><br/>
	1773	arbitrary <a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
	1774	arccosine <a href="acosreverse.xml" target="_top">Arccosine Function Reverse Mode Theory</a><br/>
	1775	<a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a><br/>
	1776	arcsine <a href="asinreverse.xml" target="_top">Arcsine Function Reverse Mode Theory</a><br/>
	1777	<a href="asinforward.xml" target="_top">Arcsine Function Forward Taylor Polynomial Theory</a><br/>
	1778	arctangent <a href="atanreverse.xml" target="_top">Arctangent Function Reverse Mode Theory</a><br/>
	1779	<a href="atanforward.xml" target="_top">Arctangent Function Forward Taylor Polynomial Theory</a><br/>
	1780	are <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
	1781	<a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a><br/>
	1782	<a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
	1783	argument <a href="ipopt_nlp_ode_simple.xml#Argument Vector" target="_top">ODE Fitting Using Simple Representation: Argument Vector</a><br/>
	1784	<a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a><br/>
	1785	<a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a><br/>
	1786	arguments <a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
	1787	arguments<b>:</b> <a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
	1788	arithmetic <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
	1789	<a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
296	1790	AD<b> </b>operator <a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
297		array<br/>
	1791	array <a href="omp_delete_array.xml#array" target="_top">Return A Raw Array to The Available Memory for a Thread: array</a><br/>
	1792	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	1793	<a href="omp_create_array.xml#array" target="_top">Allocate Memory and Create A Raw Array: array</a><br/>
	1794	<a href="omp_create_array.xml" target="_top">Allocate Memory and Create A Raw Array</a><br/>
	1795	<a href="ta_delete_array.xml#array" target="_top">Deallocate An Array and Call Destructor for its Elements: array</a><br/>
	1796	<a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
	1797	<a href="ta_create_array.xml#array" target="_top">Allocate An Array and Call Default Constructor for its Elements: array</a><br/>
	1798	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	1799	<a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
298	1800	allocate <a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
299	1801	allocate <a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
300	1802	eigen<b> </b>example <a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
301	1803	tape<b> </b>index<b> </b>operation <a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
302		asin<br/>
	1804	arrays<b>:</b> <a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
	1805	as <a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
	1806	<a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	1807	<a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	1808	<a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a><br/>
	1809	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	1810	<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
	1811	asin <a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>
	1812	<a href="std_math_ad.xml#Derivatives.asin" target="_top">AD Standard Math Unary Functions: Derivatives.asin</a><br/>
303	1813	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
304	1814	AD<b> </b>example <a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>
305	1815	forward<b> </b>theory <a href="asinforward.xml" target="_top">Arcsine Function Forward Taylor Polynomial Theory</a><br/>
306	1816	reverse<b> </b>theory <a href="asinreverse.xml" target="_top">Arcsine Function Reverse Mode Theory</a><br/>
	1817	asked <a href="faq.xml" target="_top">Frequently Asked Questions and Answers</a><br/>
307	1818	assert<br/>
308	1819	error<b> </b>handler <a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
309	1820	error<b> </b>macro <a href="cppad_assert.xml" target="_top">CppAD Assertions During Execution</a><br/>
	1821	assertions <a href="cppad_assert.xml" target="_top">CppAD Assertions During Execution</a><br/>
310	1822	assign<br/>
311	1823	<b>*= </b>example <a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
312	1824	<b>+= </b>example <a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>

315	1827	AD<b> </b>object <a href="ad_assign.cpp.xml" target="_top">AD Assignment: Example and Test</a><br/>
316	1828	conditional <a href="condexp.xml" target="_top">AD Conditional Expressions</a><br/>
317	1829	to<b> </b>AD <a href="ad_assign.xml" target="_top">AD Assignment Operator</a><br/>
318		assignment<br/>
	1830	assignment <a href="faq.xml#Assignment and Independent" target="_top">Frequently Asked Questions and Answers: Assignment and Independent</a><br/>
	1831	<a href="cppad_vector.xml#Assignment" target="_top">The CppAD::vector Template Class: Assignment</a><br/>
	1832	<a href="simplevector.xml#Element Access.Assignment" target="_top">Definition of a Simple Vector: Element Access.Assignment</a><br/>
	1833	<a href="simplevector.xml#Assignment" target="_top">Definition of a Simple Vector: Assignment</a><br/>
	1834	<a href="numerictype.xml#Assignment" target="_top">Definition of a Numeric Type: Assignment</a><br/>
	1835	<a href="funconstruct.xml#Example.Assignment Operator" target="_top">Construct an ADFun Object and Stop Recording: Example.Assignment Operator</a><br/>
	1836	<a href="funconstruct.xml#Assignment Operator" target="_top">Construct an ADFun Object and Stop Recording: Assignment Operator</a><br/>
	1837	<a href="base_alloc.hpp.xml#Computed Assignment Macro" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Computed Assignment Macro</a><br/>
	1838	<a href="base_member.xml#Assignment Operators" target="_top">Required Base Class Member Functions: Assignment Operators</a><br/>
	1839	<a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
	1840	<a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
	1841	<a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
	1842	<a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
	1843	<a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
	1844	<a href="ad_assign.xml" target="_top">AD Assignment Operator</a><br/>
319	1845	AD <a href="ad_assign.xml" target="_top">AD Assignment Operator</a><br/>
320	1846	AD<b> </b>computed <a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
321	1847	AD<b> </b>computed<b> </b>add<b> </b>example <a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>

329	1855	operator <a href="faq.xml#Assignment and Independent" target="_top">Frequently Asked Questions and Answers: Assignment and Independent</a><br/>
330	1856	operator <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
331	1857	vector <a href="simplevector.xml#Assignment" target="_top">Definition of a Simple Vector: Assignment</a><br/>
332		atan<br/>
	1858	assignment<b>:</b> <a href="fun_assign.cpp.xml" target="_top">ADFun Assignment: Example and Test</a><br/>
	1859	<a href="ad_assign.cpp.xml" target="_top">AD Assignment: Example and Test</a><br/>
	1860	assignments <a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
	1861	assumption <a href="ad_output.xml#Assumption" target="_top">AD Output Stream Operator: Assumption</a><br/>
	1862	assumptions <a href="compare.xml#Assumptions" target="_top">AD Binary Comparison Operators: Assumptions</a><br/>
	1863	at <a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	1864	<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	1865	atan <a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
	1866	<a href="std_math_ad.xml#Derivatives.atan" target="_top">AD Standard Math Unary Functions: Derivatives.atan</a><br/>
333	1867	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
334	1868	AD<b> </b>example <a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
335	1869	forward<b> </b>theory <a href="atanforward.xml" target="_top">Arctangent Function Forward Taylor Polynomial Theory</a><br/>
336	1870	reverse<b> </b>theory <a href="atanreverse.xml" target="_top">Arctangent Function Reverse Mode Theory</a><br/>
337	1871	atan2 <a href="wishlist.xml#Atan2" target="_top">The CppAD Wish List: Atan2</a><br/>
	1872	<a href="wishlist.xml#Atan2" target="_top">The CppAD Wish List: Atan2</a><br/>
	1873	<a href="condexp.xml#Atan2" target="_top">AD Conditional Expressions: Atan2</a><br/>
	1874	<a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a><br/>
338	1875	AD <a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a><br/>
339	1876	AD<b> </b>example <a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a><br/>
340		atomic <a href="glossary.xml#Operation.Atomic" target="_top">Glossary: Operation.Atomic</a><br/>
	1877	atomic <a href="old_mat_mul.hpp.xml#CppAD User Atomic Callback Functions" target="_top">Define Matrix Multiply as a User Atomic Operation: CppAD User Atomic Callback Functions</a><br/>
	1878	<a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
	1879	<a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	1880	<a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	1881	<a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	1882	<a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	1883	<a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
	1884	<a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	1885	<a href="glossary.xml#Operation.Atomic" target="_top">Glossary: Operation.Atomic</a><br/>
	1886	<a href="speed_main.xml#option_list.atomic" target="_top">Running the Speed Test Program: option_list.atomic</a><br/>
	1887	<a href="optimize.xml#Atomic Functions" target="_top">Optimize an ADFun Object Tape: Atomic Functions</a><br/>
	1888	<a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a><br/>
	1889	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function</a><br/>
	1890	<a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>
	1891	<a href="atomic_hes_sparse.cpp.xml#Use Atomic Function" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Use Atomic Function</a><br/>
	1892	<a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
	1893	<a href="atomic_tangent.cpp.xml#Use Atomic Function" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function</a><br/>
	1894	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	1895	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function</a><br/>
	1896	<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
	1897	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function</a><br/>
	1898	<a href="atomic_get_started.cpp.xml#Use Atomic Function" target="_top">Getting Started with Atomic Operations: Example and Test: Use Atomic Function</a><br/>
	1899	<a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	1900	<a href="atomic_rev_sparse_hes.xml" target="_top">Atomic Reverse Hessian Sparsity Patterns</a><br/>
	1901	<a href="atomic_rev_sparse_jac.xml" target="_top">Atomic Reverse Jacobian Sparsity Patterns</a><br/>
	1902	<a href="atomic_for_sparse_jac.xml" target="_top">Atomic Forward Jacobian Sparsity Patterns</a><br/>
	1903	<a href="atomic_reverse.xml" target="_top">Atomic Reverse Mode</a><br/>
	1904	<a href="atomic_forward.xml" target="_top">Atomic Forward Mode</a><br/>
	1905	<a href="atomic_afun.xml" target="_top">Using AD Version of Atomic Function</a><br/>
	1906	<a href="atomic_option.xml" target="_top">Set Atomic Function Options</a><br/>
	1907	<a href="atomic_ctor.xml" target="_top">Atomic Function Constructor</a><br/>
	1908	<a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	1909	<a href="atomic.xml" target="_top">Atomic AD Functions</a><br/>
341	1910	AD<b> </b>inside <a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
342	1911	AD<b> </b>inside <a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
343	1912	ad<b> </b>function <a href="atomic.xml" target="_top">Atomic AD Functions</a><br/>

346	1915	free<b> </b>static <a href="atomic_base_clear.xml" target="_top">Free Static Variables</a><br/>
347	1916	function<b> </b>constructor <a href="atomic_ctor.xml" target="_top">Atomic Function Constructor</a><br/>
348	1917	get<b>_</b>started <a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	1918	hessian<b> </b>sparsity <a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
349	1919	matrix<b> </b>multiply<b> </b>example <a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>
350	1920	matrix<b> </b>multiply<b> </b>operation <a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a><br/>
351	1921	norm<b>_</b>sq <a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>

360	1930	use<b> </b>function <a href="atomic_afun.xml" target="_top">Using AD Version of Atomic Function</a><br/>
361	1931	user<b> </b>function <a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
362	1932	user<b> </b>function <a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	1933	atomic<b>_</b>base <a href="atomic_ctor.xml#atomic_base" target="_top">Atomic Function Constructor: atomic_base</a><br/>
363	1934	atomic<b>_</b>sparsity <a href="atomic_option.xml#atomic_sparsity" target="_top">Set Atomic Function Options: atomic_sparsity</a><br/>
	1935	<a href="atomic_option.xml#atomic_sparsity" target="_top">Set Atomic Function Options: atomic_sparsity</a><br/>
	1936	atomic<b>_</b>user <a href="atomic_ctor.xml#atomic_user" target="_top">Atomic Function Constructor: atomic_user</a><br/>
364	1937	automatic<br/>
365	1938	C<b> </b>differentiation <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
366		automatic<b> </b>differentiation <a href="cppad.xml" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms</a><br/>
367		available<br/>
	1939	automatic<b> </b>differentiation <a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1940	available <a href="memory_leak.xml#available" target="_top">Memory Leak Detection: available</a><br/>
	1941	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	1942	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	1943	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	1944	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	1945	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
368	1946	free <a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
369	1947	memory <a href="ta_return_memory.xml" target="_top">Return Memory to thread_alloc</a><br/>
370	1948	omp<b>_</b>alloc <a href="omp_available.xml#Deprecated" target="_top">Amount of Memory Available for Quick Use by a Thread: Deprecated</a><br/>
371	1949	thread<b>_</b>alloc <a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	1950	ax <a href="old_atomic.xml#afun.ax" target="_top">User Defined Atomic AD Functions: afun.ax</a><br/>
	1951	<a href="atomic_afun.xml#ax" target="_top">Using AD Version of Atomic Function: ax</a><br/>
	1952	<a href="checkpoint.xml#ax" target="_top">Checkpointing Functions: ax</a><br/>
	1953	<a href="discrete.xml#ax" target="_top">Discrete AD Functions: ax</a><br/>
	1954	ay <a href="old_atomic.xml#afun.ay" target="_top">User Defined Atomic AD Functions: afun.ay</a><br/>
	1955	<a href="atomic_afun.xml#ay" target="_top">Using AD Version of Atomic Function: ay</a><br/>
	1956	<a href="checkpoint.xml#ay" target="_top">Checkpointing Functions: ay</a><br/>
	1957	<a href="discrete.xml#ay" target="_top">Discrete AD Functions: ay</a><br/>
372	1958
373	1959	<b><big><a name="B">B</a></big></b>
374	1960	<br/>

385	1971	require <a href="ad.xml#Base Type Requirements" target="_top">AD Objects: Base Type Requirements</a><br/>
386	1972	BenderQuad <a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
387	1973	example <a href="bender_quad.cpp.xml" target="_top">BenderQuad: Example and Test</a><br/>
388		base <a href="glossary.xml#Base Type" target="_top">Glossary: Base Type</a><br/>
	1974	b <a href="rombergmul.xml#b" target="_top">Multi-dimensional Romberg Integration: b</a><br/>
	1975	<a href="rombergone.xml#b" target="_top">One DimensionalRomberg Integration: b</a><br/>
	1976	<a href="lusolve.xml#B" target="_top">Compute Determinant and Solve Linear Equations: B</a><br/>
	1977	<a href="nan.xml#hasnan.b" target="_top">Obtain Nan or Determine if a Value is Nan: hasnan.b</a><br/>
	1978	<a href="nan.xml#isnan.b" target="_top">Obtain Nan or Determine if a Value is Nan: isnan.b</a><br/>
	1979	<a href="nearequal.xml#b" target="_top">Determine if Two Values Are Nearly Equal: b</a><br/>
	1980	<a href="check_for_nan.xml#b" target="_top">Check an ADFun Object For Nan: b</a><br/>
	1981	<a href="vecad.xml#size_t Indexing.b" target="_top">AD Vectors that Record Index Operations: size_t Indexing.b</a><br/>
	1982	<a href="equalopseq.xml#b" target="_top">Check if Two Value are Identically Equal: b</a><br/>
	1983	<a href="parvar.xml#b" target="_top">Is an AD Object a Parameter or Variable: b</a><br/>
	1984	<a href="boolfun.xml#b" target="_top">AD Boolean Functions: b</a><br/>
	1985	<a href="nearequalext.xml#b" target="_top">Compare AD and Base Objects for Nearly Equal: b</a><br/>
	1986	<a href="compare.xml#b" target="_top">AD Binary Comparison Operators: b</a><br/>
	1987	<a href="value.xml#b" target="_top">Convert From an AD Type to its Base Type: b</a><br/>
	1988	background <a href="mul_level.xml#Background" target="_top">Using Multiple Levels of AD: Background</a><br/>
	1989	base <a href="old_atomic.xml#CPPAD_USER_ATOMIC.Base" target="_top">User Defined Atomic AD Functions: CPPAD_USER_ATOMIC.Base</a><br/>
	1990	<a href="glossary.xml#Base Type" target="_top">Glossary: Base Type</a><br/>
389	1991	<a href="glossary.xml#Base Function" target="_top">Glossary: Base Function</a><br/>
390	1992	<a href="glossary.xml#AD Levels Above Base" target="_top">Glossary: AD Levels Above Base</a><br/>
391	1993	<a href="glossary.xml#AD of Base" target="_top">Glossary: AD of Base</a><br/>
	1994	<a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
	1995	<a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
	1996	<a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
	1997	<a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
	1998	<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	1999	<a href="base_alloc.hpp.xml" target="_top">Example AD<Base> Where Base Constructor Allocates Memory</a><br/>
	2000	<a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a><br/>
	2001	<a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
	2002	<a href="base_ordered.xml" target="_top">Base Type Requirements for Ordered Comparisons</a><br/>
	2003	<a href="base_identical.xml" target="_top">Base Type Requirements for Identically Equal Comparisons</a><br/>
	2004	<a href="base_cond_exp.xml" target="_top">Base Type Requirements for Conditional Expressions</a><br/>
	2005	<a href="base_member.xml" target="_top">Required Base Class Member Functions</a><br/>
	2006	<a href="base_require.xml#Purpose.Standard Base Types" target="_top">AD<Base> Requirements for Base Type: Purpose.Standard Base Types</a><br/>
	2007	<a href="base_require.xml" target="_top">AD<Base> Requirements for Base Type</a><br/>
	2008	<a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a><br/>
	2009	<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
	2010	<a href="atomic_ctor.xml#atomic_base.Base" target="_top">Atomic Function Constructor: atomic_base.Base</a><br/>
	2011	<a href="checkpoint.xml#Base" target="_top">Checkpointing Functions: Base</a><br/>
	2012	<a href="discrete.xml#Base" target="_top">Discrete AD Functions: Base</a><br/>
	2013	<a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
	2014	<a href="compute_assign.xml#Base" target="_top">AD Computed Assignment Operators: Base</a><br/>
	2015	<a href="ad_binary.xml#Base" target="_top">AD Binary Arithmetic Operators: Base</a><br/>
	2016	<a href="unaryminus.xml#Base" target="_top">AD Unary Minus Operator: Base</a><br/>
	2017	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	2018	<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
	2019	<a href="ad.xml#Base Type Requirements" target="_top">AD Objects: Base Type Requirements</a><br/>
392	2020	CondExp<b> </b>require <a href="base_cond_exp.xml" target="_top">Base Type Requirements for Conditional Expressions</a><br/>
393	2021	EqualOpSeq<b> </b>require <a href="base_identical.xml#EqualOpSeq" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq</a><br/>
	2022	erf<b> </b>require <a href="base_std_math.xml#erf" target="_top">Base Type Requirements for Standard Math Functions: erf</a><br/>
394	2023	Integer<b> </b>require <a href="base_require.xml#Integer" target="_top">AD<Base> Requirements for Base Type: Integer</a><br/>
395	2024	identical<b> </b>require <a href="base_identical.xml#Identical" target="_top">Base Type Requirements for Identically Equal Comparisons: Identical</a><br/>
396	2025	isnan <a href="base_std_math.xml#isnan" target="_top">Base Type Requirements for Standard Math Functions: isnan</a><br/>

400	2029	sign<b> </b>require <a href="base_std_math.xml#sign" target="_top">Base Type Requirements for Standard Math Functions: sign</a><br/>
401	2030	type<b> </b>example <a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
402	2031	unary<b> </b>math <a href="base_std_math.xml#Unary Standard Math" target="_top">Base Type Requirements for Standard Math Functions: Unary Standard Math</a><br/>
403		binary<br/>
	2032	base<b>_</b>adolc<b>.</b>hpp <a href="mul_level_adolc_ode.cpp.xml#base_adolc.hpp" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: base_adolc.hpp</a><br/>
	2033	basevector <a href="opt_val_hes.xml#BaseVector" target="_top">Jacobian and Hessian of Optimal Values: BaseVector</a><br/>
	2034	bavector <a href="benderquad.xml#BAvector" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: BAvector</a><br/>
	2035	be <a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	2036	<a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
	2037	before <a href="printfor.xml#before" target="_top">Printing AD Values During Forward Mode: before</a><br/>
	2038	begin <a href="old_mat_mul.hpp.xml#Begin Source" target="_top">Define Matrix Multiply as a User Atomic Operation: Begin Source</a><br/>
	2039	bender<b>'</b>s <a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
	2040	benderquad <a href="wishlist.xml#BenderQuad" target="_top">The CppAD Wish List: BenderQuad</a><br/>
	2041	benderquad<b>:</b> <a href="bender_quad.cpp.xml" target="_top">BenderQuad: Example and Test</a><br/>
	2042	bibliography <a href="bib.xml" target="_top">Bibliography</a><br/>
	2043	binary <a href="reversetheory.xml#Binary Operators" target="_top">The Theory of Reverse Mode: Binary Operators</a><br/>
	2044	<a href="forwardtheory.xml#Binary Operators" target="_top">The Theory of Forward Mode: Binary Operators</a><br/>
	2045	<a href="base_alloc.hpp.xml#Binary Operator Macro" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Binary Operator Macro</a><br/>
	2046	<a href="base_member.xml#Binary Operators" target="_top">Required Base Class Member Functions: Binary Operators</a><br/>
	2047	<a href="boolfun.xml#Create Binary" target="_top">AD Boolean Functions: Create Binary</a><br/>
	2048	<a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
	2049	<a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
	2050	<a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
	2051	<a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
	2052	<a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
	2053	<a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
	2054	<a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
404	2055	AD<b> </b>bool <a href="boolfun.xml" target="_top">AD Boolean Functions</a><br/>
405	2056	AD<b> </b>compare<b> </b>operator <a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
406	2057	operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
407		bool<br/>
	2058	binary<b>_</b>name <a href="boolfun.xml#binary_name" target="_top">AD Boolean Functions: binary_name</a><br/>
	2059	black <a href="ipopt_nlp_ode_problem.xml#Black Box Method" target="_top">An ODE Inverse Problem Example: Black Box Method</a><br/>
	2060	bool <a href="base_member.xml#Bool Operators" target="_top">Required Base Class Member Functions: Bool Operators</a><br/>
	2061	<a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
408	2062	AD<b> </b>function <a href="boolfun.xml" target="_top">AD Boolean Functions</a><br/>
409	2063	CppAD<b>::</b>vector <a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
410	2064	bool<b>_</b>sparsity<b>_</b>enum <a href="atomic_option.xml#atomic_sparsity.bool_sparsity_enum" target="_top">Set Atomic Function Options: atomic_sparsity.bool_sparsity_enum</a><br/>
	2065	<a href="atomic_option.xml#atomic_sparsity.bool_sparsity_enum" target="_top">Set Atomic Function Options: atomic_sparsity.bool_sparsity_enum</a><br/>
411	2066	boolean <a href="glossary.xml#Sparsity Pattern.Vector of Boolean" target="_top">Glossary: Sparsity Pattern.Vector of Boolean</a><br/>
412		boost<br/>
	2067	<a href="base_alloc.hpp.xml#Boolean Operator Macro" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Boolean Operator Macro</a><br/>
	2068	<a href="bool_fun.cpp.xml" target="_top">AD Boolean Functions: Example and Test</a><br/>
	2069	<a href="boolfun.xml" target="_top">AD Boolean Functions</a><br/>
	2070	boolsparsity <a href="speed_main.xml#Sparsity Options.boolsparsity" target="_top">Running the Speed Test Program: Sparsity Options.boolsparsity</a><br/>
	2071	boost <a href="wishlist.xml#Software Guidelines.Boost" target="_top">The CppAD Wish List: Software Guidelines.Boost</a><br/>
	2072	<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
	2073	<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
	2074	<a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
	2075	<a href="cppad_testvector.xml#boost" target="_top">Choosing the CppAD Test Vector Template Class: boost</a><br/>
413	2076	multi<b>-</b>thread<b> </b>memory<b> </b>allocation <a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
414	2077	simple<b> </b>thread<b> </b>AD <a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
415		test<b> </b>vector <a href="installunix.xml#--with-testvector" target="_top">Unix Test and Installation: --with-testvector</a><br/>
416		unix <a href="installunix.xml#boost_dir" target="_top">Unix Test and Installation: boost_dir</a><br/>
	2078	test<b> </b>vector <a href="installunix.xml#--with-testvector" target="_top">Deprecated Unix Test and Installation: --with-testvector</a><br/>
	2079	unix <a href="installunix.xml#boost_dir" target="_top">Deprecated Unix Test and Installation: boost_dir</a><br/>
417	2080	vector <a href="cppad_testvector.xml#boost" target="_top">Choosing the CppAD Test Vector Template Class: boost</a><br/>
418	2081	boost<b> </b>thread<br/>
419	2082	example<b> </b>A<b>.</b>1<b>.</b>1c <a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
	2083	boost<b>::</b>numeric<b>::</b>ublas<b>::</b>vector <a href="test_vector.xml#boost::numeric::ublas::vector" target="_top">Choosing The Vector Testing Template Class: boost::numeric::ublas::vector</a><br/>
	2084	<a href="testvector.xml#boost::numeric::ublas::vector" target="_top">Using The CppAD Test Vector Template Class: boost::numeric::ublas::vector</a><br/>
	2085	boost<b>_</b>dir <a href="installunix.xml#boost_dir" target="_top">Deprecated Unix Test and Installation: boost_dir</a><br/>
	2086	both <a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
	2087	<a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
	2088	<a href="atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Test with x_1 Both a Variable and a Parameter</a><br/>
	2089	box <a href="ipopt_nlp_ode_problem.xml#Black Box Method" target="_top">An ODE Inverse Problem Example: Black Box Method</a><br/>
420	2090	bthread<br/>
421	2091	AD<b> </b>team <a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
422	2092	run<b> </b>tests <a href="thread_test.cpp.xml#Running Tests.threading" target="_top">Run Multi-Threading Examples and Speed Tests: Running Tests.threading</a><br/>
423		bug<br/>
	2093	bug <a href="team_pthread.cpp.xml#Bug in Cygwin" target="_top">Pthread Implementation of a Team of AD Threads: Bug in Cygwin</a><br/>
424	2094	cygwin<b> </b>pthread<b>_</b>exit <a href="team_pthread.cpp.xml#Bug in Cygwin" target="_top">Pthread Implementation of a Team of AD Threads: Bug in Cygwin</a><br/>
425	2095	gcc<b> </b>3<b>.</b>4<b>.</b>4 <a href="bugs.xml#gcc 3.4.4 -O2" target="_top">Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2</a><br/>
426		bugs<br/>
	2096	bugs <a href="bugs.xml" target="_top">Know Bugs and Problems Using CppAD</a><br/>
	2097	<a href="faq.xml#Bugs" target="_top">Frequently Asked Questions and Answers: Bugs</a><br/>
427	2098	reporting <a href="faq.xml#Bugs" target="_top">Frequently Asked Questions and Answers: Bugs</a><br/>
428	2099	using<b> </b>CppAD <a href="bugs.xml" target="_top">Know Bugs and Problems Using CppAD</a><br/>
	2100	build <a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
	2101	<a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
	2102	<a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
	2103	<a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
	2104	<a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
	2105	<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
	2106	<a href="cmake.xml#CMake Command.Build Directory" target="_top">Using CMake to Configure CppAD: CMake Command.Build Directory</a><br/>
	2107	bvector <a href="ipopt_solve.xml#Bvector" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Bvector</a><br/>
	2108	by <a href="det_by_minor_c.xml" target="_top">Compute Determinant using Expansion by Minors</a><br/>
	2109	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	2110	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	2111	<a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
	2112	<a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
	2113	<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
	2114	<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
	2115	<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
	2116	<a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
	2117	<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	2118	<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
	2119	<a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
	2120	<a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a><br/>
	2121	<a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
	2122	<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
	2123	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	2124	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	2125	<a href="exampleutility.xml" target="_top">Utility Routines used by CppAD Examples</a><br/>
	2126	<a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	2127	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	2128	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	2129	<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
	2130	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
429	2131
430	2132	<b><big><a name="C">C</a></big></b>
431	2133	<br/>

435	2137	compare<b> </b>speed<b> </b>with<b> </b>C<b>++</b> <a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
436	2138	interface<b> </b>to <a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
437	2139	C<b>++</b><br/>
438		algorithm<b> </b>derivative <a href="cppad.xml" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms</a><br/>
	2140	algorithm<b> </b>derivative <a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
439	2141	compare<b> </b>speed<b> </b>with<b> </b>C <a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
440	2142	numerical<b> </b>template<b> </b>library <a href="library.xml" target="_top">The CppAD General Purpose Library</a><br/>
441	2143	CheckNumericType <a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>

452	2154	CPPAD<b>_</b>ASSERT<b>_</b>UNKNOWN <a href="cppad_assert.xml#Restriction.Unknown" target="_top">CppAD Assertions During Execution: Restriction.Unknown</a><br/>
453	2155	CPPAD<b>_</b>BOOL<b>_</b>BINARY <a href="boolfun.xml#Create Binary" target="_top">AD Boolean Functions: Create Binary</a><br/>
454	2156	CPPAD<b>_</b>BOOL<b>_</b>UNARY <a href="boolfun.xml#Create Unary" target="_top">AD Boolean Functions: Create Unary</a><br/>
	2157	CPPAD<b>_</b>COMPILER<b>_</b>HAS<b>_</b>ERF <a href="erf.xml#Method.CPPAD_COMPILER_HAS_ERF" target="_top">The AD Error Function: Method.CPPAD_COMPILER_HAS_ERF</a><br/>
455	2158	CPPAD<b>_</b>COND<b>_</b>EXP<b>_</b>REL <a href="base_cond_exp.xml#CondExpRel" target="_top">Base Type Requirements for Conditional Expressions: CondExpRel</a><br/>
456	2159	CPPAD<b>_</b>DISCRETE<b>_</b>FUNCTION <a href="discrete.xml#Create AD Version" target="_top">Discrete AD Functions: Create AD Version</a><br/>
457	2160	CPPAD<b>_</b>MAX<b>_</b>NUM<b>_</b>THREADS <a href="multi_thread.xml#CPPAD_MAX_NUM_THREADS" target="_top">Using CppAD in a Multi-Threading Environment: CPPAD_MAX_NUM_THREADS</a><br/>

466	2169	CPPAD<b>_</b>TRACK<b>_</b>NEW<b>_</b>VEC <a href="tracknewdel.xml#TrackNewVec.Macro" target="_top">Routines That Track Use of New and Delete: TrackNewVec.Macro</a><br/>
467	2170	CPPAD<b>_</b>USER<b>_</b>ATOMIC <a href="old_atomic.xml#CPPAD_USER_ATOMIC" target="_top">User Defined Atomic AD Functions: CPPAD_USER_ATOMIC</a><br/>
468	2171	<a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
469		CppAD <a href="cppad.xml" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms</a><br/>
470		namespace <a href="cppad.xml#Namespace" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms: Namespace</a><br/>
	2172	CppAD <a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	2173	namespace <a href="cppad.xml#Namespace" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Namespace</a><br/>
471	2174	nonlinear<b> </b>programming <a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
472		preprocessor<b> </b>symbol <a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
473		unix<b> </b>install <a href="installunix.xml" target="_top">Unix Test and Installation</a><br/>
	2175	preprocessor<b> </b>symbol <a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
	2176	unix<b> </b>install <a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a><br/>
474	2177	CppAD<b>::</b>vector<br/>
475	2178	example <a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
476	2179	CppAD<b>::</b>vectorBool<br/>

481	2184	CppADTrackExtend <a href="tracknewdel.xml#TrackExtend.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackExtend.Previously Deprecated</a><br/>
482	2185	CppADTrackNewVec <a href="tracknewdel.xml#TrackCount.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackCount.Previously Deprecated</a><br/>
483	2186	<a href="tracknewdel.xml#TrackNewVec.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackNewVec.Previously Deprecated</a><br/>
484		c<b>++</b><br/>
	2187	c <a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
	2188	<a href="det_of_minor_c.xml#c" target="_top">Determinant of a Minor: c</a><br/>
	2189	<a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
	2190	<a href="det_of_minor.xml#c" target="_top">Determinant of a Minor: c</a><br/>
	2191	<a href="capacity_order.xml#c" target="_top">Controlling Taylor Coefficients Memory Allocation: c</a><br/>
	2192	<a href="comparechange.xml#c" target="_top">Comparison Changes During Zero Order Forward Mode: c</a><br/>
	2193	c<b>++</b> <a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
	2194	<a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
	2195	<a href="bib.xml#The C++ Programming Language" target="_top">Bibliography: The C++ Programming Language</a><br/>
	2196	<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	2197	<a href="library.xml#C++ Concepts" target="_top">The CppAD General Purpose Library: C++ Concepts</a><br/>
	2198	<a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
485	2199	compile<b> </b>flags <a href="cmake.xml#cppad_cxx_flags" target="_top">Using CMake to Configure CppAD: cppad_cxx_flags</a><br/>
486		calculate<br/>
487		forward<b> </b>mode <a href="forwardany.xml" target="_top">Any Order Forward Mode</a><br/>
488		capacity<br/>
489		Forward <a href="capacity_taylor.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
490		capacity<b>_</b>taylor <a href="capacity_taylor.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
491		example <a href="capacity_taylor.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	2200	c<b>:</b> <a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
	2201	calculating <a href="sparse.xml" target="_top">Calculating Sparsity Patterns</a><br/>
	2202	calculation <a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
	2203	calculations <a href="theory.xml" target="_top">The Theory of Derivative Calculations</a><br/>
	2204	<a href="mul_level.xml#General Procedure.Inner Function Calculations" target="_top">Using Multiple Levels of AD: General Procedure.Inner Function Calculations</a><br/>
	2205	<a href="parallel_ad.xml" target="_top">Enable AD Calculations During Parallel Mode</a><br/>
	2206	<a href="colpack_prefix.xml" target="_top">Including the ColPack Sparsity Calculations</a><br/>
	2207	call <a href="old_mat_mul.hpp.xml#Extra Call Information" target="_top">Define Matrix Multiply as a User Atomic Operation: Extra Call Information</a><br/>
	2208	<a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
	2209	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	2210	<a href="errorhandler.xml#Call" target="_top">Replacing the CppAD Error Handler: Call</a><br/>
	2211	callback <a href="old_mat_mul.hpp.xml#CppAD User Atomic Callback Functions" target="_top">Define Matrix Multiply as a User Atomic Operation: CppAD User Atomic Callback Functions</a><br/>
	2212	<a href="old_atomic.xml#Syntax.Callback Routines" target="_top">User Defined Atomic AD Functions: Syntax.Callback Routines</a><br/>
	2213	can <a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	2214	<a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
	2215	cap<b>_</b>bytes <a href="omp_get_memory.xml#cap_bytes" target="_top">Get At Least A Specified Amount of Memory: cap_bytes</a><br/>
	2216	<a href="ta_get_memory.xml#cap_bytes" target="_top">Get At Least A Specified Amount of Memory: cap_bytes</a><br/>
	2217	capacity <a href="cppad_vector.xml#capacity" target="_top">The CppAD::vector Template Class: capacity</a><br/>
	2218	Forward <a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
	2219	capacity<b>_</b>order <a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
	2220	<a href="size_order.xml#capacity_order" target="_top">Number Taylor Coefficient Orders Currently Stored: capacity_order</a><br/>
	2221	example <a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	2222	capacity<b>_</b>taylor <a href="fundeprecated.xml#capacity_taylor" target="_top">ADFun Object Deprecated Member Functions: capacity_taylor</a><br/>
	2223	ADFun <a href="fundeprecated.xml#capacity_taylor" target="_top">ADFun Object Deprecated Member Functions: capacity_taylor</a><br/>
	2224	case <a href="old_usead_1.cpp.xml#Simple Case" target="_top">Using AD to Compute Atomic Function Derivatives: Simple Case</a><br/>
	2225	<a href="forward_two.xml#Special Case" target="_top">Second Order Forward Mode: Derivative Values: Special Case</a><br/>
	2226	<a href="forward_one.xml#Special Case" target="_top">First Order Forward Mode: Derivative Values: Special Case</a><br/>
	2227	<a href="forward_zero.xml#Special Case" target="_top">Zero Order Forward Mode: Function Values: Special Case</a><br/>
	2228	<a href="base_identical.xml#EqualOpSeq.The Simple Case" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq.The Simple Case</a><br/>
	2229	<a href="atomic_base.xml#General Case" target="_top">User Defined Atomic AD Functions: General Case</a><br/>
	2230	case<b>:</b> <a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a><br/>
	2231	cases <a href="forwardtheory.xml#Standard Math Functions.Special Cases" target="_top">The Theory of Forward Mode: Standard Math Functions.Special Cases</a><br/>
	2232	<a href="forwardtheory.xml#Standard Math Functions.Cases that Apply Recursion Above" target="_top">The Theory of Forward Mode: Standard Math Functions.Cases that Apply Recursion Above</a><br/>
	2233	<a href="base_identical.xml#EqualOpSeq.More Complicated Cases" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq.More Complicated Cases</a><br/>
492	2234	central<b> </b>difference <a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
493		change<br/>
	2235	change <a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
494	2236	constant <a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
495		check<br/>
	2237	changes <a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a><br/>
	2238	<a href="whats_new_04.xml" target="_top">Changes and Additions to CppAD During 2004</a><br/>
	2239	<a href="whats_new_05.xml" target="_top">Changes and Additions to CppAD During 2005</a><br/>
	2240	<a href="whats_new_06.xml" target="_top">Changes and Additions to CppAD During 2006</a><br/>
	2241	<a href="whats_new_07.xml" target="_top">Changes and Additions to CppAD During 2007</a><br/>
	2242	<a href="whats_new_08.xml" target="_top">Changes and Additions to CppAD During 2008</a><br/>
	2243	<a href="whats_new_09.xml" target="_top">Changes and Additions to CppAD During 2009</a><br/>
	2244	<a href="whats_new_10.xml" target="_top">Changes and Additions to CppAD During 2010</a><br/>
	2245	<a href="whats_new_11.xml" target="_top">Changes and Additions to CppAD During 2011</a><br/>
	2246	<a href="whats_new_12.xml" target="_top">CppAD Changes and Additions During 2012</a><br/>
	2247	<a href="whats_new_13.xml" target="_top">CppAD Changes and Additions During 2013</a><br/>
	2248	<a href="whats_new_14.xml" target="_top">CppAD Changes and Additions During 2014</a><br/>
	2249	<a href="whats_new.xml" target="_top">Changes and Additions to CppAD</a><br/>
	2250	<a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
	2251	check <a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
	2252	<a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
	2253	<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	2254	<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
	2255	<a href="cppad_vector.xml#Assignment.Check Size" target="_top">The CppAD::vector Template Class: Assignment.Check Size</a><br/>
	2256	<a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a><br/>
	2257	<a href="checknumerictype.xml" target="_top">Check NumericType Class Concept</a><br/>
	2258	<a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan</a><br/>
	2259	<a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
	2260	<a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
	2261	<a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
	2262	<a href="cmake_check.xml#Check All" target="_top">Checking the CppAD Examples and Tests: Check All</a><br/>
	2263	<a href="install.xml#Instructions.Step 3: Check" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 3: Check</a><br/>
496	2264	ADFun <a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
497	2265	determinant<b> </b>correct <a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
498	2266	determinant<b> </b>correct <a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>

502	2270	simple<b> </b>vector <a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a><br/>
503	2271	check<b>_</b>for<b>_</b>nan<br/>
504	2272	example <a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
	2273	checking <a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
	2274	<a href="optimize.xml#Checking Optimization" target="_top">Optimize an ADFun Object Tape: Checking Optimization</a><br/>
	2275	<a href="cmake_check.xml" target="_top">Checking the CppAD Examples and Tests</a><br/>
	2276	checknumerictype <a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>
505	2277	checkpoint <a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
506	2278	<a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
507	2279	<a href="wishlist.xml#Checkpointing" target="_top">The CppAD Wish List: Checkpointing</a><br/>
508	2280	example <a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a><br/>
509	2281	function <a href="checkpoint.xml" target="_top">Checkpointing Functions</a><br/>
510		class<br/>
	2282	checkpointing <a href="wishlist.xml#Checkpointing" target="_top">The CppAD Wish List: Checkpointing</a><br/>
	2283	<a href="checkpoint.xml" target="_top">Checkpointing Functions</a><br/>
	2284	checkpointing<b>:</b> <a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a><br/>
	2285	checksimplevector <a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a><br/>
	2286	<a href="parallel_ad.xml#CheckSimpleVector" target="_top">Enable AD Calculations During Parallel Mode: CheckSimpleVector</a><br/>
	2287	choosing <a href="test_vector.xml" target="_top">Choosing The Vector Testing Template Class</a><br/>
	2288	<a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a><br/>
	2289	class <a href="test_vector.xml" target="_top">Choosing The Vector Testing Template Class</a><br/>
	2290	<a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a><br/>
	2291	<a href="example.xml#The CppAD Test Vector Template Class" target="_top">Examples: The CppAD Test Vector Template Class</a><br/>
	2292	<a href="cppad_vector.xml" target="_top">The CppAD::vector Template Class</a><br/>
	2293	<a href="simplevector.xml#Template Class Requirements" target="_top">Definition of a Simple Vector: Template Class Requirements</a><br/>
	2294	<a href="checknumerictype.xml" target="_top">Check NumericType Class Concept</a><br/>
	2295	<a href="base_alloc.hpp.xml#Class Definition" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Class Definition</a><br/>
	2296	<a href="base_member.xml" target="_top">Required Base Class Member Functions</a><br/>
	2297	<a href="atomic_matrix_mul.hpp.xml#End Class Definition" target="_top">Matrix Multiply as an Atomic Operation: End Class Definition</a><br/>
	2298	<a href="atomic_matrix_mul.hpp.xml#Start Class Definition" target="_top">Matrix Multiply as an Atomic Operation: Start Class Definition</a><br/>
	2299	<a href="atomic_mat_mul.cpp.xml#Class Definition" target="_top">User Atomic Matrix Multiply: Example and Test: Class Definition</a><br/>
	2300	<a href="atomic_hes_sparse.cpp.xml#Start Class Definition" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Start Class Definition</a><br/>
	2301	<a href="atomic_tangent.cpp.xml#End Class Definition" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: End Class Definition</a><br/>
	2302	<a href="atomic_tangent.cpp.xml#Start Class Definition" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Start Class Definition</a><br/>
	2303	<a href="atomic_reciprocal.cpp.xml#End Class Definition" target="_top">Reciprocal as an Atomic Operation: Example and Test: End Class Definition</a><br/>
	2304	<a href="atomic_reciprocal.cpp.xml#Start Class Definition" target="_top">Reciprocal as an Atomic Operation: Example and Test: Start Class Definition</a><br/>
	2305	<a href="atomic_norm_sq.cpp.xml#End Class Definition" target="_top">Euclidean Norm Squared: Example and Test: End Class Definition</a><br/>
	2306	<a href="atomic_norm_sq.cpp.xml#Start Class Definition" target="_top">Euclidean Norm Squared: Example and Test: Start Class Definition</a><br/>
	2307	<a href="atomic_get_started.cpp.xml#End Class Definition" target="_top">Getting Started with Atomic Operations: Example and Test: End Class Definition</a><br/>
	2308	<a href="atomic_get_started.cpp.xml#Start Class Definition" target="_top">Getting Started with Atomic Operations: Example and Test: Start Class Definition</a><br/>
	2309	<a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a><br/>
511	2310	simple<b> </b>vector <a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
512	2311	template<b> </b>CppAD<b> </b>vector <a href="cppad_vector.xml" target="_top">The CppAD::vector Template Class</a><br/>
513		clear<br/>
	2312	class<b>:</b> <a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
	2313	<a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
	2314	<a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a><br/>
	2315	clear <a href="old_atomic.xml#clear" target="_top">User Defined Atomic AD Functions: clear</a><br/>
	2316	<a href="cppad_vector.xml#clear" target="_top">The CppAD::vector Template Class: clear</a><br/>
	2317	<a href="checkpoint.xml#clear" target="_top">Checkpointing Functions: clear</a><br/>
514	2318	atomic<b> </b>static <a href="atomic_base_clear.xml" target="_top">Free Static Variables</a><br/>
515		cmake <a href="cmake.xml#The CMake Program" target="_top">Using CMake to Configure CppAD: The CMake Program</a><br/>
	2319	cmake <a href="cmake.xml#CMake Command" target="_top">Using CMake to Configure CppAD: CMake Command</a><br/>
	2320	<a href="cmake.xml#The CMake Program" target="_top">Using CMake to Configure CppAD: The CMake Program</a><br/>
	2321	<a href="cmake.xml#The CMake Program" target="_top">Using CMake to Configure CppAD: The CMake Program</a><br/>
	2322	<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
	2323	<a href="install.xml#Instructions.Step 2: Cmake" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 2: Cmake</a><br/>
516	2324	command <a href="cmake.xml#CMake Command" target="_top">Using CMake to Configure CppAD: CMake Command</a><br/>
517	2325	configure<b> </b>cppad <a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
	2326	cmake<b>_</b>install<b>_</b>datadir <a href="cmake.xml#cmake_install_datadir" target="_top">Using CMake to Configure CppAD: cmake_install_datadir</a><br/>
	2327	cmake<b>_</b>install<b>_</b>docdir <a href="cmake.xml#cmake_install_docdir" target="_top">Using CMake to Configure CppAD: cmake_install_docdir</a><br/>
	2328	cmake<b>_</b>install<b>_</b>includedirs <a href="cmake.xml#cmake_install_includedirs" target="_top">Using CMake to Configure CppAD: cmake_install_includedirs</a><br/>
	2329	cmake<b>_</b>install<b>_</b>libdirs <a href="cmake.xml#cmake_install_libdirs" target="_top">Using CMake to Configure CppAD: cmake_install_libdirs</a><br/>
	2330	cmake<b>_</b>install<b>_</b>postfix <a href="cmake.xml#cmake_install_postfix" target="_top">Using CMake to Configure CppAD: cmake_install_postfix</a><br/>
	2331	cmake<b>_</b>install<b>_</b>prefix <a href="cmake.xml#cmake_install_prefix" target="_top">Using CMake to Configure CppAD: cmake_install_prefix</a><br/>
	2332	code <a href="main_compare_c.xml#Source Code" target="_top">Main Program For Comparing C and C++ Speed: Source Code</a><br/>
	2333	<a href="time_det_by_minor_c.xml#Source Code" target="_top">Determine Amount of Time to Execute det_by_minor: Source Code</a><br/>
	2334	<a href="elapsed_seconds_c.xml#Source Code" target="_top">Returns Elapsed Number of Seconds: Source Code</a><br/>
	2335	<a href="repeat_det_by_minor_c.xml#Source Code" target="_top">Repeat det_by_minor Routine A Specified Number of Times: Source Code</a><br/>
	2336	<a href="correct_det_by_minor_c.xml#Source Code" target="_top">Correctness Test of det_by_minor Routine: Source Code</a><br/>
	2337	<a href="uniform_01_c.xml#Source Code" target="_top">Simulate a [0,1] Uniform Random Variate: Source Code</a><br/>
	2338	<a href="det_by_minor_c.xml#Source Code" target="_top">Compute Determinant using Expansion by Minors: Source Code</a><br/>
	2339	<a href="det_of_minor_c.xml#Source Code" target="_top">Determinant of a Minor: Source Code</a><br/>
	2340	<a href="ipopt_nlp_ode_problem.hpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	2341	<a href="uniform_01.xml#Source Code" target="_top">Simulate a [0,1] Uniform Random Variate: Source Code</a><br/>
	2342	<a href="sparse_hes_fun.xml#Source Code" target="_top">Evaluate a Function That Has a Sparse Hessian: Source Code</a><br/>
	2343	<a href="sparse_jac_fun.xml#Source Code" target="_top">Evaluate a Function That Has a Sparse Jacobian: Source Code</a><br/>
	2344	<a href="ode_evaluate.xml#Source Code" target="_top">Evaluate a Function Defined in Terms of an ODE: Source Code</a><br/>
	2345	<a href="mat_sum_sq.xml#Source Code" target="_top">Sum Elements of a Matrix Times Itself: Source Code</a><br/>
	2346	<a href="det_grad_33.xml#Source Code" target="_top">Check Gradient of Determinant of 3 by 3 matrix: Source Code</a><br/>
	2347	<a href="det_33.xml#Source Code" target="_top">Check Determinant of 3 by 3 matrix: Source Code</a><br/>
	2348	<a href="det_by_minor.xml#Source Code" target="_top">Determinant Using Expansion by Minors: Source Code</a><br/>
	2349	<a href="det_of_minor.xml#Source Code" target="_top">Determinant of a Minor: Source Code</a><br/>
	2350	<a href="det_by_lu.xml#Source Code" target="_top">Determinant Using Expansion by Lu Factorization: Source Code</a><br/>
	2351	<a href="speed_utility.xml#Source Code" target="_top">Speed Testing Utilities: Source Code</a><br/>
	2352	<a href="eigen_plugin.hpp.xml" target="_top">Source Code for eigen_plugin.hpp</a><br/>
	2353	<a href="ipopt_solve_ode_inverse.cpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	2354	<a href="odegearcontrol.xml#Source Code" target="_top">An Error Controller for Gear's Ode Solvers: Source Code</a><br/>
	2355	<a href="odegear.xml#Source Code" target="_top">An Arbitrary Order Gear Method: Source Code</a><br/>
	2356	<a href="odeerrcontrol.xml#Source Code" target="_top">An Error Controller for ODE Solvers: Source Code</a><br/>
	2357	<a href="rosen34.xml#Source Code" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Source Code</a><br/>
	2358	<a href="runge45.xml#Source Code" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Source Code</a><br/>
	2359	<a href="rombergmul.xml#Source Code" target="_top">Multi-dimensional Romberg Integration: Source Code</a><br/>
	2360	<a href="rombergone.xml#Source Code" target="_top">One DimensionalRomberg Integration: Source Code</a><br/>
	2361	<a href="team_example.cpp.xml#Source Code" target="_top">Using a Team of AD Threads: Example and Test: Source Code</a><br/>
	2362	<a href="simple_ad_pthread.cpp.xml#Source Code" target="_top">A Simple pthread AD: Example and Test: Source Code</a><br/>
	2363	<a href="simple_ad_bthread.cpp.xml#Source Code" target="_top">A Simple Boost Threading AD: Example and Test: Source Code</a><br/>
	2364	<a href="simple_ad_openmp.cpp.xml#Source Code" target="_top">A Simple OpenMP AD: Example and Test: Source Code</a><br/>
	2365	<a href="a11c_pthread.cpp.xml#Source Code" target="_top">A Simple Parallel Pthread Example and Test: Source Code</a><br/>
	2366	<a href="a11c_bthread.cpp.xml#Source Code" target="_top">A Simple Boost Thread Example and Test: Source Code</a><br/>
	2367	<a href="a11c_openmp.cpp.xml#Source Code" target="_top">A Simple OpenMP Example and Test: Source Code</a><br/>
	2368	<a href="print_for_cout.cpp.xml#Source Code" target="_top">Printing During Forward Mode: Example and Test: Source Code</a><br/>
	2369	<a href="exp_eps_for0.xml#Operation Sequence.Code" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence.Code</a><br/>
	2370	<a href="exp_2_for0.xml#Operation Sequence.Code" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Operation Sequence.Code</a><br/>
	2371	<a href="download.xml" target="_top">Download The CppAD Source Code</a><br/>
518	2372	coefficient <a href="glossary.xml#Taylor Coefficient" target="_top">Glossary: Taylor Coefficient</a><br/>
519		colpack<br/>
	2373	<a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	2374	<a href="size_order.xml" target="_top">Number Taylor Coefficient Orders Currently Stored</a><br/>
	2375	coefficients <a href="erf_forward.xml#Taylor Coefficients Recursion" target="_top">Error Function Forward Taylor Polynomial Theory: Taylor Coefficients Recursion</a><br/>
	2376	<a href="tan_forward.xml#Taylor Coefficients Recursion" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory: Taylor Coefficients Recursion</a><br/>
	2377	<a href="forwardtheory.xml#Standard Math Functions.Taylor Coefficients Recursion Formula" target="_top">The Theory of Forward Mode: Standard Math Functions.Taylor Coefficients Recursion Formula</a><br/>
	2378	<a href="reverse_three.cpp.xml#Taylor Coefficients" target="_top">Third Order Reverse Mode: Example and Test: Taylor Coefficients</a><br/>
	2379	<a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
	2380	<a href="funconstruct.xml#Assignment Operator.Taylor Coefficients" target="_top">Construct an ADFun Object and Stop Recording: Assignment Operator.Taylor Coefficients</a><br/>
	2381	col <a href="sparse_hes_fun.xml#col" target="_top">Evaluate a Function That Has a Sparse Hessian: col</a><br/>
	2382	<a href="sparse_jac_fun.xml#col" target="_top">Evaluate a Function That Has a Sparse Jacobian: col</a><br/>
	2383	<a href="link_sparse_jacobian.xml#col" target="_top">Speed Testing Sparse Jacobian: col</a><br/>
	2384	<a href="link_sparse_hessian.xml#col" target="_top">Speed Testing Sparse Hessian: col</a><br/>
	2385	<a href="sparse_hessian.xml#row, col" target="_top">Sparse Hessian: Easy Driver: row, col</a><br/>
	2386	<a href="sparse_jacobian.xml#row, col" target="_top">Sparse Jacobian: Easy Driver: row, col</a><br/>
	2387	color<b>_</b>method <a href="sparse_jacobian.xml#work.color_method" target="_top">Sparse Jacobian: Easy Driver: work.color_method</a><br/>
	2388	colpack <a href="speed_main.xml#Sparsity Options.colpack" target="_top">Running the Speed Test Program: Sparsity Options.colpack</a><br/>
	2389	<a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
	2390	<a href="colpack_prefix.xml" target="_top">Including the ColPack Sparsity Calculations</a><br/>
520	2391	download<b> </b>and<b> </b>install <a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
	2392	get <a href="colpack_prefix.xml#get_colpack" target="_top">Including the ColPack Sparsity Calculations: get_colpack</a><br/>
	2393	prefix <a href="colpack_prefix.xml#colpack_prefix" target="_top">Including the ColPack Sparsity Calculations: colpack_prefix</a><br/>
	2394	sparsity <a href="colpack_prefix.xml" target="_top">Including the ColPack Sparsity Calculations</a><br/>
	2395	colpack<b>:</b> <a href="colpack.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
	2396	colpack<b>_</b>prefix <a href="colpack_prefix.xml#colpack_prefix" target="_top">Including the ColPack Sparsity Calculations: colpack_prefix</a><br/>
521	2397	combine<br/>
522	2398	harmonic <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
523	2399	multi<b>_</b>newton <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
524		compare<br/>
	2400	command <a href="cmake.xml#CMake Command" target="_top">Using CMake to Configure CppAD: CMake Command</a><br/>
	2401	commands <a href="include_deprecated.xml#Linking New Files to Deprecated Commands" target="_top">Deprecated Include Files: Linking New Files to Deprecated Commands</a><br/>
	2402	compare <a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
	2403	<a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a><br/>
	2404	<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
525	2405	AD<b> </b>binary<b> </b>operator <a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
526	2406	AD<b> </b>example <a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
527	2407	change <a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
528	2408	speed<b> </b>C<b> </b>and<b> </b>C<b>++</b> <a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
	2409	comparechange <a href="faq.xml#CompareChange" target="_top">Frequently Asked Questions and Answers: CompareChange</a><br/>
	2410	<a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
	2411	compareop <a href="base_cond_exp.xml#CompareOp" target="_top">Base Type Requirements for Conditional Expressions: CompareOp</a><br/>
	2412	comparing <a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
	2413	comparison <a href="optimize.xml#Comparison Operators" target="_top">Optimize an ADFun Object Tape: Comparison Operators</a><br/>
	2414	<a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
	2415	<a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
	2416	<a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
	2417	comparisons <a href="base_ordered.xml" target="_top">Base Type Requirements for Ordered Comparisons</a><br/>
	2418	<a href="base_identical.xml" target="_top">Base Type Requirements for Identically Equal Comparisons</a><br/>
	2419	<a href="exp_eps_for0.xml#Comparisons" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Comparisons</a><br/>
529	2420	compile<br/>
530	2421	c<b>++ </b>flags <a href="cmake.xml#cppad_cxx_flags" target="_top">Using CMake to Configure CppAD: cppad_cxx_flags</a><br/>
531		OpenMP<b> </b>flags <a href="installunix.xml#openmp_flags" target="_top">Unix Test and Installation: openmp_flags</a><br/>
	2422	OpenMP<b> </b>flags <a href="installunix.xml#openmp_flags" target="_top">Deprecated Unix Test and Installation: openmp_flags</a><br/>
532	2423	speed<b> </b>AD<b><</b>double<b>></b> <a href="wishlist.xml#Library" target="_top">The CppAD Wish List: Library</a><br/>
533		unix<b> </b>flags <a href="installunix.xml#cxx_flags" target="_top">Unix Test and Installation: cxx_flags</a><br/>
534		complex<br/>
	2424	unix<b> </b>flags <a href="installunix.xml#cxx_flags" target="_top">Deprecated Unix Test and Installation: cxx_flags</a><br/>
	2425	complex <a href="faq.xml#Complex Types" target="_top">Frequently Asked Questions and Answers: Complex Types</a><br/>
	2426	<a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
	2427	<a href="not_complex_ad.cpp.xml#Not Complex Differentiable" target="_top">Not Complex Differentiable: Example and Test: Not Complex Differentiable</a><br/>
	2428	<a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
	2429	<a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
	2430	<a href="sign.xml#Complex Types" target="_top">Sign Function: Complex Types</a><br/>
	2431	<a href="abs.xml#Complex Types" target="_top">AD Absolute Value Function: Complex Types</a><br/>
	2432	<a href="integer.xml#x.Complex Types" target="_top">Convert From AD to Integer: x.Complex Types</a><br/>
535	2433	double<b> </b>Base <a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
536	2434	faq <a href="faq.xml#Complex Types" target="_top">Frequently Asked Questions and Answers: Complex Types</a><br/>
537	2435	LuSolve <a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
538	2436	polynomial <a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
539	2437	polynomial <a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
540		computed<br/>
	2438	complicated <a href="base_identical.xml#EqualOpSeq.More Complicated Cases" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq.More Complicated Cases</a><br/>
	2439	compressed <a href="download.xml#Compressed Tar File" target="_top">Download The CppAD Source Code: Compressed Tar File</a><br/>
	2440	compute <a href="det_by_minor_c.xml" target="_top">Compute Determinant using Expansion by Minors</a><br/>
	2441	<a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	2442	<a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	2443	<a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
	2444	<a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
	2445	<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
	2446	<a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
	2447	computed <a href="base_alloc.hpp.xml#Computed Assignment Macro" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Computed Assignment Macro</a><br/>
	2448	<a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
	2449	<a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
	2450	<a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
	2451	<a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
	2452	<a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
	2453	<a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
541	2454	<b>*= </b>example <a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
542	2455	<b>+= </b>example <a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
543	2456	<b>-= </b>example <a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>

547	2460	AD<b> </b>assignment<b> </b>divide<b> </b>example <a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
548	2461	AD<b> </b>assignment<b> </b>multiply<b> </b>example <a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
549	2462	AD<b> </b>assignment<b> </b>subtract<b> </b>example <a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
550		concept<br/>
	2463	computing <a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
	2464	<a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
	2465	concept <a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a><br/>
	2466	<a href="checknumerictype.xml" target="_top">Check NumericType Class Concept</a><br/>
551	2467	C<b>++</b> <a href="library.xml#C++ Concepts" target="_top">The CppAD General Purpose Library: C++ Concepts</a><br/>
552	2468	check<b> </b>numeric <a href="checknumerictype.xml" target="_top">Check NumericType Class Concept</a><br/>
553	2469	check<b> </b>simple<b> </b>vector <a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a><br/>
554		condition<br/>
	2470	concepts <a href="library.xml#C++ Concepts" target="_top">The CppAD General Purpose Library: C++ Concepts</a><br/>
	2471	condexpop <a href="base_complex.hpp.xml#CondExpOp" target="_top">Enable use of AD<Base> where Base is std::complex<double>: CondExpOp</a><br/>
	2472	<a href="base_double.hpp.xml#CondExpOp" target="_top">Enable use of AD<Base> where Base is double: CondExpOp</a><br/>
	2473	<a href="base_float.hpp.xml#CondExpOp" target="_top">Enable use of AD<Base> where Base is float: CondExpOp</a><br/>
	2474	<a href="base_adolc.hpp.xml#CondExpOp" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: CondExpOp</a><br/>
	2475	<a href="base_alloc.hpp.xml#CondExpOp" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: CondExpOp</a><br/>
	2476	condexprel <a href="base_complex.hpp.xml#CondExpRel" target="_top">Enable use of AD<Base> where Base is std::complex<double>: CondExpRel</a><br/>
	2477	<a href="base_double.hpp.xml#CondExpRel" target="_top">Enable use of AD<Base> where Base is double: CondExpRel</a><br/>
	2478	<a href="base_float.hpp.xml#CondExpRel" target="_top">Enable use of AD<Base> where Base is float: CondExpRel</a><br/>
	2479	<a href="base_alloc.hpp.xml#CondExpRel" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: CondExpRel</a><br/>
	2480	<a href="base_cond_exp.xml#CondExpRel" target="_top">Base Type Requirements for Conditional Expressions: CondExpRel</a><br/>
	2481	condexptemplate <a href="base_cond_exp.xml#CondExpTemplate" target="_top">Base Type Requirements for Conditional Expressions: CondExpTemplate</a><br/>
	2482	condition <a href="ipopt_nlp_ode_fast.xml#Initial Condition" target="_top">ODE Fitting Using Fast Representation: Initial Condition</a><br/>
	2483	<a href="ipopt_nlp_ode_simple.xml#Initial Condition Constraint" target="_top">ODE Fitting Using Simple Representation: Initial Condition Constraint</a><br/>
555	2484	expression<b> </b>optimize <a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
556		conditional<br/>
	2485	conditional <a href="wishlist.xml#Conditional Expressions" target="_top">The CppAD Wish List: Conditional Expressions</a><br/>
	2486	<a href="base_cond_exp.xml" target="_top">Base Type Requirements for Conditional Expressions</a><br/>
	2487	<a href="cond_exp.cpp.xml" target="_top">Conditional Expressions: Example and Test</a><br/>
	2488	<a href="condexp.xml" target="_top">AD Conditional Expressions</a><br/>
557	2489	expression <a href="condexp.xml" target="_top">AD Conditional Expressions</a><br/>
558		configure <a href="installunix.xml#Configure" target="_top">Unix Test and Installation: Configure</a><br/>
	2490	configuration <a href="ipopt_nlp_get_started.cpp.xml#Configuration Requirement" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test: Configuration Requirement</a><br/>
	2491	<a href="mul_level_adolc_ode.cpp.xml#Configuration Requirement" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Configuration Requirement</a><br/>
	2492	<a href="ipopt_solve_get_started.cpp.xml#Configuration Requirement" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test: Configuration Requirement</a><br/>
	2493	<a href="mul_level_adolc.cpp.xml#Configuration Requirement" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test: Configuration Requirement</a><br/>
	2494	<a href="pkgconfig.xml#CppAD Configuration Files" target="_top">CppAD pkg-config Files: CppAD Configuration Files</a><br/>
	2495	configure <a href="installunix.xml#Configure" target="_top">Deprecated Unix Test and Installation: Configure</a><br/>
	2496	<a href="installunix.xml#Configure" target="_top">Deprecated Unix Test and Installation: Configure</a><br/>
	2497	<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
559	2498	cppad <a href="cmake.xml#CMake Command" target="_top">Using CMake to Configure CppAD: CMake Command</a><br/>
560	2499	cppad <a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
561		postfix<b> </b>directory <a href="installunix.xml#postfix_dir" target="_top">Unix Test and Installation: postfix_dir</a><br/>
562		prefix<b> </b>directory <a href="installunix.xml#prefix_dir" target="_top">Unix Test and Installation: prefix_dir</a><br/>
563		conjugate<br/>
	2500	postfix<b> </b>directory <a href="installunix.xml#postfix_dir" target="_top">Deprecated Unix Test and Installation: postfix_dir</a><br/>
	2501	prefix<b> </b>directory <a href="installunix.xml#prefix_dir" target="_top">Deprecated Unix Test and Installation: prefix_dir</a><br/>
	2502	conjugate <a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
564	2503	gradient <a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
565	2504	constant<br/>
566	2505	that<b> </b>change <a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
567		construct<br/>
	2506	constants <a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
	2507	constraint <a href="ipopt_nlp_ode_simple.xml#Trapezoidal Approximation Constraint" target="_top">ODE Fitting Using Simple Representation: Trapezoidal Approximation Constraint</a><br/>
	2508	<a href="ipopt_nlp_ode_simple.xml#Initial Condition Constraint" target="_top">ODE Fitting Using Simple Representation: Initial Condition Constraint</a><br/>
	2509	construct <a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
568	2510	ADFun <a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
569		constructor<br/>
	2511	constructor <a href="det_by_minor.xml#Constructor" target="_top">Determinant Using Expansion by Minors: Constructor</a><br/>
	2512	<a href="det_by_lu.xml#Constructor" target="_top">Determinant Using Expansion by Lu Factorization: Constructor</a><br/>
	2513	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	2514	<a href="simplevector.xml#Element Constructor and Destructor" target="_top">Definition of a Simple Vector: Element Constructor and Destructor</a><br/>
	2515	<a href="simplevector.xml#Copy Constructor" target="_top">Definition of a Simple Vector: Copy Constructor</a><br/>
	2516	<a href="simplevector.xml#Sizing Constructor" target="_top">Definition of a Simple Vector: Sizing Constructor</a><br/>
	2517	<a href="simplevector.xml#Default Constructor" target="_top">Definition of a Simple Vector: Default Constructor</a><br/>
	2518	<a href="numerictype.xml#Copy Constructor" target="_top">Definition of a Numeric Type: Copy Constructor</a><br/>
	2519	<a href="numerictype.xml#Constructor From Integer" target="_top">Definition of a Numeric Type: Constructor From Integer</a><br/>
	2520	<a href="numerictype.xml#Default Constructor" target="_top">Definition of a Numeric Type: Default Constructor</a><br/>
	2521	<a href="errorhandler.xml#Constructor" target="_top">Replacing the CppAD Error Handler: Constructor</a><br/>
	2522	<a href="size_order.xml#Constructor" target="_top">Number Taylor Coefficient Orders Currently Stored: Constructor</a><br/>
	2523	<a href="funconstruct.xml#Example.Default Constructor" target="_top">Construct an ADFun Object and Stop Recording: Example.Default Constructor</a><br/>
	2524	<a href="funconstruct.xml#Example.Sequence Constructor" target="_top">Construct an ADFun Object and Stop Recording: Example.Sequence Constructor</a><br/>
	2525	<a href="funconstruct.xml#Copy Constructor" target="_top">Construct an ADFun Object and Stop Recording: Copy Constructor</a><br/>
	2526	<a href="funconstruct.xml#Sequence Constructor" target="_top">Construct an ADFun Object and Stop Recording: Sequence Constructor</a><br/>
	2527	<a href="funconstruct.xml#Default Constructor" target="_top">Construct an ADFun Object and Stop Recording: Default Constructor</a><br/>
	2528	<a href="base_alloc.hpp.xml" target="_top">Example AD<Base> Where Base Constructor Allocates Memory</a><br/>
	2529	<a href="base_member.xml#Copy Constructor" target="_top">Required Base Class Member Functions: Copy Constructor</a><br/>
	2530	<a href="base_member.xml#Double Constructor" target="_top">Required Base Class Member Functions: Double Constructor</a><br/>
	2531	<a href="base_member.xml#Default Constructor" target="_top">Required Base Class Member Functions: Default Constructor</a><br/>
	2532	<a href="vecad.xml#Constructor" target="_top">AD Vectors that Record Index Operations: Constructor</a><br/>
	2533	<a href="atomic_matrix_mul.hpp.xml#Constructor" target="_top">Matrix Multiply as an Atomic Operation: Constructor</a><br/>
	2534	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function.Constructor" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function.Constructor</a><br/>
	2535	<a href="atomic_hes_sparse.cpp.xml#Constructor" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Constructor</a><br/>
	2536	<a href="atomic_tangent.cpp.xml#Use Atomic Function.Constructor" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.Constructor</a><br/>
	2537	<a href="atomic_tangent.cpp.xml#Constructor" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Constructor</a><br/>
	2538	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function.Constructor" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function.Constructor</a><br/>
	2539	<a href="atomic_reciprocal.cpp.xml#Constructor" target="_top">Reciprocal as an Atomic Operation: Example and Test: Constructor</a><br/>
	2540	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function.Constructor" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function.Constructor</a><br/>
	2541	<a href="atomic_norm_sq.cpp.xml#Constructor" target="_top">Euclidean Norm Squared: Example and Test: Constructor</a><br/>
	2542	<a href="atomic_get_started.cpp.xml#Use Atomic Function.Constructor" target="_top">Getting Started with Atomic Operations: Example and Test: Use Atomic Function.Constructor</a><br/>
	2543	<a href="atomic_get_started.cpp.xml#Constructor" target="_top">Getting Started with Atomic Operations: Example and Test: Constructor</a><br/>
	2544	<a href="atomic_ctor.xml#Examples.Use Constructor" target="_top">Atomic Function Constructor: Examples.Use Constructor</a><br/>
	2545	<a href="atomic_ctor.xml#Examples.Define Constructor" target="_top">Atomic Function Constructor: Examples.Define Constructor</a><br/>
	2546	<a href="atomic_ctor.xml" target="_top">Atomic Function Constructor</a><br/>
	2547	<a href="checkpoint.xml#constructor" target="_top">Checkpointing Functions: constructor</a><br/>
570	2548	AD <a href="ad_ctor.xml" target="_top">AD Constructors</a><br/>
571	2549	AD<b> </b>object <a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a><br/>
572	2550	ADFun<b> </b>constructor <a href="funconstruct.xml#Default Constructor" target="_top">Construct an ADFun Object and Stop Recording: Default Constructor</a><br/>

581	2559	numeric<b> </b>copy <a href="numerictype.xml#Copy Constructor" target="_top">Definition of a Numeric Type: Copy Constructor</a><br/>
582	2560	size<b> </b>vector <a href="simplevector.xml#Sizing Constructor" target="_top">Definition of a Simple Vector: Sizing Constructor</a><br/>
583	2561	vector<b> </b>default <a href="simplevector.xml#Default Constructor" target="_top">Definition of a Simple Vector: Default Constructor</a><br/>
584		control<br/>
585		memory <a href="capacity_taylor.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
	2562	constructor<b>:</b> <a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	2563	<a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a><br/>
	2564	constructors <a href="ad_ctor.xml" target="_top">AD Constructors</a><br/>
	2565	constructors<b>:</b> <a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a><br/>
	2566	control <a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
	2567	memory <a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
586	2568	ODE<b> </b>error <a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
587	2569	Ode<b> </b>Gear <a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
588		convert<br/>
	2570	controller <a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
	2571	<a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
	2572	controlling <a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	2573	<a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
	2574	convention <a href="lu_vec_ad.cpp.xml#Storage Convention" target="_top">Lu Factor and Solve with Recorded Pivoting: Storage Convention</a><br/>
	2575	conversion <a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a><br/>
	2576	convert <a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	2577	<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
	2578	<a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
	2579	<a href="integer.xml" target="_top">Convert From AD to Integer</a><br/>
	2580	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	2581	<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
589	2582	AD<b> </b>to<b> </b>Base <a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
590	2583	AD<b> </b>to<b> </b>integer <a href="integer.xml" target="_top">Convert From AD to Integer</a><br/>
591	2584	from<b> </b>AD <a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a><br/>
592	2585	to<b> </b>AD <a href="ad_ctor.xml" target="_top">AD Constructors</a><br/>
593		copy<br/>
	2586	copy <a href="simplevector.xml#Copy Constructor" target="_top">Definition of a Simple Vector: Copy Constructor</a><br/>
	2587	<a href="numerictype.xml#Copy Constructor" target="_top">Definition of a Numeric Type: Copy Constructor</a><br/>
	2588	<a href="funconstruct.xml#Copy Constructor" target="_top">Construct an ADFun Object and Stop Recording: Copy Constructor</a><br/>
	2589	<a href="base_member.xml#Copy Constructor" target="_top">Required Base Class Member Functions: Copy Constructor</a><br/>
594	2590	ADFun<b> </b>constructor <a href="funconstruct.xml#Copy Constructor" target="_top">Construct an ADFun Object and Stop Recording: Copy Constructor</a><br/>
595	2591	numeric<b> </b>constructor <a href="numerictype.xml#Copy Constructor" target="_top">Definition of a Numeric Type: Copy Constructor</a><br/>
596	2592	vector<b> </b>constructor <a href="simplevector.xml#Copy Constructor" target="_top">Definition of a Simple Vector: Copy Constructor</a><br/>
597		correct<br/>
	2593	correct <a href="speed_main.xml#test.correct" target="_top">Running the Speed Test Program: test.correct</a><br/>
598	2594	determinant<b> </b>check <a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
599	2595	determinant<b> </b>check <a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
600		cos<br/>
	2596	correctness <a href="correct_det_by_minor_c.xml" target="_top">Correctness Test of det_by_minor Routine</a><br/>
	2597	<a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
	2598	<a href="speed_main.xml#Correctness Results" target="_top">Running the Speed Test Program: Correctness Results</a><br/>
	2599	<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
	2600	cos <a href="cos.cpp.xml" target="_top">The AD cos Function: Example and Test</a><br/>
	2601	<a href="std_math_ad.xml#Derivatives.cos" target="_top">AD Standard Math Unary Functions: Derivatives.cos</a><br/>
601	2602	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
602	2603	AD<b> </b>example <a href="cos.cpp.xml" target="_top">The AD cos Function: Example and Test</a><br/>
603	2604	forward <a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
604	2605	reverse <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
605		cosh<br/>
	2606	cosh <a href="cosh.cpp.xml" target="_top">The AD cosh Function: Example and Test</a><br/>
	2607	<a href="std_math_ad.xml#Derivatives.cosh" target="_top">AD Standard Math Unary Functions: Derivatives.cosh</a><br/>
606	2608	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
607	2609	AD<b> </b>example <a href="cosh.cpp.xml" target="_top">The AD cosh Function: Example and Test</a><br/>
608	2610	forward <a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
609	2611	reverse <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
610		cppad<br/>
	2612	cosine <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
	2613	<a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
	2614	count <a href="introduction.xml#Preface.Operation Count" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Operation Count</a><br/>
	2615	cppad <a href="license.xml" target="_top">Your License for the CppAD Software</a><br/>
	2616	<a href="old_mat_mul.hpp.xml#CppAD User Atomic Callback Functions" target="_top">Define Matrix Multiply as a User Atomic Operation: CppAD User Atomic Callback Functions</a><br/>
	2617	<a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	2618	<a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
	2619	<a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
	2620	<a href="deprecated.xml" target="_top">CppAD Deprecated API Features</a><br/>
	2621	<a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a><br/>
	2622	<a href="whats_new_04.xml" target="_top">Changes and Additions to CppAD During 2004</a><br/>
	2623	<a href="whats_new_05.xml" target="_top">Changes and Additions to CppAD During 2005</a><br/>
	2624	<a href="whats_new_06.xml" target="_top">Changes and Additions to CppAD During 2006</a><br/>
	2625	<a href="whats_new_07.xml" target="_top">Changes and Additions to CppAD During 2007</a><br/>
	2626	<a href="whats_new_08.xml" target="_top">Changes and Additions to CppAD During 2008</a><br/>
	2627	<a href="whats_new_09.xml" target="_top">Changes and Additions to CppAD During 2009</a><br/>
	2628	<a href="whats_new_10.xml" target="_top">Changes and Additions to CppAD During 2010</a><br/>
	2629	<a href="whats_new_11.xml" target="_top">Changes and Additions to CppAD During 2011</a><br/>
	2630	<a href="whats_new_12.xml" target="_top">CppAD Changes and Additions During 2012</a><br/>
	2631	<a href="whats_new_13.xml" target="_top">CppAD Changes and Additions During 2013</a><br/>
	2632	<a href="whats_new_14.xml" target="_top">CppAD Changes and Additions During 2014</a><br/>
	2633	<a href="whats_new.xml" target="_top">Changes and Additions to CppAD</a><br/>
	2634	<a href="wishlist.xml" target="_top">The CppAD Wish List</a><br/>
	2635	<a href="bugs.xml" target="_top">Know Bugs and Problems Using CppAD</a><br/>
	2636	<a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a><br/>
	2637	<a href="cppad_sparse_hessian.cpp.xml" target="_top">CppAD Speed: Sparse Hessian</a><br/>
	2638	<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
	2639	<a href="cppad_ode.cpp.xml" target="_top">CppAD Speed: Gradient of Ode Solution</a><br/>
	2640	<a href="cppad_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication</a><br/>
	2641	<a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	2642	<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
	2643	<a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a><br/>
	2644	<a href="double_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication (Double Version)</a><br/>
	2645	<a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a><br/>
	2646	<a href="example.cpp.xml" target="_top">CppAD Examples and Tests</a><br/>
	2647	<a href="cppad_eigen.hpp.xml#CppAD Namespace" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: CppAD Namespace</a><br/>
	2648	<a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
	2649	<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	2650	<a href="listallexamples.xml" target="_top">List of All the CppAD Examples</a><br/>
	2651	<a href="exampleutility.xml" target="_top">Utility Routines used by CppAD Examples</a><br/>
	2652	<a href="example.xml#The CppAD Test Vector Template Class" target="_top">Examples: The CppAD Test Vector Template Class</a><br/>
	2653	<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	2654	<a href="cppad_assert.xml" target="_top">CppAD Assertions During Execution</a><br/>
	2655	<a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
	2656	<a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
	2657	<a href="library.xml#CppAD Numerical Template Library" target="_top">The CppAD General Purpose Library: CppAD Numerical Template Library</a><br/>
	2658	<a href="library.xml" target="_top">The CppAD General Purpose Library</a><br/>
	2659	<a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
	2660	<a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a><br/>
	2661	<a href="exp_eps_cppad.xml" target="_top">exp_eps: CppAD Forward and Reverse Sweeps</a><br/>
	2662	<a href="exp_2_cppad.xml" target="_top">exp_2: CppAD Forward and Reverse Sweeps</a><br/>
	2663	<a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
	2664	<a href="installunix.xml#Profiling CppAD" target="_top">Deprecated Unix Test and Installation: Profiling CppAD</a><br/>
	2665	<a href="pkgconfig.xml#CppAD Configuration Files" target="_top">CppAD pkg-config Files: CppAD Configuration Files</a><br/>
	2666	<a href="pkgconfig.xml" target="_top">CppAD pkg-config Files</a><br/>
	2667	<a href="cmake_check.xml" target="_top">Checking the CppAD Examples and Tests</a><br/>
	2668	<a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a><br/>
	2669	<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
	2670	<a href="download.xml" target="_top">Download The CppAD Source Code</a><br/>
	2671	<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
611	2672	cmake<b> </b>configure <a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
612	2673	configure <a href="cmake.xml#CMake Command" target="_top">Using CMake to Configure CppAD: CMake Command</a><br/>
613	2674	download <a href="download.xml" target="_top">Download The CppAD Source Code</a><br/>
614		install<b> </b>documentation <a href="cmake.xml#cppad_documentation" target="_top">Using CMake to Configure CppAD: cppad_documentation</a><br/>
615	2675	link<b>_</b>det<b>_</b>lu <a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
616	2676	link<b>_</b>det<b>_</b>minor <a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
617	2677	link<b>_</b>mat<b>_</b>mul <a href="cppad_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication</a><br/>

620	2680	link<b>_</b>poly <a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
621	2681	link<b>_</b>sparse<b>_</b>hessian <a href="cppad_sparse_hessian.cpp.xml" target="_top">CppAD Speed: Sparse Hessian</a><br/>
622	2682	link<b>_</b>sparse<b>_</b>jacobian <a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a><br/>
623		profile<b> </b>speed <a href="installunix.xml#Profiling CppAD" target="_top">Unix Test and Installation: Profiling CppAD</a><br/>
	2683	profile<b> </b>speed <a href="installunix.xml#Profiling CppAD" target="_top">Deprecated Unix Test and Installation: Profiling CppAD</a><br/>
624	2684	speed <a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a><br/>
625	2685	speed <a href="cppad_sparse_hessian.cpp.xml" target="_top">CppAD Speed: Sparse Hessian</a><br/>
626	2686	speed <a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>

630	2690	speed <a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
631	2691	speed<b> </b>matrix<b> </b>multiply <a href="double_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication (Double Version)</a><br/>
632	2692	speed<b> </b>test <a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a><br/>
633		speed<b> </b>test <a href="speed_main.xml" target="_top">Speed Testing Main Program</a><br/>
	2693	speed<b> </b>test <a href="speed_main.xml" target="_top">Running the Speed Test Program</a><br/>
634	2694	test<b> </b>vector <a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a><br/>
	2695	cppad<b>-</b>20150000<b>.</b>0<b>:</b> <a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
635	2696	cppad<b>.</b>hpp<br/>
636		include <a href="cppad.xml#Include File" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
	2697	include <a href="cppad.xml#Include File" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
	2698	cppad<b>::</b>vector <a href="test_vector.xml#CppAD::vector" target="_top">Choosing The Vector Testing Template Class: CppAD::vector</a><br/>
	2699	<a href="testvector.xml#CppAD::vector" target="_top">Using The CppAD Test Vector Template Class: CppAD::vector</a><br/>
	2700	<a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
	2701	<a href="cppad_vector.xml" target="_top">The CppAD::vector Template Class</a><br/>
	2702	cppad<b>::</b>vectorbool <a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
	2703	cppad<b>_</b>colpack<b>.</b>cpp <a href="colpack_prefix.xml#cppad_colpack.cpp" target="_top">Including the ColPack Sparsity Calculations: cppad_colpack.cpp</a><br/>
	2704	<a href="colpack_prefix.xml#cppad_colpack.cpp" target="_top">Including the ColPack Sparsity Calculations: cppad_colpack.cpp</a><br/>
	2705	cppad<b>_</b>compiler<b>_</b>has<b>_</b>erf <a href="erf.xml#Method.CPPAD_COMPILER_HAS_ERF" target="_top">The AD Error Function: Method.CPPAD_COMPILER_HAS_ERF</a><br/>
	2706	cppad<b>_</b>cxx<b>_</b>flags <a href="cmake.xml#cppad_cxx_flags" target="_top">Using CMake to Configure CppAD: cppad_cxx_flags</a><br/>
	2707	cppad<b>_</b>implicit<b>_</b>ctor<b>_</b>from<b>_</b>any<b>_</b>type <a href="cmake.xml#cppad_implicit_ctor_from_any_type" target="_top">Using CMake to Configure CppAD: cppad_implicit_ctor_from_any_type</a><br/>
	2708	cppad<b>_</b>ipopt <a href="cppad_ipopt_nlp.xml#cppad_ipopt namespace" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: cppad_ipopt namespace</a><br/>
	2709	<a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>
637	2710	cppad<b>_</b>ipopt<b>_</b>nlp<br/>
638	2711	ode<b> </b>example<b> </b>source <a href="ipopt_nlp_ode_fast.hpp.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
639	2712	ode<b> </b>example<b> </b>source <a href="ipopt_nlp_ode_simple.hpp.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
640	2713	ode<b> </b>representation <a href="ipopt_nlp_ode_fast.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
641	2714	ode<b> </b>simple<b> </b>representation <a href="ipopt_nlp_ode_simple.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	2715	cppad<b>_</b>max<b>_</b>num<b>_</b>threads <a href="multi_thread.xml#CPPAD_MAX_NUM_THREADS" target="_top">Using CppAD in a Multi-Threading Environment: CPPAD_MAX_NUM_THREADS</a><br/>
	2716	<a href="cmake.xml#cppad_max_num_threads" target="_top">Using CMake to Configure CppAD: cppad_max_num_threads</a><br/>
	2717	cppad<b>_</b>null <a href="preprocessor.xml#Documented Here.CPPAD_NULL" target="_top">CppAD API Preprocessor Symbols: Documented Here.CPPAD_NULL</a><br/>
	2718	cppad<b>_</b>package<b>_</b>string <a href="preprocessor.xml#CPPAD_PACKAGE_STRING" target="_top">CppAD API Preprocessor Symbols: CPPAD_PACKAGE_STRING</a><br/>
	2719	cppad<b>_</b>sparse<b>_</b>list <a href="cmake.xml#cppad_sparse_list" target="_top">Using CMake to Configure CppAD: cppad_sparse_list</a><br/>
	2720	cppad<b>_</b>standard<b>_</b>math<b>_</b>unary <a href="base_std_math.xml#CPPAD_STANDARD_MATH_UNARY" target="_top">Base Type Requirements for Standard Math Functions: CPPAD_STANDARD_MATH_UNARY</a><br/>
	2721	cppad<b>_</b>tape<b>_</b>addr<b>_</b>type <a href="cmake.xml#cppad_tape_addr_type" target="_top">Using CMake to Configure CppAD: cppad_tape_addr_type</a><br/>
	2722	cppad<b>_</b>tape<b>_</b>id<b>_</b>type <a href="cmake.xml#cppad_tape_id_type" target="_top">Using CMake to Configure CppAD: cppad_tape_id_type</a><br/>
642	2723	cppad<b>_</b>testvector <a href="cppad_testvector.xml#cppad_testvector" target="_top">Choosing the CppAD Test Vector Template Class: cppad_testvector</a><br/>
	2724	<a href="cppad_testvector.xml#cppad_testvector" target="_top">Choosing the CppAD Test Vector Template Class: cppad_testvector</a><br/>
	2725	<a href="cmake.xml#cppad_testvector" target="_top">Using CMake to Configure CppAD: cppad_testvector</a><br/>
	2726	cppad<b>_</b>user<b>_</b>atomic <a href="old_atomic.xml#CPPAD_USER_ATOMIC" target="_top">User Defined Atomic AD Functions: CPPAD_USER_ATOMIC</a><br/>
	2727	cppadvector <a href="test_vector.xml#CppADvector" target="_top">Choosing The Vector Testing Template Class: CppADvector</a><br/>
	2728	create <a href="omp_create_array.xml" target="_top">Allocate Memory and Create A Raw Array</a><br/>
	2729	<a href="boolfun.xml#Create Binary" target="_top">AD Boolean Functions: Create Binary</a><br/>
	2730	<a href="boolfun.xml#Create Unary" target="_top">AD Boolean Functions: Create Unary</a><br/>
	2731	<a href="discrete.xml#Create AD Version" target="_top">Discrete AD Functions: Create AD Version</a><br/>
643	2732	create<b>_</b>array<br/>
644	2733	omp<b>_</b>alloc <a href="omp_create_array.xml#Deprecated" target="_top">Allocate Memory and Create A Raw Array: Deprecated</a><br/>
645	2734	thread<b>_</b>alloc <a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	2735	creating <a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
	2736	criteria <a href="odegearcontrol.xml#Error Criteria Discussion" target="_top">An Error Controller for Gear's Ode Solvers: Error Criteria Discussion</a><br/>
	2737	<a href="odeerrcontrol.xml#Error Criteria Discussion" target="_top">An Error Controller for ODE Solvers: Error Criteria Discussion</a><br/>
	2738	cstdint <a href="cmake.xml#cppad_tape_addr_type.cstdint" target="_top">Using CMake to Configure CppAD: cppad_tape_addr_type.cstdint</a><br/>
	2739	<a href="cmake.xml#cppad_tape_id_type.cstdint" target="_top">Using CMake to Configure CppAD: cppad_tape_id_type.cstdint</a><br/>
646	2740	ctor<br/>
647		implicit<b> </b>or<b> </b>explicit <a href="installunix.xml#--with-implicit_ctor" target="_top">Unix Test and Installation: --with-implicit_ctor</a><br/>
	2741	implicit<b> </b>or<b> </b>explicit <a href="installunix.xml#--with-implicit_ctor" target="_top">Deprecated Unix Test and Installation: --with-implicit_ctor</a><br/>
648	2742	implicit<b> </b>or<b> </b>explicit <a href="cmake.xml#cppad_implicit_ctor_from_any_type" target="_top">Using CMake to Configure CppAD: cppad_implicit_ctor_from_any_type</a><br/>
649		current<br/>
	2743	ctor<b>_</b>arg<b>_</b>list <a href="atomic_ctor.xml#atomic_user.ctor_arg_list" target="_top">Atomic Function Constructor: atomic_user.ctor_arg_list</a><br/>
	2744	current <a href="omp_get_thread_num.xml" target="_top">Get the Current OpenMP Thread Number</a><br/>
	2745	<a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
	2746	<a href="ta_thread_num.xml" target="_top">Get the Current Thread Number</a><br/>
	2747	<a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
	2748	<a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
	2749	<a href="download.xml#Subversion.Current Version" target="_top">Download The CppAD Source Code: Subversion.Current Version</a><br/>
	2750	<a href="download.xml#Compressed Tar File.Current Version" target="_top">Download The CppAD Source Code: Compressed Tar File.Current Version</a><br/>
650	2751	thread <a href="ta_thread_num.xml" target="_top">Get the Current Thread Number</a><br/>
651		cygwin<br/>
	2752	currently <a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	2753	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	2754	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	2755	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	2756	<a href="size_order.xml" target="_top">Number Taylor Coefficient Orders Currently Stored</a><br/>
	2757	cxx<b>_</b>flags <a href="installunix.xml#cxx_flags" target="_top">Deprecated Unix Test and Installation: cxx_flags</a><br/>
	2758	cygwin <a href="team_pthread.cpp.xml#Bug in Cygwin" target="_top">Pthread Implementation of a Team of AD Threads: Bug in Cygwin</a><br/>
	2759	<a href="installunix.xml#adolc_dir.Cygwin" target="_top">Deprecated Unix Test and Installation: adolc_dir.Cygwin</a><br/>
	2760	<a href="adolc_prefix.xml#Cygwin" target="_top">Including the ADOL-C Examples and Tests: Cygwin</a><br/>
652	2761	adolc <a href="adolc_prefix.xml#Cygwin" target="_top">Including the ADOL-C Examples and Tests: Cygwin</a><br/>
653	2762	bug<b> </b>in<b> </b>pthread<b>_</b>exit <a href="team_pthread.cpp.xml#Bug in Cygwin" target="_top">Pthread Implementation of a Team of AD Threads: Bug in Cygwin</a><br/>
654	2763

661	2770	Domain<br/>
662	2771	ADFun <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
663	2772	ADFun <a href="seq_property.xml#Domain" target="_top">ADFun Sequence Properties: Domain</a><br/>
	2773	d <a href="det_of_minor_c.xml#d" target="_top">Determinant of a Minor: d</a><br/>
	2774	<a href="det_33.xml#d" target="_top">Check Determinant of 3 by 3 matrix: d</a><br/>
	2775	<a href="det_by_minor.xml#det.d" target="_top">Determinant Using Expansion by Minors: det.d</a><br/>
	2776	<a href="det_of_minor.xml#d" target="_top">Determinant of a Minor: d</a><br/>
	2777	<a href="det_by_lu.xml#det.d" target="_top">Determinant Using Expansion by Lu Factorization: det.d</a><br/>
	2778	data <a href="cppad_vector.xml#vectorBool.data" target="_top">The CppAD::vector Template Class: vectorBool.data</a><br/>
	2779	<a href="cppad_vector.xml#data" target="_top">The CppAD::vector Template Class: data</a><br/>
	2780	CppAD<b> </b>vector <a href="cppad_vector.xml#data" target="_top">The CppAD::vector Template Class: data</a><br/>
664	2781	data<b> </b>directory<br/>
	2782	install <a href="cmake.xml#cmake_install_docdir" target="_top">Using CMake to Configure CppAD: cmake_install_docdir</a><br/>
665	2783	install <a href="cmake.xml#cmake_install_datadir" target="_top">Using CMake to Configure CppAD: cmake_install_datadir</a><br/>
	2784	ddp <a href="link_poly.xml#ddp" target="_top">Speed Testing Second Derivative of a Polynomial: ddp</a><br/>
	2785	ddw <a href="revtwo.xml#ddw" target="_top">Reverse Mode Second Partial Derivative Driver: ddw</a><br/>
	2786	ddy <a href="fortwo.xml#ddy" target="_top">Forward Mode Second Partial Derivative Driver: ddy</a><br/>
	2787	deallocate <a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
666	2788	debug<br/>
667	2789	forward<b> </b>mode <a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
668		default<br/>
	2790	declare <a href="old_mat_mul.hpp.xml#Declare mat_mul Function" target="_top">Define Matrix Multiply as a User Atomic Operation: Declare mat_mul Function</a><br/>
	2791	<a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
	2792	default <a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	2793	<a href="simplevector.xml#Default Constructor" target="_top">Definition of a Simple Vector: Default Constructor</a><br/>
	2794	<a href="numerictype.xml#Default Constructor" target="_top">Definition of a Numeric Type: Default Constructor</a><br/>
	2795	<a href="check_for_nan.xml#Default" target="_top">Check an ADFun Object For Nan: Default</a><br/>
	2796	<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	2797	<a href="funconstruct.xml#Example.Default Constructor" target="_top">Construct an ADFun Object and Stop Recording: Example.Default Constructor</a><br/>
	2798	<a href="funconstruct.xml#Default Constructor" target="_top">Construct an ADFun Object and Stop Recording: Default Constructor</a><br/>
	2799	<a href="base_member.xml#Default Constructor" target="_top">Required Base Class Member Functions: Default Constructor</a><br/>
669	2800	ADFun<b> </b>constructor <a href="funconstruct.xml#Default Constructor" target="_top">Construct an ADFun Object and Stop Recording: Default Constructor</a><br/>
670	2801	numeric<b> </b>constructor <a href="numerictype.xml#Default Constructor" target="_top">Definition of a Numeric Type: Default Constructor</a><br/>
671	2802	vector<b> </b>constructor <a href="simplevector.xml#Default Constructor" target="_top">Definition of a Simple Vector: Default Constructor</a><br/>
672		delete<br/>
	2803	define <a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
	2804	<a href="old_atomic.xml#Syntax.Define Function" target="_top">User Defined Atomic AD Functions: Syntax.Define Function</a><br/>
	2805	<a href="atomic_rev_sparse_hes.xml#Examples.Define rev_sparse_hes" target="_top">Atomic Reverse Hessian Sparsity Patterns: Examples.Define rev_sparse_hes</a><br/>
	2806	<a href="atomic_rev_sparse_jac.xml#Examples.Define rev_sparse_jac" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Examples.Define rev_sparse_jac</a><br/>
	2807	<a href="atomic_for_sparse_jac.xml#Examples.Define for_sparse_jac" target="_top">Atomic Forward Jacobian Sparsity Patterns: Examples.Define for_sparse_jac</a><br/>
	2808	<a href="atomic_reverse.xml#Examples.Define reverse" target="_top">Atomic Reverse Mode: Examples.Define reverse</a><br/>
	2809	<a href="atomic_forward.xml#Examples.Define forward" target="_top">Atomic Forward Mode: Examples.Define forward</a><br/>
	2810	<a href="atomic_ctor.xml#Examples.Define Constructor" target="_top">Atomic Function Constructor: Examples.Define Constructor</a><br/>
	2811	defined <a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	2812	<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
	2813	<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	2814	<a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	2815	<a href="pkgconfig.xml#Defined Fields" target="_top">CppAD pkg-config Files: Defined Fields</a><br/>
	2816	definition <a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
	2817	<a href="numerictype.xml" target="_top">Definition of a Numeric Type</a><br/>
	2818	<a href="base_alloc.hpp.xml#Class Definition" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Class Definition</a><br/>
	2819	<a href="atomic_matrix_mul.hpp.xml#End Class Definition" target="_top">Matrix Multiply as an Atomic Operation: End Class Definition</a><br/>
	2820	<a href="atomic_matrix_mul.hpp.xml#Start Class Definition" target="_top">Matrix Multiply as an Atomic Operation: Start Class Definition</a><br/>
	2821	<a href="atomic_mat_mul.cpp.xml#Class Definition" target="_top">User Atomic Matrix Multiply: Example and Test: Class Definition</a><br/>
	2822	<a href="atomic_hes_sparse.cpp.xml#Start Class Definition" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Start Class Definition</a><br/>
	2823	<a href="atomic_tangent.cpp.xml#End Class Definition" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: End Class Definition</a><br/>
	2824	<a href="atomic_tangent.cpp.xml#Start Class Definition" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Start Class Definition</a><br/>
	2825	<a href="atomic_reciprocal.cpp.xml#End Class Definition" target="_top">Reciprocal as an Atomic Operation: Example and Test: End Class Definition</a><br/>
	2826	<a href="atomic_reciprocal.cpp.xml#Start Class Definition" target="_top">Reciprocal as an Atomic Operation: Example and Test: Start Class Definition</a><br/>
	2827	<a href="atomic_norm_sq.cpp.xml#End Class Definition" target="_top">Euclidean Norm Squared: Example and Test: End Class Definition</a><br/>
	2828	<a href="atomic_norm_sq.cpp.xml#Start Class Definition" target="_top">Euclidean Norm Squared: Example and Test: Start Class Definition</a><br/>
	2829	<a href="atomic_get_started.cpp.xml#End Class Definition" target="_top">Getting Started with Atomic Operations: Example and Test: End Class Definition</a><br/>
	2830	<a href="atomic_get_started.cpp.xml#Start Class Definition" target="_top">Getting Started with Atomic Operations: Example and Test: Start Class Definition</a><br/>
	2831	definitions<b>:</b> <a href="ipopt_nlp_ode_problem.hpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	2832	<a href="ipopt_solve_ode_inverse.cpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	2833	delete <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
673	2834	example <a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
674	2835	track <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
	2836	delete<b>:</b> <a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
675	2837	delete<b>_</b>array<br/>
676	2838	omp<b>_</b>alloc <a href="omp_delete_array.xml#Deprecated" target="_top">Return A Raw Array to The Available Memory for a Thread: Deprecated</a><br/>
677	2839	thread<b>_</b>alloc <a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
678		dependent <a href="glossary.xml#Tape.Dependent Variables" target="_top">Glossary: Tape.Dependent Variables</a><br/>
	2840	delta <a href="omp_delete_array.xml#Delta" target="_top">Return A Raw Array to The Available Memory for a Thread: Delta</a><br/>
	2841	<a href="omp_create_array.xml#Delta" target="_top">Allocate Memory and Create A Raw Array: Delta</a><br/>
	2842	<a href="ta_delete_array.xml#Delta" target="_top">Deallocate An Array and Call Destructor for its Elements: Delta</a><br/>
	2843	<a href="ta_create_array.xml#Delta" target="_top">Allocate An Array and Call Default Constructor for its Elements: Delta</a><br/>
	2844	dependent <a href="fundeprecated.xml#Dependent" target="_top">ADFun Object Deprecated Member Functions: Dependent</a><br/>
	2845	<a href="glossary.xml#Tape.Dependent Variables" target="_top">Glossary: Tape.Dependent Variables</a><br/>
679	2846	<a href="glossary.xml#Operation.Dependent" target="_top">Glossary: Operation.Dependent</a><br/>
680		deprecated<br/>
	2847	deprecated <a href="old_mat_mul.cpp.xml#Deprecated" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test: Deprecated</a><br/>
	2848	<a href="old_tan.cpp.xml#Deprecated" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Deprecated</a><br/>
	2849	<a href="old_usead_2.cpp.xml#Deprecated" target="_top">Using AD to Compute Atomic Function Derivatives: Deprecated</a><br/>
	2850	<a href="old_usead_1.cpp.xml#Deprecated" target="_top">Using AD to Compute Atomic Function Derivatives: Deprecated</a><br/>
	2851	<a href="old_reciprocal.cpp.xml#Deprecated" target="_top">Old Atomic Operation Reciprocal: Example and Test: Deprecated</a><br/>
	2852	<a href="cppad_ipopt_nlp.xml#Deprecated" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: Deprecated</a><br/>
	2853	<a href="test_vector.xml#Deprecated" target="_top">Choosing The Vector Testing Template Class: Deprecated</a><br/>
	2854	<a href="epsilon.xml#Deprecated" target="_top">Machine Epsilon For AD Types: Deprecated</a><br/>
	2855	<a href="memory_leak.xml#Deprecated" target="_top">Memory Leak Detection: Deprecated</a><br/>
	2856	<a href="omp_alloc.cpp.xml#Deprecated" target="_top">OpenMP Memory Allocator: Example and Test: Deprecated</a><br/>
	2857	<a href="omp_delete_array.xml#Deprecated" target="_top">Return A Raw Array to The Available Memory for a Thread: Deprecated</a><br/>
	2858	<a href="omp_create_array.xml#Deprecated" target="_top">Allocate Memory and Create A Raw Array: Deprecated</a><br/>
	2859	<a href="omp_available.xml#Deprecated" target="_top">Amount of Memory Available for Quick Use by a Thread: Deprecated</a><br/>
	2860	<a href="omp_inuse.xml#Deprecated" target="_top">Amount of Memory a Thread is Currently Using: Deprecated</a><br/>
	2861	<a href="omp_free_available.xml#Deprecated" target="_top">Free Memory Currently Available for Quick Use by a Thread: Deprecated</a><br/>
	2862	<a href="omp_return_memory.xml#Deprecated" target="_top">Return Memory to omp_alloc: Deprecated</a><br/>
	2863	<a href="omp_get_memory.xml#Deprecated" target="_top">Get At Least A Specified Amount of Memory: Deprecated</a><br/>
	2864	<a href="omp_get_thread_num.xml#Deprecated" target="_top">Get the Current OpenMP Thread Number: Deprecated</a><br/>
	2865	<a href="omp_in_parallel.xml#Deprecated" target="_top">Is The Current Execution in OpenMP Parallel Mode: Deprecated</a><br/>
	2866	<a href="omp_max_num_threads.xml#Deprecated" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator: Deprecated</a><br/>
	2867	<a href="tracknewdel.xml#TrackCount.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackCount.Previously Deprecated</a><br/>
	2868	<a href="tracknewdel.xml#TrackExtend.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackExtend.Previously Deprecated</a><br/>
	2869	<a href="tracknewdel.xml#TrackDelVec.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackDelVec.Previously Deprecated</a><br/>
	2870	<a href="tracknewdel.xml#TrackNewVec.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackNewVec.Previously Deprecated</a><br/>
	2871	<a href="tracknewdel.xml#Deprecated" target="_top">Routines That Track Use of New and Delete: Deprecated</a><br/>
	2872	<a href="omp_max_thread.xml#Deprecated" target="_top">OpenMP Parallel Setup: Deprecated</a><br/>
	2873	<a href="fundeprecated.xml#capacity_taylor.Deprecated" target="_top">ADFun Object Deprecated Member Functions: capacity_taylor.Deprecated</a><br/>
	2874	<a href="fundeprecated.xml#size_taylor.Deprecated" target="_top">ADFun Object Deprecated Member Functions: size_taylor.Deprecated</a><br/>
	2875	<a href="fundeprecated.xml#use_VecAD.Deprecated" target="_top">ADFun Object Deprecated Member Functions: use_VecAD.Deprecated</a><br/>
	2876	<a href="fundeprecated.xml#taylor_size.Deprecated" target="_top">ADFun Object Deprecated Member Functions: taylor_size.Deprecated</a><br/>
	2877	<a href="fundeprecated.xml#Size.Deprecated" target="_top">ADFun Object Deprecated Member Functions: Size.Deprecated</a><br/>
	2878	<a href="fundeprecated.xml#Memory.Deprecated" target="_top">ADFun Object Deprecated Member Functions: Memory.Deprecated</a><br/>
	2879	<a href="fundeprecated.xml#Order.Deprecated" target="_top">ADFun Object Deprecated Member Functions: Order.Deprecated</a><br/>
	2880	<a href="fundeprecated.xml#Dependent.Deprecated" target="_top">ADFun Object Deprecated Member Functions: Dependent.Deprecated</a><br/>
	2881	<a href="fundeprecated.xml" target="_top">ADFun Object Deprecated Member Functions</a><br/>
	2882	<a href="include_deprecated.xml#Linking New Files to Deprecated Commands" target="_top">Deprecated Include Files: Linking New Files to Deprecated Commands</a><br/>
	2883	<a href="include_deprecated.xml" target="_top">Deprecated Include Files</a><br/>
	2884	<a href="deprecated.xml" target="_top">CppAD Deprecated API Features</a><br/>
	2885	<a href="preprocessor.xml#Deprecated" target="_top">CppAD API Preprocessor Symbols: Deprecated</a><br/>
	2886	<a href="boolfun.xml#Deprecated" target="_top">AD Boolean Functions: Deprecated</a><br/>
	2887	<a href="discrete.xml#Deprecated" target="_top">Discrete AD Functions: Deprecated</a><br/>
	2888	<a href="condexp.xml#Deprecated" target="_top">AD Conditional Expressions: Deprecated</a><br/>
	2889	<a href="ad_ctor.xml#x.deprecated" target="_top">AD Constructors: x.deprecated</a><br/>
	2890	<a href="installunix.xml#Deprecated" target="_top">Deprecated Unix Test and Installation: Deprecated</a><br/>
	2891	<a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a><br/>
681	2892	CppADCreateDiscrete <a href="discrete.xml#Deprecated" target="_top">Discrete AD Functions: Deprecated</a><br/>
682	2893	constructor <a href="ad_ctor.xml#x.deprecated" target="_top">AD Constructors: x.deprecated</a><br/>
683	2894	epsilon <a href="epsilon.xml#Deprecated" target="_top">Machine Epsilon For AD Types: Deprecated</a><br/>

688	2899	track<b> </b>memory <a href="tracknewdel.xml#Deprecated" target="_top">Routines That Track Use of New and Delete: Deprecated</a><br/>
689	2900	depreciated<br/>
690	2901	omp<b>_</b>max<b>_</b>thread <a href="omp_max_thread.xml#Deprecated" target="_top">OpenMP Parallel Setup: Deprecated</a><br/>
691		derivative<br/>
	2902	derivative <a href="theory.xml" target="_top">The Theory of Derivative Calculations</a><br/>
	2903	<a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
	2904	<a href="fadbad_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
	2905	<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
	2906	<a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>
	2907	<a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
	2908	<a href="link_mat_mul.xml" target="_top">Speed Testing Derivative of Matrix Multiply</a><br/>
	2909	<a href="mul_level_adolc_ode.cpp.xml#Derivative of ODE Solution" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Derivative of ODE Solution</a><br/>
	2910	<a href="mul_level_ode.cpp.xml#Derivative of ODE Solution" target="_top">Taylor's Ode Solver: An Example and Test: Derivative of ODE Solution</a><br/>
	2911	<a href="mul_level.xml#General Procedure.Derivative of Outer Function" target="_top">Using Multiple Levels of AD: General Procedure.Derivative of Outer Function</a><br/>
	2912	<a href="mul_level.xml#General Procedure.Derivative of Inner Function" target="_top">Using Multiple Levels of AD: General Procedure.Derivative of Inner Function</a><br/>
	2913	<a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
	2914	<a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
	2915	<a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
	2916	<a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a><br/>
	2917	<a href="forward_order.xml#Purpose.Derivative Values" target="_top">Multiple Order Forward Mode: Purpose.Derivative Values</a><br/>
	2918	<a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a><br/>
	2919	<a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
	2920	<a href="sign.xml#Derivative" target="_top">Sign Function: Derivative</a><br/>
	2921	<a href="abs.xml#Old Derivative" target="_top">AD Absolute Value Function: Old Derivative</a><br/>
	2922	<a href="abs.xml#Derivative" target="_top">AD Absolute Value Function: Derivative</a><br/>
	2923	<a href="compute_assign.xml#Derivative" target="_top">AD Computed Assignment Operators: Derivative</a><br/>
	2924	<a href="ad_binary.xml#Derivative" target="_top">AD Binary Arithmetic Operators: Derivative</a><br/>
	2925	<a href="unaryminus.xml#Derivative" target="_top">AD Unary Minus Operator: Derivative</a><br/>
	2926	<a href="unaryplus.xml#Derivative" target="_top">AD Unary Plus Operator: Derivative</a><br/>
	2927	<a href="exp_eps_for2.xml#Operation Sequence.Derivative" target="_top">exp_eps: Second Order Forward Mode: Operation Sequence.Derivative</a><br/>
	2928	<a href="exp_eps_for1.xml#Operation Sequence.Derivative" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence.Derivative</a><br/>
	2929	<a href="exp_2_for2.xml#Operation Sequence.Derivative" target="_top">exp_2: Second Order Forward Mode: Operation Sequence.Derivative</a><br/>
	2930	<a href="exp_2_for1.xml#Operation Sequence.Derivative" target="_top">exp_2: First Order Forward Mode: Operation Sequence.Derivative</a><br/>
	2931	<a href="get_started.cpp.xml#Derivative" target="_top">Getting Started Using CppAD to Compute Derivatives: Derivative</a><br/>
692	2932	easy <a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
693	2933	example <a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a><br/>
694	2934	first<b> </b>order<b> </b>driver <a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
695		forward<b> </b>mode <a href="forwardany.xml" target="_top">Any Order Forward Mode</a><br/>
696	2935	polynomial<b> </b>template <a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
697	2936	reverse<b> </b>mode <a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a><br/>
698	2937	reverse<b> </b>mode <a href="reverse_two.xml" target="_top">Second Order Reverse Mode</a><br/>
699	2938	reverse<b> </b>mode <a href="reverse_one.xml" target="_top">First Order Reverse Mode</a><br/>
700		destructor<br/>
	2939	derivative<b>:</b> <a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
	2940	<a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a><br/>
	2941	derivatives <a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	2942	<a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	2943	<a href="ipopt_nlp_ode_problem.xml#Black Box Method.Derivatives" target="_top">An ODE Inverse Problem Example: Black Box Method.Derivatives</a><br/>
	2944	<a href="bib.xml#Evaluating Derivatives" target="_top">Bibliography: Evaluating Derivatives</a><br/>
	2945	<a href="erf_forward.xml#Derivatives" target="_top">Error Function Forward Taylor Polynomial Theory: Derivatives</a><br/>
	2946	<a href="tan_forward.xml#Derivatives" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory: Derivatives</a><br/>
	2947	<a href="speed_sacado.xml" target="_top">Speed Test Derivatives Using Sacado</a><br/>
	2948	<a href="speed_fadbad.xml" target="_top">Speed Test Derivatives Using Fadbad</a><br/>
	2949	<a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a><br/>
	2950	<a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
	2951	<a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a><br/>
	2952	<a href="discrete.xml#Derivatives" target="_top">Discrete AD Functions: Derivatives</a><br/>
	2953	<a href="std_math_ad.xml#Derivatives" target="_top">AD Standard Math Unary Functions: Derivatives</a><br/>
	2954	<a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
	2955	derivatives<b>:</b> <a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
	2956	description <a href="general.xml#Description" target="_top">General Examples: Description</a><br/>
	2957	<a href="luratio.xml#Description" target="_top">LU Factorization of A Square Matrix and Stability Calculation: Description</a><br/>
	2958	<a href="cppad_vector.xml#Description" target="_top">The CppAD::vector Template Class: Description</a><br/>
	2959	<a href="odeerrcontrol.xml#Description" target="_top">An Error Controller for ODE Solvers: Description</a><br/>
	2960	<a href="rosen34.xml#Description" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Description</a><br/>
	2961	<a href="rombergmul.xml#Description" target="_top">Multi-dimensional Romberg Integration: Description</a><br/>
	2962	<a href="rombergone.xml#Description" target="_top">One DimensionalRomberg Integration: Description</a><br/>
	2963	<a href="luinvert.xml#Description" target="_top">Invert an LU Factored Equation: Description</a><br/>
	2964	<a href="lufactor.xml#Description" target="_top">LU Factorization of A Square Matrix: Description</a><br/>
	2965	<a href="lusolve.xml#Description" target="_top">Compute Determinant and Solve Linear Equations: Description</a><br/>
	2966	<a href="poly.xml#Description" target="_top">Evaluate a Polynomial or its Derivative: Description</a><br/>
	2967	<a href="cond_exp.cpp.xml#Description" target="_top">Conditional Expressions: Example and Test: Description</a><br/>
	2968	<a href="erf.xml#Description" target="_top">The AD Error Function: Description</a><br/>
	2969	destructor <a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
	2970	<a href="simplevector.xml#Element Constructor and Destructor" target="_top">Definition of a Simple Vector: Element Constructor and Destructor</a><br/>
701	2971	element <a href="simplevector.xml#Element Constructor and Destructor" target="_top">Definition of a Simple Vector: Element Constructor and Destructor</a><br/>
702		det<b>_</b>33 <a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
	2972	det <a href="det_by_minor.xml#det" target="_top">Determinant Using Expansion by Minors: det</a><br/>
	2973	<a href="det_by_lu.xml#det" target="_top">Determinant Using Expansion by Lu Factorization: det</a><br/>
	2974	det<b>_</b>33 <a href="det_33.hpp.xml" target="_top">Source: det_33</a><br/>
	2975	<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
703	2976	source <a href="det_33.hpp.xml" target="_top">Source: det_33</a><br/>
704		det<b>_</b>by<b>_</b>lu <a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
	2977	det<b>_</b>by<b>_</b>lu <a href="det_by_lu.hpp.xml" target="_top">Source: det_by_lu</a><br/>
	2978	<a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
705	2979	source <a href="det_by_lu.hpp.xml" target="_top">Source: det_by_lu</a><br/>
706		det<b>_</b>by<b>_</b>minor<br/>
	2980	det<b>_</b>by<b>_</b>minor <a href="time_det_by_minor_c.xml" target="_top">Determine Amount of Time to Execute det_by_minor</a><br/>
	2981	<a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
	2982	<a href="correct_det_by_minor_c.xml" target="_top">Correctness Test of det_by_minor Routine</a><br/>
	2983	<a href="det_by_minor.hpp.xml" target="_top">Source: det_by_minor</a><br/>
707	2984	source <a href="det_by_minor.hpp.xml" target="_top">Source: det_by_minor</a><br/>
708		det<b>_</b>grad<b>_</b>33 <a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	2985	det<b>_</b>grad<b>_</b>33 <a href="det_grad_33.hpp.xml" target="_top">Source: det_grad_33</a><br/>
	2986	<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
709	2987	source <a href="det_grad_33.hpp.xml" target="_top">Source: det_grad_33</a><br/>
710	2988	det<b>_</b>lu<br/>
711	2989	speed<b> </b>test <a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
712	2990	det<b>_</b>minor<br/>
713	2991	speed<b> </b>test <a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
714		det<b>_</b>of<b>_</b>minor <a href="det_of_minor.xml" target="_top">Determinant of a Minor</a><br/>
	2992	det<b>_</b>of<b>_</b>minor <a href="det_of_minor.hpp.xml" target="_top">Source: det_of_minor</a><br/>
	2993	<a href="det_of_minor.xml" target="_top">Determinant of a Minor</a><br/>
715	2994	example <a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
716	2995	source <a href="det_of_minor.hpp.xml" target="_top">Source: det_of_minor</a><br/>
717		determinant <a href="luratio.xml#LU.Determinant" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU.Determinant</a><br/>
	2996	detection <a href="memory_leak.xml" target="_top">Memory Leak Detection</a><br/>
	2997	determinant <a href="det_by_minor_c.xml" target="_top">Compute Determinant using Expansion by Minors</a><br/>
	2998	<a href="det_of_minor_c.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
	2999	<a href="det_of_minor_c.xml" target="_top">Determinant of a Minor</a><br/>
	3000	<a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	3001	<a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
	3002	<a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	3003	<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
	3004	<a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	3005	<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
	3006	<a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	3007	<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
	3008	<a href="double_det_lu.cpp.xml" target="_top">Double Speed: Determinant Using Lu Factorization</a><br/>
	3009	<a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
	3010	<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	3011	<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
	3012	<a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
	3013	<a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a><br/>
	3014	<a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
	3015	<a href="det_of_minor.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
	3016	<a href="det_of_minor.xml" target="_top">Determinant of a Minor</a><br/>
	3017	<a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a><br/>
	3018	<a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
	3019	<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
	3020	<a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
	3021	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	3022	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	3023	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
	3024	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	3025	<a href="luratio.xml#LU.Determinant" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU.Determinant</a><br/>
	3026	<a href="luratio.xml#LU.Determinant" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU.Determinant</a><br/>
718	3027	<a href="lufactor.xml#LU.Determinant" target="_top">LU Factorization of A Square Matrix: LU.Determinant</a><br/>
	3028	<a href="lufactor.xml#LU.Determinant" target="_top">LU Factorization of A Square Matrix: LU.Determinant</a><br/>
	3029	<a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
719	3030	<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
720	3031	by<b> </b>minors <a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
721	3032	by<b> </b>minors <a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a><br/>

734	3045	speed<b> </b>double <a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
735	3046	speed<b> </b>fadbad <a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
736	3047	speed<b> </b>sacado <a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
	3048	determinant<b>:</b> <a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
	3049	determinants <a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
	3050	determine <a href="time_det_by_minor_c.xml" target="_top">Determine Amount of Time to Execute det_by_minor</a><br/>
	3051	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	3052	<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
	3053	<a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
737	3054	difference<br/>
738	3055	absolute <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
739	3056	central <a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
740	3057	relative <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
741		differential<br/>
	3058	differentiable <a href="not_complex_ad.cpp.xml#Not Complex Differentiable" target="_top">Not Complex Differentiable: Example and Test: Not Complex Differentiable</a><br/>
	3059	differentiable<b>:</b> <a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
	3060	differential <a href="sincosforward.xml#Differential Equation" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory: Differential Equation</a><br/>
	3061	<a href="forwardtheory.xml#Standard Math Functions.Differential Equation" target="_top">The Theory of Forward Mode: Standard Math Functions.Differential Equation</a><br/>
742	3062	equation <a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
743	3063	equation <a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
744	3064	equation <a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
745	3065	ODE<b> </b>error<b> </b>control <a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
746	3066	Ode<b> </b>Gear<b> </b>control <a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
	3067	differentiate <a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
	3068	differentiating <a href="stack_machine.cpp.xml" target="_top">Example Differentiating a Stack Machine Interpreter</a><br/>
	3069	differentiation <a href="introduction.xml#Preface.Algorithmic Differentiation" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Algorithmic Differentiation</a><br/>
	3070	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
	3071	<a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
747	3072	dimension<br/>
748	3073	multi<b> </b>Romberg<b> </b>integration <a href="rombergmul.xml" target="_top">Multi-dimensional Romberg Integration</a><br/>
749		direction<br/>
	3074	dimensional <a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	3075	<a href="romberg_one.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	3076	dimensionalromberg <a href="rombergone.xml" target="_top">One DimensionalRomberg Integration</a><br/>
	3077	direction <a href="reverse_two.xml#Hessian Times Direction" target="_top">Second Order Reverse Mode: Hessian Times Direction</a><br/>
	3078	multiple <a href="forward_dir.xml" target="_top">Multiple Directions Forward Mode</a><br/>
750	3079	times<b> </b>Hessian <a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a><br/>
751		directory<br/>
752		configure<b> </b>postfix <a href="installunix.xml#postfix_dir" target="_top">Unix Test and Installation: postfix_dir</a><br/>
753		configure<b> </b>prefix <a href="installunix.xml#prefix_dir" target="_top">Unix Test and Installation: prefix_dir</a><br/>
754		discrete<br/>
	3080	direction<b>:</b> <a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a><br/>
	3081	directions <a href="wishlist.xml#Multiple Directions" target="_top">The CppAD Wish List: Multiple Directions</a><br/>
	3082	<a href="reverse.xml#Multiple Directions" target="_top">Reverse Mode: Multiple Directions</a><br/>
	3083	<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	3084	<a href="forward_dir.xml" target="_top">Multiple Directions Forward Mode</a><br/>
	3085	directory <a href="installunix.xml#Work Directory" target="_top">Deprecated Unix Test and Installation: Work Directory</a><br/>
	3086	<a href="installunix.xml#Distribution Directory" target="_top">Deprecated Unix Test and Installation: Distribution Directory</a><br/>
	3087	<a href="get_sacado.sh.xml#Prefix Directory" target="_top">Download and Install Sacado in Build Directory: Prefix Directory</a><br/>
	3088	<a href="get_sacado.sh.xml#External Directory" target="_top">Download and Install Sacado in Build Directory: External Directory</a><br/>
	3089	<a href="get_sacado.sh.xml#Distribution Directory" target="_top">Download and Install Sacado in Build Directory: Distribution Directory</a><br/>
	3090	<a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
	3091	<a href="get_ipopt.sh.xml#Prefix Directory" target="_top">Download and Install Ipopt in Build Directory: Prefix Directory</a><br/>
	3092	<a href="get_ipopt.sh.xml#External Directory" target="_top">Download and Install Ipopt in Build Directory: External Directory</a><br/>
	3093	<a href="get_ipopt.sh.xml#Distribution Directory" target="_top">Download and Install Ipopt in Build Directory: Distribution Directory</a><br/>
	3094	<a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
	3095	<a href="get_fadbad.sh.xml#Prefix Directory" target="_top">Download and Install Fadbad in Build Directory: Prefix Directory</a><br/>
	3096	<a href="get_fadbad.sh.xml#External Directory" target="_top">Download and Install Fadbad in Build Directory: External Directory</a><br/>
	3097	<a href="get_fadbad.sh.xml#Distribution Directory" target="_top">Download and Install Fadbad in Build Directory: Distribution Directory</a><br/>
	3098	<a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
	3099	<a href="get_eigen.sh.xml#Prefix Directory" target="_top">Download and Install Eigen in Build Directory: Prefix Directory</a><br/>
	3100	<a href="get_eigen.sh.xml#External Directory" target="_top">Download and Install Eigen in Build Directory: External Directory</a><br/>
	3101	<a href="get_eigen.sh.xml#Distribution Directory" target="_top">Download and Install Eigen in Build Directory: Distribution Directory</a><br/>
	3102	<a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
	3103	<a href="get_colpack.sh.xml#Prefix Directory" target="_top">Download and Install ColPack in Build Directory: Prefix Directory</a><br/>
	3104	<a href="get_colpack.sh.xml#External Directory" target="_top">Download and Install ColPack in Build Directory: External Directory</a><br/>
	3105	<a href="get_colpack.sh.xml#Distribution Directory" target="_top">Download and Install ColPack in Build Directory: Distribution Directory</a><br/>
	3106	<a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
	3107	<a href="get_adolc.sh.xml#Prefix Directory" target="_top">Download and Install Adolc in Build Directory: Prefix Directory</a><br/>
	3108	<a href="get_adolc.sh.xml#External Directory" target="_top">Download and Install Adolc in Build Directory: External Directory</a><br/>
	3109	<a href="get_adolc.sh.xml#Distribution Directory" target="_top">Download and Install Adolc in Build Directory: Distribution Directory</a><br/>
	3110	<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
	3111	<a href="cmake.xml#CMake Command.Build Directory" target="_top">Using CMake to Configure CppAD: CMake Command.Build Directory</a><br/>
	3112	<a href="download.xml#Distribution Directory" target="_top">Download The CppAD Source Code: Distribution Directory</a><br/>
	3113	configure<b> </b>postfix <a href="installunix.xml#postfix_dir" target="_top">Deprecated Unix Test and Installation: postfix_dir</a><br/>
	3114	configure<b> </b>prefix <a href="installunix.xml#prefix_dir" target="_top">Deprecated Unix Test and Installation: prefix_dir</a><br/>
	3115	discrete <a href="discrete.xml" target="_top">Discrete AD Functions</a><br/>
755	3116	AD<b> </b>function <a href="discrete.xml" target="_top">Discrete AD Functions</a><br/>
756	3117	parallel <a href="discrete.xml#Parallel Mode" target="_top">Discrete AD Functions: Parallel Mode</a><br/>
757		disk<br/>
	3118	discussion <a href="odegearcontrol.xml#Error Criteria Discussion" target="_top">An Error Controller for Gear's Ode Solvers: Error Criteria Discussion</a><br/>
	3119	<a href="odeerrcontrol.xml#Error Criteria Discussion" target="_top">An Error Controller for ODE Solvers: Error Criteria Discussion</a><br/>
	3120	<a href="parallel_ad.xml#Discussion" target="_top">Enable AD Calculations During Parallel Mode: Discussion</a><br/>
	3121	<a href="funcheck.xml#Discussion" target="_top">Check an ADFun Sequence of Operations: Discussion</a><br/>
	3122	<a href="comparechange.xml#Discussion" target="_top">Comparison Changes During Zero Order Forward Mode: Discussion</a><br/>
	3123	<a href="atomic_forward.xml#Discussion" target="_top">Atomic Forward Mode: Discussion</a><br/>
	3124	<a href="printfor.xml#Discussion" target="_top">Printing AD Values During Forward Mode: Discussion</a><br/>
	3125	disk <a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
758	3126	tape <a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
	3127	distribution <a href="installunix.xml#Distribution Directory" target="_top">Deprecated Unix Test and Installation: Distribution Directory</a><br/>
	3128	<a href="get_sacado.sh.xml#Distribution Directory" target="_top">Download and Install Sacado in Build Directory: Distribution Directory</a><br/>
	3129	<a href="get_ipopt.sh.xml#Distribution Directory" target="_top">Download and Install Ipopt in Build Directory: Distribution Directory</a><br/>
	3130	<a href="get_fadbad.sh.xml#Distribution Directory" target="_top">Download and Install Fadbad in Build Directory: Distribution Directory</a><br/>
	3131	<a href="get_eigen.sh.xml#Distribution Directory" target="_top">Download and Install Eigen in Build Directory: Distribution Directory</a><br/>
	3132	<a href="get_colpack.sh.xml#Distribution Directory" target="_top">Download and Install ColPack in Build Directory: Distribution Directory</a><br/>
	3133	<a href="get_adolc.sh.xml#Distribution Directory" target="_top">Download and Install Adolc in Build Directory: Distribution Directory</a><br/>
	3134	<a href="download.xml#Distribution Directory" target="_top">Download The CppAD Source Code: Distribution Directory</a><br/>
759	3135	divide<br/>
760	3136	AD<b> </b>example <a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
761	3137	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
762	3138	computed<b> </b>assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
	3139	division <a href="reversetheory.xml#Binary Operators.Division" target="_top">The Theory of Reverse Mode: Binary Operators.Division</a><br/>
	3140	<a href="forwardtheory.xml#Binary Operators.Division" target="_top">The Theory of Forward Mode: Binary Operators.Division</a><br/>
	3141	<a href="compute_assign.xml#Derivative.Division" target="_top">AD Computed Assignment Operators: Derivative.Division</a><br/>
	3142	<a href="ad_binary.xml#Derivative.Division" target="_top">AD Binary Arithmetic Operators: Derivative.Division</a><br/>
	3143	division<b>:</b> <a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
	3144	<a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
763	3145	documentation<br/>
764		install <a href="installunix.xml#--with-Documentation" target="_top">Unix Test and Installation: --with-Documentation</a><br/>
765		install <a href="cmake.xml#cppad_documentation" target="_top">Using CMake to Configure CppAD: cppad_documentation</a><br/>
766		double<br/>
	3146	install <a href="installunix.xml#--with-Documentation" target="_top">Deprecated Unix Test and Installation: --with-Documentation</a><br/>
	3147	documented <a href="preprocessor.xml#Documented Elsewhere" target="_top">CppAD API Preprocessor Symbols: Documented Elsewhere</a><br/>
	3148	<a href="preprocessor.xml#Documented Here" target="_top">CppAD API Preprocessor Symbols: Documented Here</a><br/>
	3149	domain <a href="ipopt_nlp_ode_fast.xml#Trapezoidal Approximation.Domain Indices J(k,0)" target="_top">ODE Fitting Using Fast Representation: Trapezoidal Approximation.Domain Indices J(k,0)</a><br/>
	3150	<a href="ipopt_nlp_ode_fast.xml#Initial Condition.Domain Indices J(k,0)" target="_top">ODE Fitting Using Fast Representation: Initial Condition.Domain Indices J(k,0)</a><br/>
	3151	<a href="ipopt_nlp_ode_fast.xml#Objective Function.Domain Indices J(k,0)" target="_top">ODE Fitting Using Fast Representation: Objective Function.Domain Indices J(k,0)</a><br/>
	3152	<a href="seq_property.xml#Domain" target="_top">ADFun Sequence Properties: Domain</a><br/>
	3153	double <a href="double_sparse_jacobian.cpp.xml" target="_top">Double Speed: Sparse Jacobian</a><br/>
	3154	<a href="double_sparse_hessian.cpp.xml" target="_top">Double Speed: Sparse Hessian</a><br/>
	3155	<a href="double_poly.cpp.xml" target="_top">Double Speed: Evaluate a Polynomial</a><br/>
	3156	<a href="double_ode.cpp.xml" target="_top">Double Speed: Ode Solution</a><br/>
	3157	<a href="double_det_lu.cpp.xml" target="_top">Double Speed: Determinant Using Lu Factorization</a><br/>
	3158	<a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
	3159	<a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
	3160	<a href="link_sparse_jacobian.xml#n_sweep.double" target="_top">Speed Testing Sparse Jacobian: n_sweep.double</a><br/>
	3161	<a href="link_sparse_hessian.xml#hessian.double" target="_top">Speed Testing Sparse Hessian: hessian.double</a><br/>
	3162	<a href="link_poly.xml#ddp.double" target="_top">Speed Testing Second Derivative of a Polynomial: ddp.double</a><br/>
	3163	<a href="link_ode.xml#jacobian.double" target="_top">Speed Testing the Jacobian of Ode Solution: jacobian.double</a><br/>
	3164	<a href="link_det_minor.xml#gradient.double" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: gradient.double</a><br/>
	3165	<a href="link_det_lu.xml#gradient.double" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: gradient.double</a><br/>
	3166	<a href="speed_main.xml#package.double" target="_top">Running the Speed Test Program: package.double</a><br/>
	3167	<a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
	3168	<a href="base_member.xml#Double Constructor" target="_top">Required Base Class Member Functions: Double Constructor</a><br/>
767	3169	Base <a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
768	3170	Base <a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
769	3171	complex<b> </b>Base <a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>

780	3182	speed <a href="double_det_lu.cpp.xml" target="_top">Double Speed: Determinant Using Lu Factorization</a><br/>
781	3183	speed <a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
782	3184	speed<b> </b>test <a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
783		download<br/>
	3185	download <a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
	3186	<a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
	3187	<a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
	3188	<a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
	3189	<a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
	3190	<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
	3191	<a href="download.xml" target="_top">Download The CppAD Source Code</a><br/>
	3192	<a href="install.xml#Instructions.Step 1: Download" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 1: Download</a><br/>
	3193	<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
784	3194	cppad <a href="download.xml" target="_top">Download The CppAD Source Code</a><br/>
785	3195	install<b> </b>adolc <a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
786	3196	install<b> </b>colpack <a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>

788	3198	install<b> </b>fadbad <a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
789	3199	install<b> </b>ipopt <a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
790	3200	install<b> </b>sacado <a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
791		driver<br/>
	3201	driver <a href="ipopt_nlp_ode_run.hpp.xml" target="_top">Driver for Running the Ipopt ODE Example</a><br/>
	3202	<a href="sparse_hessian.xml" target="_top">Sparse Hessian: Easy Driver</a><br/>
	3203	<a href="sparse_jacobian.xml" target="_top">Sparse Jacobian: Easy Driver</a><br/>
	3204	<a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
	3205	<a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
	3206	<a href="hessian.xml" target="_top">Hessian: Easy Driver</a><br/>
	3207	<a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
	3208	<a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a><br/>
	3209	<a href="jacobian.xml" target="_top">Jacobian: Driver Routine</a><br/>
792	3210	easy <a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
793	3211	easy<b> </b>derivative <a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
794	3212	easy<b> </b>partial <a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>

800	3218	Jacobian <a href="jacobian.xml" target="_top">Jacobian: Driver Routine</a><br/>
801	3219	second<b> </b>order<b> </b>partial <a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
802	3220	second<b> </b>order<b> </b>partial <a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
	3221	driver<b>:</b> <a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a><br/>
	3222	<a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a><br/>
	3223	<a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a><br/>
	3224	drivers <a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
	3225	during <a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a><br/>
	3226	<a href="whats_new_04.xml" target="_top">Changes and Additions to CppAD During 2004</a><br/>
	3227	<a href="whats_new_05.xml" target="_top">Changes and Additions to CppAD During 2005</a><br/>
	3228	<a href="whats_new_06.xml" target="_top">Changes and Additions to CppAD During 2006</a><br/>
	3229	<a href="whats_new_07.xml" target="_top">Changes and Additions to CppAD During 2007</a><br/>
	3230	<a href="whats_new_08.xml" target="_top">Changes and Additions to CppAD During 2008</a><br/>
	3231	<a href="whats_new_09.xml" target="_top">Changes and Additions to CppAD During 2009</a><br/>
	3232	<a href="whats_new_10.xml" target="_top">Changes and Additions to CppAD During 2010</a><br/>
	3233	<a href="whats_new_11.xml" target="_top">Changes and Additions to CppAD During 2011</a><br/>
	3234	<a href="whats_new_12.xml" target="_top">CppAD Changes and Additions During 2012</a><br/>
	3235	<a href="whats_new_13.xml" target="_top">CppAD Changes and Additions During 2013</a><br/>
	3236	<a href="whats_new_14.xml" target="_top">CppAD Changes and Additions During 2014</a><br/>
	3237	<a href="cppad_assert.xml" target="_top">CppAD Assertions During Execution</a><br/>
	3238	<a href="parallel_ad.xml" target="_top">Enable AD Calculations During Parallel Mode</a><br/>
	3239	<a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
	3240	<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
	3241	<a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
	3242	<a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
	3243	dvector <a href="ipopt_solve.xml#Dvector" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Dvector</a><br/>
	3244	dw <a href="revone.xml#dw" target="_top">First Order Derivative: Driver Routine: dw</a><br/>
	3245	<a href="reverse_any.xml#dw" target="_top">Any Order Reverse Mode: dw</a><br/>
	3246	<a href="reverse_two.xml#dw" target="_top">Second Order Reverse Mode: dw</a><br/>
	3247	<a href="reverse_one.xml#dw" target="_top">First Order Reverse Mode: dw</a><br/>
	3248	dy <a href="forone.xml#dy" target="_top">First Order Partial Derivative: Driver Routine: dy</a><br/>
	3249	dz <a href="link_mat_mul.xml#dz" target="_top">Speed Testing Derivative of Matrix Multiply: dz</a><br/>
803	3250
804	3251	<b><big><a name="E">E</a></big></b>
805	3252	<br/>
806	3253	Eigen<br/>
807		unix <a href="installunix.xml#eigen_dir" target="_top">Unix Test and Installation: eigen_dir</a><br/>
	3254	unix <a href="installunix.xml#eigen_dir" target="_top">Deprecated Unix Test and Installation: eigen_dir</a><br/>
808	3255	EqualOpSeq <a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
809	3256	base<b> </b>require <a href="base_identical.xml#EqualOpSeq" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq</a><br/>
810	3257	example <a href="equal_op_seq.cpp.xml" target="_top">EqualOpSeq: Example and Test</a><br/>

812	3259	parallel <a href="errorhandler.xml#Constructor.Parallel Mode" target="_top">Replacing the CppAD Error Handler: Constructor.Parallel Mode</a><br/>
813	3260	Euclidean<br/>
814	3261	norm<b> </b>example <a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>
815		easy<br/>
	3262	e <a href="odegear.xml#e" target="_top">An Arbitrary Order Gear Method: e</a><br/>
	3263	<a href="rosen34.xml#e" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: e</a><br/>
	3264	<a href="runge45.xml#e" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: e</a><br/>
	3265	<a href="rombergmul.xml#e" target="_top">Multi-dimensional Romberg Integration: e</a><br/>
	3266	<a href="rombergone.xml#e" target="_top">One DimensionalRomberg Integration: e</a><br/>
	3267	eabs <a href="odegearcontrol.xml#eabs" target="_top">An Error Controller for Gear's Ode Solvers: eabs</a><br/>
	3268	<a href="odeerrcontrol.xml#eabs" target="_top">An Error Controller for ODE Solvers: eabs</a><br/>
	3269	easy <a href="sparse_hessian.xml" target="_top">Sparse Hessian: Easy Driver</a><br/>
	3270	<a href="sparse_jacobian.xml" target="_top">Sparse Jacobian: Easy Driver</a><br/>
	3271	<a href="hessian.xml" target="_top">Hessian: Easy Driver</a><br/>
	3272	<a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
816	3273	derivative <a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
817	3274	driver <a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
818	3275	partial <a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
819	3276	partial <a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
820	3277	partial <a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a><br/>
821		efficient<br/>
	3278	ef <a href="odegearcontrol.xml#ef" target="_top">An Error Controller for Gear's Ode Solvers: ef</a><br/>
	3279	<a href="odeerrcontrol.xml#ef" target="_top">An Error Controller for ODE Solvers: ef</a><br/>
	3280	efficiency <a href="optimize.xml#Efficiency" target="_top">Optimize an ADFun Object Tape: Efficiency</a><br/>
	3281	<a href="introduction.xml#Preface.Efficiency" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Efficiency</a><br/>
	3282	efficient <a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
822	3283	omp<b>_</b>alloc <a href="omp_efficient.xml#Removed" target="_top">Check If A Memory Allocation is Efficient for Another Use: Removed</a><br/>
823	3284	sparsity <a href="glossary.xml#Sparsity Pattern" target="_top">Glossary: Sparsity Pattern</a><br/>
824		eigen<br/>
	3285	eigen <a href="testvector.xml#Eigen Vectors" target="_top">Using The CppAD Test Vector Template Class: Eigen Vectors</a><br/>
	3286	<a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
	3287	<a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
	3288	<a href="cppad_eigen.hpp.xml#Eigen NumTraits" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: Eigen NumTraits</a><br/>
	3289	<a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
	3290	<a href="cppad_testvector.xml#eigen" target="_top">Choosing the CppAD Test Vector Template Class: eigen</a><br/>
	3291	<a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
	3292	<a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a><br/>
825	3293	array<b> </b>example <a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
826	3294	determinant<b> </b>example <a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
827	3295	download<b> </b>and<b> </b>install <a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>

829	3297	example <a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a><br/>
830	3298	get <a href="eigen_prefix.xml#get_eigen" target="_top">Including the Eigen Examples and Tests: get_eigen</a><br/>
831	3299	prefix <a href="eigen_prefix.xml#eigen_prefix" target="_top">Including the Eigen Examples and Tests: eigen_prefix</a><br/>
832		test<b> </b>vector <a href="installunix.xml#--with-testvector" target="_top">Unix Test and Installation: --with-testvector</a><br/>
	3300	test<b> </b>vector <a href="installunix.xml#--with-testvector" target="_top">Deprecated Unix Test and Installation: --with-testvector</a><br/>
833	3301	vector <a href="cppad_testvector.xml#eigen" target="_top">Choosing the CppAD Test Vector Template Class: eigen</a><br/>
834	3302	vector <a href="eigen_prefix.xml#Test Vector" target="_top">Including the Eigen Examples and Tests: Test Vector</a><br/>
835		elapsed<br/>
	3303	eigen<b>_</b>dir <a href="installunix.xml#eigen_dir" target="_top">Deprecated Unix Test and Installation: eigen_dir</a><br/>
	3304	eigen<b>_</b>plugin<b>.</b>hpp <a href="eigen_plugin.hpp.xml" target="_top">Source Code for eigen_plugin.hpp</a><br/>
	3305	eigen<b>_</b>prefix <a href="eigen_prefix.xml#eigen_prefix" target="_top">Including the Eigen Examples and Tests: eigen_prefix</a><br/>
	3306	elapsed <a href="elapsed_seconds_c.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	3307	<a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a><br/>
	3308	<a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a><br/>
	3309	<a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
836	3310	seconds <a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a><br/>
837	3311	elapsed<b>_</b>seconds <a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	3312	element <a href="cppad_vector.xml#vectorBool.Element Type" target="_top">The CppAD::vector Template Class: vectorBool.Element Type</a><br/>
	3313	<a href="cppad_vector.xml#Element Access" target="_top">The CppAD::vector Template Class: Element Access</a><br/>
	3314	<a href="simplevector.xml#Element Access" target="_top">Definition of a Simple Vector: Element Access</a><br/>
	3315	<a href="simplevector.xml#Element Constructor and Destructor" target="_top">Definition of a Simple Vector: Element Constructor and Destructor</a><br/>
	3316	<a href="atomic_matrix_mul.hpp.xml#Result Element Index" target="_top">Matrix Multiply as an Atomic Operation: Result Element Index</a><br/>
	3317	<a href="atomic_matrix_mul.hpp.xml#Right Operand Element Index" target="_top">Matrix Multiply as an Atomic Operation: Right Operand Element Index</a><br/>
	3318	<a href="atomic_matrix_mul.hpp.xml#Left Operand Element Index" target="_top">Matrix Multiply as an Atomic Operation: Left Operand Element Index</a><br/>
838	3319	elementary <a href="glossary.xml#Elementary Vector" target="_top">Glossary: Elementary Vector</a><br/>
839		epsilon<br/>
	3320	elements <a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	3321	<a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
	3322	<a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
	3323	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	3324	<a href="simplevector.xml#Elements of Specified Type" target="_top">Definition of a Simple Vector: Elements of Specified Type</a><br/>
	3325	eliminating <a href="tan_reverse.xml#Eliminating Y(t)" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory: Eliminating Y(t)</a><br/>
	3326	elsewhere <a href="preprocessor.xml#Documented Elsewhere" target="_top">CppAD API Preprocessor Symbols: Documented Elsewhere</a><br/>
	3327	embedded <a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
	3328	enable <a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
	3329	<a href="parallel_ad.xml" target="_top">Enable AD Calculations During Parallel Mode</a><br/>
	3330	<a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
	3331	<a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
	3332	<a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
	3333	<a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
	3334	end <a href="atomic_matrix_mul.hpp.xml#End Class Definition" target="_top">Matrix Multiply as an Atomic Operation: End Class Definition</a><br/>
	3335	<a href="atomic_tangent.cpp.xml#End Class Definition" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: End Class Definition</a><br/>
	3336	<a href="atomic_reciprocal.cpp.xml#End Class Definition" target="_top">Reciprocal as an Atomic Operation: Example and Test: End Class Definition</a><br/>
	3337	<a href="atomic_norm_sq.cpp.xml#End Class Definition" target="_top">Euclidean Norm Squared: Example and Test: End Class Definition</a><br/>
	3338	<a href="atomic_get_started.cpp.xml#End Class Definition" target="_top">Getting Started with Atomic Operations: Example and Test: End Class Definition</a><br/>
	3339	entire <a href="revsparsehes.xml#Entire Sparsity Pattern" target="_top">Hessian Sparsity Pattern: Reverse Mode: Entire Sparsity Pattern</a><br/>
	3340	<a href="revsparsejac.xml#Entire Sparsity Pattern" target="_top">Jacobian Sparsity Pattern: Reverse Mode: Entire Sparsity Pattern</a><br/>
	3341	<a href="forsparsejac.xml#Entire Sparsity Pattern" target="_top">Jacobian Sparsity Pattern: Forward Mode: Entire Sparsity Pattern</a><br/>
	3342	environment <a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	3343	<a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
	3344	eps <a href="epsilon.xml#eps" target="_top">Machine Epsilon For AD Types: eps</a><br/>
	3345	<a href="limits.xml#eps" target="_top">Numeric Limits For an AD and Base Types: eps</a><br/>
	3346	epsilon <a href="epsilon.xml" target="_top">Machine Epsilon For AD Types</a><br/>
	3347	<a href="multi_newton_work.cpp.xml#xlow.epsilon" target="_top">Multi-threading Newton Method Utility Routines: xlow.epsilon</a><br/>
	3348	<a href="multi_newton.cpp.xml#epsilon" target="_top">A Multi-Threaded Newton's Method: epsilon</a><br/>
	3349	<a href="base_std_math.xml#limits.epsilon" target="_top">Base Type Requirements for Standard Math Functions: limits.epsilon</a><br/>
	3350	<a href="exp_eps_rev2.xml#epsilon" target="_top">exp_eps: Second Order Reverse Sweep: epsilon</a><br/>
	3351	<a href="exp_eps_rev1.xml#epsilon" target="_top">exp_eps: First Order Reverse Sweep: epsilon</a><br/>
	3352	<a href="exp_eps.xml#epsilon" target="_top">An Epsilon Accurate Exponential Approximation: epsilon</a><br/>
	3353	<a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
840	3354	AD <a href="epsilon.xml" target="_top">Machine Epsilon For AD Types</a><br/>
841	3355	AD <a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
842		equal<br/>
	3356	equal <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
	3357	<a href="base_identical.xml" target="_top">Base Type Requirements for Identically Equal Comparisons</a><br/>
	3358	<a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
	3359	<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
843	3360	near <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
844	3361	operation<b> </b>sequence <a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
845		equation<br/>
	3362	equalopseq <a href="base_complex.hpp.xml#EqualOpSeq" target="_top">Enable use of AD<Base> where Base is std::complex<double>: EqualOpSeq</a><br/>
	3363	<a href="base_double.hpp.xml#EqualOpSeq" target="_top">Enable use of AD<Base> where Base is double: EqualOpSeq</a><br/>
	3364	<a href="base_float.hpp.xml#EqualOpSeq" target="_top">Enable use of AD<Base> where Base is float: EqualOpSeq</a><br/>
	3365	<a href="base_adolc.hpp.xml#EqualOpSeq" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: EqualOpSeq</a><br/>
	3366	<a href="base_alloc.hpp.xml#EqualOpSeq" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: EqualOpSeq</a><br/>
	3367	<a href="base_identical.xml#EqualOpSeq" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq</a><br/>
	3368	equalopseq<b>:</b> <a href="equal_op_seq.cpp.xml" target="_top">EqualOpSeq: Example and Test</a><br/>
	3369	equation <a href="sincosforward.xml#Differential Equation" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory: Differential Equation</a><br/>
	3370	<a href="forwardtheory.xml#Standard Math Functions.Differential Equation" target="_top">The Theory of Forward Mode: Standard Math Functions.Differential Equation</a><br/>
	3371	<a href="luinvert.xml" target="_top">Invert an LU Factored Equation</a><br/>
846	3372	differential <a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
847	3373	differential <a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
848	3374	differential <a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>

854	3380	ODE<b> </b>error<b> </b>control <a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
855	3381	Ode<b> </b>Gear<b> </b>control <a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
856	3382	solve<b> </b>linear <a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
	3383	equations <a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
	3384	<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
	3385	erel <a href="odegearcontrol.xml#erel" target="_top">An Error Controller for Gear's Ode Solvers: erel</a><br/>
	3386	<a href="odeerrcontrol.xml#erel" target="_top">An Error Controller for ODE Solvers: erel</a><br/>
857	3387	erf <a href="whats_new_08.xml#11-20" target="_top">Changes and Additions to CppAD During 2008: 11-20</a><br/>
	3388	<a href="base_complex.hpp.xml#erf" target="_top">Enable use of AD<Base> where Base is std::complex<double>: erf</a><br/>
	3389	<a href="base_adolc.hpp.xml#erf" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: erf</a><br/>
	3390	<a href="base_alloc.hpp.xml#erf" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: erf</a><br/>
	3391	<a href="base_std_math.xml#erf" target="_top">Base Type Requirements for Standard Math Functions: erf</a><br/>
	3392	<a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a><br/>
858	3393	AD<b> </b>function <a href="erf.xml" target="_top">The AD Error Function</a><br/>
	3394	base<b> </b>require <a href="base_std_math.xml#erf" target="_top">Base Type Requirements for Standard Math Functions: erf</a><br/>
859	3395	example <a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a><br/>
860		error<br/>
	3396	forward<b> </b>theory <a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a><br/>
	3397	reverse<b> </b>theory <a href="erf_reverse.xml" target="_top">Error Function Reverse Mode Theory</a><br/>
	3398	error <a href="memory_leak.xml#Error Message" target="_top">Memory Leak Detection: Error Message</a><br/>
	3399	<a href="erf_reverse.xml" target="_top">Error Function Reverse Mode Theory</a><br/>
	3400	<a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a><br/>
	3401	<a href="odegearcontrol.xml#Error Criteria Discussion" target="_top">An Error Controller for Gear's Ode Solvers: Error Criteria Discussion</a><br/>
	3402	<a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
	3403	<a href="odeerrcontrol.xml#Error Criteria Discussion" target="_top">An Error Controller for ODE Solvers: Error Criteria Discussion</a><br/>
	3404	<a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
	3405	<a href="cppad_assert.xml#Error Handler" target="_top">CppAD Assertions During Execution: Error Handler</a><br/>
	3406	<a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
	3407	<a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
	3408	<a href="library.xml#Error Handler" target="_top">The CppAD General Purpose Library: Error Handler</a><br/>
	3409	<a href="erf.xml" target="_top">The AD Error Function</a><br/>
861	3410	AD<b> </b>function <a href="erf.xml" target="_top">The AD Error Function</a><br/>
862	3411	assert<b> </b>macro <a href="cppad_assert.xml" target="_top">CppAD Assertions During Execution</a><br/>
863	3412	control<b> </b>ODE <a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
864	3413	Gear<b> </b>Ode <a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
865	3414	handler <a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
866	3415	handler <a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
867		evaluate<br/>
	3416	errors <a href="speedtest.xml#Errors" target="_top">Run One Speed Test and Print Results: Errors</a><br/>
	3417	euclidean <a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>
	3418	evaluate <a href="double_poly.cpp.xml" target="_top">Double Speed: Evaluate a Polynomial</a><br/>
	3419	<a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
	3420	<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
	3421	<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
	3422	<a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
	3423	<a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a><br/>
868	3424	ADFun <a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a><br/>
869		example <a href="example.xml" target="_top">Examples</a><br/>
	3425	evaluating <a href="bib.xml#Evaluating Derivatives" target="_top">Bibliography: Evaluating Derivatives</a><br/>
	3426	evaluation<b>:</b> <a href="poly.cpp.xml" target="_top">Polynomial Evaluation: Example and Test</a><br/>
	3427	example <a href="old_mat_mul.hpp.xml#Example" target="_top">Define Matrix Multiply as a User Atomic Operation: Example</a><br/>
	3428	<a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	3429	<a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	3430	<a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
	3431	<a href="old_atomic.xml#Example" target="_top">User Defined Atomic AD Functions: Example</a><br/>
	3432	<a href="ipopt_nlp_ode_run.hpp.xml" target="_top">Driver for Running the Ipopt ODE Example</a><br/>
	3433	<a href="ipopt_nlp_ode_problem.xml" target="_top">An ODE Inverse Problem Example</a><br/>
	3434	<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
	3435	<a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	3436	<a href="cppad_ipopt_nlp.xml#Example" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: Example</a><br/>
	3437	<a href="omp_alloc.cpp.xml" target="_top">OpenMP Memory Allocator: Example and Test</a><br/>
	3438	<a href="omp_delete_array.xml#Example" target="_top">Return A Raw Array to The Available Memory for a Thread: Example</a><br/>
	3439	<a href="omp_create_array.xml#Example" target="_top">Allocate Memory and Create A Raw Array: Example</a><br/>
	3440	<a href="omp_available.xml#Example" target="_top">Amount of Memory Available for Quick Use by a Thread: Example</a><br/>
	3441	<a href="omp_inuse.xml#Example" target="_top">Amount of Memory a Thread is Currently Using: Example</a><br/>
	3442	<a href="omp_free_available.xml#Example" target="_top">Free Memory Currently Available for Quick Use by a Thread: Example</a><br/>
	3443	<a href="omp_return_memory.xml#Example" target="_top">Return Memory to omp_alloc: Example</a><br/>
	3444	<a href="omp_get_memory.xml#Example" target="_top">Get At Least A Specified Amount of Memory: Example</a><br/>
	3445	<a href="omp_get_thread_num.xml#Example" target="_top">Get the Current OpenMP Thread Number: Example</a><br/>
	3446	<a href="omp_in_parallel.xml#Example" target="_top">Is The Current Execution in OpenMP Parallel Mode: Example</a><br/>
	3447	<a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
	3448	<a href="tracknewdel.xml#Example" target="_top">Routines That Track Use of New and Delete: Example</a><br/>
	3449	<a href="bugs.xml#gcc 3.4.4 -O2.Example" target="_top">Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2.Example</a><br/>
	3450	<a href="sparse_hes_fun.cpp.xml" target="_top">sparse_hes_fun: Example and test</a><br/>
	3451	<a href="sparse_hes_fun.xml#Example" target="_top">Evaluate a Function That Has a Sparse Hessian: Example</a><br/>
	3452	<a href="sparse_jac_fun.cpp.xml" target="_top">sparse_jac_fun: Example and test</a><br/>
	3453	<a href="sparse_jac_fun.xml#Example" target="_top">Evaluate a Function That Has a Sparse Jacobian: Example</a><br/>
	3454	<a href="ode_evaluate.cpp.xml" target="_top">ode_evaluate: Example and test</a><br/>
	3455	<a href="ode_evaluate.xml#Example" target="_top">Evaluate a Function Defined in Terms of an ODE: Example</a><br/>
	3456	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	3457	<a href="mat_sum_sq.xml#Example" target="_top">Sum Elements of a Matrix Times Itself: Example</a><br/>
	3458	<a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
	3459	<a href="det_by_minor.xml#Example" target="_top">Determinant Using Expansion by Minors: Example</a><br/>
	3460	<a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
	3461	<a href="det_of_minor.xml#Example" target="_top">Determinant of a Minor: Example</a><br/>
	3462	<a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a><br/>
	3463	<a href="det_by_lu.xml#Example" target="_top">Determinant Using Expansion by Lu Factorization: Example</a><br/>
	3464	<a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	3465	<a href="lu_vec_ad.cpp.xml#Example" target="_top">Lu Factor and Solve with Recorded Pivoting: Example</a><br/>
	3466	<a href="stack_machine.cpp.xml" target="_top">Example Differentiating a Stack Machine Interpreter</a><br/>
	3467	<a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	3468	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	3469	<a href="mul_level_ode.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	3470	<a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
	3471	<a href="mul_level.cpp.xml" target="_top">Multiple Tapes: Example and Test</a><br/>
	3472	<a href="mul_level.xml#Example" target="_top">Using Multiple Levels of AD: Example</a><br/>
	3473	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	3474	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	3475	<a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
	3476	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
	3477	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	3478	<a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
	3479	<a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
	3480	<a href="cppad_eigen.hpp.xml#Example" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: Example</a><br/>
	3481	<a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
	3482	<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	3483	<a href="example.xml" target="_top">Examples</a><br/>
	3484	<a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a><br/>
	3485	<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	3486	<a href="ipopt_solve.xml#Example" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Example</a><br/>
	3487	<a href="lu_ratio.cpp.xml" target="_top">LuRatio: Example and Test</a><br/>
	3488	<a href="luratio.xml#Example" target="_top">LU Factorization of A Square Matrix and Stability Calculation: Example</a><br/>
	3489	<a href="opt_val_hes.cpp.xml" target="_top">opt_val_hes: Example and Test</a><br/>
	3490	<a href="opt_val_hes.xml#Example" target="_top">Jacobian and Hessian of Optimal Values: Example</a><br/>
	3491	<a href="bender_quad.cpp.xml" target="_top">BenderQuad: Example and Test</a><br/>
	3492	<a href="benderquad.xml#Example" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: Example</a><br/>
	3493	<a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a><br/>
	3494	<a href="index_sort.xml#Example" target="_top">Returns Indices that Sort a Vector: Example</a><br/>
	3495	<a href="ta_free_all.xml#Example" target="_top">Free All Memory That Was Allocated for Use by thread_alloc: Example</a><br/>
	3496	<a href="ta_delete_array.xml#Example" target="_top">Deallocate An Array and Call Destructor for its Elements: Example</a><br/>
	3497	<a href="ta_create_array.xml#Example" target="_top">Allocate An Array and Call Default Constructor for its Elements: Example</a><br/>
	3498	<a href="ta_available.xml#Example" target="_top">Amount of Memory Available for Quick Use by a Thread: Example</a><br/>
	3499	<a href="ta_inuse.xml#Example" target="_top">Amount of Memory a Thread is Currently Using: Example</a><br/>
	3500	<a href="ta_free_available.xml#Example" target="_top">Free Memory Currently Available for Quick Use by a Thread: Example</a><br/>
	3501	<a href="ta_return_memory.xml#Example" target="_top">Return Memory to thread_alloc: Example</a><br/>
	3502	<a href="ta_get_memory.xml#Example" target="_top">Get At Least A Specified Amount of Memory: Example</a><br/>
	3503	<a href="ta_thread_num.xml#Example" target="_top">Get the Current Thread Number: Example</a><br/>
	3504	<a href="ta_in_parallel.xml#Example" target="_top">Is The Current Execution in Parallel Mode: Example</a><br/>
	3505	<a href="ta_num_threads.xml#Example" target="_top">Get Number of Threads: Example</a><br/>
	3506	<a href="ta_parallel_setup.xml#Example" target="_top">Setup thread_alloc For Use in Multi-Threading Environment: Example</a><br/>
	3507	<a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
	3508	<a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
	3509	<a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
	3510	<a href="cppad_vector.xml#Example" target="_top">The CppAD::vector Template Class: Example</a><br/>
	3511	<a href="ode_gear_control.cpp.xml" target="_top">OdeGearControl: Example and Test</a><br/>
	3512	<a href="odegearcontrol.xml#Example" target="_top">An Error Controller for Gear's Ode Solvers: Example</a><br/>
	3513	<a href="ode_gear.cpp.xml" target="_top">OdeGear: Example and Test</a><br/>
	3514	<a href="odegear.xml#Example" target="_top">An Arbitrary Order Gear Method: Example</a><br/>
	3515	<a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a><br/>
	3516	<a href="ode_err_control.cpp.xml" target="_top">OdeErrControl: Example and Test</a><br/>
	3517	<a href="odeerrcontrol.xml#Example" target="_top">An Error Controller for ODE Solvers: Example</a><br/>
	3518	<a href="rosen_34.cpp.xml" target="_top">Rosen34: Example and Test</a><br/>
	3519	<a href="rosen34.xml#Example" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Example</a><br/>
	3520	<a href="runge45_2.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
	3521	<a href="runge45_1.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
	3522	<a href="runge45.xml#Example" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Example</a><br/>
	3523	<a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	3524	<a href="rombergmul.xml#Example" target="_top">Multi-dimensional Romberg Integration: Example</a><br/>
	3525	<a href="romberg_one.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	3526	<a href="rombergone.xml#Example" target="_top">One DimensionalRomberg Integration: Example</a><br/>
	3527	<a href="lu_invert.cpp.xml" target="_top">LuInvert: Example and Test</a><br/>
	3528	<a href="luinvert.xml#Example" target="_top">Invert an LU Factored Equation: Example</a><br/>
	3529	<a href="lu_factor.cpp.xml" target="_top">LuFactor: Example and Test</a><br/>
	3530	<a href="lufactor.xml#Example" target="_top">LU Factorization of A Square Matrix: Example</a><br/>
	3531	<a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
	3532	<a href="lusolve.xml#Example" target="_top">Compute Determinant and Solve Linear Equations: Example</a><br/>
	3533	<a href="poly.cpp.xml" target="_top">Polynomial Evaluation: Example and Test</a><br/>
	3534	<a href="poly.xml#Example" target="_top">Evaluate a Polynomial or its Derivative: Example</a><br/>
	3535	<a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a><br/>
	3536	<a href="pow_int.xml#Example" target="_top">The Integer Power Function: Example</a><br/>
	3537	<a href="nan.cpp.xml" target="_top">nan: Example and Test</a><br/>
	3538	<a href="nan.xml#Example" target="_top">Obtain Nan or Determine if a Value is Nan: Example</a><br/>
	3539	<a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a><br/>
	3540	<a href="checksimplevector.xml#Example" target="_top">Check Simple Vector Concept: Example</a><br/>
	3541	<a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a><br/>
	3542	<a href="simplevector.xml#Example" target="_top">Definition of a Simple Vector: Example</a><br/>
	3543	<a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>
	3544	<a href="checknumerictype.xml#Example" target="_top">Check NumericType Class Concept: Example</a><br/>
	3545	<a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a><br/>
	3546	<a href="numerictype.xml#Example" target="_top">Definition of a Numeric Type: Example</a><br/>
	3547	<a href="time_test.cpp.xml" target="_top">time_test: Example and test</a><br/>
	3548	<a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a><br/>
	3549	<a href="elapsed_seconds.xml#Example" target="_top">Returns Elapsed Number of Seconds: Example</a><br/>
	3550	<a href="time_test.xml#Example" target="_top">Determine Amount of Time to Execute a Test: Example</a><br/>
	3551	<a href="speed_program.cpp.xml" target="_top">Example Use of SpeedTest</a><br/>
	3552	<a href="speed_test.cpp.xml" target="_top">speed_test: Example and test</a><br/>
	3553	<a href="speedtest.xml#Example" target="_top">Run One Speed Test and Print Results: Example</a><br/>
	3554	<a href="speed_test.xml#Example" target="_top">Run One Speed Test and Return Results: Example</a><br/>
	3555	<a href="near_equal.cpp.xml" target="_top">NearEqual Function: Example and Test</a><br/>
	3556	<a href="nearequal.xml#Example" target="_top">Determine if Two Values Are Nearly Equal: Example</a><br/>
	3557	<a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
	3558	<a href="errorhandler.xml#Example" target="_top">Replacing the CppAD Error Handler: Example</a><br/>
	3559	<a href="team_thread.hpp.xml#Example Implementation" target="_top">Specifications for A Team of AD Threads: Example Implementation</a><br/>
	3560	<a href="team_thread.hpp.xml#Example Use" target="_top">Specifications for A Team of AD Threads: Example Use</a><br/>
	3561	<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
	3562	<a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
	3563	<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
	3564	<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
	3565	<a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
	3566	<a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
	3567	<a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
	3568	<a href="parallel_ad.xml#Example" target="_top">Enable AD Calculations During Parallel Mode: Example</a><br/>
	3569	<a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
	3570	<a href="check_for_nan.xml#Example" target="_top">Check an ADFun Object For Nan: Example</a><br/>
	3571	<a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>
	3572	<a href="optimize.xml#Example" target="_top">Optimize an ADFun Object Tape: Example</a><br/>
	3573	<a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
	3574	<a href="funcheck.xml#Example" target="_top">Check an ADFun Sequence of Operations: Example</a><br/>
	3575	<a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a><br/>
	3576	<a href="sparse_hessian.xml#Example" target="_top">Sparse Hessian: Easy Driver: Example</a><br/>
	3577	<a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a><br/>
	3578	<a href="sparse_jacobian.xml#Example" target="_top">Sparse Jacobian: Easy Driver: Example</a><br/>
	3579	<a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a><br/>
	3580	<a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
	3581	<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	3582	<a href="hessian.cpp.xml" target="_top">Hessian: Example and Test</a><br/>
	3583	<a href="hessian.xml#Example" target="_top">Hessian: Easy Driver: Example</a><br/>
	3584	<a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a><br/>
	3585	<a href="revone.xml#Example" target="_top">First Order Derivative: Driver Routine: Example</a><br/>
	3586	<a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a><br/>
	3587	<a href="forone.xml#Example" target="_top">First Order Partial Derivative: Driver Routine: Example</a><br/>
	3588	<a href="jacobian.cpp.xml" target="_top">Jacobian: Example and Test</a><br/>
	3589	<a href="jacobian.xml#Example" target="_top">Jacobian: Driver Routine: Example</a><br/>
	3590	<a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>
	3591	<a href="revsparsehes.xml#Example" target="_top">Hessian Sparsity Pattern: Reverse Mode: Example</a><br/>
	3592	<a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
	3593	<a href="revsparsejac.xml#Example" target="_top">Jacobian Sparsity Pattern: Reverse Mode: Example</a><br/>
	3594	<a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
	3595	<a href="forsparsejac.xml#Example" target="_top">Jacobian Sparsity Pattern: Forward Mode: Example</a><br/>
	3596	<a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a><br/>
	3597	<a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a><br/>
	3598	<a href="reverse_any.xml#Example" target="_top">Any Order Reverse Mode: Example</a><br/>
	3599	<a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a><br/>
	3600	<a href="reverse_two.xml#Example" target="_top">Second Order Reverse Mode: Example</a><br/>
	3601	<a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a><br/>
	3602	<a href="reverse_one.xml#Example" target="_top">First Order Reverse Mode: Example</a><br/>
	3603	<a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	3604	<a href="number_skip.xml#Example" target="_top">Number of Variables that Can be Skipped: Example</a><br/>
	3605	<a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	3606	<a href="capacity_order.xml#Example" target="_top">Controlling Taylor Coefficients Memory Allocation: Example</a><br/>
	3607	<a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
	3608	<a href="comparechange.xml#Example" target="_top">Comparison Changes During Zero Order Forward Mode: Example</a><br/>
	3609	<a href="size_order.xml#Example" target="_top">Number Taylor Coefficient Orders Currently Stored: Example</a><br/>
	3610	<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	3611	<a href="forward_dir.xml#Example" target="_top">Multiple Directions Forward Mode: Example</a><br/>
	3612	<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	3613	<a href="forward.cpp.xml" target="_top">Forward Mode: Example and Test</a><br/>
	3614	<a href="forward_order.xml#Example" target="_top">Multiple Order Forward Mode: Example</a><br/>
	3615	<a href="forward_two.xml#Example" target="_top">Second Order Forward Mode: Derivative Values: Example</a><br/>
	3616	<a href="forward_one.xml#Example" target="_top">First Order Forward Mode: Derivative Values: Example</a><br/>
	3617	<a href="forward_zero.xml#Example" target="_top">Zero Order Forward Mode: Function Values: Example</a><br/>
	3618	<a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
	3619	<a href="seq_property.xml#Example" target="_top">ADFun Sequence Properties: Example</a><br/>
	3620	<a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
	3621	<a href="abort_recording.xml#Example" target="_top">Abort Recording of an Operation Sequence: Example</a><br/>
	3622	<a href="dependent.xml#Example" target="_top">Stop Recording and Store Operation Sequence: Example</a><br/>
	3623	<a href="fun_assign.cpp.xml" target="_top">ADFun Assignment: Example and Test</a><br/>
	3624	<a href="funconstruct.xml#Example" target="_top">Construct an ADFun Object and Stop Recording: Example</a><br/>
	3625	<a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a><br/>
	3626	<a href="independent.xml#Example" target="_top">Declare Independent Variables and Start Recording: Example</a><br/>
	3627	<a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
	3628	<a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
	3629	<a href="base_complex.hpp.xml#Example" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Example</a><br/>
	3630	<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
	3631	<a href="base_adolc.hpp.xml#Example" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Example</a><br/>
	3632	<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	3633	<a href="base_alloc.hpp.xml" target="_top">Example AD<Base> Where Base Constructor Allocates Memory</a><br/>
	3634	<a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a><br/>
	3635	<a href="base_member.xml#Example" target="_top">Required Base Class Member Functions: Example</a><br/>
	3636	<a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
	3637	<a href="vecad.xml#Example" target="_top">AD Vectors that Record Index Operations: Example</a><br/>
	3638	<a href="equal_op_seq.cpp.xml" target="_top">EqualOpSeq: Example and Test</a><br/>
	3639	<a href="equalopseq.xml#Example" target="_top">Check if Two Value are Identically Equal: Example</a><br/>
	3640	<a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
	3641	<a href="parvar.xml#Example" target="_top">Is an AD Object a Parameter or Variable: Example</a><br/>
	3642	<a href="bool_fun.cpp.xml" target="_top">AD Boolean Functions: Example and Test</a><br/>
	3643	<a href="boolfun.xml#Example" target="_top">AD Boolean Functions: Example</a><br/>
	3644	<a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a><br/>
	3645	<a href="nearequalext.xml#Example" target="_top">Compare AD and Base Objects for Nearly Equal: Example</a><br/>
	3646	<a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
	3647	<a href="compare.xml#Example" target="_top">AD Binary Comparison Operators: Example</a><br/>
	3648	<a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>
	3649	<a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
	3650	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	3651	<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
	3652	<a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>
	3653	<a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	3654	<a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a><br/>
	3655	<a href="checkpoint.xml#Example" target="_top">Checkpointing Functions: Example</a><br/>
	3656	<a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
	3657	<a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
	3658	<a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
	3659	<a href="discrete.xml#Example" target="_top">Discrete AD Functions: Example</a><br/>
	3660	<a href="cond_exp.cpp.xml" target="_top">Conditional Expressions: Example and Test</a><br/>
	3661	<a href="condexp.xml#Example" target="_top">AD Conditional Expressions: Example</a><br/>
	3662	<a href="limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a><br/>
	3663	<a href="limits.xml#Example" target="_top">Numeric Limits For an AD and Base Types: Example</a><br/>
	3664	<a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a><br/>
	3665	<a href="pow.xml#Example" target="_top">The AD Power Function: Example</a><br/>
	3666	<a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a><br/>
	3667	<a href="erf.xml#Example" target="_top">The AD Error Function: Example</a><br/>
	3668	<a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a><br/>
	3669	<a href="atan2.xml#Example" target="_top">AD Two Argument Inverse Tangent Function: Example</a><br/>
	3670	<a href="sign.cpp.xml" target="_top">Sign Function: Example and Test</a><br/>
	3671	<a href="sign.xml#Example" target="_top">Sign Function: Example</a><br/>
	3672	<a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
	3673	<a href="abs.xml#Example" target="_top">AD Absolute Value Function: Example</a><br/>
	3674	<a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a><br/>
	3675	<a href="tan.cpp.xml" target="_top">The AD tan Function: Example and Test</a><br/>
	3676	<a href="sqrt.cpp.xml" target="_top">The AD sqrt Function: Example and Test</a><br/>
	3677	<a href="sinh.cpp.xml" target="_top">The AD sinh Function: Example and Test</a><br/>
	3678	<a href="sin.cpp.xml" target="_top">The AD sin Function: Example and Test</a><br/>
	3679	<a href="log10.cpp.xml" target="_top">The AD log10 Function: Example and Test</a><br/>
	3680	<a href="log.cpp.xml" target="_top">The AD log Function: Example and Test</a><br/>
	3681	<a href="exp.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
	3682	<a href="cosh.cpp.xml" target="_top">The AD cosh Function: Example and Test</a><br/>
	3683	<a href="cos.cpp.xml" target="_top">The AD cos Function: Example and Test</a><br/>
	3684	<a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
	3685	<a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>
	3686	<a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
	3687	<a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
	3688	<a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
	3689	<a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
	3690	<a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
	3691	<a href="compute_assign.xml#Example" target="_top">AD Computed Assignment Operators: Example</a><br/>
	3692	<a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
	3693	<a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
	3694	<a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
	3695	<a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
	3696	<a href="ad_binary.xml#Example" target="_top">AD Binary Arithmetic Operators: Example</a><br/>
	3697	<a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a><br/>
	3698	<a href="unaryminus.xml#Example" target="_top">AD Unary Minus Operator: Example</a><br/>
	3699	<a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a><br/>
	3700	<a href="unaryplus.xml#Example" target="_top">AD Unary Plus Operator: Example</a><br/>
	3701	<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	3702	<a href="var2par.xml#Example" target="_top">Convert an AD Variable to a Parameter: Example</a><br/>
	3703	<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
	3704	<a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
	3705	<a href="printfor.xml#Example" target="_top">Printing AD Values During Forward Mode: Example</a><br/>
	3706	<a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	3707	<a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	3708	<a href="ad_output.xml#Example" target="_top">AD Output Stream Operator: Example</a><br/>
	3709	<a href="ad_input.xml#Example" target="_top">AD Output Stream Operator: Example</a><br/>
	3710	<a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
	3711	<a href="integer.xml#Example" target="_top">Convert From AD to Integer: Example</a><br/>
	3712	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	3713	<a href="value.xml#Example" target="_top">Convert From an AD Type to its Base Type: Example</a><br/>
	3714	<a href="ad_assign.cpp.xml" target="_top">AD Assignment: Example and Test</a><br/>
	3715	<a href="ad_assign.xml#Example" target="_top">AD Assignment Operator: Example</a><br/>
	3716	<a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a><br/>
	3717	<a href="ad_ctor.xml#Example" target="_top">AD Constructors: Example</a><br/>
	3718	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
	3719	<a href="colpack.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
	3720	<a href="colpack_prefix.xml#Example" target="_top">Including the ColPack Sparsity Calculations: Example</a><br/>
	3721	<a href="cppad.xml#Example" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Example</a><br/>
870	3722	AD<b> </b>acos <a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
871	3723	AD<b> </b>add <a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
872	3724	AD<b> </b>asin <a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>

910	3762	CppAD <a href="example.cpp.xml" target="_top">CppAD Examples and Tests</a><br/>
911	3763	CppAD<b>::</b>vector <a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
912	3764	CppAD<b>::</b>vectorBool <a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
913		capacity<b>_</b>taylor <a href="capacity_taylor.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	3765	capacity<b>_</b>order <a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
914	3766	check<b> </b>NumericType <a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>
915	3767	check<b> </b>SimpleVector <a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a><br/>
916	3768	check<b>_</b>for<b>_</b>nan <a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
917	3769	checkpoint <a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a><br/>
	3770	colpack <a href="colpack.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
918	3771	complex <a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
919	3772	complex<b> </b>polynomial <a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
920	3773	conjugate<b> </b>gradient <a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>

1048	3901	Var2Par <a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
1049	3902	Variable <a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
1050	3903	VecAD <a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
1051		examples<br/>
	3904	examples <a href="speed_example.cpp.xml" target="_top">Run the Speed Examples</a><br/>
	3905	<a href="example.cpp.xml" target="_top">CppAD Examples and Tests</a><br/>
	3906	<a href="listallexamples.xml" target="_top">List of All the CppAD Examples</a><br/>
	3907	<a href="exampleutility.xml" target="_top">Utility Routines used by CppAD Examples</a><br/>
	3908	<a href="general.xml" target="_top">General Examples</a><br/>
	3909	<a href="example.xml#Running Examples" target="_top">Examples: Running Examples</a><br/>
	3910	<a href="example.xml" target="_top">Examples</a><br/>
	3911	<a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
	3912	<a href="revtwo.xml#Examples" target="_top">Reverse Mode Second Partial Derivative Driver: Examples</a><br/>
	3913	<a href="fortwo.xml#Examples" target="_top">Forward Mode Second Partial Derivative Driver: Examples</a><br/>
	3914	<a href="base_identical.xml#Identical.Examples" target="_top">Base Type Requirements for Identically Equal Comparisons: Identical.Examples</a><br/>
	3915	<a href="atomic_rev_sparse_hes.xml#Examples" target="_top">Atomic Reverse Hessian Sparsity Patterns: Examples</a><br/>
	3916	<a href="atomic_rev_sparse_jac.xml#Examples" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Examples</a><br/>
	3917	<a href="atomic_for_sparse_jac.xml#Examples" target="_top">Atomic Forward Jacobian Sparsity Patterns: Examples</a><br/>
	3918	<a href="atomic_reverse.xml#Examples" target="_top">Atomic Reverse Mode: Examples</a><br/>
	3919	<a href="atomic_forward.xml#Examples" target="_top">Atomic Forward Mode: Examples</a><br/>
	3920	<a href="atomic_afun.xml#Examples" target="_top">Using AD Version of Atomic Function: Examples</a><br/>
	3921	<a href="atomic_ctor.xml#Examples" target="_top">Atomic Function Constructor: Examples</a><br/>
	3922	<a href="atomic_base.xml#Examples" target="_top">User Defined Atomic AD Functions: Examples</a><br/>
	3923	<a href="std_math_ad.xml#Examples" target="_top">AD Standard Math Unary Functions: Examples</a><br/>
	3924	<a href="installunix.xml#make.Examples and Tests" target="_top">Deprecated Unix Test and Installation: make.Examples and Tests</a><br/>
	3925	<a href="cmake_check.xml" target="_top">Checking the CppAD Examples and Tests</a><br/>
	3926	<a href="ipopt_prefix.xml#Examples and Tests" target="_top">Including the cppad_ipopt Library and Tests: Examples and Tests</a><br/>
	3927	<a href="eigen_prefix.xml#Examples" target="_top">Including the Eigen Examples and Tests: Examples</a><br/>
	3928	<a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a><br/>
	3929	<a href="adolc_prefix.xml#Examples" target="_top">Including the ADOL-C Examples and Tests: Examples</a><br/>
	3930	<a href="adolc_prefix.xml" target="_top">Including the ADOL-C Examples and Tests</a><br/>
1052	3931	adolc <a href="adolc_prefix.xml#Examples" target="_top">Including the ADOL-C Examples and Tests: Examples</a><br/>
1053	3932	exception<br/>
1054	3933	error<b> </b>handler <a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
1055	3934	test <a href="faq.xml#Exceptions" target="_top">Frequently Asked Questions and Answers: Exceptions</a><br/>
1056		execution<br/>
	3935	exceptions <a href="faq.xml#Exceptions" target="_top">Frequently Asked Questions and Answers: Exceptions</a><br/>
	3936	<a href="vecad.xml#VecAD<Base>::reference.Exceptions" target="_top">AD Vectors that Record Index Operations: VecAD<Base>::reference.Exceptions</a><br/>
	3937	execute <a href="time_det_by_minor_c.xml" target="_top">Determine Amount of Time to Execute det_by_minor</a><br/>
	3938	<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
	3939	execution <a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
	3940	<a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
	3941	<a href="cppad_assert.xml" target="_top">CppAD Assertions During Execution</a><br/>
1057	3942	parallel <a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
1058	3943	parallel <a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
1059		exercise<br/>
	3944	exercise <a href="cppad_vector.xml#Exercise" target="_top">The CppAD::vector Template Class: Exercise</a><br/>
	3945	<a href="simplevector.xml#Exercise" target="_top">Definition of a Simple Vector: Exercise</a><br/>
	3946	<a href="numerictype.xml#Exercise" target="_top">Definition of a Numeric Type: Exercise</a><br/>
	3947	<a href="nearequal.xml#Exercise" target="_top">Determine if Two Values Are Nearly Equal: Exercise</a><br/>
1060	3948	CppAD<b>::</b>vector <a href="cppad_vector.xml#Exercise" target="_top">The CppAD::vector Template Class: Exercise</a><br/>
1061	3949	NearEqual <a href="nearequal.xml#Exercise" target="_top">Determine if Two Values Are Nearly Equal: Exercise</a><br/>
1062	3950	numeric<b> </b>type <a href="numerictype.xml#Exercise" target="_top">Definition of a Numeric Type: Exercise</a><br/>
1063	3951	simple<b> </b>vector <a href="simplevector.xml#Exercise" target="_top">Definition of a Simple Vector: Exercise</a><br/>
1064		exp<br/>
	3952	exercises <a href="exp_eps_cppad.xml#Exercises" target="_top">exp_eps: CppAD Forward and Reverse Sweeps: Exercises</a><br/>
	3953	<a href="exp_eps_rev2.xml#Exercises" target="_top">exp_eps: Second Order Reverse Sweep: Exercises</a><br/>
	3954	<a href="exp_eps_for2.xml#Exercises" target="_top">exp_eps: Second Order Forward Mode: Exercises</a><br/>
	3955	<a href="exp_eps_rev1.xml#Exercises" target="_top">exp_eps: First Order Reverse Sweep: Exercises</a><br/>
	3956	<a href="exp_eps_for1.xml#Exercises" target="_top">exp_eps: First Order Forward Sweep: Exercises</a><br/>
	3957	<a href="exp_eps_for0.xml#Exercises" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Exercises</a><br/>
	3958	<a href="exp_eps.xml#Exercises" target="_top">An Epsilon Accurate Exponential Approximation: Exercises</a><br/>
	3959	<a href="exp_2_cppad.xml#Exercises" target="_top">exp_2: CppAD Forward and Reverse Sweeps: Exercises</a><br/>
	3960	<a href="exp_2_rev2.xml#Exercises" target="_top">exp_2: Second Order Reverse Mode: Exercises</a><br/>
	3961	<a href="exp_2_for2.xml#Exercises" target="_top">exp_2: Second Order Forward Mode: Exercises</a><br/>
	3962	<a href="exp_2_rev1.xml#Exercises" target="_top">exp_2: First Order Reverse Mode: Exercises</a><br/>
	3963	<a href="exp_2_for1.xml#Exercises" target="_top">exp_2: First Order Forward Mode: Exercises</a><br/>
	3964	<a href="exp_2_for0.xml#Exercises" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Exercises</a><br/>
	3965	<a href="exp_2.xml#Exercises" target="_top">Second Order Exponential Approximation: Exercises</a><br/>
	3966	<a href="get_started.cpp.xml#Exercises" target="_top">Getting Started Using CppAD to Compute Derivatives: Exercises</a><br/>
	3967	exp <a href="cppad_assert.xml#Exp" target="_top">CppAD Assertions During Execution: Exp</a><br/>
	3968	<a href="errorhandler.xml#exp" target="_top">Replacing the CppAD Error Handler: exp</a><br/>
	3969	<a href="exp.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
	3970	<a href="std_math_ad.xml#Derivatives.exp" target="_top">AD Standard Math Unary Functions: Derivatives.exp</a><br/>
1065	3971	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
1066	3972	AD<b> </b>example <a href="exp.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
1067	3973	example <a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>

1083	3989	second<b> </b>order <a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a><br/>
1084	3990	test <a href="exp_2.cpp.xml" target="_top">exp_2: Test</a><br/>
1085	3991	zero<b> </b>order <a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a><br/>
	3992	exp<b>_</b>2<b>:</b> <a href="exp_2_cppad.xml" target="_top">exp_2: CppAD Forward and Reverse Sweeps</a><br/>
	3993	<a href="exp_2_rev2.cpp.xml" target="_top">exp_2: Verify Second Order Reverse Sweep</a><br/>
	3994	<a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a><br/>
	3995	<a href="exp_2_rev1.cpp.xml" target="_top">exp_2: Verify First Order Reverse Sweep</a><br/>
	3996	<a href="exp_2_for1.cpp.xml" target="_top">exp_2: Verify First Order Forward Sweep</a><br/>
	3997	<a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a><br/>
	3998	<a href="exp_2_rev2.xml" target="_top">exp_2: Second Order Reverse Mode</a><br/>
	3999	<a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a><br/>
	4000	<a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a><br/>
	4001	<a href="exp_2_for1.xml" target="_top">exp_2: First Order Forward Mode</a><br/>
	4002	<a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
	4003	<a href="exp_2.cpp.xml" target="_top">exp_2: Test</a><br/>
	4004	<a href="exp_2.hpp.xml" target="_top">exp_2: Implementation</a><br/>
1086	4005	exp<b>_</b>apx<br/>
1087	4006	main<b> </b>test <a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
1088		exp<b>_</b>eps <a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
	4007	exp<b>_</b>eps <a href="exp_eps.cpp.xml" target="_top">exp_eps: Test of exp_eps</a><br/>
	4008	<a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
1089	4009	forward<b> </b>mode <a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a><br/>
1090	4010	implementation <a href="exp_eps.hpp.xml" target="_top">exp_eps: Implementation</a><br/>
1091	4011	operation<b> </b>sequence <a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>

1095	4015	reverse<b> </b>mode <a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a><br/>
1096	4016	test <a href="exp_eps.cpp.xml" target="_top">exp_eps: Test of exp_eps</a><br/>
1097	4017	zero<b> </b>order <a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a><br/>
1098		expansion <a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	4018	exp<b>_</b>eps<b>:</b> <a href="exp_eps_cppad.xml" target="_top">exp_eps: CppAD Forward and Reverse Sweeps</a><br/>
	4019	<a href="exp_eps_rev2.cpp.xml" target="_top">exp_eps: Verify Second Order Reverse Sweep</a><br/>
	4020	<a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a><br/>
	4021	<a href="exp_eps_rev1.cpp.xml" target="_top">exp_eps: Verify First Order Reverse Sweep</a><br/>
	4022	<a href="exp_eps_for1.cpp.xml" target="_top">exp_eps: Verify First Order Forward Sweep</a><br/>
	4023	<a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a><br/>
	4024	<a href="exp_eps_rev2.xml" target="_top">exp_eps: Second Order Reverse Sweep</a><br/>
	4025	<a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a><br/>
	4026	<a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a><br/>
	4027	<a href="exp_eps_for1.xml" target="_top">exp_eps: First Order Forward Sweep</a><br/>
	4028	<a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
	4029	<a href="exp_eps.cpp.xml" target="_top">exp_eps: Test of exp_eps</a><br/>
	4030	<a href="exp_eps.hpp.xml" target="_top">exp_eps: Implementation</a><br/>
	4031	expansion <a href="det_by_minor_c.xml" target="_top">Compute Determinant using Expansion by Minors</a><br/>
	4032	<a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
	4033	<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
	4034	<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
	4035	<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
	4036	<a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
	4037	<a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
	4038	<a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a><br/>
	4039	<a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
	4040	<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
	4041	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	4042	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
1099	4043	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	4044	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	4045	<a href="exp_eps_for2.xml#Second Order Expansion" target="_top">exp_eps: Second Order Forward Mode: Second Order Expansion</a><br/>
	4046	<a href="exp_eps_for1.xml#First Order Expansion" target="_top">exp_eps: First Order Forward Sweep: First Order Expansion</a><br/>
	4047	<a href="exp_2_for2.xml#Second Order Expansion" target="_top">exp_2: Second Order Forward Mode: Second Order Expansion</a><br/>
	4048	<a href="exp_2_for1.xml#First Order Expansion" target="_top">exp_2: First Order Forward Mode: First Order Expansion</a><br/>
	4049	<a href="exp_2_for0.xml#Zero Order Expansion" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion</a><br/>
1100	4050	first<b> </b>order <a href="exp_eps_for1.xml#First Order Expansion" target="_top">exp_eps: First Order Forward Sweep: First Order Expansion</a><br/>
1101	4051	first<b> </b>order <a href="exp_2_for1.xml#First Order Expansion" target="_top">exp_2: First Order Forward Mode: First Order Expansion</a><br/>
1102	4052	minor<b> </b>determinant <a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a><br/>
1103	4053	second<b> </b>order <a href="exp_eps_for2.xml#Second Order Expansion" target="_top">exp_eps: Second Order Forward Mode: Second Order Expansion</a><br/>
1104	4054	second<b> </b>order <a href="exp_2_for2.xml#Second Order Expansion" target="_top">exp_2: Second Order Forward Mode: Second Order Expansion</a><br/>
1105	4055	zero<b> </b>order <a href="exp_2_for0.xml#Zero Order Expansion" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion</a><br/>
1106		explicit<br/>
1107		ctor <a href="installunix.xml#--with-implicit_ctor" target="_top">Unix Test and Installation: --with-implicit_ctor</a><br/>
	4056	explicit <a href="ad_ctor.xml#x.explicit" target="_top">AD Constructors: x.explicit</a><br/>
	4057	ctor <a href="installunix.xml#--with-implicit_ctor" target="_top">Deprecated Unix Test and Installation: --with-implicit_ctor</a><br/>
1108	4058	ctor <a href="cmake.xml#cppad_implicit_ctor_from_any_type" target="_top">Using CMake to Configure CppAD: cppad_implicit_ctor_from_any_type</a><br/>
1109	4059	exponent<br/>
1110	4060	AD<b> </b>function <a href="pow.xml" target="_top">The AD Power Function</a><br/>
1111	4061	integer <a href="pow_int.xml" target="_top">The Integer Power Function</a><br/>
1112		expression<br/>
	4062	exponent<b>:</b> <a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a><br/>
	4063	exponential <a href="expreverse.xml" target="_top">Exponential Function Reverse Mode Theory</a><br/>
	4064	<a href="expforward.xml" target="_top">Exponential Function Forward Taylor Polynomial Theory</a><br/>
	4065	<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
	4066	<a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
	4067	<a href="exp_2.xml" target="_top">Second Order Exponential Approximation</a><br/>
	4068	expression <a href="wishlist.xml#Optimization.Expression Hashing" target="_top">The CppAD Wish List: Optimization.Expression Hashing</a><br/>
1113	4069	conditional <a href="condexp.xml" target="_top">AD Conditional Expressions</a><br/>
1114	4070	conditional<b> </b>optimize <a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	4071	expressions <a href="wishlist.xml#Conditional Expressions" target="_top">The CppAD Wish List: Conditional Expressions</a><br/>
	4072	<a href="base_cond_exp.xml" target="_top">Base Type Requirements for Conditional Expressions</a><br/>
	4073	<a href="condexp.xml" target="_top">AD Conditional Expressions</a><br/>
	4074	expressions<b>:</b> <a href="cond_exp.cpp.xml" target="_top">Conditional Expressions: Example and Test</a><br/>
	4075	external <a href="get_sacado.sh.xml#External Directory" target="_top">Download and Install Sacado in Build Directory: External Directory</a><br/>
	4076	<a href="get_ipopt.sh.xml#External Directory" target="_top">Download and Install Ipopt in Build Directory: External Directory</a><br/>
	4077	<a href="get_fadbad.sh.xml#External Directory" target="_top">Download and Install Fadbad in Build Directory: External Directory</a><br/>
	4078	<a href="get_eigen.sh.xml#External Directory" target="_top">Download and Install Eigen in Build Directory: External Directory</a><br/>
	4079	<a href="get_colpack.sh.xml#External Directory" target="_top">Download and Install ColPack in Build Directory: External Directory</a><br/>
	4080	<a href="get_adolc.sh.xml#External Directory" target="_top">Download and Install Adolc in Build Directory: External Directory</a><br/>
	4081	extra <a href="old_mat_mul.hpp.xml#Extra Call Information" target="_top">Define Matrix Multiply as a User Atomic Operation: Extra Call Information</a><br/>
	4082	<a href="ta_free_available.xml#Purpose.Extra Memory" target="_top">Free Memory Currently Available for Quick Use by a Thread: Purpose.Extra Memory</a><br/>
	4083	extraction <a href="download.xml#Compressed Tar File.Windows File Extraction" target="_top">Download The CppAD Source Code: Compressed Tar File.Windows File Extraction</a><br/>
	4084	<a href="download.xml#Compressed Tar File.Unix File Extraction" target="_top">Download The CppAD Source Code: Compressed Tar File.Unix File Extraction</a><br/>
1115	4085
1116	4086	<b><big><a name="F">F</a></big></b>
1117	4087	<br/>
1118	4088	FAQ <a href="faq.xml" target="_top">Frequently Asked Questions and Answers</a><br/>
1119	4089	Fadbad<br/>
1120		unix <a href="installunix.xml#fadbad_dir" target="_top">Unix Test and Installation: fadbad_dir</a><br/>
	4090	unix <a href="installunix.xml#fadbad_dir" target="_top">Deprecated Unix Test and Installation: fadbad_dir</a><br/>
1121	4091	ForSparseJac <a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
1122	4092	<a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a><br/>
1123	4093	Forward <a href="forward.cpp.xml" target="_top">Forward Mode: Example and Test</a><br/>
1124		capacity <a href="capacity_taylor.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
1125		order<b> </b>one <a href="forwardone.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
1126		order<b> </b>zero <a href="forwardzero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
	4094	capacity <a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
	4095	order<b> </b>one <a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
	4096	order<b> </b>two <a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a><br/>
	4097	order<b> </b>zero <a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
1127	4098	FunCheck <a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
1128	4099	example <a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
1129		fabs<br/>
	4100	f <a href="link_ode.xml#f" target="_top">Speed Testing the Jacobian of Ode Solution: f</a><br/>
	4101	<a href="odegearcontrol.xml#Fun.f" target="_top">An Error Controller for Gear's Ode Solvers: Fun.f</a><br/>
	4102	<a href="odegear.xml#Fun.f" target="_top">An Arbitrary Order Gear Method: Fun.f</a><br/>
	4103	<a href="rosen34.xml#Fun.f" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.f</a><br/>
	4104	<a href="runge45.xml#Fun.f" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Fun.f</a><br/>
	4105	<a href="rombergmul.xml#F" target="_top">Multi-dimensional Romberg Integration: F</a><br/>
	4106	<a href="rombergone.xml#F" target="_top">One DimensionalRomberg Integration: F</a><br/>
	4107	<a href="check_for_nan.xml#f" target="_top">Check an ADFun Object For Nan: f</a><br/>
	4108	<a href="optimize.xml#f" target="_top">Optimize an ADFun Object Tape: f</a><br/>
	4109	<a href="funcheck.xml#f" target="_top">Check an ADFun Sequence of Operations: f</a><br/>
	4110	<a href="sparse_hessian.xml#f" target="_top">Sparse Hessian: Easy Driver: f</a><br/>
	4111	<a href="sparse_jacobian.xml#f" target="_top">Sparse Jacobian: Easy Driver: f</a><br/>
	4112	<a href="revtwo.xml#f" target="_top">Reverse Mode Second Partial Derivative Driver: f</a><br/>
	4113	<a href="fortwo.xml#f" target="_top">Forward Mode Second Partial Derivative Driver: f</a><br/>
	4114	<a href="hessian.xml#f" target="_top">Hessian: Easy Driver: f</a><br/>
	4115	<a href="revone.xml#f" target="_top">First Order Derivative: Driver Routine: f</a><br/>
	4116	<a href="forone.xml#f" target="_top">First Order Partial Derivative: Driver Routine: f</a><br/>
	4117	<a href="jacobian.xml#f" target="_top">Jacobian: Driver Routine: f</a><br/>
	4118	<a href="revsparsehes.xml#f" target="_top">Hessian Sparsity Pattern: Reverse Mode: f</a><br/>
	4119	<a href="revsparsejac.xml#f" target="_top">Jacobian Sparsity Pattern: Reverse Mode: f</a><br/>
	4120	<a href="forsparsejac.xml#f" target="_top">Jacobian Sparsity Pattern: Forward Mode: f</a><br/>
	4121	<a href="reverse_any.xml#f" target="_top">Any Order Reverse Mode: f</a><br/>
	4122	<a href="reverse_two.xml#f" target="_top">Second Order Reverse Mode: f</a><br/>
	4123	<a href="reverse_one.xml#f" target="_top">First Order Reverse Mode: f</a><br/>
	4124	<a href="number_skip.xml#f" target="_top">Number of Variables that Can be Skipped: f</a><br/>
	4125	<a href="capacity_order.xml#f" target="_top">Controlling Taylor Coefficients Memory Allocation: f</a><br/>
	4126	<a href="comparechange.xml#f" target="_top">Comparison Changes During Zero Order Forward Mode: f</a><br/>
	4127	<a href="size_order.xml#f" target="_top">Number Taylor Coefficient Orders Currently Stored: f</a><br/>
	4128	<a href="forward_dir.xml#f" target="_top">Multiple Directions Forward Mode: f</a><br/>
	4129	<a href="forward_order.xml#f" target="_top">Multiple Order Forward Mode: f</a><br/>
	4130	<a href="forward_two.xml#f" target="_top">Second Order Forward Mode: Derivative Values: f</a><br/>
	4131	<a href="forward_one.xml#f" target="_top">First Order Forward Mode: Derivative Values: f</a><br/>
	4132	<a href="forward_zero.xml#f" target="_top">Zero Order Forward Mode: Function Values: f</a><br/>
	4133	<a href="seq_property.xml#f" target="_top">ADFun Sequence Properties: f</a><br/>
	4134	<a href="dependent.xml#f" target="_top">Stop Recording and Store Operation Sequence: f</a><br/>
	4135	<a href="atomic_reverse.xml#F, G, H" target="_top">Atomic Reverse Mode: F, G, H</a><br/>
	4136	f<b>.</b>forward<b>(</b>0 <a href="printfor.xml#f.Forward(0, x)" target="_top">Printing AD Values During Forward Mode: f.Forward(0, x)</a><br/>
	4137	f<b>_</b>1 <a href="exp_eps_rev2.xml#Index 2: f_1" target="_top">exp_eps: Second Order Reverse Sweep: Index 2: f_1</a><br/>
	4138	<a href="exp_eps_rev1.xml#Index 2: f_1" target="_top">exp_eps: First Order Reverse Sweep: Index 2: f_1</a><br/>
	4139	<a href="exp_2_rev2.xml#Index 2: f_1" target="_top">exp_2: Second Order Reverse Mode: Index 2: f_1</a><br/>
	4140	<a href="exp_2_rev1.xml#Index 2: f_1" target="_top">exp_2: First Order Reverse Mode: Index 2: f_1</a><br/>
	4141	f<b>_</b>2 <a href="exp_eps_rev2.xml#Index 3: f_2" target="_top">exp_eps: Second Order Reverse Sweep: Index 3: f_2</a><br/>
	4142	<a href="exp_eps_rev1.xml#Index 3: f_2" target="_top">exp_eps: First Order Reverse Sweep: Index 3: f_2</a><br/>
	4143	<a href="exp_2_rev2.xml#Index 3: f_2" target="_top">exp_2: Second Order Reverse Mode: Index 3: f_2</a><br/>
	4144	<a href="exp_2_rev1.xml#Index 3: f_2" target="_top">exp_2: First Order Reverse Mode: Index 3: f_2</a><br/>
	4145	f<b>_</b>3 <a href="exp_eps_rev2.xml#Index 4: f_3" target="_top">exp_eps: Second Order Reverse Sweep: Index 4: f_3</a><br/>
	4146	<a href="exp_eps_rev1.xml#Index 4: f_3" target="_top">exp_eps: First Order Reverse Sweep: Index 4: f_3</a><br/>
	4147	<a href="exp_2_rev2.xml#Index 4: f_3" target="_top">exp_2: Second Order Reverse Mode: Index 4: f_3</a><br/>
	4148	<a href="exp_2_rev1.xml#Index 4: f_3" target="_top">exp_2: First Order Reverse Mode: Index 4: f_3</a><br/>
	4149	f<b>_</b>4 <a href="exp_eps_rev2.xml#Index 5: f_4" target="_top">exp_eps: Second Order Reverse Sweep: Index 5: f_4</a><br/>
	4150	<a href="exp_eps_rev1.xml#Index 5: f_4" target="_top">exp_eps: First Order Reverse Sweep: Index 5: f_4</a><br/>
	4151	<a href="exp_2_rev2.xml#Index 5: f_4" target="_top">exp_2: Second Order Reverse Mode: Index 5: f_4</a><br/>
	4152	<a href="exp_2_rev1.xml#Index 5: f_4" target="_top">exp_2: First Order Reverse Mode: Index 5: f_4</a><br/>
	4153	f<b>_</b>5 <a href="exp_eps_rev2.xml#Index 6: f_5" target="_top">exp_eps: Second Order Reverse Sweep: Index 6: f_5</a><br/>
	4154	<a href="exp_eps_rev1.xml#Index 6: f_5" target="_top">exp_eps: First Order Reverse Sweep: Index 6: f_5</a><br/>
	4155	<a href="exp_2_rev2.xml#f_5" target="_top">exp_2: Second Order Reverse Mode: f_5</a><br/>
	4156	<a href="exp_2_rev1.xml#f_5" target="_top">exp_2: First Order Reverse Mode: f_5</a><br/>
	4157	f<b>_</b>6 <a href="exp_eps_rev2.xml#Index 7: f_6" target="_top">exp_eps: Second Order Reverse Sweep: Index 7: f_6</a><br/>
	4158	<a href="exp_eps_rev1.xml#Index 7: f_6" target="_top">exp_eps: First Order Reverse Sweep: Index 7: f_6</a><br/>
	4159	f<b>_</b>7 <a href="exp_eps_rev2.xml#f_7" target="_top">exp_eps: Second Order Reverse Sweep: f_7</a><br/>
	4160	<a href="exp_eps_rev1.xml#f_7" target="_top">exp_eps: First Order Reverse Sweep: f_7</a><br/>
	4161	f<b>_</b>t <a href="rosen34.xml#Fun.f_t" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.f_t</a><br/>
	4162	f<b>_</b>x <a href="odegearcontrol.xml#Fun.f_x" target="_top">An Error Controller for Gear's Ode Solvers: Fun.f_x</a><br/>
	4163	<a href="odegear.xml#Fun.f_x" target="_top">An Arbitrary Order Gear Method: Fun.f_x</a><br/>
	4164	<a href="rosen34.xml#Fun.f_x" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.f_x</a><br/>
	4165	fabs <a href="ode_evaluate.xml#Float.fabs" target="_top">Evaluate a Function Defined in Terms of an ODE: Float.fabs</a><br/>
	4166	<a href="runge45.xml#Scalar.fabs" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Scalar.fabs</a><br/>
1130	4167	AD <a href="abs.xml" target="_top">AD Absolute Value Function</a><br/>
1131	4168	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
1132	4169	example <a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
1133		factor<br/>
	4170	factor <a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	4171	<a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
	4172	<a href="luratio.xml#LU.Factor" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU.Factor</a><br/>
	4173	<a href="lufactor.xml#LU.Factor" target="_top">LU Factorization of A Square Matrix: LU.Factor</a><br/>
	4174	<a href="lusolve.xml#Factor and Invert" target="_top">Compute Determinant and Solve Linear Equations: Factor and Invert</a><br/>
1134	4175	lu<b> </b>determinant <a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
1135	4176	matrix <a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
1136	4177	matrix<b> </b>speed<b> </b>adolc <a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>

1138	4179	matrix<b> </b>speed<b> </b>double <a href="double_det_lu.cpp.xml" target="_top">Double Speed: Determinant Using Lu Factorization</a><br/>
1139	4180	matrix<b> </b>speed<b> </b>fadbad <a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
1140	4181	matrix<b> </b>speed<b> </b>sacado <a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
1141		fadbad<br/>
	4182	factored <a href="luinvert.xml" target="_top">Invert an LU Factored Equation</a><br/>
	4183	factorization <a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	4184	<a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	4185	<a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	4186	<a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	4187	<a href="double_det_lu.cpp.xml" target="_top">Double Speed: Determinant Using Lu Factorization</a><br/>
	4188	<a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
	4189	<a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
	4190	<a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
	4191	<a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
	4192	<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
	4193	factorization<b>:</b> <a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a><br/>
	4194	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	4195	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
	4196	fadbad <a href="fadbad_sparse_jacobian.cpp.xml" target="_top">fadbad Speed: sparse_jacobian</a><br/>
	4197	<a href="fadbad_sparse_hessian.cpp.xml" target="_top">Fadbad Speed: Sparse Hessian</a><br/>
	4198	<a href="fadbad_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
	4199	<a href="fadbad_ode.cpp.xml" target="_top">Fadbad Speed: Ode</a><br/>
	4200	<a href="fadbad_mat_mul.cpp.xml" target="_top">Fadbad Speed: Matrix Multiplication</a><br/>
	4201	<a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	4202	<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
	4203	<a href="speed_fadbad.xml" target="_top">Speed Test Derivatives Using Fadbad</a><br/>
	4204	<a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
	4205	<a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a><br/>
1142	4206	download<b> </b>and<b> </b>install <a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
1143	4207	get <a href="fadbad_prefix.xml#get_fadbad" target="_top">Including the FADBAD Speed Tests: get_fadbad</a><br/>
1144	4208	link<b>_</b>det<b>_</b>lu <a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>

1155	4219	speed <a href="fadbad_prefix.xml#Speed Tests" target="_top">Including the FADBAD Speed Tests: Speed Tests</a><br/>
1156	4220	speed <a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a><br/>
1157	4221	speed<b> </b>test <a href="speed_fadbad.xml" target="_top">Speed Test Derivatives Using Fadbad</a><br/>
1158		features<br/>
	4222	fadbad<b>_</b>dir <a href="installunix.xml#fadbad_dir" target="_top">Deprecated Unix Test and Installation: fadbad_dir</a><br/>
	4223	fadbad<b>_</b>prefix <a href="speed_fadbad.xml#fadbad_prefix" target="_top">Speed Test Derivatives Using Fadbad: fadbad_prefix</a><br/>
	4224	<a href="fadbad_prefix.xml#fadbad_prefix" target="_top">Including the FADBAD Speed Tests: fadbad_prefix</a><br/>
	4225	false <a href="revsparsehes.xml#h.transpose false" target="_top">Hessian Sparsity Pattern: Reverse Mode: h.transpose false</a><br/>
	4226	<a href="revsparsejac.xml#s.transpose false" target="_top">Jacobian Sparsity Pattern: Reverse Mode: s.transpose false</a><br/>
	4227	<a href="revsparsejac.xml#r.transpose false" target="_top">Jacobian Sparsity Pattern: Reverse Mode: r.transpose false</a><br/>
	4228	<a href="forsparsejac.xml#s.transpose false" target="_top">Jacobian Sparsity Pattern: Forward Mode: s.transpose false</a><br/>
	4229	<a href="forsparsejac.xml#r.transpose false" target="_top">Jacobian Sparsity Pattern: Forward Mode: r.transpose false</a><br/>
	4230	fast <a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
	4231	<a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
	4232	<a href="ipopt_nlp_ode_fast.hpp.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	4233	<a href="ipopt_nlp_ode_fast.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	4234	<a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
	4235	<a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a><br/>
	4236	features <a href="deprecated.xml" target="_top">CppAD Deprecated API Features</a><br/>
1159	4237	new <a href="wishlist.xml" target="_top">The CppAD Wish List</a><br/>
1160		file<br/>
	4238	fg <a href="ipopt_solve.xml#fg_eval.fg" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: fg_eval.fg</a><br/>
	4239	fg<b>(</b>x<b>)</b> <a href="cppad_ipopt_nlp.xml#fg(x)" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg(x)</a><br/>
	4240	fg<b>_</b>eval <a href="ipopt_solve.xml#fg_eval" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: fg_eval</a><br/>
	4241	fg<b>_</b>info <a href="cppad_ipopt_nlp.xml#fg_info" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg_info</a><br/>
	4242	fg<b>_</b>info<b>.</b>domain<b>_</b>size <a href="cppad_ipopt_nlp.xml#fg_info.fg_info.domain_size" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg_info.fg_info.domain_size</a><br/>
	4243	fg<b>_</b>info<b>.</b>eval<b>_</b>r <a href="cppad_ipopt_nlp.xml#fg_info.fg_info.eval_r" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg_info.fg_info.eval_r</a><br/>
	4244	fg<b>_</b>info<b>.</b>index <a href="cppad_ipopt_nlp.xml#fg_info.fg_info.index" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg_info.fg_info.index</a><br/>
	4245	fg<b>_</b>info<b>.</b>number<b>_</b>functions <a href="cppad_ipopt_nlp.xml#fg_info.fg_info.number_functions" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg_info.fg_info.number_functions</a><br/>
	4246	fg<b>_</b>info<b>.</b>number<b>_</b>terms <a href="cppad_ipopt_nlp.xml#fg_info.fg_info.number_terms" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg_info.fg_info.number_terms</a><br/>
	4247	fg<b>_</b>info<b>.</b>range<b>_</b>size <a href="cppad_ipopt_nlp.xml#fg_info.fg_info.range_size" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg_info.fg_info.range_size</a><br/>
	4248	fg<b>_</b>info<b>.</b>retape <a href="cppad_ipopt_nlp.xml#fg_info.fg_info.retape" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg_info.fg_info.retape</a><br/>
	4249	fields <a href="pkgconfig.xml#Defined Fields" target="_top">CppAD pkg-config Files: Defined Fields</a><br/>
	4250	file <a href="old_mat_mul.cpp.xml#Include File" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test: Include File</a><br/>
	4251	<a href="tracknewdel.xml#file" target="_top">Routines That Track Use of New and Delete: file</a><br/>
	4252	<a href="ipopt_solve.xml#Include File" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Include File</a><br/>
	4253	<a href="near_equal.cpp.xml#File Name" target="_top">NearEqual Function: Example and Test: File Name</a><br/>
	4254	<a href="errorhandler.xml#file" target="_top">Replacing the CppAD Error Handler: file</a><br/>
	4255	<a href="base_alloc.hpp.xml#Include File" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Include File</a><br/>
	4256	<a href="download.xml#Compressed Tar File.Windows File Extraction" target="_top">Download The CppAD Source Code: Compressed Tar File.Windows File Extraction</a><br/>
	4257	<a href="download.xml#Compressed Tar File.Unix File Extraction" target="_top">Download The CppAD Source Code: Compressed Tar File.Unix File Extraction</a><br/>
	4258	<a href="download.xml#Compressed Tar File" target="_top">Download The CppAD Source Code: Compressed Tar File</a><br/>
	4259	<a href="cppad.xml#Include File" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
1161	4260	deprecated<b> </b>include <a href="include_deprecated.xml" target="_top">Deprecated Include Files</a><br/>
1162		files<br/>
	4261	files <a href="include_deprecated.xml#Linking New Files to Deprecated Commands" target="_top">Deprecated Include Files: Linking New Files to Deprecated Commands</a><br/>
	4262	<a href="include_deprecated.xml" target="_top">Deprecated Include Files</a><br/>
	4263	<a href="cppad_eigen.hpp.xml#Include Files" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: Include Files</a><br/>
	4264	<a href="nearequal.xml#Include Files" target="_top">Determine if Two Values Are Nearly Equal: Include Files</a><br/>
	4265	<a href="base_adolc.hpp.xml#Include Files" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Include Files</a><br/>
	4266	<a href="pkgconfig.xml#CppAD Configuration Files" target="_top">CppAD pkg-config Files: CppAD Configuration Files</a><br/>
	4267	<a href="pkgconfig.xml" target="_top">CppAD pkg-config Files</a><br/>
1163	4268	pkg<b>-</b>config <a href="pkgconfig.xml" target="_top">CppAD pkg-config Files</a><br/>
1164		first<br/>
	4269	first <a href="speedtest.xml#first" target="_top">Run One Speed Test and Print Results: first</a><br/>
	4270	<a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a><br/>
	4271	<a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
	4272	<a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a><br/>
	4273	<a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a><br/>
	4274	<a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
	4275	<a href="reverse_any.xml#First Order" target="_top">Any Order Reverse Mode: First Order</a><br/>
	4276	<a href="reverse_two.xml#dw.First Order Partials" target="_top">Second Order Reverse Mode: dw.First Order Partials</a><br/>
	4277	<a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a><br/>
	4278	<a href="reverse_one.xml" target="_top">First Order Reverse Mode</a><br/>
	4279	<a href="forward_order.xml#First Order" target="_top">Multiple Order Forward Mode: First Order</a><br/>
	4280	<a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
	4281	<a href="exp_eps_rev1.cpp.xml" target="_top">exp_eps: Verify First Order Reverse Sweep</a><br/>
	4282	<a href="exp_eps_for1.cpp.xml" target="_top">exp_eps: Verify First Order Forward Sweep</a><br/>
	4283	<a href="exp_eps_for2.xml#Operation Sequence.First" target="_top">exp_eps: Second Order Forward Mode: Operation Sequence.First</a><br/>
	4284	<a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a><br/>
	4285	<a href="exp_eps_for1.xml#Operation Sequence.First Order" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence.First Order</a><br/>
	4286	<a href="exp_eps_for1.xml#First Order Expansion" target="_top">exp_eps: First Order Forward Sweep: First Order Expansion</a><br/>
	4287	<a href="exp_eps_for1.xml" target="_top">exp_eps: First Order Forward Sweep</a><br/>
	4288	<a href="exp_2_rev1.cpp.xml" target="_top">exp_2: Verify First Order Reverse Sweep</a><br/>
	4289	<a href="exp_2_for1.cpp.xml" target="_top">exp_2: Verify First Order Forward Sweep</a><br/>
	4290	<a href="exp_2_for2.xml#Operation Sequence.First" target="_top">exp_2: Second Order Forward Mode: Operation Sequence.First</a><br/>
	4291	<a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a><br/>
	4292	<a href="exp_2_for1.xml#Operation Sequence.First Order" target="_top">exp_2: First Order Forward Mode: Operation Sequence.First Order</a><br/>
	4293	<a href="exp_2_for1.xml#First Order Expansion" target="_top">exp_2: First Order Forward Mode: First Order Expansion</a><br/>
	4294	<a href="exp_2_for1.xml" target="_top">exp_2: First Order Forward Mode</a><br/>
1165	4295	derivative <a href="jacobian.xml" target="_top">Jacobian: Driver Routine</a><br/>
1166	4296	order<b> </b>derivative<b> </b>driver <a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
1167	4297	order<b> </b>exp<b>_</b>2 <a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a><br/>

1174	4304	order<b> </b>reverse <a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a><br/>
1175	4305	order<b> </b>reverse <a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a><br/>
1176	4306	order<b> </b>reverse<b> </b>mode <a href="reverse_one.xml" target="_top">First Order Reverse Mode</a><br/>
	4307	fitting <a href="ipopt_nlp_ode_fast.hpp.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	4308	<a href="ipopt_nlp_ode_simple.hpp.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	4309	<a href="ipopt_nlp_ode_fast.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	4310	<a href="ipopt_nlp_ode_simple.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	4311	flag <a href="correct_det_by_minor_c.xml#flag" target="_top">Correctness Test of det_by_minor Routine: flag</a><br/>
	4312	<a href="memory_leak.xml#flag" target="_top">Memory Leak Detection: flag</a><br/>
	4313	<a href="omp_efficient.xml#flag" target="_top">Check If A Memory Allocation is Efficient for Another Use: flag</a><br/>
	4314	<a href="omp_in_parallel.xml#flag" target="_top">Is The Current Execution in OpenMP Parallel Mode: flag</a><br/>
	4315	<a href="ta_in_parallel.xml#flag" target="_top">Is The Current Execution in Parallel Mode: flag</a><br/>
1177	4316	flags<br/>
1178	4317	c<b>++ </b>compile <a href="cmake.xml#cppad_cxx_flags" target="_top">Using CMake to Configure CppAD: cppad_cxx_flags</a><br/>
1179		OpenMP<b> </b>compile <a href="installunix.xml#openmp_flags" target="_top">Unix Test and Installation: openmp_flags</a><br/>
1180		unix<b> </b>compile <a href="installunix.xml#cxx_flags" target="_top">Unix Test and Installation: cxx_flags</a><br/>
1181		float<br/>
	4318	OpenMP<b> </b>compile <a href="installunix.xml#openmp_flags" target="_top">Deprecated Unix Test and Installation: openmp_flags</a><br/>
	4319	unix<b> </b>compile <a href="installunix.xml#cxx_flags" target="_top">Deprecated Unix Test and Installation: cxx_flags</a><br/>
	4320	float <a href="epsilon.xml#Float" target="_top">Machine Epsilon For AD Types: Float</a><br/>
	4321	<a href="sparse_hes_fun.xml#Float" target="_top">Evaluate a Function That Has a Sparse Hessian: Float</a><br/>
	4322	<a href="sparse_jac_fun.xml#Float" target="_top">Evaluate a Function That Has a Sparse Jacobian: Float</a><br/>
	4323	<a href="ode_evaluate.xml#Float" target="_top">Evaluate a Function Defined in Terms of an ODE: Float</a><br/>
	4324	<a href="rombergmul.xml#Float" target="_top">Multi-dimensional Romberg Integration: Float</a><br/>
	4325	<a href="rombergone.xml#Float" target="_top">One DimensionalRomberg Integration: Float</a><br/>
	4326	<a href="lufactor.xml#Float" target="_top">LU Factorization of A Square Matrix: Float</a><br/>
	4327	<a href="lusolve.xml#Float" target="_top">Compute Determinant and Solve Linear Equations: Float</a><br/>
	4328	<a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
	4329	<a href="limits.xml#Float" target="_top">Numeric Limits For an AD and Base Types: Float</a><br/>
1182	4330	Base <a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
1183	4331	Base <a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
1184		for<b>_</b>sparse<b>_</b>jac<br/>
	4332	floatvector <a href="sparse_hes_fun.xml#FloatVector" target="_top">Evaluate a Function That Has a Sparse Hessian: FloatVector</a><br/>
	4333	<a href="sparse_jac_fun.xml#FloatVector" target="_top">Evaluate a Function That Has a Sparse Jacobian: FloatVector</a><br/>
	4334	<a href="rombergmul.xml#FloatVector" target="_top">Multi-dimensional Romberg Integration: FloatVector</a><br/>
	4335	<a href="lufactor.xml#FloatVector" target="_top">LU Factorization of A Square Matrix: FloatVector</a><br/>
	4336	<a href="lusolve.xml#FloatVector" target="_top">Compute Determinant and Solve Linear Equations: FloatVector</a><br/>
	4337	for <a href="license.xml" target="_top">Your License for the CppAD Software</a><br/>
	4338	<a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
	4339	<a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
	4340	<a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
	4341	<a href="ipopt_nlp_ode_run.hpp.xml" target="_top">Driver for Running the Ipopt ODE Example</a><br/>
	4342	<a href="epsilon.xml" target="_top">Machine Epsilon For AD Types</a><br/>
	4343	<a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
	4344	<a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
	4345	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	4346	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	4347	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	4348	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
	4349	<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
	4350	<a href="eigen_plugin.hpp.xml" target="_top">Source Code for eigen_plugin.hpp</a><br/>
	4351	<a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	4352	<a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
	4353	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	4354	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	4355	<a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
	4356	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	4357	<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	4358	<a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
	4359	<a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
	4360	<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
	4361	<a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
	4362	<a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan</a><br/>
	4363	<a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
	4364	<a href="base_ordered.xml" target="_top">Base Type Requirements for Ordered Comparisons</a><br/>
	4365	<a href="base_identical.xml" target="_top">Base Type Requirements for Identically Equal Comparisons</a><br/>
	4366	<a href="base_cond_exp.xml" target="_top">Base Type Requirements for Conditional Expressions</a><br/>
	4367	<a href="base_require.xml" target="_top">AD<Base> Requirements for Base Type</a><br/>
	4368	<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
	4369	<a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
	4370	<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
	4371	<a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	4372	for<b>_</b>jac<b>_</b>sparse <a href="old_atomic.xml#for_jac_sparse" target="_top">User Defined Atomic AD Functions: for_jac_sparse</a><br/>
	4373	for<b>_</b>sparse<b>_</b>jac <a href="atomic_matrix_mul.hpp.xml#for_sparse_jac" target="_top">Matrix Multiply as an Atomic Operation: for_sparse_jac</a><br/>
	4374	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function.for_sparse_jac" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function.for_sparse_jac</a><br/>
	4375	<a href="atomic_hes_sparse.cpp.xml#for_sparse_jac" target="_top">Atomic Operation Hessian Sparsity: Example and Test: for_sparse_jac</a><br/>
	4376	<a href="atomic_tangent.cpp.xml#Use Atomic Function.for_sparse_jac" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.for_sparse_jac</a><br/>
	4377	<a href="atomic_tangent.cpp.xml#for_sparse_jac" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: for_sparse_jac</a><br/>
	4378	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function.for_sparse_jac" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function.for_sparse_jac</a><br/>
	4379	<a href="atomic_reciprocal.cpp.xml#for_sparse_jac" target="_top">Reciprocal as an Atomic Operation: Example and Test: for_sparse_jac</a><br/>
	4380	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function.for_sparse_jac" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function.for_sparse_jac</a><br/>
	4381	<a href="atomic_norm_sq.cpp.xml#for_sparse_jac" target="_top">Euclidean Norm Squared: Example and Test: for_sparse_jac</a><br/>
	4382	<a href="atomic_for_sparse_jac.xml#Examples.Use for_sparse_jac" target="_top">Atomic Forward Jacobian Sparsity Patterns: Examples.Use for_sparse_jac</a><br/>
	4383	<a href="atomic_for_sparse_jac.xml#Examples.Define for_sparse_jac" target="_top">Atomic Forward Jacobian Sparsity Patterns: Examples.Define for_sparse_jac</a><br/>
1185	4384	atomic<b> </b>callback <a href="atomic_for_sparse_jac.xml" target="_top">Atomic Forward Jacobian Sparsity Patterns</a><br/>
1186	4385	atomic<b> </b>virtual <a href="atomic_for_sparse_jac.xml" target="_top">Atomic Forward Jacobian Sparsity Patterns</a><br/>
1187		forward <a href="wishlist.xml#Forward Mode Recomputation" target="_top">The CppAD Wish List: Forward Mode Recomputation</a><br/>
	4386	form <a href="exp_eps_rev2.xml#Mathematical Form" target="_top">exp_eps: Second Order Reverse Sweep: Mathematical Form</a><br/>
	4387	<a href="exp_eps_for2.xml#Mathematical Form" target="_top">exp_eps: Second Order Forward Mode: Mathematical Form</a><br/>
	4388	<a href="exp_eps_rev1.xml#Mathematical Form" target="_top">exp_eps: First Order Reverse Sweep: Mathematical Form</a><br/>
	4389	<a href="exp_eps_for1.xml#Mathematical Form" target="_top">exp_eps: First Order Forward Sweep: Mathematical Form</a><br/>
	4390	<a href="exp_eps_for0.xml#Mathematical Form" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Mathematical Form</a><br/>
	4391	<a href="exp_2_rev2.xml#Mathematical Form" target="_top">exp_2: Second Order Reverse Mode: Mathematical Form</a><br/>
	4392	<a href="exp_2_for2.xml#Mathematical Form" target="_top">exp_2: Second Order Forward Mode: Mathematical Form</a><br/>
	4393	<a href="exp_2_rev1.xml#Mathematical Form" target="_top">exp_2: First Order Reverse Mode: Mathematical Form</a><br/>
	4394	<a href="exp_2_for1.xml#Mathematical Form" target="_top">exp_2: First Order Forward Mode: Mathematical Form</a><br/>
	4395	<a href="exp_2_for0.xml#Mathematical Form" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Mathematical Form</a><br/>
	4396	<a href="exp_2.xml#Mathematical Form" target="_top">Second Order Exponential Approximation: Mathematical Form</a><br/>
	4397	formula <a href="forwardtheory.xml#Standard Math Functions.Taylor Coefficients Recursion Formula" target="_top">The Theory of Forward Mode: Standard Math Functions.Taylor Coefficients Recursion Formula</a><br/>
	4398	forone <a href="forone.xml#ForOne Uses Forward" target="_top">First Order Partial Derivative: Driver Routine: ForOne Uses Forward</a><br/>
	4399	fortwo <a href="fortwo.xml#ForTwo Uses Forward" target="_top">Forward Mode Second Partial Derivative Driver: ForTwo Uses Forward</a><br/>
	4400	forward <a href="old_atomic.xml#forward" target="_top">User Defined Atomic AD Functions: forward</a><br/>
	4401	<a href="old_atomic.xml#ty.forward" target="_top">User Defined Atomic AD Functions: ty.forward</a><br/>
	4402	<a href="ipopt_nlp_ode_problem.xml#Forward Problem" target="_top">An ODE Inverse Problem Example: Forward Problem</a><br/>
	4403	<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
	4404	<a href="wishlist.xml#Forward Mode Recomputation" target="_top">The CppAD Wish List: Forward Mode Recomputation</a><br/>
	4405	<a href="wishlist.xml#Forward Mode Recomputation" target="_top">The CppAD Wish List: Forward Mode Recomputation</a><br/>
	4406	<a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a><br/>
	4407	<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
	4408	<a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a><br/>
	4409	<a href="asinforward.xml" target="_top">Arcsine Function Forward Taylor Polynomial Theory</a><br/>
	4410	<a href="atanforward.xml" target="_top">Arctangent Function Forward Taylor Polynomial Theory</a><br/>
	4411	<a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
	4412	<a href="sqrtforward.xml" target="_top">Square Root Function Forward Taylor Polynomial Theory</a><br/>
	4413	<a href="logforward.xml" target="_top">Logarithm Function Forward Taylor Polynomial Theory</a><br/>
	4414	<a href="expforward.xml" target="_top">Exponential Function Forward Taylor Polynomial Theory</a><br/>
	4415	<a href="forwardtheory.xml" target="_top">The Theory of Forward Mode</a><br/>
1188	4416	<a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
	4417	<a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
	4418	<a href="ode_taylor.cpp.xml#Forward Mode" target="_top">Taylor's Ode Solver: An Example and Test: Forward Mode</a><br/>
	4419	<a href="ipopt_solve_ode_inverse.cpp.xml#Forward Problem" target="_top">ODE Inverse Problem Definitions: Source Code: Forward Problem</a><br/>
	4420	<a href="funcheck.xml#FunCheck Uses Forward" target="_top">Check an ADFun Sequence of Operations: FunCheck Uses Forward</a><br/>
	4421	<a href="sparse_hessian.xml#Uses Forward" target="_top">Sparse Hessian: Easy Driver: Uses Forward</a><br/>
	4422	<a href="sparse_jacobian.xml#Uses Forward" target="_top">Sparse Jacobian: Easy Driver: Uses Forward</a><br/>
	4423	<a href="revtwo.xml#RevTwo Uses Forward" target="_top">Reverse Mode Second Partial Derivative Driver: RevTwo Uses Forward</a><br/>
	4424	<a href="fortwo.xml#ForTwo Uses Forward" target="_top">Forward Mode Second Partial Derivative Driver: ForTwo Uses Forward</a><br/>
	4425	<a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
	4426	<a href="hessian.xml#Hessian Uses Forward" target="_top">Hessian: Easy Driver: Hessian Uses Forward</a><br/>
	4427	<a href="revone.xml#RevOne Uses Forward" target="_top">First Order Derivative: Driver Routine: RevOne Uses Forward</a><br/>
	4428	<a href="forone.xml#ForOne Uses Forward" target="_top">First Order Partial Derivative: Driver Routine: ForOne Uses Forward</a><br/>
	4429	<a href="jacobian.xml#Forward or Reverse" target="_top">Jacobian: Driver Routine: Forward or Reverse</a><br/>
	4430	<a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
	4431	<a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a><br/>
	4432	<a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
	4433	<a href="size_order.xml#Forward" target="_top">Number Taylor Coefficient Orders Currently Stored: Forward</a><br/>
	4434	<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	4435	<a href="forward_dir.xml" target="_top">Multiple Directions Forward Mode</a><br/>
	4436	<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	4437	<a href="forward.cpp.xml" target="_top">Forward Mode: Example and Test</a><br/>
	4438	<a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a><br/>
	4439	<a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a><br/>
	4440	<a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
	4441	<a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
	4442	<a href="forward.xml" target="_top">Forward Mode</a><br/>
	4443	<a href="dependent.xml#Forward" target="_top">Stop Recording and Store Operation Sequence: Forward</a><br/>
	4444	<a href="atomic_matrix_mul.hpp.xml#forward" target="_top">Matrix Multiply as an Atomic Operation: forward</a><br/>
	4445	<a href="atomic_matrix_mul.hpp.xml#Forward Matrix Multipliy" target="_top">Matrix Multiply as an Atomic Operation: Forward Matrix Multipliy</a><br/>
	4446	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function.forward" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function.forward</a><br/>
	4447	<a href="atomic_hes_sparse.cpp.xml#forward" target="_top">Atomic Operation Hessian Sparsity: Example and Test: forward</a><br/>
	4448	<a href="atomic_tangent.cpp.xml#Use Atomic Function.forward" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.forward</a><br/>
	4449	<a href="atomic_tangent.cpp.xml#forward" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: forward</a><br/>
	4450	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function.forward" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function.forward</a><br/>
	4451	<a href="atomic_reciprocal.cpp.xml#forward" target="_top">Reciprocal as an Atomic Operation: Example and Test: forward</a><br/>
	4452	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function.forward" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function.forward</a><br/>
	4453	<a href="atomic_norm_sq.cpp.xml#forward" target="_top">Euclidean Norm Squared: Example and Test: forward</a><br/>
	4454	<a href="atomic_get_started.cpp.xml#Use Atomic Function.forward" target="_top">Getting Started with Atomic Operations: Example and Test: Use Atomic Function.forward</a><br/>
	4455	<a href="atomic_get_started.cpp.xml#forward" target="_top">Getting Started with Atomic Operations: Example and Test: forward</a><br/>
	4456	<a href="atomic_for_sparse_jac.xml" target="_top">Atomic Forward Jacobian Sparsity Patterns</a><br/>
	4457	<a href="atomic_forward.xml#Examples.Use forward" target="_top">Atomic Forward Mode: Examples.Use forward</a><br/>
	4458	<a href="atomic_forward.xml#Examples.Define forward" target="_top">Atomic Forward Mode: Examples.Define forward</a><br/>
	4459	<a href="atomic_forward.xml" target="_top">Atomic Forward Mode</a><br/>
	4460	<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
	4461	<a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
	4462	<a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
	4463	<a href="exp_eps_cppad.xml" target="_top">exp_eps: CppAD Forward and Reverse Sweeps</a><br/>
	4464	<a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a><br/>
	4465	<a href="exp_eps_for1.cpp.xml" target="_top">exp_eps: Verify First Order Forward Sweep</a><br/>
	4466	<a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a><br/>
	4467	<a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a><br/>
	4468	<a href="exp_eps_for1.xml" target="_top">exp_eps: First Order Forward Sweep</a><br/>
	4469	<a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
	4470	<a href="exp_2_cppad.xml" target="_top">exp_2: CppAD Forward and Reverse Sweeps</a><br/>
	4471	<a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a><br/>
	4472	<a href="exp_2_for1.cpp.xml" target="_top">exp_2: Verify First Order Forward Sweep</a><br/>
	4473	<a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a><br/>
	4474	<a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a><br/>
	4475	<a href="exp_2_for1.xml" target="_top">exp_2: First Order Forward Mode</a><br/>
	4476	<a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
	4477	<a href="introduction.xml#Preface.Forward Mode" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Forward Mode</a><br/>
1189	4478	acos<b> </b>theory <a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a><br/>
1190	4479	asin<b> </b>theory <a href="asinforward.xml" target="_top">Arcsine Function Forward Taylor Polynomial Theory</a><br/>
1191	4480	atan<b> </b>theory <a href="atanforward.xml" target="_top">Arctangent Function Forward Taylor Polynomial Theory</a><br/>

1195	4484	cosh <a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
1196	4485	debug <a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
1197	4486	easy<b> </b>driver <a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
	4487	erf<b> </b>theory <a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a><br/>
1198	4488	exp<b> </b>theory <a href="expforward.xml" target="_top">Exponential Function Forward Taylor Polynomial Theory</a><br/>
1199	4489	first<b> </b>order <a href="exp_eps_for1.xml" target="_top">exp_eps: First Order Forward Sweep</a><br/>
1200	4490	first<b> </b>order <a href="exp_2_for1.xml" target="_top">exp_2: First Order Forward Mode</a><br/>
1201	4491	log<b> </b>theory <a href="logforward.xml" target="_top">Logarithm Function Forward Taylor Polynomial Theory</a><br/>
1202		mode <a href="forwardany.xml" target="_top">Any Order Forward Mode</a><br/>
	4492	mode <a href="forward_dir.xml" target="_top">Multiple Directions Forward Mode</a><br/>
	4493	mode <a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a><br/>
1203	4494	mode<b> </b>example <a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a><br/>
1204	4495	mode<b> </b>example <a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a><br/>
1205	4496	mode<b> </b>example <a href="exp_2_for1.xml" target="_top">exp_2: First Order Forward Mode</a><br/>
1206	4497	mode<b> </b>print <a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
1207	4498	mode<b> </b>print <a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
1208		multiple<b> </b>orders <a href="forward_mul.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	4499	multiple<b> </b>orders <a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	4500	multiple<b> </b>orders <a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
1209	4501	second<b> </b>order <a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a><br/>
1210	4502	second<b> </b>order <a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a><br/>
1211	4503	sin <a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
1212	4504	sinh <a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
1213	4505	sparsity<b> </b>Jacobian <a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a><br/>
1214		speed <a href="wishlist.xml#Multiple Argument Forward" target="_top">The CppAD Wish List: Multiple Argument Forward</a><br/>
	4506	speed <a href="wishlist.xml#Multiple Directions" target="_top">The CppAD Wish List: Multiple Directions</a><br/>
1215	4507	sqrt<b> </b>theory <a href="sqrtforward.xml" target="_top">Square Root Function Forward Taylor Polynomial Theory</a><br/>
1216	4508	tan<b> </b>theory <a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
1217	4509	zero<b> </b>order <a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
1218	4510	zero<b> </b>order <a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
1219	4511	zero<b> </b>order <a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
1220	4512	zero<b> </b>order<b> </b>print <a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
1221		free<br/>
	4513	fp <a href="sparse_hes_fun.xml#fp" target="_top">Evaluate a Function That Has a Sparse Hessian: fp</a><br/>
	4514	<a href="sparse_jac_fun.xml#fp" target="_top">Evaluate a Function That Has a Sparse Jacobian: fp</a><br/>
	4515	<a href="ode_evaluate.xml#fp" target="_top">Evaluate a Function Defined in Terms of an ODE: fp</a><br/>
	4516	free <a href="old_atomic.xml#Syntax.Free Static Memory" target="_top">User Defined Atomic AD Functions: Syntax.Free Static Memory</a><br/>
	4517	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	4518	<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
	4519	<a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	4520	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	4521	<a href="atomic_base_clear.xml" target="_top">Free Static Variables</a><br/>
1222	4522	all<b> </b>thread<b>_</b>alloc <a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
1223	4523	atomic<b> </b>static <a href="atomic_base_clear.xml" target="_top">Free Static Variables</a><br/>
1224	4524	available <a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
1225		unix<b> </b>install <a href="installunix.xml" target="_top">Unix Test and Installation</a><br/>
1226		free<b>_</b>available<br/>
	4525	unix<b> </b>install <a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a><br/>
	4526	free<b>_</b>available <a href="ta_hold_memory.xml#free_available" target="_top">Control When Thread Alloc Retains Memory For Future Use: free_available</a><br/>
1227	4527	omp<b>_</b>alloc <a href="omp_free_available.xml#Deprecated" target="_top">Free Memory Currently Available for Quick Use by a Thread: Deprecated</a><br/>
1228	4528	thread<b>_</b>alloc <a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
1229		function <a href="glossary.xml#Base Function" target="_top">Glossary: Base Function</a><br/>
	4529	freeing <a href="capacity_order.xml#c.Freeing Memory" target="_top">Controlling Taylor Coefficients Memory Allocation: c.Freeing Memory</a><br/>
	4530	frequently <a href="faq.xml" target="_top">Frequently Asked Questions and Answers</a><br/>
	4531	from <a href="numerictype.xml#Constructor From Integer" target="_top">Definition of a Numeric Type: Constructor From Integer</a><br/>
	4532	<a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
	4533	<a href="integer.xml" target="_top">Convert From AD to Integer</a><br/>
	4534	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	4535	<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
	4536	fun <a href="opt_val_hes.xml#Fun" target="_top">Jacobian and Hessian of Optimal Values: Fun</a><br/>
	4537	<a href="benderquad.xml#fun" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: fun</a><br/>
	4538	<a href="odegearcontrol.xml#Fun" target="_top">An Error Controller for Gear's Ode Solvers: Fun</a><br/>
	4539	<a href="odegear.xml#Fun" target="_top">An Arbitrary Order Gear Method: Fun</a><br/>
	4540	<a href="rosen34.xml#Fun" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun</a><br/>
	4541	<a href="runge45.xml#Fun" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Fun</a><br/>
	4542	<a href="multi_newton_work.cpp.xml#multi_newton_setup.fun" target="_top">Multi-threading Newton Method Utility Routines: multi_newton_setup.fun</a><br/>
	4543	<a href="multi_newton.cpp.xml#fun" target="_top">A Multi-Threaded Newton's Method: fun</a><br/>
	4544	<a href="std_math_ad.xml#fun" target="_top">AD Standard Math Unary Functions: fun</a><br/>
	4545	fun<b>.</b>dy <a href="benderquad.xml#fun.fun.dy" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: fun.fun.dy</a><br/>
	4546	fun<b>.</b>ell <a href="opt_val_hes.xml#Fun.fun.ell" target="_top">Jacobian and Hessian of Optimal Values: Fun.fun.ell</a><br/>
	4547	fun<b>.</b>f <a href="benderquad.xml#fun.fun.f" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: fun.fun.f</a><br/>
	4548	fun<b>.</b>h <a href="benderquad.xml#fun.fun.h" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: fun.fun.h</a><br/>
	4549	fun<b>.</b>s <a href="opt_val_hes.xml#Fun.fun.s" target="_top">Jacobian and Hessian of Optimal Values: Fun.fun.s</a><br/>
	4550	fun<b>.</b>sy <a href="opt_val_hes.xml#Fun.fun.sy" target="_top">Jacobian and Hessian of Optimal Values: Fun.fun.sy</a><br/>
	4551	fun<b>::</b>ad<b>_</b>vector <a href="opt_val_hes.xml#Fun.Fun::ad_vector" target="_top">Jacobian and Hessian of Optimal Values: Fun.Fun::ad_vector</a><br/>
	4552	funcheck <a href="funcheck.xml#FunCheck Uses Forward" target="_top">Check an ADFun Sequence of Operations: FunCheck Uses Forward</a><br/>
	4553	function <a href="old_mat_mul.hpp.xml#Declare mat_mul Function" target="_top">Define Matrix Multiply as a User Atomic Operation: Declare mat_mul Function</a><br/>
	4554	<a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	4555	<a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	4556	<a href="old_atomic.xml#Example.Tangent Function" target="_top">User Defined Atomic AD Functions: Example.Tangent Function</a><br/>
	4557	<a href="old_atomic.xml#Syntax.Use Function" target="_top">User Defined Atomic AD Functions: Syntax.Use Function</a><br/>
	4558	<a href="old_atomic.xml#Syntax.Define Function" target="_top">User Defined Atomic AD Functions: Syntax.Define Function</a><br/>
	4559	<a href="ipopt_nlp_ode_fast.xml#Objective Function" target="_top">ODE Fitting Using Fast Representation: Objective Function</a><br/>
	4560	<a href="ipopt_nlp_ode_simple.xml#Objective Function" target="_top">ODE Fitting Using Simple Representation: Objective Function</a><br/>
	4561	<a href="glossary.xml#Base Function" target="_top">Glossary: Base Function</a><br/>
1230	4562	<a href="glossary.xml#AD Function" target="_top">Glossary: AD Function</a><br/>
	4563	<a href="erf_reverse.xml" target="_top">Error Function Reverse Mode Theory</a><br/>
	4564	<a href="acosreverse.xml" target="_top">Arccosine Function Reverse Mode Theory</a><br/>
	4565	<a href="asinreverse.xml" target="_top">Arcsine Function Reverse Mode Theory</a><br/>
	4566	<a href="atanreverse.xml" target="_top">Arctangent Function Reverse Mode Theory</a><br/>
	4567	<a href="sqrtreverse.xml" target="_top">Square Root Function Reverse Mode Theory</a><br/>
	4568	<a href="logreverse.xml" target="_top">Logarithm Function Reverse Mode Theory</a><br/>
	4569	<a href="expreverse.xml" target="_top">Exponential Function Reverse Mode Theory</a><br/>
	4570	<a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a><br/>
	4571	<a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a><br/>
	4572	<a href="asinforward.xml" target="_top">Arcsine Function Forward Taylor Polynomial Theory</a><br/>
	4573	<a href="atanforward.xml" target="_top">Arctangent Function Forward Taylor Polynomial Theory</a><br/>
	4574	<a href="sqrtforward.xml" target="_top">Square Root Function Forward Taylor Polynomial Theory</a><br/>
	4575	<a href="logforward.xml" target="_top">Logarithm Function Forward Taylor Polynomial Theory</a><br/>
	4576	<a href="expforward.xml" target="_top">Exponential Function Forward Taylor Polynomial Theory</a><br/>
	4577	<a href="sparse_hes_fun.xml#fp.Function" target="_top">Evaluate a Function That Has a Sparse Hessian: fp.Function</a><br/>
	4578	<a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
	4579	<a href="sparse_jac_fun.xml#fp.Function" target="_top">Evaluate a Function That Has a Sparse Jacobian: fp.Function</a><br/>
	4580	<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
	4581	<a href="ode_evaluate.xml#fp.Function" target="_top">Evaluate a Function Defined in Terms of an ODE: fp.Function</a><br/>
	4582	<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
	4583	<a href="mul_level.xml#General Procedure.Derivative of Outer Function" target="_top">Using Multiple Levels of AD: General Procedure.Derivative of Outer Function</a><br/>
	4584	<a href="mul_level.xml#General Procedure.Outer Function" target="_top">Using Multiple Levels of AD: General Procedure.Outer Function</a><br/>
	4585	<a href="mul_level.xml#General Procedure.Derivative of Inner Function" target="_top">Using Multiple Levels of AD: General Procedure.Derivative of Inner Function</a><br/>
	4586	<a href="mul_level.xml#General Procedure.Inner Function Calculations" target="_top">Using Multiple Levels of AD: General Procedure.Inner Function Calculations</a><br/>
	4587	<a href="pow_int.xml" target="_top">The Integer Power Function</a><br/>
	4588	<a href="forward_order.xml#Purpose.Function Values" target="_top">Multiple Order Forward Mode: Purpose.Function Values</a><br/>
	4589	<a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
	4590	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function</a><br/>
	4591	<a href="atomic_hes_sparse.cpp.xml#Use Atomic Function" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Use Atomic Function</a><br/>
	4592	<a href="atomic_tangent.cpp.xml#Use Atomic Function" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function</a><br/>
	4593	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function</a><br/>
	4594	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function</a><br/>
	4595	<a href="atomic_get_started.cpp.xml#Use Atomic Function" target="_top">Getting Started with Atomic Operations: Example and Test: Use Atomic Function</a><br/>
	4596	<a href="atomic_afun.xml" target="_top">Using AD Version of Atomic Function</a><br/>
	4597	<a href="atomic_option.xml" target="_top">Set Atomic Function Options</a><br/>
	4598	<a href="atomic_ctor.xml" target="_top">Atomic Function Constructor</a><br/>
	4599	<a href="atomic_base.xml#Examples.Scalar Function" target="_top">User Defined Atomic AD Functions: Examples.Scalar Function</a><br/>
	4600	<a href="pow.xml" target="_top">The AD Power Function</a><br/>
	4601	<a href="erf.xml" target="_top">The AD Error Function</a><br/>
	4602	<a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a><br/>
	4603	<a href="sign.xml" target="_top">Sign Function</a><br/>
	4604	<a href="abs.xml" target="_top">AD Absolute Value Function</a><br/>
	4605	<a href="exp_eps.xml#Mathematical Function" target="_top">An Epsilon Accurate Exponential Approximation: Mathematical Function</a><br/>
	4606	<a href="get_started.cpp.xml#Function" target="_top">Getting Started Using CppAD to Compute Derivatives: Function</a><br/>
1231	4607	AD<b> </b>Bool<b> </b>valued <a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
1232	4608	AD<b> </b>bool <a href="boolfun.xml" target="_top">AD Boolean Functions</a><br/>
1233	4609	AD<b> </b>valued <a href="advalued.xml" target="_top">AD Valued Operations and Functions</a><br/>

1242	4618	sparse<b>_</b>jac<b>_</b>fun <a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
1243	4619	user<b> </b>atomic <a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
1244	4620	user<b> </b>atomic <a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	4621	function<b>:</b> <a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a><br/>
	4622	<a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>
	4623	<a href="near_equal.cpp.xml" target="_top">NearEqual Function: Example and Test</a><br/>
	4624	<a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a><br/>
	4625	<a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a><br/>
	4626	<a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a><br/>
	4627	<a href="sign.cpp.xml" target="_top">Sign Function: Example and Test</a><br/>
	4628	<a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
	4629	<a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a><br/>
	4630	<a href="tan.cpp.xml" target="_top">The AD tan Function: Example and Test</a><br/>
	4631	<a href="sqrt.cpp.xml" target="_top">The AD sqrt Function: Example and Test</a><br/>
	4632	<a href="sinh.cpp.xml" target="_top">The AD sinh Function: Example and Test</a><br/>
	4633	<a href="sin.cpp.xml" target="_top">The AD sin Function: Example and Test</a><br/>
	4634	<a href="log10.cpp.xml" target="_top">The AD log10 Function: Example and Test</a><br/>
	4635	<a href="log.cpp.xml" target="_top">The AD log Function: Example and Test</a><br/>
	4636	<a href="exp.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
	4637	<a href="cosh.cpp.xml" target="_top">The AD cosh Function: Example and Test</a><br/>
	4638	<a href="cos.cpp.xml" target="_top">The AD cos Function: Example and Test</a><br/>
	4639	<a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
	4640	<a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>
	4641	<a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
	4642	functions <a href="old_mat_mul.hpp.xml#CppAD User Atomic Callback Functions" target="_top">Define Matrix Multiply as a User Atomic Operation: CppAD User Atomic Callback Functions</a><br/>
	4643	<a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	4644	<a href="fundeprecated.xml" target="_top">ADFun Object Deprecated Member Functions</a><br/>
	4645	<a href="reversetheory.xml#Standard Math Functions" target="_top">The Theory of Reverse Mode: Standard Math Functions</a><br/>
	4646	<a href="forwardtheory.xml#Standard Math Functions" target="_top">The Theory of Forward Mode: Standard Math Functions</a><br/>
	4647	<a href="faq.xml#Math Functions" target="_top">Frequently Asked Questions and Answers: Math Functions</a><br/>
	4648	<a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
	4649	<a href="speed_main.xml#Link Functions" target="_top">Running the Speed Test Program: Link Functions</a><br/>
	4650	<a href="optimize.xml#Atomic Functions" target="_top">Optimize an ADFun Object Tape: Atomic Functions</a><br/>
	4651	<a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a><br/>
	4652	<a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
	4653	<a href="base_identical.xml#Identical.Identical Functions" target="_top">Base Type Requirements for Identically Equal Comparisons: Identical.Identical Functions</a><br/>
	4654	<a href="base_member.xml" target="_top">Required Base Class Member Functions</a><br/>
	4655	<a href="boolfun.xml" target="_top">AD Boolean Functions</a><br/>
	4656	<a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
	4657	<a href="atomic_base.xml#Virtual Functions" target="_top">User Defined Atomic AD Functions: Virtual Functions</a><br/>
	4658	<a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	4659	<a href="checkpoint.xml" target="_top">Checkpointing Functions</a><br/>
	4660	<a href="atomic.xml" target="_top">Atomic AD Functions</a><br/>
	4661	<a href="discrete.xml" target="_top">Discrete AD Functions</a><br/>
	4662	<a href="mathother.xml" target="_top">Other AD Math Functions</a><br/>
	4663	<a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
	4664	<a href="advalued.xml" target="_top">AD Valued Operations and Functions</a><br/>
	4665	functions<b>:</b> <a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
	4666	<a href="bool_fun.cpp.xml" target="_top">AD Boolean Functions: Example and Test</a><br/>
	4667	future <a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
	4668	<a href="atomic_base_clear.xml#Future Use" target="_top">Free Static Variables: Future Use</a><br/>
1245	4669
1246	4670	<b><big><a name="G">G</a></big></b>
1247	4671	<br/>
1248	4672	Gear<br/>
1249	4673	Ode <a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
	4674	g <a href="cppad_ipopt_nlp.xml#solution.g" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: solution.g</a><br/>
	4675	<a href="det_grad_33.xml#g" target="_top">Check Gradient of Determinant of 3 by 3 matrix: g</a><br/>
	4676	<a href="ipopt_solve.xml#solution.g" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: solution.g</a><br/>
	4677	<a href="benderquad.xml#g" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: g</a><br/>
	4678	<a href="funcheck.xml#g" target="_top">Check an ADFun Sequence of Operations: g</a><br/>
	4679	<a href="atomic_reverse.xml#F, G, H" target="_top">Atomic Reverse Mode: F, G, H</a><br/>
	4680	g<b>_</b>l <a href="cppad_ipopt_nlp.xml#g_l" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: g_l</a><br/>
	4681	g<b>_</b>u <a href="cppad_ipopt_nlp.xml#g_u" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: g_u</a><br/>
	4682	gcc <a href="bugs.xml#gcc 3.4.4 -O2" target="_top">Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2</a><br/>
1250	4683	gcc<b> </b>3<b>.</b>4<b>.</b>4<br/>
1251	4684	bug <a href="bugs.xml#gcc 3.4.4 -O2" target="_top">Know Bugs and Problems Using CppAD: gcc 3.4.4 -O2</a><br/>
1252		general<br/>
	4685	gear <a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
	4686	gear<b>'</b>s <a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
	4687	<a href="odegear.xml#Gear's Method" target="_top">An Arbitrary Order Gear Method: Gear's Method</a><br/>
	4688	general <a href="mul_level.xml#General Procedure" target="_top">Using Multiple Levels of AD: General Procedure</a><br/>
	4689	<a href="mul_level.xml#General Solution" target="_top">Using Multiple Levels of AD: General Solution</a><br/>
	4690	<a href="general.xml" target="_top">General Examples</a><br/>
	4691	<a href="library.xml#General Purpose Utilities" target="_top">The CppAD General Purpose Library: General Purpose Utilities</a><br/>
	4692	<a href="library.xml" target="_top">The CppAD General Purpose Library</a><br/>
	4693	<a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a><br/>
	4694	<a href="atomic_base.xml#General Case" target="_top">User Defined Atomic AD Functions: General Case</a><br/>
1253	4695	example <a href="general.xml" target="_top">General Examples</a><br/>
1254		generator<br/>
	4696	generator <a href="cmake.xml#generator" target="_top">Using CMake to Configure CppAD: generator</a><br/>
1255	4697	makefile <a href="cmake.xml#generator" target="_top">Using CMake to Configure CppAD: generator</a><br/>
1256		get<br/>
	4698	get <a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	4699	<a href="omp_get_thread_num.xml" target="_top">Get the Current OpenMP Thread Number</a><br/>
	4700	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
	4701	<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	4702	<a href="ta_thread_num.xml" target="_top">Get the Current Thread Number</a><br/>
	4703	<a href="ta_num_threads.xml" target="_top">Get Number of Threads</a><br/>
1257	4704	adolc <a href="adolc_prefix.xml#get_adolc" target="_top">Including the ADOL-C Examples and Tests: get_adolc</a><br/>
	4705	colpack <a href="colpack_prefix.xml#get_colpack" target="_top">Including the ColPack Sparsity Calculations: get_colpack</a><br/>
1258	4706	eigen <a href="eigen_prefix.xml#get_eigen" target="_top">Including the Eigen Examples and Tests: get_eigen</a><br/>
1259	4707	fadbad <a href="fadbad_prefix.xml#get_fadbad" target="_top">Including the FADBAD Speed Tests: get_fadbad</a><br/>
1260	4708	ipopt <a href="ipopt_prefix.xml#get_ipopt" target="_top">Including the cppad_ipopt Library and Tests: get_ipopt</a><br/>
1261	4709	sacado <a href="sacado_prefix.xml#get_sacado" target="_top">Including the Sacado Speed Tests: get_sacado</a><br/>
1262		get<b>_</b>max<b>_</b>num<b>_</b>threads<br/>
	4710	get<b>_</b>adolc <a href="adolc_prefix.xml#get_adolc" target="_top">Including the ADOL-C Examples and Tests: get_adolc</a><br/>
	4711	get<b>_</b>colpack <a href="colpack_prefix.xml#get_colpack" target="_top">Including the ColPack Sparsity Calculations: get_colpack</a><br/>
	4712	get<b>_</b>eigen <a href="eigen_prefix.xml#get_eigen" target="_top">Including the Eigen Examples and Tests: get_eigen</a><br/>
	4713	get<b>_</b>fadbad <a href="fadbad_prefix.xml#get_fadbad" target="_top">Including the FADBAD Speed Tests: get_fadbad</a><br/>
	4714	get<b>_</b>ipopt <a href="ipopt_prefix.xml#get_ipopt" target="_top">Including the cppad_ipopt Library and Tests: get_ipopt</a><br/>
	4715	get<b>_</b>max<b>_</b>num<b>_</b>threads <a href="omp_max_num_threads.xml#get_max_num_threads" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator: get_max_num_threads</a><br/>
1263	4716	omp<b>_</b>alloc <a href="omp_max_num_threads.xml#Deprecated" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator: Deprecated</a><br/>
1264		get<b>_</b>started<br/>
	4717	get<b>_</b>sacado <a href="sacado_prefix.xml#get_sacado" target="_top">Including the Sacado Speed Tests: get_sacado</a><br/>
	4718	get<b>_</b>started <a href="ipopt_solve.xml#Example.get_started" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Example.get_started</a><br/>
1265	4719	atomic<b> </b>operation <a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
1266	4720	get<b>_</b>thread<b>_</b>num<br/>
1267	4721	omp<b>_</b>alloc <a href="omp_get_memory.xml#Deprecated" target="_top">Get At Least A Specified Amount of Memory: Deprecated</a><br/>
1268	4722	omp<b>_</b>alloc <a href="omp_get_thread_num.xml#Deprecated" target="_top">Get the Current OpenMP Thread Number: Deprecated</a><br/>
1269		getting<br/>
	4723	getting <a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	4724	<a href="atomic_base.xml#Examples.Getting Started" target="_top">User Defined Atomic AD Functions: Examples.Getting Started</a><br/>
	4725	<a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
1270	4726	started <a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
1271		gradient <a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	4727	gl <a href="ipopt_solve.xml#gl" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: gl</a><br/>
	4728	gradient <a href="sacado_ode.cpp.xml" target="_top">Sacado Speed: Gradient of Ode Solution</a><br/>
	4729	<a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	4730	<a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
	4731	<a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	4732	<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
	4733	<a href="cppad_ode.cpp.xml" target="_top">CppAD Speed: Gradient of Ode Solution</a><br/>
	4734	<a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	4735	<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
	4736	<a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	4737	<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
	4738	<a href="sparse_hes_fun.xml#fp.Gradient" target="_top">Evaluate a Function That Has a Sparse Hessian: fp.Gradient</a><br/>
	4739	<a href="ode_evaluate.xml#fp.Gradient" target="_top">Evaluate a Function Defined in Terms of an ODE: fp.Gradient</a><br/>
	4740	<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	4741	<a href="link_det_minor.xml#gradient" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: gradient</a><br/>
	4742	<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
	4743	<a href="link_det_lu.xml#gradient" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: gradient</a><br/>
	4744	<a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
	4745	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	4746	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	4747	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
1272	4748	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
1273	4749	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
	4750	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
1274	4751	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	4752	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	4753	<a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
1275	4754	conjugate <a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
	4755	grid <a href="ipopt_nlp_ode_problem.xml#Trapezoidal Approximation.Trapezoidal Time Grid" target="_top">An ODE Inverse Problem Example: Trapezoidal Approximation.Trapezoidal Time Grid</a><br/>
	4756	gu <a href="ipopt_solve.xml#gu" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: gu</a><br/>
	4757	guidelines <a href="wishlist.xml#Software Guidelines" target="_top">The CppAD Wish List: Software Guidelines</a><br/>
	4758	gx <a href="benderquad.xml#gx" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: gx</a><br/>
	4759	gxx <a href="benderquad.xml#gxx" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: gxx</a><br/>
1276	4760
1277	4761	<b><big><a name="H">H</a></big></b>
1278	4762	<br/>

1283	4767	driver <a href="hessian.xml" target="_top">Hessian: Easy Driver</a><br/>
1284	4768	sparse <a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a><br/>
1285	4769	times<b> </b>direction <a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a><br/>
1286		handler<br/>
	4770	h <a href="revsparsehes.xml#h" target="_top">Hessian Sparsity Pattern: Reverse Mode: h</a><br/>
	4771	<a href="atomic_reverse.xml#F, G, H" target="_top">Atomic Reverse Mode: F, G, H</a><br/>
	4772	handler <a href="cppad_assert.xml#Error Handler" target="_top">CppAD Assertions During Execution: Error Handler</a><br/>
	4773	<a href="errorhandler.xml#handler" target="_top">Replacing the CppAD Error Handler: handler</a><br/>
	4774	<a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
	4775	<a href="library.xml#Error Handler" target="_top">The CppAD General Purpose Library: Error Handler</a><br/>
1287	4776	error <a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
1288	4777	error <a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
	4778	handler<b>:</b> <a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
1289	4779	harmonic <a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
	4780	<a href="thread_test.cpp.xml#harmonic" target="_top">Run Multi-Threading Examples and Speed Tests: harmonic</a><br/>
1290	4781	multi<b>_</b>thread <a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
1291		harmonic<b>_</b>combine <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
1292		harmonic<b>_</b>setup <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
	4782	harmonic<b>_</b>combine <a href="harmonic_work.cpp.xml#harmonic_combine" target="_top">Multi-threading Sum of 1/i Utility Routines: harmonic_combine</a><br/>
	4783	<a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
	4784	harmonic<b>_</b>setup <a href="harmonic_work.cpp.xml#harmonic_setup" target="_top">Multi-threading Sum of 1/i Utility Routines: harmonic_setup</a><br/>
	4785	<a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
1293	4786	harmonic<b>_</b>time <a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
1294	4787	harmonic<b>_</b>work <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
1295		harmonic<b>_</b>worker <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
1296		hasnan <a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
1297		hessian<br/>
	4788	harmonic<b>_</b>worker <a href="harmonic_work.cpp.xml#harmonic_worker" target="_top">Multi-threading Sum of 1/i Utility Routines: harmonic_worker</a><br/>
	4789	<a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
	4790	has <a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
	4791	<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
	4792	hashing <a href="wishlist.xml#Optimization.Expression Hashing" target="_top">The CppAD Wish List: Optimization.Expression Hashing</a><br/>
	4793	hasnan <a href="nan.xml#hasnan" target="_top">Obtain Nan or Determine if a Value is Nan: hasnan</a><br/>
	4794	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	4795	head <a href="tracknewdel.xml#head newptr" target="_top">Routines That Track Use of New and Delete: head newptr</a><br/>
	4796	here <a href="preprocessor.xml#Documented Here" target="_top">CppAD API Preprocessor Symbols: Documented Here</a><br/>
	4797	hes <a href="opt_val_hes.xml#hes" target="_top">Jacobian and Hessian of Optimal Values: hes</a><br/>
	4798	<a href="sparse_hessian.xml#hes" target="_top">Sparse Hessian: Easy Driver: hes</a><br/>
	4799	<a href="hessian.xml#hes" target="_top">Hessian: Easy Driver: hes</a><br/>
	4800	hessian <a href="sacado_sparse_hessian.cpp.xml" target="_top">Sacado Speed: Sparse Hessian</a><br/>
	4801	<a href="fadbad_sparse_hessian.cpp.xml" target="_top">Fadbad Speed: Sparse Hessian</a><br/>
	4802	<a href="cppad_sparse_hessian.cpp.xml" target="_top">CppAD Speed: Sparse Hessian</a><br/>
	4803	<a href="adolc_sparse_hessian.cpp.xml" target="_top">Adolc Speed: Sparse Hessian</a><br/>
	4804	<a href="double_sparse_hessian.cpp.xml" target="_top">Double Speed: Sparse Hessian</a><br/>
	4805	<a href="sparse_hes_fun.xml#fp.Hessian" target="_top">Evaluate a Function That Has a Sparse Hessian: fp.Hessian</a><br/>
	4806	<a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
	4807	<a href="link_sparse_hessian.xml#hessian" target="_top">Speed Testing Sparse Hessian: hessian</a><br/>
	4808	<a href="link_sparse_hessian.xml" target="_top">Speed Testing Sparse Hessian</a><br/>
	4809	<a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
	4810	<a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
	4811	<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	4812	<a href="hessian.xml#Hessian Uses Forward" target="_top">Hessian: Easy Driver: Hessian Uses Forward</a><br/>
	4813	<a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>
	4814	<a href="revsparsehes.xml" target="_top">Hessian Sparsity Pattern: Reverse Mode</a><br/>
	4815	<a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a><br/>
	4816	<a href="reverse_two.xml#Hessian Times Direction" target="_top">Second Order Reverse Mode: Hessian Times Direction</a><br/>
	4817	<a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
	4818	<a href="atomic_rev_sparse_hes.xml" target="_top">Atomic Reverse Hessian Sparsity Patterns</a><br/>
	4819	<a href="atomic_base.xml#Examples.Hessian Sparsity Patterns" target="_top">User Defined Atomic AD Functions: Examples.Hessian Sparsity Patterns</a><br/>
	4820	atomic<b> </b>operation<b> </b>sparsity <a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
1298	4821	sparse <a href="sparse_hessian.xml" target="_top">Sparse Hessian: Easy Driver</a><br/>
1299	4822	speed<b> </b>adolc <a href="adolc_sparse_hessian.cpp.xml" target="_top">Adolc Speed: Sparse Hessian</a><br/>
1300	4823	speed<b> </b>cppad <a href="cppad_sparse_hessian.cpp.xml" target="_top">CppAD Speed: Sparse Hessian</a><br/>
1301	4824	speed<b> </b>double <a href="double_sparse_hessian.cpp.xml" target="_top">Double Speed: Sparse Hessian</a><br/>
	4825	hessian<b>:</b> <a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a><br/>
	4826	<a href="sparse_hessian.xml" target="_top">Sparse Hessian: Easy Driver</a><br/>
	4827	<a href="hessian.cpp.xml" target="_top">Hessian: Example and Test</a><br/>
	4828	<a href="hessian.xml" target="_top">Hessian: Easy Driver</a><br/>
1302	4829	hold<br/>
1303	4830	thread<b>_</b>alloc<b> </b>memory <a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
	4831	hold<b>_</b>memory <a href="multi_thread.xml#hold_memory" target="_top">Using CppAD in a Multi-Threading Environment: hold_memory</a><br/>
	4832	hyperbolic <a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
	4833	<a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
	4834	<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
	4835	<a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
1304	4836
1305	4837	<b><big><a name="I">I</a></big></b>
1306	4838	<br/>

1312	4844	base<b> </b>require <a href="base_require.xml#Integer" target="_top">AD<Base> Requirements for Base Type: Integer</a><br/>
1313	4845	Ipopt<br/>
1314	4846	AD <a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
1315		unix <a href="installunix.xml#ipopt_dir" target="_top">Unix Test and Installation: ipopt_dir</a><br/>
1316		identical<br/>
	4847	unix <a href="installunix.xml#ipopt_dir" target="_top">Deprecated Unix Test and Installation: ipopt_dir</a><br/>
	4848	i <a href="revtwo.xml#i" target="_top">Reverse Mode Second Partial Derivative Driver: i</a><br/>
	4849	<a href="revone.xml#i" target="_top">First Order Derivative: Driver Routine: i</a><br/>
	4850	<a href="vecad.xml#size_t Indexing.i" target="_top">AD Vectors that Record Index Operations: size_t Indexing.i</a><br/>
	4851	<a href="integer.xml#i" target="_top">Convert From AD to Integer: i</a><br/>
	4852	i<b>(</b>k<br/>
	4853	0<b>)</b> <a href="ipopt_nlp_ode_fast.xml#Trapezoidal Approximation.Range Indices I(k,0)" target="_top">ODE Fitting Using Fast Representation: Trapezoidal Approximation.Range Indices I(k,0)</a><br/>
	4854	0<b>)</b> <a href="ipopt_nlp_ode_fast.xml#Initial Condition.Range Indices I(k,0)" target="_top">ODE Fitting Using Fast Representation: Initial Condition.Range Indices I(k,0)</a><br/>
	4855	0<b>)</b> <a href="ipopt_nlp_ode_fast.xml#Objective Function.Range Indices I(k,0)" target="_top">ODE Fitting Using Fast Representation: Objective Function.Range Indices I(k,0)</a><br/>
	4856	i<b>/</b>o <a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a><br/>
	4857	id <a href="old_atomic.xml#id" target="_top">User Defined Atomic AD Functions: id</a><br/>
	4858	identical <a href="base_complex.hpp.xml#Identical" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Identical</a><br/>
	4859	<a href="base_double.hpp.xml#Identical" target="_top">Enable use of AD<Base> where Base is double: Identical</a><br/>
	4860	<a href="base_float.hpp.xml#Identical" target="_top">Enable use of AD<Base> where Base is float: Identical</a><br/>
	4861	<a href="base_adolc.hpp.xml#Identical" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Identical</a><br/>
	4862	<a href="base_alloc.hpp.xml#Identical" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Identical</a><br/>
	4863	<a href="base_identical.xml#Identical.Identical Functions" target="_top">Base Type Requirements for Identically Equal Comparisons: Identical.Identical Functions</a><br/>
	4864	<a href="base_identical.xml#Identical" target="_top">Base Type Requirements for Identically Equal Comparisons: Identical</a><br/>
1317	4865	base<b> </b>require <a href="base_identical.xml#Identical" target="_top">Base Type Requirements for Identically Equal Comparisons: Identical</a><br/>
	4866	identically <a href="base_identical.xml" target="_top">Base Type Requirements for Identically Equal Comparisons</a><br/>
	4867	<a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
	4868	identicalpar <a href="base_identical.xml#Identical.IdenticalPar" target="_top">Base Type Requirements for Identically Equal Comparisons: Identical.IdenticalPar</a><br/>
	4869	identity <a href="reverse_identity.xml" target="_top">An Important Reverse Mode Identity</a><br/>
	4870	if <a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
	4871	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	4872	<a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
	4873	<a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
	4874	if<b>_</b>false <a href="condexp.xml#if_false" target="_top">AD Conditional Expressions: if_false</a><br/>
	4875	if<b>_</b>true <a href="condexp.xml#if_true" target="_top">AD Conditional Expressions: if_true</a><br/>
1318	4876	imag<b>()</b> <a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
1319		implementation<br/>
	4877	implementation <a href="old_atomic.xml#Partial Implementation" target="_top">User Defined Atomic AD Functions: Partial Implementation</a><br/>
	4878	<a href="sacado_poly.cpp.xml#Implementation" target="_top">Sacado Speed: Second Derivative of a Polynomial: Implementation</a><br/>
	4879	<a href="sacado_ode.cpp.xml#Implementation" target="_top">Sacado Speed: Gradient of Ode Solution: Implementation</a><br/>
	4880	<a href="sacado_mat_mul.cpp.xml#Implementation" target="_top">Sacado Speed: Matrix Multiplication: Implementation</a><br/>
	4881	<a href="sacado_det_lu.cpp.xml#Implementation" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization: Implementation</a><br/>
	4882	<a href="sacado_det_minor.cpp.xml#Implementation" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion: Implementation</a><br/>
	4883	<a href="fadbad_poly.cpp.xml#Implementation" target="_top">Fadbad Speed: Second Derivative of a Polynomial: Implementation</a><br/>
	4884	<a href="fadbad_ode.cpp.xml#Implementation" target="_top">Fadbad Speed: Ode: Implementation</a><br/>
	4885	<a href="fadbad_mat_mul.cpp.xml#Implementation" target="_top">Fadbad Speed: Matrix Multiplication: Implementation</a><br/>
	4886	<a href="fadbad_det_lu.cpp.xml#Implementation" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization: Implementation</a><br/>
	4887	<a href="fadbad_det_minor.cpp.xml#Implementation" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion: Implementation</a><br/>
	4888	<a href="cppad_sparse_jacobian.cpp.xml#Implementation" target="_top">CppAD Speed: Sparse Jacobian: Implementation</a><br/>
	4889	<a href="cppad_sparse_hessian.cpp.xml#Implementation" target="_top">CppAD Speed: Sparse Hessian: Implementation</a><br/>
	4890	<a href="cppad_poly.cpp.xml#Implementation" target="_top">CppAD Speed: Second Derivative of a Polynomial: Implementation</a><br/>
	4891	<a href="cppad_ode.cpp.xml#Implementation" target="_top">CppAD Speed: Gradient of Ode Solution: Implementation</a><br/>
	4892	<a href="cppad_mat_mul.cpp.xml#Implementation" target="_top">CppAD Speed: Matrix Multiplication: Implementation</a><br/>
	4893	<a href="cppad_det_lu.cpp.xml#Implementation" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization: Implementation</a><br/>
	4894	<a href="cppad_det_minor.cpp.xml#Implementation" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion: Implementation</a><br/>
	4895	<a href="adolc_sparse_jacobian.cpp.xml#Implementation" target="_top">adolc Speed: Sparse Jacobian: Implementation</a><br/>
	4896	<a href="adolc_sparse_hessian.cpp.xml#Implementation" target="_top">Adolc Speed: Sparse Hessian: Implementation</a><br/>
	4897	<a href="adolc_poly.cpp.xml#Implementation" target="_top">Adolc Speed: Second Derivative of a Polynomial: Implementation</a><br/>
	4898	<a href="adolc_ode.cpp.xml#Implementation" target="_top">Adolc Speed: Ode: Implementation</a><br/>
	4899	<a href="adolc_mat_mul.cpp.xml#Implementation" target="_top">Adolc Speed: Matrix Multiplication: Implementation</a><br/>
	4900	<a href="adolc_det_lu.cpp.xml#Implementation" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization: Implementation</a><br/>
	4901	<a href="adolc_det_minor.cpp.xml#Implementation" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion: Implementation</a><br/>
	4902	<a href="double_sparse_jacobian.cpp.xml#Implementation" target="_top">Double Speed: Sparse Jacobian: Implementation</a><br/>
	4903	<a href="double_sparse_hessian.cpp.xml#Implementation" target="_top">Double Speed: Sparse Hessian: Implementation</a><br/>
	4904	<a href="double_poly.cpp.xml#Implementation" target="_top">Double Speed: Evaluate a Polynomial: Implementation</a><br/>
	4905	<a href="double_ode.cpp.xml#Implementation" target="_top">Double Speed: Ode Solution: Implementation</a><br/>
	4906	<a href="double_mat_mul.cpp.xml#Implementation" target="_top">CppAD Speed: Matrix Multiplication (Double Version): Implementation</a><br/>
	4907	<a href="double_det_lu.cpp.xml#Implementation" target="_top">Double Speed: Determinant Using Lu Factorization: Implementation</a><br/>
	4908	<a href="double_det_minor.cpp.xml#Implementation" target="_top">Double Speed: Determinant by Minor Expansion: Implementation</a><br/>
	4909	<a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
	4910	<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
	4911	<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
	4912	<a href="team_thread.hpp.xml#Speed Test of Implementation" target="_top">Specifications for A Team of AD Threads: Speed Test of Implementation</a><br/>
	4913	<a href="team_thread.hpp.xml#Example Implementation" target="_top">Specifications for A Team of AD Threads: Example Implementation</a><br/>
	4914	<a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
	4915	<a href="atomic_rev_sparse_hes.xml#Implementation" target="_top">Atomic Reverse Hessian Sparsity Patterns: Implementation</a><br/>
	4916	<a href="atomic_rev_sparse_jac.xml#Implementation" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Implementation</a><br/>
	4917	<a href="atomic_for_sparse_jac.xml#Implementation" target="_top">Atomic Forward Jacobian Sparsity Patterns: Implementation</a><br/>
	4918	<a href="atomic_reverse.xml#Implementation" target="_top">Atomic Reverse Mode: Implementation</a><br/>
	4919	<a href="atomic_forward.xml#Implementation" target="_top">Atomic Forward Mode: Implementation</a><br/>
	4920	<a href="atomic_ctor.xml#atomic_user.Implementation" target="_top">Atomic Function Constructor: atomic_user.Implementation</a><br/>
	4921	<a href="exp_eps.hpp.xml" target="_top">exp_eps: Implementation</a><br/>
	4922	<a href="exp_eps.xml#Implementation" target="_top">An Epsilon Accurate Exponential Approximation: Implementation</a><br/>
	4923	<a href="exp_2.hpp.xml" target="_top">exp_2: Implementation</a><br/>
	4924	<a href="exp_2.xml#Implementation" target="_top">Second Order Exponential Approximation: Implementation</a><br/>
1320	4925	exp<b>_</b>2 <a href="exp_2.hpp.xml" target="_top">exp_2: Implementation</a><br/>
1321	4926	exp<b>_</b>eps <a href="exp_eps.hpp.xml" target="_top">exp_eps: Implementation</a><br/>
1322		implicit<br/>
1323		ctor <a href="installunix.xml#--with-implicit_ctor" target="_top">Unix Test and Installation: --with-implicit_ctor</a><br/>
	4927	implementations <a href="thread_test.cpp.xml#Team Implementations" target="_top">Run Multi-Threading Examples and Speed Tests: Team Implementations</a><br/>
	4928	implicit <a href="ad_ctor.xml#x.implicit" target="_top">AD Constructors: x.implicit</a><br/>
	4929	ctor <a href="installunix.xml#--with-implicit_ctor" target="_top">Deprecated Unix Test and Installation: --with-implicit_ctor</a><br/>
1324	4930	ctor <a href="cmake.xml#cppad_implicit_ctor_from_any_type" target="_top">Using CMake to Configure CppAD: cppad_implicit_ctor_from_any_type</a><br/>
1325		in<b>_</b>parallel <a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	4931	important <a href="reverse_identity.xml" target="_top">An Important Reverse Mode Identity</a><br/>
	4932	improvements <a href="optimize.xml#Improvements" target="_top">Optimize an ADFun Object Tape: Improvements</a><br/>
	4933	in <a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
	4934	<a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
	4935	<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
	4936	<a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
	4937	<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	4938	<a href="team_pthread.cpp.xml#Bug in Cygwin" target="_top">Pthread Implementation of a Team of AD Threads: Bug in Cygwin</a><br/>
	4939	<a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
	4940	<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
	4941	<a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
	4942	<a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
	4943	<a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
	4944	<a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
	4945	<a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
	4946	<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
	4947	in<b>_</b>parallel <a href="ta_parallel_setup.xml#in_parallel" target="_top">Setup thread_alloc For Use in Multi-Threading Environment: in_parallel</a><br/>
	4948	<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
1326	4949	omp<b>_</b>alloc <a href="omp_in_parallel.xml#Deprecated" target="_top">Is The Current Execution in OpenMP Parallel Mode: Deprecated</a><br/>
1327	4950	thread<b>_</b>alloc <a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
1328	4951	inactive <a href="glossary.xml#Tape.Inactive" target="_top">Glossary: Tape.Inactive</a><br/>
1329		include<br/>
1330		cppad<b>.</b>hpp <a href="cppad.xml#Include File" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
	4952	inc <a href="speedtest.xml#inc" target="_top">Run One Speed Test and Print Results: inc</a><br/>
	4953	include <a href="old_mat_mul.cpp.xml#Include File" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test: Include File</a><br/>
	4954	<a href="omp_alloc.xml#Include" target="_top">A Quick OpenMP Memory Allocator Used by CppAD: Include</a><br/>
	4955	<a href="tracknewdel.xml#Include" target="_top">Routines That Track Use of New and Delete: Include</a><br/>
	4956	<a href="include_deprecated.xml" target="_top">Deprecated Include Files</a><br/>
	4957	<a href="cppad_eigen.hpp.xml#Include Files" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: Include Files</a><br/>
	4958	<a href="ipopt_solve.xml#Include File" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Include File</a><br/>
	4959	<a href="luratio.xml#Include" target="_top">LU Factorization of A Square Matrix and Stability Calculation: Include</a><br/>
	4960	<a href="thread_alloc.xml#Include" target="_top">A Fast Multi-Threading Memory Allocator: Include</a><br/>
	4961	<a href="cppad_vector.xml#Include" target="_top">The CppAD::vector Template Class: Include</a><br/>
	4962	<a href="odegearcontrol.xml#Include" target="_top">An Error Controller for Gear's Ode Solvers: Include</a><br/>
	4963	<a href="odegear.xml#Include" target="_top">An Arbitrary Order Gear Method: Include</a><br/>
	4964	<a href="odeerrcontrol.xml#Include" target="_top">An Error Controller for ODE Solvers: Include</a><br/>
	4965	<a href="rosen34.xml#Include" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Include</a><br/>
	4966	<a href="runge45.xml#Include" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Include</a><br/>
	4967	<a href="rombergmul.xml#Include" target="_top">Multi-dimensional Romberg Integration: Include</a><br/>
	4968	<a href="rombergone.xml#Include" target="_top">One DimensionalRomberg Integration: Include</a><br/>
	4969	<a href="luinvert.xml#Include" target="_top">Invert an LU Factored Equation: Include</a><br/>
	4970	<a href="lufactor.xml#Include" target="_top">LU Factorization of A Square Matrix: Include</a><br/>
	4971	<a href="lusolve.xml#Include" target="_top">Compute Determinant and Solve Linear Equations: Include</a><br/>
	4972	<a href="poly.xml#Include" target="_top">Evaluate a Polynomial or its Derivative: Include</a><br/>
	4973	<a href="pow_int.xml#Include" target="_top">The Integer Power Function: Include</a><br/>
	4974	<a href="nan.xml#Include" target="_top">Obtain Nan or Determine if a Value is Nan: Include</a><br/>
	4975	<a href="checksimplevector.xml#Include" target="_top">Check Simple Vector Concept: Include</a><br/>
	4976	<a href="checknumerictype.xml#Include" target="_top">Check NumericType Class Concept: Include</a><br/>
	4977	<a href="time_test.xml#Include" target="_top">Determine Amount of Time to Execute a Test: Include</a><br/>
	4978	<a href="speedtest.xml#Include" target="_top">Run One Speed Test and Print Results: Include</a><br/>
	4979	<a href="speed_test.xml#Include" target="_top">Run One Speed Test and Return Results: Include</a><br/>
	4980	<a href="nearequal.xml#Include Files" target="_top">Determine if Two Values Are Nearly Equal: Include Files</a><br/>
	4981	<a href="base_complex.hpp.xml#Include Order" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Include Order</a><br/>
	4982	<a href="base_adolc.hpp.xml#Include Files" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Include Files</a><br/>
	4983	<a href="base_alloc.hpp.xml#Include File" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Include File</a><br/>
	4984	<a href="base_require.xml#Include Order" target="_top">AD<Base> Requirements for Base Type: Include Order</a><br/>
	4985	<a href="exp_eps.xml#include" target="_top">An Epsilon Accurate Exponential Approximation: include</a><br/>
	4986	<a href="exp_2.xml#include" target="_top">Second Order Exponential Approximation: include</a><br/>
	4987	<a href="cppad.xml#Include File" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
	4988	cppad<b>.</b>hpp <a href="cppad.xml#Include File" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
1331	4989	deprecated<b> </b>file <a href="include_deprecated.xml" target="_top">Deprecated Include Files</a><br/>
1332	4990	include<b> </b>directories<br/>
1333	4991	install <a href="cmake.xml#cmake_install_includedirs" target="_top">Using CMake to Configure CppAD: cmake_install_includedirs</a><br/>
1334		independent <a href="glossary.xml#Tape.Independent Variable" target="_top">Glossary: Tape.Independent Variable</a><br/>
	4992	including <a href="sacado_prefix.xml" target="_top">Including the Sacado Speed Tests</a><br/>
	4993	<a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>
	4994	<a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a><br/>
	4995	<a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a><br/>
	4996	<a href="colpack_prefix.xml" target="_top">Including the ColPack Sparsity Calculations</a><br/>
	4997	<a href="adolc_prefix.xml" target="_top">Including the ADOL-C Examples and Tests</a><br/>
	4998	inclusion <a href="uniform_01.xml#Inclusion" target="_top">Simulate a [0,1] Uniform Random Variate: Inclusion</a><br/>
	4999	<a href="sparse_hes_fun.xml#Inclusion" target="_top">Evaluate a Function That Has a Sparse Hessian: Inclusion</a><br/>
	5000	<a href="sparse_jac_fun.xml#Inclusion" target="_top">Evaluate a Function That Has a Sparse Jacobian: Inclusion</a><br/>
	5001	<a href="ode_evaluate.xml#Inclusion" target="_top">Evaluate a Function Defined in Terms of an ODE: Inclusion</a><br/>
	5002	<a href="mat_sum_sq.xml#Inclusion" target="_top">Sum Elements of a Matrix Times Itself: Inclusion</a><br/>
	5003	<a href="det_grad_33.xml#Inclusion" target="_top">Check Gradient of Determinant of 3 by 3 matrix: Inclusion</a><br/>
	5004	<a href="det_33.xml#Inclusion" target="_top">Check Determinant of 3 by 3 matrix: Inclusion</a><br/>
	5005	<a href="det_by_minor.xml#Inclusion" target="_top">Determinant Using Expansion by Minors: Inclusion</a><br/>
	5006	<a href="det_of_minor.xml#Inclusion" target="_top">Determinant of a Minor: Inclusion</a><br/>
	5007	<a href="det_by_lu.xml#Inclusion" target="_top">Determinant Using Expansion by Lu Factorization: Inclusion</a><br/>
	5008	ind <a href="index_sort.xml#ind" target="_top">Returns Indices that Sort a Vector: ind</a><br/>
	5009	independent <a href="omp_max_thread.xml#Independent" target="_top">OpenMP Parallel Setup: Independent</a><br/>
	5010	<a href="glossary.xml#Tape.Independent Variable" target="_top">Glossary: Tape.Independent Variable</a><br/>
1335	5011	<a href="glossary.xml#Operation.Independent" target="_top">Glossary: Operation.Independent</a><br/>
	5012	<a href="faq.xml#Independent Variables" target="_top">Frequently Asked Questions and Answers: Independent Variables</a><br/>
1336	5013	<a href="faq.xml#Assignment and Independent" target="_top">Frequently Asked Questions and Answers: Assignment and Independent</a><br/>
	5014	<a href="faq.xml#Assignment and Independent" target="_top">Frequently Asked Questions and Answers: Assignment and Independent</a><br/>
	5015	<a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a><br/>
	5016	<a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
1337	5017	independent<b> </b>variable <a href="faq.xml#Independent Variables" target="_top">Frequently Asked Questions and Answers: Independent Variables</a><br/>
1338		index<br/>
	5018	index <a href="cppad_ipopt_nlp.xml#fg(x).Index Vector" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg(x).Index Vector</a><br/>
	5019	<a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a><br/>
	5020	<a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
	5021	<a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
	5022	<a href="atomic_matrix_mul.hpp.xml#Result Element Index" target="_top">Matrix Multiply as an Atomic Operation: Result Element Index</a><br/>
	5023	<a href="atomic_matrix_mul.hpp.xml#Right Operand Element Index" target="_top">Matrix Multiply as an Atomic Operation: Right Operand Element Index</a><br/>
	5024	<a href="atomic_matrix_mul.hpp.xml#Left Operand Element Index" target="_top">Matrix Multiply as an Atomic Operation: Left Operand Element Index</a><br/>
	5025	<a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
	5026	<a href="exp_eps_rev2.xml#Index 2: f_1" target="_top">exp_eps: Second Order Reverse Sweep: Index 2: f_1</a><br/>
	5027	<a href="exp_eps_rev2.xml#Index 3: f_2" target="_top">exp_eps: Second Order Reverse Sweep: Index 3: f_2</a><br/>
	5028	<a href="exp_eps_rev2.xml#Index 4: f_3" target="_top">exp_eps: Second Order Reverse Sweep: Index 4: f_3</a><br/>
	5029	<a href="exp_eps_rev2.xml#Index 5: f_4" target="_top">exp_eps: Second Order Reverse Sweep: Index 5: f_4</a><br/>
	5030	<a href="exp_eps_rev2.xml#Index 6: f_5" target="_top">exp_eps: Second Order Reverse Sweep: Index 6: f_5</a><br/>
	5031	<a href="exp_eps_rev2.xml#Index 7: f_6" target="_top">exp_eps: Second Order Reverse Sweep: Index 7: f_6</a><br/>
	5032	<a href="exp_eps_for2.xml#Operation Sequence.Index" target="_top">exp_eps: Second Order Forward Mode: Operation Sequence.Index</a><br/>
	5033	<a href="exp_eps_rev1.xml#Index 2: f_1" target="_top">exp_eps: First Order Reverse Sweep: Index 2: f_1</a><br/>
	5034	<a href="exp_eps_rev1.xml#Index 3: f_2" target="_top">exp_eps: First Order Reverse Sweep: Index 3: f_2</a><br/>
	5035	<a href="exp_eps_rev1.xml#Index 4: f_3" target="_top">exp_eps: First Order Reverse Sweep: Index 4: f_3</a><br/>
	5036	<a href="exp_eps_rev1.xml#Index 5: f_4" target="_top">exp_eps: First Order Reverse Sweep: Index 5: f_4</a><br/>
	5037	<a href="exp_eps_rev1.xml#Index 6: f_5" target="_top">exp_eps: First Order Reverse Sweep: Index 6: f_5</a><br/>
	5038	<a href="exp_eps_rev1.xml#Index 7: f_6" target="_top">exp_eps: First Order Reverse Sweep: Index 7: f_6</a><br/>
	5039	<a href="exp_eps_for1.xml#Operation Sequence.Index" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence.Index</a><br/>
	5040	<a href="exp_eps_for0.xml#Operation Sequence.Index" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence.Index</a><br/>
	5041	<a href="exp_2_rev2.xml#Index 2: f_1" target="_top">exp_2: Second Order Reverse Mode: Index 2: f_1</a><br/>
	5042	<a href="exp_2_rev2.xml#Index 3: f_2" target="_top">exp_2: Second Order Reverse Mode: Index 3: f_2</a><br/>
	5043	<a href="exp_2_rev2.xml#Index 4: f_3" target="_top">exp_2: Second Order Reverse Mode: Index 4: f_3</a><br/>
	5044	<a href="exp_2_rev2.xml#Index 5: f_4" target="_top">exp_2: Second Order Reverse Mode: Index 5: f_4</a><br/>
	5045	<a href="exp_2_for2.xml#Operation Sequence.Index" target="_top">exp_2: Second Order Forward Mode: Operation Sequence.Index</a><br/>
	5046	<a href="exp_2_rev1.xml#Index 2: f_1" target="_top">exp_2: First Order Reverse Mode: Index 2: f_1</a><br/>
	5047	<a href="exp_2_rev1.xml#Index 3: f_2" target="_top">exp_2: First Order Reverse Mode: Index 3: f_2</a><br/>
	5048	<a href="exp_2_rev1.xml#Index 4: f_3" target="_top">exp_2: First Order Reverse Mode: Index 4: f_3</a><br/>
	5049	<a href="exp_2_rev1.xml#Index 5: f_4" target="_top">exp_2: First Order Reverse Mode: Index 5: f_4</a><br/>
	5050	<a href="exp_2_for1.xml#Operation Sequence.Index" target="_top">exp_2: First Order Forward Mode: Operation Sequence.Index</a><br/>
	5051	<a href="exp_2_for0.xml#Operation Sequence.Index" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Operation Sequence.Index</a><br/>
1339	5052	AD<b> </b>record <a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
1340	5053	sort<b> </b>example <a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a><br/>
1341	5054	tape<b> </b>array<b> </b>operation <a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
1342	5055	index<b>_</b>sort <a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a><br/>
1343	5056	example <a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a><br/>
	5057	indexing <a href="old_mat_mul.hpp.xml#Matrix Indexing" target="_top">Define Matrix Multiply as a User Atomic Operation: Matrix Indexing</a><br/>
	5058	<a href="vecad.xml#AD Indexing" target="_top">AD Vectors that Record Index Operations: AD Indexing</a><br/>
	5059	<a href="vecad.xml#size_t Indexing" target="_top">AD Vectors that Record Index Operations: size_t Indexing</a><br/>
	5060	indices <a href="ipopt_nlp_ode_fast.xml#Trapezoidal Approximation.Domain Indices J(k,0)" target="_top">ODE Fitting Using Fast Representation: Trapezoidal Approximation.Domain Indices J(k,0)</a><br/>
	5061	<a href="ipopt_nlp_ode_fast.xml#Trapezoidal Approximation.Range Indices I(k,0)" target="_top">ODE Fitting Using Fast Representation: Trapezoidal Approximation.Range Indices I(k,0)</a><br/>
	5062	<a href="ipopt_nlp_ode_fast.xml#Initial Condition.Domain Indices J(k,0)" target="_top">ODE Fitting Using Fast Representation: Initial Condition.Domain Indices J(k,0)</a><br/>
	5063	<a href="ipopt_nlp_ode_fast.xml#Initial Condition.Range Indices I(k,0)" target="_top">ODE Fitting Using Fast Representation: Initial Condition.Range Indices I(k,0)</a><br/>
	5064	<a href="ipopt_nlp_ode_fast.xml#Objective Function.Domain Indices J(k,0)" target="_top">ODE Fitting Using Fast Representation: Objective Function.Domain Indices J(k,0)</a><br/>
	5065	<a href="ipopt_nlp_ode_fast.xml#Objective Function.Range Indices I(k,0)" target="_top">ODE Fitting Using Fast Representation: Objective Function.Range Indices I(k,0)</a><br/>
	5066	<a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a><br/>
	5067	info <a href="errorhandler.xml#info" target="_top">Replacing the CppAD Error Handler: info</a><br/>
	5068	information <a href="old_mat_mul.hpp.xml#Extra Call Information" target="_top">Define Matrix Multiply as a User Atomic Operation: Extra Call Information</a><br/>
	5069	initial <a href="ipopt_nlp_ode_fast.xml#Initial Condition" target="_top">ODE Fitting Using Fast Representation: Initial Condition</a><br/>
	5070	<a href="ipopt_nlp_ode_simple.xml#Initial Condition Constraint" target="_top">ODE Fitting Using Simple Representation: Initial Condition Constraint</a><br/>
	5071	initialization <a href="multi_thread.xml#Initialization" target="_top">Using CppAD in a Multi-Threading Environment: Initialization</a><br/>
1344	5072	initialize<br/>
1345	5073	multi<b>-</b>threading <a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	5074	injection <a href="cppad_ipopt_nlp.xml#fg(x).Injection" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg(x).Injection</a><br/>
	5075	inner <a href="mul_level.xml#General Procedure.Derivative of Inner Function" target="_top">Using Multiple Levels of AD: General Procedure.Derivative of Inner Function</a><br/>
	5076	<a href="mul_level.xml#General Procedure.Inner Function Calculations" target="_top">Using Multiple Levels of AD: General Procedure.Inner Function Calculations</a><br/>
1346	5077	input<br/>
1347	5078	AD <a href="ad_input.xml" target="_top">AD Output Stream Operator</a><br/>
1348	5079	AD<b> </b>example <a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
1349		install <a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
	5080	install <a href="installunix.xml#make install" target="_top">Deprecated Unix Test and Installation: make install</a><br/>
	5081	<a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
	5082	<a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
	5083	<a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
	5084	<a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
	5085	<a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
	5086	<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
	5087	<a href="download.xml#Subversion.Install Instructions" target="_top">Download The CppAD Source Code: Subversion.Install Instructions</a><br/>
	5088	<a href="download.xml#Compressed Tar File.Install Instructions" target="_top">Download The CppAD Source Code: Compressed Tar File.Install Instructions</a><br/>
	5089	<a href="install.xml#Instructions.Step 4: Install" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 4: Install</a><br/>
	5090	<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
	5091	<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
1350	5092	adolc <a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
1351	5093	colpack <a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
1352		cppad<b> </b>documentation <a href="cmake.xml#cppad_documentation" target="_top">Using CMake to Configure CppAD: cppad_documentation</a><br/>
	5094	data<b> </b>directory <a href="cmake.xml#cmake_install_docdir" target="_top">Using CMake to Configure CppAD: cmake_install_docdir</a><br/>
1353	5095	data<b> </b>directory <a href="cmake.xml#cmake_install_datadir" target="_top">Using CMake to Configure CppAD: cmake_install_datadir</a><br/>
1354		documentation <a href="installunix.xml#--with-Documentation" target="_top">Unix Test and Installation: --with-Documentation</a><br/>
	5096	documentation <a href="installunix.xml#--with-Documentation" target="_top">Deprecated Unix Test and Installation: --with-Documentation</a><br/>
1355	5097	eigen <a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
1356	5098	fadbad <a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
1357	5099	include<b> </b>directories <a href="cmake.xml#cmake_install_includedirs" target="_top">Using CMake to Configure CppAD: cmake_install_includedirs</a><br/>

1360	5102	postfix <a href="cmake.xml#cmake_install_postfix" target="_top">Using CMake to Configure CppAD: cmake_install_postfix</a><br/>
1361	5103	prefix <a href="cmake.xml#cmake_install_prefix" target="_top">Using CMake to Configure CppAD: cmake_install_prefix</a><br/>
1362	5104	sacado <a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
1363		unix<b> </b>CppAD <a href="installunix.xml" target="_top">Unix Test and Installation</a><br/>
	5105	unix<b> </b>CppAD <a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a><br/>
	5106	installation <a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a><br/>
	5107	instructions <a href="download.xml#Subversion.Install Instructions" target="_top">Download The CppAD Source Code: Subversion.Install Instructions</a><br/>
	5108	<a href="download.xml#Compressed Tar File.Install Instructions" target="_top">Download The CppAD Source Code: Compressed Tar File.Install Instructions</a><br/>
	5109	<a href="install.xml#Instructions" target="_top">CppAD Download, Test, and Install Instructions: Instructions</a><br/>
	5110	<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
1364	5111	int<br/>
1365	5112	numeric<b> </b>constructor <a href="numerictype.xml#Constructor From Integer" target="_top">Definition of a Numeric Type: Constructor From Integer</a><br/>
1366		integer<br/>
	5113	integer <a href="ipopt_solve.xml#options.Integer" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: options.Integer</a><br/>
	5114	<a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a><br/>
	5115	<a href="pow_int.xml" target="_top">The Integer Power Function</a><br/>
	5116	<a href="numerictype.xml#Constructor From Integer" target="_top">Definition of a Numeric Type: Constructor From Integer</a><br/>
	5117	<a href="base_complex.hpp.xml#Integer" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Integer</a><br/>
	5118	<a href="base_double.hpp.xml#Integer" target="_top">Enable use of AD<Base> where Base is double: Integer</a><br/>
	5119	<a href="base_float.hpp.xml#Integer" target="_top">Enable use of AD<Base> where Base is float: Integer</a><br/>
	5120	<a href="base_adolc.hpp.xml#Integer" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Integer</a><br/>
	5121	<a href="base_alloc.hpp.xml#Integer" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Integer</a><br/>
	5122	<a href="base_require.xml#Integer" target="_top">AD<Base> Requirements for Base Type: Integer</a><br/>
	5123	<a href="integer.xml" target="_top">Convert From AD to Integer</a><br/>
1367	5124	pow <a href="pow_int.xml" target="_top">The Integer Power Function</a><br/>
	5125	integer<b>:</b> <a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
1368	5126	integrate<br/>
1369	5127	multi<b>-</b>dimensional<b> </b>Romberg <a href="rombergmul.xml" target="_top">Multi-dimensional Romberg Integration</a><br/>
1370	5128	Romberg <a href="rombergone.xml" target="_top">One DimensionalRomberg Integration</a><br/>
1371		interface<br/>
	5129	integration <a href="rombergmul.xml" target="_top">Multi-dimensional Romberg Integration</a><br/>
	5130	<a href="rombergone.xml" target="_top">One DimensionalRomberg Integration</a><br/>
	5131	integration<b>:</b> <a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	5132	<a href="romberg_one.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	5133	interface <a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
	5134	<a href="wishlist.xml#Iterator Interface" target="_top">The CppAD Wish List: Iterator Interface</a><br/>
	5135	<a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
1372	5136	to<b> </b>C <a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
	5137	interfacing <a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
1373	5138	internal<br/>
1374		sparse<b> </b>vector<b> </b>sets <a href="installunix.xml#--with-sparse_option" target="_top">Unix Test and Installation: --with-sparse_option</a><br/>
	5139	sparse<b> </b>vector<b> </b>sets <a href="installunix.xml#--with-sparse_option" target="_top">Deprecated Unix Test and Installation: --with-sparse_option</a><br/>
1375	5140	interpolate<br/>
1376	5141	example <a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
1377	5142	example <a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
1378	5143	test <a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
1379	5144	test <a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
1380		interpreter<br/>
	5145	interpolation <a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
	5146	<a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
	5147	interpreter <a href="stack_machine.cpp.xml" target="_top">Example Differentiating a Stack Machine Interpreter</a><br/>
1381	5148	example <a href="stack_machine.cpp.xml" target="_top">Example Differentiating a Stack Machine Interpreter</a><br/>
1382		introduction <a href="cppad.xml#Introduction" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms: Introduction</a><br/>
	5149	introduction <a href="test_vector.xml#Introduction" target="_top">Choosing The Vector Testing Template Class: Introduction</a><br/>
	5150	<a href="whats_new_03.xml#Introduction" target="_top">Changes and Additions to CppAD During 2003: Introduction</a><br/>
	5151	<a href="whats_new_04.xml#Introduction" target="_top">Changes and Additions to CppAD During 2004: Introduction</a><br/>
	5152	<a href="whats_new_06.xml#Introduction" target="_top">Changes and Additions to CppAD During 2006: Introduction</a><br/>
	5153	<a href="whats_new_07.xml#Introduction" target="_top">Changes and Additions to CppAD During 2007: Introduction</a><br/>
	5154	<a href="whats_new_08.xml#Introduction" target="_top">Changes and Additions to CppAD During 2008: Introduction</a><br/>
	5155	<a href="whats_new_09.xml#Introduction" target="_top">Changes and Additions to CppAD During 2009: Introduction</a><br/>
	5156	<a href="whats_new_10.xml#Introduction" target="_top">Changes and Additions to CppAD During 2010: Introduction</a><br/>
	5157	<a href="whats_new_11.xml#Introduction" target="_top">Changes and Additions to CppAD During 2011: Introduction</a><br/>
	5158	<a href="whats_new_12.xml#Introduction" target="_top">CppAD Changes and Additions During 2012: Introduction</a><br/>
	5159	<a href="whats_new_13.xml#Introduction" target="_top">CppAD Changes and Additions During 2013: Introduction</a><br/>
	5160	<a href="whats_new_14.xml#Introduction" target="_top">CppAD Changes and Additions During 2014: Introduction</a><br/>
	5161	<a href="whats_new.xml#Introduction" target="_top">Changes and Additions to CppAD: Introduction</a><br/>
	5162	<a href="testvector.xml#Introduction" target="_top">Using The CppAD Test Vector Template Class: Introduction</a><br/>
	5163	<a href="example.xml#Introduction" target="_top">Examples: Introduction</a><br/>
	5164	<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
	5165	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
	5166	<a href="cppad.xml#Introduction" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Introduction</a><br/>
	5167	<a href="cppad.xml#Introduction" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Introduction</a><br/>
1383	5168	AD <a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
1384		inuse<br/>
	5169	inuse <a href="memory_leak.xml#inuse" target="_top">Memory Leak Detection: inuse</a><br/>
1385	5170	omp<b>_</b>alloc <a href="omp_inuse.xml#Deprecated" target="_top">Amount of Memory a Thread is Currently Using: Deprecated</a><br/>
1386	5171	thread<b>_</b>alloc <a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
1387		inverse<br/>
	5172	invalid <a href="base_complex.hpp.xml#Invalid Unary Math" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Invalid Unary Math</a><br/>
	5173	inverse <a href="ipopt_nlp_ode_problem.hpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	5174	<a href="ipopt_nlp_ode_problem.xml#Inverse Problem" target="_top">An ODE Inverse Problem Example: Inverse Problem</a><br/>
	5175	<a href="ipopt_nlp_ode_problem.xml" target="_top">An ODE Inverse Problem Example</a><br/>
	5176	<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
	5177	<a href="faq.xml#Matrix Inverse" target="_top">Frequently Asked Questions and Answers: Matrix Inverse</a><br/>
	5178	<a href="ipopt_solve_ode_inverse.cpp.xml#Inverse Problem" target="_top">ODE Inverse Problem Definitions: Source Code: Inverse Problem</a><br/>
	5179	<a href="ipopt_solve_ode_inverse.cpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	5180	<a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a><br/>
1388	5181	AD<b> </b>tan <a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a><br/>
1389	5182	matrix <a href="faq.xml#Matrix Inverse" target="_top">Frequently Asked Questions and Answers: Matrix Inverse</a><br/>
1390	5183	ode<b> </b>example <a href="ipopt_nlp_ode_problem.hpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
1391	5184	ode<b> </b>example <a href="ipopt_nlp_ode_problem.xml" target="_top">An ODE Inverse Problem Example</a><br/>
1392	5185	ode<b> </b>example <a href="ipopt_solve_ode_inverse.cpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
1393		ipopt<br/>
	5186	invert <a href="luinvert.xml" target="_top">Invert an LU Factored Equation</a><br/>
	5187	<a href="lusolve.xml#Factor and Invert" target="_top">Compute Determinant and Solve Linear Equations: Factor and Invert</a><br/>
	5188	ip <a href="luratio.xml#ip" target="_top">LU Factorization of A Square Matrix and Stability Calculation: ip</a><br/>
	5189	<a href="luinvert.xml#ip" target="_top">Invert an LU Factored Equation: ip</a><br/>
	5190	<a href="lufactor.xml#ip" target="_top">LU Factorization of A Square Matrix: ip</a><br/>
	5191	ipopt <a href="ipopt_nlp_ode_run.hpp.xml" target="_top">Driver for Running the Ipopt ODE Example</a><br/>
	5192	<a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
	5193	<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
	5194	<a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
1394	5195	AD<b> </b>example <a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
1395	5196	AD<b> </b>example <a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
1396	5197	cppad<b> </b>library <a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>

1398	5199	example <a href="ipopt_prefix.xml#Examples and Tests" target="_top">Including the cppad_ipopt Library and Tests: Examples and Tests</a><br/>
1399	5200	get <a href="ipopt_prefix.xml#get_ipopt" target="_top">Including the cppad_ipopt Library and Tests: get_ipopt</a><br/>
1400	5201	prefix <a href="ipopt_prefix.xml#ipopt_prefix" target="_top">Including the cppad_ipopt Library and Tests: ipopt_prefix</a><br/>
	5202	ipopt<b>:</b> <a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	5203	<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
1401	5204	ipopt<b>_</b>cppad<b>_</b>nlp <a href="whats_new_08.xml#08-29" target="_top">Changes and Additions to CppAD During 2008: 08-29</a><br/>
	5205	ipopt<b>_</b>dir <a href="installunix.xml#ipopt_dir" target="_top">Deprecated Unix Test and Installation: ipopt_dir</a><br/>
	5206	ipopt<b>_</b>library<b>_</b>paths <a href="cppad_ipopt_nlp.xml#ipopt_library_paths" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: ipopt_library_paths</a><br/>
	5207	ipopt<b>_</b>prefix <a href="ipopt_prefix.xml#ipopt_prefix" target="_top">Including the cppad_ipopt Library and Tests: ipopt_prefix</a><br/>
1402	5208	ipopt<b>_</b>solve<br/>
1403	5209	retape <a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a><br/>
1404		isnan <a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	5210	is <a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
	5211	<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	5212	<a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
	5213	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	5214	<a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
	5215	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	5216	<a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
	5217	<a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
	5218	<a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
	5219	<a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
	5220	<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
	5221	<a href="ad_input.xml#is" target="_top">AD Output Stream Operator: is</a><br/>
	5222	isnan <a href="nan.xml#isnan" target="_top">Obtain Nan or Determine if a Value is Nan: isnan</a><br/>
	5223	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	5224	<a href="base_complex.hpp.xml#isnan" target="_top">Enable use of AD<Base> where Base is std::complex<double>: isnan</a><br/>
	5225	<a href="base_std_math.xml#isnan" target="_top">Base Type Requirements for Standard Math Functions: isnan</a><br/>
1405	5226	base<b> </b>type <a href="base_std_math.xml#isnan" target="_top">Base Type Requirements for Standard Math Functions: isnan</a><br/>
1406	5227	macro <a href="nan.xml#Include.Macros" target="_top">Obtain Nan or Determine if a Value is Nan: Include.Macros</a><br/>
	5228	iteration <a href="ipopt_nlp_ode_problem.xml#Black Box Method.Two levels of Iteration" target="_top">An ODE Inverse Problem Example: Black Box Method.Two levels of Iteration</a><br/>
1407	5229	iterator <a href="wishlist.xml#Iterator Interface" target="_top">The CppAD Wish List: Iterator Interface</a><br/>
	5230	<a href="wishlist.xml#Iterator Interface" target="_top">The CppAD Wish List: Iterator Interface</a><br/>
	5231	its <a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
	5232	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
	5233	<a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
	5234	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	5235	<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
	5236	itself <a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
1408	5237
1409	5238	<b><big><a name="J">J</a></big></b>
1410	5239	<br/>

1413	5242	Bender <a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
1414	5243	driver <a href="jacobian.xml" target="_top">Jacobian: Driver Routine</a><br/>
1415	5244	sparse <a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a><br/>
1416		jacobian<br/>
	5245	j <a href="revtwo.xml#j" target="_top">Reverse Mode Second Partial Derivative Driver: j</a><br/>
	5246	<a href="fortwo.xml#j" target="_top">Forward Mode Second Partial Derivative Driver: j</a><br/>
	5247	<a href="forone.xml#j" target="_top">First Order Partial Derivative: Driver Routine: j</a><br/>
	5248	j<b>(</b>k<br/>
	5249	0<b>)</b> <a href="ipopt_nlp_ode_fast.xml#Trapezoidal Approximation.Domain Indices J(k,0)" target="_top">ODE Fitting Using Fast Representation: Trapezoidal Approximation.Domain Indices J(k,0)</a><br/>
	5250	0<b>)</b> <a href="ipopt_nlp_ode_fast.xml#Initial Condition.Domain Indices J(k,0)" target="_top">ODE Fitting Using Fast Representation: Initial Condition.Domain Indices J(k,0)</a><br/>
	5251	0<b>)</b> <a href="ipopt_nlp_ode_fast.xml#Objective Function.Domain Indices J(k,0)" target="_top">ODE Fitting Using Fast Representation: Objective Function.Domain Indices J(k,0)</a><br/>
	5252	jac <a href="opt_val_hes.xml#jac" target="_top">Jacobian and Hessian of Optimal Values: jac</a><br/>
	5253	<a href="sparse_jacobian.xml#jac" target="_top">Sparse Jacobian: Easy Driver: jac</a><br/>
	5254	<a href="jacobian.xml#jac" target="_top">Jacobian: Driver Routine: jac</a><br/>
	5255	jacobian <a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a><br/>
	5256	<a href="adolc_sparse_jacobian.cpp.xml" target="_top">adolc Speed: Sparse Jacobian</a><br/>
	5257	<a href="double_sparse_jacobian.cpp.xml" target="_top">Double Speed: Sparse Jacobian</a><br/>
	5258	<a href="sparse_jac_fun.xml#fp.Jacobian" target="_top">Evaluate a Function That Has a Sparse Jacobian: fp.Jacobian</a><br/>
	5259	<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
	5260	<a href="link_sparse_jacobian.xml#jacobian" target="_top">Speed Testing Sparse Jacobian: jacobian</a><br/>
	5261	<a href="link_sparse_jacobian.xml" target="_top">Speed Testing Sparse Jacobian</a><br/>
	5262	<a href="link_ode.xml#jacobian" target="_top">Speed Testing the Jacobian of Ode Solution: jacobian</a><br/>
	5263	<a href="link_ode.xml" target="_top">Speed Testing the Jacobian of Ode Solution</a><br/>
	5264	<a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
	5265	<a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
	5266	<a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
	5267	<a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
	5268	<a href="revsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Reverse Mode</a><br/>
	5269	<a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
	5270	<a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a><br/>
	5271	<a href="atomic_rev_sparse_jac.xml" target="_top">Atomic Reverse Jacobian Sparsity Patterns</a><br/>
	5272	<a href="atomic_for_sparse_jac.xml" target="_top">Atomic Forward Jacobian Sparsity Patterns</a><br/>
1417	5273	sparse <a href="sparse_jacobian.xml" target="_top">Sparse Jacobian: Easy Driver</a><br/>
1418	5274	speed<b> </b>adolc <a href="adolc_sparse_jacobian.cpp.xml" target="_top">adolc Speed: Sparse Jacobian</a><br/>
1419	5275	speed<b> </b>cppad <a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a><br/>
1420	5276	speed<b> </b>double <a href="double_sparse_jacobian.cpp.xml" target="_top">Double Speed: Sparse Jacobian</a><br/>
	5277	jacobian<b>:</b> <a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a><br/>
	5278	<a href="sparse_jacobian.xml" target="_top">Sparse Jacobian: Easy Driver</a><br/>
	5279	<a href="jacobian.cpp.xml" target="_top">Jacobian: Example and Test</a><br/>
	5280	<a href="jacobian.xml" target="_top">Jacobian: Driver Routine</a><br/>
	5281	jp <a href="luratio.xml#jp" target="_top">LU Factorization of A Square Matrix and Stability Calculation: jp</a><br/>
	5282	<a href="luinvert.xml#jp" target="_top">Invert an LU Factored Equation: jp</a><br/>
	5283	<a href="lufactor.xml#jp" target="_top">LU Factorization of A Square Matrix: jp</a><br/>
1421	5284
1422	5285	<b><big><a name="K">K</a></big></b>
1423	5286	<br/>
1424	5287	Kutta<br/>
1425	5288	ODE <a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
	5289	k <a href="old_atomic.xml#k" target="_top">User Defined Atomic AD Functions: k</a><br/>
	5290	<a href="poly.xml#k" target="_top">Evaluate a Polynomial or its Derivative: k</a><br/>
	5291	<a href="fortwo.xml#k" target="_top">Forward Mode Second Partial Derivative Driver: k</a><br/>
	5292	keys <a href="index_sort.xml#keys" target="_top">Returns Indices that Sort a Vector: keys</a><br/>
	5293	know <a href="bugs.xml" target="_top">Know Bugs and Problems Using CppAD</a><br/>
	5294	known <a href="cppad_assert.xml#Restriction.Known" target="_top">CppAD Assertions During Execution: Restriction.Known</a><br/>
	5295	<a href="errorhandler.xml#known" target="_top">Replacing the CppAD Error Handler: known</a><br/>
1426	5296
1427	5297	<b><big><a name="L">L</a></big></b>
1428	5298	<br/>

1438	5308	LuSolve <a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
1439	5309	source <a href="lu_solve.hpp.xml" target="_top">Source: LuSolve</a><br/>
1440	5310	LuVecAD <a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
1441		language<br/>
	5311	l <a href="luratio.xml#LU.L" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU.L</a><br/>
	5312	<a href="luinvert.xml#LU.L" target="_top">Invert an LU Factored Equation: LU.L</a><br/>
	5313	<a href="lufactor.xml#LU.L" target="_top">LU Factorization of A Square Matrix: LU.L</a><br/>
	5314	<a href="hessian.xml#l" target="_top">Hessian: Easy Driver: l</a><br/>
	5315	l<b>.</b>f<b>.</b> <a href="bib.xml#Shampine, L.F." target="_top">Bibliography: Shampine, L.F.</a><br/>
	5316	lagrangian <a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	5317	lambda <a href="cppad_ipopt_nlp.xml#solution.lambda" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: solution.lambda</a><br/>
	5318	<a href="ipopt_solve.xml#solution.lambda" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: solution.lambda</a><br/>
	5319	language <a href="bib.xml#The C++ Programming Language" target="_top">Bibliography: The C++ Programming Language</a><br/>
1442	5320	link<b> </b>CppAD <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
1443		leak<br/>
	5321	languages <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	5322	large <a href="atomic_tangent.cpp.xml#Use Atomic Function.Large x Values" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.Large x Values</a><br/>
	5323	last <a href="speedtest.xml#last" target="_top">Run One Speed Test and Print Results: last</a><br/>
	5324	leak <a href="memory_leak.xml" target="_top">Memory Leak Detection</a><br/>
1444	5325	memory <a href="memory_leak.xml" target="_top">Memory Leak Detection</a><br/>
	5326	least <a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	5327	<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	5328	left <a href="atomic_matrix_mul.hpp.xml#Left Operand Element Index" target="_top">Matrix Multiply as an Atomic Operation: Left Operand Element Index</a><br/>
	5329	<a href="condexp.xml#left" target="_top">AD Conditional Expressions: left</a><br/>
	5330	leqzero <a href="lusolve.xml#LeqZero" target="_top">Compute Determinant and Solve Linear Equations: LeqZero</a><br/>
1445	5331	level<br/>
1446	5332	AD <a href="glossary.xml#AD Levels Above Base" target="_top">Glossary: AD Levels Above Base</a><br/>
1447	5333	multiple<b> </b>AD <a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
1448	5334	multiple<b> </b>AD <a href="mul_level.cpp.xml" target="_top">Multiple Tapes: Example and Test</a><br/>
1449	5335	multiple<b> </b>AD <a href="mul_level.xml" target="_top">Using Multiple Levels of AD</a><br/>
1450	5336	multiple<b> </b>Adolc <a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
1451		levels <a href="glossary.xml#AD Levels Above Base" target="_top">Glossary: AD Levels Above Base</a><br/>
1452		library<br/>
	5337	levels <a href="ipopt_nlp_ode_problem.xml#Black Box Method.Two levels of Iteration" target="_top">An ODE Inverse Problem Example: Black Box Method.Two levels of Iteration</a><br/>
	5338	<a href="glossary.xml#AD Levels Above Base" target="_top">Glossary: AD Levels Above Base</a><br/>
	5339	<a href="mul_level.xml" target="_top">Using Multiple Levels of AD</a><br/>
	5340	<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
	5341	library <a href="wishlist.xml#Library" target="_top">The CppAD Wish List: Library</a><br/>
	5342	<a href="speed_utility.xml#Library Routines" target="_top">Speed Testing Utilities: Library Routines</a><br/>
	5343	<a href="library.xml#Numerical AD Library" target="_top">The CppAD General Purpose Library: Numerical AD Library</a><br/>
	5344	<a href="library.xml#CppAD Numerical Template Library" target="_top">The CppAD General Purpose Library: CppAD Numerical Template Library</a><br/>
	5345	<a href="library.xml" target="_top">The CppAD General Purpose Library</a><br/>
	5346	<a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>
1453	5347	cppad<b>_</b>ipopt <a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>
1454	5348	numerical<b> </b>C<b>++ </b>template <a href="library.xml" target="_top">The CppAD General Purpose Library</a><br/>
1455	5349	library<b> </b>directories<br/>
1456	5350	install <a href="cmake.xml#cmake_install_libdirs" target="_top">Using CMake to Configure CppAD: cmake_install_libdirs</a><br/>
	5351	license <a href="license.xml" target="_top">Your License for the CppAD Software</a><br/>
1457	5352	limit<br/>
1458	5353	epsilon <a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
1459	5354	max <a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
1460	5355	min <a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
1461		limits <a href="limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a><br/>
	5356	limitations <a href="download.xml#Subversion.Limitations" target="_top">Download The CppAD Source Code: Subversion.Limitations</a><br/>
	5357	limits <a href="wishlist.xml#Numeric Limits" target="_top">The CppAD Wish List: Numeric Limits</a><br/>
	5358	<a href="base_complex.hpp.xml#limits" target="_top">Enable use of AD<Base> where Base is std::complex<double>: limits</a><br/>
	5359	<a href="base_double.hpp.xml#limits" target="_top">Enable use of AD<Base> where Base is double: limits</a><br/>
	5360	<a href="base_float.hpp.xml#limits" target="_top">Enable use of AD<Base> where Base is float: limits</a><br/>
	5361	<a href="base_adolc.hpp.xml#limits" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: limits</a><br/>
	5362	<a href="base_alloc.hpp.xml#limits" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: limits</a><br/>
	5363	<a href="base_std_math.xml#limits" target="_top">Base Type Requirements for Standard Math Functions: limits</a><br/>
	5364	<a href="limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a><br/>
	5365	<a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
1462	5366	AD <a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
1463	5367	numeric<b> </b>Base <a href="base_std_math.xml#limits" target="_top">Base Type Requirements for Standard Math Functions: limits</a><br/>
1464		linear<br/>
	5368	limits<b>:</b> <a href="limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a><br/>
	5369	line <a href="tracknewdel.xml#line" target="_top">Routines That Track Use of New and Delete: line</a><br/>
	5370	<a href="errorhandler.xml#line" target="_top">Replacing the CppAD Error Handler: line</a><br/>
	5371	linear <a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
	5372	<a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
1465	5373	equation <a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
1466	5374	equation <a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
1467	5375	invert<b> </b>Lu<b> </b>equation <a href="luinvert.xml" target="_top">Invert an LU Factored Equation</a><br/>
1468	5376	Lu<b> </b>factor<b> </b>equation <a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
1469	5377	Lu<b> </b>factor<b> </b>equation <a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
1470	5378	solve<b> </b>equation <a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
1471		link<br/>
	5379	link <a href="speed_main.xml#Link Functions" target="_top">Running the Speed Test Program: Link Functions</a><br/>
1472	5380	CppAD<b> </b>to<b> </b>language <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
1473	5381	link<b>_</b>det<b>_</b>lu <a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
1474	5382	adolc <a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>

1508	5416	adolc <a href="adolc_sparse_jacobian.cpp.xml" target="_top">adolc Speed: Sparse Jacobian</a><br/>
1509	5417	cppad <a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a><br/>
1510	5418	double <a href="double_sparse_jacobian.cpp.xml" target="_top">Double Speed: Sparse Jacobian</a><br/>
1511		log<br/>
	5419	linking <a href="include_deprecated.xml#Linking New Files to Deprecated Commands" target="_top">Deprecated Include Files: Linking New Files to Deprecated Commands</a><br/>
	5420	<a href="microsoft_timer.xml#Linking" target="_top">Microsoft Version of Elapsed Number of Seconds: Linking</a><br/>
	5421	<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	5422	linux <a href="installunix.xml#adolc_dir.Linux" target="_top">Deprecated Unix Test and Installation: adolc_dir.Linux</a><br/>
	5423	list <a href="cppad_ipopt_nlp.xml#Wish List" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: Wish List</a><br/>
	5424	<a href="wishlist.xml" target="_top">The CppAD Wish List</a><br/>
	5425	<a href="listallexamples.xml" target="_top">List of All the CppAD Examples</a><br/>
	5426	log <a href="log.cpp.xml" target="_top">The AD log Function: Example and Test</a><br/>
	5427	<a href="std_math_ad.xml#Derivatives.log" target="_top">AD Standard Math Unary Functions: Derivatives.log</a><br/>
1512	5428	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
1513	5429	AD<b> </b>example <a href="log.cpp.xml" target="_top">The AD log Function: Example and Test</a><br/>
1514	5430	forward<b> </b>theory <a href="logforward.xml" target="_top">Logarithm Function Forward Taylor Polynomial Theory</a><br/>
1515	5431	reverse<b> </b>theory <a href="logreverse.xml" target="_top">Logarithm Function Reverse Mode Theory</a><br/>
1516		log10<br/>
	5432	log10 <a href="log10.cpp.xml" target="_top">The AD log10 Function: Example and Test</a><br/>
	5433	<a href="std_math_ad.xml#Derivatives.log10" target="_top">AD Standard Math Unary Functions: Derivatives.log10</a><br/>
1517	5434	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
1518	5435	AD<b> </b>example <a href="log10.cpp.xml" target="_top">The AD log10 Function: Example and Test</a><br/>
1519		lu<br/>
	5436	logarithm <a href="logreverse.xml" target="_top">Logarithm Function Reverse Mode Theory</a><br/>
	5437	<a href="logforward.xml" target="_top">Logarithm Function Forward Taylor Polynomial Theory</a><br/>
	5438	logdet <a href="lu_vec_ad.cpp.xml#logdet" target="_top">Lu Factor and Solve with Recorded Pivoting: logdet</a><br/>
	5439	<a href="lusolve.xml#logdet" target="_top">Compute Determinant and Solve Linear Equations: logdet</a><br/>
	5440	lower <a href="forward_dir.xml#Non-Zero Lower Orders" target="_top">Multiple Directions Forward Mode: Non-Zero Lower Orders</a><br/>
	5441	lu <a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	5442	<a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	5443	<a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	5444	<a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	5445	<a href="double_det_lu.cpp.xml" target="_top">Double Speed: Determinant Using Lu Factorization</a><br/>
	5446	<a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a><br/>
	5447	<a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
	5448	<a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
	5449	<a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	5450	<a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
	5451	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	5452	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
	5453	<a href="luratio.xml#LU" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU</a><br/>
	5454	<a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
	5455	<a href="luinvert.xml#LU" target="_top">Invert an LU Factored Equation: LU</a><br/>
	5456	<a href="luinvert.xml" target="_top">Invert an LU Factored Equation</a><br/>
	5457	<a href="lufactor.xml#LU" target="_top">LU Factorization of A Square Matrix: LU</a><br/>
	5458	<a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
	5459	<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
1520	5460	factor<b> </b>determinant <a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
1521	5461	speed<b> </b>adolc <a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
1522	5462	speed<b> </b>cppad <a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
1523	5463	speed<b> </b>double <a href="double_det_lu.cpp.xml" target="_top">Double Speed: Determinant Using Lu Factorization</a><br/>
1524	5464	speed<b> </b>fadbad <a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
1525	5465	speed<b> </b>sacado <a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	5466	lufactor <a href="lu_factor.hpp.xml" target="_top">Source: LuFactor</a><br/>
	5467	lufactor<b>:</b> <a href="lu_factor.cpp.xml" target="_top">LuFactor: Example and Test</a><br/>
	5468	luinvert <a href="lu_invert.hpp.xml" target="_top">Source: LuInvert</a><br/>
	5469	luinvert<b>:</b> <a href="lu_invert.cpp.xml" target="_top">LuInvert: Example and Test</a><br/>
	5470	luratio<b>:</b> <a href="lu_ratio.cpp.xml" target="_top">LuRatio: Example and Test</a><br/>
	5471	lusolve <a href="lu_solve.hpp.xml" target="_top">Source: LuSolve</a><br/>
	5472	<a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
1526	5473
1527	5474	<b><big><a name="M">M</a></big></b>
1528	5475	<br/>
1529	5476	Memory<br/>
1530	5477	ADFun <a href="fundeprecated.xml#Memory" target="_top">ADFun Object Deprecated Member Functions: Memory</a><br/>
	5478	m <a href="det_by_minor_c.xml#m" target="_top">Compute Determinant using Expansion by Minors: m</a><br/>
	5479	<a href="det_of_minor_c.xml#m" target="_top">Determinant of a Minor: m</a><br/>
	5480	<a href="old_atomic.xml#m" target="_top">User Defined Atomic AD Functions: m</a><br/>
	5481	<a href="cppad_ipopt_nlp.xml#m" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: m</a><br/>
	5482	<a href="adolc_alloc_mat.xml#m" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix: m</a><br/>
	5483	<a href="sparse_jac_fun.xml#m" target="_top">Evaluate a Function That Has a Sparse Jacobian: m</a><br/>
	5484	<a href="det_of_minor.xml#m" target="_top">Determinant of a Minor: m</a><br/>
	5485	<a href="link_sparse_jacobian.xml#m" target="_top">Speed Testing Sparse Jacobian: m</a><br/>
	5486	<a href="lu_vec_ad.cpp.xml#m" target="_top">Lu Factor and Solve with Recorded Pivoting: m</a><br/>
	5487	<a href="odegearcontrol.xml#M" target="_top">An Error Controller for Gear's Ode Solvers: M</a><br/>
	5488	<a href="odegear.xml#m" target="_top">An Arbitrary Order Gear Method: m</a><br/>
	5489	<a href="rosen34.xml#M" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: M</a><br/>
	5490	<a href="runge45.xml#M" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: M</a><br/>
	5491	<a href="rombergmul.xml#m" target="_top">Multi-dimensional Romberg Integration: m</a><br/>
	5492	<a href="lusolve.xml#m" target="_top">Compute Determinant and Solve Linear Equations: m</a><br/>
	5493	<a href="forward_dir.xml#Notation.m" target="_top">Multiple Directions Forward Mode: Notation.m</a><br/>
	5494	<a href="forward_order.xml#Notation.m" target="_top">Multiple Order Forward Mode: Notation.m</a><br/>
	5495	machine <a href="epsilon.xml" target="_top">Machine Epsilon For AD Types</a><br/>
	5496	<a href="stack_machine.cpp.xml" target="_top">Example Differentiating a Stack Machine Interpreter</a><br/>
1531	5497	machine<b> </b>epsilon<br/>
1532	5498	testing <a href="wishlist.xml#Numeric Limits" target="_top">The CppAD Wish List: Numeric Limits</a><br/>
1533		macro<br/>
	5499	macro <a href="tracknewdel.xml#TrackCount.Macro" target="_top">Routines That Track Use of New and Delete: TrackCount.Macro</a><br/>
	5500	<a href="tracknewdel.xml#TrackExtend.Macro" target="_top">Routines That Track Use of New and Delete: TrackExtend.Macro</a><br/>
	5501	<a href="tracknewdel.xml#TrackDelVec.Macro" target="_top">Routines That Track Use of New and Delete: TrackDelVec.Macro</a><br/>
	5502	<a href="tracknewdel.xml#TrackNewVec.Macro" target="_top">Routines That Track Use of New and Delete: TrackNewVec.Macro</a><br/>
	5503	<a href="base_alloc.hpp.xml#Boolean Operator Macro" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Boolean Operator Macro</a><br/>
	5504	<a href="base_alloc.hpp.xml#Binary Operator Macro" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Binary Operator Macro</a><br/>
	5505	<a href="base_alloc.hpp.xml#Computed Assignment Macro" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Computed Assignment Macro</a><br/>
1534	5506	error<b> </b>assert <a href="cppad_assert.xml" target="_top">CppAD Assertions During Execution</a><br/>
1535	5507	isnan <a href="nan.xml#Include.Macros" target="_top">Obtain Nan or Determine if a Value is Nan: Include.Macros</a><br/>
1536	5508	nan <a href="nan.xml#Include.Macros" target="_top">Obtain Nan or Determine if a Value is Nan: Include.Macros</a><br/>
	5509	macros <a href="nan.xml#Include.Macros" target="_top">Obtain Nan or Determine if a Value is Nan: Include.Macros</a><br/>
	5510	main <a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
	5511	<a href="speed_utility.xml#Speed Main Program" target="_top">Speed Testing Utilities: Speed Main Program</a><br/>
	5512	main<b>.</b>cpp <a href="exp_apx_main.cpp.xml#main.cpp" target="_top">Correctness Tests For Exponential Approximation in Introduction: main.cpp</a><br/>
	5513	make <a href="installunix.xml#make install" target="_top">Deprecated Unix Test and Installation: make install</a><br/>
	5514	<a href="installunix.xml#make" target="_top">Deprecated Unix Test and Installation: make</a><br/>
1537	5515	makefile<br/>
1538	5516	generator <a href="cmake.xml#generator" target="_top">Using CMake to Configure CppAD: generator</a><br/>
1539		mat<b>_</b>sum<b>_</b>sq <a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
	5517	management <a href="mul_level_adolc_ode.cpp.xml#Memory Management" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Memory Management</a><br/>
	5518	<a href="mul_level_adolc.cpp.xml#Memory Management" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test: Memory Management</a><br/>
	5519	mat <a href="adolc_alloc_mat.xml#mat" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix: mat</a><br/>
	5520	mat<b>_</b>mul <a href="old_mat_mul.hpp.xml#Declare mat_mul Function" target="_top">Define Matrix Multiply as a User Atomic Operation: Declare mat_mul Function</a><br/>
	5521	mat<b>_</b>sum<b>_</b>sq <a href="mat_sum_sq.hpp.xml" target="_top">Source: mat_sum_sq</a><br/>
	5522	<a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
1540	5523	example <a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
1541	5524	source <a href="mat_sum_sq.hpp.xml" target="_top">Source: mat_sum_sq</a><br/>
1542		math<br/>
	5525	math <a href="reversetheory.xml#Standard Math Functions" target="_top">The Theory of Reverse Mode: Standard Math Functions</a><br/>
	5526	<a href="forwardtheory.xml#Standard Math Functions" target="_top">The Theory of Forward Mode: Standard Math Functions</a><br/>
	5527	<a href="faq.xml#Math Functions" target="_top">Frequently Asked Questions and Answers: Math Functions</a><br/>
	5528	<a href="base_complex.hpp.xml#Invalid Unary Math" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Invalid Unary Math</a><br/>
	5529	<a href="base_complex.hpp.xml#Valid Unary Math" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Valid Unary Math</a><br/>
	5530	<a href="base_double.hpp.xml#Unary Standard Math" target="_top">Enable use of AD<Base> where Base is double: Unary Standard Math</a><br/>
	5531	<a href="base_float.hpp.xml#Unary Standard Math" target="_top">Enable use of AD<Base> where Base is float: Unary Standard Math</a><br/>
	5532	<a href="base_adolc.hpp.xml#Unary Standard Math" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Unary Standard Math</a><br/>
	5533	<a href="base_alloc.hpp.xml#Unary Standard Math" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Unary Standard Math</a><br/>
	5534	<a href="base_std_math.xml#Unary Standard Math" target="_top">Base Type Requirements for Standard Math Functions: Unary Standard Math</a><br/>
	5535	<a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
	5536	<a href="mathother.xml" target="_top">Other AD Math Functions</a><br/>
	5537	<a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
1543	5538	AD<b> </b>other <a href="mathother.xml" target="_top">Other AD Math Functions</a><br/>
1544	5539	AD<b> </b>unary <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
1545	5540	base<b> </b>require <a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
1546	5541	base<b> </b>unary <a href="base_std_math.xml#Unary Standard Math" target="_top">Base Type Requirements for Standard Math Functions: Unary Standard Math</a><br/>
1547	5542	functions <a href="faq.xml#Math Functions" target="_top">Frequently Asked Questions and Answers: Math Functions</a><br/>
1548	5543	standard<b> </b>function <a href="faq.xml#Namespace.Using" target="_top">Frequently Asked Questions and Answers: Namespace.Using</a><br/>
1549		matrix<br/>
	5544	mathematical <a href="exp_eps_rev2.xml#Mathematical Form" target="_top">exp_eps: Second Order Reverse Sweep: Mathematical Form</a><br/>
	5545	<a href="exp_eps_for2.xml#Mathematical Form" target="_top">exp_eps: Second Order Forward Mode: Mathematical Form</a><br/>
	5546	<a href="exp_eps_rev1.xml#Mathematical Form" target="_top">exp_eps: First Order Reverse Sweep: Mathematical Form</a><br/>
	5547	<a href="exp_eps_for1.xml#Mathematical Form" target="_top">exp_eps: First Order Forward Sweep: Mathematical Form</a><br/>
	5548	<a href="exp_eps_for0.xml#Mathematical Form" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Mathematical Form</a><br/>
	5549	<a href="exp_eps.xml#Mathematical Function" target="_top">An Epsilon Accurate Exponential Approximation: Mathematical Function</a><br/>
	5550	<a href="exp_2_rev2.xml#Mathematical Form" target="_top">exp_2: Second Order Reverse Mode: Mathematical Form</a><br/>
	5551	<a href="exp_2_for2.xml#Mathematical Form" target="_top">exp_2: Second Order Forward Mode: Mathematical Form</a><br/>
	5552	<a href="exp_2_rev1.xml#Mathematical Form" target="_top">exp_2: First Order Reverse Mode: Mathematical Form</a><br/>
	5553	<a href="exp_2_for1.xml#Mathematical Form" target="_top">exp_2: First Order Forward Mode: Mathematical Form</a><br/>
	5554	<a href="exp_2_for0.xml#Mathematical Form" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Mathematical Form</a><br/>
	5555	<a href="exp_2.xml#Mathematical Form" target="_top">Second Order Exponential Approximation: Mathematical Form</a><br/>
	5556	matrix <a href="old_mat_mul.hpp.xml#One Matrix Multiply" target="_top">Define Matrix Multiply as a User Atomic Operation: One Matrix Multiply</a><br/>
	5557	<a href="old_mat_mul.hpp.xml#Matrix Indexing" target="_top">Define Matrix Multiply as a User Atomic Operation: Matrix Indexing</a><br/>
	5558	<a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
	5559	<a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	5560	<a href="old_atomic.xml#Example.Matrix Multiplication" target="_top">User Defined Atomic AD Functions: Example.Matrix Multiplication</a><br/>
	5561	<a href="faq.xml#Matrix Inverse" target="_top">Frequently Asked Questions and Answers: Matrix Inverse</a><br/>
	5562	<a href="sacado_mat_mul.cpp.xml" target="_top">Sacado Speed: Matrix Multiplication</a><br/>
	5563	<a href="fadbad_mat_mul.cpp.xml" target="_top">Fadbad Speed: Matrix Multiplication</a><br/>
	5564	<a href="cppad_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication</a><br/>
	5565	<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
	5566	<a href="adolc_mat_mul.cpp.xml" target="_top">Adolc Speed: Matrix Multiplication</a><br/>
	5567	<a href="double_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication (Double Version)</a><br/>
	5568	<a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
	5569	<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	5570	<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
	5571	<a href="link_mat_mul.xml" target="_top">Speed Testing Derivative of Matrix Multiply</a><br/>
	5572	<a href="link_det_minor.xml#matrix" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: matrix</a><br/>
	5573	<a href="link_det_lu.xml#matrix" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: matrix</a><br/>
	5574	<a href="lu_vec_ad.cpp.xml#Matrix" target="_top">Lu Factor and Solve with Recorded Pivoting: Matrix</a><br/>
	5575	<a href="luratio.xml#Matrix Storage" target="_top">LU Factorization of A Square Matrix and Stability Calculation: Matrix Storage</a><br/>
	5576	<a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
	5577	<a href="luinvert.xml#Matrix Storage" target="_top">Invert an LU Factored Equation: Matrix Storage</a><br/>
	5578	<a href="lufactor.xml#Matrix Storage" target="_top">LU Factorization of A Square Matrix: Matrix Storage</a><br/>
	5579	<a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
	5580	<a href="lusolve.xml#Matrix Storage" target="_top">Compute Determinant and Solve Linear Equations: Matrix Storage</a><br/>
	5581	<a href="atomic_matrix_mul.hpp.xml#Reverse Matrix Multipliy" target="_top">Matrix Multiply as an Atomic Operation: Reverse Matrix Multipliy</a><br/>
	5582	<a href="atomic_matrix_mul.hpp.xml#Forward Matrix Multipliy" target="_top">Matrix Multiply as an Atomic Operation: Forward Matrix Multipliy</a><br/>
	5583	<a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a><br/>
	5584	<a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>
1550	5585	adolc <a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
1551	5586	atomic<b> </b>example <a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
1552	5587	atomic<b> </b>multiply<b> </b>example <a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>

1569	5604	speed<b> </b>cppad <a href="cppad_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication</a><br/>
1570	5605	speed<b> </b>fadbad <a href="fadbad_mat_mul.cpp.xml" target="_top">Fadbad Speed: Matrix Multiplication</a><br/>
1571	5606	speed<b> </b>sacado <a href="sacado_mat_mul.cpp.xml" target="_top">Sacado Speed: Matrix Multiplication</a><br/>
1572		max<b>_</b>num<b>_</b>threads<br/>
	5607	matrix<b>:</b> <a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	5608	max <a href="limits.xml#max" target="_top">Numeric Limits For an AD and Base Types: max</a><br/>
	5609	max<b>_</b>itr <a href="multi_newton_work.cpp.xml#max_itr" target="_top">Multi-threading Newton Method Utility Routines: max_itr</a><br/>
	5610	<a href="multi_newton.cpp.xml#max_itr" target="_top">A Multi-Threaded Newton's Method: max_itr</a><br/>
	5611	max<b>_</b>num<b>_</b>threads <a href="installunix.xml#max_num_threads" target="_top">Deprecated Unix Test and Installation: max_num_threads</a><br/>
1573	5612	omp<b>_</b>alloc <a href="old_max_num_threads.xml#Removed" target="_top">Set Maximum Number of Threads for omp_alloc Allocator: Removed</a><br/>
1574		maxabs<br/>
	5613	max<b>_</b>threads <a href="thread_test.cpp.xml#multi_newton.max_threads" target="_top">Run Multi-Threading Examples and Speed Tests: multi_newton.max_threads</a><br/>
	5614	<a href="thread_test.cpp.xml#harmonic.max_threads" target="_top">Run Multi-Threading Examples and Speed Tests: harmonic.max_threads</a><br/>
	5615	maxabs <a href="odegearcontrol.xml#maxabs" target="_top">An Error Controller for Gear's Ode Solvers: maxabs</a><br/>
	5616	<a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a><br/>
	5617	<a href="odeerrcontrol.xml#maxabs" target="_top">An Error Controller for ODE Solvers: maxabs</a><br/>
1575	5618	OdeErrControl <a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a><br/>
1576		maximum<br/>
	5619	maximum <a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
	5620	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
1577	5621	number<b> </b>of<b> </b>threads <a href="multi_thread.xml#CPPAD_MAX_NUM_THREADS" target="_top">Using CppAD in a Multi-Threading Environment: CPPAD_MAX_NUM_THREADS</a><br/>
1578	5622	number<b> </b>threads <a href="cmake.xml#cppad_max_num_threads" target="_top">Using CMake to Configure CppAD: cppad_max_num_threads</a><br/>
1579		memory<br/>
	5623	measurement <a href="ipopt_nlp_ode_problem.xml#Measurements.Simulated Measurement Values" target="_top">An ODE Inverse Problem Example: Measurements.Simulated Measurement Values</a><br/>
	5624	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements.Simulated Measurement Values" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements.Simulated Measurement Values</a><br/>
	5625	measurements <a href="ipopt_nlp_ode_problem.xml#Measurements" target="_top">An ODE Inverse Problem Example: Measurements</a><br/>
	5626	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements</a><br/>
	5627	mega<b>_</b>sum <a href="harmonic_time.cpp.xml#mega_sum" target="_top">Timing Test of Multi-Threaded Summation of 1/i: mega_sum</a><br/>
	5628	<a href="thread_test.cpp.xml#harmonic.mega_sum" target="_top">Run Multi-Threading Examples and Speed Tests: harmonic.mega_sum</a><br/>
	5629	member <a href="fundeprecated.xml" target="_top">ADFun Object Deprecated Member Functions</a><br/>
	5630	<a href="base_member.xml" target="_top">Required Base Class Member Functions</a><br/>
	5631	memory <a href="old_atomic.xml#Syntax.Free Static Memory" target="_top">User Defined Atomic AD Functions: Syntax.Free Static Memory</a><br/>
	5632	<a href="memory_leak.xml" target="_top">Memory Leak Detection</a><br/>
	5633	<a href="omp_alloc.cpp.xml" target="_top">OpenMP Memory Allocator: Example and Test</a><br/>
	5634	<a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
	5635	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	5636	<a href="omp_create_array.xml" target="_top">Allocate Memory and Create A Raw Array</a><br/>
	5637	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	5638	<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	5639	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	5640	<a href="omp_return_memory.xml" target="_top">Return Memory to omp_alloc</a><br/>
	5641	<a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	5642	<a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
	5643	<a href="fundeprecated.xml#Memory" target="_top">ADFun Object Deprecated Member Functions: Memory</a><br/>
	5644	<a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
	5645	<a href="faq.xml#Speed.Memory Allocation" target="_top">Frequently Asked Questions and Answers: Speed.Memory Allocation</a><br/>
	5646	<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
	5647	<a href="speed_main.xml#option_list.memory" target="_top">Running the Speed Test Program: option_list.memory</a><br/>
	5648	<a href="mul_level_adolc_ode.cpp.xml#Memory Management" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Memory Management</a><br/>
	5649	<a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	5650	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	5651	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	5652	<a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
	5653	<a href="ta_free_available.xml#Purpose.Extra Memory" target="_top">Free Memory Currently Available for Quick Use by a Thread: Purpose.Extra Memory</a><br/>
	5654	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	5655	<a href="ta_return_memory.xml" target="_top">Return Memory to thread_alloc</a><br/>
	5656	<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	5657	<a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
	5658	<a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a><br/>
	5659	<a href="cppad_vector.xml#Memory and Parallel Mode" target="_top">The CppAD::vector Template Class: Memory and Parallel Mode</a><br/>
	5660	<a href="cppad_vector.xml#vectorBool.Memory" target="_top">The CppAD::vector Template Class: vectorBool.Memory</a><br/>
	5661	<a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	5662	<a href="capacity_order.xml#c.Freeing Memory" target="_top">Controlling Taylor Coefficients Memory Allocation: c.Freeing Memory</a><br/>
	5663	<a href="capacity_order.xml#c.Pre-Allocating Memory" target="_top">Controlling Taylor Coefficients Memory Allocation: c.Pre-Allocating Memory</a><br/>
	5664	<a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
	5665	<a href="mul_level_adolc.cpp.xml#Memory Management" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test: Memory Management</a><br/>
	5666	<a href="base_alloc.hpp.xml" target="_top">Example AD<Base> Where Base Constructor Allocates Memory</a><br/>
	5667	<a href="vecad.xml#Speed and Memory" target="_top">AD Vectors that Record Index Operations: Speed and Memory</a><br/>
1580	5668	allocate <a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
1581	5669	available <a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
1582	5670	available <a href="ta_return_memory.xml" target="_top">Return Memory to thread_alloc</a><br/>
1583		control <a href="capacity_taylor.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
	5671	control <a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
1584	5672	multi<b>-</b>threading<b> </b>allocation <a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
1585	5673	multi<b>-</b>threading<b> </b>allocation <a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a><br/>
1586	5674	optimize <a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
1587	5675	tape <a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
1588		tape <a href="installunix.xml#tape_id_type" target="_top">Unix Test and Installation: tape_id_type</a><br/>
1589		tape <a href="installunix.xml#tape_addr_type" target="_top">Unix Test and Installation: tape_addr_type</a><br/>
	5676	tape <a href="installunix.xml#tape_id_type" target="_top">Deprecated Unix Test and Installation: tape_id_type</a><br/>
	5677	tape <a href="installunix.xml#tape_addr_type" target="_top">Deprecated Unix Test and Installation: tape_addr_type</a><br/>
1590	5678	tape <a href="cmake.xml#cppad_tape_addr_type" target="_top">Using CMake to Configure CppAD: cppad_tape_addr_type</a><br/>
1591	5679	tape <a href="cmake.xml#cppad_tape_id_type" target="_top">Using CMake to Configure CppAD: cppad_tape_id_type</a><br/>
1592	5680	thread<b>_</b>alloc<b> </b>hold <a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
1593	5681	track <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
1594		usage <a href="installunix.xml#tape_id_type" target="_top">Unix Test and Installation: tape_id_type</a><br/>
1595		usage <a href="installunix.xml#tape_addr_type" target="_top">Unix Test and Installation: tape_addr_type</a><br/>
	5682	usage <a href="installunix.xml#tape_id_type" target="_top">Deprecated Unix Test and Installation: tape_id_type</a><br/>
	5683	usage <a href="installunix.xml#tape_addr_type" target="_top">Deprecated Unix Test and Installation: tape_addr_type</a><br/>
1596	5684	usage <a href="cmake.xml#cppad_tape_addr_type" target="_top">Using CMake to Configure CppAD: cppad_tape_addr_type</a><br/>
1597	5685	usage <a href="cmake.xml#cppad_tape_id_type" target="_top">Using CMake to Configure CppAD: cppad_tape_id_type</a><br/>
1598	5686	memory<b>_</b>leak <a href="memory_leak.xml" target="_top">Memory Leak Detection</a><br/>
1599		minor<br/>
	5687	message <a href="memory_leak.xml#Error Message" target="_top">Memory Leak Detection: Error Message</a><br/>
	5688	method <a href="ipopt_nlp_ode_problem.xml#Simultaneous Method" target="_top">An ODE Inverse Problem Example: Simultaneous Method</a><br/>
	5689	<a href="ipopt_nlp_ode_problem.xml#Black Box Method" target="_top">An ODE Inverse Problem Example: Black Box Method</a><br/>
	5690	<a href="link_sparse_jacobian.xml#Method" target="_top">Speed Testing Sparse Jacobian: Method</a><br/>
	5691	<a href="link_sparse_hessian.xml#Method" target="_top">Speed Testing Sparse Hessian: Method</a><br/>
	5692	<a href="link_poly.xml#Method" target="_top">Speed Testing Second Derivative of a Polynomial: Method</a><br/>
	5693	<a href="link_ode.xml#Method" target="_top">Speed Testing the Jacobian of Ode Solution: Method</a><br/>
	5694	<a href="link_det_minor.xml#Method" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: Method</a><br/>
	5695	<a href="link_det_lu.xml#Method" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: Method</a><br/>
	5696	<a href="mul_level_adolc_ode.cpp.xml#Taylor's Method Using AD" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Taylor's Method Using AD</a><br/>
	5697	<a href="mul_level_ode.cpp.xml#Taylor's Method Using AD" target="_top">Taylor's Ode Solver: An Example and Test: Taylor's Method Using AD</a><br/>
	5698	<a href="ipopt_solve_ode_inverse.cpp.xml#Solution Method" target="_top">ODE Inverse Problem Definitions: Source Code: Solution Method</a><br/>
	5699	<a href="odegear.xml#Gear's Method" target="_top">An Arbitrary Order Gear Method: Gear's Method</a><br/>
	5700	<a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
	5701	<a href="odeerrcontrol.xml#Method" target="_top">An Error Controller for ODE Solvers: Method</a><br/>
	5702	<a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
	5703	<a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
	5704	<a href="multi_newton.cpp.xml#Method" target="_top">A Multi-Threaded Newton's Method: Method</a><br/>
	5705	<a href="multi_newton.cpp.xml" target="_top">A Multi-Threaded Newton's Method</a><br/>
	5706	<a href="checkpoint.xml#Method" target="_top">Checkpointing Functions: Method</a><br/>
	5707	<a href="erf.xml#Method" target="_top">The AD Error Function: Method</a><br/>
	5708	microsoft <a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a><br/>
	5709	<a href="elapsed_seconds.xml#Microsoft Systems" target="_top">Returns Elapsed Number of Seconds: Microsoft Systems</a><br/>
	5710	min <a href="limits.xml#min" target="_top">Numeric Limits For an AD and Base Types: min</a><br/>
	5711	min<b>_</b>bytes <a href="omp_get_memory.xml#min_bytes" target="_top">Get At Least A Specified Amount of Memory: min_bytes</a><br/>
	5712	<a href="ta_get_memory.xml#min_bytes" target="_top">Get At Least A Specified Amount of Memory: min_bytes</a><br/>
	5713	minor <a href="det_of_minor_c.xml" target="_top">Determinant of a Minor</a><br/>
	5714	<a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
	5715	<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
	5716	<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
	5717	<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
	5718	<a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
	5719	<a href="det_of_minor.xml" target="_top">Determinant of a Minor</a><br/>
	5720	<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
1600	5721	expansion<b> </b>determinant <a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a><br/>
1601	5722	matrix<b> </b>determinant <a href="det_of_minor.xml" target="_top">Determinant of a Minor</a><br/>
1602	5723	speed<b> </b>adolc <a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>

1604	5725	speed<b> </b>double <a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
1605	5726	speed<b> </b>fadbad <a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
1606	5727	speed<b> </b>sacado <a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
1607		minors <a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	5728	minor<b>:</b> <a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
	5729	minors <a href="det_by_minor_c.xml" target="_top">Compute Determinant using Expansion by Minors</a><br/>
	5730	<a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a><br/>
	5731	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
1608	5732	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
1609		minus<br/>
	5733	minors<b>:</b> <a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
	5734	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	5735	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	5736	minus <a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a><br/>
	5737	<a href="unaryminus.xml" target="_top">AD Unary Minus Operator</a><br/>
1610	5738	AD<b> </b>example <a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
1611	5739	AD<b> </b>unary<b> </b>operator <a href="unaryminus.xml" target="_top">AD Unary Minus Operator</a><br/>
1612	5740	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
1613	5741	computed<b> </b>assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
1614		mode <a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
	5742	mode <a href="old_atomic.xml#afun.Parallel Mode" target="_top">User Defined Atomic AD Functions: afun.Parallel Mode</a><br/>
	5743	<a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
	5744	<a href="wishlist.xml#Forward Mode Recomputation" target="_top">The CppAD Wish List: Forward Mode Recomputation</a><br/>
	5745	<a href="reverse_identity.xml" target="_top">An Important Reverse Mode Identity</a><br/>
	5746	<a href="erf_reverse.xml" target="_top">Error Function Reverse Mode Theory</a><br/>
	5747	<a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
	5748	<a href="acosreverse.xml" target="_top">Arccosine Function Reverse Mode Theory</a><br/>
	5749	<a href="asinreverse.xml" target="_top">Arcsine Function Reverse Mode Theory</a><br/>
	5750	<a href="atanreverse.xml" target="_top">Arctangent Function Reverse Mode Theory</a><br/>
	5751	<a href="sqrtreverse.xml" target="_top">Square Root Function Reverse Mode Theory</a><br/>
	5752	<a href="logreverse.xml" target="_top">Logarithm Function Reverse Mode Theory</a><br/>
	5753	<a href="expreverse.xml" target="_top">Exponential Function Reverse Mode Theory</a><br/>
	5754	<a href="reversetheory.xml" target="_top">The Theory of Reverse Mode</a><br/>
	5755	<a href="forwardtheory.xml" target="_top">The Theory of Forward Mode</a><br/>
	5756	<a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
	5757	<a href="ode_taylor.cpp.xml#Forward Mode" target="_top">Taylor's Ode Solver: An Example and Test: Forward Mode</a><br/>
	5758	<a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
	5759	<a href="cppad_vector.xml#Memory and Parallel Mode" target="_top">The CppAD::vector Template Class: Memory and Parallel Mode</a><br/>
	5760	<a href="rosen34.xml#Parallel Mode" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Parallel Mode</a><br/>
	5761	<a href="runge45.xml#Parallel Mode" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Parallel Mode</a><br/>
	5762	<a href="checksimplevector.xml#Parallel Mode" target="_top">Check Simple Vector Concept: Parallel Mode</a><br/>
	5763	<a href="checknumerictype.xml#Parallel Mode" target="_top">Check NumericType Class Concept: Parallel Mode</a><br/>
	5764	<a href="errorhandler.xml#Constructor.Parallel Mode" target="_top">Replacing the CppAD Error Handler: Constructor.Parallel Mode</a><br/>
	5765	<a href="parallel_ad.xml" target="_top">Enable AD Calculations During Parallel Mode</a><br/>
	5766	<a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
	5767	<a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
	5768	<a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>
	5769	<a href="revsparsehes.xml" target="_top">Hessian Sparsity Pattern: Reverse Mode</a><br/>
	5770	<a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
	5771	<a href="revsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Reverse Mode</a><br/>
	5772	<a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
	5773	<a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a><br/>
	5774	<a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a><br/>
	5775	<a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a><br/>
	5776	<a href="reverse_two.xml" target="_top">Second Order Reverse Mode</a><br/>
	5777	<a href="reverse_one.xml" target="_top">First Order Reverse Mode</a><br/>
	5778	<a href="reverse.xml" target="_top">Reverse Mode</a><br/>
	5779	<a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
	5780	<a href="forward_dir.xml" target="_top">Multiple Directions Forward Mode</a><br/>
	5781	<a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a><br/>
	5782	<a href="forward.xml" target="_top">Forward Mode</a><br/>
	5783	<a href="dependent.xml#Parallel Mode" target="_top">Stop Recording and Store Operation Sequence: Parallel Mode</a><br/>
	5784	<a href="funconstruct.xml#Parallel Mode" target="_top">Construct an ADFun Object and Stop Recording: Parallel Mode</a><br/>
	5785	<a href="independent.xml#Parallel Mode" target="_top">Declare Independent Variables and Start Recording: Parallel Mode</a><br/>
	5786	<a href="atomic_reverse.xml" target="_top">Atomic Reverse Mode</a><br/>
	5787	<a href="atomic_forward.xml" target="_top">Atomic Forward Mode</a><br/>
	5788	<a href="discrete.xml#Parallel Mode" target="_top">Discrete AD Functions: Parallel Mode</a><br/>
	5789	<a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
	5790	<a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a><br/>
	5791	<a href="exp_2_rev2.xml" target="_top">exp_2: Second Order Reverse Mode</a><br/>
	5792	<a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a><br/>
	5793	<a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a><br/>
	5794	<a href="exp_2_for1.xml" target="_top">exp_2: First Order Forward Mode</a><br/>
	5795	<a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
	5796	<a href="introduction.xml#Preface.Reverse Mode" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Reverse Mode</a><br/>
	5797	<a href="introduction.xml#Preface.Forward Mode" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Forward Mode</a><br/>
1615	5798	any<b> </b>order<b> </b>reverse <a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a><br/>
1616	5799	example<b> </b>forward <a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a><br/>
1617	5800	example<b> </b>forward <a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a><br/>

1619	5802	example<b> </b>reverse <a href="exp_2_rev2.xml" target="_top">exp_2: Second Order Reverse Mode</a><br/>
1620	5803	example<b> </b>reverse <a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a><br/>
1621	5804	first<b> </b>order<b> </b>reverse <a href="reverse_one.xml" target="_top">First Order Reverse Mode</a><br/>
1622		forward <a href="forwardany.xml" target="_top">Any Order Forward Mode</a><br/>
	5805	forward <a href="forward_dir.xml" target="_top">Multiple Directions Forward Mode</a><br/>
	5806	forward <a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a><br/>
1623	5807	parallel <a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
1624	5808	reverse<b> </b>example <a href="exp_eps_rev2.xml" target="_top">exp_eps: Second Order Reverse Sweep</a><br/>
1625	5809	reverse<b> </b>example <a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a><br/>
1626	5810	second<b> </b>order<b> </b>reverse <a href="reverse_two.xml" target="_top">Second Order Reverse Mode</a><br/>
	5811	mode<b>:</b> <a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
	5812	<a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a><br/>
	5813	<a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a><br/>
	5814	<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	5815	<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	5816	<a href="forward.cpp.xml" target="_top">Forward Mode: Example and Test</a><br/>
	5817	<a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a><br/>
	5818	<a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
	5819	<a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
	5820	<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
	5821	<a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
	5822	modeexample <a href="reverse_two.cpp.xml" target="_top">Second Order Reverse ModeExample and Test</a><br/>
	5823	monthly <a href="download.xml#Compressed Tar File.Monthly Versions" target="_top">Download The CppAD Source Code: Compressed Tar File.Monthly Versions</a><br/>
	5824	more <a href="base_identical.xml#EqualOpSeq.More Complicated Cases" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq.More Complicated Cases</a><br/>
	5825	motivation <a href="mul_level.xml#Motivation" target="_top">Using Multiple Levels of AD: Motivation</a><br/>
	5826	<a href="time_test.xml#Motivation" target="_top">Determine Amount of Time to Execute a Test: Motivation</a><br/>
	5827	<a href="speedtest.xml#Motivation" target="_top">Run One Speed Test and Print Results: Motivation</a><br/>
	5828	<a href="speed_test.xml#Motivation" target="_top">Run One Speed Test and Return Results: Motivation</a><br/>
	5829	<a href="equalopseq.xml#Motivation" target="_top">Check if Two Value are Identically Equal: Motivation</a><br/>
	5830	move <a href="cppad_vector.xml#Assignment.Move Semantics" target="_top">The CppAD::vector Template Class: Assignment.Move Semantics</a><br/>
	5831	ms <a href="test_vector.xml#MS Windows" target="_top">Choosing The Vector Testing Template Class: MS Windows</a><br/>
	5832	msg <a href="cppad_assert.xml#Msg" target="_top">CppAD Assertions During Execution: Msg</a><br/>
	5833	<a href="errorhandler.xml#msg" target="_top">Replacing the CppAD Error Handler: msg</a><br/>
1627	5834	multi<br/>
1628	5835	dimensional<b> </b>Romberg<b> </b>integration <a href="rombergmul.xml" target="_top">Multi-dimensional Romberg Integration</a><br/>
	5836	multi<b>-</b>dimensional <a href="rombergmul.xml" target="_top">Multi-dimensional Romberg Integration</a><br/>
1629	5837	multi<b>-</b>thread<br/>
1630	5838	memory<b> </b>allocation <a href="omp_alloc.cpp.xml" target="_top">OpenMP Memory Allocator: Example and Test</a><br/>
1631	5839	memory<b> </b>allocation <a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
1632		multi<b>-</b>threading <a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
	5840	multi<b>-</b>threaded <a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
	5841	<a href="multi_newton.cpp.xml" target="_top">A Multi-Threaded Newton's Method</a><br/>
	5842	<a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
	5843	<a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
	5844	multi<b>-</b>threading <a href="tracknewdel.xml#Multi-Threading" target="_top">Routines That Track Use of New and Delete: Multi-Threading</a><br/>
	5845	<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	5846	<a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
	5847	<a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a><br/>
	5848	<a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
	5849	<a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
	5850	<a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
	5851	<a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
	5852	<a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
1633	5853	initialize <a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
1634	5854	memory<b> </b>allocation <a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
1635	5855	memory<b> </b>allocation <a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a><br/>
1636	5856	TrackCount <a href="tracknewdel.xml#Multi-Threading" target="_top">Routines That Track Use of New and Delete: Multi-Threading</a><br/>
1637		multi<b>_</b>newton<br/>
	5857	multi<b>_</b>newton <a href="thread_test.cpp.xml#multi_newton" target="_top">Run Multi-Threading Examples and Speed Tests: multi_newton</a><br/>
1638	5858	threading <a href="multi_newton.cpp.xml" target="_top">A Multi-Threaded Newton's Method</a><br/>
1639		multi<b>_</b>newton<b>_</b>combine <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
1640		multi<b>_</b>newton<b>_</b>setup <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
	5859	multi<b>_</b>newton<b>_</b>combine <a href="multi_newton_work.cpp.xml#multi_newton_combine" target="_top">Multi-threading Newton Method Utility Routines: multi_newton_combine</a><br/>
	5860	<a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
	5861	multi<b>_</b>newton<b>_</b>setup <a href="multi_newton_work.cpp.xml#multi_newton_setup" target="_top">Multi-threading Newton Method Utility Routines: multi_newton_setup</a><br/>
	5862	<a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
1641	5863	multi<b>_</b>newton<b>_</b>time <a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
1642	5864	multi<b>_</b>newton<b>_</b>work <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
1643		multi<b>_</b>newton<b>_</b>worker <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
	5865	multi<b>_</b>newton<b>_</b>worker <a href="multi_newton_work.cpp.xml#multi_newton_worker" target="_top">Multi-threading Newton Method Utility Routines: multi_newton_worker</a><br/>
	5866	<a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
1644	5867	multi<b>_</b>thread<br/>
1645	5868	harmonic <a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
1646	5869	Newton<b> </b>AD<b> </b>speed <a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
1647	5870	summation<b> </b>speed <a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
1648		multiple<br/>
	5871	multiple <a href="wishlist.xml#Multiple Directions" target="_top">The CppAD Wish List: Multiple Directions</a><br/>
	5872	<a href="mul_level.cpp.xml" target="_top">Multiple Tapes: Example and Test</a><br/>
	5873	<a href="mul_level.xml" target="_top">Using Multiple Levels of AD</a><br/>
	5874	<a href="reverse.xml#Multiple Directions" target="_top">Reverse Mode: Multiple Directions</a><br/>
	5875	<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	5876	<a href="forward_dir.xml" target="_top">Multiple Directions Forward Mode</a><br/>
	5877	<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	5878	<a href="forward_order.xml#yq.Multiple Orders" target="_top">Multiple Order Forward Mode: yq.Multiple Orders</a><br/>
	5879	<a href="forward_order.xml#xq.Multiple Orders" target="_top">Multiple Order Forward Mode: xq.Multiple Orders</a><br/>
	5880	<a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a><br/>
	5881	<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
1649	5882	AD<b> </b>level <a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
1650	5883	AD<b> </b>level <a href="mul_level.cpp.xml" target="_top">Multiple Tapes: Example and Test</a><br/>
1651	5884	AD<b> </b>level <a href="mul_level.xml" target="_top">Using Multiple Levels of AD</a><br/>
1652	5885	Adolc <a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
1653	5886	assignment <a href="compute_assign.xml#Result" target="_top">AD Computed Assignment Operators: Result</a><br/>
1654		forward<b> </b>orders <a href="forward_mul.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
1655		multiply<br/>
	5887	direction <a href="forward_dir.xml" target="_top">Multiple Directions Forward Mode</a><br/>
	5888	forward<b> </b>orders <a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	5889	forward<b> </b>orders <a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	5890	order <a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a><br/>
	5891	multiplication <a href="old_atomic.xml#Example.Matrix Multiplication" target="_top">User Defined Atomic AD Functions: Example.Matrix Multiplication</a><br/>
	5892	<a href="reversetheory.xml#Binary Operators.Multiplication" target="_top">The Theory of Reverse Mode: Binary Operators.Multiplication</a><br/>
	5893	<a href="forwardtheory.xml#Binary Operators.Multiplication" target="_top">The Theory of Forward Mode: Binary Operators.Multiplication</a><br/>
	5894	<a href="sacado_mat_mul.cpp.xml" target="_top">Sacado Speed: Matrix Multiplication</a><br/>
	5895	<a href="fadbad_mat_mul.cpp.xml" target="_top">Fadbad Speed: Matrix Multiplication</a><br/>
	5896	<a href="cppad_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication</a><br/>
	5897	<a href="adolc_mat_mul.cpp.xml" target="_top">Adolc Speed: Matrix Multiplication</a><br/>
	5898	<a href="double_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication (Double Version)</a><br/>
	5899	<a href="compute_assign.xml#Derivative.Multiplication" target="_top">AD Computed Assignment Operators: Derivative.Multiplication</a><br/>
	5900	<a href="ad_binary.xml#Derivative.Multiplication" target="_top">AD Binary Arithmetic Operators: Derivative.Multiplication</a><br/>
	5901	multiplication<b>:</b> <a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
	5902	<a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
	5903	multipliy <a href="atomic_matrix_mul.hpp.xml#Reverse Matrix Multipliy" target="_top">Matrix Multiply as an Atomic Operation: Reverse Matrix Multipliy</a><br/>
	5904	<a href="atomic_matrix_mul.hpp.xml#Forward Matrix Multipliy" target="_top">Matrix Multiply as an Atomic Operation: Forward Matrix Multipliy</a><br/>
	5905	multiply <a href="old_mat_mul.hpp.xml#One Matrix Multiply" target="_top">Define Matrix Multiply as a User Atomic Operation: One Matrix Multiply</a><br/>
	5906	<a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
	5907	<a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	5908	<a href="link_mat_mul.xml" target="_top">Speed Testing Derivative of Matrix Multiply</a><br/>
	5909	<a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a><br/>
1656	5910	AD<b> </b>example <a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
1657	5911	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
1658	5912	computed<b> </b>assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>

1666	5920	speed<b> </b>cppad <a href="cppad_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication</a><br/>
1667	5921	speed<b> </b>fadbad <a href="fadbad_mat_mul.cpp.xml" target="_top">Fadbad Speed: Matrix Multiplication</a><br/>
1668	5922	speed<b> </b>sacado <a href="sacado_mat_mul.cpp.xml" target="_top">Sacado Speed: Matrix Multiplication</a><br/>
	5923	multiply<b>:</b> <a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>
1669	5924
1670	5925	<b><big><a name="N">N</a></big></b>
1671	5926	<br/>

1685	5940	pointer <a href="preprocessor.xml#Documented Here.CPPAD_NULL" target="_top">CppAD API Preprocessor Symbols: Documented Here.CPPAD_NULL</a><br/>
1686	5941	NumericType<br/>
1687	5942	example <a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a><br/>
1688		namespace <a href="faq.xml#Namespace" target="_top">Frequently Asked Questions and Answers: Namespace</a><br/>
1689		CppAD <a href="cppad.xml#Namespace" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms: Namespace</a><br/>
1690		nan <a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	5943	n <a href="uniform_01_c.xml#n" target="_top">Simulate a [0,1] Uniform Random Variate: n</a><br/>
	5944	<a href="det_of_minor_c.xml#n" target="_top">Determinant of a Minor: n</a><br/>
	5945	<a href="old_atomic.xml#n" target="_top">User Defined Atomic AD Functions: n</a><br/>
	5946	<a href="cppad_ipopt_nlp.xml#n" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: n</a><br/>
	5947	<a href="adolc_alloc_mat.xml#n" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix: n</a><br/>
	5948	<a href="uniform_01.xml#n" target="_top">Simulate a [0,1] Uniform Random Variate: n</a><br/>
	5949	<a href="sparse_hes_fun.xml#n" target="_top">Evaluate a Function That Has a Sparse Hessian: n</a><br/>
	5950	<a href="sparse_jac_fun.xml#n" target="_top">Evaluate a Function That Has a Sparse Jacobian: n</a><br/>
	5951	<a href="mat_sum_sq.xml#n" target="_top">Sum Elements of a Matrix Times Itself: n</a><br/>
	5952	<a href="det_by_minor.xml#n" target="_top">Determinant Using Expansion by Minors: n</a><br/>
	5953	<a href="det_of_minor.xml#n" target="_top">Determinant of a Minor: n</a><br/>
	5954	<a href="det_by_lu.xml#n" target="_top">Determinant Using Expansion by Lu Factorization: n</a><br/>
	5955	<a href="link_mat_mul.xml#n" target="_top">Speed Testing Derivative of Matrix Multiply: n</a><br/>
	5956	<a href="lu_vec_ad.cpp.xml#n" target="_top">Lu Factor and Solve with Recorded Pivoting: n</a><br/>
	5957	<a href="odegear.xml#n" target="_top">An Arbitrary Order Gear Method: n</a><br/>
	5958	<a href="rombergmul.xml#n" target="_top">Multi-dimensional Romberg Integration: n</a><br/>
	5959	<a href="rombergone.xml#n" target="_top">One DimensionalRomberg Integration: n</a><br/>
	5960	<a href="lusolve.xml#n" target="_top">Compute Determinant and Solve Linear Equations: n</a><br/>
	5961	<a href="number_skip.xml#n" target="_top">Number of Variables that Can be Skipped: n</a><br/>
	5962	<a href="forward_dir.xml#Notation.n" target="_top">Multiple Directions Forward Mode: Notation.n</a><br/>
	5963	<a href="forward_order.xml#Notation.n" target="_top">Multiple Order Forward Mode: Notation.n</a><br/>
	5964	<a href="vecad.xml#n" target="_top">AD Vectors that Record Index Operations: n</a><br/>
	5965	n<b>_</b>sweep <a href="link_sparse_jacobian.xml#n_sweep" target="_top">Speed Testing Sparse Jacobian: n_sweep</a><br/>
	5966	<a href="sparse_hessian.xml#n_sweep" target="_top">Sparse Hessian: Easy Driver: n_sweep</a><br/>
	5967	<a href="sparse_jacobian.xml#n_sweep" target="_top">Sparse Jacobian: Easy Driver: n_sweep</a><br/>
	5968	name <a href="speedtest.xml#Test.name" target="_top">Run One Speed Test and Print Results: Test.name</a><br/>
	5969	<a href="near_equal.cpp.xml#File Name" target="_top">NearEqual Function: Example and Test: File Name</a><br/>
	5970	<a href="atomic_ctor.xml#atomic_base.name" target="_top">Atomic Function Constructor: atomic_base.name</a><br/>
	5971	<a href="checkpoint.xml#name" target="_top">Checkpointing Functions: name</a><br/>
	5972	<a href="discrete.xml#name" target="_top">Discrete AD Functions: name</a><br/>
	5973	namespace <a href="cppad_ipopt_nlp.xml#cppad_ipopt namespace" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: cppad_ipopt namespace</a><br/>
	5974	<a href="faq.xml#Namespace" target="_top">Frequently Asked Questions and Answers: Namespace</a><br/>
	5975	<a href="faq.xml#Namespace" target="_top">Frequently Asked Questions and Answers: Namespace</a><br/>
	5976	<a href="cppad_eigen.hpp.xml#CppAD Namespace" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: CppAD Namespace</a><br/>
	5977	<a href="cppad.xml#Namespace" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Namespace</a><br/>
	5978	CppAD <a href="cppad.xml#Namespace" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Namespace</a><br/>
	5979	nan <a href="ode_err_control.cpp.xml#Nan" target="_top">OdeErrControl: Example and Test: Nan</a><br/>
	5980	<a href="odeerrcontrol.xml#Method.Nan" target="_top">An Error Controller for ODE Solvers: Method.Nan</a><br/>
	5981	<a href="rosen34.xml#Fun.Nan" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.Nan</a><br/>
	5982	<a href="nan.xml#nan" target="_top">Obtain Nan or Determine if a Value is Nan: nan</a><br/>
	5983	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	5984	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	5985	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	5986	<a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan</a><br/>
	5987	<a href="optimize.xml#Atomic Functions.nan" target="_top">Optimize an ADFun Object Tape: Atomic Functions.nan</a><br/>
1691	5988	check<b> </b>ADFun <a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan</a><br/>
1692	5989	example <a href="nan.cpp.xml" target="_top">nan: Example and Test</a><br/>
1693	5990	macro <a href="nan.xml#Include.Macros" target="_top">Obtain Nan or Determine if a Value is Nan: Include.Macros</a><br/>
1694		new<br/>
	5991	nan<b>:</b> <a href="nan.cpp.xml" target="_top">nan: Example and Test</a><br/>
	5992	<a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
	5993	ncopy <a href="tracknewdel.xml#ncopy" target="_top">Routines That Track Use of New and Delete: ncopy</a><br/>
	5994	ndebug <a href="omp_efficient.xml#NDEBUG" target="_top">Check If A Memory Allocation is Efficient for Another Use: NDEBUG</a><br/>
	5995	<a href="omp_return_memory.xml#NDEBUG" target="_top">Return Memory to omp_alloc: NDEBUG</a><br/>
	5996	<a href="faq.xml#Speed.NDEBUG" target="_top">Frequently Asked Questions and Answers: Speed.NDEBUG</a><br/>
	5997	<a href="ta_return_memory.xml#NDEBUG" target="_top">Return Memory to thread_alloc: NDEBUG</a><br/>
	5998	<a href="cppad_assert.xml#NDEBUG" target="_top">CppAD Assertions During Execution: NDEBUG</a><br/>
	5999	nearequal <a href="near_equal.cpp.xml" target="_top">NearEqual Function: Example and Test</a><br/>
	6000	nearly <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
	6001	<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
	6002	nesting <a href="wishlist.xml#Conditional Expressions.Nesting" target="_top">The CppAD Wish List: Conditional Expressions.Nesting</a><br/>
	6003	new <a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
	6004	<a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
	6005	<a href="include_deprecated.xml#Linking New Files to Deprecated Commands" target="_top">Deprecated Include Files: Linking New Files to Deprecated Commands</a><br/>
1695	6006	example <a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
1696	6007	features <a href="wishlist.xml" target="_top">The CppAD Wish List</a><br/>
1697	6008	track <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
1698		newton<br/>
	6009	newlen <a href="tracknewdel.xml#newlen" target="_top">Routines That Track Use of New and Delete: newlen</a><br/>
	6010	newptr <a href="tracknewdel.xml#head newptr" target="_top">Routines That Track Use of New and Delete: head newptr</a><br/>
	6011	newton <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
	6012	<a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
1699	6013	multi<b>-</b>threading <a href="multi_newton.cpp.xml" target="_top">A Multi-Threaded Newton's Method</a><br/>
1700	6014	multi<b>_</b>thread<b> </b>AD<b> </b>speed <a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
1701		nonlinear<br/>
	6015	newton<b>'</b>s <a href="multi_newton.cpp.xml" target="_top">A Multi-Threaded Newton's Method</a><br/>
	6016	non<b>-</b>zero <a href="forward_dir.xml#Non-Zero Lower Orders" target="_top">Multiple Directions Forward Mode: Non-Zero Lower Orders</a><br/>
	6017	nonlinear <a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	6018	<a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
	6019	<a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a><br/>
	6020	<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	6021	<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
1702	6022	programming<b> </b>CppAD <a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
	6023	norm <a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>
1703	6024	norm<b>_</b>sq<br/>
1704	6025	atomic<b> </b>operation <a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>
1705		num<b>_</b>threads <a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	6026	not <a href="not_complex_ad.cpp.xml#Not Complex Differentiable" target="_top">Not Complex Differentiable: Example and Test: Not Complex Differentiable</a><br/>
	6027	<a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
	6028	<a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a><br/>
	6029	<a href="base_ordered.xml#Not Ordered" target="_top">Base Type Requirements for Ordered Comparisons: Not Ordered</a><br/>
	6030	<a href="base_cond_exp.xml#CondExpTemplate.Not Ordered" target="_top">Base Type Requirements for Conditional Expressions: CondExpTemplate.Not Ordered</a><br/>
	6031	notation <a href="ipopt_nlp_ode_problem.xml#Notation" target="_top">An ODE Inverse Problem Example: Notation</a><br/>
	6032	<a href="reverse_identity.xml#Notation" target="_top">An Important Reverse Mode Identity: Notation</a><br/>
	6033	<a href="erf_reverse.xml#Notation" target="_top">Error Function Reverse Mode Theory: Notation</a><br/>
	6034	<a href="tan_reverse.xml#Notation" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory: Notation</a><br/>
	6035	<a href="reversetheory.xml#Taylor Notation" target="_top">The Theory of Reverse Mode: Taylor Notation</a><br/>
	6036	<a href="forwardtheory.xml#Taylor Notation" target="_top">The Theory of Forward Mode: Taylor Notation</a><br/>
	6037	<a href="odegearcontrol.xml#Notation" target="_top">An Error Controller for Gear's Ode Solvers: Notation</a><br/>
	6038	<a href="odeerrcontrol.xml#Notation" target="_top">An Error Controller for ODE Solvers: Notation</a><br/>
	6039	<a href="reverse_any.xml#Notation" target="_top">Any Order Reverse Mode: Notation</a><br/>
	6040	<a href="forward_dir.xml#Notation" target="_top">Multiple Directions Forward Mode: Notation</a><br/>
	6041	<a href="forward_order.xml#Notation" target="_top">Multiple Order Forward Mode: Notation</a><br/>
	6042	<a href="base_member.xml#Notation" target="_top">Required Base Class Member Functions: Notation</a><br/>
	6043	nstep <a href="odegearcontrol.xml#nstep" target="_top">An Error Controller for Gear's Ode Solvers: nstep</a><br/>
	6044	<a href="odeerrcontrol.xml#nstep" target="_top">An Error Controller for ODE Solvers: nstep</a><br/>
	6045	num<b>_</b>bytes <a href="omp_efficient.xml#num_bytes" target="_top">Check If A Memory Allocation is Efficient for Another Use: num_bytes</a><br/>
	6046	<a href="omp_available.xml#num_bytes" target="_top">Amount of Memory Available for Quick Use by a Thread: num_bytes</a><br/>
	6047	<a href="omp_inuse.xml#num_bytes" target="_top">Amount of Memory a Thread is Currently Using: num_bytes</a><br/>
	6048	<a href="ta_available.xml#num_bytes" target="_top">Amount of Memory Available for Quick Use by a Thread: num_bytes</a><br/>
	6049	<a href="ta_inuse.xml#num_bytes" target="_top">Amount of Memory a Thread is Currently Using: num_bytes</a><br/>
	6050	num<b>_</b>sub <a href="multi_newton_work.cpp.xml#multi_newton_setup.num_sub" target="_top">Multi-threading Newton Method Utility Routines: multi_newton_setup.num_sub</a><br/>
	6051	<a href="multi_newton_time.cpp.xml#num_sub" target="_top">Timing Test of Multi-Threaded Newton Method: num_sub</a><br/>
	6052	<a href="multi_newton.cpp.xml#num_sub" target="_top">A Multi-Threaded Newton's Method: num_sub</a><br/>
	6053	<a href="thread_test.cpp.xml#multi_newton.num_sub" target="_top">Run Multi-Threading Examples and Speed Tests: multi_newton.num_sub</a><br/>
	6054	num<b>_</b>sum <a href="multi_newton_time.cpp.xml#num_sum" target="_top">Timing Test of Multi-Threaded Newton Method: num_sum</a><br/>
	6055	<a href="harmonic_work.cpp.xml#harmonic_setup.num_sum" target="_top">Multi-threading Sum of 1/i Utility Routines: harmonic_setup.num_sum</a><br/>
	6056	<a href="harmonic.cpp.xml#num_sum" target="_top">Multi-Threaded Implementation of Summation of 1/i: num_sum</a><br/>
	6057	<a href="thread_test.cpp.xml#multi_newton.num_sum" target="_top">Run Multi-Threading Examples and Speed Tests: multi_newton.num_sum</a><br/>
	6058	num<b>_</b>threads <a href="ta_parallel_setup.xml#num_threads" target="_top">Setup thread_alloc For Use in Multi-Threading Environment: num_threads</a><br/>
	6059	<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	6060	<a href="multi_newton_work.cpp.xml#max_itr.num_threads" target="_top">Multi-threading Newton Method Utility Routines: max_itr.num_threads</a><br/>
	6061	<a href="multi_newton_time.cpp.xml#num_threads" target="_top">Timing Test of Multi-Threaded Newton Method: num_threads</a><br/>
	6062	<a href="multi_newton.cpp.xml#num_threads" target="_top">A Multi-Threaded Newton's Method: num_threads</a><br/>
	6063	<a href="harmonic_work.cpp.xml#harmonic_setup.num_threads" target="_top">Multi-threading Sum of 1/i Utility Routines: harmonic_setup.num_threads</a><br/>
	6064	<a href="harmonic_time.cpp.xml#num_threads" target="_top">Timing Test of Multi-Threaded Summation of 1/i: num_threads</a><br/>
	6065	<a href="harmonic.cpp.xml#num_threads" target="_top">Multi-Threaded Implementation of Summation of 1/i: num_threads</a><br/>
1706	6066	thread<b>_</b>alloc <a href="ta_num_threads.xml" target="_top">Get Number of Threads</a><br/>
1707		number<br/>
	6067	num<b>_</b>zero <a href="multi_newton_time.cpp.xml#num_zero" target="_top">Timing Test of Multi-Threaded Newton Method: num_zero</a><br/>
	6068	<a href="thread_test.cpp.xml#multi_newton.num_zero" target="_top">Run Multi-Threading Examples and Speed Tests: multi_newton.num_zero</a><br/>
	6069	number <a href="elapsed_seconds_c.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	6070	<a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
	6071	<a href="old_max_num_threads.xml#number" target="_top">Set Maximum Number of Threads for omp_alloc Allocator: number</a><br/>
	6072	<a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
	6073	<a href="omp_get_thread_num.xml" target="_top">Get the Current OpenMP Thread Number</a><br/>
	6074	<a href="omp_max_num_threads.xml#number" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator: number</a><br/>
	6075	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
	6076	<a href="omp_max_thread.xml#number" target="_top">OpenMP Parallel Setup: number</a><br/>
	6077	<a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a><br/>
	6078	<a href="ta_thread_num.xml" target="_top">Get the Current Thread Number</a><br/>
	6079	<a href="ta_num_threads.xml#number" target="_top">Get Number of Threads: number</a><br/>
	6080	<a href="ta_num_threads.xml" target="_top">Get Number of Threads</a><br/>
	6081	<a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	6082	<a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	6083	<a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
	6084	<a href="size_order.xml" target="_top">Number Taylor Coefficient Orders Currently Stored</a><br/>
1708	6085	skip<b> </b>variables <a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
1709	6086	number<b>_</b>skip <a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
1710	6087	example <a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
1711		numeric<br/>
	6088	numbervector <a href="cppad_ipopt_nlp.xml#NumberVector" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: NumberVector</a><br/>
	6089	numeric <a href="wishlist.xml#Numeric Limits" target="_top">The CppAD Wish List: Numeric Limits</a><br/>
	6090	<a href="ipopt_solve.xml#options.Numeric" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: options.Numeric</a><br/>
	6091	<a href="numerictype.xml" target="_top">Definition of a Numeric Type</a><br/>
	6092	<a href="base_require.xml#Numeric Type" target="_top">AD<Base> Requirements for Base Type: Numeric Type</a><br/>
	6093	<a href="limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a><br/>
	6094	<a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
1712	6095	check <a href="checknumerictype.xml" target="_top">Check NumericType Class Concept</a><br/>
1713	6096	limits<b> </b>Base <a href="base_std_math.xml#limits" target="_top">Base Type Requirements for Standard Math Functions: limits</a><br/>
1714	6097	type <a href="numerictype.xml" target="_top">Definition of a Numeric Type</a><br/>
1715		numerical<br/>
	6098	numerical <a href="bib.xml#Numerical Recipes" target="_top">Bibliography: Numerical Recipes</a><br/>
	6099	<a href="library.xml#Numerical AD Library" target="_top">The CppAD General Purpose Library: Numerical AD Library</a><br/>
	6100	<a href="library.xml#CppAD Numerical Template Library" target="_top">The CppAD General Purpose Library: CppAD Numerical Template Library</a><br/>
1716	6101	C<b>++ </b>template<b> </b>library <a href="library.xml" target="_top">The CppAD General Purpose Library</a><br/>
	6102	numerictype <a href="checknumerictype.xml" target="_top">Check NumericType Class Concept</a><br/>
	6103	numerictype<b>:</b> <a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a><br/>
	6104	numtraits <a href="cppad_eigen.hpp.xml#Eigen NumTraits" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: Eigen NumTraits</a><br/>
	6105	nz<b>_</b>compare <a href="revsparsejac.xml#nz_compare" target="_top">Jacobian Sparsity Pattern: Reverse Mode: nz_compare</a><br/>
1717	6106
1718	6107	<b><big><a name="O">O</a></big></b>
1719	6108	<br/>

1735	6124	OdeGearControl <a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
1736	6125	example <a href="ode_gear_control.cpp.xml" target="_top">OdeGearControl: Example and Test</a><br/>
1737	6126	OpenMP<br/>
1738		compile<b> </b>flags <a href="installunix.xml#openmp_flags" target="_top">Unix Test and Installation: openmp_flags</a><br/>
	6127	compile<b> </b>flags <a href="installunix.xml#openmp_flags" target="_top">Deprecated Unix Test and Installation: openmp_flags</a><br/>
1739	6128	example<b> </b>A<b>.</b>1<b>.</b>1c <a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
1740	6129	example<b> </b>A<b>.</b>1<b>.</b>1c <a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
1741	6130	Order<br/>
1742	6131	ADFun <a href="fundeprecated.xml#Order" target="_top">ADFun Object Deprecated Member Functions: Order</a><br/>
1743		object<br/>
	6132	obj<b>_</b>value <a href="cppad_ipopt_nlp.xml#solution.obj_value" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: solution.obj_value</a><br/>
	6133	<a href="ipopt_solve.xml#solution.obj_value" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: solution.obj_value</a><br/>
	6134	object <a href="fundeprecated.xml" target="_top">ADFun Object Deprecated Member Functions</a><br/>
	6135	<a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
	6136	<a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan</a><br/>
	6137	<a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
	6138	<a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
	6139	<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
1744	6140	ADFun <a href="adfun.xml" target="_top">ADFun Objects</a><br/>
1745		ode<br/>
	6141	objective <a href="ipopt_nlp_ode_fast.xml#Objective Function" target="_top">ODE Fitting Using Fast Representation: Objective Function</a><br/>
	6142	<a href="ipopt_nlp_ode_simple.xml#Objective Function" target="_top">ODE Fitting Using Simple Representation: Objective Function</a><br/>
	6143	<a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
	6144	objects <a href="adfun.xml" target="_top">ADFun Objects</a><br/>
	6145	<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
	6146	<a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a><br/>
	6147	<a href="ad.xml" target="_top">AD Objects</a><br/>
	6148	objects<b>:</b> <a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a><br/>
	6149	obtain <a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	6150	ode <a href="ipopt_nlp_ode_run.hpp.xml" target="_top">Driver for Running the Ipopt ODE Example</a><br/>
	6151	<a href="ipopt_nlp_ode_fast.hpp.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	6152	<a href="ipopt_nlp_ode_simple.hpp.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	6153	<a href="ipopt_nlp_ode_problem.hpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	6154	<a href="ipopt_nlp_ode_fast.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	6155	<a href="ipopt_nlp_ode_simple.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	6156	<a href="ipopt_nlp_ode_problem.xml" target="_top">An ODE Inverse Problem Example</a><br/>
	6157	<a href="sacado_ode.cpp.xml" target="_top">Sacado Speed: Gradient of Ode Solution</a><br/>
	6158	<a href="fadbad_ode.cpp.xml" target="_top">Fadbad Speed: Ode</a><br/>
	6159	<a href="cppad_ode.cpp.xml" target="_top">CppAD Speed: Gradient of Ode Solution</a><br/>
	6160	<a href="adolc_ode.cpp.xml" target="_top">Adolc Speed: Ode</a><br/>
	6161	<a href="double_ode.cpp.xml" target="_top">Double Speed: Ode Solution</a><br/>
	6162	<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
	6163	<a href="link_ode.xml" target="_top">Speed Testing the Jacobian of Ode Solution</a><br/>
	6164	<a href="ode_taylor.cpp.xml#ODE Solution" target="_top">Taylor's Ode Solver: An Example and Test: ODE Solution</a><br/>
	6165	<a href="ode_taylor.cpp.xml#ODE" target="_top">Taylor's Ode Solver: An Example and Test: ODE</a><br/>
	6166	<a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	6167	<a href="mul_level_adolc_ode.cpp.xml#Derivative of ODE Solution" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Derivative of ODE Solution</a><br/>
	6168	<a href="mul_level_adolc_ode.cpp.xml#ODE Solution" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: ODE Solution</a><br/>
	6169	<a href="mul_level_adolc_ode.cpp.xml#ODE" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: ODE</a><br/>
	6170	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	6171	<a href="mul_level_ode.cpp.xml#Derivative of ODE Solution" target="_top">Taylor's Ode Solver: An Example and Test: Derivative of ODE Solution</a><br/>
	6172	<a href="mul_level_ode.cpp.xml#ODE Solution" target="_top">Taylor's Ode Solver: An Example and Test: ODE Solution</a><br/>
	6173	<a href="mul_level_ode.cpp.xml#ODE" target="_top">Taylor's Ode Solver: An Example and Test: ODE</a><br/>
	6174	<a href="mul_level_ode.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	6175	<a href="ipopt_solve_ode_inverse.cpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	6176	<a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
	6177	<a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
	6178	<a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
	6179	<a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
1746	6180	cppad<b>_</b>ipopt<b>_</b>nlp<b> </b>example<b> </b>source <a href="ipopt_nlp_ode_fast.hpp.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
1747	6181	cppad<b>_</b>ipopt<b>_</b>nlp<b> </b>example<b> </b>source <a href="ipopt_nlp_ode_simple.hpp.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
1748	6182	cppad<b>_</b>ipopt<b>_</b>nlp<b> </b>representation <a href="ipopt_nlp_ode_fast.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>

1757	6191	speed<b> </b>sacado <a href="sacado_ode.cpp.xml" target="_top">Sacado Speed: Gradient of Ode Solution</a><br/>
1758	6192	speed<b> </b>test <a href="link_ode.xml" target="_top">Speed Testing the Jacobian of Ode Solution</a><br/>
1759	6193	stiff <a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
1760		ode<b>_</b>evaluate<br/>
	6194	ode<b>:</b> <a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
	6195	ode<b>_</b>evaluate <a href="ode_evaluate.hpp.xml" target="_top">Source: ode_evaluate</a><br/>
1761	6196	example <a href="ode_evaluate.cpp.xml" target="_top">ode_evaluate: Example and test</a><br/>
1762	6197	function <a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
1763	6198	source <a href="ode_evaluate.hpp.xml" target="_top">Source: ode_evaluate</a><br/>
1764		of <a href="glossary.xml#Sparsity Pattern.Vector of Sets" target="_top">Glossary: Sparsity Pattern.Vector of Sets</a><br/>
	6199	ode<b>_</b>evaluate<b>:</b> <a href="ode_evaluate.cpp.xml" target="_top">ode_evaluate: Example and test</a><br/>
	6200	ode<b>_</b>inverse <a href="ipopt_solve.xml#Example.ode_inverse" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Example.ode_inverse</a><br/>
	6201	odeerrcontrol<b>:</b> <a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a><br/>
	6202	<a href="ode_err_control.cpp.xml" target="_top">OdeErrControl: Example and Test</a><br/>
	6203	odegear<b>:</b> <a href="ode_gear.cpp.xml" target="_top">OdeGear: Example and Test</a><br/>
	6204	odegearcontrol<b>:</b> <a href="ode_gear_control.cpp.xml" target="_top">OdeGearControl: Example and Test</a><br/>
	6205	of <a href="time_det_by_minor_c.xml" target="_top">Determine Amount of Time to Execute det_by_minor</a><br/>
	6206	<a href="elapsed_seconds_c.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	6207	<a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
	6208	<a href="correct_det_by_minor_c.xml" target="_top">Correctness Test of det_by_minor Routine</a><br/>
	6209	<a href="det_of_minor_c.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
	6210	<a href="det_of_minor_c.xml" target="_top">Determinant of a Minor</a><br/>
	6211	<a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
	6212	<a href="ipopt_nlp_ode_problem.xml#Black Box Method.Two levels of Iteration" target="_top">An ODE Inverse Problem Example: Black Box Method.Two levels of Iteration</a><br/>
	6213	<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
	6214	<a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
	6215	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	6216	<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	6217	<a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	6218	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
	6219	<a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
	6220	<a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
	6221	<a href="glossary.xml#Sparsity Pattern.Vector of Sets" target="_top">Glossary: Sparsity Pattern.Vector of Sets</a><br/>
1765	6222	<a href="glossary.xml#Sparsity Pattern.Vector of Boolean" target="_top">Glossary: Sparsity Pattern.Vector of Boolean</a><br/>
1766	6223	<a href="glossary.xml#AD of Base" target="_top">Glossary: AD of Base</a><br/>
	6224	<a href="reversetheory.xml" target="_top">The Theory of Reverse Mode</a><br/>
	6225	<a href="forwardtheory.xml" target="_top">The Theory of Forward Mode</a><br/>
	6226	<a href="theory.xml" target="_top">The Theory of Derivative Calculations</a><br/>
	6227	<a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
	6228	<a href="sacado_ode.cpp.xml" target="_top">Sacado Speed: Gradient of Ode Solution</a><br/>
	6229	<a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	6230	<a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
	6231	<a href="fadbad_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
	6232	<a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	6233	<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
	6234	<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
	6235	<a href="cppad_ode.cpp.xml" target="_top">CppAD Speed: Gradient of Ode Solution</a><br/>
	6236	<a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	6237	<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
	6238	<a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>
	6239	<a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	6240	<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
	6241	<a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
	6242	<a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
	6243	<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
	6244	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	6245	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	6246	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	6247	<a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
	6248	<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	6249	<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
	6250	<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
	6251	<a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
	6252	<a href="det_of_minor.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
	6253	<a href="det_of_minor.xml" target="_top">Determinant of a Minor</a><br/>
	6254	<a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a><br/>
	6255	<a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a><br/>
	6256	<a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
	6257	<a href="link_ode.xml" target="_top">Speed Testing the Jacobian of Ode Solution</a><br/>
	6258	<a href="link_mat_mul.xml" target="_top">Speed Testing Derivative of Matrix Multiply</a><br/>
	6259	<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
	6260	<a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
	6261	<a href="mul_level_adolc_ode.cpp.xml#Derivative of ODE Solution" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Derivative of ODE Solution</a><br/>
	6262	<a href="mul_level_ode.cpp.xml#Derivative of ODE Solution" target="_top">Taylor's Ode Solver: An Example and Test: Derivative of ODE Solution</a><br/>
	6263	<a href="mul_level.xml#General Procedure.Derivative of Outer Function" target="_top">Using Multiple Levels of AD: General Procedure.Derivative of Outer Function</a><br/>
	6264	<a href="mul_level.xml#General Procedure.Derivative of Inner Function" target="_top">Using Multiple Levels of AD: General Procedure.Derivative of Inner Function</a><br/>
	6265	<a href="mul_level.xml" target="_top">Using Multiple Levels of AD</a><br/>
	6266	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	6267	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	6268	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
	6269	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	6270	<a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
	6271	<a href="listallexamples.xml" target="_top">List of All the CppAD Examples</a><br/>
	6272	<a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
	6273	<a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
	6274	<a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
	6275	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	6276	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	6277	<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	6278	<a href="ta_num_threads.xml" target="_top">Get Number of Threads</a><br/>
	6279	<a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
	6280	<a href="simplevector.xml#Elements of Specified Type" target="_top">Definition of a Simple Vector: Elements of Specified Type</a><br/>
	6281	<a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
	6282	<a href="numerictype.xml" target="_top">Definition of a Numeric Type</a><br/>
	6283	<a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	6284	<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
	6285	<a href="speed_program.cpp.xml" target="_top">Example Use of SpeedTest</a><br/>
	6286	<a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
	6287	<a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
	6288	<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
	6289	<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
	6290	<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
	6291	<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
	6292	<a href="team_thread.hpp.xml#Speed Test of Implementation" target="_top">Specifications for A Team of AD Threads: Speed Test of Implementation</a><br/>
	6293	<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
	6294	<a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
	6295	<a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
	6296	<a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
	6297	<a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
	6298	<a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
	6299	<a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
	6300	<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
	6301	<a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
	6302	<a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
	6303	<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	6304	<a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	6305	<a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
	6306	<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	6307	<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	6308	<a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
	6309	<a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
	6310	<a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
	6311	<a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
	6312	<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
	6313	<a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
	6314	<a href="atomic_afun.xml" target="_top">Using AD Version of Atomic Function</a><br/>
	6315	<a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a><br/>
	6316	<a href="exp_eps.cpp.xml" target="_top">exp_eps: Test of exp_eps</a><br/>
	6317	<a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	6318	ok <a href="old_atomic.xml#ok" target="_top">User Defined Atomic AD Functions: ok</a><br/>
	6319	<a href="det_grad_33.xml#ok" target="_top">Check Gradient of Determinant of 3 by 3 matrix: ok</a><br/>
	6320	<a href="det_33.xml#ok" target="_top">Check Determinant of 3 by 3 matrix: ok</a><br/>
	6321	<a href="ta_free_all.xml#ok" target="_top">Free All Memory That Was Allocated for Use by thread_alloc: ok</a><br/>
	6322	<a href="team_thread.hpp.xml#ok" target="_top">Specifications for A Team of AD Threads: ok</a><br/>
	6323	<a href="multi_newton_time.cpp.xml#ok" target="_top">Timing Test of Multi-Threaded Newton Method: ok</a><br/>
	6324	<a href="multi_newton.cpp.xml#ok" target="_top">A Multi-Threaded Newton's Method: ok</a><br/>
	6325	<a href="harmonic_time.cpp.xml#ok" target="_top">Timing Test of Multi-Threaded Summation of 1/i: ok</a><br/>
	6326	<a href="harmonic.cpp.xml#ok" target="_top">Multi-Threaded Implementation of Summation of 1/i: ok</a><br/>
	6327	<a href="funcheck.xml#ok" target="_top">Check an ADFun Sequence of Operations: ok</a><br/>
	6328	<a href="atomic_rev_sparse_jac.xml#ok" target="_top">Atomic Reverse Jacobian Sparsity Patterns: ok</a><br/>
	6329	<a href="atomic_for_sparse_jac.xml#ok" target="_top">Atomic Forward Jacobian Sparsity Patterns: ok</a><br/>
	6330	<a href="atomic_reverse.xml#ok" target="_top">Atomic Reverse Mode: ok</a><br/>
	6331	<a href="atomic_forward.xml#ok" target="_top">Atomic Forward Mode: ok</a><br/>
	6332	old <a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
	6333	<a href="abs.xml#Old Derivative" target="_top">AD Absolute Value Function: Old Derivative</a><br/>
1767	6334	old<b>_</b>atomic<br/>
1768	6335	example <a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
1769	6336	example <a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>

1775	6342	define <a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
1776	6343	example <a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
1777	6344	test <a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
1778		omp<b>_</b>alloc<br/>
	6345	oldptr <a href="tracknewdel.xml#oldptr" target="_top">Routines That Track Use of New and Delete: oldptr</a><br/>
	6346	omp<b>_</b>alloc <a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
	6347	<a href="omp_return_memory.xml" target="_top">Return Memory to omp_alloc</a><br/>
	6348	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
1779	6349	available <a href="omp_available.xml#Deprecated" target="_top">Amount of Memory Available for Quick Use by a Thread: Deprecated</a><br/>
1780	6350	create<b>_</b>array <a href="omp_create_array.xml#Deprecated" target="_top">Allocate Memory and Create A Raw Array: Deprecated</a><br/>
1781	6351	delete<b>_</b>array <a href="omp_delete_array.xml#Deprecated" target="_top">Return A Raw Array to The Available Memory for a Thread: Deprecated</a><br/>

1789	6359	return<b>_</b>memory <a href="omp_return_memory.xml#Deprecated" target="_top">Return Memory to omp_alloc: Deprecated</a><br/>
1790	6360	omp<b>_</b>max<b>_</b>thread<br/>
1791	6361	depreciated <a href="omp_max_thread.xml#Deprecated" target="_top">OpenMP Parallel Setup: Deprecated</a><br/>
1792		one<br/>
1793		order<b> </b>Forward <a href="forwardone.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
1794		openmp<br/>
	6362	one <a href="old_mat_mul.hpp.xml#Reverse Partials One Order" target="_top">Define Matrix Multiply as a User Atomic Operation: Reverse Partials One Order</a><br/>
	6363	<a href="old_mat_mul.hpp.xml#One Matrix Multiply" target="_top">Define Matrix Multiply as a User Atomic Operation: One Matrix Multiply</a><br/>
	6364	<a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	6365	<a href="romberg_one.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	6366	<a href="rombergone.xml" target="_top">One DimensionalRomberg Integration</a><br/>
	6367	<a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
	6368	<a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
	6369	<a href="forward_order.xml#yq.One Order" target="_top">Multiple Order Forward Mode: yq.One Order</a><br/>
	6370	<a href="forward_order.xml#xq.One Order" target="_top">Multiple Order Forward Mode: xq.One Order</a><br/>
	6371	<a href="forward_order.xml#One Order" target="_top">Multiple Order Forward Mode: One Order</a><br/>
	6372	order<b> </b>Forward <a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
	6373	onetape <a href="speed_main.xml#option_list.onetape" target="_top">Running the Speed Test Program: option_list.onetape</a><br/>
	6374	op <a href="compare.xml#Op" target="_top">AD Binary Comparison Operators: Op</a><br/>
	6375	<a href="compute_assign.xml#Op" target="_top">AD Computed Assignment Operators: Op</a><br/>
	6376	<a href="ad_binary.xml#Op" target="_top">AD Binary Arithmetic Operators: Op</a><br/>
	6377	openmp <a href="omp_alloc.cpp.xml" target="_top">OpenMP Memory Allocator: Example and Test</a><br/>
	6378	<a href="omp_get_thread_num.xml" target="_top">Get the Current OpenMP Thread Number</a><br/>
	6379	<a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
	6380	<a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
	6381	<a href="omp_max_thread.xml" target="_top">OpenMP Parallel Setup</a><br/>
	6382	<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
	6383	<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
	6384	<a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
1795	6385	AD<b> </b>team <a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
1796	6386	memory<b> </b>allocation <a href="omp_alloc.cpp.xml" target="_top">OpenMP Memory Allocator: Example and Test</a><br/>
1797	6387	memory<b> </b>allocation <a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
1798	6388	memory<b> </b>allocation <a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
1799	6389	run<b> </b>tests <a href="thread_test.cpp.xml#Running Tests.threading" target="_top">Run Multi-Threading Examples and Speed Tests: Running Tests.threading</a><br/>
1800	6390	simple<b> </b>AD <a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
1801		operation <a href="glossary.xml#Operation" target="_top">Glossary: Operation</a><br/>
	6391	openmp<b>/</b>run<b>.</b>sh <a href="whats_new_11.xml#07-11.openmp/run.sh" target="_top">Changes and Additions to CppAD During 2011: 07-11.openmp/run.sh</a><br/>
	6392	openmp<b>_</b>flags <a href="installunix.xml#openmp_flags" target="_top">Deprecated Unix Test and Installation: openmp_flags</a><br/>
	6393	operand <a href="atomic_matrix_mul.hpp.xml#Right Operand Element Index" target="_top">Matrix Multiply as an Atomic Operation: Right Operand Element Index</a><br/>
	6394	<a href="atomic_matrix_mul.hpp.xml#Left Operand Element Index" target="_top">Matrix Multiply as an Atomic Operation: Left Operand Element Index</a><br/>
	6395	operation <a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
	6396	<a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
	6397	<a href="wishlist.xml#Operation Sequence" target="_top">The CppAD Wish List: Operation Sequence</a><br/>
	6398	<a href="glossary.xml#Operation" target="_top">Glossary: Operation</a><br/>
	6399	<a href="ode_evaluate.xml#Float.Operation Sequence" target="_top">Evaluate a Function Defined in Terms of an ODE: Float.Operation Sequence</a><br/>
	6400	<a href="runge45.xml#Operation Sequence" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Operation Sequence</a><br/>
	6401	<a href="poly.xml#Operation Sequence" target="_top">Evaluate a Polynomial or its Derivative: Operation Sequence</a><br/>
	6402	<a href="pow_int.xml#Operation Sequence" target="_top">The Integer Power Function: Operation Sequence</a><br/>
	6403	<a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>
	6404	<a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
	6405	<a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
	6406	<a href="parvar.xml#Operation Sequence" target="_top">Is an AD Object a Parameter or Variable: Operation Sequence</a><br/>
	6407	<a href="boolfun.xml#Operation Sequence" target="_top">AD Boolean Functions: Operation Sequence</a><br/>
	6408	<a href="nearequalext.xml#Operation Sequence" target="_top">Compare AD and Base Objects for Nearly Equal: Operation Sequence</a><br/>
	6409	<a href="compare.xml#Operation Sequence" target="_top">AD Binary Comparison Operators: Operation Sequence</a><br/>
	6410	<a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a><br/>
	6411	<a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
	6412	<a href="discrete.xml#Operation Sequence" target="_top">Discrete AD Functions: Operation Sequence</a><br/>
	6413	<a href="condexp.xml#Operation Sequence" target="_top">AD Conditional Expressions: Operation Sequence</a><br/>
	6414	<a href="pow.xml#Operation Sequence" target="_top">The AD Power Function: Operation Sequence</a><br/>
	6415	<a href="erf.xml#Operation Sequence" target="_top">The AD Error Function: Operation Sequence</a><br/>
	6416	<a href="atan2.xml#Operation Sequence" target="_top">AD Two Argument Inverse Tangent Function: Operation Sequence</a><br/>
	6417	<a href="sign.xml#Operation Sequence" target="_top">Sign Function: Operation Sequence</a><br/>
	6418	<a href="abs.xml#Operation Sequence" target="_top">AD Absolute Value Function: Operation Sequence</a><br/>
	6419	<a href="std_math_ad.xml#Operation Sequence" target="_top">AD Standard Math Unary Functions: Operation Sequence</a><br/>
	6420	<a href="compute_assign.xml#Operation Sequence" target="_top">AD Computed Assignment Operators: Operation Sequence</a><br/>
	6421	<a href="ad_binary.xml#Operation Sequence" target="_top">AD Binary Arithmetic Operators: Operation Sequence</a><br/>
	6422	<a href="unaryminus.xml#Operation Sequence" target="_top">AD Unary Minus Operator: Operation Sequence</a><br/>
	6423	<a href="unaryplus.xml#Operation Sequence" target="_top">AD Unary Plus Operator: Operation Sequence</a><br/>
	6424	<a href="ad_output.xml#Operation Sequence" target="_top">AD Output Stream Operator: Operation Sequence</a><br/>
	6425	<a href="ad_input.xml#Operation Sequence" target="_top">AD Output Stream Operator: Operation Sequence</a><br/>
	6426	<a href="integer.xml#Operation Sequence" target="_top">Convert From AD to Integer: Operation Sequence</a><br/>
	6427	<a href="value.xml#Operation Sequence" target="_top">Convert From an AD Type to its Base Type: Operation Sequence</a><br/>
	6428	<a href="exp_eps_for2.xml#Operation Sequence.Operation" target="_top">exp_eps: Second Order Forward Mode: Operation Sequence.Operation</a><br/>
	6429	<a href="exp_eps_for2.xml#Operation Sequence" target="_top">exp_eps: Second Order Forward Mode: Operation Sequence</a><br/>
	6430	<a href="exp_eps_for1.xml#Operation Sequence.Operation" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence.Operation</a><br/>
	6431	<a href="exp_eps_for1.xml#Operation Sequence" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence</a><br/>
	6432	<a href="exp_eps_for0.xml#Operation Sequence.Operation" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence.Operation</a><br/>
	6433	<a href="exp_eps_for0.xml#Operation Sequence" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence</a><br/>
	6434	<a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
	6435	<a href="exp_2_for2.xml#Operation Sequence.Operation" target="_top">exp_2: Second Order Forward Mode: Operation Sequence.Operation</a><br/>
	6436	<a href="exp_2_for2.xml#Operation Sequence" target="_top">exp_2: Second Order Forward Mode: Operation Sequence</a><br/>
	6437	<a href="exp_2_for1.xml#Operation Sequence.Operation" target="_top">exp_2: First Order Forward Mode: Operation Sequence.Operation</a><br/>
	6438	<a href="exp_2_for1.xml#Operation Sequence" target="_top">exp_2: First Order Forward Mode: Operation Sequence</a><br/>
	6439	<a href="exp_2_for0.xml#Operation Sequence.Operation" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Operation Sequence.Operation</a><br/>
	6440	<a href="exp_2_for0.xml#Operation Sequence" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Operation Sequence</a><br/>
	6441	<a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
	6442	<a href="introduction.xml#Preface.Operation Count" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Operation Count</a><br/>
1802	6443	AD<b> </b>Bool<b> </b>valued <a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
1803	6444	AD<b> </b>valued <a href="advalued.xml" target="_top">AD Valued Operations and Functions</a><br/>
1804	6445	ad<b> </b>atomic <a href="atomic.xml" target="_top">Atomic AD Functions</a><br/>
1805	6446	atomic<b> </b>get<b>_</b>started <a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	6447	atomic<b> </b>hessian<b> </b>sparsity <a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
1806	6448	equal<b> </b>sequence <a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
1807	6449	norm<b>_</b>sq <a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>
1808	6450	optimize<b> </b>sequence <a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>

1815	6457	simple<b> </b>atomic <a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
1816	6458	user<b> </b>atomic <a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
1817	6459	user<b> </b>atomic <a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a><br/>
1818		operations<br/>
	6460	operation<b>:</b> <a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	6461	<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
	6462	<a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
	6463	operations <a href="poly.xml#Type.Operations" target="_top">Evaluate a Polynomial or its Derivative: Type.Operations</a><br/>
	6464	<a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
	6465	<a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
	6466	<a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
	6467	<a href="advalued.xml" target="_top">AD Valued Operations and Functions</a><br/>
1819	6468	optimize<b> </b>sequence <a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
1820		operator<br/>
	6469	operations<b>:</b> <a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	6470	<a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
	6471	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	6472	<a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	6473	operator <a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
	6474	<a href="funconstruct.xml#Example.Assignment Operator" target="_top">Construct an ADFun Object and Stop Recording: Example.Assignment Operator</a><br/>
	6475	<a href="funconstruct.xml#Assignment Operator" target="_top">Construct an ADFun Object and Stop Recording: Assignment Operator</a><br/>
	6476	<a href="base_alloc.hpp.xml#Output Operator" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Output Operator</a><br/>
	6477	<a href="base_alloc.hpp.xml#Boolean Operator Macro" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Boolean Operator Macro</a><br/>
	6478	<a href="base_alloc.hpp.xml#Binary Operator Macro" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Binary Operator Macro</a><br/>
	6479	<a href="base_require.xml#Output Operator" target="_top">AD<Base> Requirements for Base Type: Output Operator</a><br/>
	6480	<a href="unaryminus.xml" target="_top">AD Unary Minus Operator</a><br/>
	6481	<a href="unaryplus.xml" target="_top">AD Unary Plus Operator</a><br/>
	6482	<a href="ad_output.xml" target="_top">AD Output Stream Operator</a><br/>
	6483	<a href="ad_input.xml" target="_top">AD Output Stream Operator</a><br/>
	6484	<a href="ad_assign.xml" target="_top">AD Assignment Operator</a><br/>
1821	6485	AD<b> </b>arithmetic <a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
1822	6486	AD<b> </b>binary<b> </b>compare <a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
1823	6487	ADFun<b> </b>assignment <a href="funconstruct.xml#Assignment Operator" target="_top">Construct an ADFun Object and Stop Recording: Assignment Operator</a><br/>

1825	6489	assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
1826	6490	base<b> </b>output <a href="base_require.xml#Output Operator" target="_top">AD<Base> Requirements for Base Type: Output Operator</a><br/>
1827	6491	binary <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
	6492	operator<b>:</b> <a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a><br/>
	6493	<a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a><br/>
	6494	<a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	6495	<a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	6496	operators <a href="reversetheory.xml#Binary Operators" target="_top">The Theory of Reverse Mode: Binary Operators</a><br/>
	6497	<a href="forwardtheory.xml#Binary Operators" target="_top">The Theory of Forward Mode: Binary Operators</a><br/>
	6498	<a href="numerictype.xml#Operators" target="_top">Definition of a Numeric Type: Operators</a><br/>
	6499	<a href="optimize.xml#Comparison Operators" target="_top">Optimize an ADFun Object Tape: Comparison Operators</a><br/>
	6500	<a href="base_member.xml#Bool Operators" target="_top">Required Base Class Member Functions: Bool Operators</a><br/>
	6501	<a href="base_member.xml#Binary Operators" target="_top">Required Base Class Member Functions: Binary Operators</a><br/>
	6502	<a href="base_member.xml#Assignment Operators" target="_top">Required Base Class Member Functions: Assignment Operators</a><br/>
	6503	<a href="base_member.xml#Unary Operators" target="_top">Required Base Class Member Functions: Unary Operators</a><br/>
	6504	<a href="compare.xml" target="_top">AD Binary Comparison Operators</a><br/>
	6505	<a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
	6506	<a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
	6507	<a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
	6508	operators<b>:</b> <a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
1828	6509	opt<b>_</b>val<b>_</b>hes <a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
1829	6510	example <a href="opt_val_hes.cpp.xml" target="_top">opt_val_hes: Example and Test</a><br/>
	6511	opt<b>_</b>val<b>_</b>hes<b>:</b> <a href="opt_val_hes.cpp.xml" target="_top">opt_val_hes: Example and Test</a><br/>
	6512	optimal <a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
1830	6513	optimal<b> </b>value <a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
1831		optimize <a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
	6514	optimization <a href="wishlist.xml#Optimization" target="_top">The CppAD Wish List: Optimization</a><br/>
	6515	<a href="rosen34.xml#Fun.Optimization" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.Optimization</a><br/>
	6516	<a href="optimize.xml#Checking Optimization" target="_top">Optimize an ADFun Object Tape: Checking Optimization</a><br/>
	6517	optimization<b>:</b> <a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>
	6518	optimize <a href="faq.xml#Speed.Optimize" target="_top">Frequently Asked Questions and Answers: Speed.Optimize</a><br/>
	6519	<a href="speed_main.xml#option_list.optimize" target="_top">Running the Speed Test Program: option_list.optimize</a><br/>
	6520	<a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
	6521	<a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
	6522	<a href="condexp.xml#Optimize" target="_top">AD Conditional Expressions: Optimize</a><br/>
1832	6523	conditional<b> </b>expression <a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
1833	6524	operation<b> </b>sequence <a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>
1834		print<b> </b>cppad<b> </b>speed<b> </b>test <a href="cppad_print_optimize.xml" target="_top">Speed Test Utility: Optimize Operation Sequences and Print Results</a><br/>
1835	6525	tape <a href="wishlist.xml#Optimization" target="_top">The CppAD Wish List: Optimization</a><br/>
1836		options<br/>
	6526	option <a href="atomic_mat_mul.cpp.xml#Use Atomic Function.option" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function.option</a><br/>
	6527	<a href="checkpoint.xml#option" target="_top">Checkpointing Functions: option</a><br/>
	6528	option<b>_</b>list <a href="speed_main.xml#option_list" target="_top">Running the Speed Test Program: option_list</a><br/>
	6529	options <a href="speed_main.xml#Sparsity Options" target="_top">Running the Speed Test Program: Sparsity Options</a><br/>
	6530	<a href="ipopt_solve.xml#options" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: options</a><br/>
	6531	<a href="atomic_option.xml" target="_top">Set Atomic Function Options</a><br/>
1837	6532	atomic <a href="atomic_option.xml" target="_top">Set Atomic Function Options</a><br/>
1838		order<br/>
	6533	or <a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
	6534	<a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
	6535	<a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
	6536	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	6537	<a href="jacobian.xml#Forward or Reverse" target="_top">Jacobian: Driver Routine: Forward or Reverse</a><br/>
	6538	<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
	6539	order <a href="old_mat_mul.hpp.xml#Reverse Partials One Order" target="_top">Define Matrix Multiply as a User Atomic Operation: Reverse Partials One Order</a><br/>
	6540	<a href="fundeprecated.xml#Order" target="_top">ADFun Object Deprecated Member Functions: Order</a><br/>
	6541	<a href="erf_reverse.xml#Order Zero Z(t)" target="_top">Error Function Reverse Mode Theory: Order Zero Z(t)</a><br/>
	6542	<a href="tan_reverse.xml#Order Zero Z(t)" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory: Order Zero Z(t)</a><br/>
	6543	<a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
	6544	<a href="odeerrcontrol.xml#Method.order" target="_top">An Error Controller for ODE Solvers: Method.order</a><br/>
	6545	<a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
	6546	<a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
	6547	<a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
	6548	<a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a><br/>
	6549	<a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
	6550	<a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a><br/>
	6551	<a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a><br/>
	6552	<a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a><br/>
	6553	<a href="reverse_any.xml#Second Order" target="_top">Any Order Reverse Mode: Second Order</a><br/>
	6554	<a href="reverse_any.xml#First Order" target="_top">Any Order Reverse Mode: First Order</a><br/>
	6555	<a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a><br/>
	6556	<a href="reverse_two.cpp.xml" target="_top">Second Order Reverse ModeExample and Test</a><br/>
	6557	<a href="reverse_two.xml#dw.Second Order Partials" target="_top">Second Order Reverse Mode: dw.Second Order Partials</a><br/>
	6558	<a href="reverse_two.xml#dw.First Order Partials" target="_top">Second Order Reverse Mode: dw.First Order Partials</a><br/>
	6559	<a href="reverse_two.xml" target="_top">Second Order Reverse Mode</a><br/>
	6560	<a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a><br/>
	6561	<a href="reverse_one.xml" target="_top">First Order Reverse Mode</a><br/>
	6562	<a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
	6563	<a href="forward_dir.xml#Zero Order" target="_top">Multiple Directions Forward Mode: Zero Order</a><br/>
	6564	<a href="forward_order.xml#Second Order" target="_top">Multiple Order Forward Mode: Second Order</a><br/>
	6565	<a href="forward_order.xml#First Order" target="_top">Multiple Order Forward Mode: First Order</a><br/>
	6566	<a href="forward_order.xml#Zero Order" target="_top">Multiple Order Forward Mode: Zero Order</a><br/>
	6567	<a href="forward_order.xml#yq.One Order" target="_top">Multiple Order Forward Mode: yq.One Order</a><br/>
	6568	<a href="forward_order.xml#xq.One Order" target="_top">Multiple Order Forward Mode: xq.One Order</a><br/>
	6569	<a href="forward_order.xml#One Order" target="_top">Multiple Order Forward Mode: One Order</a><br/>
	6570	<a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a><br/>
	6571	<a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a><br/>
	6572	<a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
	6573	<a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
	6574	<a href="base_complex.hpp.xml#Include Order" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Include Order</a><br/>
	6575	<a href="base_require.xml#Include Order" target="_top">AD<Base> Requirements for Base Type: Include Order</a><br/>
	6576	<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
	6577	<a href="exp_eps_rev2.cpp.xml" target="_top">exp_eps: Verify Second Order Reverse Sweep</a><br/>
	6578	<a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a><br/>
	6579	<a href="exp_eps_rev1.cpp.xml" target="_top">exp_eps: Verify First Order Reverse Sweep</a><br/>
	6580	<a href="exp_eps_for1.cpp.xml" target="_top">exp_eps: Verify First Order Forward Sweep</a><br/>
	6581	<a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a><br/>
	6582	<a href="exp_eps_rev2.xml" target="_top">exp_eps: Second Order Reverse Sweep</a><br/>
	6583	<a href="exp_eps_for2.xml#Second Order Expansion" target="_top">exp_eps: Second Order Forward Mode: Second Order Expansion</a><br/>
	6584	<a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a><br/>
	6585	<a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a><br/>
	6586	<a href="exp_eps_for1.xml#Operation Sequence.First Order" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence.First Order</a><br/>
	6587	<a href="exp_eps_for1.xml#Operation Sequence.Zero Order" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence.Zero Order</a><br/>
	6588	<a href="exp_eps_for1.xml#First Order Expansion" target="_top">exp_eps: First Order Forward Sweep: First Order Expansion</a><br/>
	6589	<a href="exp_eps_for1.xml" target="_top">exp_eps: First Order Forward Sweep</a><br/>
	6590	<a href="exp_eps_for0.xml#Operation Sequence.Zero Order" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence.Zero Order</a><br/>
	6591	<a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
	6592	<a href="exp_2_rev2.cpp.xml" target="_top">exp_2: Verify Second Order Reverse Sweep</a><br/>
	6593	<a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a><br/>
	6594	<a href="exp_2_rev1.cpp.xml" target="_top">exp_2: Verify First Order Reverse Sweep</a><br/>
	6595	<a href="exp_2_for1.cpp.xml" target="_top">exp_2: Verify First Order Forward Sweep</a><br/>
	6596	<a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a><br/>
	6597	<a href="exp_2_rev2.xml" target="_top">exp_2: Second Order Reverse Mode</a><br/>
	6598	<a href="exp_2_for2.xml#Second Order Expansion" target="_top">exp_2: Second Order Forward Mode: Second Order Expansion</a><br/>
	6599	<a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a><br/>
	6600	<a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a><br/>
	6601	<a href="exp_2_for1.xml#Operation Sequence.First Order" target="_top">exp_2: First Order Forward Mode: Operation Sequence.First Order</a><br/>
	6602	<a href="exp_2_for1.xml#Operation Sequence.Zero Order" target="_top">exp_2: First Order Forward Mode: Operation Sequence.Zero Order</a><br/>
	6603	<a href="exp_2_for1.xml#First Order Expansion" target="_top">exp_2: First Order Forward Mode: First Order Expansion</a><br/>
	6604	<a href="exp_2_for1.xml" target="_top">exp_2: First Order Forward Mode</a><br/>
	6605	<a href="exp_2_for0.xml#Operation Sequence.Zero Order" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Operation Sequence.Zero Order</a><br/>
	6606	<a href="exp_2_for0.xml#Zero Order Expansion" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion</a><br/>
	6607	<a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
	6608	<a href="exp_2.xml" target="_top">Second Order Exponential Approximation</a><br/>
	6609	any <a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a><br/>
1839	6610	first<b> </b>exp<b>_</b>2 <a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a><br/>
1840	6611	first<b> </b>exp<b>_</b>2 <a href="exp_eps_for1.cpp.xml" target="_top">exp_eps: Verify First Order Forward Sweep</a><br/>
1841	6612	first<b> </b>exp<b>_</b>2 <a href="exp_2_for1.cpp.xml" target="_top">exp_2: Verify First Order Forward Sweep</a><br/>

1844	6615	first<b> </b>forward <a href="exp_eps_for1.xml" target="_top">exp_eps: First Order Forward Sweep</a><br/>
1845	6616	first<b> </b>reverse <a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a><br/>
1846	6617	first<b> </b>reverse <a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a><br/>
1847		multiple<b> </b>forward <a href="forward_mul.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
1848		one<b> </b>Forward <a href="forwardone.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
	6618	multiple <a href="forward_order.xml" target="_top">Multiple Order Forward Mode</a><br/>
	6619	multiple<b> </b>forward <a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	6620	multiple<b> </b>forward <a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	6621	one<b> </b>Forward <a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
1849	6622	second<b> </b>exp<b>_</b>2 <a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a><br/>
1850	6623	second<b> </b>expansion <a href="exp_eps_for2.xml#Second Order Expansion" target="_top">exp_eps: Second Order Forward Mode: Second Order Expansion</a><br/>
1851	6624	second<b> </b>expansion <a href="exp_2_for2.xml#Second Order Expansion" target="_top">exp_2: Second Order Forward Mode: Second Order Expansion</a><br/>
1852	6625	second<b> </b>reverse <a href="exp_eps_rev2.xml" target="_top">exp_eps: Second Order Reverse Sweep</a><br/>
1853	6626	second<b> </b>reverse <a href="exp_2_rev2.xml" target="_top">exp_2: Second Order Reverse Mode</a><br/>
	6627	two<b> </b>Forward <a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a><br/>
1854	6628	zero<b> </b>exp<b>_</b>2 <a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a><br/>
1855	6629	zero<b> </b>exp<b>_</b>eps <a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a><br/>
1856	6630	zero<b> </b>expansion <a href="exp_2_for0.xml#Zero Order Expansion" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion</a><br/>
1857		zero<b> </b>Forward <a href="forwardzero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
	6631	zero<b> </b>Forward <a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
1858	6632	zero<b> </b>forward <a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
1859	6633	zero<b> </b>forward <a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
1860		other<br/>
	6634	ordered <a href="base_complex.hpp.xml#Ordered" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Ordered</a><br/>
	6635	<a href="base_double.hpp.xml#Ordered" target="_top">Enable use of AD<Base> where Base is double: Ordered</a><br/>
	6636	<a href="base_float.hpp.xml#Ordered" target="_top">Enable use of AD<Base> where Base is float: Ordered</a><br/>
	6637	<a href="base_adolc.hpp.xml#Ordered" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Ordered</a><br/>
	6638	<a href="base_alloc.hpp.xml#Ordered" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Ordered</a><br/>
	6639	<a href="base_ordered.xml#Not Ordered" target="_top">Base Type Requirements for Ordered Comparisons: Not Ordered</a><br/>
	6640	<a href="base_ordered.xml#Ordered Type" target="_top">Base Type Requirements for Ordered Comparisons: Ordered Type</a><br/>
	6641	<a href="base_ordered.xml" target="_top">Base Type Requirements for Ordered Comparisons</a><br/>
	6642	<a href="base_cond_exp.xml#CondExpTemplate.Not Ordered" target="_top">Base Type Requirements for Conditional Expressions: CondExpTemplate.Not Ordered</a><br/>
	6643	<a href="base_cond_exp.xml#CondExpTemplate.Ordered Type" target="_top">Base Type Requirements for Conditional Expressions: CondExpTemplate.Ordered Type</a><br/>
	6644	orders <a href="erf_reverse.xml#Positive Orders Z(t)" target="_top">Error Function Reverse Mode Theory: Positive Orders Z(t)</a><br/>
	6645	<a href="tan_reverse.xml#Positive Orders Z(t)" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory: Positive Orders Z(t)</a><br/>
	6646	<a href="size_order.xml" target="_top">Number Taylor Coefficient Orders Currently Stored</a><br/>
	6647	<a href="forward_dir.xml#Non-Zero Lower Orders" target="_top">Multiple Directions Forward Mode: Non-Zero Lower Orders</a><br/>
	6648	<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	6649	<a href="forward_order.xml#yq.Multiple Orders" target="_top">Multiple Order Forward Mode: yq.Multiple Orders</a><br/>
	6650	<a href="forward_order.xml#xq.Multiple Orders" target="_top">Multiple Order Forward Mode: xq.Multiple Orders</a><br/>
	6651	original <a href="capacity_order.xml#Original State" target="_top">Controlling Taylor Coefficients Memory Allocation: Original State</a><br/>
	6652	os <a href="ad_output.xml#os" target="_top">AD Output Stream Operator: os</a><br/>
	6653	other <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	6654	<a href="erf.xml#Method.Other" target="_top">The AD Error Function: Method.Other</a><br/>
	6655	<a href="mathother.xml" target="_top">Other AD Math Functions</a><br/>
1861	6656	AD<b> </b>math <a href="mathother.xml" target="_top">Other AD Math Functions</a><br/>
1862		output<br/>
	6657	out <a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
	6658	outer <a href="mul_level.xml#General Procedure.Derivative of Outer Function" target="_top">Using Multiple Levels of AD: General Procedure.Derivative of Outer Function</a><br/>
	6659	<a href="mul_level.xml#General Procedure.Outer Function" target="_top">Using Multiple Levels of AD: General Procedure.Outer Function</a><br/>
	6660	outline <a href="introduction.xml#Outline" target="_top">An Introduction by Example to Algorithmic Differentiation: Outline</a><br/>
	6661	output <a href="cppad_vector.xml#vectorBool.Output" target="_top">The CppAD::vector Template Class: vectorBool.Output</a><br/>
	6662	<a href="cppad_vector.xml#Output" target="_top">The CppAD::vector Template Class: Output</a><br/>
	6663	<a href="speed_program.cpp.xml#Output" target="_top">Example Use of SpeedTest: Output</a><br/>
	6664	<a href="base_alloc.hpp.xml#Output Operator" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Output Operator</a><br/>
	6665	<a href="base_require.xml#Output Operator" target="_top">AD<Base> Requirements for Base Type: Output Operator</a><br/>
	6666	<a href="print_for_cout.cpp.xml#Output" target="_top">Printing During Forward Mode: Example and Test: Output</a><br/>
	6667	<a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	6668	<a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	6669	<a href="ad_output.xml" target="_top">AD Output Stream Operator</a><br/>
	6670	<a href="ad_input.xml" target="_top">AD Output Stream Operator</a><br/>
	6671	<a href="get_started.cpp.xml#Output" target="_top">Getting Started Using CppAD to Compute Derivatives: Output</a><br/>
1863	6672	AD <a href="ad_output.xml" target="_top">AD Output Stream Operator</a><br/>
1864	6673	AD<b> </b>example <a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
1865	6674	base<b> </b>operator <a href="base_require.xml#Output Operator" target="_top">AD<Base> Requirements for Base Type: Output Operator</a><br/>
1866	6675	text <a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
	6676	overloading <a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
	6677	own <a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
1867	6678
1868	6679	<b><big><a name="P">P</a></big></b>
1869	6680	<br/>

1873	6684	example <a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
1874	6685	Poly <a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
1875	6686	source <a href="poly.hpp.xml" target="_top">Source: Poly</a><br/>
1876		package<br/>
	6687	p <a href="sparse_hes_fun.xml#p" target="_top">Evaluate a Function That Has a Sparse Hessian: p</a><br/>
	6688	<a href="sparse_jac_fun.xml#p" target="_top">Evaluate a Function That Has a Sparse Jacobian: p</a><br/>
	6689	<a href="ode_evaluate.xml#p.p = 1" target="_top">Evaluate a Function Defined in Terms of an ODE: p.p = 1</a><br/>
	6690	<a href="ode_evaluate.xml#p.p == 0" target="_top">Evaluate a Function Defined in Terms of an ODE: p.p == 0</a><br/>
	6691	<a href="ode_evaluate.xml#p" target="_top">Evaluate a Function Defined in Terms of an ODE: p</a><br/>
	6692	<a href="luratio.xml#LU.P" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU.P</a><br/>
	6693	<a href="rombergmul.xml#p" target="_top">Multi-dimensional Romberg Integration: p</a><br/>
	6694	<a href="rombergone.xml#p" target="_top">One DimensionalRomberg Integration: p</a><br/>
	6695	<a href="luinvert.xml#LU.P" target="_top">Invert an LU Factored Equation: LU.P</a><br/>
	6696	<a href="lufactor.xml#LU.P" target="_top">LU Factorization of A Square Matrix: LU.P</a><br/>
	6697	<a href="poly.xml#p" target="_top">Evaluate a Polynomial or its Derivative: p</a><br/>
	6698	<a href="sparse_hessian.xml#p" target="_top">Sparse Hessian: Easy Driver: p</a><br/>
	6699	<a href="sparse_jacobian.xml#p" target="_top">Sparse Jacobian: Easy Driver: p</a><br/>
	6700	<a href="atomic_forward.xml#p" target="_top">Atomic Forward Mode: p</a><br/>
	6701	package <a href="speed_main.xml#package.AD Package" target="_top">Running the Speed Test Program: package.AD Package</a><br/>
	6702	<a href="speed_main.xml#package" target="_top">Running the Speed Test Program: package</a><br/>
	6703	<a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
	6704	<a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
	6705	<a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
1877	6706	prefix <a href="cmake.xml#package_prefix" target="_top">Using CMake to Configure CppAD: package_prefix</a><br/>
1878		parallel<br/>
	6707	package<b>_</b>prefix <a href="cmake.xml#package_prefix" target="_top">Using CMake to Configure CppAD: package_prefix</a><br/>
	6708	pairs <a href="wishlist.xml#Optimization.Variable Pairs" target="_top">The CppAD Wish List: Optimization.Variable Pairs</a><br/>
	6709	parallel <a href="old_atomic.xml#afun.Parallel Mode" target="_top">User Defined Atomic AD Functions: afun.Parallel Mode</a><br/>
	6710	<a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
	6711	<a href="omp_max_thread.xml" target="_top">OpenMP Parallel Setup</a><br/>
	6712	<a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
	6713	<a href="cppad_vector.xml#Memory and Parallel Mode" target="_top">The CppAD::vector Template Class: Memory and Parallel Mode</a><br/>
	6714	<a href="rosen34.xml#Parallel Mode" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Parallel Mode</a><br/>
	6715	<a href="runge45.xml#Parallel Mode" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Parallel Mode</a><br/>
	6716	<a href="checksimplevector.xml#Parallel Mode" target="_top">Check Simple Vector Concept: Parallel Mode</a><br/>
	6717	<a href="checknumerictype.xml#Parallel Mode" target="_top">Check NumericType Class Concept: Parallel Mode</a><br/>
	6718	<a href="errorhandler.xml#Constructor.Parallel Mode" target="_top">Replacing the CppAD Error Handler: Constructor.Parallel Mode</a><br/>
	6719	<a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
	6720	<a href="parallel_ad.xml" target="_top">Enable AD Calculations During Parallel Mode</a><br/>
	6721	<a href="multi_thread.xml#Parallel Prohibited" target="_top">Using CppAD in a Multi-Threading Environment: Parallel Prohibited</a><br/>
	6722	<a href="multi_thread.xml#Parallel AD" target="_top">Using CppAD in a Multi-Threading Environment: Parallel AD</a><br/>
	6723	<a href="dependent.xml#Parallel Mode" target="_top">Stop Recording and Store Operation Sequence: Parallel Mode</a><br/>
	6724	<a href="funconstruct.xml#Parallel Mode" target="_top">Construct an ADFun Object and Stop Recording: Parallel Mode</a><br/>
	6725	<a href="independent.xml#Parallel Mode" target="_top">Declare Independent Variables and Start Recording: Parallel Mode</a><br/>
	6726	<a href="discrete.xml#Parallel Mode" target="_top">Discrete AD Functions: Parallel Mode</a><br/>
1879	6727	ADFun <a href="funconstruct.xml#Parallel Mode" target="_top">Construct an ADFun Object and Stop Recording: Parallel Mode</a><br/>
1880	6728	CheckNumericType <a href="checknumerictype.xml#Parallel Mode" target="_top">Check NumericType Class Concept: Parallel Mode</a><br/>
1881	6729	CheckSimpleVector <a href="checksimplevector.xml#Parallel Mode" target="_top">Check Simple Vector Concept: Parallel Mode</a><br/>

1889	6737	Rosen34 <a href="rosen34.xml#Parallel Mode" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Parallel Mode</a><br/>
1890	6738	Runge45 <a href="runge45.xml#Parallel Mode" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Parallel Mode</a><br/>
1891	6739	setup <a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
1892		parameter <a href="glossary.xml#Parameter" target="_top">Glossary: Parameter</a><br/>
	6740	parallel<b>_</b>setup <a href="multi_thread.xml#parallel_setup" target="_top">Using CppAD in a Multi-Threading Environment: parallel_setup</a><br/>
	6741	parameter <a href="ipopt_nlp_ode_problem.xml#Measurements.Simulation Parameter Values" target="_top">An ODE Inverse Problem Example: Measurements.Simulation Parameter Values</a><br/>
	6742	<a href="glossary.xml#Parameter" target="_top">Glossary: Parameter</a><br/>
	6743	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements.Simulation Parameter Values" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements.Simulation Parameter Values</a><br/>
	6744	<a href="seq_property.xml#Parameter" target="_top">ADFun Sequence Properties: Parameter</a><br/>
	6745	<a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
	6746	<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
	6747	<a href="atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Test with x_1 Both a Variable and a Parameter</a><br/>
	6748	<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
	6749	<a href="exp_eps_for0.xml#Operation Sequence.Parameter" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence.Parameter</a><br/>
1893	6750	convert<b> </b>from<b> </b>variable <a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
1894		partial<br/>
	6751	parameter<b>:</b> <a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	6752	partial <a href="old_atomic.xml#Partial Implementation" target="_top">User Defined Atomic AD Functions: Partial Implementation</a><br/>
	6753	<a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
	6754	<a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
	6755	<a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a><br/>
	6756	<a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a><br/>
1895	6757	easy <a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
1896	6758	easy <a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
1897	6759	easy <a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a><br/>

1901	6763	second <a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
1902	6764	second<b> </b>order<b> </b>driver <a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
1903	6765	second<b> </b>order<b> </b>driver <a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
	6766	partials <a href="old_mat_mul.hpp.xml#Reverse Partials One Order" target="_top">Define Matrix Multiply as a User Atomic Operation: Reverse Partials One Order</a><br/>
	6767	<a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a><br/>
	6768	<a href="reverse_two.xml#dw.Second Order Partials" target="_top">Second Order Reverse Mode: dw.Second Order Partials</a><br/>
	6769	<a href="reverse_two.xml#dw.First Order Partials" target="_top">Second Order Reverse Mode: dw.First Order Partials</a><br/>
	6770	partials<b>:</b> <a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
1904	6771	pattern <a href="glossary.xml#Sparsity Pattern" target="_top">Glossary: Sparsity Pattern</a><br/>
	6772	<a href="revsparsehes.xml#Entire Sparsity Pattern" target="_top">Hessian Sparsity Pattern: Reverse Mode: Entire Sparsity Pattern</a><br/>
	6773	<a href="revsparsejac.xml#Entire Sparsity Pattern" target="_top">Jacobian Sparsity Pattern: Reverse Mode: Entire Sparsity Pattern</a><br/>
	6774	<a href="forsparsejac.xml#Entire Sparsity Pattern" target="_top">Jacobian Sparsity Pattern: Forward Mode: Entire Sparsity Pattern</a><br/>
1905	6775	forward<b> </b>Jacobian <a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a><br/>
1906	6776	reverse<b> </b>Hessian <a href="revsparsehes.xml" target="_top">Hessian Sparsity Pattern: Reverse Mode</a><br/>
1907	6777	reverse<b> </b>Jacobian <a href="revsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Reverse Mode</a><br/>
1908	6778	sparsity <a href="glossary.xml#Sparsity Pattern" target="_top">Glossary: Sparsity Pattern</a><br/>
1909	6779	sparsity <a href="sparse.xml" target="_top">Calculating Sparsity Patterns</a><br/>
	6780	pattern<b>:</b> <a href="revsparsehes.xml" target="_top">Hessian Sparsity Pattern: Reverse Mode</a><br/>
	6781	<a href="revsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Reverse Mode</a><br/>
	6782	<a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a><br/>
	6783	patterns <a href="sparse.xml" target="_top">Calculating Sparsity Patterns</a><br/>
	6784	<a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a><br/>
	6785	<a href="funconstruct.xml#Assignment Operator.Sparsity Patterns" target="_top">Construct an ADFun Object and Stop Recording: Assignment Operator.Sparsity Patterns</a><br/>
	6786	<a href="atomic_rev_sparse_hes.xml" target="_top">Atomic Reverse Hessian Sparsity Patterns</a><br/>
	6787	<a href="atomic_rev_sparse_jac.xml" target="_top">Atomic Reverse Jacobian Sparsity Patterns</a><br/>
	6788	<a href="atomic_for_sparse_jac.xml" target="_top">Atomic Forward Jacobian Sparsity Patterns</a><br/>
	6789	<a href="atomic_base.xml#Examples.Hessian Sparsity Patterns" target="_top">User Defined Atomic AD Functions: Examples.Hessian Sparsity Patterns</a><br/>
1910	6790	pc<br/>
1911	6791	pkg<b>-</b>config <a href="pkgconfig.xml" target="_top">CppAD pkg-config Files</a><br/>
1912		pkg<b>-</b>config<br/>
	6792	pivoting <a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
	6793	pivoting<b>:</b> <a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	6794	pkg<b>-</b>config <a href="pkgconfig.xml" target="_top">CppAD pkg-config Files</a><br/>
1913	6795	files <a href="pkgconfig.xml" target="_top">CppAD pkg-config Files</a><br/>
1914		plus<br/>
	6796	plus <a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a><br/>
	6797	<a href="unaryplus.xml" target="_top">AD Unary Plus Operator</a><br/>
1915	6798	<b>*= </b>example <a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
1916	6799	<b>+= </b>example <a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
1917	6800	<b>-= </b>example <a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>

1920	6803	AD<b> </b>unary<b> </b>operator <a href="unaryplus.xml" target="_top">AD Unary Plus Operator</a><br/>
1921	6804	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
1922	6805	computed<b> </b>assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
1923		polynomial <a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
	6806	poly <a href="poly.hpp.xml" target="_top">Source: Poly</a><br/>
	6807	<a href="not_complex_ad.cpp.xml#Poly" target="_top">Not Complex Differentiable: Example and Test: Poly</a><br/>
	6808	<a href="complex_poly.cpp.xml#Poly" target="_top">Complex Polynomial: Example and Test: Poly</a><br/>
	6809	<a href="get_started.cpp.xml#Poly" target="_top">Getting Started Using CppAD to Compute Derivatives: Poly</a><br/>
	6810	polynomial <a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a><br/>
	6811	<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
	6812	<a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a><br/>
	6813	<a href="asinforward.xml" target="_top">Arcsine Function Forward Taylor Polynomial Theory</a><br/>
	6814	<a href="atanforward.xml" target="_top">Arctangent Function Forward Taylor Polynomial Theory</a><br/>
	6815	<a href="sqrtforward.xml" target="_top">Square Root Function Forward Taylor Polynomial Theory</a><br/>
	6816	<a href="logforward.xml" target="_top">Logarithm Function Forward Taylor Polynomial Theory</a><br/>
	6817	<a href="expforward.xml" target="_top">Exponential Function Forward Taylor Polynomial Theory</a><br/>
	6818	<a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
	6819	<a href="fadbad_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
	6820	<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
	6821	<a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>
	6822	<a href="double_poly.cpp.xml" target="_top">Double Speed: Evaluate a Polynomial</a><br/>
	6823	<a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
	6824	<a href="poly.cpp.xml" target="_top">Polynomial Evaluation: Example and Test</a><br/>
	6825	<a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
	6826	<a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
1924	6827	complex <a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
1925	6828	complex <a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
1926	6829	example <a href="poly.cpp.xml" target="_top">Polynomial Evaluation: Example and Test</a><br/>

1930	6833	speed<b> </b>fadbad <a href="fadbad_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
1931	6834	speed<b> </b>sacado <a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
1932	6835	speed<b> </b>test <a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
	6836	polynomial<b>:</b> <a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
	6837	pos <a href="printfor.xml#pos" target="_top">Printing AD Values During Forward Mode: pos</a><br/>
	6838	positive <a href="erf_reverse.xml#Positive Orders Z(t)" target="_top">Error Function Reverse Mode Theory: Positive Orders Z(t)</a><br/>
	6839	<a href="tan_reverse.xml#Positive Orders Z(t)" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory: Positive Orders Z(t)</a><br/>
1933	6840	postfix<br/>
1934		configure<b> </b>directory <a href="installunix.xml#postfix_dir" target="_top">Unix Test and Installation: postfix_dir</a><br/>
	6841	configure<b> </b>directory <a href="installunix.xml#postfix_dir" target="_top">Deprecated Unix Test and Installation: postfix_dir</a><br/>
1935	6842	install <a href="cmake.xml#cmake_install_postfix" target="_top">Using CMake to Configure CppAD: cmake_install_postfix</a><br/>
1936		pow<br/>
	6843	postfix<b>_</b>dir <a href="installunix.xml#postfix_dir" target="_top">Deprecated Unix Test and Installation: postfix_dir</a><br/>
	6844	pow <a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a><br/>
	6845	<a href="base_complex.hpp.xml#pow" target="_top">Enable use of AD<Base> where Base is std::complex<double>: pow</a><br/>
	6846	<a href="base_double.hpp.xml#pow" target="_top">Enable use of AD<Base> where Base is double: pow</a><br/>
	6847	<a href="base_float.hpp.xml#pow" target="_top">Enable use of AD<Base> where Base is float: pow</a><br/>
	6848	<a href="base_adolc.hpp.xml#pow" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: pow</a><br/>
	6849	<a href="base_alloc.hpp.xml#pow" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: pow</a><br/>
	6850	<a href="base_std_math.xml#pow" target="_top">Base Type Requirements for Standard Math Functions: pow</a><br/>
1937	6851	AD <a href="pow.xml" target="_top">The AD Power Function</a><br/>
1938	6852	AD<b> </b>example <a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a><br/>
1939	6853	base<b> </b>require <a href="base_std_math.xml#pow" target="_top">Base Type Requirements for Standard Math Functions: pow</a><br/>
1940	6854	int <a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a><br/>
1941	6855	integer <a href="pow_int.xml" target="_top">The Integer Power Function</a><br/>
1942		prefix<br/>
	6856	power <a href="pow_int.xml" target="_top">The Integer Power Function</a><br/>
	6857	<a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a><br/>
	6858	<a href="pow.xml" target="_top">The AD Power Function</a><br/>
	6859	pre<b>-</b>allocating <a href="capacity_order.xml#c.Pre-Allocating Memory" target="_top">Controlling Taylor Coefficients Memory Allocation: c.Pre-Allocating Memory</a><br/>
	6860	preface <a href="introduction.xml#Preface" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface</a><br/>
	6861	prefix <a href="get_sacado.sh.xml#Prefix Directory" target="_top">Download and Install Sacado in Build Directory: Prefix Directory</a><br/>
	6862	<a href="get_ipopt.sh.xml#Prefix Directory" target="_top">Download and Install Ipopt in Build Directory: Prefix Directory</a><br/>
	6863	<a href="get_fadbad.sh.xml#Prefix Directory" target="_top">Download and Install Fadbad in Build Directory: Prefix Directory</a><br/>
	6864	<a href="get_eigen.sh.xml#Prefix Directory" target="_top">Download and Install Eigen in Build Directory: Prefix Directory</a><br/>
	6865	<a href="get_colpack.sh.xml#Prefix Directory" target="_top">Download and Install ColPack in Build Directory: Prefix Directory</a><br/>
	6866	<a href="get_adolc.sh.xml#Prefix Directory" target="_top">Download and Install Adolc in Build Directory: Prefix Directory</a><br/>
1943	6867	adolc <a href="adolc_prefix.xml#adolc_prefix" target="_top">Including the ADOL-C Examples and Tests: adolc_prefix</a><br/>
1944		configure<b> </b>directory <a href="installunix.xml#prefix_dir" target="_top">Unix Test and Installation: prefix_dir</a><br/>
	6868	colpack <a href="colpack_prefix.xml#colpack_prefix" target="_top">Including the ColPack Sparsity Calculations: colpack_prefix</a><br/>
	6869	configure<b> </b>directory <a href="installunix.xml#prefix_dir" target="_top">Deprecated Unix Test and Installation: prefix_dir</a><br/>
1945	6870	eigen <a href="eigen_prefix.xml#eigen_prefix" target="_top">Including the Eigen Examples and Tests: eigen_prefix</a><br/>
1946	6871	fadbad <a href="fadbad_prefix.xml#fadbad_prefix" target="_top">Including the FADBAD Speed Tests: fadbad_prefix</a><br/>
1947	6872	install <a href="cmake.xml#cmake_install_prefix" target="_top">Using CMake to Configure CppAD: cmake_install_prefix</a><br/>
1948	6873	ipopt <a href="ipopt_prefix.xml#ipopt_prefix" target="_top">Including the cppad_ipopt Library and Tests: ipopt_prefix</a><br/>
1949	6874	package <a href="cmake.xml#package_prefix" target="_top">Using CMake to Configure CppAD: package_prefix</a><br/>
1950	6875	sacado <a href="sacado_prefix.xml#sacado_prefix" target="_top">Including the Sacado Speed Tests: sacado_prefix</a><br/>
	6876	prefix<b>_</b>dir <a href="installunix.xml#prefix_dir" target="_top">Deprecated Unix Test and Installation: prefix_dir</a><br/>
1951	6877	preprocessor <a href="wishlist.xml#Preprocessor Symbols" target="_top">The CppAD Wish List: Preprocessor Symbols</a><br/>
	6878	<a href="wishlist.xml#Preprocessor Symbols" target="_top">The CppAD Wish List: Preprocessor Symbols</a><br/>
	6879	<a href="faq.xml#Namespace.Test Vector Preprocessor Symbol" target="_top">Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol</a><br/>
	6880	<a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a><br/>
	6881	<a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
1952	6882	CPPAD<b>_ </b>symbol <a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a><br/>
1953		symbol<b> </b>CppAD <a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
	6883	symbol<b> </b>CppAD <a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
1954	6884	symbols <a href="faq.xml#Namespace.Test Vector Preprocessor Symbol" target="_top">Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol</a><br/>
1955		print<br/>
	6885	previous <a href="whats_new.xml#Previous Years" target="_top">Changes and Additions to CppAD: Previous Years</a><br/>
	6886	previously <a href="tracknewdel.xml#TrackCount.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackCount.Previously Deprecated</a><br/>
	6887	<a href="tracknewdel.xml#TrackExtend.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackExtend.Previously Deprecated</a><br/>
	6888	<a href="tracknewdel.xml#TrackDelVec.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackDelVec.Previously Deprecated</a><br/>
	6889	<a href="tracknewdel.xml#TrackNewVec.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackNewVec.Previously Deprecated</a><br/>
	6890	print <a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
	6891	<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
1956	6892	example<b> </b>forward<b> </b>mode <a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
1957	6893	forward<b> </b>mode <a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
1958	6894	zero<b> </b>order<b> </b>forward <a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
1959		print<b>_</b>optimize<br/>
1960		cppad<b> </b>speed<b> </b>test <a href="cppad_print_optimize.xml" target="_top">Speed Test Utility: Optimize Operation Sequences and Print Results</a><br/>
1961		problem<br/>
	6895	printing <a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
	6896	<a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
	6897	problem <a href="ipopt_nlp_ode_problem.hpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	6898	<a href="ipopt_nlp_ode_problem.xml#Inverse Problem" target="_top">An ODE Inverse Problem Example: Inverse Problem</a><br/>
	6899	<a href="ipopt_nlp_ode_problem.xml#Forward Problem" target="_top">An ODE Inverse Problem Example: Forward Problem</a><br/>
	6900	<a href="ipopt_nlp_ode_problem.xml" target="_top">An ODE Inverse Problem Example</a><br/>
	6901	<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
	6902	<a href="ipopt_solve_ode_inverse.cpp.xml#Inverse Problem" target="_top">ODE Inverse Problem Definitions: Source Code: Inverse Problem</a><br/>
	6903	<a href="ipopt_solve_ode_inverse.cpp.xml#Forward Problem" target="_top">ODE Inverse Problem Definitions: Source Code: Forward Problem</a><br/>
	6904	<a href="ipopt_solve_ode_inverse.cpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	6905	<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
	6906	<a href="benderquad.xml#Problem" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: Problem</a><br/>
1962	6907	using<b> </b>CppAD <a href="bugs.xml" target="_top">Know Bugs and Problems Using CppAD</a><br/>
1963		profile<br/>
1964		cppad<b> </b>speed <a href="installunix.xml#Profiling CppAD" target="_top">Unix Test and Installation: Profiling CppAD</a><br/>
1965		program<br/>
	6908	problems <a href="bugs.xml" target="_top">Know Bugs and Problems Using CppAD</a><br/>
	6909	procedure <a href="mul_level.xml#General Procedure" target="_top">Using Multiple Levels of AD: General Procedure</a><br/>
	6910	processing <a href="reverse_any.cpp.xml#Processing Steps" target="_top">Reverse Mode General Case: Example and Test: Processing Steps</a><br/>
	6911	profile <a href="speed_main.xml#package.profile" target="_top">Running the Speed Test Program: package.profile</a><br/>
	6912	cppad<b> </b>speed <a href="installunix.xml#Profiling CppAD" target="_top">Deprecated Unix Test and Installation: Profiling CppAD</a><br/>
	6913	profiling <a href="installunix.xml#Profiling CppAD" target="_top">Deprecated Unix Test and Installation: Profiling CppAD</a><br/>
	6914	program <a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
	6915	<a href="speed_utility.xml#Speed Main Program" target="_top">Speed Testing Utilities: Speed Main Program</a><br/>
	6916	<a href="speed_main.xml" target="_top">Running the Speed Test Program</a><br/>
	6917	<a href="speed_program.cpp.xml#Program" target="_top">Example Use of SpeedTest: Program</a><br/>
	6918	<a href="speed_program.cpp.xml#Running This Program" target="_top">Example Use of SpeedTest: Running This Program</a><br/>
	6919	<a href="get_started.cpp.xml#Program" target="_top">Getting Started Using CppAD to Compute Derivatives: Program</a><br/>
	6920	<a href="cmake.xml#The CMake Program" target="_top">Using CMake to Configure CppAD: The CMake Program</a><br/>
1966	6921	speed<b> </b>example <a href="speed_example.cpp.xml" target="_top">Run the Speed Examples</a><br/>
1967		programming<br/>
	6922	programming <a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	6923	<a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
	6924	<a href="bib.xml#The C++ Programming Language" target="_top">Bibliography: The C++ Programming Language</a><br/>
	6925	<a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a><br/>
	6926	<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	6927	<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
1968	6928	nonlinear <a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
1969	6929	nonlinear<b> </b>example <a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
1970	6930	nonlinear<b> </b>example <a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
1971		pthread<br/>
	6931	prohibited <a href="multi_thread.xml#Parallel Prohibited" target="_top">Using CppAD in a Multi-Threading Environment: Parallel Prohibited</a><br/>
	6932	projection <a href="cppad_ipopt_nlp.xml#fg(x).Projection" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg(x).Projection</a><br/>
	6933	proof <a href="reverse_identity.xml#Proof" target="_top">An Important Reverse Mode Identity: Proof</a><br/>
	6934	properties <a href="seq_property.xml" target="_top">ADFun Sequence Properties</a><br/>
	6935	properties<b>:</b> <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
	6936	prototype <a href="link_sparse_jacobian.xml#Prototype" target="_top">Speed Testing Sparse Jacobian: Prototype</a><br/>
	6937	<a href="link_sparse_hessian.xml#Prototype" target="_top">Speed Testing Sparse Hessian: Prototype</a><br/>
	6938	<a href="link_poly.xml#Prototype" target="_top">Speed Testing Second Derivative of a Polynomial: Prototype</a><br/>
	6939	<a href="link_ode.xml#Prototype" target="_top">Speed Testing the Jacobian of Ode Solution: Prototype</a><br/>
	6940	<a href="link_mat_mul.xml#Prototype" target="_top">Speed Testing Derivative of Matrix Multiply: Prototype</a><br/>
	6941	<a href="link_det_minor.xml#Prototype" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: Prototype</a><br/>
	6942	<a href="link_det_lu.xml#Prototype" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: Prototype</a><br/>
	6943	prototypes <a href="base_identical.xml#Identical.Prototypes" target="_top">Base Type Requirements for Identically Equal Comparisons: Identical.Prototypes</a><br/>
	6944	pthread <a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
	6945	<a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
	6946	<a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
1972	6947	AD<b> </b>team <a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
1973	6948	memory<b> </b>allocation <a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
1974	6949	run<b> </b>tests <a href="thread_test.cpp.xml#Running Tests.threading" target="_top">Run Multi-Threading Examples and Speed Tests: Running Tests.threading</a><br/>
1975	6950	simple<b> </b>AD <a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
1976	6951	pthread<b>_</b>exit<br/>
1977	6952	bug<b> </b>in<b> </b>cygwin <a href="team_pthread.cpp.xml#Bug in Cygwin" target="_top">Pthread Implementation of a Team of AD Threads: Bug in Cygwin</a><br/>
1978		push<b>_</b>back<br/>
	6953	purpose <a href="time_det_by_minor_c.xml#Purpose" target="_top">Determine Amount of Time to Execute det_by_minor: Purpose</a><br/>
	6954	<a href="elapsed_seconds_c.xml#Purpose" target="_top">Returns Elapsed Number of Seconds: Purpose</a><br/>
	6955	<a href="uniform_01_c.xml#Purpose" target="_top">Simulate a [0,1] Uniform Random Variate: Purpose</a><br/>
	6956	<a href="det_by_minor_c.xml#Purpose" target="_top">Compute Determinant using Expansion by Minors: Purpose</a><br/>
	6957	<a href="det_of_minor_c.xml#Purpose" target="_top">Determinant of a Minor: Purpose</a><br/>
	6958	<a href="compare_c.xml#Purpose" target="_top">Compare Speed of C and C++: Purpose</a><br/>
	6959	<a href="old_usead_2.cpp.xml#Purpose" target="_top">Using AD to Compute Atomic Function Derivatives: Purpose</a><br/>
	6960	<a href="old_usead_1.cpp.xml#Purpose" target="_top">Using AD to Compute Atomic Function Derivatives: Purpose</a><br/>
	6961	<a href="old_atomic.xml#Purpose" target="_top">User Defined Atomic AD Functions: Purpose</a><br/>
	6962	<a href="ipopt_nlp_ode_fast.xml#Purpose" target="_top">ODE Fitting Using Fast Representation: Purpose</a><br/>
	6963	<a href="ipopt_nlp_ode_simple.xml#Purpose" target="_top">ODE Fitting Using Simple Representation: Purpose</a><br/>
	6964	<a href="ipopt_nlp_get_started.cpp.xml#Purpose" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test: Purpose</a><br/>
	6965	<a href="cppad_ipopt_nlp.xml#Purpose" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: Purpose</a><br/>
	6966	<a href="epsilon.xml#Purpose" target="_top">Machine Epsilon For AD Types: Purpose</a><br/>
	6967	<a href="memory_leak.xml#Purpose" target="_top">Memory Leak Detection: Purpose</a><br/>
	6968	<a href="old_max_num_threads.xml#Purpose" target="_top">Set Maximum Number of Threads for omp_alloc Allocator: Purpose</a><br/>
	6969	<a href="omp_efficient.xml#Purpose" target="_top">Check If A Memory Allocation is Efficient for Another Use: Purpose</a><br/>
	6970	<a href="omp_delete_array.xml#Purpose" target="_top">Return A Raw Array to The Available Memory for a Thread: Purpose</a><br/>
	6971	<a href="omp_create_array.xml#Purpose" target="_top">Allocate Memory and Create A Raw Array: Purpose</a><br/>
	6972	<a href="omp_available.xml#Purpose" target="_top">Amount of Memory Available for Quick Use by a Thread: Purpose</a><br/>
	6973	<a href="omp_inuse.xml#Purpose" target="_top">Amount of Memory a Thread is Currently Using: Purpose</a><br/>
	6974	<a href="omp_free_available.xml#Purpose" target="_top">Free Memory Currently Available for Quick Use by a Thread: Purpose</a><br/>
	6975	<a href="omp_return_memory.xml#Purpose" target="_top">Return Memory to omp_alloc: Purpose</a><br/>
	6976	<a href="omp_get_memory.xml#Purpose" target="_top">Get At Least A Specified Amount of Memory: Purpose</a><br/>
	6977	<a href="omp_get_thread_num.xml#Purpose" target="_top">Get the Current OpenMP Thread Number: Purpose</a><br/>
	6978	<a href="omp_in_parallel.xml#Purpose" target="_top">Is The Current Execution in OpenMP Parallel Mode: Purpose</a><br/>
	6979	<a href="omp_max_num_threads.xml#Purpose" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator: Purpose</a><br/>
	6980	<a href="omp_alloc.xml#Purpose" target="_top">A Quick OpenMP Memory Allocator Used by CppAD: Purpose</a><br/>
	6981	<a href="tracknewdel.xml#Purpose" target="_top">Routines That Track Use of New and Delete: Purpose</a><br/>
	6982	<a href="omp_max_thread.xml#Purpose" target="_top">OpenMP Parallel Setup: Purpose</a><br/>
	6983	<a href="fundeprecated.xml#Purpose" target="_top">ADFun Object Deprecated Member Functions: Purpose</a><br/>
	6984	<a href="include_deprecated.xml#Purpose" target="_top">Deprecated Include Files: Purpose</a><br/>
	6985	<a href="speed_sacado.xml#Purpose" target="_top">Speed Test Derivatives Using Sacado: Purpose</a><br/>
	6986	<a href="speed_fadbad.xml#Purpose" target="_top">Speed Test Derivatives Using Fadbad: Purpose</a><br/>
	6987	<a href="speed_cppad.xml#Purpose" target="_top">Speed Test Derivatives Using CppAD: Purpose</a><br/>
	6988	<a href="adolc_alloc_mat.xml#Purpose" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix: Purpose</a><br/>
	6989	<a href="speed_adolc.xml#Purpose" target="_top">Speed Test of Derivatives Using Adolc: Purpose</a><br/>
	6990	<a href="speed_double.xml#Purpose" target="_top">Speed Test of Functions in Double: Purpose</a><br/>
	6991	<a href="uniform_01.xml#Purpose" target="_top">Simulate a [0,1] Uniform Random Variate: Purpose</a><br/>
	6992	<a href="sparse_hes_fun.xml#Purpose" target="_top">Evaluate a Function That Has a Sparse Hessian: Purpose</a><br/>
	6993	<a href="sparse_jac_fun.xml#Purpose" target="_top">Evaluate a Function That Has a Sparse Jacobian: Purpose</a><br/>
	6994	<a href="ode_evaluate.xml#Purpose" target="_top">Evaluate a Function Defined in Terms of an ODE: Purpose</a><br/>
	6995	<a href="mat_sum_sq.xml#Purpose" target="_top">Sum Elements of a Matrix Times Itself: Purpose</a><br/>
	6996	<a href="det_grad_33.xml#Purpose" target="_top">Check Gradient of Determinant of 3 by 3 matrix: Purpose</a><br/>
	6997	<a href="det_33.xml#Purpose" target="_top">Check Determinant of 3 by 3 matrix: Purpose</a><br/>
	6998	<a href="det_of_minor.xml#Purpose" target="_top">Determinant of a Minor: Purpose</a><br/>
	6999	<a href="microsoft_timer.xml#Purpose" target="_top">Microsoft Version of Elapsed Number of Seconds: Purpose</a><br/>
	7000	<a href="link_poly.xml#Purpose" target="_top">Speed Testing Second Derivative of a Polynomial: Purpose</a><br/>
	7001	<a href="link_ode.xml#Purpose" target="_top">Speed Testing the Jacobian of Ode Solution: Purpose</a><br/>
	7002	<a href="link_mat_mul.xml#Purpose" target="_top">Speed Testing Derivative of Matrix Multiply: Purpose</a><br/>
	7003	<a href="link_det_minor.xml#Purpose" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: Purpose</a><br/>
	7004	<a href="link_det_lu.xml#Purpose" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: Purpose</a><br/>
	7005	<a href="speed_main.xml#Purpose" target="_top">Running the Speed Test Program: Purpose</a><br/>
	7006	<a href="speed.xml#Purpose" target="_top">Speed Test an Operator Overloading AD Package: Purpose</a><br/>
	7007	<a href="lu_vec_ad.cpp.xml#Purpose" target="_top">Lu Factor and Solve with Recorded Pivoting: Purpose</a><br/>
	7008	<a href="ode_taylor.cpp.xml#Purpose" target="_top">Taylor's Ode Solver: An Example and Test: Purpose</a><br/>
	7009	<a href="mul_level_adolc_ode.cpp.xml#Purpose" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Purpose</a><br/>
	7010	<a href="mul_level_ode.cpp.xml#Purpose" target="_top">Taylor's Ode Solver: An Example and Test: Purpose</a><br/>
	7011	<a href="change_const.cpp.xml#Purpose" target="_top">Computing a Jacobian With Constants that Change: Purpose</a><br/>
	7012	<a href="mul_level.cpp.xml#Purpose" target="_top">Multiple Tapes: Example and Test: Purpose</a><br/>
	7013	<a href="cppad_eigen.hpp.xml#Purpose" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: Purpose</a><br/>
	7014	<a href="conj_grad.cpp.xml#Purpose" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test: Purpose</a><br/>
	7015	<a href="ipopt_solve_ode_inverse.cpp.xml#Purpose" target="_top">ODE Inverse Problem Definitions: Source Code: Purpose</a><br/>
	7016	<a href="ipopt_solve_retape.cpp.xml#Purpose" target="_top">Nonlinear Programming Retaping: Example and Test: Purpose</a><br/>
	7017	<a href="ipopt_solve_get_started.cpp.xml#Purpose" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test: Purpose</a><br/>
	7018	<a href="ipopt_solve.xml#Purpose" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Purpose</a><br/>
	7019	<a href="luratio.xml#ratio.Purpose" target="_top">LU Factorization of A Square Matrix and Stability Calculation: ratio.Purpose</a><br/>
	7020	<a href="opt_val_hes.xml#Purpose" target="_top">Jacobian and Hessian of Optimal Values: Purpose</a><br/>
	7021	<a href="benderquad.xml#Purpose" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: Purpose</a><br/>
	7022	<a href="ta_free_all.xml#Purpose" target="_top">Free All Memory That Was Allocated for Use by thread_alloc: Purpose</a><br/>
	7023	<a href="ta_delete_array.xml#Purpose" target="_top">Deallocate An Array and Call Destructor for its Elements: Purpose</a><br/>
	7024	<a href="ta_create_array.xml#Purpose" target="_top">Allocate An Array and Call Default Constructor for its Elements: Purpose</a><br/>
	7025	<a href="ta_available.xml#Purpose" target="_top">Amount of Memory Available for Quick Use by a Thread: Purpose</a><br/>
	7026	<a href="ta_inuse.xml#Purpose" target="_top">Amount of Memory a Thread is Currently Using: Purpose</a><br/>
	7027	<a href="ta_hold_memory.xml#Purpose" target="_top">Control When Thread Alloc Retains Memory For Future Use: Purpose</a><br/>
	7028	<a href="ta_free_available.xml#Purpose" target="_top">Free Memory Currently Available for Quick Use by a Thread: Purpose</a><br/>
	7029	<a href="ta_return_memory.xml#Purpose" target="_top">Return Memory to thread_alloc: Purpose</a><br/>
	7030	<a href="ta_get_memory.xml#Purpose" target="_top">Get At Least A Specified Amount of Memory: Purpose</a><br/>
	7031	<a href="ta_thread_num.xml#Purpose" target="_top">Get the Current Thread Number: Purpose</a><br/>
	7032	<a href="ta_in_parallel.xml#Purpose" target="_top">Is The Current Execution in Parallel Mode: Purpose</a><br/>
	7033	<a href="ta_num_threads.xml#Purpose" target="_top">Get Number of Threads: Purpose</a><br/>
	7034	<a href="ta_parallel_setup.xml#Purpose" target="_top">Setup thread_alloc For Use in Multi-Threading Environment: Purpose</a><br/>
	7035	<a href="thread_alloc.xml#Purpose" target="_top">A Fast Multi-Threading Memory Allocator: Purpose</a><br/>
	7036	<a href="odegearcontrol.xml#Purpose" target="_top">An Error Controller for Gear's Ode Solvers: Purpose</a><br/>
	7037	<a href="odegear.xml#Purpose" target="_top">An Arbitrary Order Gear Method: Purpose</a><br/>
	7038	<a href="runge45.xml#Purpose" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Purpose</a><br/>
	7039	<a href="pow_int.xml#Purpose" target="_top">The Integer Power Function: Purpose</a><br/>
	7040	<a href="nan.xml#Purpose" target="_top">Obtain Nan or Determine if a Value is Nan: Purpose</a><br/>
	7041	<a href="checksimplevector.xml#Purpose" target="_top">Check Simple Vector Concept: Purpose</a><br/>
	7042	<a href="checknumerictype.xml#Purpose" target="_top">Check NumericType Class Concept: Purpose</a><br/>
	7043	<a href="elapsed_seconds.xml#Purpose" target="_top">Returns Elapsed Number of Seconds: Purpose</a><br/>
	7044	<a href="time_test.xml#Purpose" target="_top">Determine Amount of Time to Execute a Test: Purpose</a><br/>
	7045	<a href="speedtest.xml#Purpose" target="_top">Run One Speed Test and Print Results: Purpose</a><br/>
	7046	<a href="speed_test.xml#Purpose" target="_top">Run One Speed Test and Return Results: Purpose</a><br/>
	7047	<a href="nearequal.xml#Purpose" target="_top">Determine if Two Values Are Nearly Equal: Purpose</a><br/>
	7048	<a href="cppad_assert.xml#Purpose" target="_top">CppAD Assertions During Execution: Purpose</a><br/>
	7049	<a href="library.xml#General Purpose Utilities" target="_top">The CppAD General Purpose Library: General Purpose Utilities</a><br/>
	7050	<a href="library.xml" target="_top">The CppAD General Purpose Library</a><br/>
	7051	<a href="team_thread.hpp.xml#Purpose" target="_top">Specifications for A Team of AD Threads: Purpose</a><br/>
	7052	<a href="multi_newton_work.cpp.xml#Purpose" target="_top">Multi-threading Newton Method Utility Routines: Purpose</a><br/>
	7053	<a href="multi_newton_time.cpp.xml#Purpose" target="_top">Timing Test of Multi-Threaded Newton Method: Purpose</a><br/>
	7054	<a href="multi_newton.cpp.xml#Purpose" target="_top">A Multi-Threaded Newton's Method: Purpose</a><br/>
	7055	<a href="harmonic_work.cpp.xml#Purpose" target="_top">Multi-threading Sum of 1/i Utility Routines: Purpose</a><br/>
	7056	<a href="harmonic_time.cpp.xml#Purpose" target="_top">Timing Test of Multi-Threaded Summation of 1/i: Purpose</a><br/>
	7057	<a href="team_example.cpp.xml#Purpose" target="_top">Using a Team of AD Threads: Example and Test: Purpose</a><br/>
	7058	<a href="simple_ad_pthread.cpp.xml#Purpose" target="_top">A Simple pthread AD: Example and Test: Purpose</a><br/>
	7059	<a href="simple_ad_bthread.cpp.xml#Purpose" target="_top">A Simple Boost Threading AD: Example and Test: Purpose</a><br/>
	7060	<a href="simple_ad_openmp.cpp.xml#Purpose" target="_top">A Simple OpenMP AD: Example and Test: Purpose</a><br/>
	7061	<a href="a11c_pthread.cpp.xml#Purpose" target="_top">A Simple Parallel Pthread Example and Test: Purpose</a><br/>
	7062	<a href="a11c_bthread.cpp.xml#Purpose" target="_top">A Simple Boost Thread Example and Test: Purpose</a><br/>
	7063	<a href="a11c_openmp.cpp.xml#Purpose" target="_top">A Simple OpenMP Example and Test: Purpose</a><br/>
	7064	<a href="thread_test.cpp.xml#Purpose" target="_top">Run Multi-Threading Examples and Speed Tests: Purpose</a><br/>
	7065	<a href="parallel_ad.xml#Purpose" target="_top">Enable AD Calculations During Parallel Mode: Purpose</a><br/>
	7066	<a href="multi_thread.xml#Purpose" target="_top">Using CppAD in a Multi-Threading Environment: Purpose</a><br/>
	7067	<a href="preprocessor.xml#Purpose" target="_top">CppAD API Preprocessor Symbols: Purpose</a><br/>
	7068	<a href="check_for_nan.xml#Purpose" target="_top">Check an ADFun Object For Nan: Purpose</a><br/>
	7069	<a href="optimize.xml#Purpose" target="_top">Optimize an ADFun Object Tape: Purpose</a><br/>
	7070	<a href="funcheck.xml#Purpose" target="_top">Check an ADFun Sequence of Operations: Purpose</a><br/>
	7071	<a href="sparse_hessian.xml#Purpose" target="_top">Sparse Hessian: Easy Driver: Purpose</a><br/>
	7072	<a href="sparse_jacobian.xml#Purpose" target="_top">Sparse Jacobian: Easy Driver: Purpose</a><br/>
	7073	<a href="revtwo.xml#Purpose" target="_top">Reverse Mode Second Partial Derivative Driver: Purpose</a><br/>
	7074	<a href="fortwo.xml#Purpose" target="_top">Forward Mode Second Partial Derivative Driver: Purpose</a><br/>
	7075	<a href="hessian.xml#Purpose" target="_top">Hessian: Easy Driver: Purpose</a><br/>
	7076	<a href="revone.xml#Purpose" target="_top">First Order Derivative: Driver Routine: Purpose</a><br/>
	7077	<a href="forone.xml#Purpose" target="_top">First Order Partial Derivative: Driver Routine: Purpose</a><br/>
	7078	<a href="jacobian.xml#Purpose" target="_top">Jacobian: Driver Routine: Purpose</a><br/>
	7079	<a href="revsparsehes.xml#Purpose" target="_top">Hessian Sparsity Pattern: Reverse Mode: Purpose</a><br/>
	7080	<a href="revsparsejac.xml#Purpose" target="_top">Jacobian Sparsity Pattern: Reverse Mode: Purpose</a><br/>
	7081	<a href="forsparsejac.xml#Purpose" target="_top">Jacobian Sparsity Pattern: Forward Mode: Purpose</a><br/>
	7082	<a href="reverse_any.cpp.xml#Purpose" target="_top">Reverse Mode General Case: Example and Test: Purpose</a><br/>
	7083	<a href="reverse_any.xml#Purpose" target="_top">Any Order Reverse Mode: Purpose</a><br/>
	7084	<a href="reverse_two.xml#Purpose" target="_top">Second Order Reverse Mode: Purpose</a><br/>
	7085	<a href="reverse_one.xml#Purpose" target="_top">First Order Reverse Mode: Purpose</a><br/>
	7086	<a href="number_skip.xml#Purpose" target="_top">Number of Variables that Can be Skipped: Purpose</a><br/>
	7087	<a href="capacity_order.xml#Purpose" target="_top">Controlling Taylor Coefficients Memory Allocation: Purpose</a><br/>
	7088	<a href="comparechange.xml#Purpose" target="_top">Comparison Changes During Zero Order Forward Mode: Purpose</a><br/>
	7089	<a href="size_order.xml#Purpose" target="_top">Number Taylor Coefficient Orders Currently Stored: Purpose</a><br/>
	7090	<a href="forward_dir.xml#Purpose" target="_top">Multiple Directions Forward Mode: Purpose</a><br/>
	7091	<a href="forward_order.xml#Purpose" target="_top">Multiple Order Forward Mode: Purpose</a><br/>
	7092	<a href="forward_two.xml#Purpose" target="_top">Second Order Forward Mode: Derivative Values: Purpose</a><br/>
	7093	<a href="forward_one.xml#Purpose" target="_top">First Order Forward Mode: Derivative Values: Purpose</a><br/>
	7094	<a href="forward_zero.xml#Purpose" target="_top">Zero Order Forward Mode: Function Values: Purpose</a><br/>
	7095	<a href="seq_property.xml#Purpose" target="_top">ADFun Sequence Properties: Purpose</a><br/>
	7096	<a href="abort_recording.xml#Purpose" target="_top">Abort Recording of an Operation Sequence: Purpose</a><br/>
	7097	<a href="dependent.xml#Purpose" target="_top">Stop Recording and Store Operation Sequence: Purpose</a><br/>
	7098	<a href="funconstruct.xml#Purpose" target="_top">Construct an ADFun Object and Stop Recording: Purpose</a><br/>
	7099	<a href="independent.xml#Purpose" target="_top">Declare Independent Variables and Start Recording: Purpose</a><br/>
	7100	<a href="adfun.xml#Purpose" target="_top">ADFun Objects: Purpose</a><br/>
	7101	<a href="mul_level_adolc.cpp.xml#Purpose" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test: Purpose</a><br/>
	7102	<a href="base_require.cpp.xml#Purpose" target="_top">Using a User Defined AD Base Type: Example and Test: Purpose</a><br/>
	7103	<a href="base_alloc.hpp.xml#Purpose" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Purpose</a><br/>
	7104	<a href="base_std_math.xml#Purpose" target="_top">Base Type Requirements for Standard Math Functions: Purpose</a><br/>
	7105	<a href="base_ordered.xml#Purpose" target="_top">Base Type Requirements for Ordered Comparisons: Purpose</a><br/>
	7106	<a href="base_cond_exp.xml#Purpose" target="_top">Base Type Requirements for Conditional Expressions: Purpose</a><br/>
	7107	<a href="base_require.xml#Purpose" target="_top">AD<Base> Requirements for Base Type: Purpose</a><br/>
	7108	<a href="vecad.xml#Purpose" target="_top">AD Vectors that Record Index Operations: Purpose</a><br/>
	7109	<a href="equalopseq.xml#Purpose" target="_top">Check if Two Value are Identically Equal: Purpose</a><br/>
	7110	<a href="parvar.xml#Purpose" target="_top">Is an AD Object a Parameter or Variable: Purpose</a><br/>
	7111	<a href="boolfun.xml#Purpose" target="_top">AD Boolean Functions: Purpose</a><br/>
	7112	<a href="nearequalext.xml#Purpose" target="_top">Compare AD and Base Objects for Nearly Equal: Purpose</a><br/>
	7113	<a href="compare.xml#Purpose" target="_top">AD Binary Comparison Operators: Purpose</a><br/>
	7114	<a href="atomic_hes_sparse.cpp.xml#Purpose" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Purpose</a><br/>
	7115	<a href="atomic_get_started.cpp.xml#Purpose" target="_top">Getting Started with Atomic Operations: Example and Test: Purpose</a><br/>
	7116	<a href="atomic_base_clear.xml#Purpose" target="_top">Free Static Variables: Purpose</a><br/>
	7117	<a href="atomic_rev_sparse_hes.xml#Purpose" target="_top">Atomic Reverse Hessian Sparsity Patterns: Purpose</a><br/>
	7118	<a href="atomic_rev_sparse_jac.xml#Purpose" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Purpose</a><br/>
	7119	<a href="atomic_for_sparse_jac.xml#Purpose" target="_top">Atomic Forward Jacobian Sparsity Patterns: Purpose</a><br/>
	7120	<a href="atomic_reverse.xml#Purpose" target="_top">Atomic Reverse Mode: Purpose</a><br/>
	7121	<a href="atomic_forward.xml#Purpose" target="_top">Atomic Forward Mode: Purpose</a><br/>
	7122	<a href="atomic_afun.xml#Purpose" target="_top">Using AD Version of Atomic Function: Purpose</a><br/>
	7123	<a href="atomic_base.xml#Purpose" target="_top">User Defined Atomic AD Functions: Purpose</a><br/>
	7124	<a href="checkpoint.cpp.xml#Purpose" target="_top">Simple Checkpointing: Example and Test: Purpose</a><br/>
	7125	<a href="checkpoint.xml#Purpose" target="_top">Checkpointing Functions: Purpose</a><br/>
	7126	<a href="discrete.xml#Purpose" target="_top">Discrete AD Functions: Purpose</a><br/>
	7127	<a href="condexp.xml#Purpose" target="_top">AD Conditional Expressions: Purpose</a><br/>
	7128	<a href="limits.xml#Purpose" target="_top">Numeric Limits For an AD and Base Types: Purpose</a><br/>
	7129	<a href="pow.xml#Purpose" target="_top">The AD Power Function: Purpose</a><br/>
	7130	<a href="atan2.xml#Purpose" target="_top">AD Two Argument Inverse Tangent Function: Purpose</a><br/>
	7131	<a href="sign.xml#Purpose" target="_top">Sign Function: Purpose</a><br/>
	7132	<a href="abs.xml#Purpose" target="_top">AD Absolute Value Function: Purpose</a><br/>
	7133	<a href="std_math_ad.xml#Purpose" target="_top">AD Standard Math Unary Functions: Purpose</a><br/>
	7134	<a href="compute_assign.xml#Purpose" target="_top">AD Computed Assignment Operators: Purpose</a><br/>
	7135	<a href="ad_binary.xml#Purpose" target="_top">AD Binary Arithmetic Operators: Purpose</a><br/>
	7136	<a href="unaryminus.xml#Purpose" target="_top">AD Unary Minus Operator: Purpose</a><br/>
	7137	<a href="unaryplus.xml#Purpose" target="_top">AD Unary Plus Operator: Purpose</a><br/>
	7138	<a href="var2par.xml#Purpose" target="_top">Convert an AD Variable to a Parameter: Purpose</a><br/>
	7139	<a href="printfor.xml#Purpose" target="_top">Printing AD Values During Forward Mode: Purpose</a><br/>
	7140	<a href="ad_output.xml#Purpose" target="_top">AD Output Stream Operator: Purpose</a><br/>
	7141	<a href="ad_input.xml#Purpose" target="_top">AD Output Stream Operator: Purpose</a><br/>
	7142	<a href="integer.xml#Purpose" target="_top">Convert From AD to Integer: Purpose</a><br/>
	7143	<a href="value.xml#Purpose" target="_top">Convert From an AD Type to its Base Type: Purpose</a><br/>
	7144	<a href="ad_assign.xml#Purpose" target="_top">AD Assignment Operator: Purpose</a><br/>
	7145	<a href="ad_ctor.xml#Purpose" target="_top">AD Constructors: Purpose</a><br/>
	7146	<a href="ad.xml#Purpose" target="_top">AD Objects: Purpose</a><br/>
	7147	<a href="exp_eps_cppad.xml#Purpose" target="_top">exp_eps: CppAD Forward and Reverse Sweeps: Purpose</a><br/>
	7148	<a href="exp_eps_rev2.xml#Purpose" target="_top">exp_eps: Second Order Reverse Sweep: Purpose</a><br/>
	7149	<a href="exp_eps_for2.xml#Purpose" target="_top">exp_eps: Second Order Forward Mode: Purpose</a><br/>
	7150	<a href="exp_eps_rev1.xml#Purpose" target="_top">exp_eps: First Order Reverse Sweep: Purpose</a><br/>
	7151	<a href="exp_eps.xml#Purpose" target="_top">An Epsilon Accurate Exponential Approximation: Purpose</a><br/>
	7152	<a href="exp_2_cppad.xml#Purpose" target="_top">exp_2: CppAD Forward and Reverse Sweeps: Purpose</a><br/>
	7153	<a href="exp_2_rev2.xml#Purpose" target="_top">exp_2: Second Order Reverse Mode: Purpose</a><br/>
	7154	<a href="exp_2_for2.xml#Purpose" target="_top">exp_2: Second Order Forward Mode: Purpose</a><br/>
	7155	<a href="exp_2_rev1.xml#Purpose" target="_top">exp_2: First Order Reverse Mode: Purpose</a><br/>
	7156	<a href="exp_2_for1.xml#Purpose" target="_top">exp_2: First Order Forward Mode: Purpose</a><br/>
	7157	<a href="exp_2.xml#Purpose" target="_top">Second Order Exponential Approximation: Purpose</a><br/>
	7158	<a href="get_started.cpp.xml#Purpose" target="_top">Getting Started Using CppAD to Compute Derivatives: Purpose</a><br/>
	7159	<a href="introduction.xml#Purpose" target="_top">An Introduction by Example to Algorithmic Differentiation: Purpose</a><br/>
	7160	<a href="pkgconfig.xml#Purpose" target="_top">CppAD pkg-config Files: Purpose</a><br/>
	7161	<a href="cmake_check.xml#Purpose" target="_top">Checking the CppAD Examples and Tests: Purpose</a><br/>
	7162	<a href="cppad_testvector.xml#Purpose" target="_top">Choosing the CppAD Test Vector Template Class: Purpose</a><br/>
	7163	<a href="get_sacado.sh.xml#Purpose" target="_top">Download and Install Sacado in Build Directory: Purpose</a><br/>
	7164	<a href="sacado_prefix.xml#Purpose" target="_top">Including the Sacado Speed Tests: Purpose</a><br/>
	7165	<a href="get_ipopt.sh.xml#Purpose" target="_top">Download and Install Ipopt in Build Directory: Purpose</a><br/>
	7166	<a href="ipopt_prefix.xml#Purpose" target="_top">Including the cppad_ipopt Library and Tests: Purpose</a><br/>
	7167	<a href="get_fadbad.sh.xml#Purpose" target="_top">Download and Install Fadbad in Build Directory: Purpose</a><br/>
	7168	<a href="fadbad_prefix.xml#Purpose" target="_top">Including the FADBAD Speed Tests: Purpose</a><br/>
	7169	<a href="get_eigen.sh.xml#Purpose" target="_top">Download and Install Eigen in Build Directory: Purpose</a><br/>
	7170	<a href="eigen_prefix.xml#Purpose" target="_top">Including the Eigen Examples and Tests: Purpose</a><br/>
	7171	<a href="get_colpack.sh.xml#Purpose" target="_top">Download and Install ColPack in Build Directory: Purpose</a><br/>
	7172	<a href="colpack_prefix.xml#Purpose" target="_top">Including the ColPack Sparsity Calculations: Purpose</a><br/>
	7173	<a href="get_adolc.sh.xml#Purpose" target="_top">Download and Install Adolc in Build Directory: Purpose</a><br/>
	7174	<a href="adolc_prefix.xml#Purpose" target="_top">Including the ADOL-C Examples and Tests: Purpose</a><br/>
	7175	<a href="download.xml#Purpose" target="_top">Download The CppAD Source Code: Purpose</a><br/>
	7176	push<b>_</b>back <a href="cppad_vector.xml#push_back" target="_top">The CppAD::vector Template Class: push_back</a><br/>
1979	7177	CppAD<b> </b>vector <a href="cppad_vector.xml#push_back" target="_top">The CppAD::vector Template Class: push_back</a><br/>
1980		push<b>_</b>vector<br/>
	7178	push<b>_</b>vector <a href="cppad_vector.xml#push_vector" target="_top">The CppAD::vector Template Class: push_vector</a><br/>
1981	7179	CppAD <a href="cppad_vector.xml#push_vector" target="_top">The CppAD::vector Template Class: push_vector</a><br/>
	7180	px <a href="old_atomic.xml#reverse.px" target="_top">User Defined Atomic AD Functions: reverse.px</a><br/>
	7181	<a href="atomic_reverse.xml#py.px" target="_top">Atomic Reverse Mode: py.px</a><br/>
	7182	py <a href="old_atomic.xml#reverse.py" target="_top">User Defined Atomic AD Functions: reverse.py</a><br/>
	7183	<a href="atomic_reverse.xml#py" target="_top">Atomic Reverse Mode: py</a><br/>
1982	7184
1983	7185	<b><big><a name="Q">Q</a></big></b>
1984	7186	<br/>
	7187	q <a href="old_atomic.xml#rev_hes_sparse.q" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.q</a><br/>
	7188	<a href="old_atomic.xml#rev_jac_sparse.q" target="_top">User Defined Atomic AD Functions: rev_jac_sparse.q</a><br/>
	7189	<a href="old_atomic.xml#for_jac_sparse.q" target="_top">User Defined Atomic AD Functions: for_jac_sparse.q</a><br/>
	7190	<a href="revsparsehes.xml#q" target="_top">Hessian Sparsity Pattern: Reverse Mode: q</a><br/>
	7191	<a href="revsparsejac.xml#q" target="_top">Jacobian Sparsity Pattern: Reverse Mode: q</a><br/>
	7192	<a href="forsparsejac.xml#q" target="_top">Jacobian Sparsity Pattern: Forward Mode: q</a><br/>
	7193	<a href="reverse_any.xml#q" target="_top">Any Order Reverse Mode: q</a><br/>
	7194	<a href="forward_dir.xml#q" target="_top">Multiple Directions Forward Mode: q</a><br/>
	7195	<a href="forward_order.xml#q" target="_top">Multiple Order Forward Mode: q</a><br/>
	7196	<a href="atomic_rev_sparse_hes.xml#Implementation.q" target="_top">Atomic Reverse Hessian Sparsity Patterns: Implementation.q</a><br/>
	7197	<a href="atomic_rev_sparse_jac.xml#Implementation.q" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Implementation.q</a><br/>
	7198	<a href="atomic_for_sparse_jac.xml#Implementation.q" target="_top">Atomic Forward Jacobian Sparsity Patterns: Implementation.q</a><br/>
	7199	<a href="atomic_reverse.xml#q" target="_top">Atomic Reverse Mode: q</a><br/>
	7200	<a href="atomic_forward.xml#q" target="_top">Atomic Forward Mode: q</a><br/>
	7201	questions <a href="faq.xml" target="_top">Frequently Asked Questions and Answers</a><br/>
	7202	quick <a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	7203	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	7204	<a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
	7205	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	7206	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
1985	7207	quotient<br/>
1986	7208	AD<b> </b>example <a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
1987	7209

2010	7232	example <a href="runge45_2.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
2011	7233	example <a href="runge45_1.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
2012	7234	parallel <a href="runge45.xml#Parallel Mode" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Parallel Mode</a><br/>
2013		random<br/>
	7235	r <a href="det_of_minor_c.xml#r" target="_top">Determinant of a Minor: r</a><br/>
	7236	<a href="old_atomic.xml#rev_hes_sparse.r" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.r</a><br/>
	7237	<a href="old_atomic.xml#rev_jac_sparse.r" target="_top">User Defined Atomic AD Functions: rev_jac_sparse.r</a><br/>
	7238	<a href="old_atomic.xml#for_jac_sparse.r" target="_top">User Defined Atomic AD Functions: for_jac_sparse.r</a><br/>
	7239	<a href="det_of_minor.xml#r" target="_top">Determinant of a Minor: r</a><br/>
	7240	<a href="rombergmul.xml#r" target="_top">Multi-dimensional Romberg Integration: r</a><br/>
	7241	<a href="rombergone.xml#r" target="_top">One DimensionalRomberg Integration: r</a><br/>
	7242	<a href="nearequal.xml#r" target="_top">Determine if Two Values Are Nearly Equal: r</a><br/>
	7243	<a href="funcheck.xml#r" target="_top">Check an ADFun Sequence of Operations: r</a><br/>
	7244	<a href="revsparsehes.xml#r" target="_top">Hessian Sparsity Pattern: Reverse Mode: r</a><br/>
	7245	<a href="revsparsejac.xml#r" target="_top">Jacobian Sparsity Pattern: Reverse Mode: r</a><br/>
	7246	<a href="forsparsejac.xml#r" target="_top">Jacobian Sparsity Pattern: Forward Mode: r</a><br/>
	7247	<a href="forward_dir.xml#r" target="_top">Multiple Directions Forward Mode: r</a><br/>
	7248	<a href="vecad.xml#AD Indexing.r" target="_top">AD Vectors that Record Index Operations: AD Indexing.r</a><br/>
	7249	<a href="nearequalext.xml#r" target="_top">Compare AD and Base Objects for Nearly Equal: r</a><br/>
	7250	<a href="atomic_rev_sparse_hes.xml#Implementation.r" target="_top">Atomic Reverse Hessian Sparsity Patterns: Implementation.r</a><br/>
	7251	<a href="atomic_for_sparse_jac.xml#Implementation.r" target="_top">Atomic Forward Jacobian Sparsity Patterns: Implementation.r</a><br/>
	7252	random <a href="uniform_01_c.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	7253	<a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
2014	7254	uniform<b> </b>vector <a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	7255	range <a href="ipopt_nlp_ode_fast.xml#Trapezoidal Approximation.Range Indices I(k,0)" target="_top">ODE Fitting Using Fast Representation: Trapezoidal Approximation.Range Indices I(k,0)</a><br/>
	7256	<a href="ipopt_nlp_ode_fast.xml#Initial Condition.Range Indices I(k,0)" target="_top">ODE Fitting Using Fast Representation: Initial Condition.Range Indices I(k,0)</a><br/>
	7257	<a href="ipopt_nlp_ode_fast.xml#Objective Function.Range Indices I(k,0)" target="_top">ODE Fitting Using Fast Representation: Objective Function.Range Indices I(k,0)</a><br/>
	7258	<a href="seq_property.xml#Range" target="_top">ADFun Sequence Properties: Range</a><br/>
	7259	<a href="atomic_base.xml#Examples.Vector Range" target="_top">User Defined Atomic AD Functions: Examples.Vector Range</a><br/>
	7260	rate <a href="speedtest.xml#rate" target="_top">Run One Speed Test and Print Results: rate</a><br/>
	7261	rate<b>_</b>vec <a href="speed_test.xml#rate_vec" target="_top">Run One Speed Test and Return Results: rate_vec</a><br/>
	7262	ratio <a href="luratio.xml#ratio" target="_top">LU Factorization of A Square Matrix and Stability Calculation: ratio</a><br/>
	7263	raw <a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	7264	<a href="omp_create_array.xml" target="_top">Allocate Memory and Create A Raw Array</a><br/>
2015	7265	re<b>-</b>tape<br/>
2016	7266	example <a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
	7267	re<b>-</b>tape<b>:</b> <a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
	7268	<a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
	7269	real <a href="integer.xml#x.Real Types" target="_top">Convert From AD to Integer: x.Real Types</a><br/>
2017	7270	real<b>()</b> <a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
2018	7271	realistic<br/>
2019	7272	example <a href="general.xml" target="_top">General Examples</a><br/>
2020		reciprocal<br/>
	7273	recipes <a href="bib.xml#Numerical Recipes" target="_top">Bibliography: Numerical Recipes</a><br/>
	7274	reciprocal <a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
2021	7275	atomic<b> </b>operation <a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
2022	7276	old<b> </b>atomic <a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
2023		record<br/>
	7277	reciprocal<b>:</b> <a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
	7278	recomputation <a href="wishlist.xml#Forward Mode Recomputation" target="_top">The CppAD Wish List: Forward Mode Recomputation</a><br/>
	7279	record <a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
	7280	<a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
2024	7281	AD<b> </b>index <a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
2025	7282	avoid <a href="faq.xml#Independent Variables" target="_top">Frequently Asked Questions and Answers: Independent Variables</a><br/>
2026	7283	example <a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
2027		recording<br/>
	7284	recorded <a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	7285	<a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
	7286	recording <a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
	7287	<a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
	7288	<a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
	7289	<a href="independent.xml#Stop Recording" target="_top">Declare Independent Variables and Start Recording: Stop Recording</a><br/>
	7290	<a href="independent.xml#Start Recording" target="_top">Declare Independent Variables and Start Recording: Start Recording</a><br/>
	7291	<a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
	7292	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function.Recording" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function.Recording</a><br/>
	7293	<a href="atomic_tangent.cpp.xml#Use Atomic Function.Recording" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.Recording</a><br/>
	7294	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function.Recording" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function.Recording</a><br/>
	7295	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function.Recording" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function.Recording</a><br/>
	7296	<a href="atomic_get_started.cpp.xml#Use Atomic Function.Recording" target="_top">Getting Started with Atomic Operations: Example and Test: Use Atomic Function.Recording</a><br/>
2028	7297	abort <a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
2029	7298	abort <a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
2030	7299	start <a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
2031	7300	stop <a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
2032	7301	stop<b> </b>tape <a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
2033		reference<br/>
	7302	recording<b>:</b> <a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
	7303	recursion <a href="erf_forward.xml#Taylor Coefficients Recursion" target="_top">Error Function Forward Taylor Polynomial Theory: Taylor Coefficients Recursion</a><br/>
	7304	<a href="tan_forward.xml#Taylor Coefficients Recursion" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory: Taylor Coefficients Recursion</a><br/>
	7305	<a href="forwardtheory.xml#Standard Math Functions.Cases that Apply Recursion Above" target="_top">The Theory of Forward Mode: Standard Math Functions.Cases that Apply Recursion Above</a><br/>
	7306	<a href="forwardtheory.xml#Standard Math Functions.Taylor Coefficients Recursion Formula" target="_top">The Theory of Forward Mode: Standard Math Functions.Taylor Coefficients Recursion Formula</a><br/>
	7307	reduced <a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
	7308	reference <a href="opt_val_hes.xml#Reference" target="_top">Jacobian and Hessian of Optimal Values: Reference</a><br/>
	7309	<a href="cppad_vector.xml#Assignment.Return Reference" target="_top">The CppAD::vector Template Class: Assignment.Return Reference</a><br/>
	7310	<a href="introduction.xml#Reference" target="_top">An Introduction by Example to Algorithmic Differentiation: Reference</a><br/>
2034	7311	VecAD<b><</b>Base<b>></b> <a href="vecad.xml#VecAD<Base>::reference" target="_top">AD Vectors that Record Index Operations: VecAD<Base>::reference</a><br/>
	7312	rel <a href="condexp.xml#Rel" target="_top">AD Conditional Expressions: Rel</a><br/>
2035	7313	relative<br/>
2036	7314	difference <a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
	7315	release <a href="download.xml#Subversion.Release Versions" target="_top">Download The CppAD Source Code: Subversion.Release Versions</a><br/>
	7316	<a href="download.xml#Compressed Tar File.Release Versions" target="_top">Download The CppAD Source Code: Compressed Tar File.Release Versions</a><br/>
	7317	removed <a href="old_max_num_threads.xml#Removed" target="_top">Set Maximum Number of Threads for omp_alloc Allocator: Removed</a><br/>
	7318	<a href="omp_efficient.xml#Removed" target="_top">Check If A Memory Allocation is Efficient for Another Use: Removed</a><br/>
	7319	repeat <a href="repeat_det_by_minor_c.xml#repeat" target="_top">Repeat det_by_minor Routine A Specified Number of Times: repeat</a><br/>
	7320	<a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
	7321	<a href="link_sparse_jacobian.xml#repeat" target="_top">Speed Testing Sparse Jacobian: repeat</a><br/>
	7322	<a href="link_sparse_hessian.xml#repeat" target="_top">Speed Testing Sparse Hessian: repeat</a><br/>
	7323	<a href="link_poly.xml#repeat" target="_top">Speed Testing Second Derivative of a Polynomial: repeat</a><br/>
	7324	<a href="link_ode.xml#repeat" target="_top">Speed Testing the Jacobian of Ode Solution: repeat</a><br/>
	7325	<a href="link_mat_mul.xml#repeat" target="_top">Speed Testing Derivative of Matrix Multiply: repeat</a><br/>
	7326	<a href="link_det_minor.xml#repeat" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: repeat</a><br/>
	7327	<a href="link_det_lu.xml#repeat" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: repeat</a><br/>
	7328	<a href="time_test.xml#test.repeat" target="_top">Determine Amount of Time to Execute a Test: test.repeat</a><br/>
	7329	<a href="speedtest.xml#Test.repeat" target="_top">Run One Speed Test and Print Results: Test.repeat</a><br/>
	7330	<a href="speed_test.xml#test.repeat" target="_top">Run One Speed Test and Return Results: test.repeat</a><br/>
2037	7331	replace<br/>
2038	7332	error<b> </b>handler <a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
2039		representation<br/>
	7333	replacing <a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
	7334	<a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
	7335	representation <a href="ipopt_nlp_ode_fast.hpp.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	7336	<a href="ipopt_nlp_ode_simple.hpp.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	7337	<a href="ipopt_nlp_ode_fast.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	7338	<a href="ipopt_nlp_ode_simple.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	7339	<a href="cppad_ipopt_nlp.xml#Simple Representation" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: Simple Representation</a><br/>
	7340	<a href="cppad_ipopt_nlp.xml#fg(x).Representation" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg(x).Representation</a><br/>
2040	7341	cppad<b>_</b>ipopt<b>_</b>nlp<b> </b>ode <a href="ipopt_nlp_ode_fast.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	7342	representations <a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
	7343	<a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
2041	7344	require<br/>
2042	7345	Base<b> </b>type <a href="base_require.xml" target="_top">AD<Base> Requirements for Base Type</a><br/>
2043	7346	base<b> </b>CondExp <a href="base_cond_exp.xml" target="_top">Base Type Requirements for Conditional Expressions</a><br/>
2044	7347	base<b> </b>EqualOpSeq <a href="base_identical.xml#EqualOpSeq" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq</a><br/>
	7348	base<b> </b>erf <a href="base_std_math.xml#erf" target="_top">Base Type Requirements for Standard Math Functions: erf</a><br/>
2045	7349	base<b> </b>Integer <a href="base_require.xml#Integer" target="_top">AD<Base> Requirements for Base Type: Integer</a><br/>
2046	7350	base<b> </b>identical <a href="base_identical.xml#Identical" target="_top">Base Type Requirements for Identically Equal Comparisons: Identical</a><br/>
2047	7351	base<b> </b>math <a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
2048	7352	base<b> </b>pow <a href="base_std_math.xml#pow" target="_top">Base Type Requirements for Standard Math Functions: pow</a><br/>
2049	7353	base<b> </b>sign <a href="base_std_math.xml#sign" target="_top">Base Type Requirements for Standard Math Functions: sign</a><br/>
2050		resize<br/>
	7354	required <a href="base_member.xml" target="_top">Required Base Class Member Functions</a><br/>
	7355	requirement <a href="ipopt_nlp_get_started.cpp.xml#Configuration Requirement" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test: Configuration Requirement</a><br/>
	7356	<a href="mul_level_adolc_ode.cpp.xml#Configuration Requirement" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Configuration Requirement</a><br/>
	7357	<a href="ipopt_solve_get_started.cpp.xml#Configuration Requirement" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test: Configuration Requirement</a><br/>
	7358	<a href="mul_level_adolc.cpp.xml#Configuration Requirement" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test: Configuration Requirement</a><br/>
	7359	requirements <a href="simplevector.xml#Template Class Requirements" target="_top">Definition of a Simple Vector: Template Class Requirements</a><br/>
	7360	<a href="numerictype.xml#Type Requirements" target="_top">Definition of a Numeric Type: Type Requirements</a><br/>
	7361	<a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
	7362	<a href="base_ordered.xml" target="_top">Base Type Requirements for Ordered Comparisons</a><br/>
	7363	<a href="base_identical.xml" target="_top">Base Type Requirements for Identically Equal Comparisons</a><br/>
	7364	<a href="base_cond_exp.xml" target="_top">Base Type Requirements for Conditional Expressions</a><br/>
	7365	<a href="base_require.xml" target="_top">AD<Base> Requirements for Base Type</a><br/>
	7366	<a href="ad.xml#Base Type Requirements" target="_top">AD Objects: Base Type Requirements</a><br/>
	7367	<a href="get_adolc.sh.xml#Requirements" target="_top">Download and Install Adolc in Build Directory: Requirements</a><br/>
	7368	resize <a href="cppad_vector.xml#resize" target="_top">The CppAD::vector Template Class: resize</a><br/>
	7369	<a href="simplevector.xml#Resize" target="_top">Definition of a Simple Vector: Resize</a><br/>
2051	7370	vector <a href="simplevector.xml#Resize" target="_top">Definition of a Simple Vector: Resize</a><br/>
2052		retape<br/>
	7371	restriction <a href="old_atomic.xml#clear.Restriction" target="_top">User Defined Atomic AD Functions: clear.Restriction</a><br/>
	7372	<a href="omp_max_thread.xml#Restriction" target="_top">OpenMP Parallel Setup: Restriction</a><br/>
	7373	<a href="cppad_assert.xml#Restriction" target="_top">CppAD Assertions During Execution: Restriction</a><br/>
	7374	<a href="parallel_ad.xml#Restriction" target="_top">Enable AD Calculations During Parallel Mode: Restriction</a><br/>
	7375	<a href="atomic_base_clear.xml#Restriction" target="_top">Free Static Variables: Restriction</a><br/>
	7376	<a href="checkpoint.xml#clear.Restriction" target="_top">Checkpointing Functions: clear.Restriction</a><br/>
	7377	<a href="value.xml#Restriction" target="_top">Convert From an AD Type to its Base Type: Restriction</a><br/>
	7378	restrictions <a href="old_max_num_threads.xml#Restrictions" target="_top">Set Maximum Number of Threads for omp_alloc Allocator: Restrictions</a><br/>
	7379	<a href="omp_max_num_threads.xml#Restrictions" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator: Restrictions</a><br/>
	7380	<a href="ta_free_all.xml#Restrictions" target="_top">Free All Memory That Was Allocated for Use by thread_alloc: Restrictions</a><br/>
	7381	<a href="ta_parallel_setup.xml#Restrictions" target="_top">Setup thread_alloc For Use in Multi-Threading Environment: Restrictions</a><br/>
	7382	<a href="checksimplevector.xml#Restrictions" target="_top">Check Simple Vector Concept: Restrictions</a><br/>
	7383	<a href="team_thread.hpp.xml#Restrictions" target="_top">Specifications for A Team of AD Threads: Restrictions</a><br/>
	7384	<a href="sparse_hessian.xml#VectorSet.Restrictions" target="_top">Sparse Hessian: Easy Driver: VectorSet.Restrictions</a><br/>
	7385	<a href="sparse_jacobian.xml#VectorSet.Restrictions" target="_top">Sparse Jacobian: Easy Driver: VectorSet.Restrictions</a><br/>
	7386	<a href="comparechange.xml#Restrictions" target="_top">Comparison Changes During Zero Order Forward Mode: Restrictions</a><br/>
	7387	<a href="forward_order.xml#xq.Restrictions" target="_top">Multiple Order Forward Mode: xq.Restrictions</a><br/>
	7388	<a href="atomic_ctor.xml#atomic_base.Restrictions" target="_top">Atomic Function Constructor: atomic_base.Restrictions</a><br/>
	7389	result <a href="lu_vec_ad.cpp.xml#Result" target="_top">Lu Factor and Solve with Recorded Pivoting: Result</a><br/>
	7390	<a href="atomic_matrix_mul.hpp.xml#Result Element Index" target="_top">Matrix Multiply as an Atomic Operation: Result Element Index</a><br/>
	7391	<a href="condexp.xml#result" target="_top">AD Conditional Expressions: result</a><br/>
	7392	<a href="compute_assign.xml#Result" target="_top">AD Computed Assignment Operators: Result</a><br/>
	7393	<a href="ad_output.xml#Result" target="_top">AD Output Stream Operator: Result</a><br/>
	7394	<a href="ad_input.xml#Result" target="_top">AD Output Stream Operator: Result</a><br/>
	7395	results <a href="speed_main.xml#Speed Results" target="_top">Running the Speed Test Program: Speed Results</a><br/>
	7396	<a href="speed_main.xml#Correctness Results" target="_top">Running the Speed Test Program: Correctness Results</a><br/>
	7397	<a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
	7398	<a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
	7399	retains <a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
	7400	retape <a href="ipopt_solve.xml#Example.retape" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Example.retape</a><br/>
	7401	<a href="ipopt_solve.xml#options.Retape" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: options.Retape</a><br/>
2053	7402	interpolate <a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
2054	7403	interpolate <a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
2055	7404	ipopt<b>_</b>solve <a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a><br/>
	7405	retaping<b>:</b> <a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a><br/>
	7406	<a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
	7407	<a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
	7408	return <a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	7409	<a href="omp_return_memory.xml" target="_top">Return Memory to omp_alloc</a><br/>
	7410	<a href="link_poly.xml#Return Value" target="_top">Speed Testing Second Derivative of a Polynomial: Return Value</a><br/>
	7411	<a href="link_ode.xml#Return Value" target="_top">Speed Testing the Jacobian of Ode Solution: Return Value</a><br/>
	7412	<a href="link_mat_mul.xml#Return Value" target="_top">Speed Testing Derivative of Matrix Multiply: Return Value</a><br/>
	7413	<a href="link_det_minor.xml#Return Value" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: Return Value</a><br/>
	7414	<a href="link_det_lu.xml#Return Value" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: Return Value</a><br/>
	7415	<a href="ta_return_memory.xml" target="_top">Return Memory to thread_alloc</a><br/>
	7416	<a href="cppad_vector.xml#Assignment.Return Reference" target="_top">The CppAD::vector Template Class: Assignment.Return Reference</a><br/>
	7417	<a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
	7418	<a href="exp_eps_for2.xml#Return Value" target="_top">exp_eps: Second Order Forward Mode: Return Value</a><br/>
	7419	<a href="exp_eps_for1.xml#Return Value" target="_top">exp_eps: First Order Forward Sweep: Return Value</a><br/>
	7420	<a href="exp_eps_for0.xml#Return Value" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Return Value</a><br/>
	7421	<a href="exp_2_for2.xml#Return Value" target="_top">exp_2: Second Order Forward Mode: Return Value</a><br/>
	7422	<a href="exp_2_for1.xml#Return Value" target="_top">exp_2: First Order Forward Mode: Return Value</a><br/>
	7423	<a href="exp_2_for0.xml#Return Value" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Return Value</a><br/>
2056	7424	return<b>_</b>memory<br/>
2057	7425	omp<b>_</b>alloc <a href="omp_return_memory.xml#Deprecated" target="_top">Return Memory to omp_alloc: Deprecated</a><br/>
2058	7426	thread<b>_</b>alloc <a href="ta_return_memory.xml" target="_top">Return Memory to thread_alloc</a><br/>
2059		rev<b>_</b>sparse<b>_</b>hes<br/>
	7427	returns <a href="elapsed_seconds_c.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	7428	<a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a><br/>
	7429	<a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	7430	reuse <a href="get_sacado.sh.xml#Reuse" target="_top">Download and Install Sacado in Build Directory: Reuse</a><br/>
	7431	<a href="get_ipopt.sh.xml#Reuse" target="_top">Download and Install Ipopt in Build Directory: Reuse</a><br/>
	7432	<a href="get_eigen.sh.xml#Reuse" target="_top">Download and Install Eigen in Build Directory: Reuse</a><br/>
	7433	<a href="get_colpack.sh.xml#Reuse" target="_top">Download and Install ColPack in Build Directory: Reuse</a><br/>
	7434	<a href="get_adolc.sh.xml#Reuse" target="_top">Download and Install Adolc in Build Directory: Reuse</a><br/>
	7435	rev<b>_</b>hes<b>_</b>sparse <a href="old_atomic.xml#rev_hes_sparse" target="_top">User Defined Atomic AD Functions: rev_hes_sparse</a><br/>
	7436	rev<b>_</b>jac<b>_</b>sparse <a href="old_atomic.xml#rev_jac_sparse" target="_top">User Defined Atomic AD Functions: rev_jac_sparse</a><br/>
	7437	rev<b>_</b>sparse<b>_</b>hes <a href="atomic_matrix_mul.hpp.xml#rev_sparse_hes" target="_top">Matrix Multiply as an Atomic Operation: rev_sparse_hes</a><br/>
	7438	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function.rev_sparse_hes" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function.rev_sparse_hes</a><br/>
	7439	<a href="atomic_hes_sparse.cpp.xml#rev_sparse_hes" target="_top">Atomic Operation Hessian Sparsity: Example and Test: rev_sparse_hes</a><br/>
	7440	<a href="atomic_tangent.cpp.xml#Use Atomic Function.rev_sparse_hes" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.rev_sparse_hes</a><br/>
	7441	<a href="atomic_tangent.cpp.xml#rev_sparse_hes" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: rev_sparse_hes</a><br/>
	7442	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function.rev_sparse_hes" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function.rev_sparse_hes</a><br/>
	7443	<a href="atomic_reciprocal.cpp.xml#rev_sparse_hes" target="_top">Reciprocal as an Atomic Operation: Example and Test: rev_sparse_hes</a><br/>
	7444	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function.rev_sparse_hes" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function.rev_sparse_hes</a><br/>
	7445	<a href="atomic_norm_sq.cpp.xml#rev_sparse_hes" target="_top">Euclidean Norm Squared: Example and Test: rev_sparse_hes</a><br/>
	7446	<a href="atomic_rev_sparse_hes.xml#Examples.Use rev_sparse_hes" target="_top">Atomic Reverse Hessian Sparsity Patterns: Examples.Use rev_sparse_hes</a><br/>
	7447	<a href="atomic_rev_sparse_hes.xml#Examples.Define rev_sparse_hes" target="_top">Atomic Reverse Hessian Sparsity Patterns: Examples.Define rev_sparse_hes</a><br/>
2060	7448	atomic<b> </b>callback <a href="atomic_rev_sparse_hes.xml" target="_top">Atomic Reverse Hessian Sparsity Patterns</a><br/>
2061	7449	atomic<b> </b>virtual <a href="atomic_rev_sparse_hes.xml" target="_top">Atomic Reverse Hessian Sparsity Patterns</a><br/>
2062		rev<b>_</b>sparse<b>_</b>jac<br/>
	7450	rev<b>_</b>sparse<b>_</b>jac <a href="optimize.xml#Atomic Functions.rev_sparse_jac" target="_top">Optimize an ADFun Object Tape: Atomic Functions.rev_sparse_jac</a><br/>
	7451	<a href="atomic_matrix_mul.hpp.xml#rev_sparse_jac" target="_top">Matrix Multiply as an Atomic Operation: rev_sparse_jac</a><br/>
	7452	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function.rev_sparse_jac" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function.rev_sparse_jac</a><br/>
	7453	<a href="atomic_tangent.cpp.xml#Use Atomic Function.rev_sparse_jac" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.rev_sparse_jac</a><br/>
	7454	<a href="atomic_tangent.cpp.xml#rev_sparse_jac" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: rev_sparse_jac</a><br/>
	7455	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function.rev_sparse_jac" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function.rev_sparse_jac</a><br/>
	7456	<a href="atomic_reciprocal.cpp.xml#rev_sparse_jac" target="_top">Reciprocal as an Atomic Operation: Example and Test: rev_sparse_jac</a><br/>
	7457	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function.rev_sparse_jac" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function.rev_sparse_jac</a><br/>
	7458	<a href="atomic_norm_sq.cpp.xml#rev_sparse_jac" target="_top">Euclidean Norm Squared: Example and Test: rev_sparse_jac</a><br/>
	7459	<a href="atomic_rev_sparse_jac.xml#Examples.Use rev_sparse_jac" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Examples.Use rev_sparse_jac</a><br/>
	7460	<a href="atomic_rev_sparse_jac.xml#Examples.Define rev_sparse_jac" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Examples.Define rev_sparse_jac</a><br/>
2063	7461	atomic<b> </b>callback <a href="atomic_rev_sparse_jac.xml" target="_top">Atomic Reverse Jacobian Sparsity Patterns</a><br/>
2064	7462	atomic<b> </b>virtual <a href="atomic_rev_sparse_jac.xml" target="_top">Atomic Reverse Jacobian Sparsity Patterns</a><br/>
2065		reverse <a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
	7463	reverse <a href="old_mat_mul.hpp.xml#Reverse Partials One Order" target="_top">Define Matrix Multiply as a User Atomic Operation: Reverse Partials One Order</a><br/>
	7464	<a href="old_atomic.xml#reverse" target="_top">User Defined Atomic AD Functions: reverse</a><br/>
	7465	<a href="old_atomic.xml#ty.reverse" target="_top">User Defined Atomic AD Functions: ty.reverse</a><br/>
	7466	<a href="reverse_identity.xml#Reverse Sweep" target="_top">An Important Reverse Mode Identity: Reverse Sweep</a><br/>
	7467	<a href="reverse_identity.xml" target="_top">An Important Reverse Mode Identity</a><br/>
	7468	<a href="erf_reverse.xml" target="_top">Error Function Reverse Mode Theory</a><br/>
	7469	<a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
	7470	<a href="acosreverse.xml" target="_top">Arccosine Function Reverse Mode Theory</a><br/>
	7471	<a href="asinreverse.xml" target="_top">Arcsine Function Reverse Mode Theory</a><br/>
	7472	<a href="atanreverse.xml" target="_top">Arctangent Function Reverse Mode Theory</a><br/>
	7473	<a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
	7474	<a href="sqrtreverse.xml" target="_top">Square Root Function Reverse Mode Theory</a><br/>
	7475	<a href="logreverse.xml" target="_top">Logarithm Function Reverse Mode Theory</a><br/>
	7476	<a href="expreverse.xml" target="_top">Exponential Function Reverse Mode Theory</a><br/>
	7477	<a href="reversetheory.xml" target="_top">The Theory of Reverse Mode</a><br/>
	7478	<a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
	7479	<a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
	7480	<a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a><br/>
	7481	<a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
	7482	<a href="jacobian.xml#Forward or Reverse" target="_top">Jacobian: Driver Routine: Forward or Reverse</a><br/>
	7483	<a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>
	7484	<a href="revsparsehes.xml" target="_top">Hessian Sparsity Pattern: Reverse Mode</a><br/>
	7485	<a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
	7486	<a href="revsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Reverse Mode</a><br/>
	7487	<a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a><br/>
	7488	<a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a><br/>
	7489	<a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a><br/>
	7490	<a href="reverse_two.cpp.xml" target="_top">Second Order Reverse ModeExample and Test</a><br/>
	7491	<a href="reverse_two.xml" target="_top">Second Order Reverse Mode</a><br/>
	7492	<a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a><br/>
	7493	<a href="reverse_one.xml" target="_top">First Order Reverse Mode</a><br/>
	7494	<a href="reverse.xml" target="_top">Reverse Mode</a><br/>
	7495	<a href="atomic_matrix_mul.hpp.xml#reverse" target="_top">Matrix Multiply as an Atomic Operation: reverse</a><br/>
	7496	<a href="atomic_matrix_mul.hpp.xml#Reverse Matrix Multipliy" target="_top">Matrix Multiply as an Atomic Operation: Reverse Matrix Multipliy</a><br/>
	7497	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function.reverse" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function.reverse</a><br/>
	7498	<a href="atomic_tangent.cpp.xml#Use Atomic Function.reverse" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.reverse</a><br/>
	7499	<a href="atomic_tangent.cpp.xml#reverse" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: reverse</a><br/>
	7500	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function.reverse" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function.reverse</a><br/>
	7501	<a href="atomic_reciprocal.cpp.xml#reverse" target="_top">Reciprocal as an Atomic Operation: Example and Test: reverse</a><br/>
	7502	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function.reverse" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function.reverse</a><br/>
	7503	<a href="atomic_norm_sq.cpp.xml#reverse" target="_top">Euclidean Norm Squared: Example and Test: reverse</a><br/>
	7504	<a href="atomic_rev_sparse_hes.xml" target="_top">Atomic Reverse Hessian Sparsity Patterns</a><br/>
	7505	<a href="atomic_rev_sparse_jac.xml" target="_top">Atomic Reverse Jacobian Sparsity Patterns</a><br/>
	7506	<a href="atomic_reverse.xml#Examples.Use reverse" target="_top">Atomic Reverse Mode: Examples.Use reverse</a><br/>
	7507	<a href="atomic_reverse.xml#Examples.Define reverse" target="_top">Atomic Reverse Mode: Examples.Define reverse</a><br/>
	7508	<a href="atomic_reverse.xml" target="_top">Atomic Reverse Mode</a><br/>
	7509	<a href="exp_eps_cppad.xml" target="_top">exp_eps: CppAD Forward and Reverse Sweeps</a><br/>
	7510	<a href="exp_eps_rev2.cpp.xml" target="_top">exp_eps: Verify Second Order Reverse Sweep</a><br/>
	7511	<a href="exp_eps_rev1.cpp.xml" target="_top">exp_eps: Verify First Order Reverse Sweep</a><br/>
	7512	<a href="exp_eps_rev2.xml" target="_top">exp_eps: Second Order Reverse Sweep</a><br/>
	7513	<a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a><br/>
	7514	<a href="exp_2_cppad.xml" target="_top">exp_2: CppAD Forward and Reverse Sweeps</a><br/>
	7515	<a href="exp_2_rev2.cpp.xml" target="_top">exp_2: Verify Second Order Reverse Sweep</a><br/>
	7516	<a href="exp_2_rev1.cpp.xml" target="_top">exp_2: Verify First Order Reverse Sweep</a><br/>
	7517	<a href="exp_2_rev2.xml" target="_top">exp_2: Second Order Reverse Mode</a><br/>
	7518	<a href="exp_2_rev1.xml" target="_top">exp_2: First Order Reverse Mode</a><br/>
	7519	<a href="introduction.xml#Preface.Reverse Mode" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Reverse Mode</a><br/>
2066	7520	acos<b> </b>theory <a href="acosreverse.xml" target="_top">Arccosine Function Reverse Mode Theory</a><br/>
2067	7521	any<b> </b>order<b> </b>mode <a href="reverse_any.xml" target="_top">Any Order Reverse Mode</a><br/>
2068	7522	asin<b> </b>theory <a href="asinreverse.xml" target="_top">Arcsine Function Reverse Mode Theory</a><br/>

2072	7526	cos <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
2073	7527	cosh <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
2074	7528	easy<b> </b>driver <a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
	7529	erf<b> </b>theory <a href="erf_reverse.xml" target="_top">Error Function Reverse Mode Theory</a><br/>
2075	7530	example <a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a><br/>
2076	7531	exp<b> </b>theory <a href="expreverse.xml" target="_top">Exponential Function Reverse Mode Theory</a><br/>
2077	7532	exp<b>_</b>2 <a href="exp_2_rev2.cpp.xml" target="_top">exp_2: Verify Second Order Reverse Sweep</a><br/>

2098	7553	sqrt<b> </b>theory <a href="sqrtreverse.xml" target="_top">Square Root Function Reverse Mode Theory</a><br/>
2099	7554	tan<b> </b>theory <a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
2100	7555	third<b> </b>order <a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a><br/>
2101		run<br/>
	7556	revone <a href="revone.xml#RevOne Uses Forward" target="_top">First Order Derivative: Driver Routine: RevOne Uses Forward</a><br/>
	7557	revtwo <a href="revtwo.xml#RevTwo Uses Forward" target="_top">Reverse Mode Second Partial Derivative Driver: RevTwo Uses Forward</a><br/>
	7558	rhs <a href="lu_vec_ad.cpp.xml#Rhs" target="_top">Lu Factor and Solve with Recorded Pivoting: Rhs</a><br/>
	7559	right <a href="atomic_matrix_mul.hpp.xml#Right Operand Element Index" target="_top">Matrix Multiply as an Atomic Operation: Right Operand Element Index</a><br/>
	7560	<a href="condexp.xml#right" target="_top">AD Conditional Expressions: right</a><br/>
	7561	romberg <a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	7562	<a href="rombergmul.xml" target="_top">Multi-dimensional Romberg Integration</a><br/>
	7563	<a href="romberg_one.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	7564	root <a href="sqrtreverse.xml" target="_top">Square Root Function Reverse Mode Theory</a><br/>
	7565	<a href="sqrtforward.xml" target="_top">Square Root Function Forward Taylor Polynomial Theory</a><br/>
	7566	rosen34<b>:</b> <a href="rosen_34.cpp.xml" target="_top">Rosen34: Example and Test</a><br/>
	7567	rosenbrock <a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
	7568	routine <a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
	7569	<a href="correct_det_by_minor_c.xml" target="_top">Correctness Test of det_by_minor Routine</a><br/>
	7570	<a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
	7571	<a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a><br/>
	7572	<a href="jacobian.xml" target="_top">Jacobian: Driver Routine</a><br/>
	7573	routines <a href="old_atomic.xml#Syntax.Callback Routines" target="_top">User Defined Atomic AD Functions: Syntax.Callback Routines</a><br/>
	7574	<a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
	7575	<a href="speed_utility.xml#Library Routines" target="_top">Speed Testing Utilities: Library Routines</a><br/>
	7576	<a href="speed_utility.xml#Speed Utility Routines" target="_top">Speed Testing Utilities: Speed Utility Routines</a><br/>
	7577	<a href="exampleutility.xml" target="_top">Utility Routines used by CppAD Examples</a><br/>
	7578	<a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
	7579	<a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
	7580	row <a href="sparse_hes_fun.xml#row" target="_top">Evaluate a Function That Has a Sparse Hessian: row</a><br/>
	7581	<a href="sparse_jac_fun.xml#row" target="_top">Evaluate a Function That Has a Sparse Jacobian: row</a><br/>
	7582	<a href="link_sparse_jacobian.xml#row" target="_top">Speed Testing Sparse Jacobian: row</a><br/>
	7583	<a href="link_sparse_hessian.xml#row" target="_top">Speed Testing Sparse Hessian: row</a><br/>
	7584	<a href="sparse_hessian.xml#row, col" target="_top">Sparse Hessian: Easy Driver: row, col</a><br/>
	7585	<a href="sparse_jacobian.xml#row, col" target="_top">Sparse Jacobian: Easy Driver: row, col</a><br/>
	7586	rt <a href="atomic_rev_sparse_jac.xml#Implementation.rt" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Implementation.rt</a><br/>
	7587	run <a href="speed_example.cpp.xml" target="_top">Run the Speed Examples</a><br/>
	7588	<a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
	7589	<a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
	7590	<a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
2102	7591	exp<b>_</b>apx<b> </b>test <a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
	7592	runge<b>-</b>kutta <a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
	7593	runge45<b>:</b> <a href="runge45_2.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
	7594	<a href="runge45_1.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
	7595	running <a href="ipopt_nlp_ode_run.hpp.xml" target="_top">Driver for Running the Ipopt ODE Example</a><br/>
	7596	<a href="speed_sacado.xml#Running Tests" target="_top">Speed Test Derivatives Using Sacado: Running Tests</a><br/>
	7597	<a href="speed_fadbad.xml#Running Tests" target="_top">Speed Test Derivatives Using Fadbad: Running Tests</a><br/>
	7598	<a href="speed_cppad.xml#Running Tests" target="_top">Speed Test Derivatives Using CppAD: Running Tests</a><br/>
	7599	<a href="speed_adolc.xml#Running Tests" target="_top">Speed Test of Derivatives Using Adolc: Running Tests</a><br/>
	7600	<a href="speed_double.xml#Running Tests" target="_top">Speed Test of Functions in Double: Running Tests</a><br/>
	7601	<a href="speed_main.xml" target="_top">Running the Speed Test Program</a><br/>
	7602	<a href="speed_example.cpp.xml#Running Tests" target="_top">Run the Speed Examples: Running Tests</a><br/>
	7603	<a href="example.cpp.xml#Running Tests" target="_top">CppAD Examples and Tests: Running Tests</a><br/>
	7604	<a href="example.xml#Running Examples" target="_top">Examples: Running Examples</a><br/>
	7605	<a href="speed_program.cpp.xml#Running This Program" target="_top">Example Use of SpeedTest: Running This Program</a><br/>
	7606	<a href="thread_test.cpp.xml#Running Tests" target="_top">Run Multi-Threading Examples and Speed Tests: Running Tests</a><br/>
	7607	<a href="print_for_cout.cpp.xml#Running" target="_top">Printing During Forward Mode: Example and Test: Running</a><br/>
	7608	<a href="exp_apx_main.cpp.xml#Running Tests" target="_top">Correctness Tests For Exponential Approximation in Introduction: Running Tests</a><br/>
	7609	<a href="get_started.cpp.xml#Running" target="_top">Getting Started Using CppAD to Compute Derivatives: Running</a><br/>
2103	7610
2104	7611	<b><big><a name="S">S</a></big></b>
2105	7612	<br/>
2106	7613	Sacado<br/>
2107		unix <a href="installunix.xml#sacado_dir" target="_top">Unix Test and Installation: sacado_dir</a><br/>
	7614	unix <a href="installunix.xml#sacado_dir" target="_top">Deprecated Unix Test and Installation: sacado_dir</a><br/>
2108	7615	Size<br/>
2109	7616	ADFun <a href="fundeprecated.xml#Size" target="_top">ADFun Object Deprecated Member Functions: Size</a><br/>
2110	7617	SparseHessian <a href="sparse_hessian.xml" target="_top">Sparse Hessian: Easy Driver</a><br/>
2111	7618	SparseJacobian <a href="sparse_jacobian.xml" target="_top">Sparse Jacobian: Easy Driver</a><br/>
2112	7619	SpeedTest <a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
2113	7620	example <a href="speed_program.cpp.xml" target="_top">Example Use of SpeedTest</a><br/>
2114		sacado<br/>
	7621	s <a href="elapsed_seconds_c.xml#s" target="_top">Returns Elapsed Number of Seconds: s</a><br/>
	7622	<a href="old_atomic.xml#rev_hes_sparse.s" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.s</a><br/>
	7623	<a href="old_atomic.xml#rev_jac_sparse.s" target="_top">User Defined Atomic AD Functions: rev_jac_sparse.s</a><br/>
	7624	<a href="old_atomic.xml#for_jac_sparse.s" target="_top">User Defined Atomic AD Functions: for_jac_sparse.s</a><br/>
	7625	<a href="microsoft_timer.xml#s" target="_top">Microsoft Version of Elapsed Number of Seconds: s</a><br/>
	7626	<a href="nan.xml#isnan.s" target="_top">Obtain Nan or Determine if a Value is Nan: isnan.s</a><br/>
	7627	<a href="nan.xml#nan.s" target="_top">Obtain Nan or Determine if a Value is Nan: nan.s</a><br/>
	7628	<a href="elapsed_seconds.xml#s" target="_top">Returns Elapsed Number of Seconds: s</a><br/>
	7629	<a href="revsparsehes.xml#s" target="_top">Hessian Sparsity Pattern: Reverse Mode: s</a><br/>
	7630	<a href="revsparsejac.xml#s" target="_top">Jacobian Sparsity Pattern: Reverse Mode: s</a><br/>
	7631	<a href="forsparsejac.xml#s" target="_top">Jacobian Sparsity Pattern: Forward Mode: s</a><br/>
	7632	<a href="size_order.xml#s" target="_top">Number Taylor Coefficient Orders Currently Stored: s</a><br/>
	7633	<a href="forward_order.xml#s" target="_top">Multiple Order Forward Mode: s</a><br/>
	7634	<a href="forward_zero.xml#s" target="_top">Zero Order Forward Mode: Function Values: s</a><br/>
	7635	<a href="atomic_rev_sparse_hes.xml#Implementation.s" target="_top">Atomic Reverse Hessian Sparsity Patterns: Implementation.s</a><br/>
	7636	<a href="atomic_for_sparse_jac.xml#Implementation.s" target="_top">Atomic Forward Jacobian Sparsity Patterns: Implementation.s</a><br/>
	7637	sacado <a href="sacado_sparse_jacobian.cpp.xml" target="_top">sacado Speed: sparse_jacobian</a><br/>
	7638	<a href="sacado_sparse_hessian.cpp.xml" target="_top">Sacado Speed: Sparse Hessian</a><br/>
	7639	<a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
	7640	<a href="sacado_ode.cpp.xml" target="_top">Sacado Speed: Gradient of Ode Solution</a><br/>
	7641	<a href="sacado_mat_mul.cpp.xml" target="_top">Sacado Speed: Matrix Multiplication</a><br/>
	7642	<a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	7643	<a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
	7644	<a href="speed_sacado.xml" target="_top">Speed Test Derivatives Using Sacado</a><br/>
	7645	<a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
	7646	<a href="sacado_prefix.xml" target="_top">Including the Sacado Speed Tests</a><br/>
2115	7647	download<b> </b>and<b> </b>install <a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
2116	7648	get <a href="sacado_prefix.xml#get_sacado" target="_top">Including the Sacado Speed Tests: get_sacado</a><br/>
2117	7649	link<b>_</b>det<b>_</b>lu <a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>

2128	7660	speed <a href="sacado_prefix.xml#Speed Tests" target="_top">Including the Sacado Speed Tests: Speed Tests</a><br/>
2129	7661	speed <a href="sacado_prefix.xml" target="_top">Including the Sacado Speed Tests</a><br/>
2130	7662	speed<b> </b>test <a href="speed_sacado.xml" target="_top">Speed Test Derivatives Using Sacado</a><br/>
2131		second<br/>
	7663	sacado<b>_</b>dir <a href="installunix.xml#sacado_dir" target="_top">Deprecated Unix Test and Installation: sacado_dir</a><br/>
	7664	sacado<b>_</b>prefix <a href="speed_sacado.xml#sacado_prefix" target="_top">Speed Test Derivatives Using Sacado: sacado_prefix</a><br/>
	7665	<a href="sacado_prefix.xml#sacado_prefix" target="_top">Including the Sacado Speed Tests: sacado_prefix</a><br/>
	7666	same <a href="multi_thread.xml#Same Thread" target="_top">Using CppAD in a Multi-Threading Environment: Same Thread</a><br/>
	7667	scalar <a href="det_by_minor.xml#Scalar" target="_top">Determinant Using Expansion by Minors: Scalar</a><br/>
	7668	<a href="det_of_minor.xml#Scalar" target="_top">Determinant of a Minor: Scalar</a><br/>
	7669	<a href="det_by_lu.xml#Scalar" target="_top">Determinant Using Expansion by Lu Factorization: Scalar</a><br/>
	7670	<a href="odegearcontrol.xml#Scalar" target="_top">An Error Controller for Gear's Ode Solvers: Scalar</a><br/>
	7671	<a href="odegear.xml#Scalar" target="_top">An Arbitrary Order Gear Method: Scalar</a><br/>
	7672	<a href="odeerrcontrol.xml#Scalar" target="_top">An Error Controller for ODE Solvers: Scalar</a><br/>
	7673	<a href="rosen34.xml#Scalar" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Scalar</a><br/>
	7674	<a href="runge45.xml#Scalar" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Scalar</a><br/>
	7675	<a href="nan.xml#Scalar" target="_top">Obtain Nan or Determine if a Value is Nan: Scalar</a><br/>
	7676	<a href="atomic_base.xml#Examples.Scalar Function" target="_top">User Defined Atomic AD Functions: Examples.Scalar Function</a><br/>
	7677	scur <a href="odeerrcontrol.xml#scur" target="_top">An Error Controller for ODE Solvers: scur</a><br/>
	7678	second <a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
	7679	<a href="fadbad_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
	7680	<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
	7681	<a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>
	7682	<a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
	7683	<a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a><br/>
	7684	<a href="revtwo.xml" target="_top">Reverse Mode Second Partial Derivative Driver</a><br/>
	7685	<a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
	7686	<a href="fortwo.xml" target="_top">Forward Mode Second Partial Derivative Driver</a><br/>
	7687	<a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
	7688	<a href="reverse_any.xml#Second Order" target="_top">Any Order Reverse Mode: Second Order</a><br/>
	7689	<a href="reverse_two.cpp.xml" target="_top">Second Order Reverse ModeExample and Test</a><br/>
	7690	<a href="reverse_two.xml#dw.Second Order Partials" target="_top">Second Order Reverse Mode: dw.Second Order Partials</a><br/>
	7691	<a href="reverse_two.xml" target="_top">Second Order Reverse Mode</a><br/>
	7692	<a href="forward_order.xml#Second Order" target="_top">Multiple Order Forward Mode: Second Order</a><br/>
	7693	<a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a><br/>
	7694	<a href="exp_eps_rev2.cpp.xml" target="_top">exp_eps: Verify Second Order Reverse Sweep</a><br/>
	7695	<a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a><br/>
	7696	<a href="exp_eps_rev2.xml" target="_top">exp_eps: Second Order Reverse Sweep</a><br/>
	7697	<a href="exp_eps_for2.xml#Operation Sequence.Second" target="_top">exp_eps: Second Order Forward Mode: Operation Sequence.Second</a><br/>
	7698	<a href="exp_eps_for2.xml#Second Order Expansion" target="_top">exp_eps: Second Order Forward Mode: Second Order Expansion</a><br/>
	7699	<a href="exp_eps_for2.xml" target="_top">exp_eps: Second Order Forward Mode</a><br/>
	7700	<a href="exp_2_rev2.cpp.xml" target="_top">exp_2: Verify Second Order Reverse Sweep</a><br/>
	7701	<a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a><br/>
	7702	<a href="exp_2_rev2.xml" target="_top">exp_2: Second Order Reverse Mode</a><br/>
	7703	<a href="exp_2_for2.xml#Operation Sequence.Second" target="_top">exp_2: Second Order Forward Mode: Operation Sequence.Second</a><br/>
	7704	<a href="exp_2_for2.xml#Second Order Expansion" target="_top">exp_2: Second Order Forward Mode: Second Order Expansion</a><br/>
	7705	<a href="exp_2_for2.xml" target="_top">exp_2: Second Order Forward Mode</a><br/>
	7706	<a href="exp_2.xml" target="_top">Second Order Exponential Approximation</a><br/>
2132	7707	derivative <a href="hessian.xml" target="_top">Hessian: Easy Driver</a><br/>
2133	7708	order<b> </b>exp<b>_</b>2 <a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a><br/>
2134	7709	order<b> </b>expansion <a href="exp_eps_for2.xml#Second Order Expansion" target="_top">exp_eps: Second Order Forward Mode: Second Order Expansion</a><br/>

2140	7715	order<b> </b>reverse<b> </b>mode <a href="reverse_two.xml" target="_top">Second Order Reverse Mode</a><br/>
2141	7716	partial <a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a><br/>
2142	7717	partial <a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
2143		seconds<br/>
	7718	seconds <a href="elapsed_seconds_c.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	7719	<a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a><br/>
	7720	<a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
2144	7721	elapsed <a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a><br/>
2145	7722	time <a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
2146		sequence <a href="glossary.xml#Operation.Sequence" target="_top">Glossary: Operation.Sequence</a><br/>
	7723	seconds<b>:</b> <a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a><br/>
	7724	see <a href="opt_val_hes.xml#See Also" target="_top">Jacobian and Hessian of Optimal Values: See Also</a><br/>
	7725	<a href="benderquad.xml#See Also" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: See Also</a><br/>
	7726	<a href="pow_int.xml#See Also" target="_top">The Integer Power Function: See Also</a><br/>
	7727	<a href="number_skip.xml#Syntax.See Also" target="_top">Number of Variables that Can be Skipped: Syntax.See Also</a><br/>
	7728	<a href="capacity_order.xml#Syntax.See Also" target="_top">Controlling Taylor Coefficients Memory Allocation: Syntax.See Also</a><br/>
	7729	<a href="size_order.xml#Syntax.See Also" target="_top">Number Taylor Coefficient Orders Currently Stored: Syntax.See Also</a><br/>
	7730	<a href="seq_property.xml#Syntax.See Also" target="_top">ADFun Sequence Properties: Syntax.See Also</a><br/>
	7731	<a href="not_complex_ad.cpp.xml#See Also" target="_top">Not Complex Differentiable: Example and Test: See Also</a><br/>
	7732	<a href="complex_poly.cpp.xml#See Also" target="_top">Complex Polynomial: Example and Test: See Also</a><br/>
	7733	<a href="base_complex.hpp.xml#See Also" target="_top">Enable use of AD<Base> where Base is std::complex<double>: See Also</a><br/>
	7734	<a href="interp_retape.cpp.xml#See Also" target="_top">Interpolation With Retaping: Example and Test: See Also</a><br/>
	7735	<a href="interp_onetape.cpp.xml#See Also" target="_top">Interpolation With Out Retaping: Example and Test: See Also</a><br/>
	7736	<a href="pow.xml#See Also" target="_top">The AD Power Function: See Also</a><br/>
	7737	seed <a href="uniform_01_c.xml#seed" target="_top">Simulate a [0,1] Uniform Random Variate: seed</a><br/>
	7738	<a href="uniform_01.xml#seed" target="_top">Simulate a [0,1] Uniform Random Variate: seed</a><br/>
	7739	<a href="speed_main.xml#seed" target="_top">Running the Speed Test Program: seed</a><br/>
	7740	semantics <a href="cppad_vector.xml#Assignment.Move Semantics" target="_top">The CppAD::vector Template Class: Assignment.Move Semantics</a><br/>
	7741	sequence <a href="wishlist.xml#Operation Sequence" target="_top">The CppAD Wish List: Operation Sequence</a><br/>
	7742	<a href="glossary.xml#Operation.Sequence" target="_top">Glossary: Operation.Sequence</a><br/>
	7743	<a href="ode_evaluate.xml#Float.Operation Sequence" target="_top">Evaluate a Function Defined in Terms of an ODE: Float.Operation Sequence</a><br/>
	7744	<a href="runge45.xml#Operation Sequence" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Operation Sequence</a><br/>
	7745	<a href="poly.xml#Operation Sequence" target="_top">Evaluate a Polynomial or its Derivative: Operation Sequence</a><br/>
	7746	<a href="pow_int.xml#Operation Sequence" target="_top">The Integer Power Function: Operation Sequence</a><br/>
	7747	<a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>
	7748	<a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
	7749	<a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
	7750	<a href="seq_property.xml" target="_top">ADFun Sequence Properties</a><br/>
	7751	<a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
	7752	<a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
	7753	<a href="funconstruct.xml#Example.Sequence Constructor" target="_top">Construct an ADFun Object and Stop Recording: Example.Sequence Constructor</a><br/>
	7754	<a href="funconstruct.xml#Sequence Constructor" target="_top">Construct an ADFun Object and Stop Recording: Sequence Constructor</a><br/>
	7755	<a href="parvar.xml#Operation Sequence" target="_top">Is an AD Object a Parameter or Variable: Operation Sequence</a><br/>
	7756	<a href="boolfun.xml#Operation Sequence" target="_top">AD Boolean Functions: Operation Sequence</a><br/>
	7757	<a href="nearequalext.xml#Operation Sequence" target="_top">Compare AD and Base Objects for Nearly Equal: Operation Sequence</a><br/>
	7758	<a href="compare.xml#Operation Sequence" target="_top">AD Binary Comparison Operators: Operation Sequence</a><br/>
	7759	<a href="discrete.xml#Operation Sequence" target="_top">Discrete AD Functions: Operation Sequence</a><br/>
	7760	<a href="condexp.xml#Operation Sequence" target="_top">AD Conditional Expressions: Operation Sequence</a><br/>
	7761	<a href="pow.xml#Operation Sequence" target="_top">The AD Power Function: Operation Sequence</a><br/>
	7762	<a href="erf.xml#Operation Sequence" target="_top">The AD Error Function: Operation Sequence</a><br/>
	7763	<a href="atan2.xml#Operation Sequence" target="_top">AD Two Argument Inverse Tangent Function: Operation Sequence</a><br/>
	7764	<a href="sign.xml#Operation Sequence" target="_top">Sign Function: Operation Sequence</a><br/>
	7765	<a href="abs.xml#Operation Sequence" target="_top">AD Absolute Value Function: Operation Sequence</a><br/>
	7766	<a href="std_math_ad.xml#Operation Sequence" target="_top">AD Standard Math Unary Functions: Operation Sequence</a><br/>
	7767	<a href="compute_assign.xml#Operation Sequence" target="_top">AD Computed Assignment Operators: Operation Sequence</a><br/>
	7768	<a href="ad_binary.xml#Operation Sequence" target="_top">AD Binary Arithmetic Operators: Operation Sequence</a><br/>
	7769	<a href="unaryminus.xml#Operation Sequence" target="_top">AD Unary Minus Operator: Operation Sequence</a><br/>
	7770	<a href="unaryplus.xml#Operation Sequence" target="_top">AD Unary Plus Operator: Operation Sequence</a><br/>
	7771	<a href="ad_output.xml#Operation Sequence" target="_top">AD Output Stream Operator: Operation Sequence</a><br/>
	7772	<a href="ad_input.xml#Operation Sequence" target="_top">AD Output Stream Operator: Operation Sequence</a><br/>
	7773	<a href="integer.xml#Operation Sequence" target="_top">Convert From AD to Integer: Operation Sequence</a><br/>
	7774	<a href="value.xml#Operation Sequence" target="_top">Convert From an AD Type to its Base Type: Operation Sequence</a><br/>
	7775	<a href="exp_eps_for2.xml#Operation Sequence" target="_top">exp_eps: Second Order Forward Mode: Operation Sequence</a><br/>
	7776	<a href="exp_eps_for1.xml#Operation Sequence" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence</a><br/>
	7777	<a href="exp_eps_for0.xml#Operation Sequence" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence</a><br/>
	7778	<a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
	7779	<a href="exp_2_for2.xml#Operation Sequence" target="_top">exp_2: Second Order Forward Mode: Operation Sequence</a><br/>
	7780	<a href="exp_2_for1.xml#Operation Sequence" target="_top">exp_2: First Order Forward Mode: Operation Sequence</a><br/>
	7781	<a href="exp_2_for0.xml#Operation Sequence" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Operation Sequence</a><br/>
	7782	<a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
2147	7783	ADFun<b> </b>constructor <a href="funconstruct.xml#Sequence Constructor" target="_top">Construct an ADFun Object and Stop Recording: Sequence Constructor</a><br/>
2148	7784	equal<b> </b>operation <a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
2149	7785	example<b> </b>operation <a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>

2156	7792	optimize<b> </b>operations <a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
2157	7793	sequential<br/>
2158	7794	execution <a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
2159		set<b>_</b>max<b>_</b>num<b>_</b>threads<br/>
	7795	set <a href="old_mat_mul.hpp.xml#Set Union" target="_top">Define Matrix Multiply as a User Atomic Operation: Set Union</a><br/>
	7796	<a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
	7797	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
	7798	<a href="atomic_option.xml" target="_top">Set Atomic Function Options</a><br/>
	7799	set<b>_</b>max<b>_</b>num<b>_</b>threads <a href="omp_max_num_threads.xml#set_max_num_threads" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator: set_max_num_threads</a><br/>
2160	7800	omp<b>_</b>alloc <a href="omp_max_num_threads.xml#Deprecated" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator: Deprecated</a><br/>
2161	7801	set<b>_</b>sparsity<b>_</b>enum <a href="atomic_option.xml#atomic_sparsity.set_sparsity_enum" target="_top">Set Atomic Function Options: atomic_sparsity.set_sparsity_enum</a><br/>
	7802	<a href="atomic_option.xml#atomic_sparsity.set_sparsity_enum" target="_top">Set Atomic Function Options: atomic_sparsity.set_sparsity_enum</a><br/>
2162	7803	sets <a href="glossary.xml#Sparsity Pattern.Vector of Sets" target="_top">Glossary: Sparsity Pattern.Vector of Sets</a><br/>
2163		internal<b> </b>sparse<b> </b>vector <a href="installunix.xml#--with-sparse_option" target="_top">Unix Test and Installation: --with-sparse_option</a><br/>
2164		setup<br/>
	7804	internal<b> </b>sparse<b> </b>vector <a href="installunix.xml#--with-sparse_option" target="_top">Deprecated Unix Test and Installation: --with-sparse_option</a><br/>
	7805	setup <a href="omp_max_thread.xml" target="_top">OpenMP Parallel Setup</a><br/>
	7806	<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
2165	7807	harmonic <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
2166	7808	multi<b>_</b>newton <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
2167	7809	parallel <a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
2168	7810	thread<b>_</b>alloc <a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
2169		sign<br/>
	7811	shampine <a href="bib.xml#Shampine, L.F." target="_top">Bibliography: Shampine, L.F.</a><br/>
	7812	sign <a href="luratio.xml#sign" target="_top">LU Factorization of A Square Matrix and Stability Calculation: sign</a><br/>
	7813	<a href="lufactor.xml#sign" target="_top">LU Factorization of A Square Matrix: sign</a><br/>
	7814	<a href="base_double.hpp.xml#sign" target="_top">Enable use of AD<Base> where Base is double: sign</a><br/>
	7815	<a href="base_float.hpp.xml#sign" target="_top">Enable use of AD<Base> where Base is float: sign</a><br/>
	7816	<a href="base_adolc.hpp.xml#sign" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: sign</a><br/>
	7817	<a href="base_alloc.hpp.xml#sign" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: sign</a><br/>
	7818	<a href="base_std_math.xml#sign" target="_top">Base Type Requirements for Standard Math Functions: sign</a><br/>
	7819	<a href="sign.cpp.xml" target="_top">Sign Function: Example and Test</a><br/>
	7820	<a href="sign.xml" target="_top">Sign Function</a><br/>
2170	7821	AD <a href="sign.xml" target="_top">Sign Function</a><br/>
2171	7822	base<b> </b>require <a href="base_std_math.xml#sign" target="_top">Base Type Requirements for Standard Math Functions: sign</a><br/>
2172	7823	example <a href="sign.cpp.xml" target="_top">Sign Function: Example and Test</a><br/>
2173		simple<br/>
	7824	signdet <a href="opt_val_hes.xml#signdet" target="_top">Jacobian and Hessian of Optimal Values: signdet</a><br/>
	7825	<a href="lusolve.xml#signdet" target="_top">Compute Determinant and Solve Linear Equations: signdet</a><br/>
	7826	simple <a href="old_usead_1.cpp.xml#Simple Case" target="_top">Using AD to Compute Atomic Function Derivatives: Simple Case</a><br/>
	7827	<a href="old_atomic.xml#Example.Simple" target="_top">User Defined Atomic AD Functions: Example.Simple</a><br/>
	7828	<a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
	7829	<a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
	7830	<a href="ipopt_nlp_ode_simple.hpp.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	7831	<a href="ipopt_nlp_ode_simple.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	7832	<a href="cppad_ipopt_nlp.xml#Simple Representation" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: Simple Representation</a><br/>
	7833	<a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a><br/>
	7834	<a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a><br/>
	7835	<a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
	7836	<a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
	7837	<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
	7838	<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
	7839	<a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
	7840	<a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
	7841	<a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
	7842	<a href="base_identical.xml#EqualOpSeq.The Simple Case" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq.The Simple Case</a><br/>
	7843	<a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a><br/>
2174	7844	atomic<b> </b>operation <a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
2175	7845	boost<b> </b>thread<b> </b>AD <a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
2176	7846	cppad<b>_</b>ipopt<b>_</b>nlp<b> </b>ode<b> </b>representation <a href="ipopt_nlp_ode_simple.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>

2180	7850	vector <a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
2181	7851	vector<b> </b>check <a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a><br/>
2182	7852	vector<b> </b>example <a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a><br/>
2183		sin<br/>
	7853	simple<b>_</b>ad <a href="thread_test.cpp.xml#simple_ad" target="_top">Run Multi-Threading Examples and Speed Tests: simple_ad</a><br/>
	7854	simulate <a href="uniform_01_c.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	7855	<a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	7856	simulated <a href="ipopt_nlp_ode_problem.xml#Measurements.Simulated Measurement Values" target="_top">An ODE Inverse Problem Example: Measurements.Simulated Measurement Values</a><br/>
	7857	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements.Simulated Measurement Values" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements.Simulated Measurement Values</a><br/>
	7858	simulation <a href="ipopt_nlp_ode_problem.xml#Measurements.Simulation Parameter Values" target="_top">An ODE Inverse Problem Example: Measurements.Simulation Parameter Values</a><br/>
	7859	<a href="ipopt_nlp_ode_problem.xml#Measurements.Simulation Analytic Solution" target="_top">An ODE Inverse Problem Example: Measurements.Simulation Analytic Solution</a><br/>
	7860	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements.Simulation Parameter Values" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements.Simulation Parameter Values</a><br/>
	7861	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements.Simulation Analytic Solution" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements.Simulation Analytic Solution</a><br/>
	7862	simultaneous <a href="ipopt_nlp_ode_problem.xml#Simultaneous Method" target="_top">An ODE Inverse Problem Example: Simultaneous Method</a><br/>
	7863	<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
	7864	sin <a href="sin.cpp.xml" target="_top">The AD sin Function: Example and Test</a><br/>
	7865	<a href="std_math_ad.xml#Derivatives.sin" target="_top">AD Standard Math Unary Functions: Derivatives.sin</a><br/>
2184	7866	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
2185	7867	AD<b> </b>example <a href="sin.cpp.xml" target="_top">The AD sin Function: Example and Test</a><br/>
2186	7868	forward <a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
2187	7869	reverse <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
2188		sinh<br/>
	7870	sine <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
	7871	<a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
	7872	sinh <a href="sinh.cpp.xml" target="_top">The AD sinh Function: Example and Test</a><br/>
	7873	<a href="std_math_ad.xml#Derivatives.sinh" target="_top">AD Standard Math Unary Functions: Derivatives.sinh</a><br/>
2189	7874	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
2190	7875	AD<b> </b>example <a href="sinh.cpp.xml" target="_top">The AD sinh Function: Example and Test</a><br/>
2191	7876	forward <a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
2192	7877	reverse <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
2193		size<br/>
	7878	sini <a href="odegearcontrol.xml#sini" target="_top">An Error Controller for Gear's Ode Solvers: sini</a><br/>
	7879	size <a href="repeat_det_by_minor_c.xml#size" target="_top">Repeat det_by_minor Routine A Specified Number of Times: size</a><br/>
	7880	<a href="fundeprecated.xml#Size" target="_top">ADFun Object Deprecated Member Functions: Size</a><br/>
	7881	<a href="link_sparse_jacobian.xml#size" target="_top">Speed Testing Sparse Jacobian: size</a><br/>
	7882	<a href="link_sparse_hessian.xml#size" target="_top">Speed Testing Sparse Hessian: size</a><br/>
	7883	<a href="link_poly.xml#size" target="_top">Speed Testing Second Derivative of a Polynomial: size</a><br/>
	7884	<a href="link_ode.xml#size" target="_top">Speed Testing the Jacobian of Ode Solution: size</a><br/>
	7885	<a href="link_det_minor.xml#size" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: size</a><br/>
	7886	<a href="link_det_lu.xml#size" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: size</a><br/>
	7887	<a href="cppad_vector.xml#Assignment.Check Size" target="_top">The CppAD::vector Template Class: Assignment.Check Size</a><br/>
	7888	<a href="simplevector.xml#Size" target="_top">Definition of a Simple Vector: Size</a><br/>
	7889	<a href="time_test.xml#test.size" target="_top">Determine Amount of Time to Execute a Test: test.size</a><br/>
	7890	<a href="speedtest.xml#Test.size" target="_top">Run One Speed Test and Print Results: Test.size</a><br/>
	7891	<a href="speed_test.xml#test.size" target="_top">Run One Speed Test and Return Results: test.size</a><br/>
	7892	<a href="vecad.xml#size" target="_top">AD Vectors that Record Index Operations: size</a><br/>
2194	7893	vector <a href="simplevector.xml#Size" target="_top">Definition of a Simple Vector: Size</a><br/>
2195	7894	vector<b> </b>constructor <a href="simplevector.xml#Sizing Constructor" target="_top">Definition of a Simple Vector: Sizing Constructor</a><br/>
2196		size<b>_</b>op<br/>
	7895	size<b>_</b>forward<b>_</b>bool <a href="forsparsejac.xml#f.size_forward_bool" target="_top">Jacobian Sparsity Pattern: Forward Mode: f.size_forward_bool</a><br/>
	7896	size<b>_</b>forward<b>_</b>set <a href="forsparsejac.xml#f.size_forward_set" target="_top">Jacobian Sparsity Pattern: Forward Mode: f.size_forward_set</a><br/>
	7897	size<b>_</b>min <a href="omp_create_array.xml#size_min" target="_top">Allocate Memory and Create A Raw Array: size_min</a><br/>
	7898	<a href="ta_create_array.xml#size_min" target="_top">Allocate An Array and Call Default Constructor for its Elements: size_min</a><br/>
	7899	size<b>_</b>op <a href="seq_property.xml#size_op" target="_top">ADFun Sequence Properties: size_op</a><br/>
2197	7900	ADFun <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
2198		size<b>_</b>op<b>_</b>arg<br/>
	7901	size<b>_</b>op<b>_</b>arg <a href="seq_property.xml#size_op_arg" target="_top">ADFun Sequence Properties: size_op_arg</a><br/>
2199	7902	ADFun <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
2200		size<b>_</b>par<br/>
	7903	size<b>_</b>op<b>_</b>seq <a href="seq_property.xml#size_op_seq" target="_top">ADFun Sequence Properties: size_op_seq</a><br/>
	7904	size<b>_</b>out <a href="omp_create_array.xml#size_out" target="_top">Allocate Memory and Create A Raw Array: size_out</a><br/>
	7905	<a href="ta_create_array.xml#size_out" target="_top">Allocate An Array and Call Default Constructor for its Elements: size_out</a><br/>
	7906	size<b>_</b>par <a href="seq_property.xml#size_par" target="_top">ADFun Sequence Properties: size_par</a><br/>
2201	7907	ADFun <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
2202	7908	ADFun <a href="seq_property.xml#size_par" target="_top">ADFun Sequence Properties: size_par</a><br/>
	7909	size<b>_</b>t <a href="vecad.xml#size_t Indexing" target="_top">AD Vectors that Record Index Operations: size_t Indexing</a><br/>
	7910	size<b>_</b>taylor <a href="fundeprecated.xml#size_taylor" target="_top">ADFun Object Deprecated Member Functions: size_taylor</a><br/>
	7911	ADFun <a href="fundeprecated.xml#size_taylor" target="_top">ADFun Object Deprecated Member Functions: size_taylor</a><br/>
	7912	size<b>_</b>text <a href="seq_property.xml#size_text" target="_top">ADFun Sequence Properties: size_text</a><br/>
2203	7913	size<b>_</b>VecAD<br/>
2204	7914	ADFun <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
2205	7915	ADFun <a href="seq_property.xml#size_VecAD" target="_top">ADFun Sequence Properties: size_VecAD</a><br/>
2206		size<b>_</b>var<br/>
	7916	size<b>_</b>var <a href="seq_property.xml#size_var" target="_top">ADFun Sequence Properties: size_var</a><br/>
2207	7917	ADFun <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
2208	7918	ADFun <a href="seq_property.xml#size_var" target="_top">ADFun Sequence Properties: size_var</a><br/>
	7919	size<b>_</b>vec <a href="speed_test.xml#size_vec" target="_top">Run One Speed Test and Return Results: size_vec</a><br/>
	7920	size<b>_</b>vecad <a href="seq_property.xml#size_VecAD" target="_top">ADFun Sequence Properties: size_VecAD</a><br/>
	7921	sizevector <a href="cppad_ipopt_nlp.xml#SizeVector" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: SizeVector</a><br/>
	7922	<a href="luratio.xml#SizeVector" target="_top">LU Factorization of A Square Matrix and Stability Calculation: SizeVector</a><br/>
	7923	<a href="lufactor.xml#SizeVector" target="_top">LU Factorization of A Square Matrix: SizeVector</a><br/>
	7924	sizing <a href="simplevector.xml#Sizing Constructor" target="_top">Definition of a Simple Vector: Sizing Constructor</a><br/>
2209	7925	skip<br/>
2210	7926	number<b> </b>variables <a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
2211		solve<br/>
	7927	skipped <a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
	7928	skipped<b>:</b> <a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	7929	smax <a href="odegearcontrol.xml#smax" target="_top">An Error Controller for Gear's Ode Solvers: smax</a><br/>
	7930	<a href="odeerrcontrol.xml#smax" target="_top">An Error Controller for ODE Solvers: smax</a><br/>
	7931	smin <a href="odegearcontrol.xml#smin" target="_top">An Error Controller for Gear's Ode Solvers: smin</a><br/>
	7932	<a href="odeerrcontrol.xml#smin" target="_top">An Error Controller for ODE Solvers: smin</a><br/>
	7933	software <a href="license.xml" target="_top">Your License for the CppAD Software</a><br/>
	7934	<a href="wishlist.xml#Software Guidelines" target="_top">The CppAD Wish List: Software Guidelines</a><br/>
	7935	solution <a href="ipopt_nlp_ode_problem.xml#Measurements.Simulation Analytic Solution" target="_top">An ODE Inverse Problem Example: Measurements.Simulation Analytic Solution</a><br/>
	7936	<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
	7937	<a href="cppad_ipopt_nlp.xml#solution" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: solution</a><br/>
	7938	<a href="sacado_ode.cpp.xml" target="_top">Sacado Speed: Gradient of Ode Solution</a><br/>
	7939	<a href="cppad_ode.cpp.xml" target="_top">CppAD Speed: Gradient of Ode Solution</a><br/>
	7940	<a href="double_ode.cpp.xml" target="_top">Double Speed: Ode Solution</a><br/>
	7941	<a href="link_ode.xml" target="_top">Speed Testing the Jacobian of Ode Solution</a><br/>
	7942	<a href="ode_taylor.cpp.xml#ODE Solution" target="_top">Taylor's Ode Solver: An Example and Test: ODE Solution</a><br/>
	7943	<a href="mul_level_adolc_ode.cpp.xml#Derivative of ODE Solution" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Derivative of ODE Solution</a><br/>
	7944	<a href="mul_level_adolc_ode.cpp.xml#ODE Solution" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: ODE Solution</a><br/>
	7945	<a href="mul_level_ode.cpp.xml#Derivative of ODE Solution" target="_top">Taylor's Ode Solver: An Example and Test: Derivative of ODE Solution</a><br/>
	7946	<a href="mul_level_ode.cpp.xml#ODE Solution" target="_top">Taylor's Ode Solver: An Example and Test: ODE Solution</a><br/>
	7947	<a href="mul_level.xml#General Solution" target="_top">Using Multiple Levels of AD: General Solution</a><br/>
	7948	<a href="ipopt_solve_ode_inverse.cpp.xml#Solution Method" target="_top">ODE Inverse Problem Definitions: Source Code: Solution Method</a><br/>
	7949	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements.Simulation Analytic Solution" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements.Simulation Analytic Solution</a><br/>
	7950	<a href="ipopt_solve.xml#solution" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: solution</a><br/>
	7951	solve <a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	7952	<a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
	7953	<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
	7954	<a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
	7955	<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
2212	7956	Lu<b> </b>factor <a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
2213	7957	Lu<b> </b>factor <a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
2214	7958	linear<b> </b>equation <a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
2215	7959	linear<b> </b>equation <a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
2216	7960	ODE <a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
2217	7961	ODE <a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
2218		sort<br/>
	7962	solver <a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
	7963	<a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
	7964	solver<b>:</b> <a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	7965	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	7966	<a href="mul_level_ode.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	7967	solvers <a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
	7968	<a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
	7969	sort <a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a><br/>
2219	7970	index <a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a><br/>
2220	7971	index<b> </b>example <a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a><br/>
2221		source<br/>
	7972	sort<b>:</b> <a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a><br/>
	7973	source <a href="main_compare_c.xml#Source Code" target="_top">Main Program For Comparing C and C++ Speed: Source Code</a><br/>
	7974	<a href="time_det_by_minor_c.xml#Source Code" target="_top">Determine Amount of Time to Execute det_by_minor: Source Code</a><br/>
	7975	<a href="elapsed_seconds_c.xml#Source Code" target="_top">Returns Elapsed Number of Seconds: Source Code</a><br/>
	7976	<a href="repeat_det_by_minor_c.xml#Source Code" target="_top">Repeat det_by_minor Routine A Specified Number of Times: Source Code</a><br/>
	7977	<a href="correct_det_by_minor_c.xml#Source Code" target="_top">Correctness Test of det_by_minor Routine: Source Code</a><br/>
	7978	<a href="uniform_01_c.xml#Source Code" target="_top">Simulate a [0,1] Uniform Random Variate: Source Code</a><br/>
	7979	<a href="det_by_minor_c.xml#Source Code" target="_top">Compute Determinant using Expansion by Minors: Source Code</a><br/>
	7980	<a href="det_of_minor_c.xml#Source Code" target="_top">Determinant of a Minor: Source Code</a><br/>
	7981	<a href="old_mat_mul.hpp.xml#Begin Source" target="_top">Define Matrix Multiply as a User Atomic Operation: Begin Source</a><br/>
	7982	<a href="ipopt_nlp_ode_problem.hpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	7983	<a href="ipopt_nlp_ode_fast.xml#Source" target="_top">ODE Fitting Using Fast Representation: Source</a><br/>
	7984	<a href="ipopt_nlp_ode_simple.xml#Source" target="_top">ODE Fitting Using Simple Representation: Source</a><br/>
	7985	<a href="ipopt_nlp_ode_problem.xml#Source" target="_top">An ODE Inverse Problem Example: Source</a><br/>
	7986	<a href="uniform_01.xml#Source Code" target="_top">Simulate a [0,1] Uniform Random Variate: Source Code</a><br/>
	7987	<a href="sparse_hes_fun.xml#Source Code" target="_top">Evaluate a Function That Has a Sparse Hessian: Source Code</a><br/>
	7988	<a href="sparse_jac_fun.xml#Source Code" target="_top">Evaluate a Function That Has a Sparse Jacobian: Source Code</a><br/>
	7989	<a href="ode_evaluate.xml#Source Code" target="_top">Evaluate a Function Defined in Terms of an ODE: Source Code</a><br/>
	7990	<a href="mat_sum_sq.xml#Source Code" target="_top">Sum Elements of a Matrix Times Itself: Source Code</a><br/>
	7991	<a href="det_grad_33.xml#Source Code" target="_top">Check Gradient of Determinant of 3 by 3 matrix: Source Code</a><br/>
	7992	<a href="det_33.xml#Source Code" target="_top">Check Determinant of 3 by 3 matrix: Source Code</a><br/>
	7993	<a href="det_by_minor.xml#Source Code" target="_top">Determinant Using Expansion by Minors: Source Code</a><br/>
	7994	<a href="det_of_minor.xml#Source Code" target="_top">Determinant of a Minor: Source Code</a><br/>
	7995	<a href="det_by_lu.xml#Source Code" target="_top">Determinant Using Expansion by Lu Factorization: Source Code</a><br/>
	7996	<a href="speed_utility.xml#Source Code" target="_top">Speed Testing Utilities: Source Code</a><br/>
	7997	<a href="eigen_plugin.hpp.xml" target="_top">Source Code for eigen_plugin.hpp</a><br/>
	7998	<a href="ipopt_solve_ode_inverse.cpp.xml#Source" target="_top">ODE Inverse Problem Definitions: Source Code: Source</a><br/>
	7999	<a href="ipopt_solve_ode_inverse.cpp.xml" target="_top">ODE Inverse Problem Definitions: Source Code</a><br/>
	8000	<a href="odegearcontrol.xml#Source Code" target="_top">An Error Controller for Gear's Ode Solvers: Source Code</a><br/>
	8001	<a href="odegear.xml#Source Code" target="_top">An Arbitrary Order Gear Method: Source Code</a><br/>
	8002	<a href="odeerrcontrol.xml#Source Code" target="_top">An Error Controller for ODE Solvers: Source Code</a><br/>
	8003	<a href="rosen34.xml#Source Code" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Source Code</a><br/>
	8004	<a href="runge45.xml#Source Code" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Source Code</a><br/>
	8005	<a href="rombergmul.xml#Source Code" target="_top">Multi-dimensional Romberg Integration: Source Code</a><br/>
	8006	<a href="rombergone.xml#Source Code" target="_top">One DimensionalRomberg Integration: Source Code</a><br/>
	8007	<a href="luinvert.xml#Source" target="_top">Invert an LU Factored Equation: Source</a><br/>
	8008	<a href="lufactor.xml#Source" target="_top">LU Factorization of A Square Matrix: Source</a><br/>
	8009	<a href="lusolve.xml#Source" target="_top">Compute Determinant and Solve Linear Equations: Source</a><br/>
	8010	<a href="poly.xml#Source" target="_top">Evaluate a Polynomial or its Derivative: Source</a><br/>
	8011	<a href="team_thread.hpp.xml#Source" target="_top">Specifications for A Team of AD Threads: Source</a><br/>
	8012	<a href="multi_newton_work.cpp.xml#Source" target="_top">Multi-threading Newton Method Utility Routines: Source</a><br/>
	8013	<a href="multi_newton_time.cpp.xml#Source" target="_top">Timing Test of Multi-Threaded Newton Method: Source</a><br/>
	8014	<a href="multi_newton.cpp.xml#Source" target="_top">A Multi-Threaded Newton's Method: Source</a><br/>
	8015	<a href="harmonic_work.cpp.xml#Source" target="_top">Multi-threading Sum of 1/i Utility Routines: Source</a><br/>
	8016	<a href="harmonic_time.cpp.xml#Source" target="_top">Timing Test of Multi-Threaded Summation of 1/i: Source</a><br/>
	8017	<a href="harmonic.cpp.xml#Source" target="_top">Multi-Threaded Implementation of Summation of 1/i: Source</a><br/>
	8018	<a href="team_example.cpp.xml#Source Code" target="_top">Using a Team of AD Threads: Example and Test: Source Code</a><br/>
	8019	<a href="simple_ad_pthread.cpp.xml#Source Code" target="_top">A Simple pthread AD: Example and Test: Source Code</a><br/>
	8020	<a href="simple_ad_bthread.cpp.xml#Source Code" target="_top">A Simple Boost Threading AD: Example and Test: Source Code</a><br/>
	8021	<a href="simple_ad_openmp.cpp.xml#Source Code" target="_top">A Simple OpenMP AD: Example and Test: Source Code</a><br/>
	8022	<a href="a11c_pthread.cpp.xml#Source Code" target="_top">A Simple Parallel Pthread Example and Test: Source Code</a><br/>
	8023	<a href="a11c_bthread.cpp.xml#Source Code" target="_top">A Simple Boost Thread Example and Test: Source Code</a><br/>
	8024	<a href="a11c_openmp.cpp.xml#Source Code" target="_top">A Simple OpenMP Example and Test: Source Code</a><br/>
	8025	<a href="thread_test.cpp.xml#Source" target="_top">Run Multi-Threading Examples and Speed Tests: Source</a><br/>
	8026	<a href="print_for_cout.cpp.xml#Source Code" target="_top">Printing During Forward Mode: Example and Test: Source Code</a><br/>
	8027	<a href="download.xml" target="_top">Download The CppAD Source Code</a><br/>
2222	8028	cppad<b>_</b>ipopt<b>_</b>nlp<b> </b>ode<b> </b>example <a href="ipopt_nlp_ode_fast.hpp.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
2223	8029	cppad<b>_</b>ipopt<b>_</b>nlp<b> </b>ode<b> </b>example <a href="ipopt_nlp_ode_simple.hpp.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
2224	8030	det<b>_</b>33 <a href="det_33.hpp.xml" target="_top">Source: det_33</a><br/>

2235	8041	sparse<b>_</b>hes<b>_</b>fun <a href="sparse_hes_fun.hpp.xml" target="_top">Source: sparse_hes_fun</a><br/>
2236	8042	sparse<b>_</b>jac<b>_</b>fun <a href="sparse_jac_fun.hpp.xml" target="_top">Source: sparse_jac_fun</a><br/>
2237	8043	uniform<b>_</b>01 <a href="uniform_01.hpp.xml" target="_top">Source: uniform_01</a><br/>
	8044	source<b>:</b> <a href="uniform_01.hpp.xml" target="_top">Source: uniform_01</a><br/>
	8045	<a href="sparse_hes_fun.hpp.xml" target="_top">Source: sparse_hes_fun</a><br/>
	8046	<a href="sparse_jac_fun.hpp.xml" target="_top">Source: sparse_jac_fun</a><br/>
	8047	<a href="ode_evaluate.hpp.xml" target="_top">Source: ode_evaluate</a><br/>
	8048	<a href="mat_sum_sq.hpp.xml" target="_top">Source: mat_sum_sq</a><br/>
	8049	<a href="det_grad_33.hpp.xml" target="_top">Source: det_grad_33</a><br/>
	8050	<a href="det_33.hpp.xml" target="_top">Source: det_33</a><br/>
	8051	<a href="det_by_minor.hpp.xml" target="_top">Source: det_by_minor</a><br/>
	8052	<a href="det_of_minor.hpp.xml" target="_top">Source: det_of_minor</a><br/>
	8053	<a href="det_by_lu.hpp.xml" target="_top">Source: det_by_lu</a><br/>
	8054	<a href="lu_invert.hpp.xml" target="_top">Source: LuInvert</a><br/>
	8055	<a href="lu_factor.hpp.xml" target="_top">Source: LuFactor</a><br/>
	8056	<a href="lu_solve.hpp.xml" target="_top">Source: LuSolve</a><br/>
	8057	<a href="poly.hpp.xml" target="_top">Source: Poly</a><br/>
2238	8058	spare<br/>
	8059	colpack <a href="colpack.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
2239	8060	Hessian<b> </b>example <a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a><br/>
2240	8061	Jacobian<b> </b>example <a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a><br/>
2241		sparse<br/>
2242		internal<b> </b>vector<b> </b>sets <a href="installunix.xml#--with-sparse_option" target="_top">Unix Test and Installation: --with-sparse_option</a><br/>
	8062	sparse <a href="sacado_sparse_hessian.cpp.xml" target="_top">Sacado Speed: Sparse Hessian</a><br/>
	8063	<a href="fadbad_sparse_hessian.cpp.xml" target="_top">Fadbad Speed: Sparse Hessian</a><br/>
	8064	<a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a><br/>
	8065	<a href="cppad_sparse_hessian.cpp.xml" target="_top">CppAD Speed: Sparse Hessian</a><br/>
	8066	<a href="adolc_sparse_jacobian.cpp.xml" target="_top">adolc Speed: Sparse Jacobian</a><br/>
	8067	<a href="adolc_sparse_hessian.cpp.xml" target="_top">Adolc Speed: Sparse Hessian</a><br/>
	8068	<a href="double_sparse_jacobian.cpp.xml" target="_top">Double Speed: Sparse Jacobian</a><br/>
	8069	<a href="double_sparse_hessian.cpp.xml" target="_top">Double Speed: Sparse Hessian</a><br/>
	8070	<a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
	8071	<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
	8072	<a href="link_sparse_jacobian.xml" target="_top">Speed Testing Sparse Jacobian</a><br/>
	8073	<a href="link_sparse_hessian.xml" target="_top">Speed Testing Sparse Hessian</a><br/>
	8074	<a href="ipopt_solve.xml#options.Sparse" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: options.Sparse</a><br/>
	8075	<a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a><br/>
	8076	<a href="sparse_hessian.xml" target="_top">Sparse Hessian: Easy Driver</a><br/>
	8077	<a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a><br/>
	8078	<a href="sparse_jacobian.xml" target="_top">Sparse Jacobian: Easy Driver</a><br/>
	8079	internal<b> </b>vector<b> </b>sets <a href="installunix.xml#--with-sparse_option" target="_top">Deprecated Unix Test and Installation: --with-sparse_option</a><br/>
2243	8080	reverse<b> </b>Hessian <a href="revsparsehes.xml" target="_top">Hessian Sparsity Pattern: Reverse Mode</a><br/>
2244	8081	reverse<b> </b>Jacobian <a href="revsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Reverse Mode</a><br/>
2245	8082	speed<b> </b>adolc <a href="adolc_sparse_jacobian.cpp.xml" target="_top">adolc Speed: Sparse Jacobian</a><br/>

2250	8087	speed<b> </b>double <a href="double_sparse_hessian.cpp.xml" target="_top">Double Speed: Sparse Hessian</a><br/>
2251	8088	speed<b> </b>test <a href="link_sparse_jacobian.xml" target="_top">Speed Testing Sparse Jacobian</a><br/>
2252	8089	speed<b> </b>test <a href="link_sparse_hessian.xml" target="_top">Speed Testing Sparse Hessian</a><br/>
2253		sparse<b>_</b>hes<b>_</b>fun<br/>
	8090	sparse<b>_</b>hes<b>_</b>fun <a href="sparse_hes_fun.hpp.xml" target="_top">Source: sparse_hes_fun</a><br/>
2254	8091	example <a href="sparse_hes_fun.cpp.xml" target="_top">sparse_hes_fun: Example and test</a><br/>
2255	8092	function <a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
2256	8093	source <a href="sparse_hes_fun.hpp.xml" target="_top">Source: sparse_hes_fun</a><br/>
2257		sparse<b>_</b>jac<b>_</b>fun<br/>
	8094	sparse<b>_</b>hes<b>_</b>fun<b>:</b> <a href="sparse_hes_fun.cpp.xml" target="_top">sparse_hes_fun: Example and test</a><br/>
	8095	sparse<b>_</b>jac<b>_</b>fun <a href="sparse_jac_fun.hpp.xml" target="_top">Source: sparse_jac_fun</a><br/>
2258	8096	example <a href="sparse_jac_fun.cpp.xml" target="_top">sparse_jac_fun: Example and test</a><br/>
2259	8097	function <a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
2260	8098	source <a href="sparse_jac_fun.hpp.xml" target="_top">Source: sparse_jac_fun</a><br/>
2261		sparsity <a href="glossary.xml#Sparsity Pattern" target="_top">Glossary: Sparsity Pattern</a><br/>
	8099	sparse<b>_</b>jac<b>_</b>fun<b>:</b> <a href="sparse_jac_fun.cpp.xml" target="_top">sparse_jac_fun: Example and test</a><br/>
	8100	sparse<b>_</b>jacobian <a href="sacado_sparse_jacobian.cpp.xml" target="_top">sacado Speed: sparse_jacobian</a><br/>
	8101	<a href="fadbad_sparse_jacobian.cpp.xml" target="_top">fadbad Speed: sparse_jacobian</a><br/>
	8102	<a href="speed_main.xml#Speed Results.sparse_jacobian" target="_top">Running the Speed Test Program: Speed Results.sparse_jacobian</a><br/>
	8103	sparsity <a href="wishlist.xml#Conditional Expressions.Sparsity" target="_top">The CppAD Wish List: Conditional Expressions.Sparsity</a><br/>
	8104	<a href="glossary.xml#Sparsity Pattern" target="_top">Glossary: Sparsity Pattern</a><br/>
	8105	<a href="speed_main.xml#Sparsity Options" target="_top">Running the Speed Test Program: Sparsity Options</a><br/>
	8106	<a href="revsparsehes.xml#Entire Sparsity Pattern" target="_top">Hessian Sparsity Pattern: Reverse Mode: Entire Sparsity Pattern</a><br/>
	8107	<a href="revsparsehes.xml" target="_top">Hessian Sparsity Pattern: Reverse Mode</a><br/>
	8108	<a href="revsparsejac.xml#Entire Sparsity Pattern" target="_top">Jacobian Sparsity Pattern: Reverse Mode: Entire Sparsity Pattern</a><br/>
	8109	<a href="revsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Reverse Mode</a><br/>
	8110	<a href="forsparsejac.xml#Entire Sparsity Pattern" target="_top">Jacobian Sparsity Pattern: Forward Mode: Entire Sparsity Pattern</a><br/>
	8111	<a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a><br/>
	8112	<a href="sparse.xml" target="_top">Calculating Sparsity Patterns</a><br/>
	8113	<a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a><br/>
	8114	<a href="funconstruct.xml#Assignment Operator.Sparsity Patterns" target="_top">Construct an ADFun Object and Stop Recording: Assignment Operator.Sparsity Patterns</a><br/>
	8115	<a href="atomic_rev_sparse_hes.xml" target="_top">Atomic Reverse Hessian Sparsity Patterns</a><br/>
	8116	<a href="atomic_rev_sparse_jac.xml" target="_top">Atomic Reverse Jacobian Sparsity Patterns</a><br/>
	8117	<a href="atomic_for_sparse_jac.xml" target="_top">Atomic Forward Jacobian Sparsity Patterns</a><br/>
	8118	<a href="atomic_base.xml#Examples.Hessian Sparsity Patterns" target="_top">User Defined Atomic AD Functions: Examples.Hessian Sparsity Patterns</a><br/>
	8119	<a href="colpack_prefix.xml" target="_top">Including the ColPack Sparsity Calculations</a><br/>
2262	8120	atomic <a href="atomic_option.xml#atomic_sparsity" target="_top">Set Atomic Function Options: atomic_sparsity</a><br/>
	8121	atomic<b> </b>hessian <a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
	8122	colpack <a href="colpack_prefix.xml" target="_top">Including the ColPack Sparsity Calculations</a><br/>
2263	8123	forward<b> </b>example <a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
2264	8124	forward<b> </b>Jacobian <a href="forsparsejac.xml" target="_top">Jacobian Sparsity Pattern: Forward Mode</a><br/>
2265	8125	Hessian <a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>

2268	8128	pattern <a href="sparse.xml" target="_top">Calculating Sparsity Patterns</a><br/>
2269	8129	reverse<b> </b>example <a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
2270	8130	vector<b> </b>of<b> </b>sets <a href="cmake.xml#cppad_sparse_list" target="_top">Using CMake to Configure CppAD: cppad_sparse_list</a><br/>
2271		speed <a href="faq.xml#Speed" target="_top">Frequently Asked Questions and Answers: Speed</a><br/>
	8131	sparsity<b>:</b> <a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>
	8132	<a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
	8133	<a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
	8134	<a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
	8135	special <a href="forwardtheory.xml#Standard Math Functions.Special Cases" target="_top">The Theory of Forward Mode: Standard Math Functions.Special Cases</a><br/>
	8136	<a href="forward_two.xml#Special Case" target="_top">Second Order Forward Mode: Derivative Values: Special Case</a><br/>
	8137	<a href="forward_one.xml#Special Case" target="_top">First Order Forward Mode: Derivative Values: Special Case</a><br/>
	8138	<a href="forward_zero.xml#Special Case" target="_top">Zero Order Forward Mode: Function Values: Special Case</a><br/>
	8139	specifications <a href="sacado_poly.cpp.xml#Specifications" target="_top">Sacado Speed: Second Derivative of a Polynomial: Specifications</a><br/>
	8140	<a href="sacado_ode.cpp.xml#Specifications" target="_top">Sacado Speed: Gradient of Ode Solution: Specifications</a><br/>
	8141	<a href="sacado_mat_mul.cpp.xml#Specifications" target="_top">Sacado Speed: Matrix Multiplication: Specifications</a><br/>
	8142	<a href="sacado_det_lu.cpp.xml#Specifications" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization: Specifications</a><br/>
	8143	<a href="sacado_det_minor.cpp.xml#Specifications" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion: Specifications</a><br/>
	8144	<a href="fadbad_poly.cpp.xml#Specifications" target="_top">Fadbad Speed: Second Derivative of a Polynomial: Specifications</a><br/>
	8145	<a href="fadbad_ode.cpp.xml#Specifications" target="_top">Fadbad Speed: Ode: Specifications</a><br/>
	8146	<a href="fadbad_mat_mul.cpp.xml#Specifications" target="_top">Fadbad Speed: Matrix Multiplication: Specifications</a><br/>
	8147	<a href="fadbad_det_lu.cpp.xml#Specifications" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization: Specifications</a><br/>
	8148	<a href="fadbad_det_minor.cpp.xml#Specifications" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion: Specifications</a><br/>
	8149	<a href="cppad_sparse_jacobian.cpp.xml#Specifications" target="_top">CppAD Speed: Sparse Jacobian: Specifications</a><br/>
	8150	<a href="cppad_sparse_hessian.cpp.xml#Specifications" target="_top">CppAD Speed: Sparse Hessian: Specifications</a><br/>
	8151	<a href="cppad_poly.cpp.xml#Specifications" target="_top">CppAD Speed: Second Derivative of a Polynomial: Specifications</a><br/>
	8152	<a href="cppad_ode.cpp.xml#Specifications" target="_top">CppAD Speed: Gradient of Ode Solution: Specifications</a><br/>
	8153	<a href="cppad_mat_mul.cpp.xml#Specifications" target="_top">CppAD Speed: Matrix Multiplication: Specifications</a><br/>
	8154	<a href="cppad_det_lu.cpp.xml#Specifications" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization: Specifications</a><br/>
	8155	<a href="cppad_det_minor.cpp.xml#Specifications" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion: Specifications</a><br/>
	8156	<a href="adolc_sparse_jacobian.cpp.xml#Specifications" target="_top">adolc Speed: Sparse Jacobian: Specifications</a><br/>
	8157	<a href="adolc_sparse_hessian.cpp.xml#Specifications" target="_top">Adolc Speed: Sparse Hessian: Specifications</a><br/>
	8158	<a href="adolc_poly.cpp.xml#Specifications" target="_top">Adolc Speed: Second Derivative of a Polynomial: Specifications</a><br/>
	8159	<a href="adolc_ode.cpp.xml#Specifications" target="_top">Adolc Speed: Ode: Specifications</a><br/>
	8160	<a href="adolc_mat_mul.cpp.xml#Specifications" target="_top">Adolc Speed: Matrix Multiplication: Specifications</a><br/>
	8161	<a href="adolc_det_lu.cpp.xml#Specifications" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization: Specifications</a><br/>
	8162	<a href="adolc_det_minor.cpp.xml#Specifications" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion: Specifications</a><br/>
	8163	<a href="double_sparse_jacobian.cpp.xml#Specifications" target="_top">Double Speed: Sparse Jacobian: Specifications</a><br/>
	8164	<a href="double_sparse_hessian.cpp.xml#Specifications" target="_top">Double Speed: Sparse Hessian: Specifications</a><br/>
	8165	<a href="double_poly.cpp.xml#Specifications" target="_top">Double Speed: Evaluate a Polynomial: Specifications</a><br/>
	8166	<a href="double_ode.cpp.xml#Specifications" target="_top">Double Speed: Ode Solution: Specifications</a><br/>
	8167	<a href="double_mat_mul.cpp.xml#Specifications" target="_top">CppAD Speed: Matrix Multiplication (Double Version): Specifications</a><br/>
	8168	<a href="double_det_lu.cpp.xml#Specifications" target="_top">Double Speed: Determinant Using Lu Factorization: Specifications</a><br/>
	8169	<a href="double_det_minor.cpp.xml#Specifications" target="_top">Double Speed: Determinant by Minor Expansion: Specifications</a><br/>
	8170	<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
	8171	specified <a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
	8172	<a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	8173	<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
	8174	<a href="simplevector.xml#Elements of Specified Type" target="_top">Definition of a Simple Vector: Elements of Specified Type</a><br/>
	8175	speed <a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
	8176	<a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
	8177	<a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
	8178	<a href="omp_get_memory.xml#Allocation Speed" target="_top">Get At Least A Specified Amount of Memory: Allocation Speed</a><br/>
	8179	<a href="faq.xml#Speed" target="_top">Frequently Asked Questions and Answers: Speed</a><br/>
	8180	<a href="faq.xml#Speed" target="_top">Frequently Asked Questions and Answers: Speed</a><br/>
	8181	<a href="speed_sacado.xml" target="_top">Speed Test Derivatives Using Sacado</a><br/>
	8182	<a href="speed_fadbad.xml" target="_top">Speed Test Derivatives Using Fadbad</a><br/>
	8183	<a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a><br/>
	8184	<a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
	8185	<a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
	8186	<a href="speed_utility.xml#Speed Utility Routines" target="_top">Speed Testing Utilities: Speed Utility Routines</a><br/>
	8187	<a href="speed_utility.xml#Speed Main Program" target="_top">Speed Testing Utilities: Speed Main Program</a><br/>
	8188	<a href="speed_utility.xml" target="_top">Speed Testing Utilities</a><br/>
	8189	<a href="link_sparse_jacobian.xml" target="_top">Speed Testing Sparse Jacobian</a><br/>
	8190	<a href="link_sparse_hessian.xml" target="_top">Speed Testing Sparse Hessian</a><br/>
	8191	<a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
	8192	<a href="link_ode.xml" target="_top">Speed Testing the Jacobian of Ode Solution</a><br/>
	8193	<a href="link_mat_mul.xml" target="_top">Speed Testing Derivative of Matrix Multiply</a><br/>
	8194	<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
	8195	<a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
	8196	<a href="speed_main.xml#Speed Results" target="_top">Running the Speed Test Program: Speed Results</a><br/>
	8197	<a href="speed_main.xml#test.speed" target="_top">Running the Speed Test Program: test.speed</a><br/>
	8198	<a href="speed_main.xml" target="_top">Running the Speed Test Program</a><br/>
	8199	<a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
	8200	<a href="speed_example.cpp.xml" target="_top">Run the Speed Examples</a><br/>
	8201	<a href="ta_get_memory.xml#Allocation Speed" target="_top">Get At Least A Specified Amount of Memory: Allocation Speed</a><br/>
	8202	<a href="ta_parallel_setup.xml#Speed" target="_top">Setup thread_alloc For Use in Multi-Threading Environment: Speed</a><br/>
	8203	<a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
	8204	<a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
	8205	<a href="team_thread.hpp.xml#Speed Test of Implementation" target="_top">Specifications for A Team of AD Threads: Speed Test of Implementation</a><br/>
	8206	<a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
	8207	<a href="vecad.xml#Speed and Memory" target="_top">AD Vectors that Record Index Operations: Speed and Memory</a><br/>
	8208	<a href="sacado_prefix.xml#Speed Tests" target="_top">Including the Sacado Speed Tests: Speed Tests</a><br/>
	8209	<a href="sacado_prefix.xml" target="_top">Including the Sacado Speed Tests</a><br/>
	8210	<a href="fadbad_prefix.xml#Speed Tests" target="_top">Including the FADBAD Speed Tests: Speed Tests</a><br/>
	8211	<a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a><br/>
	8212	<a href="adolc_prefix.xml#Speed Tests" target="_top">Including the ADOL-C Examples and Tests: Speed Tests</a><br/>
2272	8213	adolc <a href="adolc_sparse_jacobian.cpp.xml" target="_top">adolc Speed: Sparse Jacobian</a><br/>
2273	8214	adolc <a href="adolc_sparse_hessian.cpp.xml" target="_top">Adolc Speed: Sparse Hessian</a><br/>
2274	8215	adolc <a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>

2302	8243	fadbad <a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
2303	8244	fadbad <a href="fadbad_prefix.xml#Speed Tests" target="_top">Including the FADBAD Speed Tests: Speed Tests</a><br/>
2304	8245	fadbad <a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a><br/>
2305		forward <a href="wishlist.xml#Multiple Argument Forward" target="_top">The CppAD Wish List: Multiple Argument Forward</a><br/>
	8246	forward <a href="wishlist.xml#Multiple Directions" target="_top">The CppAD Wish List: Multiple Directions</a><br/>
2306	8247	matrix<b> </b>multiply<b> </b>test <a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
2307	8248	multi<b>_</b>thread<b> </b>summation <a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
2308	8249	optimize <a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
2309		profile<b> </b>cppad <a href="installunix.xml#Profiling CppAD" target="_top">Unix Test and Installation: Profiling CppAD</a><br/>
	8250	profile<b> </b>cppad <a href="installunix.xml#Profiling CppAD" target="_top">Deprecated Unix Test and Installation: Profiling CppAD</a><br/>
2310	8251	sacado <a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
2311	8252	sacado <a href="sacado_ode.cpp.xml" target="_top">Sacado Speed: Gradient of Ode Solution</a><br/>
2312	8253	sacado <a href="sacado_mat_mul.cpp.xml" target="_top">Sacado Speed: Matrix Multiplication</a><br/>

2314	8255	sacado <a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
2315	8256	sacado <a href="sacado_prefix.xml#Speed Tests" target="_top">Including the Sacado Speed Tests: Speed Tests</a><br/>
2316	8257	sacado <a href="sacado_prefix.xml" target="_top">Including the Sacado Speed Tests</a><br/>
2317		test <a href="speed.xml" target="_top">AD Speed Test Routines</a><br/>
	8258	test <a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
2318	8259	test<b> </b>adolc <a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
2319	8260	test<b> </b>cppad <a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a><br/>
2320		test<b> </b>cppad <a href="speed_main.xml" target="_top">Speed Testing Main Program</a><br/>
	8261	test<b> </b>cppad <a href="speed_main.xml" target="_top">Running the Speed Test Program</a><br/>
2321	8262	test<b> </b>det<b>_</b>lu <a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
2322	8263	test<b> </b>det<b>_</b>minor <a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
2323	8264	test<b> </b>double <a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>

2328	8269	test<b> </b>sacado <a href="speed_sacado.xml" target="_top">Speed Test Derivatives Using Sacado</a><br/>
2329	8270	test<b> </b>sparse <a href="link_sparse_jacobian.xml" target="_top">Speed Testing Sparse Jacobian</a><br/>
2330	8271	test<b> </b>sparse <a href="link_sparse_hessian.xml" target="_top">Speed Testing Sparse Hessian</a><br/>
2331		test<b> </b>windows <a href="speed.xml#Windows" target="_top">AD Speed Test Routines: Windows</a><br/>
2332	8272	thread<b>_</b>test <a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
2333	8273	utility <a href="speed_utility.xml" target="_top">Speed Testing Utilities</a><br/>
	8274	speed<b>:</b> <a href="sacado_sparse_jacobian.cpp.xml" target="_top">sacado Speed: sparse_jacobian</a><br/>
	8275	<a href="sacado_sparse_hessian.cpp.xml" target="_top">Sacado Speed: Sparse Hessian</a><br/>
	8276	<a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
	8277	<a href="sacado_ode.cpp.xml" target="_top">Sacado Speed: Gradient of Ode Solution</a><br/>
	8278	<a href="sacado_mat_mul.cpp.xml" target="_top">Sacado Speed: Matrix Multiplication</a><br/>
	8279	<a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	8280	<a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
	8281	<a href="fadbad_sparse_jacobian.cpp.xml" target="_top">fadbad Speed: sparse_jacobian</a><br/>
	8282	<a href="fadbad_sparse_hessian.cpp.xml" target="_top">Fadbad Speed: Sparse Hessian</a><br/>
	8283	<a href="fadbad_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
	8284	<a href="fadbad_ode.cpp.xml" target="_top">Fadbad Speed: Ode</a><br/>
	8285	<a href="fadbad_mat_mul.cpp.xml" target="_top">Fadbad Speed: Matrix Multiplication</a><br/>
	8286	<a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	8287	<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
	8288	<a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a><br/>
	8289	<a href="cppad_sparse_hessian.cpp.xml" target="_top">CppAD Speed: Sparse Hessian</a><br/>
	8290	<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
	8291	<a href="cppad_ode.cpp.xml" target="_top">CppAD Speed: Gradient of Ode Solution</a><br/>
	8292	<a href="cppad_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication</a><br/>
	8293	<a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	8294	<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
	8295	<a href="adolc_sparse_jacobian.cpp.xml" target="_top">adolc Speed: Sparse Jacobian</a><br/>
	8296	<a href="adolc_sparse_hessian.cpp.xml" target="_top">Adolc Speed: Sparse Hessian</a><br/>
	8297	<a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>
	8298	<a href="adolc_ode.cpp.xml" target="_top">Adolc Speed: Ode</a><br/>
	8299	<a href="adolc_mat_mul.cpp.xml" target="_top">Adolc Speed: Matrix Multiplication</a><br/>
	8300	<a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	8301	<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
	8302	<a href="double_sparse_jacobian.cpp.xml" target="_top">Double Speed: Sparse Jacobian</a><br/>
	8303	<a href="double_sparse_hessian.cpp.xml" target="_top">Double Speed: Sparse Hessian</a><br/>
	8304	<a href="double_poly.cpp.xml" target="_top">Double Speed: Evaluate a Polynomial</a><br/>
	8305	<a href="double_ode.cpp.xml" target="_top">Double Speed: Ode Solution</a><br/>
	8306	<a href="double_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication (Double Version)</a><br/>
	8307	<a href="double_det_lu.cpp.xml" target="_top">Double Speed: Determinant Using Lu Factorization</a><br/>
	8308	<a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
2334	8309	speed<b>_</b>test <a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
2335	8310	example <a href="speed_test.cpp.xml" target="_top">speed_test: Example and test</a><br/>
2336		sqrt<br/>
	8311	speed<b>_</b>test<b>:</b> <a href="speed_test.cpp.xml" target="_top">speed_test: Example and test</a><br/>
	8312	speedtest <a href="speed_program.cpp.xml" target="_top">Example Use of SpeedTest</a><br/>
	8313	sqrt <a href="sqrt.cpp.xml" target="_top">The AD sqrt Function: Example and Test</a><br/>
	8314	<a href="std_math_ad.xml#Derivatives.sqrt" target="_top">AD Standard Math Unary Functions: Derivatives.sqrt</a><br/>
2337	8315	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
2338	8316	AD<b> </b>example <a href="sqrt.cpp.xml" target="_top">The AD sqrt Function: Example and Test</a><br/>
2339	8317	forward<b> </b>theory <a href="sqrtforward.xml" target="_top">Square Root Function Forward Taylor Polynomial Theory</a><br/>
2340	8318	reverse<b> </b>theory <a href="sqrtreverse.xml" target="_top">Square Root Function Reverse Mode Theory</a><br/>
2341		standard<br/>
	8319	square <a href="sqrtreverse.xml" target="_top">Square Root Function Reverse Mode Theory</a><br/>
	8320	<a href="sqrtforward.xml" target="_top">Square Root Function Forward Taylor Polynomial Theory</a><br/>
	8321	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	8322	<a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
	8323	<a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
	8324	squared<b>:</b> <a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>
	8325	st <a href="atomic_rev_sparse_jac.xml#Implementation.st" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Implementation.st</a><br/>
	8326	stability <a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
	8327	stable <a href="download.xml#Subversion.Stable Versions" target="_top">Download The CppAD Source Code: Subversion.Stable Versions</a><br/>
	8328	stack <a href="stack_machine.cpp.xml" target="_top">Example Differentiating a Stack Machine Interpreter</a><br/>
	8329	standard <a href="reversetheory.xml#Standard Math Functions" target="_top">The Theory of Reverse Mode: Standard Math Functions</a><br/>
	8330	<a href="forwardtheory.xml#Standard Math Functions" target="_top">The Theory of Forward Mode: Standard Math Functions</a><br/>
	8331	<a href="base_double.hpp.xml#Unary Standard Math" target="_top">Enable use of AD<Base> where Base is double: Unary Standard Math</a><br/>
	8332	<a href="base_float.hpp.xml#Unary Standard Math" target="_top">Enable use of AD<Base> where Base is float: Unary Standard Math</a><br/>
	8333	<a href="base_adolc.hpp.xml#Unary Standard Math" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Unary Standard Math</a><br/>
	8334	<a href="base_alloc.hpp.xml#Unary Standard Math" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Unary Standard Math</a><br/>
	8335	<a href="base_std_math.xml#Unary Standard Math" target="_top">Base Type Requirements for Standard Math Functions: Unary Standard Math</a><br/>
	8336	<a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
	8337	<a href="base_require.xml#Purpose.Standard Base Types" target="_top">AD<Base> Requirements for Base Type: Purpose.Standard Base Types</a><br/>
	8338	<a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
2342	8339	AD<b> </b>math<b> </b>unary <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
2343	8340	math<b> </b>function <a href="faq.xml#Namespace.Using" target="_top">Frequently Asked Questions and Answers: Namespace.Using</a><br/>
2344		start<br/>
	8341	start <a href="mul_level.xml#General Procedure.Start ADDBaseTape" target="_top">Using Multiple Levels of AD: General Procedure.Start ADDBaseTape</a><br/>
	8342	<a href="mul_level.xml#General Procedure.Start ADBaseTape" target="_top">Using Multiple Levels of AD: General Procedure.Start ADBaseTape</a><br/>
	8343	<a href="independent.xml#Start Recording" target="_top">Declare Independent Variables and Start Recording: Start Recording</a><br/>
	8344	<a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
	8345	<a href="atomic_matrix_mul.hpp.xml#Start Class Definition" target="_top">Matrix Multiply as an Atomic Operation: Start Class Definition</a><br/>
	8346	<a href="atomic_hes_sparse.cpp.xml#Start Class Definition" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Start Class Definition</a><br/>
	8347	<a href="atomic_tangent.cpp.xml#Start Class Definition" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Start Class Definition</a><br/>
	8348	<a href="atomic_reciprocal.cpp.xml#Start Class Definition" target="_top">Reciprocal as an Atomic Operation: Example and Test: Start Class Definition</a><br/>
	8349	<a href="atomic_norm_sq.cpp.xml#Start Class Definition" target="_top">Euclidean Norm Squared: Example and Test: Start Class Definition</a><br/>
	8350	<a href="atomic_get_started.cpp.xml#Start Class Definition" target="_top">Getting Started with Atomic Operations: Example and Test: Start Class Definition</a><br/>
2345	8351	recording <a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
2346	8352	using<b> </b>CppAD <a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
2347		started<br/>
	8353	started <a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	8354	<a href="atomic_base.xml#Examples.Getting Started" target="_top">User Defined Atomic AD Functions: Examples.Getting Started</a><br/>
	8355	<a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
2348	8356	getting <a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
2349		static<br/>
	8357	state <a href="capacity_order.xml#Original State" target="_top">Controlling Taylor Coefficients Memory Allocation: Original State</a><br/>
	8358	static <a href="old_atomic.xml#Syntax.Free Static Memory" target="_top">User Defined Atomic AD Functions: Syntax.Free Static Memory</a><br/>
	8359	<a href="atomic_base_clear.xml" target="_top">Free Static Variables</a><br/>
2350	8360	free<b> </b>atomic <a href="atomic_base_clear.xml" target="_top">Free Static Variables</a><br/>
2351	8361	memory<b> </b>leak<b> </b>check <a href="memory_leak.xml" target="_top">Memory Leak Detection</a><br/>
	8362	status <a href="cppad_ipopt_nlp.xml#solution.status" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: solution.status</a><br/>
	8363	<a href="ipopt_solve.xml#solution.status" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: solution.status</a><br/>
2352	8364	std<br/>
2353		test<b> </b>vector <a href="installunix.xml#--with-testvector" target="_top">Unix Test and Installation: --with-testvector</a><br/>
2354		stiff<br/>
	8365	test<b> </b>vector <a href="installunix.xml#--with-testvector" target="_top">Deprecated Unix Test and Installation: --with-testvector</a><br/>
	8366	std<b>::</b>complex<b><</b>double<b>></b> <a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
	8367	std<b>::</b>vector <a href="test_vector.xml#std::vector" target="_top">Choosing The Vector Testing Template Class: std::vector</a><br/>
	8368	<a href="testvector.xml#std::vector" target="_top">Using The CppAD Test Vector Template Class: std::vector</a><br/>
	8369	stegun <a href="bib.xml#Abramowitz and Stegun" target="_top">Bibliography: Abramowitz and Stegun</a><br/>
	8370	step <a href="odeerrcontrol.xml#Method.step" target="_top">An Error Controller for ODE Solvers: Method.step</a><br/>
	8371	<a href="install.xml#Instructions.Step 4: Install" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 4: Install</a><br/>
	8372	<a href="install.xml#Instructions.Step 3: Check" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 3: Check</a><br/>
	8373	<a href="install.xml#Instructions.Step 2: Cmake" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 2: Cmake</a><br/>
	8374	<a href="install.xml#Instructions.Step 1: Download" target="_top">CppAD Download, Test, and Install Instructions: Instructions.Step 1: Download</a><br/>
	8375	steps <a href="reverse_any.cpp.xml#Processing Steps" target="_top">Reverse Mode General Case: Example and Test: Processing Steps</a><br/>
	8376	stiff <a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
2355	8377	ODE <a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
2356	8378	Ode <a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
2357	8379	ode <a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
2358		storage<br/>
	8380	stop <a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
	8381	<a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
	8382	<a href="independent.xml#Stop Recording" target="_top">Declare Independent Variables and Start Recording: Stop Recording</a><br/>
	8383	storage <a href="lu_vec_ad.cpp.xml#Storage Convention" target="_top">Lu Factor and Solve with Recorded Pivoting: Storage Convention</a><br/>
	8384	<a href="luratio.xml#Matrix Storage" target="_top">LU Factorization of A Square Matrix and Stability Calculation: Matrix Storage</a><br/>
	8385	<a href="luinvert.xml#Matrix Storage" target="_top">Invert an LU Factored Equation: Matrix Storage</a><br/>
	8386	<a href="lufactor.xml#Matrix Storage" target="_top">LU Factorization of A Square Matrix: Matrix Storage</a><br/>
	8387	<a href="lusolve.xml#Matrix Storage" target="_top">Compute Determinant and Solve Linear Equations: Matrix Storage</a><br/>
2359	8388	tape <a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
2360		stream<br/>
	8389	storage<b>:</b> <a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
	8390	store <a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
	8391	stored <a href="size_order.xml" target="_top">Number Taylor Coefficient Orders Currently Stored</a><br/>
	8392	stream <a href="ad_output.xml" target="_top">AD Output Stream Operator</a><br/>
	8393	<a href="ad_input.xml" target="_top">AD Output Stream Operator</a><br/>
2361	8394	AD<b> </b>input <a href="ad_input.xml" target="_top">AD Output Stream Operator</a><br/>
2362	8395	AD<b> </b>output <a href="ad_output.xml" target="_top">AD Output Stream Operator</a><br/>
	8396	string <a href="ipopt_solve.xml#options.String" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: options.String</a><br/>
	8397	subset <a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
	8398	subsets <a href="cmake_check.xml#Subsets" target="_top">Checking the CppAD Examples and Tests: Subsets</a><br/>
2363	8399	subtract<br/>
2364	8400	AD<b> </b>example <a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
2365	8401	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
2366	8402	computed<b> </b>assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
2367		summation<br/>
	8403	subtraction <a href="reversetheory.xml#Binary Operators.Subtraction" target="_top">The Theory of Reverse Mode: Binary Operators.Subtraction</a><br/>
	8404	<a href="forwardtheory.xml#Binary Operators.Subtraction" target="_top">The Theory of Forward Mode: Binary Operators.Subtraction</a><br/>
	8405	<a href="compute_assign.xml#Derivative.Subtraction" target="_top">AD Computed Assignment Operators: Derivative.Subtraction</a><br/>
	8406	<a href="ad_binary.xml#Derivative.Subtraction" target="_top">AD Binary Arithmetic Operators: Derivative.Subtraction</a><br/>
	8407	subtraction<b>:</b> <a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
	8408	<a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
	8409	subversion <a href="download.xml#Subversion" target="_top">Download The CppAD Source Code: Subversion</a><br/>
	8410	suggestion <a href="base_require.xml#Integer.Suggestion" target="_top">AD<Base> Requirements for Base Type: Integer.Suggestion</a><br/>
	8411	sum <a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	8412	<a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
	8413	<a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
	8414	<a href="harmonic.cpp.xml#sum" target="_top">Multi-Threaded Implementation of Summation of 1/i: sum</a><br/>
	8415	summation <a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
	8416	<a href="harmonic.cpp.xml#Summation" target="_top">Multi-Threaded Implementation of Summation of 1/i: Summation</a><br/>
	8417	<a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
2368	8418	multi<b>_</b>thread<b> </b>speed <a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
2369		symbol<br/>
	8419	sweep <a href="reverse_identity.xml#Reverse Sweep" target="_top">An Important Reverse Mode Identity: Reverse Sweep</a><br/>
	8420	<a href="exp_eps_rev2.cpp.xml" target="_top">exp_eps: Verify Second Order Reverse Sweep</a><br/>
	8421	<a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a><br/>
	8422	<a href="exp_eps_rev1.cpp.xml" target="_top">exp_eps: Verify First Order Reverse Sweep</a><br/>
	8423	<a href="exp_eps_for1.cpp.xml" target="_top">exp_eps: Verify First Order Forward Sweep</a><br/>
	8424	<a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a><br/>
	8425	<a href="exp_eps_rev2.xml" target="_top">exp_eps: Second Order Reverse Sweep</a><br/>
	8426	<a href="exp_eps_for2.xml#Operation Sequence.Sweep" target="_top">exp_eps: Second Order Forward Mode: Operation Sequence.Sweep</a><br/>
	8427	<a href="exp_eps_rev1.xml" target="_top">exp_eps: First Order Reverse Sweep</a><br/>
	8428	<a href="exp_eps_for1.xml#Operation Sequence.Sweep" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence.Sweep</a><br/>
	8429	<a href="exp_eps_for1.xml" target="_top">exp_eps: First Order Forward Sweep</a><br/>
	8430	<a href="exp_eps_for0.xml#Operation Sequence.Sweep" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence.Sweep</a><br/>
	8431	<a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
	8432	<a href="exp_2_rev2.cpp.xml" target="_top">exp_2: Verify Second Order Reverse Sweep</a><br/>
	8433	<a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a><br/>
	8434	<a href="exp_2_rev1.cpp.xml" target="_top">exp_2: Verify First Order Reverse Sweep</a><br/>
	8435	<a href="exp_2_for1.cpp.xml" target="_top">exp_2: Verify First Order Forward Sweep</a><br/>
	8436	<a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a><br/>
	8437	<a href="exp_2_for2.xml#Operation Sequence.Sweep" target="_top">exp_2: Second Order Forward Mode: Operation Sequence.Sweep</a><br/>
	8438	<a href="exp_2_for1.xml#Operation Sequence.Sweep" target="_top">exp_2: First Order Forward Mode: Operation Sequence.Sweep</a><br/>
	8439	<a href="exp_2_for0.xml#Operation Sequence.Sweep" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Operation Sequence.Sweep</a><br/>
	8440	sweeps <a href="exp_eps_cppad.xml" target="_top">exp_eps: CppAD Forward and Reverse Sweeps</a><br/>
	8441	<a href="exp_2_cppad.xml" target="_top">exp_2: CppAD Forward and Reverse Sweeps</a><br/>
	8442	symbol <a href="faq.xml#Namespace.Test Vector Preprocessor Symbol" target="_top">Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol</a><br/>
2370	8443	preprocessor<b> </b>CPPAD<b>_</b> <a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a><br/>
2371		preprocessor<b> </b>CppAD <a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
2372		symbols<br/>
	8444	preprocessor<b> </b>CppAD <a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
	8445	symbols <a href="wishlist.xml#Preprocessor Symbols" target="_top">The CppAD Wish List: Preprocessor Symbols</a><br/>
	8446	<a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a><br/>
	8447	<a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
2373	8448	preprocessor <a href="faq.xml#Namespace.Test Vector Preprocessor Symbol" target="_top">Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol</a><br/>
	8449	syntax <a href="time_det_by_minor_c.xml#Syntax" target="_top">Determine Amount of Time to Execute det_by_minor: Syntax</a><br/>
	8450	<a href="elapsed_seconds_c.xml#Syntax" target="_top">Returns Elapsed Number of Seconds: Syntax</a><br/>
	8451	<a href="repeat_det_by_minor_c.xml#Syntax" target="_top">Repeat det_by_minor Routine A Specified Number of Times: Syntax</a><br/>
	8452	<a href="correct_det_by_minor_c.xml#Syntax" target="_top">Correctness Test of det_by_minor Routine: Syntax</a><br/>
	8453	<a href="uniform_01_c.xml#Syntax" target="_top">Simulate a [0,1] Uniform Random Variate: Syntax</a><br/>
	8454	<a href="det_by_minor_c.xml#Syntax" target="_top">Compute Determinant using Expansion by Minors: Syntax</a><br/>
	8455	<a href="det_of_minor_c.xml#Syntax" target="_top">Determinant of a Minor: Syntax</a><br/>
	8456	<a href="compare_c.xml#Syntax" target="_top">Compare Speed of C and C++: Syntax</a><br/>
	8457	<a href="old_mat_mul.hpp.xml#Syntax" target="_top">Define Matrix Multiply as a User Atomic Operation: Syntax</a><br/>
	8458	<a href="old_atomic.xml#Syntax" target="_top">User Defined Atomic AD Functions: Syntax</a><br/>
	8459	<a href="cppad_ipopt_nlp.xml#Syntax" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: Syntax</a><br/>
	8460	<a href="test_vector.xml#Syntax" target="_top">Choosing The Vector Testing Template Class: Syntax</a><br/>
	8461	<a href="epsilon.xml#Syntax" target="_top">Machine Epsilon For AD Types: Syntax</a><br/>
	8462	<a href="memory_leak.xml#Syntax" target="_top">Memory Leak Detection: Syntax</a><br/>
	8463	<a href="old_max_num_threads.xml#Syntax" target="_top">Set Maximum Number of Threads for omp_alloc Allocator: Syntax</a><br/>
	8464	<a href="omp_efficient.xml#Syntax" target="_top">Check If A Memory Allocation is Efficient for Another Use: Syntax</a><br/>
	8465	<a href="omp_delete_array.xml#Syntax" target="_top">Return A Raw Array to The Available Memory for a Thread: Syntax</a><br/>
	8466	<a href="omp_create_array.xml#Syntax" target="_top">Allocate Memory and Create A Raw Array: Syntax</a><br/>
	8467	<a href="omp_available.xml#Syntax" target="_top">Amount of Memory Available for Quick Use by a Thread: Syntax</a><br/>
	8468	<a href="omp_inuse.xml#Syntax" target="_top">Amount of Memory a Thread is Currently Using: Syntax</a><br/>
	8469	<a href="omp_free_available.xml#Syntax" target="_top">Free Memory Currently Available for Quick Use by a Thread: Syntax</a><br/>
	8470	<a href="omp_return_memory.xml#Syntax" target="_top">Return Memory to omp_alloc: Syntax</a><br/>
	8471	<a href="omp_get_memory.xml#Syntax" target="_top">Get At Least A Specified Amount of Memory: Syntax</a><br/>
	8472	<a href="omp_get_thread_num.xml#Syntax" target="_top">Get the Current OpenMP Thread Number: Syntax</a><br/>
	8473	<a href="omp_in_parallel.xml#Syntax" target="_top">Is The Current Execution in OpenMP Parallel Mode: Syntax</a><br/>
	8474	<a href="omp_max_num_threads.xml#Syntax" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator: Syntax</a><br/>
	8475	<a href="omp_alloc.xml#Syntax" target="_top">A Quick OpenMP Memory Allocator Used by CppAD: Syntax</a><br/>
	8476	<a href="tracknewdel.xml#Syntax" target="_top">Routines That Track Use of New and Delete: Syntax</a><br/>
	8477	<a href="omp_max_thread.xml#Syntax" target="_top">OpenMP Parallel Setup: Syntax</a><br/>
	8478	<a href="fundeprecated.xml#Syntax" target="_top">ADFun Object Deprecated Member Functions: Syntax</a><br/>
	8479	<a href="adolc_alloc_mat.xml#Syntax" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix: Syntax</a><br/>
	8480	<a href="uniform_01.xml#Syntax" target="_top">Simulate a [0,1] Uniform Random Variate: Syntax</a><br/>
	8481	<a href="sparse_hes_fun.xml#Syntax" target="_top">Evaluate a Function That Has a Sparse Hessian: Syntax</a><br/>
	8482	<a href="sparse_jac_fun.xml#Syntax" target="_top">Evaluate a Function That Has a Sparse Jacobian: Syntax</a><br/>
	8483	<a href="ode_evaluate.xml#Syntax" target="_top">Evaluate a Function Defined in Terms of an ODE: Syntax</a><br/>
	8484	<a href="mat_sum_sq.xml#Syntax" target="_top">Sum Elements of a Matrix Times Itself: Syntax</a><br/>
	8485	<a href="det_grad_33.xml#Syntax" target="_top">Check Gradient of Determinant of 3 by 3 matrix: Syntax</a><br/>
	8486	<a href="det_33.xml#Syntax" target="_top">Check Determinant of 3 by 3 matrix: Syntax</a><br/>
	8487	<a href="det_by_minor.xml#Syntax" target="_top">Determinant Using Expansion by Minors: Syntax</a><br/>
	8488	<a href="det_of_minor.xml#Syntax" target="_top">Determinant of a Minor: Syntax</a><br/>
	8489	<a href="det_by_lu.xml#Syntax" target="_top">Determinant Using Expansion by Lu Factorization: Syntax</a><br/>
	8490	<a href="microsoft_timer.xml#Syntax" target="_top">Microsoft Version of Elapsed Number of Seconds: Syntax</a><br/>
	8491	<a href="speed_main.xml#Syntax" target="_top">Running the Speed Test Program: Syntax</a><br/>
	8492	<a href="testvector.xml#Syntax" target="_top">Using The CppAD Test Vector Template Class: Syntax</a><br/>
	8493	<a href="lu_vec_ad.cpp.xml#Syntax" target="_top">Lu Factor and Solve with Recorded Pivoting: Syntax</a><br/>
	8494	<a href="cppad_eigen.hpp.xml#Syntax" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: Syntax</a><br/>
	8495	<a href="ipopt_solve.xml#Syntax" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Syntax</a><br/>
	8496	<a href="luratio.xml#Syntax" target="_top">LU Factorization of A Square Matrix and Stability Calculation: Syntax</a><br/>
	8497	<a href="opt_val_hes.xml#Syntax" target="_top">Jacobian and Hessian of Optimal Values: Syntax</a><br/>
	8498	<a href="benderquad.xml#Syntax" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: Syntax</a><br/>
	8499	<a href="index_sort.xml#Syntax" target="_top">Returns Indices that Sort a Vector: Syntax</a><br/>
	8500	<a href="ta_free_all.xml#Syntax" target="_top">Free All Memory That Was Allocated for Use by thread_alloc: Syntax</a><br/>
	8501	<a href="ta_delete_array.xml#Syntax" target="_top">Deallocate An Array and Call Destructor for its Elements: Syntax</a><br/>
	8502	<a href="ta_create_array.xml#Syntax" target="_top">Allocate An Array and Call Default Constructor for its Elements: Syntax</a><br/>
	8503	<a href="ta_available.xml#Syntax" target="_top">Amount of Memory Available for Quick Use by a Thread: Syntax</a><br/>
	8504	<a href="ta_inuse.xml#Syntax" target="_top">Amount of Memory a Thread is Currently Using: Syntax</a><br/>
	8505	<a href="ta_hold_memory.xml#Syntax" target="_top">Control When Thread Alloc Retains Memory For Future Use: Syntax</a><br/>
	8506	<a href="ta_free_available.xml#Syntax" target="_top">Free Memory Currently Available for Quick Use by a Thread: Syntax</a><br/>
	8507	<a href="ta_return_memory.xml#Syntax" target="_top">Return Memory to thread_alloc: Syntax</a><br/>
	8508	<a href="ta_get_memory.xml#Syntax" target="_top">Get At Least A Specified Amount of Memory: Syntax</a><br/>
	8509	<a href="ta_thread_num.xml#Syntax" target="_top">Get the Current Thread Number: Syntax</a><br/>
	8510	<a href="ta_in_parallel.xml#Syntax" target="_top">Is The Current Execution in Parallel Mode: Syntax</a><br/>
	8511	<a href="ta_num_threads.xml#Syntax" target="_top">Get Number of Threads: Syntax</a><br/>
	8512	<a href="ta_parallel_setup.xml#Syntax" target="_top">Setup thread_alloc For Use in Multi-Threading Environment: Syntax</a><br/>
	8513	<a href="thread_alloc.xml#Syntax" target="_top">A Fast Multi-Threading Memory Allocator: Syntax</a><br/>
	8514	<a href="cppad_vector.xml#Syntax" target="_top">The CppAD::vector Template Class: Syntax</a><br/>
	8515	<a href="odegearcontrol.xml#Syntax" target="_top">An Error Controller for Gear's Ode Solvers: Syntax</a><br/>
	8516	<a href="odegear.xml#Syntax" target="_top">An Arbitrary Order Gear Method: Syntax</a><br/>
	8517	<a href="odeerrcontrol.xml#Syntax" target="_top">An Error Controller for ODE Solvers: Syntax</a><br/>
	8518	<a href="rosen34.xml#Syntax" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Syntax</a><br/>
	8519	<a href="runge45.xml#Syntax" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Syntax</a><br/>
	8520	<a href="rombergmul.xml#Syntax" target="_top">Multi-dimensional Romberg Integration: Syntax</a><br/>
	8521	<a href="rombergone.xml#Syntax" target="_top">One DimensionalRomberg Integration: Syntax</a><br/>
	8522	<a href="luinvert.xml#Syntax" target="_top">Invert an LU Factored Equation: Syntax</a><br/>
	8523	<a href="lufactor.xml#Syntax" target="_top">LU Factorization of A Square Matrix: Syntax</a><br/>
	8524	<a href="lusolve.xml#Syntax" target="_top">Compute Determinant and Solve Linear Equations: Syntax</a><br/>
	8525	<a href="poly.xml#Syntax" target="_top">Evaluate a Polynomial or its Derivative: Syntax</a><br/>
	8526	<a href="pow_int.xml#Syntax" target="_top">The Integer Power Function: Syntax</a><br/>
	8527	<a href="nan.xml#Syntax" target="_top">Obtain Nan or Determine if a Value is Nan: Syntax</a><br/>
	8528	<a href="checksimplevector.xml#Syntax" target="_top">Check Simple Vector Concept: Syntax</a><br/>
	8529	<a href="checknumerictype.xml#Syntax" target="_top">Check NumericType Class Concept: Syntax</a><br/>
	8530	<a href="elapsed_seconds.xml#Syntax" target="_top">Returns Elapsed Number of Seconds: Syntax</a><br/>
	8531	<a href="time_test.xml#Syntax" target="_top">Determine Amount of Time to Execute a Test: Syntax</a><br/>
	8532	<a href="speedtest.xml#Syntax" target="_top">Run One Speed Test and Print Results: Syntax</a><br/>
	8533	<a href="speed_test.xml#Syntax" target="_top">Run One Speed Test and Return Results: Syntax</a><br/>
	8534	<a href="nearequal.xml#Syntax" target="_top">Determine if Two Values Are Nearly Equal: Syntax</a><br/>
	8535	<a href="cppad_assert.xml#Syntax" target="_top">CppAD Assertions During Execution: Syntax</a><br/>
	8536	<a href="errorhandler.xml#Syntax" target="_top">Replacing the CppAD Error Handler: Syntax</a><br/>
	8537	<a href="team_thread.hpp.xml#Syntax" target="_top">Specifications for A Team of AD Threads: Syntax</a><br/>
	8538	<a href="multi_newton_work.cpp.xml#Syntax" target="_top">Multi-threading Newton Method Utility Routines: Syntax</a><br/>
	8539	<a href="multi_newton_time.cpp.xml#Syntax" target="_top">Timing Test of Multi-Threaded Newton Method: Syntax</a><br/>
	8540	<a href="multi_newton.cpp.xml#Syntax" target="_top">A Multi-Threaded Newton's Method: Syntax</a><br/>
	8541	<a href="harmonic_work.cpp.xml#Syntax" target="_top">Multi-threading Sum of 1/i Utility Routines: Syntax</a><br/>
	8542	<a href="harmonic_time.cpp.xml#Syntax" target="_top">Timing Test of Multi-Threaded Summation of 1/i: Syntax</a><br/>
	8543	<a href="harmonic.cpp.xml#Syntax" target="_top">Multi-Threaded Implementation of Summation of 1/i: Syntax</a><br/>
	8544	<a href="thread_test.cpp.xml#Syntax" target="_top">Run Multi-Threading Examples and Speed Tests: Syntax</a><br/>
	8545	<a href="parallel_ad.xml#Syntax" target="_top">Enable AD Calculations During Parallel Mode: Syntax</a><br/>
	8546	<a href="check_for_nan.xml#Syntax" target="_top">Check an ADFun Object For Nan: Syntax</a><br/>
	8547	<a href="optimize.xml#Syntax" target="_top">Optimize an ADFun Object Tape: Syntax</a><br/>
	8548	<a href="funcheck.xml#Syntax" target="_top">Check an ADFun Sequence of Operations: Syntax</a><br/>
	8549	<a href="sparse_hessian.xml#Syntax" target="_top">Sparse Hessian: Easy Driver: Syntax</a><br/>
	8550	<a href="sparse_jacobian.xml#Syntax" target="_top">Sparse Jacobian: Easy Driver: Syntax</a><br/>
	8551	<a href="revtwo.xml#Syntax" target="_top">Reverse Mode Second Partial Derivative Driver: Syntax</a><br/>
	8552	<a href="fortwo.xml#Syntax" target="_top">Forward Mode Second Partial Derivative Driver: Syntax</a><br/>
	8553	<a href="hessian.xml#Syntax" target="_top">Hessian: Easy Driver: Syntax</a><br/>
	8554	<a href="revone.xml#Syntax" target="_top">First Order Derivative: Driver Routine: Syntax</a><br/>
	8555	<a href="forone.xml#Syntax" target="_top">First Order Partial Derivative: Driver Routine: Syntax</a><br/>
	8556	<a href="jacobian.xml#Syntax" target="_top">Jacobian: Driver Routine: Syntax</a><br/>
	8557	<a href="revsparsehes.xml#Syntax" target="_top">Hessian Sparsity Pattern: Reverse Mode: Syntax</a><br/>
	8558	<a href="revsparsejac.xml#Syntax" target="_top">Jacobian Sparsity Pattern: Reverse Mode: Syntax</a><br/>
	8559	<a href="forsparsejac.xml#Syntax" target="_top">Jacobian Sparsity Pattern: Forward Mode: Syntax</a><br/>
	8560	<a href="reverse_any.xml#Syntax" target="_top">Any Order Reverse Mode: Syntax</a><br/>
	8561	<a href="reverse_two.xml#Syntax" target="_top">Second Order Reverse Mode: Syntax</a><br/>
	8562	<a href="reverse_one.xml#Syntax" target="_top">First Order Reverse Mode: Syntax</a><br/>
	8563	<a href="number_skip.xml#Syntax" target="_top">Number of Variables that Can be Skipped: Syntax</a><br/>
	8564	<a href="capacity_order.xml#Syntax" target="_top">Controlling Taylor Coefficients Memory Allocation: Syntax</a><br/>
	8565	<a href="comparechange.xml#Syntax" target="_top">Comparison Changes During Zero Order Forward Mode: Syntax</a><br/>
	8566	<a href="size_order.xml#Syntax" target="_top">Number Taylor Coefficient Orders Currently Stored: Syntax</a><br/>
	8567	<a href="forward_dir.xml#Syntax" target="_top">Multiple Directions Forward Mode: Syntax</a><br/>
	8568	<a href="forward_order.xml#Syntax" target="_top">Multiple Order Forward Mode: Syntax</a><br/>
	8569	<a href="forward_two.xml#Syntax" target="_top">Second Order Forward Mode: Derivative Values: Syntax</a><br/>
	8570	<a href="forward_one.xml#Syntax" target="_top">First Order Forward Mode: Derivative Values: Syntax</a><br/>
	8571	<a href="forward_zero.xml#Syntax" target="_top">Zero Order Forward Mode: Function Values: Syntax</a><br/>
	8572	<a href="seq_property.xml#Syntax" target="_top">ADFun Sequence Properties: Syntax</a><br/>
	8573	<a href="abort_recording.xml#Syntax" target="_top">Abort Recording of an Operation Sequence: Syntax</a><br/>
	8574	<a href="dependent.xml#Syntax" target="_top">Stop Recording and Store Operation Sequence: Syntax</a><br/>
	8575	<a href="funconstruct.xml#Syntax" target="_top">Construct an ADFun Object and Stop Recording: Syntax</a><br/>
	8576	<a href="independent.xml#Syntax" target="_top">Declare Independent Variables and Start Recording: Syntax</a><br/>
	8577	<a href="base_adolc.hpp.xml#Syntax" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Syntax</a><br/>
	8578	<a href="base_require.xml#Syntax" target="_top">AD<Base> Requirements for Base Type: Syntax</a><br/>
	8579	<a href="vecad.xml#Syntax" target="_top">AD Vectors that Record Index Operations: Syntax</a><br/>
	8580	<a href="equalopseq.xml#Syntax" target="_top">Check if Two Value are Identically Equal: Syntax</a><br/>
	8581	<a href="parvar.xml#Syntax" target="_top">Is an AD Object a Parameter or Variable: Syntax</a><br/>
	8582	<a href="boolfun.xml#Syntax" target="_top">AD Boolean Functions: Syntax</a><br/>
	8583	<a href="nearequalext.xml#Syntax" target="_top">Compare AD and Base Objects for Nearly Equal: Syntax</a><br/>
	8584	<a href="compare.xml#Syntax" target="_top">AD Binary Comparison Operators: Syntax</a><br/>
	8585	<a href="atomic_base_clear.xml#Syntax" target="_top">Free Static Variables: Syntax</a><br/>
	8586	<a href="atomic_rev_sparse_hes.xml#Syntax" target="_top">Atomic Reverse Hessian Sparsity Patterns: Syntax</a><br/>
	8587	<a href="atomic_rev_sparse_jac.xml#Syntax" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Syntax</a><br/>
	8588	<a href="atomic_for_sparse_jac.xml#Syntax" target="_top">Atomic Forward Jacobian Sparsity Patterns: Syntax</a><br/>
	8589	<a href="atomic_reverse.xml#Syntax" target="_top">Atomic Reverse Mode: Syntax</a><br/>
	8590	<a href="atomic_forward.xml#Syntax" target="_top">Atomic Forward Mode: Syntax</a><br/>
	8591	<a href="atomic_afun.xml#Syntax" target="_top">Using AD Version of Atomic Function: Syntax</a><br/>
	8592	<a href="atomic_option.xml#Syntax" target="_top">Set Atomic Function Options: Syntax</a><br/>
	8593	<a href="atomic_ctor.xml#Syntax" target="_top">Atomic Function Constructor: Syntax</a><br/>
	8594	<a href="atomic_base.xml#Syntax" target="_top">User Defined Atomic AD Functions: Syntax</a><br/>
	8595	<a href="checkpoint.xml#Syntax" target="_top">Checkpointing Functions: Syntax</a><br/>
	8596	<a href="discrete.xml#Syntax" target="_top">Discrete AD Functions: Syntax</a><br/>
	8597	<a href="condexp.xml#Syntax" target="_top">AD Conditional Expressions: Syntax</a><br/>
	8598	<a href="limits.xml#Syntax" target="_top">Numeric Limits For an AD and Base Types: Syntax</a><br/>
	8599	<a href="pow.xml#Syntax" target="_top">The AD Power Function: Syntax</a><br/>
	8600	<a href="erf.xml#Syntax" target="_top">The AD Error Function: Syntax</a><br/>
	8601	<a href="atan2.xml#Syntax" target="_top">AD Two Argument Inverse Tangent Function: Syntax</a><br/>
	8602	<a href="sign.xml#Syntax" target="_top">Sign Function: Syntax</a><br/>
	8603	<a href="abs.xml#Syntax" target="_top">AD Absolute Value Function: Syntax</a><br/>
	8604	<a href="std_math_ad.xml#Syntax" target="_top">AD Standard Math Unary Functions: Syntax</a><br/>
	8605	<a href="compute_assign.xml#Syntax" target="_top">AD Computed Assignment Operators: Syntax</a><br/>
	8606	<a href="ad_binary.xml#Syntax" target="_top">AD Binary Arithmetic Operators: Syntax</a><br/>
	8607	<a href="unaryminus.xml#Syntax" target="_top">AD Unary Minus Operator: Syntax</a><br/>
	8608	<a href="unaryplus.xml#Syntax" target="_top">AD Unary Plus Operator: Syntax</a><br/>
	8609	<a href="var2par.xml#Syntax" target="_top">Convert an AD Variable to a Parameter: Syntax</a><br/>
	8610	<a href="printfor.xml#Syntax" target="_top">Printing AD Values During Forward Mode: Syntax</a><br/>
	8611	<a href="ad_output.xml#Syntax" target="_top">AD Output Stream Operator: Syntax</a><br/>
	8612	<a href="ad_input.xml#Syntax" target="_top">AD Output Stream Operator: Syntax</a><br/>
	8613	<a href="integer.xml#Syntax" target="_top">Convert From AD to Integer: Syntax</a><br/>
	8614	<a href="value.xml#Syntax" target="_top">Convert From an AD Type to its Base Type: Syntax</a><br/>
	8615	<a href="ad_assign.xml#Syntax" target="_top">AD Assignment Operator: Syntax</a><br/>
	8616	<a href="ad_ctor.xml#Syntax" target="_top">AD Constructors: Syntax</a><br/>
	8617	<a href="exp_eps.xml#Syntax" target="_top">An Epsilon Accurate Exponential Approximation: Syntax</a><br/>
	8618	<a href="exp_2.xml#Syntax" target="_top">Second Order Exponential Approximation: Syntax</a><br/>
	8619	<a href="get_sacado.sh.xml#Syntax" target="_top">Download and Install Sacado in Build Directory: Syntax</a><br/>
	8620	<a href="get_ipopt.sh.xml#Syntax" target="_top">Download and Install Ipopt in Build Directory: Syntax</a><br/>
	8621	<a href="get_fadbad.sh.xml#Syntax" target="_top">Download and Install Fadbad in Build Directory: Syntax</a><br/>
	8622	<a href="get_eigen.sh.xml#Syntax" target="_top">Download and Install Eigen in Build Directory: Syntax</a><br/>
	8623	<a href="get_colpack.sh.xml#Syntax" target="_top">Download and Install ColPack in Build Directory: Syntax</a><br/>
	8624	<a href="get_adolc.sh.xml#Syntax" target="_top">Download and Install Adolc in Build Directory: Syntax</a><br/>
	8625	<a href="cppad.xml#Syntax" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms: Syntax</a><br/>
	8626	systems <a href="elapsed_seconds.xml#Microsoft Systems" target="_top">Returns Elapsed Number of Seconds: Microsoft Systems</a><br/>
2374	8627
2375	8628	<b><big><a name="T">T</a></big></b>
2376	8629	<br/>

2383	8636	TrackDelVec <a href="tracknewdel.xml#TrackDelVec" target="_top">Routines That Track Use of New and Delete: TrackDelVec</a><br/>
2384	8637	TrackExtend <a href="tracknewdel.xml#TrackExtend" target="_top">Routines That Track Use of New and Delete: TrackExtend</a><br/>
2385	8638	TrackNewVec <a href="tracknewdel.xml#TrackNewVec" target="_top">Routines That Track Use of New and Delete: TrackNewVec</a><br/>
2386		tan<br/>
	8639	t <a href="old_atomic.xml#rev_hes_sparse.t" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.t</a><br/>
	8640	<a href="odegearcontrol.xml#Fun.t" target="_top">An Error Controller for Gear's Ode Solvers: Fun.t</a><br/>
	8641	<a href="odegear.xml#T" target="_top">An Arbitrary Order Gear Method: T</a><br/>
	8642	<a href="odegear.xml#Fun.t" target="_top">An Arbitrary Order Gear Method: Fun.t</a><br/>
	8643	<a href="rosen34.xml#Fun.t" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.t</a><br/>
	8644	<a href="runge45.xml#Fun.t" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Fun.t</a><br/>
	8645	<a href="atomic_rev_sparse_hes.xml#Implementation.t" target="_top">Atomic Reverse Hessian Sparsity Patterns: Implementation.t</a><br/>
	8646	tan <a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	8647	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	8648	<a href="tan.cpp.xml" target="_top">The AD tan Function: Example and Test</a><br/>
	8649	<a href="std_math_ad.xml#Derivatives.tan" target="_top">AD Standard Math Unary Functions: Derivatives.tan</a><br/>
2387	8650	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
2388	8651	AD<b> </b>inverse <a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a><br/>
2389	8652	atomic<b> </b>operation <a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>

2391	8654	forward<b> </b>theory <a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
2392	8655	old<b>_</b>atomic <a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
2393	8656	reverse<b> </b>theory <a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
2394		tangent<br/>
	8657	tangent <a href="old_atomic.xml#Example.Tangent Function" target="_top">User Defined Atomic AD Functions: Example.Tangent Function</a><br/>
	8658	<a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
	8659	<a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
	8660	<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
	8661	<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
	8662	<a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a><br/>
2395	8663	atomic<b> </b>operation <a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
2396		tanh<br/>
	8664	tanh <a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	8665	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	8666	<a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a><br/>
	8667	<a href="std_math_ad.xml#Derivatives.tanh" target="_top">AD Standard Math Unary Functions: Derivatives.tanh</a><br/>
2397	8668	AD <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
2398	8669	example <a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a><br/>
2399	8670	tape <a href="glossary.xml#Tape" target="_top">Glossary: Tape</a><br/>
	8671	<a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
	8672	<a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
2400	8673	AD<b> </b>index <a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
2401	8674	abort<b> </b>recording <a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
2402	8675	array<b> </b>index<b> </b>operation <a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
2403	8676	avoid <a href="faq.xml#Independent Variables" target="_top">Frequently Asked Questions and Answers: Independent Variables</a><br/>
2404	8677	interpolate <a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
2405	8678	interpolate <a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
2406		memory <a href="installunix.xml#tape_id_type" target="_top">Unix Test and Installation: tape_id_type</a><br/>
2407		memory <a href="installunix.xml#tape_addr_type" target="_top">Unix Test and Installation: tape_addr_type</a><br/>
	8679	memory <a href="installunix.xml#tape_id_type" target="_top">Deprecated Unix Test and Installation: tape_id_type</a><br/>
	8680	memory <a href="installunix.xml#tape_addr_type" target="_top">Deprecated Unix Test and Installation: tape_addr_type</a><br/>
2408	8681	memory <a href="cmake.xml#cppad_tape_addr_type" target="_top">Using CMake to Configure CppAD: cppad_tape_addr_type</a><br/>
2409	8682	memory <a href="cmake.xml#cppad_tape_id_type" target="_top">Using CMake to Configure CppAD: cppad_tape_id_type</a><br/>
2410	8683	optimize <a href="wishlist.xml#Optimization" target="_top">The CppAD Wish List: Optimization</a><br/>

2412	8685	stop<b> </b>recording <a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
2413	8686	stop<b> </b>recording <a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
2414	8687	storage <a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
2415		taping<br/>
	8688	tape<b>_</b>addr<b>_</b>type <a href="installunix.xml#tape_addr_type" target="_top">Deprecated Unix Test and Installation: tape_addr_type</a><br/>
	8689	tape<b>_</b>id<b>_</b>type <a href="installunix.xml#tape_id_type" target="_top">Deprecated Unix Test and Installation: tape_id_type</a><br/>
	8690	tapes<b>:</b> <a href="mul_level.cpp.xml" target="_top">Multiple Tapes: Example and Test</a><br/>
	8691	taping <a href="dependent.xml#Taping" target="_top">Stop Recording and Store Operation Sequence: Taping</a><br/>
	8692	<a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
2416	8693	Value<b> </b>during <a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	8694	taping<b>:</b> <a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
	8695	tar <a href="download.xml#Compressed Tar File" target="_top">Download The CppAD Source Code: Compressed Tar File</a><br/>
2417	8696	taylor <a href="glossary.xml#Taylor Coefficient" target="_top">Glossary: Taylor Coefficient</a><br/>
2418		taylor<b>_</b>size<br/>
	8697	<a href="reversetheory.xml#Taylor Notation" target="_top">The Theory of Reverse Mode: Taylor Notation</a><br/>
	8698	<a href="erf_forward.xml#Taylor Coefficients Recursion" target="_top">Error Function Forward Taylor Polynomial Theory: Taylor Coefficients Recursion</a><br/>
	8699	<a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a><br/>
	8700	<a href="tan_forward.xml#Taylor Coefficients Recursion" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory: Taylor Coefficients Recursion</a><br/>
	8701	<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
	8702	<a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a><br/>
	8703	<a href="asinforward.xml" target="_top">Arcsine Function Forward Taylor Polynomial Theory</a><br/>
	8704	<a href="atanforward.xml" target="_top">Arctangent Function Forward Taylor Polynomial Theory</a><br/>
	8705	<a href="sqrtforward.xml" target="_top">Square Root Function Forward Taylor Polynomial Theory</a><br/>
	8706	<a href="logforward.xml" target="_top">Logarithm Function Forward Taylor Polynomial Theory</a><br/>
	8707	<a href="expforward.xml" target="_top">Exponential Function Forward Taylor Polynomial Theory</a><br/>
	8708	<a href="forwardtheory.xml#Standard Math Functions.Taylor Coefficients Recursion Formula" target="_top">The Theory of Forward Mode: Standard Math Functions.Taylor Coefficients Recursion Formula</a><br/>
	8709	<a href="forwardtheory.xml#Taylor Notation" target="_top">The Theory of Forward Mode: Taylor Notation</a><br/>
	8710	<a href="reverse_three.cpp.xml#Taylor Coefficients" target="_top">Third Order Reverse Mode: Example and Test: Taylor Coefficients</a><br/>
	8711	<a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	8712	<a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
	8713	<a href="size_order.xml" target="_top">Number Taylor Coefficient Orders Currently Stored</a><br/>
	8714	<a href="funconstruct.xml#Assignment Operator.Taylor Coefficients" target="_top">Construct an ADFun Object and Stop Recording: Assignment Operator.Taylor Coefficients</a><br/>
	8715	taylor<b>'</b>s <a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	8716	<a href="mul_level_adolc_ode.cpp.xml#Taylor's Method Using AD" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Taylor's Method Using AD</a><br/>
	8717	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	8718	<a href="mul_level_ode.cpp.xml#Taylor's Method Using AD" target="_top">Taylor's Ode Solver: An Example and Test: Taylor's Method Using AD</a><br/>
	8719	<a href="mul_level_ode.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	8720	taylor<b>_</b>size <a href="fundeprecated.xml#taylor_size" target="_top">ADFun Object Deprecated Member Functions: taylor_size</a><br/>
2419	8721	ADFun <a href="fundeprecated.xml#taylor_size" target="_top">ADFun Object Deprecated Member Functions: taylor_size</a><br/>
2420		team<br/>
	8722	team <a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
	8723	<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
	8724	<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
	8725	<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
	8726	<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
	8727	<a href="thread_test.cpp.xml#Team Implementations" target="_top">Run Multi-Threading Examples and Speed Tests: Team Implementations</a><br/>
2421	8728	AD<b> </b>bthread <a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
2422	8729	AD<b> </b>openmp <a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
2423	8730	AD<b> </b>pthread <a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
2424	8731	AD<b> </b>threads <a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
2425		template<br/>
	8732	team<b>_</b>create <a href="team_thread.hpp.xml#team_create" target="_top">Specifications for A Team of AD Threads: team_create</a><br/>
	8733	team<b>_</b>destroy <a href="team_thread.hpp.xml#team_destroy" target="_top">Specifications for A Team of AD Threads: team_destroy</a><br/>
	8734	team<b>_</b>example <a href="thread_test.cpp.xml#team_example" target="_top">Run Multi-Threading Examples and Speed Tests: team_example</a><br/>
	8735	team<b>_</b>name <a href="team_thread.hpp.xml#team_name" target="_top">Specifications for A Team of AD Threads: team_name</a><br/>
	8736	team<b>_</b>work <a href="team_thread.hpp.xml#team_work" target="_top">Specifications for A Team of AD Threads: team_work</a><br/>
	8737	template <a href="test_vector.xml" target="_top">Choosing The Vector Testing Template Class</a><br/>
	8738	<a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a><br/>
	8739	<a href="example.xml#The CppAD Test Vector Template Class" target="_top">Examples: The CppAD Test Vector Template Class</a><br/>
	8740	<a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
	8741	<a href="cppad_vector.xml" target="_top">The CppAD::vector Template Class</a><br/>
	8742	<a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a><br/>
	8743	<a href="simplevector.xml#Template Class Requirements" target="_top">Definition of a Simple Vector: Template Class Requirements</a><br/>
	8744	<a href="library.xml#CppAD Numerical Template Library" target="_top">The CppAD General Purpose Library: CppAD Numerical Template Library</a><br/>
	8745	<a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a><br/>
2426	8746	CppAD<b> </b>vector<b> </b>class <a href="cppad_vector.xml" target="_top">The CppAD::vector Template Class</a><br/>
2427	8747	numerical<b> </b>C<b>++ </b>library <a href="library.xml" target="_top">The CppAD General Purpose Library</a><br/>
2428	8748	polynomial<b> </b>derivative <a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
2429	8749	simple<b> </b>vector<b> </b>class <a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
2430		test <a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
	8750	terms <a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
	8751	test <a href="correct_det_by_minor_c.xml" target="_top">Correctness Test of det_by_minor Routine</a><br/>
	8752	<a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	8753	<a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	8754	<a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
	8755	<a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
	8756	<a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	8757	<a href="omp_alloc.cpp.xml" target="_top">OpenMP Memory Allocator: Example and Test</a><br/>
	8758	<a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
	8759	<a href="faq.xml#Namespace.Test Vector Preprocessor Symbol" target="_top">Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol</a><br/>
	8760	<a href="speed_sacado.xml" target="_top">Speed Test Derivatives Using Sacado</a><br/>
	8761	<a href="speed_fadbad.xml" target="_top">Speed Test Derivatives Using Fadbad</a><br/>
	8762	<a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a><br/>
	8763	<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
	8764	<a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
	8765	<a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
	8766	<a href="sparse_hes_fun.cpp.xml" target="_top">sparse_hes_fun: Example and test</a><br/>
	8767	<a href="sparse_jac_fun.cpp.xml" target="_top">sparse_jac_fun: Example and test</a><br/>
	8768	<a href="ode_evaluate.cpp.xml" target="_top">ode_evaluate: Example and test</a><br/>
	8769	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	8770	<a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
	8771	<a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
	8772	<a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a><br/>
	8773	<a href="speed_main.xml#test" target="_top">Running the Speed Test Program: test</a><br/>
	8774	<a href="speed_main.xml" target="_top">Running the Speed Test Program</a><br/>
	8775	<a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
	8776	<a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a><br/>
	8777	<a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	8778	<a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	8779	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	8780	<a href="mul_level_ode.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
	8781	<a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
	8782	<a href="mul_level.cpp.xml" target="_top">Multiple Tapes: Example and Test</a><br/>
	8783	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	8784	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	8785	<a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
	8786	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
	8787	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	8788	<a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
	8789	<a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
	8790	<a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
	8791	<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	8792	<a href="example.xml#The CppAD Test Vector Template Class" target="_top">Examples: The CppAD Test Vector Template Class</a><br/>
	8793	<a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a><br/>
	8794	<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	8795	<a href="lu_ratio.cpp.xml" target="_top">LuRatio: Example and Test</a><br/>
	8796	<a href="opt_val_hes.cpp.xml" target="_top">opt_val_hes: Example and Test</a><br/>
	8797	<a href="bender_quad.cpp.xml" target="_top">BenderQuad: Example and Test</a><br/>
	8798	<a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a><br/>
	8799	<a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
	8800	<a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
	8801	<a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
	8802	<a href="ode_gear_control.cpp.xml" target="_top">OdeGearControl: Example and Test</a><br/>
	8803	<a href="ode_gear.cpp.xml" target="_top">OdeGear: Example and Test</a><br/>
	8804	<a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a><br/>
	8805	<a href="ode_err_control.cpp.xml" target="_top">OdeErrControl: Example and Test</a><br/>
	8806	<a href="rosen_34.cpp.xml" target="_top">Rosen34: Example and Test</a><br/>
	8807	<a href="runge45_2.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
	8808	<a href="runge45_1.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
	8809	<a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	8810	<a href="romberg_one.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
	8811	<a href="lu_invert.cpp.xml" target="_top">LuInvert: Example and Test</a><br/>
	8812	<a href="lu_factor.cpp.xml" target="_top">LuFactor: Example and Test</a><br/>
	8813	<a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
	8814	<a href="poly.cpp.xml" target="_top">Polynomial Evaluation: Example and Test</a><br/>
	8815	<a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a><br/>
	8816	<a href="nan.cpp.xml" target="_top">nan: Example and Test</a><br/>
	8817	<a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a><br/>
	8818	<a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a><br/>
	8819	<a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>
	8820	<a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a><br/>
	8821	<a href="time_test.cpp.xml" target="_top">time_test: Example and test</a><br/>
	8822	<a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a><br/>
	8823	<a href="time_test.xml#test" target="_top">Determine Amount of Time to Execute a Test: test</a><br/>
	8824	<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
	8825	<a href="speed_test.cpp.xml" target="_top">speed_test: Example and test</a><br/>
	8826	<a href="speedtest.xml#Test" target="_top">Run One Speed Test and Print Results: Test</a><br/>
	8827	<a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
	8828	<a href="speed_test.xml#test" target="_top">Run One Speed Test and Return Results: test</a><br/>
	8829	<a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
	8830	<a href="near_equal.cpp.xml" target="_top">NearEqual Function: Example and Test</a><br/>
	8831	<a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
	8832	<a href="team_thread.hpp.xml#Speed Test of Implementation" target="_top">Specifications for A Team of AD Threads: Speed Test of Implementation</a><br/>
	8833	<a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
	8834	<a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
	8835	<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
	8836	<a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
	8837	<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
	8838	<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
	8839	<a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
	8840	<a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
	8841	<a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
	8842	<a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
	8843	<a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>
	8844	<a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
	8845	<a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a><br/>
	8846	<a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a><br/>
	8847	<a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a><br/>
	8848	<a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
	8849	<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
	8850	<a href="hessian.cpp.xml" target="_top">Hessian: Example and Test</a><br/>
	8851	<a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a><br/>
	8852	<a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a><br/>
	8853	<a href="jacobian.cpp.xml" target="_top">Jacobian: Example and Test</a><br/>
	8854	<a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>
	8855	<a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
	8856	<a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
	8857	<a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a><br/>
	8858	<a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a><br/>
	8859	<a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a><br/>
	8860	<a href="reverse_two.cpp.xml" target="_top">Second Order Reverse ModeExample and Test</a><br/>
	8861	<a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a><br/>
	8862	<a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	8863	<a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
	8864	<a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
	8865	<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
	8866	<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
	8867	<a href="forward.cpp.xml" target="_top">Forward Mode: Example and Test</a><br/>
	8868	<a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
	8869	<a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
	8870	<a href="fun_assign.cpp.xml" target="_top">ADFun Assignment: Example and Test</a><br/>
	8871	<a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a><br/>
	8872	<a href="not_complex_ad.cpp.xml" target="_top">Not Complex Differentiable: Example and Test</a><br/>
	8873	<a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
	8874	<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
	8875	<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	8876	<a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
	8877	<a href="equal_op_seq.cpp.xml" target="_top">EqualOpSeq: Example and Test</a><br/>
	8878	<a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
	8879	<a href="bool_fun.cpp.xml" target="_top">AD Boolean Functions: Example and Test</a><br/>
	8880	<a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a><br/>
	8881	<a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
	8882	<a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>
	8883	<a href="atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Test with x_1 Both a Variable and a Parameter</a><br/>
	8884	<a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
	8885	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	8886	<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
	8887	<a href="atomic_norm_sq.cpp.xml" target="_top">Euclidean Norm Squared: Example and Test</a><br/>
	8888	<a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	8889	<a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a><br/>
	8890	<a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
	8891	<a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
	8892	<a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
	8893	<a href="cond_exp.cpp.xml" target="_top">Conditional Expressions: Example and Test</a><br/>
	8894	<a href="condexp.xml#Test" target="_top">AD Conditional Expressions: Test</a><br/>
	8895	<a href="limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a><br/>
	8896	<a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a><br/>
	8897	<a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a><br/>
	8898	<a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a><br/>
	8899	<a href="sign.cpp.xml" target="_top">Sign Function: Example and Test</a><br/>
	8900	<a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
	8901	<a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a><br/>
	8902	<a href="tan.cpp.xml" target="_top">The AD tan Function: Example and Test</a><br/>
	8903	<a href="sqrt.cpp.xml" target="_top">The AD sqrt Function: Example and Test</a><br/>
	8904	<a href="sinh.cpp.xml" target="_top">The AD sinh Function: Example and Test</a><br/>
	8905	<a href="sin.cpp.xml" target="_top">The AD sin Function: Example and Test</a><br/>
	8906	<a href="log10.cpp.xml" target="_top">The AD log10 Function: Example and Test</a><br/>
	8907	<a href="log.cpp.xml" target="_top">The AD log Function: Example and Test</a><br/>
	8908	<a href="exp.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
	8909	<a href="cosh.cpp.xml" target="_top">The AD cosh Function: Example and Test</a><br/>
	8910	<a href="cos.cpp.xml" target="_top">The AD cos Function: Example and Test</a><br/>
	8911	<a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
	8912	<a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>
	8913	<a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
	8914	<a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
	8915	<a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
	8916	<a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
	8917	<a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
	8918	<a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
	8919	<a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
	8920	<a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
	8921	<a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
	8922	<a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a><br/>
	8923	<a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a><br/>
	8924	<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	8925	<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
	8926	<a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
	8927	<a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	8928	<a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
	8929	<a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
	8930	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	8931	<a href="ad_assign.cpp.xml" target="_top">AD Assignment: Example and Test</a><br/>
	8932	<a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a><br/>
	8933	<a href="exp_eps.cpp.xml" target="_top">exp_eps: Test of exp_eps</a><br/>
	8934	<a href="exp_eps.xml#Test" target="_top">An Epsilon Accurate Exponential Approximation: Test</a><br/>
	8935	<a href="exp_2.cpp.xml" target="_top">exp_2: Test</a><br/>
	8936	<a href="exp_2.xml#Test" target="_top">Second Order Exponential Approximation: Test</a><br/>
	8937	<a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a><br/>
	8938	<a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a><br/>
	8939	<a href="eigen_prefix.xml#Test Vector" target="_top">Including the Eigen Examples and Tests: Test Vector</a><br/>
	8940	<a href="colpack.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
	8941	<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
	8942	<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
2431	8943	AD<b> </b>acos <a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
2432	8944	AD<b> </b>add <a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
2433	8945	AD<b> </b>asin <a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>

2472	8984	check<b> </b>SimpleVector <a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a><br/>
2473	8985	check<b>_</b>for<b>_</b>nan <a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
2474	8986	checkpoint <a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a><br/>
	8987	colpack <a href="colpack.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
2475	8988	complex <a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
2476	8989	complex<b> </b>polynomial <a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
2477	8990	conjugate<b> </b>gradient <a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
2478	8991	constructor<b> </b>AD<b> </b>object <a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a><br/>
2479	8992	cppad<b> </b>speed <a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a><br/>
2480		cppad<b> </b>speed <a href="speed_main.xml" target="_top">Speed Testing Main Program</a><br/>
	8993	cppad<b> </b>speed <a href="speed_main.xml" target="_top">Running the Speed Test Program</a><br/>
2481	8994	cppad<b> </b>vector <a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a><br/>
2482	8995	Dependent <a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
2483	8996	Domain <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>

2583	9096	sparsity<b> </b>forward <a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
2584	9097	sparsity<b> </b>Hessian <a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>
2585	9098	sparsity<b> </b>reverse <a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
2586		speed <a href="speed.xml" target="_top">AD Speed Test Routines</a><br/>
	9099	speed <a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
2587	9100	speed <a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
2588	9101	speed <a href="speed_program.cpp.xml" target="_top">Example Use of SpeedTest</a><br/>
2589	9102	speed <a href="speed_test.cpp.xml" target="_top">speed_test: Example and test</a><br/>
2590	9103	speed <a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
2591	9104	speed <a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
2592		speed<b> </b>windows <a href="speed.xml#Windows" target="_top">AD Speed Test Routines: Windows</a><br/>
2593	9105	stiff<b> </b>ode <a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
2594	9106	subtract <a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
2595	9107	tan <a href="tan.cpp.xml" target="_top">The AD tan Function: Example and Test</a><br/>

2605	9117	VecAD <a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
2606	9118	vector <a href="test_vector.xml" target="_top">Choosing The Vector Testing Template Class</a><br/>
2607	9119	vector <a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a><br/>
2608		vector <a href="installunix.xml#--with-testvector" target="_top">Unix Test and Installation: --with-testvector</a><br/>
2609		testing<br/>
	9120	vector <a href="installunix.xml#--with-testvector" target="_top">Deprecated Unix Test and Installation: --with-testvector</a><br/>
	9121	test<b>_</b>size <a href="time_test.xml#test_size" target="_top">Determine Amount of Time to Execute a Test: test_size</a><br/>
	9122	test<b>_</b>time <a href="multi_newton_time.cpp.xml#test_time" target="_top">Timing Test of Multi-Threaded Newton Method: test_time</a><br/>
	9123	<a href="harmonic_time.cpp.xml#test_time" target="_top">Timing Test of Multi-Threaded Summation of 1/i: test_time</a><br/>
	9124	<a href="thread_test.cpp.xml#multi_newton.test_time" target="_top">Run Multi-Threading Examples and Speed Tests: multi_newton.test_time</a><br/>
	9125	<a href="thread_test.cpp.xml#harmonic.test_time" target="_top">Run Multi-Threading Examples and Speed Tests: harmonic.test_time</a><br/>
	9126	testing <a href="test_vector.xml" target="_top">Choosing The Vector Testing Template Class</a><br/>
	9127	<a href="speed_utility.xml" target="_top">Speed Testing Utilities</a><br/>
	9128	<a href="link_sparse_jacobian.xml" target="_top">Speed Testing Sparse Jacobian</a><br/>
	9129	<a href="link_sparse_hessian.xml" target="_top">Speed Testing Sparse Hessian</a><br/>
	9130	<a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
	9131	<a href="link_ode.xml" target="_top">Speed Testing the Jacobian of Ode Solution</a><br/>
	9132	<a href="link_mat_mul.xml" target="_top">Speed Testing Derivative of Matrix Multiply</a><br/>
	9133	<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
	9134	<a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
	9135	<a href="library.xml#Testing Utilities" target="_top">The CppAD General Purpose Library: Testing Utilities</a><br/>
	9136	<a href="optimize.xml#Improvements.Testing" target="_top">Optimize an ADFun Object Tape: Improvements.Testing</a><br/>
2610	9137	machine<b> </b>epsilon <a href="wishlist.xml#Numeric Limits" target="_top">The CppAD Wish List: Numeric Limits</a><br/>
	9138	tests <a href="speed_sacado.xml#Running Tests" target="_top">Speed Test Derivatives Using Sacado: Running Tests</a><br/>
	9139	<a href="speed_fadbad.xml#Running Tests" target="_top">Speed Test Derivatives Using Fadbad: Running Tests</a><br/>
	9140	<a href="speed_cppad.xml#Running Tests" target="_top">Speed Test Derivatives Using CppAD: Running Tests</a><br/>
	9141	<a href="speed_adolc.xml#Running Tests" target="_top">Speed Test of Derivatives Using Adolc: Running Tests</a><br/>
	9142	<a href="speed_double.xml#Running Tests" target="_top">Speed Test of Functions in Double: Running Tests</a><br/>
	9143	<a href="speed_example.cpp.xml#Running Tests" target="_top">Run the Speed Examples: Running Tests</a><br/>
	9144	<a href="example.cpp.xml#Running Tests" target="_top">CppAD Examples and Tests: Running Tests</a><br/>
	9145	<a href="example.cpp.xml" target="_top">CppAD Examples and Tests</a><br/>
	9146	<a href="thread_test.cpp.xml#Running Tests" target="_top">Run Multi-Threading Examples and Speed Tests: Running Tests</a><br/>
	9147	<a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
	9148	<a href="exp_apx_main.cpp.xml#Running Tests" target="_top">Correctness Tests For Exponential Approximation in Introduction: Running Tests</a><br/>
	9149	<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
	9150	<a href="installunix.xml#make.Examples and Tests" target="_top">Deprecated Unix Test and Installation: make.Examples and Tests</a><br/>
	9151	<a href="cmake_check.xml" target="_top">Checking the CppAD Examples and Tests</a><br/>
	9152	<a href="sacado_prefix.xml#Speed Tests" target="_top">Including the Sacado Speed Tests: Speed Tests</a><br/>
	9153	<a href="sacado_prefix.xml" target="_top">Including the Sacado Speed Tests</a><br/>
	9154	<a href="ipopt_prefix.xml#Examples and Tests" target="_top">Including the cppad_ipopt Library and Tests: Examples and Tests</a><br/>
	9155	<a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>
	9156	<a href="fadbad_prefix.xml#Speed Tests" target="_top">Including the FADBAD Speed Tests: Speed Tests</a><br/>
	9157	<a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a><br/>
	9158	<a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a><br/>
	9159	<a href="adolc_prefix.xml#Speed Tests" target="_top">Including the ADOL-C Examples and Tests: Speed Tests</a><br/>
	9160	<a href="adolc_prefix.xml" target="_top">Including the ADOL-C Examples and Tests</a><br/>
2611	9161	text<br/>
2612	9162	output <a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
2613		theory<br/>
	9163	tf <a href="odegearcontrol.xml#tf" target="_top">An Error Controller for Gear's Ode Solvers: tf</a><br/>
	9164	<a href="odeerrcontrol.xml#tf" target="_top">An Error Controller for ODE Solvers: tf</a><br/>
	9165	<a href="rosen34.xml#tf" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: tf</a><br/>
	9166	<a href="runge45.xml#tf" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: tf</a><br/>
	9167	than <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	9168	that <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
	9169	<a href="forwardtheory.xml#Standard Math Functions.Cases that Apply Recursion Above" target="_top">The Theory of Forward Mode: Standard Math Functions.Cases that Apply Recursion Above</a><br/>
	9170	<a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
	9171	<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
	9172	<a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
	9173	<a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a><br/>
	9174	<a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	9175	<a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	9176	<a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
	9177	<a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a><br/>
	9178	<a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
	9179	<a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
	9180	the <a href="license.xml" target="_top">Your License for the CppAD Software</a><br/>
	9181	<a href="ipopt_nlp_ode_run.hpp.xml" target="_top">Driver for Running the Ipopt ODE Example</a><br/>
	9182	<a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
	9183	<a href="test_vector.xml" target="_top">Choosing The Vector Testing Template Class</a><br/>
	9184	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	9185	<a href="omp_get_thread_num.xml" target="_top">Get the Current OpenMP Thread Number</a><br/>
	9186	<a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
	9187	<a href="wishlist.xml" target="_top">The CppAD Wish List</a><br/>
	9188	<a href="bib.xml#The C++ Programming Language" target="_top">Bibliography: The C++ Programming Language</a><br/>
	9189	<a href="reversetheory.xml" target="_top">The Theory of Reverse Mode</a><br/>
	9190	<a href="forwardtheory.xml" target="_top">The Theory of Forward Mode</a><br/>
	9191	<a href="theory.xml" target="_top">The Theory of Derivative Calculations</a><br/>
	9192	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	9193	<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
	9194	<a href="link_ode.xml" target="_top">Speed Testing the Jacobian of Ode Solution</a><br/>
	9195	<a href="speed_main.xml" target="_top">Running the Speed Test Program</a><br/>
	9196	<a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a><br/>
	9197	<a href="speed_example.cpp.xml" target="_top">Run the Speed Examples</a><br/>
	9198	<a href="listallexamples.xml" target="_top">List of All the CppAD Examples</a><br/>
	9199	<a href="example.xml#The CppAD Test Vector Template Class" target="_top">Examples: The CppAD Test Vector Template Class</a><br/>
	9200	<a href="ta_thread_num.xml" target="_top">Get the Current Thread Number</a><br/>
	9201	<a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
	9202	<a href="cppad_vector.xml" target="_top">The CppAD::vector Template Class</a><br/>
	9203	<a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a><br/>
	9204	<a href="pow_int.xml" target="_top">The Integer Power Function</a><br/>
	9205	<a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a><br/>
	9206	<a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>
	9207	<a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a><br/>
	9208	<a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
	9209	<a href="errorhandler.xml" target="_top">Replacing the CppAD Error Handler</a><br/>
	9210	<a href="library.xml" target="_top">The CppAD General Purpose Library</a><br/>
	9211	<a href="base_identical.xml#EqualOpSeq.The Simple Case" target="_top">Base Type Requirements for Identically Equal Comparisons: EqualOpSeq.The Simple Case</a><br/>
	9212	<a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a><br/>
	9213	<a href="pow.xml" target="_top">The AD Power Function</a><br/>
	9214	<a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a><br/>
	9215	<a href="erf.xml" target="_top">The AD Error Function</a><br/>
	9216	<a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a><br/>
	9217	<a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a><br/>
	9218	<a href="tan.cpp.xml" target="_top">The AD tan Function: Example and Test</a><br/>
	9219	<a href="sqrt.cpp.xml" target="_top">The AD sqrt Function: Example and Test</a><br/>
	9220	<a href="sinh.cpp.xml" target="_top">The AD sinh Function: Example and Test</a><br/>
	9221	<a href="sin.cpp.xml" target="_top">The AD sin Function: Example and Test</a><br/>
	9222	<a href="log10.cpp.xml" target="_top">The AD log10 Function: Example and Test</a><br/>
	9223	<a href="log.cpp.xml" target="_top">The AD log Function: Example and Test</a><br/>
	9224	<a href="exp.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
	9225	<a href="cosh.cpp.xml" target="_top">The AD cosh Function: Example and Test</a><br/>
	9226	<a href="cos.cpp.xml" target="_top">The AD cos Function: Example and Test</a><br/>
	9227	<a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
	9228	<a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>
	9229	<a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
	9230	<a href="cmake_check.xml" target="_top">Checking the CppAD Examples and Tests</a><br/>
	9231	<a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a><br/>
	9232	<a href="sacado_prefix.xml" target="_top">Including the Sacado Speed Tests</a><br/>
	9233	<a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>
	9234	<a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a><br/>
	9235	<a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a><br/>
	9236	<a href="colpack_prefix.xml" target="_top">Including the ColPack Sparsity Calculations</a><br/>
	9237	<a href="adolc_prefix.xml" target="_top">Including the ADOL-C Examples and Tests</a><br/>
	9238	<a href="cmake.xml#The CMake Program" target="_top">Using CMake to Configure CppAD: The CMake Program</a><br/>
	9239	<a href="download.xml" target="_top">Download The CppAD Source Code</a><br/>
	9240	theorem <a href="reverse_identity.xml#Theorem" target="_top">An Important Reverse Mode Identity: Theorem</a><br/>
	9241	theory <a href="old_tan.cpp.xml#Theory" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Theory</a><br/>
	9242	<a href="old_reciprocal.cpp.xml#Theory" target="_top">Old Atomic Operation Reciprocal: Example and Test: Theory</a><br/>
	9243	<a href="erf_reverse.xml" target="_top">Error Function Reverse Mode Theory</a><br/>
	9244	<a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
	9245	<a href="acosreverse.xml" target="_top">Arccosine Function Reverse Mode Theory</a><br/>
	9246	<a href="asinreverse.xml" target="_top">Arcsine Function Reverse Mode Theory</a><br/>
	9247	<a href="atanreverse.xml" target="_top">Arctangent Function Reverse Mode Theory</a><br/>
	9248	<a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
	9249	<a href="sqrtreverse.xml" target="_top">Square Root Function Reverse Mode Theory</a><br/>
	9250	<a href="logreverse.xml" target="_top">Logarithm Function Reverse Mode Theory</a><br/>
	9251	<a href="expreverse.xml" target="_top">Exponential Function Reverse Mode Theory</a><br/>
	9252	<a href="reversetheory.xml" target="_top">The Theory of Reverse Mode</a><br/>
	9253	<a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a><br/>
	9254	<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
	9255	<a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a><br/>
	9256	<a href="asinforward.xml" target="_top">Arcsine Function Forward Taylor Polynomial Theory</a><br/>
	9257	<a href="atanforward.xml" target="_top">Arctangent Function Forward Taylor Polynomial Theory</a><br/>
	9258	<a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
	9259	<a href="sqrtforward.xml" target="_top">Square Root Function Forward Taylor Polynomial Theory</a><br/>
	9260	<a href="logforward.xml" target="_top">Logarithm Function Forward Taylor Polynomial Theory</a><br/>
	9261	<a href="expforward.xml" target="_top">Exponential Function Forward Taylor Polynomial Theory</a><br/>
	9262	<a href="forwardtheory.xml" target="_top">The Theory of Forward Mode</a><br/>
	9263	<a href="theory.xml" target="_top">The Theory of Derivative Calculations</a><br/>
	9264	<a href="odegearcontrol.xml#Theory" target="_top">An Error Controller for Gear's Ode Solvers: Theory</a><br/>
	9265	<a href="odegear.xml#Theory" target="_top">An Arbitrary Order Gear Method: Theory</a><br/>
	9266	<a href="odeerrcontrol.xml#Theory" target="_top">An Error Controller for ODE Solvers: Theory</a><br/>
	9267	<a href="atomic_tangent.cpp.xml#Theory" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Theory</a><br/>
	9268	<a href="atomic_reciprocal.cpp.xml#Theory" target="_top">Reciprocal as an Atomic Operation: Example and Test: Theory</a><br/>
	9269	<a href="atomic_norm_sq.cpp.xml#Theory" target="_top">Euclidean Norm Squared: Example and Test: Theory</a><br/>
2614	9270	acos<b> </b>forward <a href="acosforward.xml" target="_top">Arccosine Function Forward Taylor Polynomial Theory</a><br/>
2615	9271	acos<b> </b>reverse <a href="acosreverse.xml" target="_top">Arccosine Function Reverse Mode Theory</a><br/>
2616	9272	asin<b> </b>forward <a href="asinforward.xml" target="_top">Arcsine Function Forward Taylor Polynomial Theory</a><br/>

2621	9277	cos <a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
2622	9278	cosh <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
2623	9279	cosh <a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
	9280	erf<b> </b>forward <a href="erf_forward.xml" target="_top">Error Function Forward Taylor Polynomial Theory</a><br/>
	9281	erf<b> </b>reverse <a href="erf_reverse.xml" target="_top">Error Function Reverse Mode Theory</a><br/>
2624	9282	exp<b> </b>forward <a href="expforward.xml" target="_top">Exponential Function Forward Taylor Polynomial Theory</a><br/>
2625	9283	exp<b> </b>reverse <a href="expreverse.xml" target="_top">Exponential Function Reverse Mode Theory</a><br/>
2626	9284	log<b> </b>forward <a href="logforward.xml" target="_top">Logarithm Function Forward Taylor Polynomial Theory</a><br/>

2633	9291	sqrt<b> </b>reverse <a href="sqrtreverse.xml" target="_top">Square Root Function Reverse Mode Theory</a><br/>
2634	9292	tan<b> </b>forward <a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
2635	9293	tan<b> </b>reverse <a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
2636		thread<br/>
	9294	theta <a href="atan2.xml#theta" target="_top">AD Two Argument Inverse Tangent Function: theta</a><br/>
	9295	third <a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a><br/>
	9296	this <a href="whats_new.xml#This Year" target="_top">Changes and Additions to CppAD: This Year</a><br/>
	9297	<a href="speed_program.cpp.xml#Running This Program" target="_top">Example Use of SpeedTest: Running This Program</a><br/>
	9298	thread <a href="memory_leak.xml#thread" target="_top">Memory Leak Detection: thread</a><br/>
	9299	<a href="omp_efficient.xml#Thread" target="_top">Check If A Memory Allocation is Efficient for Another Use: Thread</a><br/>
	9300	<a href="omp_delete_array.xml#Thread" target="_top">Return A Raw Array to The Available Memory for a Thread: Thread</a><br/>
	9301	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	9302	<a href="omp_available.xml#thread" target="_top">Amount of Memory Available for Quick Use by a Thread: thread</a><br/>
	9303	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	9304	<a href="omp_inuse.xml#thread" target="_top">Amount of Memory a Thread is Currently Using: thread</a><br/>
	9305	<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	9306	<a href="omp_free_available.xml#thread" target="_top">Free Memory Currently Available for Quick Use by a Thread: thread</a><br/>
	9307	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	9308	<a href="omp_return_memory.xml#Thread" target="_top">Return Memory to omp_alloc: Thread</a><br/>
	9309	<a href="omp_get_thread_num.xml#thread" target="_top">Get the Current OpenMP Thread Number: thread</a><br/>
	9310	<a href="omp_get_thread_num.xml" target="_top">Get the Current OpenMP Thread Number</a><br/>
	9311	<a href="ta_delete_array.xml#Thread" target="_top">Deallocate An Array and Call Destructor for its Elements: Thread</a><br/>
	9312	<a href="ta_available.xml#thread" target="_top">Amount of Memory Available for Quick Use by a Thread: thread</a><br/>
	9313	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	9314	<a href="ta_inuse.xml#thread" target="_top">Amount of Memory a Thread is Currently Using: thread</a><br/>
	9315	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	9316	<a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
	9317	<a href="ta_free_available.xml#thread" target="_top">Free Memory Currently Available for Quick Use by a Thread: thread</a><br/>
	9318	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	9319	<a href="ta_return_memory.xml#Thread" target="_top">Return Memory to thread_alloc: Thread</a><br/>
	9320	<a href="ta_thread_num.xml#thread" target="_top">Get the Current Thread Number: thread</a><br/>
	9321	<a href="ta_thread_num.xml" target="_top">Get the Current Thread Number</a><br/>
	9322	<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
	9323	<a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
	9324	<a href="multi_thread.xml#Same Thread" target="_top">Using CppAD in a Multi-Threading Environment: Same Thread</a><br/>
2637	9325	AD<b> </b>team <a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
2638	9326	available<b> </b>memory <a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
2639	9327	available<b> </b>memory <a href="ta_return_memory.xml" target="_top">Return Memory to thread_alloc</a><br/>

2650	9338	OpenMP<b> </b>example <a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
2651	9339	simple<b> </b>boost<b> </b>AD <a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
2652	9340	team<b> </b>example<b> </b>AD <a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
2653		thread<b>_</b>alloc<br/>
	9341	thread<b>_</b>alloc <a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	9342	<a href="ta_return_memory.xml" target="_top">Return Memory to thread_alloc</a><br/>
	9343	<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
2654	9344	available <a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
2655	9345	create<b>_</b>array <a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
2656	9346	delete<b>_</b>array <a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>

2665	9355	thread<b>_</b>num <a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
2666	9356	thread<b>_</b>num <a href="ta_thread_num.xml" target="_top">Get the Current Thread Number</a><br/>
2667	9357	vector <a href="cppad_vector.xml#Memory and Parallel Mode" target="_top">The CppAD::vector Template Class: Memory and Parallel Mode</a><br/>
2668		thread<b>_</b>num <a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	9358	thread<b>_</b>num <a href="ta_parallel_setup.xml#thread_num" target="_top">Setup thread_alloc For Use in Multi-Threading Environment: thread_num</a><br/>
	9359	<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
2669	9360	thread<b>_</b>alloc <a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
2670	9361	thread<b>_</b>alloc <a href="ta_thread_num.xml" target="_top">Get the Current Thread Number</a><br/>
	9362	thread<b>_</b>team <a href="team_example.cpp.xml#thread_team" target="_top">Using a Team of AD Threads: Example and Test: thread_team</a><br/>
2671	9363	thread<b>_</b>test<br/>
2672	9364	example <a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
2673	9365	speed <a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
2674		threads<br/>
	9366	threading <a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
	9367	<a href="thread_test.cpp.xml#Running Tests.threading" target="_top">Run Multi-Threading Examples and Speed Tests: Running Tests.threading</a><br/>
	9368	threads <a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
	9369	<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
	9370	<a href="ta_num_threads.xml" target="_top">Get Number of Threads</a><br/>
	9371	<a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
	9372	<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
	9373	<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
	9374	<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
2675	9375	maximum<b> </b>number <a href="cmake.xml#cppad_max_num_threads" target="_top">Using CMake to Configure CppAD: cppad_max_num_threads</a><br/>
2676	9376	maximum<b> </b>number<b> </b>of <a href="multi_thread.xml#CPPAD_MAX_NUM_THREADS" target="_top">Using CppAD in a Multi-Threading Environment: CPPAD_MAX_NUM_THREADS</a><br/>
2677	9377	number<b> </b>of <a href="ta_num_threads.xml" target="_top">Get Number of Threads</a><br/>
2678		time<br/>
	9378	threads<b>:</b> <a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
	9379	ti <a href="odegearcontrol.xml#ti" target="_top">An Error Controller for Gear's Ode Solvers: ti</a><br/>
	9380	<a href="odeerrcontrol.xml#ti" target="_top">An Error Controller for ODE Solvers: ti</a><br/>
	9381	<a href="rosen34.xml#ti" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: ti</a><br/>
	9382	<a href="runge45.xml#ti" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: ti</a><br/>
	9383	time <a href="time_det_by_minor_c.xml#time" target="_top">Determine Amount of Time to Execute det_by_minor: time</a><br/>
	9384	<a href="time_det_by_minor_c.xml" target="_top">Determine Amount of Time to Execute det_by_minor</a><br/>
	9385	<a href="ipopt_nlp_ode_problem.xml#Trapezoidal Approximation.Trapezoidal Time Grid" target="_top">An ODE Inverse Problem Example: Trapezoidal Approximation.Trapezoidal Time Grid</a><br/>
	9386	<a href="time_test.xml#time" target="_top">Determine Amount of Time to Execute a Test: time</a><br/>
	9387	<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
2679	9388	multi<b>_</b>thread<b> </b>summation <a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
2680	9389	seconds <a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
	9390	time<b>_</b>min <a href="time_det_by_minor_c.xml#time_min" target="_top">Determine Amount of Time to Execute det_by_minor: time_min</a><br/>
	9391	<a href="time_test.xml#time_min" target="_top">Determine Amount of Time to Execute a Test: time_min</a><br/>
	9392	<a href="speed_test.xml#time_min" target="_top">Run One Speed Test and Return Results: time_min</a><br/>
	9393	time<b>_</b>out <a href="multi_newton_time.cpp.xml#time_out" target="_top">Timing Test of Multi-Threaded Newton Method: time_out</a><br/>
	9394	<a href="harmonic_time.cpp.xml#time_out" target="_top">Timing Test of Multi-Threaded Summation of 1/i: time_out</a><br/>
2681	9395	time<b>_</b>test <a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
2682	9396	example <a href="time_test.cpp.xml" target="_top">time_test: Example and test</a><br/>
2683		times<br/>
	9397	time<b>_</b>test<b>:</b> <a href="time_test.cpp.xml" target="_top">time_test: Example and test</a><br/>
	9398	times <a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
	9399	<a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
	9400	<a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a><br/>
	9401	<a href="reverse_two.xml#Hessian Times Direction" target="_top">Second Order Reverse Mode: Hessian Times Direction</a><br/>
2684	9402	AD<b> </b>example <a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
2685	9403	binary<b> </b>operator <a href="ad_binary.xml" target="_top">AD Binary Arithmetic Operators</a><br/>
2686	9404	computed<b> </b>assignment <a href="compute_assign.xml" target="_top">AD Computed Assignment Operators</a><br/>
2687		tracing<br/>
	9405	timing <a href="time_test.xml#Timing" target="_top">Determine Amount of Time to Execute a Test: Timing</a><br/>
	9406	<a href="speed_test.xml#Timing" target="_top">Run One Speed Test and Return Results: Timing</a><br/>
	9407	<a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
	9408	<a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
	9409	to <a href="time_det_by_minor_c.xml" target="_top">Determine Amount of Time to Execute det_by_minor</a><br/>
	9410	<a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	9411	<a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	9412	<a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
	9413	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
	9414	<a href="omp_return_memory.xml" target="_top">Return Memory to omp_alloc</a><br/>
	9415	<a href="include_deprecated.xml#Linking New Files to Deprecated Commands" target="_top">Deprecated Include Files: Linking New Files to Deprecated Commands</a><br/>
	9416	<a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a><br/>
	9417	<a href="whats_new_04.xml" target="_top">Changes and Additions to CppAD During 2004</a><br/>
	9418	<a href="whats_new_05.xml" target="_top">Changes and Additions to CppAD During 2005</a><br/>
	9419	<a href="whats_new_06.xml" target="_top">Changes and Additions to CppAD During 2006</a><br/>
	9420	<a href="whats_new_07.xml" target="_top">Changes and Additions to CppAD During 2007</a><br/>
	9421	<a href="whats_new_08.xml" target="_top">Changes and Additions to CppAD During 2008</a><br/>
	9422	<a href="whats_new_09.xml" target="_top">Changes and Additions to CppAD During 2009</a><br/>
	9423	<a href="whats_new_10.xml" target="_top">Changes and Additions to CppAD During 2010</a><br/>
	9424	<a href="whats_new_11.xml" target="_top">Changes and Additions to CppAD During 2011</a><br/>
	9425	<a href="whats_new.xml" target="_top">Changes and Additions to CppAD</a><br/>
	9426	<a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
	9427	<a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
	9428	<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
	9429	<a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
	9430	<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
	9431	<a href="ta_return_memory.xml" target="_top">Return Memory to thread_alloc</a><br/>
	9432	<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
	9433	<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	9434	<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
	9435	<a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
	9436	<a href="integer.xml" target="_top">Convert From AD to Integer</a><br/>
	9437	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	9438	<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
	9439	<a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
	9440	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
	9441	<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
	9442	tracing <a href="wishlist.xml#Tracing" target="_top">The CppAD Wish List: Tracing</a><br/>
2688	9443	operation<b> </b>sequence <a href="wishlist.xml#Tracing" target="_top">The CppAD Wish List: Tracing</a><br/>
2689		track<br/>
	9444	track <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
2690	9445	new<b> </b>and<b> </b>delete <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
2691		type <a href="glossary.xml#Base Type" target="_top">Glossary: Base Type</a><br/>
	9446	track<b>_</b>count <a href="memory_leak.xml#TRACK_COUNT" target="_top">Memory Leak Detection: TRACK_COUNT</a><br/>
	9447	trackcount <a href="tracknewdel.xml#TrackCount" target="_top">Routines That Track Use of New and Delete: TrackCount</a><br/>
	9448	trackdelvec <a href="tracknewdel.xml#TrackDelVec" target="_top">Routines That Track Use of New and Delete: TrackDelVec</a><br/>
	9449	trackextend <a href="tracknewdel.xml#TrackExtend" target="_top">Routines That Track Use of New and Delete: TrackExtend</a><br/>
	9450	tracking <a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
	9451	tracknewvec <a href="tracknewdel.xml#TrackNewVec" target="_top">Routines That Track Use of New and Delete: TrackNewVec</a><br/>
	9452	transpose <a href="revsparsehes.xml#h.transpose true" target="_top">Hessian Sparsity Pattern: Reverse Mode: h.transpose true</a><br/>
	9453	<a href="revsparsehes.xml#h.transpose false" target="_top">Hessian Sparsity Pattern: Reverse Mode: h.transpose false</a><br/>
	9454	<a href="revsparsehes.xml#transpose" target="_top">Hessian Sparsity Pattern: Reverse Mode: transpose</a><br/>
	9455	<a href="revsparsejac.xml#s.transpose true" target="_top">Jacobian Sparsity Pattern: Reverse Mode: s.transpose true</a><br/>
	9456	<a href="revsparsejac.xml#s.transpose false" target="_top">Jacobian Sparsity Pattern: Reverse Mode: s.transpose false</a><br/>
	9457	<a href="revsparsejac.xml#r.transpose true" target="_top">Jacobian Sparsity Pattern: Reverse Mode: r.transpose true</a><br/>
	9458	<a href="revsparsejac.xml#r.transpose false" target="_top">Jacobian Sparsity Pattern: Reverse Mode: r.transpose false</a><br/>
	9459	<a href="revsparsejac.xml#transpose" target="_top">Jacobian Sparsity Pattern: Reverse Mode: transpose</a><br/>
	9460	<a href="forsparsejac.xml#s.transpose true" target="_top">Jacobian Sparsity Pattern: Forward Mode: s.transpose true</a><br/>
	9461	<a href="forsparsejac.xml#s.transpose false" target="_top">Jacobian Sparsity Pattern: Forward Mode: s.transpose false</a><br/>
	9462	<a href="forsparsejac.xml#r.transpose true" target="_top">Jacobian Sparsity Pattern: Forward Mode: r.transpose true</a><br/>
	9463	<a href="forsparsejac.xml#r.transpose false" target="_top">Jacobian Sparsity Pattern: Forward Mode: r.transpose false</a><br/>
	9464	<a href="forsparsejac.xml#transpose" target="_top">Jacobian Sparsity Pattern: Forward Mode: transpose</a><br/>
	9465	trapezoidal <a href="ipopt_nlp_ode_fast.xml#Trapezoidal Approximation" target="_top">ODE Fitting Using Fast Representation: Trapezoidal Approximation</a><br/>
	9466	<a href="ipopt_nlp_ode_simple.xml#Trapezoidal Approximation Constraint" target="_top">ODE Fitting Using Simple Representation: Trapezoidal Approximation Constraint</a><br/>
	9467	<a href="ipopt_nlp_ode_problem.xml#Trapezoidal Approximation.Trapezoidal Time Grid" target="_top">An ODE Inverse Problem Example: Trapezoidal Approximation.Trapezoidal Time Grid</a><br/>
	9468	<a href="ipopt_nlp_ode_problem.xml#Trapezoidal Approximation" target="_top">An ODE Inverse Problem Example: Trapezoidal Approximation</a><br/>
	9469	<a href="ipopt_solve_ode_inverse.cpp.xml#Trapezoidal Approximation" target="_top">ODE Inverse Problem Definitions: Source Code: Trapezoidal Approximation</a><br/>
	9470	trigonometric <a href="sincosreverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
	9471	<a href="sincosforward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
	9472	true <a href="revsparsehes.xml#h.transpose true" target="_top">Hessian Sparsity Pattern: Reverse Mode: h.transpose true</a><br/>
	9473	<a href="revsparsejac.xml#s.transpose true" target="_top">Jacobian Sparsity Pattern: Reverse Mode: s.transpose true</a><br/>
	9474	<a href="revsparsejac.xml#r.transpose true" target="_top">Jacobian Sparsity Pattern: Reverse Mode: r.transpose true</a><br/>
	9475	<a href="forsparsejac.xml#s.transpose true" target="_top">Jacobian Sparsity Pattern: Forward Mode: s.transpose true</a><br/>
	9476	<a href="forsparsejac.xml#r.transpose true" target="_top">Jacobian Sparsity Pattern: Forward Mode: r.transpose true</a><br/>
	9477	tvector <a href="old_atomic.xml#CPPAD_USER_ATOMIC.Tvector" target="_top">User Defined Atomic AD Functions: CPPAD_USER_ATOMIC.Tvector</a><br/>
	9478	two <a href="ipopt_nlp_ode_problem.xml#Black Box Method.Two levels of Iteration" target="_top">An ODE Inverse Problem Example: Black Box Method.Two levels of Iteration</a><br/>
	9479	<a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
	9480	<a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
	9481	<a href="atan2.xml" target="_top">AD Two Argument Inverse Tangent Function</a><br/>
	9482	order<b> </b>Forward <a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a><br/>
	9483	tx <a href="old_atomic.xml#tx" target="_top">User Defined Atomic AD Functions: tx</a><br/>
	9484	<a href="atomic_reverse.xml#tx" target="_top">Atomic Reverse Mode: tx</a><br/>
	9485	<a href="atomic_forward.xml#tx" target="_top">Atomic Forward Mode: tx</a><br/>
	9486	ty <a href="old_atomic.xml#ty" target="_top">User Defined Atomic AD Functions: ty</a><br/>
	9487	<a href="atomic_reverse.xml#ty" target="_top">Atomic Reverse Mode: ty</a><br/>
	9488	<a href="atomic_forward.xml#ty" target="_top">Atomic Forward Mode: ty</a><br/>
	9489	type <a href="omp_delete_array.xml#Type" target="_top">Return A Raw Array to The Available Memory for a Thread: Type</a><br/>
	9490	<a href="omp_create_array.xml#Type" target="_top">Allocate Memory and Create A Raw Array: Type</a><br/>
	9491	<a href="glossary.xml#Base Type" target="_top">Glossary: Base Type</a><br/>
	9492	<a href="ta_delete_array.xml#Type" target="_top">Deallocate An Array and Call Destructor for its Elements: Type</a><br/>
	9493	<a href="ta_create_array.xml#Type" target="_top">Allocate An Array and Call Default Constructor for its Elements: Type</a><br/>
	9494	<a href="cppad_vector.xml#vectorBool.Element Type" target="_top">The CppAD::vector Template Class: vectorBool.Element Type</a><br/>
	9495	<a href="poly.xml#Type" target="_top">Evaluate a Polynomial or its Derivative: Type</a><br/>
	9496	<a href="pow_int.xml#Type" target="_top">The Integer Power Function: Type</a><br/>
	9497	<a href="simplevector.xml#Value Type" target="_top">Definition of a Simple Vector: Value Type</a><br/>
	9498	<a href="simplevector.xml#Elements of Specified Type" target="_top">Definition of a Simple Vector: Elements of Specified Type</a><br/>
	9499	<a href="numerictype.xml#Type Requirements" target="_top">Definition of a Numeric Type: Type Requirements</a><br/>
	9500	<a href="numerictype.xml" target="_top">Definition of a Numeric Type</a><br/>
	9501	<a href="nearequal.xml#Type" target="_top">Determine if Two Values Are Nearly Equal: Type</a><br/>
	9502	<a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
	9503	<a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
	9504	<a href="base_ordered.xml#Ordered Type" target="_top">Base Type Requirements for Ordered Comparisons: Ordered Type</a><br/>
	9505	<a href="base_ordered.xml" target="_top">Base Type Requirements for Ordered Comparisons</a><br/>
	9506	<a href="base_identical.xml" target="_top">Base Type Requirements for Identically Equal Comparisons</a><br/>
	9507	<a href="base_cond_exp.xml#CondExpTemplate.Ordered Type" target="_top">Base Type Requirements for Conditional Expressions: CondExpTemplate.Ordered Type</a><br/>
	9508	<a href="base_cond_exp.xml" target="_top">Base Type Requirements for Conditional Expressions</a><br/>
	9509	<a href="base_require.xml#Numeric Type" target="_top">AD<Base> Requirements for Base Type: Numeric Type</a><br/>
	9510	<a href="base_require.xml" target="_top">AD<Base> Requirements for Base Type</a><br/>
	9511	<a href="nearequalext.xml#Type" target="_top">Compare AD and Base Objects for Nearly Equal: Type</a><br/>
	9512	<a href="condexp.xml#Type" target="_top">AD Conditional Expressions: Type</a><br/>
	9513	<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
	9514	<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
	9515	<a href="ad.xml#Base Type Requirements" target="_top">AD Objects: Base Type Requirements</a><br/>
	9516	<a href="exp_eps.xml#Type" target="_top">An Epsilon Accurate Exponential Approximation: Type</a><br/>
	9517	<a href="exp_2.xml#Type" target="_top">Second Order Exponential Approximation: Type</a><br/>
2692	9518	Base<b> </b>require <a href="base_require.xml" target="_top">AD<Base> Requirements for Base Type</a><br/>
2693	9519	base<b> </b>example <a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
2694	9520	numeric <a href="numerictype.xml" target="_top">Definition of a Numeric Type</a><br/>
	9521	type<b>:</b> <a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	9522	<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
	9523	types <a href="epsilon.xml" target="_top">Machine Epsilon For AD Types</a><br/>
	9524	<a href="faq.xml#Complex Types" target="_top">Frequently Asked Questions and Answers: Complex Types</a><br/>
	9525	<a href="base_example.xml" target="_top">Example AD Base Types That are not AD<OtherBase></a><br/>
	9526	<a href="base_require.xml#Purpose.Standard Base Types" target="_top">AD<Base> Requirements for Base Type: Purpose.Standard Base Types</a><br/>
	9527	<a href="limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
	9528	<a href="sign.xml#Complex Types" target="_top">Sign Function: Complex Types</a><br/>
	9529	<a href="abs.xml#Complex Types" target="_top">AD Absolute Value Function: Complex Types</a><br/>
	9530	<a href="integer.xml#x.AD Types" target="_top">Convert From AD to Integer: x.AD Types</a><br/>
	9531	<a href="integer.xml#x.Complex Types" target="_top">Convert From AD to Integer: x.Complex Types</a><br/>
	9532	<a href="integer.xml#x.Real Types" target="_top">Convert From AD to Integer: x.Real Types</a><br/>
2695	9533
2696	9534	<b><big><a name="U">U</a></big></b>
2697	9535	<br/>
2698		unary<br/>
	9536	u <a href="old_atomic.xml#rev_hes_sparse.u" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.u</a><br/>
	9537	<a href="luratio.xml#LU.U" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU.U</a><br/>
	9538	<a href="luinvert.xml#LU.U" target="_top">Invert an LU Factored Equation: LU.U</a><br/>
	9539	<a href="lufactor.xml#LU.U" target="_top">LU Factorization of A Square Matrix: LU.U</a><br/>
	9540	<a href="boolfun.xml#u" target="_top">AD Boolean Functions: u</a><br/>
	9541	<a href="atomic_rev_sparse_hes.xml#u" target="_top">Atomic Reverse Hessian Sparsity Patterns: u</a><br/>
	9542	u<b>)</b> <a href="reverse_any.xml#Notation.Y(t, u)" target="_top">Any Order Reverse Mode: Notation.Y(t, u)</a><br/>
	9543	<a href="reverse_any.xml#Notation.X(t, u)" target="_top">Any Order Reverse Mode: Notation.X(t, u)</a><br/>
	9544	u<b>^(</b>k<b>)</b> <a href="reverse_any.xml#Notation.u^(k)" target="_top">Any Order Reverse Mode: Notation.u^(k)</a><br/>
	9545	unary <a href="base_complex.hpp.xml#Invalid Unary Math" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Invalid Unary Math</a><br/>
	9546	<a href="base_complex.hpp.xml#Valid Unary Math" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Valid Unary Math</a><br/>
	9547	<a href="base_double.hpp.xml#Unary Standard Math" target="_top">Enable use of AD<Base> where Base is double: Unary Standard Math</a><br/>
	9548	<a href="base_float.hpp.xml#Unary Standard Math" target="_top">Enable use of AD<Base> where Base is float: Unary Standard Math</a><br/>
	9549	<a href="base_adolc.hpp.xml#Unary Standard Math" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type: Unary Standard Math</a><br/>
	9550	<a href="base_alloc.hpp.xml#Unary Standard Math" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Unary Standard Math</a><br/>
	9551	<a href="base_std_math.xml#Unary Standard Math" target="_top">Base Type Requirements for Standard Math Functions: Unary Standard Math</a><br/>
	9552	<a href="base_member.xml#Unary Operators" target="_top">Required Base Class Member Functions: Unary Operators</a><br/>
	9553	<a href="boolfun.xml#Create Unary" target="_top">AD Boolean Functions: Create Unary</a><br/>
	9554	<a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
	9555	<a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a><br/>
	9556	<a href="unaryminus.xml" target="_top">AD Unary Minus Operator</a><br/>
	9557	<a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a><br/>
	9558	<a href="unaryplus.xml" target="_top">AD Unary Plus Operator</a><br/>
2699	9559	AD<b> </b>bool <a href="boolfun.xml" target="_top">AD Boolean Functions</a><br/>
2700	9560	AD<b> </b>math <a href="std_math_ad.xml" target="_top">AD Standard Math Unary Functions</a><br/>
2701	9561	AD<b> </b>minus<b> </b>operator <a href="unaryminus.xml" target="_top">AD Unary Minus Operator</a><br/>

2705	9565	example <a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a><br/>
2706	9566	unary<b> </b>plus<br/>
2707	9567	example <a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a><br/>
2708		uniform<br/>
	9568	unary<b>_</b>name <a href="boolfun.xml#unary_name" target="_top">AD Boolean Functions: unary_name</a><br/>
	9569	uniform <a href="uniform_01_c.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	9570	<a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
2709	9571	random<b> </b>vector <a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
2710		uniform<b>_</b>01 <a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
2711		<a href="speed_main.xml#seed" target="_top">Speed Testing Main Program: seed</a><br/>
	9572	uniform<b>_</b>01 <a href="uniform_01.hpp.xml" target="_top">Source: uniform_01</a><br/>
	9573	<a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	9574	<a href="speed_main.xml#seed" target="_top">Running the Speed Test Program: seed</a><br/>
2712	9575	source <a href="uniform_01.hpp.xml" target="_top">Source: uniform_01</a><br/>
2713		unix<br/>
	9576	union <a href="old_mat_mul.hpp.xml#Set Union" target="_top">Define Matrix Multiply as a User Atomic Operation: Set Union</a><br/>
	9577	unix <a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a><br/>
	9578	<a href="adolc_prefix.xml#Unix" target="_top">Including the ADOL-C Examples and Tests: Unix</a><br/>
	9579	<a href="download.xml#Compressed Tar File.Unix File Extraction" target="_top">Download The CppAD Source Code: Compressed Tar File.Unix File Extraction</a><br/>
2714	9580	adolc <a href="adolc_prefix.xml#Unix" target="_top">Including the ADOL-C Examples and Tests: Unix</a><br/>
2715		CppAD<b> </b>install <a href="installunix.xml" target="_top">Unix Test and Installation</a><br/>
2716		use<br/>
	9581	CppAD<b> </b>install <a href="installunix.xml" target="_top">Deprecated Unix Test and Installation</a><br/>
	9582	unknown <a href="cppad_assert.xml#Restriction.Unknown" target="_top">CppAD Assertions During Execution: Restriction.Unknown</a><br/>
	9583	usage <a href="old_atomic.xml#rev_hes_sparse.Usage" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.Usage</a><br/>
	9584	<a href="old_atomic.xml#rev_jac_sparse.Usage" target="_top">User Defined Atomic AD Functions: rev_jac_sparse.Usage</a><br/>
	9585	<a href="old_atomic.xml#for_jac_sparse.Usage" target="_top">User Defined Atomic AD Functions: for_jac_sparse.Usage</a><br/>
	9586	<a href="old_atomic.xml#reverse.Usage" target="_top">User Defined Atomic AD Functions: reverse.Usage</a><br/>
	9587	<a href="old_atomic.xml#forward.Usage" target="_top">User Defined Atomic AD Functions: forward.Usage</a><br/>
	9588	<a href="pkgconfig.xml#Usage" target="_top">CppAD pkg-config Files: Usage</a><br/>
	9589	use <a href="old_atomic.xml#Example.Use AD" target="_top">User Defined Atomic AD Functions: Example.Use AD</a><br/>
	9590	<a href="old_atomic.xml#Syntax.Use Function" target="_top">User Defined Atomic AD Functions: Syntax.Use Function</a><br/>
	9591	<a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
	9592	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	9593	<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	9594	<a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
	9595	<a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
	9596	<a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
	9597	<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
	9598	<a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	9599	<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
	9600	<a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
	9601	<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
	9602	<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
	9603	<a href="speed_program.cpp.xml" target="_top">Example Use of SpeedTest</a><br/>
	9604	<a href="team_thread.hpp.xml#Example Use" target="_top">Specifications for A Team of AD Threads: Example Use</a><br/>
	9605	<a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
	9606	<a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
	9607	<a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
	9608	<a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
	9609	<a href="atomic_mat_mul.cpp.xml#Use Atomic Function" target="_top">User Atomic Matrix Multiply: Example and Test: Use Atomic Function</a><br/>
	9610	<a href="atomic_hes_sparse.cpp.xml#Use Atomic Function" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Use Atomic Function</a><br/>
	9611	<a href="atomic_tangent.cpp.xml#Use Atomic Function" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function</a><br/>
	9612	<a href="atomic_reciprocal.cpp.xml#Use Atomic Function" target="_top">Reciprocal as an Atomic Operation: Example and Test: Use Atomic Function</a><br/>
	9613	<a href="atomic_norm_sq.cpp.xml#Use Atomic Function" target="_top">Euclidean Norm Squared: Example and Test: Use Atomic Function</a><br/>
	9614	<a href="atomic_get_started.cpp.xml#Use Atomic Function" target="_top">Getting Started with Atomic Operations: Example and Test: Use Atomic Function</a><br/>
	9615	<a href="atomic_base_clear.xml#Future Use" target="_top">Free Static Variables: Future Use</a><br/>
	9616	<a href="atomic_rev_sparse_hes.xml#Examples.Use rev_sparse_hes" target="_top">Atomic Reverse Hessian Sparsity Patterns: Examples.Use rev_sparse_hes</a><br/>
	9617	<a href="atomic_rev_sparse_jac.xml#Examples.Use rev_sparse_jac" target="_top">Atomic Reverse Jacobian Sparsity Patterns: Examples.Use rev_sparse_jac</a><br/>
	9618	<a href="atomic_for_sparse_jac.xml#Examples.Use for_sparse_jac" target="_top">Atomic Forward Jacobian Sparsity Patterns: Examples.Use for_sparse_jac</a><br/>
	9619	<a href="atomic_reverse.xml#Examples.Use reverse" target="_top">Atomic Reverse Mode: Examples.Use reverse</a><br/>
	9620	<a href="atomic_forward.xml#Examples.Use forward" target="_top">Atomic Forward Mode: Examples.Use forward</a><br/>
	9621	<a href="atomic_ctor.xml#Examples.Use Constructor" target="_top">Atomic Function Constructor: Examples.Use Constructor</a><br/>
2717	9622	memory <a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	9623	use<b>_</b>ad <a href="multi_newton_time.cpp.xml#use_ad" target="_top">Timing Test of Multi-Threaded Newton Method: use_ad</a><br/>
	9624	<a href="thread_test.cpp.xml#multi_newton.use_ad" target="_top">Run Multi-Threading Examples and Speed Tests: multi_newton.use_ad</a><br/>
2718	9625	use<b>_</b>VecAD<br/>
2719	9626	ADFun <a href="fundeprecated.xml#use_VecAD" target="_top">ADFun Object Deprecated Member Functions: use_VecAD</a><br/>
2720		user<br/>
	9627	use<b>_</b>vecad <a href="fundeprecated.xml#use_VecAD" target="_top">ADFun Object Deprecated Member Functions: use_VecAD</a><br/>
	9628	used <a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
	9629	<a href="exampleutility.xml" target="_top">Utility Routines used by CppAD Examples</a><br/>
	9630	user <a href="old_mat_mul.hpp.xml#CppAD User Atomic Callback Functions" target="_top">Define Matrix Multiply as a User Atomic Operation: CppAD User Atomic Callback Functions</a><br/>
	9631	<a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
	9632	<a href="old_mat_mul.cpp.xml" target="_top">Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
	9633	<a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	9634	<a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
	9635	<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	9636	<a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>
	9637	<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
	9638	<a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a><br/>
2721	9639	atomic<b> </b>AD<b> </b>inside <a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
2722	9640	atomic<b> </b>AD<b> </b>inside <a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
2723	9641	atomic<b> </b>function <a href="old_atomic.xml" target="_top">User Defined Atomic AD Functions</a><br/>
2724	9642	atomic<b> </b>function <a href="atomic_base.xml" target="_top">User Defined Atomic AD Functions</a><br/>
2725	9643	atomic<b> </b>tan <a href="old_tan.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
2726	9644	old<b> </b>atomic<b> </b>reciprocal <a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
2727		using<br/>
	9645	uses <a href="funcheck.xml#FunCheck Uses Forward" target="_top">Check an ADFun Sequence of Operations: FunCheck Uses Forward</a><br/>
	9646	<a href="sparse_hessian.xml#Uses Forward" target="_top">Sparse Hessian: Easy Driver: Uses Forward</a><br/>
	9647	<a href="sparse_jacobian.xml#Uses Forward" target="_top">Sparse Jacobian: Easy Driver: Uses Forward</a><br/>
	9648	<a href="revtwo.xml#RevTwo Uses Forward" target="_top">Reverse Mode Second Partial Derivative Driver: RevTwo Uses Forward</a><br/>
	9649	<a href="fortwo.xml#ForTwo Uses Forward" target="_top">Forward Mode Second Partial Derivative Driver: ForTwo Uses Forward</a><br/>
	9650	<a href="hessian.xml#Hessian Uses Forward" target="_top">Hessian: Easy Driver: Hessian Uses Forward</a><br/>
	9651	<a href="revone.xml#RevOne Uses Forward" target="_top">First Order Derivative: Driver Routine: RevOne Uses Forward</a><br/>
	9652	<a href="forone.xml#ForOne Uses Forward" target="_top">First Order Partial Derivative: Driver Routine: ForOne Uses Forward</a><br/>
	9653	using <a href="det_by_minor_c.xml" target="_top">Compute Determinant using Expansion by Minors</a><br/>
	9654	<a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	9655	<a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
	9656	<a href="ipopt_nlp_ode_fast.hpp.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	9657	<a href="ipopt_nlp_ode_simple.hpp.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	9658	<a href="ipopt_nlp_ode_fast.xml" target="_top">ODE Fitting Using Fast Representation</a><br/>
	9659	<a href="ipopt_nlp_ode_simple.xml" target="_top">ODE Fitting Using Simple Representation</a><br/>
	9660	<a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	9661	<a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
	9662	<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	9663	<a href="bugs.xml" target="_top">Know Bugs and Problems Using CppAD</a><br/>
	9664	<a href="faq.xml#Namespace.Using" target="_top">Frequently Asked Questions and Answers: Namespace.Using</a><br/>
	9665	<a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	9666	<a href="speed_sacado.xml" target="_top">Speed Test Derivatives Using Sacado</a><br/>
	9667	<a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	9668	<a href="speed_fadbad.xml" target="_top">Speed Test Derivatives Using Fadbad</a><br/>
	9669	<a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	9670	<a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a><br/>
	9671	<a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
	9672	<a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
	9673	<a href="double_det_lu.cpp.xml" target="_top">Double Speed: Determinant Using Lu Factorization</a><br/>
	9674	<a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
	9675	<a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a><br/>
	9676	<a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a><br/>
	9677	<a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
	9678	<a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
	9679	<a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a><br/>
	9680	<a href="mul_level_adolc_ode.cpp.xml#Taylor's Method Using AD" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test: Taylor's Method Using AD</a><br/>
	9681	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	9682	<a href="mul_level_ode.cpp.xml#Taylor's Method Using AD" target="_top">Taylor's Ode Solver: An Example and Test: Taylor's Method Using AD</a><br/>
	9683	<a href="mul_level.xml" target="_top">Using Multiple Levels of AD</a><br/>
	9684	<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
	9685	<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	9686	<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
	9687	<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
	9688	<a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
	9689	<a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
	9690	<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
	9691	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
	9692	<a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a><br/>
	9693	<a href="simplevector.xml#Element Access.Using Value" target="_top">Definition of a Simple Vector: Element Access.Using Value</a><br/>
	9694	<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
	9695	<a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
	9696	<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
	9697	<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
	9698	<a href="atomic_afun.xml" target="_top">Using AD Version of Atomic Function</a><br/>
	9699	<a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
	9700	<a href="colpack.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
	9701	<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
2728	9702	namespace <a href="faq.xml#Namespace.Using" target="_top">Frequently Asked Questions and Answers: Namespace.Using</a><br/>
2729		utility<br/>
	9703	utilities <a href="speed_utility.xml" target="_top">Speed Testing Utilities</a><br/>
	9704	<a href="library.xml#General Purpose Utilities" target="_top">The CppAD General Purpose Library: General Purpose Utilities</a><br/>
	9705	<a href="library.xml#Testing Utilities" target="_top">The CppAD General Purpose Library: Testing Utilities</a><br/>
	9706	utility <a href="speed_utility.xml#Speed Utility Routines" target="_top">Speed Testing Utilities: Speed Utility Routines</a><br/>
	9707	<a href="exampleutility.xml" target="_top">Utility Routines used by CppAD Examples</a><br/>
	9708	<a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>
	9709	<a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
2730	9710	speed <a href="speed_utility.xml" target="_top">Speed Testing Utilities</a><br/>
	9711	utility<b>:</b> <a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
2731	9712
2732	9713	<b><big><a name="V">V</a></big></b>
2733	9714	<br/>

2743	9724	assign<b> </b>to<b> </b>AD <a href="ad_assign.xml" target="_top">AD Assignment Operator</a><br/>
2744	9725	convert<b> </b>to<b> </b>AD <a href="ad_ctor.xml" target="_top">AD Constructors</a><br/>
2745	9726	VecAD<b><</b>Base<b>>::</b>reference <a href="vecad.xml#VecAD<Base>::reference" target="_top">AD Vectors that Record Index Operations: VecAD<Base>::reference</a><br/>
2746		value <a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
	9727	v <a href="old_atomic.xml#rev_hes_sparse.v" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.v</a><br/>
	9728	<a href="nan.xml#hasnan.v" target="_top">Obtain Nan or Determine if a Value is Nan: hasnan.v</a><br/>
	9729	<a href="vecad.xml#Constructor.v" target="_top">AD Vectors that Record Index Operations: Constructor.v</a><br/>
	9730	<a href="boolfun.xml#v" target="_top">AD Boolean Functions: v</a><br/>
	9731	<a href="atomic_rev_sparse_hes.xml#u.v" target="_top">Atomic Reverse Hessian Sparsity Patterns: u.v</a><br/>
	9732	v<b>_</b>ptr <a href="omp_efficient.xml#v_ptr" target="_top">Check If A Memory Allocation is Efficient for Another Use: v_ptr</a><br/>
	9733	<a href="omp_return_memory.xml#v_ptr" target="_top">Return Memory to omp_alloc: v_ptr</a><br/>
	9734	<a href="omp_get_memory.xml#v_ptr" target="_top">Get At Least A Specified Amount of Memory: v_ptr</a><br/>
	9735	<a href="ta_return_memory.xml#v_ptr" target="_top">Return Memory to thread_alloc: v_ptr</a><br/>
	9736	<a href="ta_get_memory.xml#v_ptr" target="_top">Get At Least A Specified Amount of Memory: v_ptr</a><br/>
	9737	valid <a href="base_complex.hpp.xml#Valid Unary Math" target="_top">Enable use of AD<Base> where Base is std::complex<double>: Valid Unary Math</a><br/>
	9738	value <a href="link_poly.xml#Return Value" target="_top">Speed Testing Second Derivative of a Polynomial: Return Value</a><br/>
	9739	<a href="link_ode.xml#Return Value" target="_top">Speed Testing the Jacobian of Ode Solution: Return Value</a><br/>
	9740	<a href="link_mat_mul.xml#Return Value" target="_top">Speed Testing Derivative of Matrix Multiply: Return Value</a><br/>
	9741	<a href="link_det_minor.xml#Return Value" target="_top">Speed Testing Gradient of Determinant by Minor Expansion: Return Value</a><br/>
	9742	<a href="link_det_lu.xml#Return Value" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization: Return Value</a><br/>
	9743	<a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
	9744	<a href="ta_hold_memory.xml#value" target="_top">Control When Thread Alloc Retains Memory For Future Use: value</a><br/>
	9745	<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
	9746	<a href="simplevector.xml#Element Access.Using Value" target="_top">Definition of a Simple Vector: Element Access.Using Value</a><br/>
	9747	<a href="simplevector.xml#Value Type" target="_top">Definition of a Simple Vector: Value Type</a><br/>
	9748	<a href="equalopseq.xml" target="_top">Check if Two Value are Identically Equal</a><br/>
	9749	<a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
	9750	<a href="abs.xml" target="_top">AD Absolute Value Function</a><br/>
	9751	<a href="exp_eps_for2.xml#Return Value" target="_top">exp_eps: Second Order Forward Mode: Return Value</a><br/>
	9752	<a href="exp_eps_for1.xml#Return Value" target="_top">exp_eps: First Order Forward Sweep: Return Value</a><br/>
	9753	<a href="exp_eps_for0.xml#Return Value" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Return Value</a><br/>
	9754	<a href="exp_2_for2.xml#Return Value" target="_top">exp_2: Second Order Forward Mode: Return Value</a><br/>
	9755	<a href="exp_2_for1.xml#Return Value" target="_top">exp_2: First Order Forward Mode: Return Value</a><br/>
	9756	<a href="exp_2_for0.xml#Return Value" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Return Value</a><br/>
	9757	<a href="get_started.cpp.xml#Value" target="_top">Getting Started Using CppAD to Compute Derivatives: Value</a><br/>
2747	9758	AD<b> </b>absolute <a href="abs.xml" target="_top">AD Absolute Value Function</a><br/>
2748	9759	value<b>_</b><br/>
2749	9760	obtain<b> </b>during<b> </b>taping <a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
2750	9761	value<b>_</b>type<br/>
2751	9762	vector <a href="simplevector.xml#Value Type" target="_top">Definition of a Simple Vector: Value Type</a><br/>
2752		variable <a href="glossary.xml#Variable" target="_top">Glossary: Variable</a><br/>
	9763	valued <a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
	9764	<a href="advalued.xml" target="_top">AD Valued Operations and Functions</a><br/>
	9765	values <a href="ipopt_nlp_ode_problem.xml#Measurements.Simulated Measurement Values" target="_top">An ODE Inverse Problem Example: Measurements.Simulated Measurement Values</a><br/>
	9766	<a href="ipopt_nlp_ode_problem.xml#Measurements.Simulation Parameter Values" target="_top">An ODE Inverse Problem Example: Measurements.Simulation Parameter Values</a><br/>
	9767	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements.Simulated Measurement Values" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements.Simulated Measurement Values</a><br/>
	9768	<a href="ipopt_solve_ode_inverse.cpp.xml#Measurements.Simulation Parameter Values" target="_top">ODE Inverse Problem Definitions: Source Code: Measurements.Simulation Parameter Values</a><br/>
	9769	<a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
	9770	<a href="nearequal.xml" target="_top">Determine if Two Values Are Nearly Equal</a><br/>
	9771	<a href="forward_order.xml#Purpose.Derivative Values" target="_top">Multiple Order Forward Mode: Purpose.Derivative Values</a><br/>
	9772	<a href="forward_order.xml#Purpose.Function Values" target="_top">Multiple Order Forward Mode: Purpose.Function Values</a><br/>
	9773	<a href="forward_two.xml" target="_top">Second Order Forward Mode: Derivative Values</a><br/>
	9774	<a href="forward_one.xml" target="_top">First Order Forward Mode: Derivative Values</a><br/>
	9775	<a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
	9776	<a href="atomic_tangent.cpp.xml#Use Atomic Function.Large x Values" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.Large x Values</a><br/>
	9777	<a href="printfor.xml" target="_top">Printing AD Values During Forward Mode</a><br/>
	9778	var <a href="printfor.xml#var" target="_top">Printing AD Values During Forward Mode: var</a><br/>
	9779	variable <a href="wishlist.xml#Optimization.Variable Pairs" target="_top">The CppAD Wish List: Optimization.Variable Pairs</a><br/>
	9780	<a href="glossary.xml#Variable" target="_top">Glossary: Variable</a><br/>
2753	9781	<a href="glossary.xml#Tape.Independent Variable" target="_top">Glossary: Tape.Independent Variable</a><br/>
	9782	<a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
	9783	<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
	9784	<a href="atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Test with x_1 Both a Variable and a Parameter</a><br/>
	9785	<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
	9786	<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
	9787	<a href="exp_eps_for0.xml#Operation Sequence.Variable" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence.Variable</a><br/>
2754	9788	convert<b> </b>to<b> </b>parameter <a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
2755	9789	independent <a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
2756	9790	variables <a href="glossary.xml#Tape.Dependent Variables" target="_top">Glossary: Tape.Dependent Variables</a><br/>
	9791	<a href="faq.xml#Independent Variables" target="_top">Frequently Asked Questions and Answers: Independent Variables</a><br/>
	9792	<a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
	9793	<a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
	9794	<a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
	9795	<a href="atomic_base_clear.xml" target="_top">Free Static Variables</a><br/>
2757	9796	skip <a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
	9797	variate <a href="uniform_01_c.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	9798	<a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
2758	9799	vec<b>_</b>ad<b>.</b>cpp <a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
2759		vector <a href="glossary.xml#Sparsity Pattern.Vector of Sets" target="_top">Glossary: Sparsity Pattern.Vector of Sets</a><br/>
	9800	vecad<b><</b>base<b>>::</b>reference <a href="vecad.xml#VecAD<Base>::reference" target="_top">AD Vectors that Record Index Operations: VecAD<Base>::reference</a><br/>
	9801	vector <a href="ipopt_nlp_ode_simple.xml#Argument Vector" target="_top">ODE Fitting Using Simple Representation: Argument Vector</a><br/>
	9802	<a href="cppad_ipopt_nlp.xml#fg(x).Index Vector" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: fg(x).Index Vector</a><br/>
	9803	<a href="test_vector.xml" target="_top">Choosing The Vector Testing Template Class</a><br/>
	9804	<a href="glossary.xml#Sparsity Pattern.Vector of Sets" target="_top">Glossary: Sparsity Pattern.Vector of Sets</a><br/>
2760	9805	<a href="glossary.xml#Sparsity Pattern.Vector of Boolean" target="_top">Glossary: Sparsity Pattern.Vector of Boolean</a><br/>
2761	9806	<a href="glossary.xml#Elementary Vector" target="_top">Glossary: Elementary Vector</a><br/>
	9807	<a href="faq.xml#Namespace.Test Vector Preprocessor Symbol" target="_top">Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol</a><br/>
	9808	<a href="uniform_01.xml#Vector" target="_top">Simulate a [0,1] Uniform Random Variate: Vector</a><br/>
	9809	<a href="mat_sum_sq.xml#Vector" target="_top">Sum Elements of a Matrix Times Itself: Vector</a><br/>
	9810	<a href="det_grad_33.xml#Vector" target="_top">Check Gradient of Determinant of 3 by 3 matrix: Vector</a><br/>
	9811	<a href="det_33.xml#Vector" target="_top">Check Determinant of 3 by 3 matrix: Vector</a><br/>
	9812	<a href="det_by_minor.xml#Vector" target="_top">Determinant Using Expansion by Minors: Vector</a><br/>
	9813	<a href="det_by_lu.xml#Vector" target="_top">Determinant Using Expansion by Lu Factorization: Vector</a><br/>
	9814	<a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a><br/>
	9815	<a href="example.xml#The CppAD Test Vector Template Class" target="_top">Examples: The CppAD Test Vector Template Class</a><br/>
	9816	<a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a><br/>
	9817	<a href="odegearcontrol.xml#Vector" target="_top">An Error Controller for Gear's Ode Solvers: Vector</a><br/>
	9818	<a href="odegear.xml#Vector" target="_top">An Arbitrary Order Gear Method: Vector</a><br/>
	9819	<a href="odeerrcontrol.xml#Vector" target="_top">An Error Controller for ODE Solvers: Vector</a><br/>
	9820	<a href="rosen34.xml#Vector" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Vector</a><br/>
	9821	<a href="runge45.xml#Vector" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Vector</a><br/>
	9822	<a href="poly.xml#Vector" target="_top">Evaluate a Polynomial or its Derivative: Vector</a><br/>
	9823	<a href="nan.xml#Vector" target="_top">Obtain Nan or Determine if a Value is Nan: Vector</a><br/>
	9824	<a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a><br/>
	9825	<a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a><br/>
	9826	<a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
	9827	<a href="speed_test.xml#Vector" target="_top">Run One Speed Test and Return Results: Vector</a><br/>
	9828	<a href="funcheck.xml#Vector" target="_top">Check an ADFun Sequence of Operations: Vector</a><br/>
	9829	<a href="hessian.xml#Vector" target="_top">Hessian: Easy Driver: Vector</a><br/>
	9830	<a href="revone.xml#Vector" target="_top">First Order Derivative: Driver Routine: Vector</a><br/>
	9831	<a href="forone.xml#Vector" target="_top">First Order Partial Derivative: Driver Routine: Vector</a><br/>
	9832	<a href="jacobian.xml#Vector" target="_top">Jacobian: Driver Routine: Vector</a><br/>
	9833	<a href="reverse_any.xml#Vector" target="_top">Any Order Reverse Mode: Vector</a><br/>
	9834	<a href="reverse_two.xml#Vector" target="_top">Second Order Reverse Mode: Vector</a><br/>
	9835	<a href="reverse_one.xml#Vector" target="_top">First Order Reverse Mode: Vector</a><br/>
	9836	<a href="forward_dir.xml#Vector" target="_top">Multiple Directions Forward Mode: Vector</a><br/>
	9837	<a href="forward_order.xml#Vector" target="_top">Multiple Order Forward Mode: Vector</a><br/>
	9838	<a href="forward_two.xml#Vector" target="_top">Second Order Forward Mode: Derivative Values: Vector</a><br/>
	9839	<a href="forward_one.xml#Vector" target="_top">First Order Forward Mode: Derivative Values: Vector</a><br/>
	9840	<a href="forward_zero.xml#Vector" target="_top">Zero Order Forward Mode: Function Values: Vector</a><br/>
	9841	<a href="atomic_base.xml#Examples.Vector Range" target="_top">User Defined Atomic AD Functions: Examples.Vector Range</a><br/>
	9842	<a href="cppad_testvector.xml" target="_top">Choosing the CppAD Test Vector Template Class</a><br/>
	9843	<a href="eigen_prefix.xml#Test Vector" target="_top">Including the Eigen Examples and Tests: Test Vector</a><br/>
2762	9844	<b>[] </b>CppAD <a href="cppad_vector.xml#Element Access" target="_top">The CppAD::vector Template Class: Element Access</a><br/>
2763	9845	AD<b> </b>index <a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
2764	9846	boost <a href="cppad_testvector.xml#boost" target="_top">Choosing the CppAD Test Vector Template Class: boost</a><br/>
2765	9847	CppAD <a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
	9848	CppAD<b> </b>data <a href="cppad_vector.xml#data" target="_top">The CppAD::vector Template Class: data</a><br/>
2766	9849	CppAD<b> </b>push <a href="cppad_vector.xml#push_vector" target="_top">The CppAD::vector Template Class: push_vector</a><br/>
2767	9850	CppAD<b> </b>push<b>_</b>back <a href="cppad_vector.xml#push_back" target="_top">The CppAD::vector Template Class: push_back</a><br/>
2768	9851	CppAD<b> </b>template<b> </b>class <a href="cppad_vector.xml" target="_top">The CppAD::vector Template Class</a><br/>

2774	9857	simple<b> </b>check <a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a><br/>
2775	9858	test <a href="test_vector.xml" target="_top">Choosing The Vector Testing Template Class</a><br/>
2776	9859	test <a href="testvector.xml" target="_top">Using The CppAD Test Vector Template Class</a><br/>
2777		test <a href="installunix.xml#--with-testvector" target="_top">Unix Test and Installation: --with-testvector</a><br/>
	9860	test <a href="installunix.xml#--with-testvector" target="_top">Deprecated Unix Test and Installation: --with-testvector</a><br/>
2778	9861	thread<b>_</b>alloc <a href="cppad_vector.xml#Memory and Parallel Mode" target="_top">The CppAD::vector Template Class: Memory and Parallel Mode</a><br/>
2779	9862	uniform<b> </b>random <a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
	9863	vectorad <a href="funconstruct.xml#VectorAD" target="_top">Construct an ADFun Object and Stop Recording: VectorAD</a><br/>
	9864	<a href="independent.xml#VectorAD" target="_top">Declare Independent Variables and Start Recording: VectorAD</a><br/>
2780	9865	vectorBool <a href="cppad_vector.xml#vectorBool" target="_top">The CppAD::vector Template Class: vectorBool</a><br/>
2781	9866	CppAD <a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
2782		version<br/>
2783		CppAD <a href="cppad.xml" target="_top">cppad-20140000.3: A Package for Differentiation of C++ Algorithms</a><br/>
	9867	vectorbase <a href="sparse_hessian.xml#VectorBase" target="_top">Sparse Hessian: Easy Driver: VectorBase</a><br/>
	9868	<a href="sparse_jacobian.xml#VectorBase" target="_top">Sparse Jacobian: Easy Driver: VectorBase</a><br/>
	9869	<a href="revtwo.xml#VectorBase" target="_top">Reverse Mode Second Partial Derivative Driver: VectorBase</a><br/>
	9870	<a href="fortwo.xml#VectorBase" target="_top">Forward Mode Second Partial Derivative Driver: VectorBase</a><br/>
	9871	vectorbool <a href="cppad_vector.xml#vectorBool" target="_top">The CppAD::vector Template Class: vectorBool</a><br/>
	9872	vectors <a href="testvector.xml#Eigen Vectors" target="_top">Using The CppAD Test Vector Template Class: Eigen Vectors</a><br/>
	9873	<a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
	9874	<a href="vecad.xml" target="_top">AD Vectors that Record Index Operations</a><br/>
	9875	vectorset <a href="sparse_hessian.xml#VectorSet" target="_top">Sparse Hessian: Easy Driver: VectorSet</a><br/>
	9876	<a href="sparse_jacobian.xml#VectorSet" target="_top">Sparse Jacobian: Easy Driver: VectorSet</a><br/>
	9877	<a href="revsparsehes.xml#VectorSet" target="_top">Hessian Sparsity Pattern: Reverse Mode: VectorSet</a><br/>
	9878	<a href="revsparsejac.xml#VectorSet" target="_top">Jacobian Sparsity Pattern: Reverse Mode: VectorSet</a><br/>
	9879	<a href="forsparsejac.xml#VectorSet" target="_top">Jacobian Sparsity Pattern: Forward Mode: VectorSet</a><br/>
	9880	vectorsize <a href="sparse_hessian.xml#VectorSize" target="_top">Sparse Hessian: Easy Driver: VectorSize</a><br/>
	9881	<a href="sparse_jacobian.xml#VectorSize" target="_top">Sparse Jacobian: Easy Driver: VectorSize</a><br/>
	9882	vectorsize<b>_</b>t <a href="revtwo.xml#VectorSize_t" target="_top">Reverse Mode Second Partial Derivative Driver: VectorSize_t</a><br/>
	9883	<a href="fortwo.xml#VectorSize_t" target="_top">Forward Mode Second Partial Derivative Driver: VectorSize_t</a><br/>
	9884	verification <a href="exp_eps_rev2.xml#Verification" target="_top">exp_eps: Second Order Reverse Sweep: Verification</a><br/>
	9885	<a href="exp_eps_for2.xml#Verification" target="_top">exp_eps: Second Order Forward Mode: Verification</a><br/>
	9886	<a href="exp_eps_rev1.xml#Verification" target="_top">exp_eps: First Order Reverse Sweep: Verification</a><br/>
	9887	<a href="exp_eps_for1.xml#Verification" target="_top">exp_eps: First Order Forward Sweep: Verification</a><br/>
	9888	<a href="exp_eps_for0.xml#Verification" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Verification</a><br/>
	9889	<a href="exp_2_rev2.xml#Verification" target="_top">exp_2: Second Order Reverse Mode: Verification</a><br/>
	9890	<a href="exp_2_for2.xml#Verification" target="_top">exp_2: Second Order Forward Mode: Verification</a><br/>
	9891	<a href="exp_2_rev1.xml#Verification" target="_top">exp_2: First Order Reverse Mode: Verification</a><br/>
	9892	<a href="exp_2_for1.xml#Verification" target="_top">exp_2: First Order Forward Mode: Verification</a><br/>
	9893	<a href="exp_2_for0.xml#Verification" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Verification</a><br/>
	9894	verify <a href="exp_eps_rev2.cpp.xml" target="_top">exp_eps: Verify Second Order Reverse Sweep</a><br/>
	9895	<a href="exp_eps_for2.cpp.xml" target="_top">exp_eps: Verify Second Order Forward Sweep</a><br/>
	9896	<a href="exp_eps_rev1.cpp.xml" target="_top">exp_eps: Verify First Order Reverse Sweep</a><br/>
	9897	<a href="exp_eps_for1.cpp.xml" target="_top">exp_eps: Verify First Order Forward Sweep</a><br/>
	9898	<a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a><br/>
	9899	<a href="exp_2_rev2.cpp.xml" target="_top">exp_2: Verify Second Order Reverse Sweep</a><br/>
	9900	<a href="exp_2_for2.cpp.xml" target="_top">exp_2: Verify Second Order Forward Sweep</a><br/>
	9901	<a href="exp_2_rev1.cpp.xml" target="_top">exp_2: Verify First Order Reverse Sweep</a><br/>
	9902	<a href="exp_2_for1.cpp.xml" target="_top">exp_2: Verify First Order Forward Sweep</a><br/>
	9903	<a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a><br/>
	9904	version <a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a><br/>
	9905	<a href="atomic_afun.xml" target="_top">Using AD Version of Atomic Function</a><br/>
	9906	<a href="discrete.xml#Create AD Version" target="_top">Discrete AD Functions: Create AD Version</a><br/>
	9907	<a href="download.xml#Subversion.Current Version" target="_top">Download The CppAD Source Code: Subversion.Current Version</a><br/>
	9908	<a href="download.xml#Compressed Tar File.Current Version" target="_top">Download The CppAD Source Code: Compressed Tar File.Current Version</a><br/>
	9909	CppAD <a href="cppad.xml" target="_top">cppad-20150000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	9910	version<b>)</b> <a href="double_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication (Double Version)</a><br/>
	9911	versions <a href="download.xml#Subversion.Release Versions" target="_top">Download The CppAD Source Code: Subversion.Release Versions</a><br/>
	9912	<a href="download.xml#Subversion.Stable Versions" target="_top">Download The CppAD Source Code: Subversion.Stable Versions</a><br/>
	9913	<a href="download.xml#Compressed Tar File.Release Versions" target="_top">Download The CppAD Source Code: Compressed Tar File.Release Versions</a><br/>
	9914	<a href="download.xml#Compressed Tar File.Monthly Versions" target="_top">Download The CppAD Source Code: Compressed Tar File.Monthly Versions</a><br/>
	9915	virtual <a href="atomic_base.xml#Virtual Functions" target="_top">User Defined Atomic AD Functions: Virtual Functions</a><br/>
	9916	vx <a href="old_atomic.xml#forward.vx" target="_top">User Defined Atomic AD Functions: forward.vx</a><br/>
	9917	<a href="atomic_rev_sparse_hes.xml#Implementation.vx" target="_top">Atomic Reverse Hessian Sparsity Patterns: Implementation.vx</a><br/>
	9918	<a href="atomic_forward.xml#vx" target="_top">Atomic Forward Mode: vx</a><br/>
	9919	vy <a href="old_atomic.xml#forward.vy" target="_top">User Defined Atomic AD Functions: forward.vy</a><br/>
	9920	<a href="atomic_forward.xml#vy" target="_top">Atomic Forward Mode: vy</a><br/>
2784	9921
2785	9922	<b><big><a name="W">W</a></big></b>
2786	9923	<br/>
2787		windows<br/>
2788		speed<b> </b>test <a href="speed.xml#Windows" target="_top">AD Speed Test Routines: Windows</a><br/>
	9924	w <a href="sparse_hessian.xml#w" target="_top">Sparse Hessian: Easy Driver: w</a><br/>
	9925	<a href="hessian.xml#w" target="_top">Hessian: Easy Driver: w</a><br/>
	9926	<a href="reverse_any.xml#w" target="_top">Any Order Reverse Mode: w</a><br/>
	9927	<a href="reverse_two.xml#w" target="_top">Second Order Reverse Mode: w</a><br/>
	9928	<a href="reverse_two.xml#W" target="_top">Second Order Reverse Mode: W</a><br/>
	9929	<a href="reverse_one.xml#w" target="_top">First Order Reverse Mode: w</a><br/>
	9930	w<b>(</b>u<b>)</b> <a href="reverse_any.xml#Notation.W(u)" target="_top">Any Order Reverse Mode: Notation.W(u)</a><br/>
	9931	w<b>^(</b>k<b>)</b> <a href="reverse_any.xml#Notation.w^(k)" target="_top">Any Order Reverse Mode: Notation.w^(k)</a><br/>
	9932	warning <a href="odegearcontrol.xml#Fun.Warning" target="_top">An Error Controller for Gear's Ode Solvers: Fun.Warning</a><br/>
	9933	<a href="odegear.xml#Fun.Warning" target="_top">An Arbitrary Order Gear Method: Fun.Warning</a><br/>
	9934	<a href="rosen34.xml#Fun.Warning" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.Warning</a><br/>
	9935	<a href="runge45.xml#Fun.Warning" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Fun.Warning</a><br/>
	9936	<a href="base_require.xml#Warning" target="_top">AD<Base> Requirements for Base Type: Warning</a><br/>
	9937	was <a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
	9938	when <a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
	9939	where <a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
	9940	<a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
	9941	<a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
	9942	<a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
	9943	<a href="base_alloc.hpp.xml" target="_top">Example AD<Base> Where Base Constructor Allocates Memory</a><br/>
	9944	windows <a href="test_vector.xml#MS Windows" target="_top">Choosing The Vector Testing Template Class: MS Windows</a><br/>
	9945	<a href="download.xml#Compressed Tar File.Windows File Extraction" target="_top">Download The CppAD Source Code: Compressed Tar File.Windows File Extraction</a><br/>
	9946	wish <a href="cppad_ipopt_nlp.xml#Wish List" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: Wish List</a><br/>
	9947	<a href="wishlist.xml" target="_top">The CppAD Wish List</a><br/>
2789	9948	wish<b> </b>list <a href="wishlist.xml" target="_top">The CppAD Wish List</a><br/>
	9949	with <a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
	9950	<a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
	9951	<a href="mul_level_adolc_ode.cpp.xml" target="_top">Using Adolc with Taylor's Ode Solver: An Example and Test</a><br/>
	9952	<a href="change_const.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
	9953	<a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
	9954	<a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
	9955	<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
	9956	<a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a><br/>
	9957	<a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
	9958	<a href="atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Test with x_1 Both a Variable and a Parameter</a><br/>
	9959	<a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
	9960	<a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
	9961	<a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
	9962	work <a href="sparse_hessian.xml#work" target="_top">Sparse Hessian: Easy Driver: work</a><br/>
	9963	<a href="sparse_jacobian.xml#work" target="_top">Sparse Jacobian: Easy Driver: work</a><br/>
	9964	<a href="installunix.xml#Work Directory" target="_top">Deprecated Unix Test and Installation: Work Directory</a><br/>
2790	9965	worker<br/>
2791	9966	harmonic <a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
2792	9967	multi<b>_</b>newton <a href="multi_newton_work.cpp.xml" target="_top">Multi-threading Newton Method Utility Routines</a><br/>

2794	9969	AD <a href="ad_output.xml" target="_top">AD Output Stream Operator</a><br/>
2795	9970	AD <a href="ad_input.xml" target="_top">AD Output Stream Operator</a><br/>
2796	9971
	9972	<b><big><a name="X">X</a></big></b>
	9973	<br/>
	9974	x <a href="cppad_ipopt_nlp.xml#solution.x" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: solution.x</a><br/>
	9975	<a href="uniform_01.xml#x" target="_top">Simulate a [0,1] Uniform Random Variate: x</a><br/>
	9976	<a href="sparse_hes_fun.xml#x" target="_top">Evaluate a Function That Has a Sparse Hessian: x</a><br/>
	9977	<a href="sparse_jac_fun.xml#x" target="_top">Evaluate a Function That Has a Sparse Jacobian: x</a><br/>
	9978	<a href="ode_evaluate.xml#x" target="_top">Evaluate a Function Defined in Terms of an ODE: x</a><br/>
	9979	<a href="mat_sum_sq.xml#x" target="_top">Sum Elements of a Matrix Times Itself: x</a><br/>
	9980	<a href="det_grad_33.xml#x" target="_top">Check Gradient of Determinant of 3 by 3 matrix: x</a><br/>
	9981	<a href="det_33.xml#x" target="_top">Check Determinant of 3 by 3 matrix: x</a><br/>
	9982	<a href="link_sparse_jacobian.xml#x" target="_top">Speed Testing Sparse Jacobian: x</a><br/>
	9983	<a href="link_sparse_hessian.xml#x" target="_top">Speed Testing Sparse Hessian: x</a><br/>
	9984	<a href="link_ode.xml#x" target="_top">Speed Testing the Jacobian of Ode Solution: x</a><br/>
	9985	<a href="link_mat_mul.xml#x" target="_top">Speed Testing Derivative of Matrix Multiply: x</a><br/>
	9986	<a href="ipopt_solve.xml#solution.x" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: solution.x</a><br/>
	9987	<a href="ipopt_solve.xml#fg_eval.x" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: fg_eval.x</a><br/>
	9988	<a href="opt_val_hes.xml#x" target="_top">Jacobian and Hessian of Optimal Values: x</a><br/>
	9989	<a href="benderquad.xml#x" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: x</a><br/>
	9990	<a href="odegearcontrol.xml#Fun.x" target="_top">An Error Controller for Gear's Ode Solvers: Fun.x</a><br/>
	9991	<a href="odegear.xml#X" target="_top">An Arbitrary Order Gear Method: X</a><br/>
	9992	<a href="odegear.xml#Fun.x" target="_top">An Arbitrary Order Gear Method: Fun.x</a><br/>
	9993	<a href="rosen34.xml#Fun.x" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.x</a><br/>
	9994	<a href="runge45.xml#Fun.x" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Fun.x</a><br/>
	9995	<a href="luinvert.xml#X" target="_top">Invert an LU Factored Equation: X</a><br/>
	9996	<a href="lusolve.xml#X" target="_top">Compute Determinant and Solve Linear Equations: X</a><br/>
	9997	<a href="pow_int.xml#x" target="_top">The Integer Power Function: x</a><br/>
	9998	<a href="checksimplevector.xml#x, y" target="_top">Check Simple Vector Concept: x, y</a><br/>
	9999	<a href="nearequal.xml#x" target="_top">Determine if Two Values Are Nearly Equal: x</a><br/>
	10000	<a href="funcheck.xml#x" target="_top">Check an ADFun Sequence of Operations: x</a><br/>
	10001	<a href="funcheck.xml#g.x" target="_top">Check an ADFun Sequence of Operations: g.x</a><br/>
	10002	<a href="sparse_hessian.xml#x" target="_top">Sparse Hessian: Easy Driver: x</a><br/>
	10003	<a href="sparse_jacobian.xml#x" target="_top">Sparse Jacobian: Easy Driver: x</a><br/>
	10004	<a href="revtwo.xml#x" target="_top">Reverse Mode Second Partial Derivative Driver: x</a><br/>
	10005	<a href="fortwo.xml#x" target="_top">Forward Mode Second Partial Derivative Driver: x</a><br/>
	10006	<a href="hessian.xml#x" target="_top">Hessian: Easy Driver: x</a><br/>
	10007	<a href="revone.xml#x" target="_top">First Order Derivative: Driver Routine: x</a><br/>
	10008	<a href="forone.xml#x" target="_top">First Order Partial Derivative: Driver Routine: x</a><br/>
	10009	<a href="jacobian.xml#x" target="_top">Jacobian: Driver Routine: x</a><br/>
	10010	<a href="revsparsehes.xml#x" target="_top">Hessian Sparsity Pattern: Reverse Mode: x</a><br/>
	10011	<a href="revsparsejac.xml#x" target="_top">Jacobian Sparsity Pattern: Reverse Mode: x</a><br/>
	10012	<a href="forsparsejac.xml#x" target="_top">Jacobian Sparsity Pattern: Forward Mode: x</a><br/>
	10013	<a href="reverse_one.xml#x" target="_top">First Order Reverse Mode: x</a><br/>
	10014	<a href="dependent.xml#x" target="_top">Stop Recording and Store Operation Sequence: x</a><br/>
	10015	<a href="funconstruct.xml#x" target="_top">Construct an ADFun Object and Stop Recording: x</a><br/>
	10016	<a href="independent.xml#x" target="_top">Declare Independent Variables and Start Recording: x</a><br/>
	10017	<a href="vecad.xml#AD Indexing.x" target="_top">AD Vectors that Record Index Operations: AD Indexing.x</a><br/>
	10018	<a href="equalopseq.xml#x" target="_top">Check if Two Value are Identically Equal: x</a><br/>
	10019	<a href="parvar.xml#x" target="_top">Is an AD Object a Parameter or Variable: x</a><br/>
	10020	<a href="boolfun.xml#x" target="_top">AD Boolean Functions: x</a><br/>
	10021	<a href="nearequalext.xml#x" target="_top">Compare AD and Base Objects for Nearly Equal: x</a><br/>
	10022	<a href="compare.xml#x" target="_top">AD Binary Comparison Operators: x</a><br/>
	10023	<a href="atomic_tangent.cpp.xml#Use Atomic Function.Large x Values" target="_top">Tan and Tanh as User Atomic Operations: Example and Test: Use Atomic Function.Large x Values</a><br/>
	10024	<a href="discrete.xml#x" target="_top">Discrete AD Functions: x</a><br/>
	10025	<a href="pow.xml#x" target="_top">The AD Power Function: x</a><br/>
	10026	<a href="erf.xml#x" target="_top">The AD Error Function: x</a><br/>
	10027	<a href="atan2.xml#x" target="_top">AD Two Argument Inverse Tangent Function: x</a><br/>
	10028	<a href="sign.xml#x" target="_top">Sign Function: x</a><br/>
	10029	<a href="abs.xml#x" target="_top">AD Absolute Value Function: x</a><br/>
	10030	<a href="std_math_ad.xml#x" target="_top">AD Standard Math Unary Functions: x</a><br/>
	10031	<a href="compute_assign.xml#x" target="_top">AD Computed Assignment Operators: x</a><br/>
	10032	<a href="ad_binary.xml#x" target="_top">AD Binary Arithmetic Operators: x</a><br/>
	10033	<a href="unaryminus.xml#x" target="_top">AD Unary Minus Operator: x</a><br/>
	10034	<a href="unaryplus.xml#x" target="_top">AD Unary Plus Operator: x</a><br/>
	10035	<a href="var2par.xml#x" target="_top">Convert an AD Variable to a Parameter: x</a><br/>
	10036	<a href="ad_output.xml#x" target="_top">AD Output Stream Operator: x</a><br/>
	10037	<a href="ad_input.xml#x" target="_top">AD Output Stream Operator: x</a><br/>
	10038	<a href="integer.xml#x" target="_top">Convert From AD to Integer: x</a><br/>
	10039	<a href="value.xml#x" target="_top">Convert From an AD Type to its Base Type: x</a><br/>
	10040	<a href="ad_assign.xml#x" target="_top">AD Assignment Operator: x</a><br/>
	10041	<a href="ad_ctor.xml#x" target="_top">AD Constructors: x</a><br/>
	10042	<a href="exp_eps.xml#x" target="_top">An Epsilon Accurate Exponential Approximation: x</a><br/>
	10043	<a href="exp_2.xml#x" target="_top">Second Order Exponential Approximation: x</a><br/>
	10044	x<b>(</b>t <a href="reverse_any.xml#Notation.X(t, u)" target="_top">Any Order Reverse Mode: Notation.X(t, u)</a><br/>
	10045	x<b>(</b>t<b>)</b> <a href="forward_dir.xml#X(t)" target="_top">Multiple Directions Forward Mode: X(t)</a><br/>
	10046	<a href="forward_order.xml#X(t)" target="_top">Multiple Order Forward Mode: X(t)</a><br/>
	10047	x<b>)</b> <a href="printfor.xml#f.Forward(0, x)" target="_top">Printing AD Values During Forward Mode: f.Forward(0, x)</a><br/>
	10048	x0 <a href="forward_two.xml#x0" target="_top">Second Order Forward Mode: Derivative Values: x0</a><br/>
	10049	<a href="forward_one.xml#x0" target="_top">First Order Forward Mode: Derivative Values: x0</a><br/>
	10050	<a href="forward_zero.xml#x0" target="_top">Zero Order Forward Mode: Function Values: x0</a><br/>
	10051	x1 <a href="forward_two.xml#x1" target="_top">Second Order Forward Mode: Derivative Values: x1</a><br/>
	10052	<a href="forward_one.xml#x1" target="_top">First Order Forward Mode: Derivative Values: x1</a><br/>
	10053	x2 <a href="forward_two.xml#x2" target="_top">Second Order Forward Mode: Derivative Values: x2</a><br/>
	10054	x<b>^(</b>k<b>)</b> <a href="reverse_two.xml#x^(k)" target="_top">Second Order Reverse Mode: x^(k)</a><br/>
	10055	x<b>_</b>1 <a href="atomic_hes_sparse.cpp.xml#Test with x_1 Both a Variable and a Parameter" target="_top">Atomic Operation Hessian Sparsity: Example and Test: Test with x_1 Both a Variable and a Parameter</a><br/>
	10056	x<b>_</b>i <a href="cppad_ipopt_nlp.xml#x_i" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: x_i</a><br/>
	10057	x<b>_</b>l <a href="cppad_ipopt_nlp.xml#x_l" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: x_l</a><br/>
	10058	x<b>_</b>u <a href="cppad_ipopt_nlp.xml#x_u" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: x_u</a><br/>
	10059	xf <a href="odegearcontrol.xml#xf" target="_top">An Error Controller for Gear's Ode Solvers: xf</a><br/>
	10060	<a href="odeerrcontrol.xml#xf" target="_top">An Error Controller for ODE Solvers: xf</a><br/>
	10061	<a href="rosen34.xml#xf" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: xf</a><br/>
	10062	<a href="runge45.xml#xf" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: xf</a><br/>
	10063	xi <a href="ipopt_solve.xml#xi" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: xi</a><br/>
	10064	<a href="odegearcontrol.xml#xi" target="_top">An Error Controller for Gear's Ode Solvers: xi</a><br/>
	10065	<a href="odeerrcontrol.xml#xi" target="_top">An Error Controller for ODE Solvers: xi</a><br/>
	10066	<a href="rosen34.xml#xi" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: xi</a><br/>
	10067	<a href="runge45.xml#xi" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: xi</a><br/>
	10068	xl <a href="ipopt_solve.xml#xl" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: xl</a><br/>
	10069	xlow <a href="multi_newton_work.cpp.xml#xlow" target="_top">Multi-threading Newton Method Utility Routines: xlow</a><br/>
	10070	<a href="multi_newton.cpp.xml#xlow" target="_top">A Multi-Threaded Newton's Method: xlow</a><br/>
	10071	xout <a href="multi_newton_work.cpp.xml#multi_newton_combine.xout" target="_top">Multi-threading Newton Method Utility Routines: multi_newton_combine.xout</a><br/>
	10072	<a href="multi_newton.cpp.xml#xout" target="_top">A Multi-Threaded Newton's Method: xout</a><br/>
	10073	xq <a href="forward_dir.xml#xq" target="_top">Multiple Directions Forward Mode: xq</a><br/>
	10074	<a href="forward_order.xml#xq" target="_top">Multiple Order Forward Mode: xq</a><br/>
	10075	xu <a href="ipopt_solve.xml#xu" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: xu</a><br/>
	10076	xup <a href="multi_newton_work.cpp.xml#xlow.xup" target="_top">Multi-threading Newton Method Utility Routines: xlow.xup</a><br/>
	10077	<a href="multi_newton.cpp.xml#xup" target="_top">A Multi-Threaded Newton's Method: xup</a><br/>
	10078
	10079	<b><big><a name="Y">Y</a></big></b>
	10080	<br/>
	10081	y <a href="mat_sum_sq.xml#y" target="_top">Sum Elements of a Matrix Times Itself: y</a><br/>
	10082	<a href="opt_val_hes.xml#y" target="_top">Jacobian and Hessian of Optimal Values: y</a><br/>
	10083	<a href="benderquad.xml#y" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: y</a><br/>
	10084	<a href="pow_int.xml#y" target="_top">The Integer Power Function: y</a><br/>
	10085	<a href="checksimplevector.xml#x, y" target="_top">Check Simple Vector Concept: x, y</a><br/>
	10086	<a href="nearequal.xml#y" target="_top">Determine if Two Values Are Nearly Equal: y</a><br/>
	10087	<a href="funcheck.xml#y" target="_top">Check an ADFun Sequence of Operations: y</a><br/>
	10088	<a href="dependent.xml#y" target="_top">Stop Recording and Store Operation Sequence: y</a><br/>
	10089	<a href="funconstruct.xml#y" target="_top">Construct an ADFun Object and Stop Recording: y</a><br/>
	10090	<a href="equalopseq.xml#y" target="_top">Check if Two Value are Identically Equal: y</a><br/>
	10091	<a href="boolfun.xml#y" target="_top">AD Boolean Functions: y</a><br/>
	10092	<a href="nearequalext.xml#y" target="_top">Compare AD and Base Objects for Nearly Equal: y</a><br/>
	10093	<a href="compare.xml#y" target="_top">AD Binary Comparison Operators: y</a><br/>
	10094	<a href="discrete.xml#y" target="_top">Discrete AD Functions: y</a><br/>
	10095	<a href="pow.xml#y" target="_top">The AD Power Function: y</a><br/>
	10096	<a href="atan2.xml#y" target="_top">AD Two Argument Inverse Tangent Function: y</a><br/>
	10097	<a href="sign.xml#y" target="_top">Sign Function: y</a><br/>
	10098	<a href="abs.xml#y" target="_top">AD Absolute Value Function: y</a><br/>
	10099	<a href="std_math_ad.xml#y" target="_top">AD Standard Math Unary Functions: y</a><br/>
	10100	<a href="compute_assign.xml#y" target="_top">AD Computed Assignment Operators: y</a><br/>
	10101	<a href="ad_binary.xml#y" target="_top">AD Binary Arithmetic Operators: y</a><br/>
	10102	<a href="unaryminus.xml#y" target="_top">AD Unary Minus Operator: y</a><br/>
	10103	<a href="unaryplus.xml#y" target="_top">AD Unary Plus Operator: y</a><br/>
	10104	<a href="var2par.xml#y" target="_top">Convert an AD Variable to a Parameter: y</a><br/>
	10105	<a href="ad_assign.xml#y" target="_top">AD Assignment Operator: y</a><br/>
	10106	<a href="ad_ctor.xml#y" target="_top">AD Constructors: y</a><br/>
	10107	<a href="exp_eps.xml#y" target="_top">An Epsilon Accurate Exponential Approximation: y</a><br/>
	10108	<a href="exp_2.xml#y" target="_top">Second Order Exponential Approximation: y</a><br/>
	10109	y<b>(</b>t <a href="reverse_any.xml#Notation.Y(t, u)" target="_top">Any Order Reverse Mode: Notation.Y(t, u)</a><br/>
	10110	y<b>(</b>t<b>)</b> <a href="tan_reverse.xml#Eliminating Y(t)" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory: Eliminating Y(t)</a><br/>
	10111	<a href="forward_dir.xml#Y(t)" target="_top">Multiple Directions Forward Mode: Y(t)</a><br/>
	10112	<a href="forward_order.xml#Y(t)" target="_top">Multiple Order Forward Mode: Y(t)</a><br/>
	10113	y0 <a href="forward_zero.xml#y0" target="_top">Zero Order Forward Mode: Function Values: y0</a><br/>
	10114	y2 <a href="forward_two.xml#y2" target="_top">Second Order Forward Mode: Derivative Values: y2</a><br/>
	10115	year <a href="whats_new.xml#This Year" target="_top">Changes and Additions to CppAD: This Year</a><br/>
	10116	years <a href="whats_new.xml#Previous Years" target="_top">Changes and Additions to CppAD: Previous Years</a><br/>
	10117	your <a href="license.xml" target="_top">Your License for the CppAD Software</a><br/>
	10118	<a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
	10119	yq <a href="forward_dir.xml#yq" target="_top">Multiple Directions Forward Mode: yq</a><br/>
	10120	<a href="forward_order.xml#yq" target="_top">Multiple Order Forward Mode: yq</a><br/>
	10121
2797	10122	<b><big><a name="Z">Z</a></big></b>
2798	10123	<br/>
2799		zero<br/>
	10124	z <a href="mat_sum_sq.xml#z" target="_top">Sum Elements of a Matrix Times Itself: z</a><br/>
	10125	<a href="link_poly.xml#z" target="_top">Speed Testing Second Derivative of a Polynomial: z</a><br/>
	10126	<a href="link_mat_mul.xml#z" target="_top">Speed Testing Derivative of Matrix Multiply: z</a><br/>
	10127	<a href="poly.xml#z" target="_top">Evaluate a Polynomial or its Derivative: z</a><br/>
	10128	<a href="pow_int.xml#z" target="_top">The Integer Power Function: z</a><br/>
	10129	<a href="nan.xml#nan.z" target="_top">Obtain Nan or Determine if a Value is Nan: nan.z</a><br/>
	10130	<a href="pow.xml#z" target="_top">The AD Power Function: z</a><br/>
	10131	<a href="ad_binary.xml#z" target="_top">AD Binary Arithmetic Operators: z</a><br/>
	10132	z<b>(</b>t<b>)</b> <a href="erf_reverse.xml#Order Zero Z(t)" target="_top">Error Function Reverse Mode Theory: Order Zero Z(t)</a><br/>
	10133	<a href="erf_reverse.xml#Positive Orders Z(t)" target="_top">Error Function Reverse Mode Theory: Positive Orders Z(t)</a><br/>
	10134	<a href="tan_reverse.xml#Order Zero Z(t)" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory: Order Zero Z(t)</a><br/>
	10135	<a href="tan_reverse.xml#Positive Orders Z(t)" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory: Positive Orders Z(t)</a><br/>
	10136	z<b>_</b>l <a href="cppad_ipopt_nlp.xml#solution.z_l" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: solution.z_l</a><br/>
	10137	z<b>_</b>u <a href="cppad_ipopt_nlp.xml#solution.z_u" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: solution.z_u</a><br/>
	10138	zero <a href="erf_reverse.xml#Order Zero Z(t)" target="_top">Error Function Reverse Mode Theory: Order Zero Z(t)</a><br/>
	10139	<a href="tan_reverse.xml#Order Zero Z(t)" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory: Order Zero Z(t)</a><br/>
	10140	<a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
	10141	<a href="forward_dir.xml#Zero Order" target="_top">Multiple Directions Forward Mode: Zero Order</a><br/>
	10142	<a href="forward_order.xml#Zero Order" target="_top">Multiple Order Forward Mode: Zero Order</a><br/>
	10143	<a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
	10144	<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
	10145	<a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a><br/>
	10146	<a href="exp_eps_for2.xml#Operation Sequence.Zero" target="_top">exp_eps: Second Order Forward Mode: Operation Sequence.Zero</a><br/>
	10147	<a href="exp_eps_for1.xml#Operation Sequence.Zero Order" target="_top">exp_eps: First Order Forward Sweep: Operation Sequence.Zero Order</a><br/>
	10148	<a href="exp_eps_for0.xml#Operation Sequence.Zero Order" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep: Operation Sequence.Zero Order</a><br/>
	10149	<a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
	10150	<a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a><br/>
	10151	<a href="exp_2_for2.xml#Operation Sequence.Zero" target="_top">exp_2: Second Order Forward Mode: Operation Sequence.Zero</a><br/>
	10152	<a href="exp_2_for1.xml#Operation Sequence.Zero Order" target="_top">exp_2: First Order Forward Mode: Operation Sequence.Zero Order</a><br/>
	10153	<a href="exp_2_for0.xml#Operation Sequence.Zero Order" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Operation Sequence.Zero Order</a><br/>
	10154	<a href="exp_2_for0.xml#Zero Order Expansion" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion</a><br/>
	10155	<a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
2800	10156	order<b> </b>exp<b>_</b>2 <a href="exp_2_for0.cpp.xml" target="_top">exp_2: Verify Zero Order Forward Sweep</a><br/>
2801	10157	order<b> </b>exp<b>_</b>eps <a href="exp_eps_for0.cpp.xml" target="_top">exp_eps: Verify Zero Order Forward Sweep</a><br/>
2802	10158	order<b> </b>expansion <a href="exp_2_for0.xml#Zero Order Expansion" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode: Zero Order Expansion</a><br/>
2803		order<b> </b>Forward <a href="forwardzero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
	10159	order<b> </b>Forward <a href="forward_zero.xml" target="_top">Zero Order Forward Mode: Function Values</a><br/>
2804	10160	order<b> </b>forward <a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
2805	10161	order<b> </b>forward <a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
2806	10162	order<b> </b>forward <a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
2807	10163	order<b> </b>forward<b> </b>print <a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
	10164	zl <a href="ipopt_solve.xml#solution.zl" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: solution.zl</a><br/>
	10165	zu <a href="ipopt_solve.xml#solution.zu" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: solution.zu</a><br/>
2808	10166
2809	10167	</body>
2810	10168	</html>

-5

doc/_install_xml.js less more

24	24	var list_down0 = [
25	25	'download.xml',
26	26	'cmake.xml',
27		'cppad_test.xml',
	27	'cmake_check.xml',
28	28	'pkgconfig.xml',
29	29	'installunix.xml'
30	30	];
31	31	var list_current0 = [
32	32	'install.xml#Instructions',
33		'install.xml#Instructions.Download',
34		'install.xml#Instructions.Cmake',
35		'install.xml#Instructions.Test',
36		'install.xml#Instructions.Install',
	33	'install.xml#Instructions.Step 1: Download',
	34	'install.xml#Instructions.Step 2: Cmake',
	35	'install.xml#Instructions.Step 3: Check',
	36	'install.xml#Instructions.Step 4: Install',
37	37	'install.xml#Contents'
38	38	];
39	39	function choose_across0(item)

-1

doc/_installunix_xml.js less more

25	25	var list_down1 = [
26	26	'download.xml',
27	27	'cmake.xml',
28		'cppad_test.xml',
	28	'cmake_check.xml',
29	29	'pkgconfig.xml',
30	30	'installunix.xml'
31	31	];

-1

doc/_ipopt_prefix_xml.js less more

26	26	var list_down2 = [
27	27	'download.xml',
28	28	'cmake.xml',
29		'cppad_test.xml',
	29	'cmake_check.xml',
30	30	'pkgconfig.xml',
31	31	'installunix.xml'
32	32	];
33	33	var list_down1 = [
34	34	'adolc_prefix.xml',
	35	'colpack_prefix.xml',
35	36	'eigen_prefix.xml',
36	37	'fadbad_prefix.xml',
37	38	'ipopt_prefix.xml',

-2

doc/_link_sparse_jacobian_xml.js less more

48	48	'link_sparse_jacobian.xml#size',
49	49	'link_sparse_jacobian.xml#repeat',
50	50	'link_sparse_jacobian.xml#m',
51		'link_sparse_jacobian.xml#x',
52	51	'link_sparse_jacobian.xml#row',
53	52	'link_sparse_jacobian.xml#col',
	53	'link_sparse_jacobian.xml#x',
54	54	'link_sparse_jacobian.xml#jacobian',
55		'link_sparse_jacobian.xml#jacobian.double'
	55	'link_sparse_jacobian.xml#n_sweep',
	56	'link_sparse_jacobian.xml#n_sweep.double'
56	57	];
57	58	function choose_across0(item)
58	59	{ var index = item.selectedIndex;

-1

doc/_logforward_xml.js less more

36	36	'atanforward.xml',
37	37	'asinforward.xml',
38	38	'acosforward.xml',
39		'tan_forward.xml'
	39	'tan_forward.xml',
	40	'erf_forward.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-1

doc/_logreverse_xml.js less more

36	36	'atanreverse.xml',
37	37	'asinreverse.xml',
38	38	'acosreverse.xml',
39		'tan_reverse.xml'
	39	'tan_reverse.xml',
	40	'erf_reverse.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-8

doc/_number_skip.cpp_xml.js less more

18	18	'sparse.xml'
19	19	];
20	20	var list_down2 = [
21		'forwardzero.xml',
22		'forwardone.xml',
23		'forwardany.xml',
24		'size_taylor.xml',
	21	'forward_zero.xml',
	22	'forward_one.xml',
	23	'forward_two.xml',
	24	'forward_order.xml',
	25	'forward_dir.xml',
	26	'size_order.xml',
25	27	'comparechange.xml',
26		'capacity_taylor.xml',
27		'number_skip.xml',
28		'forward.cpp.xml',
29		'forward_mul.cpp.xml'
	28	'capacity_order.xml',
	29	'number_skip.xml'
30	30	];
31	31	var list_down1 = [
32	32	'number_skip.cpp.xml'

-8

doc/_number_skip_xml.js less more

29	29	'sparse.xml'
30	30	];
31	31	var list_down1 = [
32		'forwardzero.xml',
33		'forwardone.xml',
34		'forwardany.xml',
35		'size_taylor.xml',
	32	'forward_zero.xml',
	33	'forward_one.xml',
	34	'forward_two.xml',
	35	'forward_order.xml',
	36	'forward_dir.xml',
	37	'size_order.xml',
36	38	'comparechange.xml',
37		'capacity_taylor.xml',
38		'number_skip.xml',
39		'forward.cpp.xml',
40		'forward_mul.cpp.xml'
	39	'capacity_order.xml',
	40	'number_skip.xml'
41	41	];
42	42	var list_down0 = [
43	43	'number_skip.cpp.xml'

-1

doc/_pkgconfig_xml.js less more

25	25	var list_down1 = [
26	26	'download.xml',
27	27	'cmake.xml',
28		'cppad_test.xml',
	28	'cmake_check.xml',
29	29	'pkgconfig.xml',
30	30	'installunix.xml'
31	31	];

+22

-13

doc/_reference.xml less more

3	3	>
4	4	<head>
5	5	<title>Alphabetic Listing of Cross Reference Tags</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Alphabetic Listing of Cross Reference Tags"/>
7	8	<style type='text/css'>
8	9	body { color : black }

140	141	<a href="atomic_for_sparse_jac.xml" target="_top">atomic_for_sparse_jac</a><br/> </td><td> Atomic Forward Jacobian Sparsity Patterns </td></tr><tr valign="top"><td>
141	142	<a href="atomic_forward.xml" target="_top">atomic_forward</a><br/> </td><td> Atomic Forward Mode </td></tr><tr valign="top"><td>
142	143	<a href="atomic_get_started.cpp.xml" target="_top">atomic_get_started.cpp</a><br/> </td><td> Getting Started with Atomic Operations: Example and Test </td></tr><tr valign="top"><td>
	144	<a href="atomic_hes_sparse.cpp.xml" target="_top">atomic_hes_sparse.cpp</a><br/> </td><td> Atomic Operation Hessian Sparsity: Example and Test </td></tr><tr valign="top"><td>
143	145	<a href="atomic_mat_mul.cpp.xml" target="_top">atomic_mat_mul.cpp</a><br/> </td><td> User Atomic Matrix Multiply: Example and Test </td></tr><tr valign="top"><td>
144	146	<a href="atomic_matrix_mul.hpp.xml" target="_top">atomic_matrix_mul.hpp</a><br/> </td><td> Matrix Multiply as an Atomic Operation </td></tr><tr valign="top"><td>
145	147	<a href="atomic_norm_sq.cpp.xml" target="_top">atomic_norm_sq.cpp</a><br/> </td><td> Euclidean Norm Squared: Example and Test </td></tr><tr valign="top"><td>

173	175	<a href="bugs.xml" target="_top">Bugs</a><br/> </td><td> Know Bugs and Problems Using CppAD </td></tr><tr valign="top"><td>
174	176
175	177	<b><big><a name="C">C</a></big></b> </td><td> </td></tr><tr valign="top"><td>
176		<a href="capacity_taylor.xml" target="_top">capacity_taylor</a><br/> </td><td> Controlling Taylor Coefficients Memory Allocation </td></tr><tr valign="top"><td>
177		<a href="capacity_taylor.cpp.xml" target="_top">capacity_taylor.cpp</a><br/> </td><td> Controlling Taylor Coefficient Memory Allocation: Example and Test </td></tr><tr valign="top"><td>
	178	<a href="capacity_order.xml" target="_top">capacity_order</a><br/> </td><td> Controlling Taylor Coefficients Memory Allocation </td></tr><tr valign="top"><td>
	179	<a href="capacity_order.cpp.xml" target="_top">capacity_order.cpp</a><br/> </td><td> Controlling Taylor Coefficient Memory Allocation: Example and Test </td></tr><tr valign="top"><td>
178	180	<a href="change_const.cpp.xml" target="_top">change_const.cpp</a><br/> </td><td> Computing a Jacobian With Constants that Change </td></tr><tr valign="top"><td>
179	181	<a href="check_for_nan.xml" target="_top">check_for_nan</a><br/> </td><td> Check an ADFun Object For Nan </td></tr><tr valign="top"><td>
180	182	<a href="check_for_nan.cpp.xml" target="_top">check_for_nan.cpp</a><br/> </td><td> ADFun Checking For Nan: Example and Test </td></tr><tr valign="top"><td>

185	187	<a href="checkpoint.cpp.xml" target="_top">checkpoint.cpp</a><br/> </td><td> Simple Checkpointing: Example and Test </td></tr><tr valign="top"><td>
186	188	<a href="checksimplevector.xml" target="_top">CheckSimpleVector</a><br/> </td><td> Check Simple Vector Concept </td></tr><tr valign="top"><td>
187	189	<a href="cmake.xml" target="_top">cmake</a><br/> </td><td> Using CMake to Configure CppAD </td></tr><tr valign="top"><td>
	190	<a href="cmake_check.xml" target="_top">cmake_check</a><br/> </td><td> Checking the CppAD Examples and Tests </td></tr><tr valign="top"><td>
	191	<a href="colpack.cpp.xml" target="_top">colpack.cpp</a><br/> </td><td> Using ColPack: Example and Test </td></tr><tr valign="top"><td>
	192	<a href="colpack_prefix.xml" target="_top">colpack_prefix</a><br/> </td><td> Including the ColPack Sparsity Calculations </td></tr><tr valign="top"><td>
188	193	<a href="compare.xml" target="_top">Compare</a><br/> </td><td> AD Binary Comparison Operators </td></tr><tr valign="top"><td>
189	194	<a href="compare.cpp.xml" target="_top">compare.cpp</a><br/> </td><td> AD Binary Comparison Operators: Example and Test </td></tr><tr valign="top"><td>
190	195	<a href="compare_c.xml" target="_top">compare_c</a><br/> </td><td> Compare Speed of C and C++ </td></tr><tr valign="top"><td>

199	204	<a href="correct_det_by_minor_c.xml" target="_top">correct_det_by_minor_c</a><br/> </td><td> Correctness Test of det_by_minor Routine </td></tr><tr valign="top"><td>
200	205	<a href="cos.cpp.xml" target="_top">cos.cpp</a><br/> </td><td> The AD cos Function: Example and Test </td></tr><tr valign="top"><td>
201	206	<a href="cosh.cpp.xml" target="_top">cosh.cpp</a><br/> </td><td> The AD cosh Function: Example and Test </td></tr><tr valign="top"><td>
202		<a href="cppad.xml" target="_top">CppAD</a><br/> </td><td> cppad-20140000.3: A Package for Differentiation of C++ Algorithms </td></tr><tr valign="top"><td>
	207	<a href="cppad.xml" target="_top">CppAD</a><br/> </td><td> cppad-20150000.0: A Package for Differentiation of C++ Algorithms </td></tr><tr valign="top"><td>
203	208	<a href="cppad_assert.xml" target="_top">cppad_assert</a><br/> </td><td> CppAD Assertions During Execution </td></tr><tr valign="top"><td>
204	209	<a href="cppad_det_lu.cpp.xml" target="_top">cppad_det_lu.cpp</a><br/> </td><td> CppAD Speed: Gradient of Determinant Using Lu Factorization </td></tr><tr valign="top"><td>
205	210	<a href="cppad_det_minor.cpp.xml" target="_top">cppad_det_minor.cpp</a><br/> </td><td> CppAD Speed: Gradient of Determinant by Minor Expansion </td></tr><tr valign="top"><td>

208	213	<a href="cppad_mat_mul.cpp.xml" target="_top">cppad_mat_mul.cpp</a><br/> </td><td> CppAD Speed: Matrix Multiplication </td></tr><tr valign="top"><td>
209	214	<a href="cppad_ode.cpp.xml" target="_top">cppad_ode.cpp</a><br/> </td><td> CppAD Speed: Gradient of Ode Solution </td></tr><tr valign="top"><td>
210	215	<a href="cppad_poly.cpp.xml" target="_top">cppad_poly.cpp</a><br/> </td><td> CppAD Speed: Second Derivative of a Polynomial </td></tr><tr valign="top"><td>
211		<a href="cppad_print_optimize.xml" target="_top">cppad_print_optimize</a><br/> </td><td> Speed Test Utility: Optimize Operation Sequences and Print Results </td></tr><tr valign="top"><td>
212	216	<a href="cppad_sparse_hessian.cpp.xml" target="_top">cppad_sparse_hessian.cpp</a><br/> </td><td> CppAD Speed: Sparse Hessian </td></tr><tr valign="top"><td>
213	217	<a href="cppad_sparse_jacobian.cpp.xml" target="_top">cppad_sparse_jacobian.cpp</a><br/> </td><td> CppAD Speed: Sparse Jacobian </td></tr><tr valign="top"><td>
214		<a href="cppad_test.xml" target="_top">cppad_test</a><br/> </td><td> Running the CppAD Examples and Tests </td></tr><tr valign="top"><td>
215	218	<a href="cppad_testvector.xml" target="_top">cppad_testvector</a><br/> </td><td> Choosing the CppAD Test Vector Template Class </td></tr><tr valign="top"><td>
216	219	<a href="cppad_vector.xml" target="_top">CppAD_vector</a><br/> </td><td> The CppAD::vector Template Class </td></tr><tr valign="top"><td>
217	220	<a href="cppad_vector.cpp.xml" target="_top">cppad_vector.cpp</a><br/> </td><td> CppAD::vector Template Class: Example and Test </td></tr><tr valign="top"><td>

260	263	<a href="equalopseq.xml" target="_top">EqualOpSeq</a><br/> </td><td> Check if Two Value are Identically Equal </td></tr><tr valign="top"><td>
261	264	<a href="erf.xml" target="_top">erf</a><br/> </td><td> The AD Error Function </td></tr><tr valign="top"><td>
262	265	<a href="erf.cpp.xml" target="_top">erf.cpp</a><br/> </td><td> The AD erf Function: Example and Test </td></tr><tr valign="top"><td>
	266	<a href="erf_forward.xml" target="_top">erf_forward</a><br/> </td><td> Error Function Forward Taylor Polynomial Theory </td></tr><tr valign="top"><td>
	267	<a href="erf_reverse.xml" target="_top">erf_reverse</a><br/> </td><td> Error Function Reverse Mode Theory </td></tr><tr valign="top"><td>
263	268	<a href="error_handler.cpp.xml" target="_top">error_handler.cpp</a><br/> </td><td> Replacing The CppAD Error Handler: Example and Test </td></tr><tr valign="top"><td>
264	269	<a href="errorhandler.xml" target="_top">ErrorHandler</a><br/> </td><td> Replacing the CppAD Error Handler </td></tr><tr valign="top"><td>
265	270	<a href="example.xml" target="_top">Example</a><br/> </td><td> Examples </td></tr><tr valign="top"><td>

316	321	<a href="fortwo.xml" target="_top">ForTwo</a><br/> </td><td> Forward Mode Second Partial Derivative Driver </td></tr><tr valign="top"><td>
317	322	<a href="forward.xml" target="_top">Forward</a><br/> </td><td> Forward Mode </td></tr><tr valign="top"><td>
318	323	<a href="forward.cpp.xml" target="_top">forward.cpp</a><br/> </td><td> Forward Mode: Example and Test </td></tr><tr valign="top"><td>
319		<a href="forward_mul.cpp.xml" target="_top">forward_mul.cpp</a><br/> </td><td> Forward Mode: Example and Test of Multiple Orders </td></tr><tr valign="top"><td>
320		<a href="forwardany.xml" target="_top">ForwardAny</a><br/> </td><td> Any Order Forward Mode </td></tr><tr valign="top"><td>
321		<a href="forwardone.xml" target="_top">ForwardOne</a><br/> </td><td> First Order Forward Mode: Derivative Values </td></tr><tr valign="top"><td>
	324	<a href="forward_dir.xml" target="_top">forward_dir</a><br/> </td><td> Multiple Directions Forward Mode </td></tr><tr valign="top"><td>
	325	<a href="forward_dir.cpp.xml" target="_top">forward_dir.cpp</a><br/> </td><td> Forward Mode: Example and Test of Multiple Directions </td></tr><tr valign="top"><td>
	326	<a href="forward_one.xml" target="_top">forward_one</a><br/> </td><td> First Order Forward Mode: Derivative Values </td></tr><tr valign="top"><td>
	327	<a href="forward_order.xml" target="_top">forward_order</a><br/> </td><td> Multiple Order Forward Mode </td></tr><tr valign="top"><td>
	328	<a href="forward_order.cpp.xml" target="_top">forward_order.cpp</a><br/> </td><td> Forward Mode: Example and Test of Multiple Orders </td></tr><tr valign="top"><td>
	329	<a href="forward_two.xml" target="_top">forward_two</a><br/> </td><td> Second Order Forward Mode: Derivative Values </td></tr><tr valign="top"><td>
	330	<a href="forward_zero.xml" target="_top">forward_zero</a><br/> </td><td> Zero Order Forward Mode: Function Values </td></tr><tr valign="top"><td>
322	331	<a href="forwardtheory.xml" target="_top">ForwardTheory</a><br/> </td><td> The Theory of Forward Mode </td></tr><tr valign="top"><td>
323		<a href="forwardzero.xml" target="_top">ForwardZero</a><br/> </td><td> Zero Order Forward Mode: Function Values </td></tr><tr valign="top"><td>
324	332	<a href="fun_assign.cpp.xml" target="_top">fun_assign.cpp</a><br/> </td><td> ADFun Assignment: Example and Test </td></tr><tr valign="top"><td>
325	333	<a href="fun_check.cpp.xml" target="_top">fun_check.cpp</a><br/> </td><td> ADFun Check and Re-Tape: Example and Test </td></tr><tr valign="top"><td>
326	334	<a href="funcheck.xml" target="_top">FunCheck</a><br/> </td><td> Check an ADFun Sequence of Operations </td></tr><tr valign="top"><td>

357	365	<a href="index_sort.xml" target="_top">index_sort</a><br/> </td><td> Returns Indices that Sort a Vector </td></tr><tr valign="top"><td>
358	366	<a href="index_sort.cpp.xml" target="_top">index_sort.cpp</a><br/> </td><td> Index Sort: Example and Test </td></tr><tr valign="top"><td>
359	367	<a href="install.xml" target="_top">Install</a><br/> </td><td> CppAD Download, Test, and Install Instructions </td></tr><tr valign="top"><td>
360		<a href="installunix.xml" target="_top">InstallUnix</a><br/> </td><td> Unix Test and Installation </td></tr><tr valign="top"><td>
	368	<a href="installunix.xml" target="_top">InstallUnix</a><br/> </td><td> Deprecated Unix Test and Installation </td></tr><tr valign="top"><td>
361	369	<a href="integer.xml" target="_top">Integer</a><br/> </td><td> Convert From AD to Integer </td></tr><tr valign="top"><td>
362	370	<a href="integer.cpp.xml" target="_top">integer.cpp</a><br/> </td><td> Convert From AD to Integer: Example and Test </td></tr><tr valign="top"><td>
363	371	<a href="interface2c.cpp.xml" target="_top">interface2c.cpp</a><br/> </td><td> Interfacing to C: Example and Test </td></tr><tr valign="top"><td>

561	569	<a href="sincosforward.xml" target="_top">SinCosForward</a><br/> </td><td> Trigonometric and Hyperbolic Sine and Cosine Forward Theory </td></tr><tr valign="top"><td>
562	570	<a href="sincosreverse.xml" target="_top">SinCosReverse</a><br/> </td><td> Trigonometric and Hyperbolic Sine and Cosine Reverse Theory </td></tr><tr valign="top"><td>
563	571	<a href="sinh.cpp.xml" target="_top">sinh.cpp</a><br/> </td><td> The AD sinh Function: Example and Test </td></tr><tr valign="top"><td>
564		<a href="size_taylor.xml" target="_top">size_taylor</a><br/> </td><td> Number Taylor Coefficients, Per Variable, Currently Stored </td></tr><tr valign="top"><td>
	572	<a href="size_order.xml" target="_top">size_order</a><br/> </td><td> Number Taylor Coefficient Orders Currently Stored </td></tr><tr valign="top"><td>
565	573	<a href="sparse.xml" target="_top">Sparse</a><br/> </td><td> Calculating Sparsity Patterns </td></tr><tr valign="top"><td>
566	574	<a href="sparse_hes_fun.xml" target="_top">sparse_hes_fun</a><br/> </td><td> Evaluate a Function That Has a Sparse Hessian </td></tr><tr valign="top"><td>
567	575	<a href="sparse_hes_fun.cpp.xml" target="_top">sparse_hes_fun.cpp</a><br/> </td><td> sparse_hes_fun: Example and test </td></tr><tr valign="top"><td>

573	581	<a href="sparse_jac_fun.hpp.xml" target="_top">sparse_jac_fun.hpp</a><br/> </td><td> Source: sparse_jac_fun </td></tr><tr valign="top"><td>
574	582	<a href="sparse_jacobian.xml" target="_top">sparse_jacobian</a><br/> </td><td> Sparse Jacobian: Easy Driver </td></tr><tr valign="top"><td>
575	583	<a href="sparse_jacobian.cpp.xml" target="_top">sparse_jacobian.cpp</a><br/> </td><td> Sparse Jacobian: Example and Test </td></tr><tr valign="top"><td>
576		<a href="speed.xml" target="_top">speed</a><br/> </td><td> AD Speed Test Routines </td></tr><tr valign="top"><td>
	584	<a href="speed.xml" target="_top">speed</a><br/> </td><td> Speed Test an Operator Overloading AD Package </td></tr><tr valign="top"><td>
577	585	<a href="speed_adolc.xml" target="_top">speed_adolc</a><br/> </td><td> Speed Test of Derivatives Using Adolc </td></tr><tr valign="top"><td>
578	586	<a href="speed_cppad.xml" target="_top">speed_cppad</a><br/> </td><td> Speed Test Derivatives Using CppAD </td></tr><tr valign="top"><td>
579	587	<a href="speed_double.xml" target="_top">speed_double</a><br/> </td><td> Speed Test of Functions in Double </td></tr><tr valign="top"><td>
580	588	<a href="speed_example.cpp.xml" target="_top">speed_example.cpp</a><br/> </td><td> Run the Speed Examples </td></tr><tr valign="top"><td>
581	589	<a href="speed_fadbad.xml" target="_top">speed_fadbad</a><br/> </td><td> Speed Test Derivatives Using Fadbad </td></tr><tr valign="top"><td>
582		<a href="speed_main.xml" target="_top">speed_main</a><br/> </td><td> Speed Testing Main Program </td></tr><tr valign="top"><td>
	590	<a href="speed_main.xml" target="_top">speed_main</a><br/> </td><td> Running the Speed Test Program </td></tr><tr valign="top"><td>
583	591	<a href="speed_program.cpp.xml" target="_top">speed_program.cpp</a><br/> </td><td> Example Use of SpeedTest </td></tr><tr valign="top"><td>
584	592	<a href="speed_sacado.xml" target="_top">speed_sacado</a><br/> </td><td> Speed Test Derivatives Using Sacado </td></tr><tr valign="top"><td>
585	593	<a href="speed_test.xml" target="_top">speed_test</a><br/> </td><td> Run One Speed Test and Return Results </td></tr><tr valign="top"><td>

661	669	<a href="whats_new_11.xml" target="_top">whats_new_11</a><br/> </td><td> Changes and Additions to CppAD During 2011 </td></tr><tr valign="top"><td>
662	670	<a href="whats_new_12.xml" target="_top">whats_new_12</a><br/> </td><td> CppAD Changes and Additions During 2012 </td></tr><tr valign="top"><td>
663	671	<a href="whats_new_13.xml" target="_top">whats_new_13</a><br/> </td><td> CppAD Changes and Additions During 2013 </td></tr><tr valign="top"><td>
	672	<a href="whats_new_14.xml" target="_top">whats_new_14</a><br/> </td><td> CppAD Changes and Additions During 2014 </td></tr><tr valign="top"><td>
664	673	<a href="wishlist.xml" target="_top">WishList</a><br/> </td><td> The CppAD Wish List </td></tr><tr valign="top"><td>
665	674	</td></tr></table>
666	675

-2

doc/_reverse_any_xml.js less more

41	41	'reverse_any.xml#Syntax',
42	42	'reverse_any.xml#Purpose',
43	43	'reverse_any.xml#Notation',
44		'reverse_any.xml#Notation.x^(k)',
	44	'reverse_any.xml#Notation.u^(k)',
45	45	'reverse_any.xml#Notation.X(t, u)',
46	46	'reverse_any.xml#Notation.Y(t, u)',
47	47	'reverse_any.xml#Notation.w^(k)',
48	48	'reverse_any.xml#Notation.W(u)',
49	49	'reverse_any.xml#f',
50		'reverse_any.xml#p',
	50	'reverse_any.xml#q',
51	51	'reverse_any.xml#w',
52	52	'reverse_any.xml#dw',
53	53	'reverse_any.xml#First Order',

-0

doc/_reverse_xml.js less more

46	46	'reverse_any.xml'
47	47	];
48	48	var list_current0 = [
	49	'reverse.xml#Multiple Directions',
49	50	'reverse.xml#Contents'
50	51	];
51	52	function choose_across0(item)

-1

doc/_reversetheory_xml.js less more

48	48	'atanreverse.xml',
49	49	'asinreverse.xml',
50	50	'acosreverse.xml',
51		'tan_reverse.xml'
	51	'tan_reverse.xml',
	52	'erf_reverse.xml'
52	53	];
53	54	var list_current0 = [
54	55	'reversetheory.xml#Taylor Notation',

-1

doc/_sacado_prefix_xml.js less more

26	26	var list_down2 = [
27	27	'download.xml',
28	28	'cmake.xml',
29		'cppad_test.xml',
	29	'cmake_check.xml',
30	30	'pkgconfig.xml',
31	31	'installunix.xml'
32	32	];
33	33	var list_down1 = [
34	34	'adolc_prefix.xml',
	35	'colpack_prefix.xml',
35	36	'eigen_prefix.xml',
36	37	'fadbad_prefix.xml',
37	38	'ipopt_prefix.xml',

+583

-564

doc/_search.xml.js less more

2	2	// -------------------------------------------------------
3	3	Keyword =
4	4	[
5		"CppAD cppad-20140000.3: A Package for Differentiation of C++ Algorithms algorithmic automatic derivative version introduction include cppad.hpp symbol preprocessor namespace",
6		"Install CppAD Download, Test, and Install Instructions ",
7		"download Download The CppAD Source Code ",
8		"cmake Using CMake to Configure CppAD command makefile generator install prefix include directories data directory library postfix package c++ compile flags documentation maximum number threads sparsity internal structure vector of sets memory usage tape implicit explicit",
9		"adolc_prefix Including the ADOL-C Examples and Tests speed unix cygwin get",
10		"get_adolc.sh Download and Install Adolc in Build Directory ",
11		"get_colpack.sh Download and Install ColPack in Build Directory ",
12		"eigen_prefix Including the Eigen Examples and Tests vector get",
13		"get_eigen.sh Download and Install Eigen in Build Directory ",
14		"fadbad_prefix Including the FADBAD Speed Tests get",
15		"get_fadbad.sh Download and Install Fadbad in Build Directory ",
16		"ipopt_prefix Including the cppad_ipopt Library and Tests example get",
17		"get_ipopt.sh Download and Install Ipopt in Build Directory ",
18		"sacado_prefix Including the Sacado Speed Tests get",
19		"get_sacado.sh Download and Install Sacado in Build Directory ",
20		"cppad_testvector Choosing the CppAD Test Vector Template Class boost eigen",
21		"cppad_test Running the CppAD Examples and Tests ",
22		"pkgconfig CppAD pkg-config Files pc",
23		"InstallUnix Unix Test and Installation cppad free configure speed profile prefix directory documentation std vector boost eigen sparse internal sets implicit explicit compile flags openmp postfix adolc fadbad ipopt sacado memory usage tape",
24		"Introduction An Introduction by Example to Algorithmic Differentiation ad automatic",
25		"get_started.cpp Getting Started Using CppAD to Compute Derivatives simple example",
26		"exp_2 Second Order Exponential Approximation example algorithm",
27		"exp_2.hpp exp_2: Implementation ",
28		"exp_2.cpp exp_2: Test ",
29		"exp_2_for0 exp_2: Operation Sequence and Zero Order Forward Mode example expansion",
30		"exp_2_for1 exp_2: First Order Forward Mode example expansion",
31		"exp_2_rev1 exp_2: First Order Reverse Mode example",
32		"exp_2_for2 exp_2: Second Order Forward Mode example expansion",
33		"exp_2_rev2 exp_2: Second Order Reverse Mode example",
34		"exp_2_for0.cpp exp_2: Verify Zero Order Forward Sweep ",
35		"exp_2_for1.cpp exp_2: Verify First Order Forward Sweep ",
36		"exp_2_rev1.cpp exp_2: Verify First Order Reverse Sweep mode",
37		"exp_2_for2.cpp exp_2: Verify Second Order Forward Sweep ",
38		"exp_2_rev2.cpp exp_2: Verify Second Order Reverse Sweep mode",
39		"exp_2_cppad exp_2: CppAD Forward and Reverse Sweeps ",
40		"exp_eps An Epsilon Accurate Exponential Approximation example algorithm",
41		"exp_eps.hpp exp_eps: Implementation ",
42		"exp_eps.cpp exp_eps: Test of exp_eps ",
43		"exp_eps_for0 exp_eps: Operation Sequence and Zero Order Forward Sweep example",
44		"exp_eps_for1 exp_eps: First Order Forward Sweep expansion",
45		"exp_eps_rev1 exp_eps: First Order Reverse Sweep mode example",
46		"exp_eps_for2 exp_eps: Second Order Forward Mode example expansion",
47		"exp_eps_rev2 exp_eps: Second Order Reverse Sweep mode example",
48		"exp_eps_for0.cpp exp_eps: Verify Zero Order Forward Sweep ",
49		"exp_eps_for1.cpp exp_eps: Verify First Order Forward Sweep exp_2",
50		"exp_eps_rev1.cpp exp_eps: Verify First Order Reverse Sweep ",
51		"exp_eps_for2.cpp exp_eps: Verify Second Order Forward Sweep first exp_2",
52		"exp_eps_rev2.cpp exp_eps: Verify Second Order Reverse Sweep ",
53		"exp_eps_cppad exp_eps: CppAD Forward and Reverse Sweeps ",
54		"exp_apx_main.cpp Correctness Tests For Exponential Approximation in Introduction run",
55		"AD AD Objects base require",
56		"ad_ctor AD Constructors convert base vecad deprecated",
57		"ad_ctor.cpp AD Constructors: Example and Test object",
58		"ad_assign AD Assignment Operator base vecad",
59		"ad_assign.cpp AD Assignment: Example and Test object",
60		"Convert Conversion and I/O of AD Objects from",
61		"Value Convert From an AD Type to its Base Type ",
62		"value.cpp Convert From AD to its Base Type: Example and Test record",
63		"Integer Convert From AD to Integer ",
64		"integer.cpp Convert From AD to Integer: Example and Test ",
65		"ad_input AD Output Stream Operator >> write",
66		"ad_output AD Output Stream Operator << write",
67		"ad_input.cpp AD Output Operator: Example and Test <<",
68		"ad_output.cpp AD Output Operator: Example and Test <<",
69		"PrintFor Printing AD Values During Forward Mode text output debug",
70		"print_for_cout.cpp Printing During Forward Mode: Example and Test ",
71		"print_for_string.cpp Print During Zero Order Forward Mode: Example and Test ",
72		"Var2Par Convert an AD Variable to a Parameter from value_ obtain during taping",
73		"var2par.cpp Convert an AD Variable to a Parameter: Example and Test value during taping",
74		"ADValued AD Valued Operations and Functions ",
75		"Arithmetic AD Arithmetic Operators and Computed Assignments ",
76		"UnaryPlus AD Unary Plus Operator +",
77		"unary_plus.cpp AD Unary Plus Operator: Example and Test ",
78		"UnaryMinus AD Unary Minus Operator -",
79		"unary_minus.cpp AD Unary Minus Operator: Example and Test ",
80		"ad_binary AD Binary Arithmetic Operators + add plus - subtract minus * multiply times / divide",
81		"add.cpp AD Binary Addition: Example and Test + plus",
82		"sub.cpp AD Binary Subtraction: Example and Test - minus",
83		"mul.cpp AD Binary Multiplication: Example and Test * multiply times",
84		"div.cpp AD Binary Division: Example and Test / divide quotient",
85		"compute_assign AD Computed Assignment Operators + add plus - subtract minus * multiply times / divide multiple",
86		"AddEq.cpp AD Computed Assignment Addition: Example and Test += plus",
87		"sub_eq.cpp AD Computed Assignment Subtraction: Example and Test -= plus add",
88		"mul_eq.cpp AD Computed Assignment Multiplication: Example and Test *= multiply plus add",
89		"div_eq.cpp AD Computed Assignment Division: Example and Test /= divide plus add",
90		"std_math_ad AD Standard Math Unary Functions acos asin atan cosh exp fabs log log10 sinh sqrt tanh",
91		"Acos.cpp The AD acos Function: Example and Test ",
92		"Asin.cpp The AD asin Function: Example and Test ",
93		"atan.cpp The AD atan Function: Example and Test ",
94		"cos.cpp The AD cos Function: Example and Test ",
95		"cosh.cpp The AD cosh Function: Example and Test ",
96		"exp.cpp The AD exp Function: Example and Test ",
97		"log.cpp The AD log Function: Example and Test ",
98		"log10.cpp The AD log10 Function: Example and Test ",
99		"sin.cpp The AD sin Function: Example and Test ",
100		"sinh.cpp The AD sinh Function: Example and Test ",
101		"sqrt.cpp The AD sqrt Function: Example and Test ",
102		"tan.cpp The AD tan Function: Example and Test ",
103		"tanh.cpp The AD tanh Function: Example and Test ",
104		"MathOther Other AD Math Functions ",
105		"abs AD Absolute Value Function fabs",
106		"abs.cpp AD Absolute Value Function: Example and Test fabs",
107		"sign Sign Function ad",
108		"sign.cpp Sign Function: Example and Test ",
109		"atan2 AD Two Argument Inverse Tangent Function ",
110		"atan2.cpp The AD atan2 Function: Example and Test ",
111		"erf The AD Error Function ",
112		"erf.cpp The AD erf Function: Example and Test ",
113		"pow The AD Power Function exponent",
114		"pow.cpp The AD Power Function: Example and Test ",
115		"limits Numeric Limits For an AD and Base Types epsilon max min",
116		"limits.cpp Numeric Limits: Example and Test ",
117		"CondExp AD Conditional Expressions assign",
118		"cond_exp.cpp Conditional Expressions: Example and Test condexp",
119		"Discrete Discrete AD Functions cppad_discrete_function parallel cppadcreatediscrete deprecated",
120		"tape_index.cpp Taping Array Index Operation: Example and Test ",
121		"interp_onetape.cpp Interpolation With Out Retaping: Example and Test interpolate retape",
122		"interp_retape.cpp Interpolation With Retaping: Example and Test interpolate",
123		"atomic Atomic AD Functions operation",
124		"checkpoint Checkpointing Functions ",
125		"checkpoint.cpp Simple Checkpointing: Example and Test ",
126		"atomic_base User Defined Atomic AD Functions operation",
127		"atomic_ctor Atomic Function Constructor ",
128		"atomic_option Set Atomic Function Options atomic_sparsity bool_sparsity_enum set_sparsity_enum",
129		"atomic_afun Using AD Version of Atomic Function use",
130		"atomic_forward Atomic Forward Mode callback virtual",
131		"atomic_reverse Atomic Reverse Mode callback virtual",
132		"atomic_for_sparse_jac Atomic Forward Jacobian Sparsity Patterns callback virtual",
133		"atomic_rev_sparse_jac Atomic Reverse Jacobian Sparsity Patterns callback virtual",
134		"atomic_rev_sparse_hes Atomic Reverse Hessian Sparsity Patterns callback virtual",
135		"atomic_base_clear Free Static Variables ",
136		"atomic_get_started.cpp Getting Started with Atomic Operations: Example and Test ",
137		"atomic_norm_sq.cpp Euclidean Norm Squared: Example and Test operation",
138		"atomic_reciprocal.cpp Reciprocal as an Atomic Operation: Example and Test simple",
139		"atomic_tangent.cpp Tan and Tanh as User Atomic Operations: Example and Test ",
140		"atomic_mat_mul.cpp User Atomic Matrix Multiply: Example and Test ",
141		"atomic_matrix_mul.hpp Matrix Multiply as an Atomic Operation ",
142		"BoolValued Bool Valued Operations and Functions with AD Arguments ",
143		"Compare AD Binary Comparison Operators < <= > >= == !=",
144		"compare.cpp AD Binary Comparison Operators: Example and Test < <= > >= == !=",
145		"NearEqualExt Compare AD and Base Objects for Nearly Equal with",
146		"near_equal_ext.cpp Compare AD with Base Objects: Example and Test nearequalext",
147		"BoolFun AD Boolean Functions unary binary cppad_bool_unary cppad_bool_binary",
148		"bool_fun.cpp AD Boolean Functions: Example and Test ",
149		"ParVar Is an AD Object a Parameter or Variable ",
150		"par_var.cpp AD Parameter and Variable Functions: Example and Test ",
151		"EqualOpSeq Check if Two Value are Identically Equal operation sequence",
152		"equal_op_seq.cpp EqualOpSeq: Example and Test ",
153		"VecAD AD Vectors that Record Index Operations tape vecad<base>::reference",
154		"vec_ad.cpp AD Vectors that Record Index Operations: Example and Test vecad",
155		"base_require AD<Base> Requirements for Base Type output operator integer",
156		"base_member Required Base Class Member Functions ",
157		"base_cond_exp Base Type Requirements for Conditional Expressions condexp cppad_cond_exp_rel",
158		"base_identical Base Type Requirements for Identically Equal Comparisons equalopseq",
159		"base_ordered Base Type Requirements for Ordered Comparisons ",
160		"base_std_math Base Type Requirements for Standard Math Functions unary cppad_standard_math_unary sign pow isnan numeric limits numeric_limits",
161		"base_example Example AD Base Types That are not AD<OtherBase> ",
162		"base_alloc.hpp Example AD<Base> Where Base Constructor Allocates Memory ",
163		"base_require.cpp Using a User Defined AD Base Type: Example and Test ",
164		"base_adolc.hpp Enable use of AD<Base> where Base is Adolc's adouble Type ",
165		"mul_level_adolc.cpp Using Adolc with Multiple Levels of Taping: Example and Test ",
166		"base_float.hpp Enable use of AD<Base> where Base is float ",
167		"base_double.hpp Enable use of AD<Base> where Base is double ",
168		"base_complex.hpp Enable use of AD<Base> where Base is std::complex<double> ",
169		"complex_poly.cpp Complex Polynomial: Example and Test ",
170		"not_complex_ad.cpp Not Complex Differentiable: Example and Test polynomial imag() real()",
171		"ADFun ADFun Objects ",
172		"Independent Declare Independent Variables and Start Recording parallel",
173		"independent.cpp Independent and ADFun Constructor: Example and Test ",
174		"FunConstruct Construct an ADFun Object and Stop Recording tape default constructor sequence copy assignment operator parallel",
175		"fun_assign.cpp ADFun Assignment: Example and Test ",
176		"Dependent Stop Recording and Store Operation Sequence adfun tape parallel",
177		"abort_recording Abort Recording of an Operation Sequence tape",
178		"abort_recording.cpp Abort Current Recording: Example and Test ",
179		"seq_property ADFun Sequence Properties domain range parameter size_var size_par size_vecad",
180		"seq_property.cpp ADFun Sequence Properties: Example and Test domain range parameter size_var size_par size_op size_op_arg size_vecad",
181		"FunEval Evaluate ADFun Functions, Derivatives, and Sparsity Patterns ",
182		"Forward Forward Mode ",
183		"ForwardZero Zero Order Forward Mode: Function Values ",
184		"ForwardOne First Order Forward Mode: Derivative Values ",
185		"ForwardAny Any Order Forward Mode derivative calculate",
186		"size_taylor Number Taylor Coefficients, Per Variable, Currently Stored ",
187		"CompareChange Comparison Changes During Zero Order Forward Mode adfun ndebug",
188		"compare_change.cpp CompareChange and Re-Tape: Example and Test ",
189		"capacity_taylor Controlling Taylor Coefficients Memory Allocation forward",
190		"capacity_taylor.cpp Controlling Taylor Coefficient Memory Allocation: Example and Test ",
191		"number_skip Number of Variables that Can be Skipped ",
192		"number_skip.cpp Number of Variables That Can be Skipped: Example and Test optimize conditional expression",
193		"forward.cpp Forward Mode: Example and Test ",
194		"forward_mul.cpp Forward Mode: Example and Test of Multiple Orders ",
195		"Reverse Reverse Mode ",
196		"reverse_one First Order Reverse Mode derivative",
197		"reverse_two Second Order Reverse Mode derivative",
198		"reverse_any Any Order Reverse Mode derivative",
199		"reverse_one.cpp First Order Reverse Mode: Example and Test ",
200		"reverse_two.cpp Second Order Reverse ModeExample and Test ",
201		"hes_times_dir.cpp Hessian Times Direction: Example and Test ",
202		"reverse_three.cpp Third Order Reverse Mode: Example and Test ",
203		"reverse_any.cpp Reverse Mode General Case: Example and Test ",
204		"Sparse Calculating Sparsity Patterns ",
205		"ForSparseJac Jacobian Sparsity Pattern: Forward Mode ",
206		"for_sparse_jac.cpp Forward Mode Jacobian Sparsity: Example and Test forsparsejac",
207		"RevSparseJac Jacobian Sparsity Pattern: Reverse Mode ",
208		"rev_sparse_jac.cpp Reverse Mode Jacobian Sparsity: Example and Test revsparsejac",
209		"RevSparseHes Hessian Sparsity Pattern: Reverse Mode ",
210		"rev_sparse_hes.cpp Reverse Mode Hessian Sparsity: Example and Test revsparsehes",
211		"Drivers First and Second Derivatives: Easy Drivers forward reverse",
212		"Jacobian Jacobian: Driver Routine first derivative",
213		"jacobian.cpp Jacobian: Example and Test ",
214		"ForOne First Order Partial Derivative: Driver Routine easy",
215		"for_one.cpp First Order Partial Driver: Example and Test ",
216		"RevOne First Order Derivative: Driver Routine easy",
217		"rev_one.cpp First Order Derivative Driver: Example and Test ",
218		"Hessian Hessian: Easy Driver second derivative",
219		"hessian.cpp Hessian: Example and Test ",
220		"hes_lagrangian.cpp Hessian of Lagrangian and ADFun Default Constructor: Example and Test heslagrangian",
221		"ForTwo Forward Mode Second Partial Derivative Driver order easy",
222		"for_two.cpp Subset of Second Order Partials: Example and Test ",
223		"RevTwo Reverse Mode Second Partial Derivative Driver order easy",
224		"rev_two.cpp Second Partials Reverse Driver: Example and Test ",
225		"sparse_jacobian Sparse Jacobian: Easy Driver sparsejacobian",
226		"sparse_jacobian.cpp Sparse Jacobian: Example and Test spare",
227		"sparse_hessian Sparse Hessian: Easy Driver sparsehessian",
228		"sparse_hessian.cpp Sparse Hessian: Example and Test spare",
229		"FunCheck Check an ADFun Sequence of Operations ",
230		"fun_check.cpp ADFun Check and Re-Tape: Example and Test funcheck dependent",
231		"optimize Optimize an ADFun Object Tape sequence operations speed memory ndebug",
232		"optimize.cpp ADFun Operation Sequence Optimization: Example and Test ",
233		"check_for_nan Check an ADFun Object For Nan in",
234		"check_for_nan.cpp ADFun Checking For Nan: Example and Test ",
235		"preprocessor CppAD API Preprocessor Symbols cppad_ null pointer cppad_null",
236		"multi_thread Using CppAD in a Multi-Threading Environment parallel mode execution maximum number of threads cppad_max_num_threads",
237		"parallel_ad Enable AD Calculations During Parallel Mode ",
238		"thread_test.cpp Run Multi-Threading Examples and Speed Tests openmp pthread bthread",
239		"a11c_openmp.cpp A Simple OpenMP Example and Test a.1.1c thread",
240		"a11c_bthread.cpp A Simple Boost Thread Example and Test a.1.1c",
241		"a11c_pthread.cpp A Simple Parallel Pthread Example and Test openmp a.1.1c",
242		"simple_ad_openmp.cpp A Simple OpenMP AD: Example and Test ",
243		"simple_ad_bthread.cpp A Simple Boost Threading AD: Example and Test ",
244		"simple_ad_pthread.cpp A Simple pthread AD: Example and Test ",
245		"team_example.cpp Using a Team of AD Threads: Example and Test ",
246		"harmonic.cpp Multi-Threaded Implementation of Summation of 1/i multi_thread",
247		"harmonic_time.cpp Timing Test of Multi-Threaded Summation of 1/i multi_thread speed",
248		"harmonic_work.cpp Multi-threading Sum of 1/i Utility Routines harmonic_setup harmonic_worker harmonic_combine",
249		"multi_newton.cpp A Multi-Threaded Newton's Method threading multi-threading",
250		"multi_newton_time.cpp Timing Test of Multi-Threaded Newton Method multi_thread speed",
251		"multi_newton_work.cpp Multi-threading Newton Method Utility Routines multi_newton_setup multi_newton_worker multi_newton_combine",
252		"team_thread.hpp Specifications for A Team of AD Threads ",
253		"team_openmp.cpp OpenMP Implementation of a Team of AD Threads ",
254		"team_bthread.cpp Boost Thread Implementation of a Team of AD Threads ",
255		"team_pthread.cpp Pthread Implementation of a Team of AD Threads bug cygwin pthread_exit",
256		"library The CppAD General Purpose Library numerical c++ template concept",
257		"ErrorHandler Replacing the CppAD Error Handler replace assert exception parallel",
258		"error_handler.cpp Replacing The CppAD Error Handler: Example and Test ",
259		"cppad_assert CppAD Assertions During Execution error macro ndebug cppad_assert_known cppad_assert_unknown",
260		"NearEqual Determine if Two Values Are Nearly Equal absolute difference relative exercise",
261		"near_equal.cpp NearEqual Function: Example and Test ",
262		"speed_test Run One Speed Test and Return Results ",
263		"SpeedTest Run One Speed Test and Print Results ",
264		"speed_test.cpp speed_test: Example and test ",
265		"speed_program.cpp Example Use of SpeedTest ",
266		"time_test Determine Amount of Time to Execute a Test speed",
267		"elapsed_seconds Returns Elapsed Number of Seconds time",
268		"elapsed_seconds.cpp Elapsed Seconds: Example and Test timer",
269		"time_test.cpp time_test: Example and test ",
270		"NumericType Definition of a Numeric Type default constructor int copy exercise",
271		"numeric_type.cpp The NumericType: Example and Test ",
272		"CheckNumericType Check NumericType Class Concept parallel",
273		"check_numeric_type.cpp The CheckNumericType Function: Example and Test ",
274		"SimpleVector Definition of a Simple Vector class template default constructor size copy element destructor assignment resize value_type [] exercise ndebug",
275		"simple_vector.cpp Simple Vector Template Class: Example and Test ",
276		"CheckSimpleVector Check Simple Vector Concept parallel",
277		"check_simple_vector.cpp The CheckSimpleVector Function: Example and Test ",
278		"nan Obtain Nan or Determine if a Value is Nan isnan hasnan macro",
279		"nan.cpp nan: Example and Test ",
280		"pow_int The Integer Power Function exponent",
281		"pow_int.cpp The Pow Integer Exponent: Example and Test ",
282		"Poly Evaluate a Polynomial or its Derivative template",
283		"poly.cpp Polynomial Evaluation: Example and Test ",
284		"poly.hpp Source: Poly ",
285		"LuDetAndSolve Compute Determinants and Solve Equations by LU Factorization matrix linear",
286		"LuSolve Compute Determinant and Solve Linear Equations ",
287		"lu_solve.cpp LuSolve With Complex Arguments: Example and Test ",
288		"lu_solve.hpp Source: LuSolve ",
289		"LuFactor LU Factorization of A Square Matrix linear equation determinant solve",
290		"lu_factor.cpp LuFactor: Example and Test ",
291		"lu_factor.hpp Source: LuFactor ",
292		"LuInvert Invert an LU Factored Equation linear",
293		"lu_invert.cpp LuInvert: Example and Test ",
294		"lu_invert.hpp Source: LuInvert ",
295		"RombergOne One DimensionalRomberg Integration integrate",
296		"romberg_one.cpp One Dimensional Romberg Integration: Example and Test ",
297		"RombergMul Multi-dimensional Romberg Integration integrate",
298		"Rombergmul.cpp One Dimensional Romberg Integration: Example and Test ",
299		"Runge45 An Embedded 4th and 5th Order Runge-Kutta ODE Solver differential equation parallel",
300		"runge45_1.cpp Runge45: Example and Test ",
301		"runge45_2.cpp Runge45: Example and Test ",
302		"Rosen34 A 3rd and 4th Order Rosenbrock ODE Solver stiff differential equation parallel",
303		"rosen_34.cpp Rosen34: Example and Test ",
304		"OdeErrControl An Error Controller for ODE Solvers differential equation",
305		"ode_err_control.cpp OdeErrControl: Example and Test ",
306		"ode_err_maxabs.cpp OdeErrControl: Example and Test Using Maxabs Argument ",
307		"OdeGear An Arbitrary Order Gear Method stiff differential equation",
308		"ode_gear.cpp OdeGear: Example and Test ",
309		"OdeGearControl An Error Controller for Gear's Ode Solvers differential equation",
310		"ode_gear_control.cpp OdeGearControl: Example and Test ",
311		"CppAD_vector The CppAD::vector Template Class assignment [] push_back push_vector vectorbool thread_alloc exercise",
312		"cppad_vector.cpp CppAD::vector Template Class: Example and Test ",
313		"vector_bool.cpp CppAD::vectorBool Class: Example and Test ",
314		"thread_alloc A Fast Multi-Threading Memory Allocator allocation",
315		"thread_alloc.cpp Fast Multi-Threading Memory Allocator: Example and Test openmp allocation pthread boost",
316		"ta_parallel_setup Setup thread_alloc For Use in Multi-Threading Environment num_threads in_parallel thread_num initialize",
317		"ta_num_threads Get Number of Threads thread_alloc",
318		"ta_in_parallel Is The Current Execution in Parallel Mode thread_alloc sequential",
319		"ta_thread_num Get the Current Thread Number thread_alloc",
320		"ta_get_memory Get At Least A Specified Amount of Memory thread_num thread_alloc allocate",
321		"ta_return_memory Return Memory to thread_alloc available",
322		"ta_free_available Free Memory Currently Available for Quick Use by a Thread thread_alloc",
323		"ta_hold_memory Control When Thread Alloc Retains Memory For Future Use thread_alloc",
324		"ta_inuse Amount of Memory a Thread is Currently Using thread_alloc",
325		"ta_available Amount of Memory Available for Quick Use by a Thread thread_alloc",
326		"ta_create_array Allocate An Array and Call Default Constructor for its Elements thread_alloc",
327		"ta_delete_array Deallocate An Array and Call Destructor for its Elements thread_alloc",
328		"ta_free_all Free All Memory That Was Allocated for Use by thread_alloc ",
329		"index_sort Returns Indices that Sort a Vector ",
330		"index_sort.cpp Index Sort: Example and Test ",
331		"BenderQuad Computing Jacobian and Hessian of Bender's Reduced Objective ",
332		"bender_quad.cpp BenderQuad: Example and Test ",
333		"opt_val_hes Jacobian and Hessian of Optimal Values ",
334		"opt_val_hes.cpp opt_val_hes: Example and Test ",
335		"LuRatio LU Factorization of A Square Matrix and Stability Calculation linear equation determinant solve",
336		"lu_ratio.cpp LuRatio: Example and Test ",
337		"ipopt_solve Use Ipopt to Solve a Nonlinear Programming Problem ",
338		"ipopt_solve_get_started.cpp Nonlinear Programming Using CppAD and Ipopt: Example and Test ",
339		"ipopt_solve_retape.cpp Nonlinear Programming Retaping: Example and Test ",
340		"ipopt_solve_ode_inverse.cpp ODE Inverse Problem Definitions: Source Code example",
341		"Example Examples ",
342		"General General Examples realistic",
343		"ExampleUtility Utility Routines used by CppAD Examples ",
344		"ListAllExamples List of All the CppAD Examples ",
345		"ad_fun.cpp Creating Your Own Interface to an ADFun Object example test",
346		"ad_in_c.cpp Example and Test Linking CppAD to Languages Other than C++ algorithmic differentiation automatic",
347		"conj_grad.cpp Differentiate Conjugate Gradient Algorithm: Example and Test ",
348		"cppad_eigen.hpp Enable Use of Eigen Linear Algebra Package with CppAD ",
349		"eigen_plugin.hpp Source Code for eigen_plugin.hpp ",
350		"eigen_array.cpp Using Eigen Arrays: Example and Test ",
351		"eigen_det.cpp Using Eigen To Compute Determinant: Example and Test ",
352		"hes_minor_det.cpp Gradient of Determinant Using Expansion by Minors: Example and Test ",
353		"hes_lu_det.cpp Gradient of Determinant Using LU Factorization: Example and Test ",
354		"interface2c.cpp Interfacing to C: Example and Test difference central",
355		"jac_minor_det.cpp Gradient of Determinant Using Expansion by Minors: Example and Test ",
356		"jac_lu_det.cpp Gradient of Determinant Using Lu Factorization: Example and Test ",
357		"mul_level Using Multiple Levels of AD ",
358		"mul_level.cpp Multiple Tapes: Example and Test ad",
359		"change_const.cpp Computing a Jacobian With Constants that Change multiple ad level",
360		"ode_stiff.cpp A Stiff Ode: Example and Test ",
361		"mul_level_ode.cpp Taylor's Ode Solver: An Example and Test ",
362		"mul_level_adolc_ode.cpp Using Adolc with Taylor's Ode Solver: An Example and Test ",
363		"ode_taylor.cpp Taylor's Ode Solver: An Example and Test ",
364		"stack_machine.cpp Example Differentiating a Stack Machine Interpreter test",
365		"example.cpp CppAD Examples and Tests ",
366		"speed_example.cpp Run the Speed Examples program",
367		"lu_vec_ad.cpp Lu Factor and Solve with Recorded Pivoting luvecad linear equation determinant",
368		"lu_vec_ad_ok.cpp Lu Factor and Solve With Recorded Pivoting: Example and Test ",
369		"testvector Using The CppAD Test Vector Template Class cppad_testvector",
370		"speed AD Speed Test Routines windows",
371		"speed_main Speed Testing Main Program cppad uniform_01",
372		"link_det_lu Speed Testing Gradient of Determinant Using Lu Factorization ",
373		"link_det_minor Speed Testing Gradient of Determinant by Minor Expansion ",
374		"link_mat_mul Speed Testing Derivative of Matrix Multiply multiple",
375		"link_ode Speed Testing the Jacobian of Ode Solution ",
376		"link_poly Speed Testing Second Derivative of a Polynomial ",
377		"link_sparse_hessian Speed Testing Sparse Hessian ",
378		"link_sparse_jacobian Speed Testing Sparse Jacobian ",
379		"microsoft_timer Microsoft Version of Elapsed Number of Seconds ",
380		"speed_utility Speed Testing Utilities ",
381		"det_by_lu Determinant Using Expansion by Lu Factorization ",
382		"det_by_lu.cpp Determinant Using Lu Factorization: Example and Test minors",
383		"det_by_lu.hpp Source: det_by_lu ",
384		"det_of_minor Determinant of a Minor matrix",
385		"det_of_minor.cpp Determinant of a Minor: Example and Test ",
386		"det_of_minor.hpp Source: det_of_minor ",
387		"det_by_minor Determinant Using Expansion by Minors ",
388		"det_by_minor.cpp Determinant Using Expansion by Minors: Example and Test ",
389		"det_by_minor.hpp Source: det_by_minor ",
390		"det_33 Check Determinant of 3 by 3 matrix correct",
391		"det_33.hpp Source: det_33 ",
392		"det_grad_33 Check Gradient of Determinant of 3 by 3 matrix correct",
393		"det_grad_33.hpp Source: det_grad_33 ",
394		"mat_sum_sq Sum Elements of a Matrix Times Itself multiply speed test",
395		"mat_sum_sq.cpp Sum of the Elements of the Square of a Matrix: Example and Test ",
396		"mat_sum_sq.hpp Source: mat_sum_sq ",
397		"ode_evaluate Evaluate a Function Defined in Terms of an ODE ",
398		"ode_evaluate.cpp ode_evaluate: Example and test ",
399		"ode_evaluate.hpp Source: ode_evaluate ",
400		"sparse_jac_fun Evaluate a Function That Has a Sparse Jacobian ",
401		"sparse_jac_fun.cpp sparse_jac_fun: Example and test ",
402		"sparse_jac_fun.hpp Source: sparse_jac_fun ",
403		"sparse_hes_fun Evaluate a Function That Has a Sparse Hessian ",
404		"sparse_hes_fun.cpp sparse_hes_fun: Example and test ",
405		"sparse_hes_fun.hpp Source: sparse_hes_fun ",
406		"uniform_01 Simulate a [0,1] Uniform Random Variate vector",
407		"uniform_01.hpp Source: uniform_01 ",
408		"speed_double Speed Test of Functions in Double ",
409		"double_det_minor.cpp Double Speed: Determinant by Minor Expansion link_det_minor",
410		"double_det_lu.cpp Double Speed: Determinant Using Lu Factorization link_det_lu matrix",
411		"double_mat_mul.cpp CppAD Speed: Matrix Multiplication (Double Version) multiply link_mat_mul",
412		"double_ode.cpp Double Speed: Ode Solution link_ode",
413		"double_poly.cpp Double Speed: Evaluate a Polynomial link_poly",
414		"double_sparse_hessian.cpp Double Speed: Sparse Hessian link_sparse_hessian",
415		"double_sparse_jacobian.cpp Double Speed: Sparse Jacobian link_sparse_jacobian",
416		"speed_adolc Speed Test of Derivatives Using Adolc ",
417		"adolc_det_minor.cpp Adolc Speed: Gradient of Determinant by Minor Expansion link_det_minor",
418		"adolc_det_lu.cpp Adolc Speed: Gradient of Determinant Using Lu Factorization link_det_lu matrix",
419		"adolc_mat_mul.cpp Adolc Speed: Matrix Multiplication link_mat_mul multiply",
420		"adolc_ode.cpp Adolc Speed: Ode link_ode",
421		"adolc_poly.cpp Adolc Speed: Second Derivative of a Polynomial link_poly",
422		"adolc_sparse_hessian.cpp Adolc Speed: Sparse Hessian link_sparse_hessian",
423		"adolc_sparse_jacobian.cpp adolc Speed: Sparse Jacobian link_sparse_jacobian",
424		"adolc_alloc_mat Adolc Test Utility: Allocate and Free Memory For a Matrix ",
425		"speed_cppad Speed Test Derivatives Using CppAD ",
426		"cppad_det_minor.cpp CppAD Speed: Gradient of Determinant by Minor Expansion link_det_minor",
427		"cppad_det_lu.cpp CppAD Speed: Gradient of Determinant Using Lu Factorization link_det_lu matrix",
428		"cppad_mat_mul.cpp CppAD Speed: Matrix Multiplication link_mat_mul multiply",
429		"cppad_ode.cpp CppAD Speed: Gradient of Ode Solution link_ode",
430		"cppad_poly.cpp CppAD Speed: Second Derivative of a Polynomial link_poly",
431		"cppad_sparse_hessian.cpp CppAD Speed: Sparse Hessian link_sparse_hessian",
432		"cppad_sparse_jacobian.cpp CppAD Speed: Sparse Jacobian link_sparse_jacobian",
433		"cppad_print_optimize Speed Test Utility: Optimize Operation Sequences and Print Results ",
434		"speed_fadbad Speed Test Derivatives Using Fadbad ",
435		"fadbad_det_minor.cpp Fadbad Speed: Gradient of Determinant by Minor Expansion link_det_minor",
436		"fadbad_det_lu.cpp Fadbad Speed: Gradient of Determinant Using Lu Factorization link_det_lu matrix",
437		"fadbad_mat_mul.cpp Fadbad Speed: Matrix Multiplication link_mat_mul multiply",
438		"fadbad_ode.cpp Fadbad Speed: Ode link_ode",
439		"fadbad_poly.cpp Fadbad Speed: Second Derivative of a Polynomial link_poly",
440		"fadbad_sparse_hessian.cpp Fadbad Speed: Sparse Hessian ",
441		"fadbad_sparse_jacobian.cpp fadbad Speed: sparse_jacobian ",
442		"speed_sacado Speed Test Derivatives Using Sacado ",
443		"sacado_det_minor.cpp Sacado Speed: Gradient of Determinant by Minor Expansion link_det_minor",
444		"sacado_det_lu.cpp Sacado Speed: Gradient of Determinant Using Lu Factorization link_det_lu matrix",
445		"sacado_mat_mul.cpp Sacado Speed: Matrix Multiplication link_mat_mul multiply",
446		"sacado_ode.cpp Sacado Speed: Gradient of Ode Solution link_ode",
447		"sacado_poly.cpp Sacado Speed: Second Derivative of a Polynomial link_poly",
448		"sacado_sparse_hessian.cpp Sacado Speed: Sparse Hessian ",
449		"sacado_sparse_jacobian.cpp sacado Speed: sparse_jacobian ",
450		"Appendix Appendix ",
451		"Faq Frequently Asked Questions and Answers assignment operator independent bugs reporting comparechange ndebug complex test exception errorhandler variable tape avoid record speed taping math functions inverse matrix forward reverse mode namespace cppad_testvector preprocessor symbols standard using storage memory disk",
452		"Theory The Theory of Derivative Calculations ",
453		"ForwardTheory The Theory of Forward Mode ",
454		"ExpForward Exponential Function Forward Taylor Polynomial Theory ",
455		"LogForward Logarithm Function Forward Taylor Polynomial Theory ",
456		"SqrtForward Square Root Function Forward Taylor Polynomial Theory ",
457		"SinCosForward Trigonometric and Hyperbolic Sine and Cosine Forward Theory sinh cosh",
458		"AtanForward Arctangent Function Forward Taylor Polynomial Theory ",
459		"AsinForward Arcsine Function Forward Taylor Polynomial Theory ",
460		"AcosForward Arccosine Function Forward Taylor Polynomial Theory ",
461		"tan_forward Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory ",
462		"ReverseTheory The Theory of Reverse Mode ",
463		"ExpReverse Exponential Function Reverse Mode Theory ",
464		"LogReverse Logarithm Function Reverse Mode Theory ",
465		"SqrtReverse Square Root Function Reverse Mode Theory ",
466		"SinCosReverse Trigonometric and Hyperbolic Sine and Cosine Reverse Theory sinh cosh",
467		"AtanReverse Arctangent Function Reverse Mode Theory ",
468		"AsinReverse Arcsine Function Reverse Mode Theory ",
469		"AcosReverse Arccosine Function Reverse Mode Theory ",
470		"tan_reverse Tangent and Hyperbolic Tangent Reverse Mode Theory ",
471		"reverse_identity An Important Reverse Mode Identity ",
472		"glossary Glossary ad function of base levels above type elementary vector operation atomic sequence dependent independent parameter sparsity pattern efficient boolean sets tape active inactive variable variables taylor coefficient",
473		"Bib Bibliography ",
474		"Bugs Know Bugs and Problems Using CppAD gcc 3.4.4",
475		"WishList The CppAD Wish List new features adolc atan2 checkpoint forward iterator compile speed ad<double> testing machine epsilon sequence operation optimize tape preprocessor tracing",
476		"whats_new Changes and Additions to CppAD ",
477		"whats_new_13 CppAD Changes and Additions During 2013 ",
478		"whats_new_12 CppAD Changes and Additions During 2012 ",
479		"whats_new_11 Changes and Additions to CppAD During 2011 ",
480		"whats_new_10 Changes and Additions to CppAD During 2010 ",
481		"whats_new_09 Changes and Additions to CppAD During 2009 ",
482		"whats_new_08 Changes and Additions to CppAD During 2008 erf ipopt_cppad_nlp",
483		"whats_new_07 Changes and Additions to CppAD During 2007 ",
484		"whats_new_06 Changes and Additions to CppAD During 2006 aclocal",
485		"whats_new_05 Changes and Additions to CppAD During 2005 ",
486		"whats_new_04 Changes and Additions to CppAD During 2004 ",
487		"whats_new_03 Changes and Additions to CppAD During 2003 ",
488		"deprecated CppAD Deprecated API Features ",
489		"include_deprecated Deprecated Include Files ",
490		"FunDeprecated ADFun Object Deprecated Member Functions dependent order memory size taylor_size use_vecad",
491		"omp_max_thread OpenMP Parallel Setup depreciated",
492		"TrackNewDel Routines That Track Use of New and Delete memory deprecated tracknewvec ndebug cppad_track_new_vec cppadtracknewvec trackdelvec cppad_track_del_vec cppadtrackdelvec trackextend cppad_track_extend cppadtrackextend trackcount cppad_track_count multi-threading",
493		"TrackNewDel.cpp Tracking Use of New and Delete: Example and Test ",
494		"omp_alloc A Quick OpenMP Memory Allocator Used by CppAD multi-threading allocation",
495		"omp_max_num_threads Set and Get Maximum Number of Threads for omp_alloc Allocator set_max_num_threads get_max_num_threads",
496		"omp_in_parallel Is The Current Execution in OpenMP Parallel Mode omp_alloc",
497		"omp_get_thread_num Get the Current OpenMP Thread Number omp_alloc",
498		"omp_get_memory Get At Least A Specified Amount of Memory get_thread_num omp_alloc",
499		"omp_return_memory Return Memory to omp_alloc ",
500		"omp_free_available Free Memory Currently Available for Quick Use by a Thread omp_alloc",
501		"omp_inuse Amount of Memory a Thread is Currently Using omp_alloc",
502		"omp_available Amount of Memory Available for Quick Use by a Thread omp_alloc",
503		"omp_create_array Allocate Memory and Create A Raw Array omp_alloc",
504		"omp_delete_array Return A Raw Array to The Available Memory for a Thread omp_alloc",
505		"omp_efficient Check If A Memory Allocation is Efficient for Another Use omp_alloc",
506		"old_max_num_threads Set Maximum Number of Threads for omp_alloc Allocator ",
507		"omp_alloc.cpp OpenMP Memory Allocator: Example and Test allocation multi-thread",
508		"memory_leak Memory Leak Detection check static deprecated",
509		"epsilon Machine Epsilon For AD Types deprecated",
510		"test_vector Choosing The Vector Testing Template Class cppad_test_vector deprecated",
511		"cppad_ipopt_nlp Nonlinear Programming Using the CppAD Interface to Ipopt deprecated",
512		"ipopt_nlp_get_started.cpp Nonlinear Programming Using CppAD and Ipopt: Example and Test ",
513		"ipopt_nlp_ode Example Simultaneous Solution of Forward and Inverse Problem ",
514		"ipopt_nlp_ode_problem An ODE Inverse Problem Example ",
515		"ipopt_nlp_ode_simple ODE Fitting Using Simple Representation cppad_ipopt_nlp",
516		"ipopt_nlp_ode_fast ODE Fitting Using Fast Representation cppad_ipopt_nlp",
517		"ipopt_nlp_ode_problem.hpp ODE Inverse Problem Definitions: Source Code example",
518		"ipopt_nlp_ode_simple.hpp ODE Fitting Using Simple Representation cppad_ipopt_nlp example source",
519		"ipopt_nlp_ode_fast.hpp ODE Fitting Using Fast Representation cppad_ipopt_nlp example source",
520		"ipopt_nlp_ode_run.hpp Driver for Running the Ipopt ODE Example ",
521		"ipopt_nlp_ode_check.cpp Correctness Check for Both Simple and Fast Representations ",
522		"ipopt_ode_speed.cpp Speed Test for Both Simple and Fast Representations ",
523		"old_atomic User Defined Atomic AD Functions cppad_user_atomic operation parallel",
524		"old_reciprocal.cpp Old Atomic Operation Reciprocal: Example and Test user",
525		"old_usead_1.cpp Using AD to Compute Atomic Function Derivatives inside user checkpoint",
526		"old_usead_2.cpp Using AD to Compute Atomic Function Derivatives inside user checkpoint",
527		"old_tan.cpp Tan and Tanh as User Atomic Operations: Example and Test old_atomic",
528		"old_mat_mul.cpp Matrix Multiply as a User Atomic Operation: Example and Test old_atomic",
529		"old_mat_mul.hpp Define Matrix Multiply as a User Atomic Operation old_atomic test example",
530		"compare_c Compare Speed of C and C++ with",
531		"det_of_minor_c Determinant of a Minor ",
532		"det_by_minor_c Compute Determinant using Expansion by Minors ",
533		"uniform_01_c Simulate a [0,1] Uniform Random Variate ",
534		"correct_det_by_minor_c Correctness Test of det_by_minor Routine ",
535		"repeat_det_by_minor_c Repeat det_by_minor Routine A Specified Number of Times ",
536		"elapsed_seconds_c Returns Elapsed Number of Seconds ",
537		"time_det_by_minor_c Determine Amount of Time to Execute det_by_minor ",
538		"main_compare_c Main Program For Comparing C and C++ Speed ",
539		"License Your License for the CppAD Software "
	5	'CppAD cppad-20150000.0: A Package for Differentiation of C++ Algorithms ',' algorithmic automatic derivative version syntax introduction example include file cppad.hpp preprocessor symbols namespace ',
	6	'Install CppAD Download, Test, and Install Instructions ',' step 1: 2: cmake 3: check 4: ',
	7	'download Download The CppAD Source Code ',' purpose distribution directory compressed tar file current version monthly versions release unix extraction windows install instructions subversion limitations stable ',
	8	'cmake Using CMake to Configure CppAD ',' the program command build directory generator makefile cmake_install_prefix cmake_install_includedirs directories cmake_install_datadir cmake_install_docdir cmake_install_libdirs library cmake_install_postfix package_prefix cppad_cxx_flags c++ compile cppad_testvector cppad_max_num_threads maximum number cppad_sparse_list sparsity internal structure of sets cppad_tape_id_type memory usage cstdint cppad_tape_addr_type cppad_implicit_ctor_from_any_type explicit ',
	9	'adolc_prefix Including the ADOL-C Examples and Tests ',' purpose speed unix cygwin get_adolc ',
	10	'get_adolc.sh Download and Install Adolc in Build Directory ',' syntax purpose requirements distribution external prefix reuse ',
	11	'colpack_prefix Including the ColPack Sparsity Calculations ',' purpose cppad_colpack.cpp example get_colpack ',
	12	'colpack.cpp Using ColPack: Example and Test ',' spare ',
	13	'get_colpack.sh Download and Install ColPack in Build Directory ',' syntax purpose distribution external prefix reuse ',
	14	'eigen_prefix Including the Eigen Examples and Tests ',' purpose vector get_eigen ',
	15	'get_eigen.sh Download and Install Eigen in Build Directory ',' syntax purpose distribution external prefix reuse ',
	16	'fadbad_prefix Including the FADBAD Speed Tests ',' purpose get_fadbad ',
	17	'get_fadbad.sh Download and Install Fadbad in Build Directory ',' syntax purpose distribution external prefix ',
	18	'ipopt_prefix Including the cppad_ipopt Library and Tests ',' purpose examples get_ipopt ',
	19	'get_ipopt.sh Download and Install Ipopt in Build Directory ',' syntax purpose distribution external prefix reuse ',
	20	'sacado_prefix Including the Sacado Speed Tests ',' purpose get_sacado ',
	21	'get_sacado.sh Download and Install Sacado in Build Directory ',' syntax purpose distribution external prefix reuse ',
	22	'cppad_testvector Choosing the CppAD Test Vector Template Class ',' purpose boost eigen ',
	23	'cmake_check Checking the CppAD Examples and Tests ',' purpose all subsets ',
	24	'pkgconfig CppAD pkg-config Files ',' pc purpose usage defined fields configuration ',
	25	'InstallUnix Deprecated Unix Test and Installation ',' cppad free distribution directory work configure make examples tests profiling speed profile prefix_dir --with-documentation --with-testvector std boost eigen --with-sparse_option internal sets --with-implicit_ctor explicit max_num_threads cxx_flags compile openmp_flags postfix_dir adolc_dir linux cygwin boost_dir eigen_dir fadbad_dir ipopt_dir sacado_dir tape_addr_type memory usage tape_id_type ',
	26	'Introduction An Introduction by Example to Algorithmic Differentiation ',' ad automatic purpose preface forward mode reverse operation count efficiency outline reference ',
	27	'get_started.cpp Getting Started Using CppAD to Compute Derivatives ',' simple example purpose function value poly exercises program output running ',
	28	'exp_2 Second Order Exponential Approximation ',' example algorithm syntax purpose mathematical form include type implementation test exercises ',
	29	'exp_2.hpp exp_2: Implementation ',' ',
	30	'exp_2.cpp exp_2: Test ',' ',
	31	'exp_2_for0 exp_2: Operation Sequence and Zero Order Forward Mode ',' example mathematical form expansion index code sweep return value verification exercises ',
	32	'exp_2_for1 exp_2: First Order Forward Mode ',' example expansion purpose mathematical form operation sequence index zero derivative sweep return value verification exercises ',
	33	'exp_2_rev1 exp_2: First Order Reverse Mode ',' example purpose mathematical form f_5 index 5: f_4 4: f_3 3: f_2 f_1 verification exercises ',
	34	'exp_2_for2 exp_2: Second Order Forward Mode ',' example expansion purpose mathematical form operation sequence index zero first derivative sweep return value verification exercises ',
	35	'exp_2_rev2 exp_2: Second Order Reverse Mode ',' example purpose mathematical form f_5 index 5: f_4 4: f_3 3: f_2 f_1 verification exercises ',
	36	'exp_2_for0.cpp exp_2: Verify Zero Order Forward Sweep ',' ',
	37	'exp_2_for1.cpp exp_2: Verify First Order Forward Sweep ',' ',
	38	'exp_2_rev1.cpp exp_2: Verify First Order Reverse Sweep ',' mode ',
	39	'exp_2_for2.cpp exp_2: Verify Second Order Forward Sweep ',' ',
	40	'exp_2_rev2.cpp exp_2: Verify Second Order Reverse Sweep ',' mode ',
	41	'exp_2_cppad exp_2: CppAD Forward and Reverse Sweeps ',' purpose exercises ',
	42	'exp_eps An Epsilon Accurate Exponential Approximation ',' example algorithm syntax purpose mathematical function include type implementation test exercises ',
	43	'exp_eps.hpp exp_eps: Implementation ',' ',
	44	'exp_eps.cpp exp_eps: Test of exp_eps ',' ',
	45	'exp_eps_for0 exp_eps: Operation Sequence and Zero Order Forward Sweep ',' example mathematical form variable parameter index code return value comparisons verification exercises ',
	46	'exp_eps_for1 exp_eps: First Order Forward Sweep ',' expansion mathematical form operation sequence index zero derivative return value verification exercises ',
	47	'exp_eps_rev1 exp_eps: First Order Reverse Sweep ',' mode example purpose mathematical form epsilon f_7 index 7: f_6 6: f_5 5: f_4 4: f_3 3: f_2 2: f_1 verification exercises ',
	48	'exp_eps_for2 exp_eps: Second Order Forward Mode ',' example expansion purpose mathematical form operation sequence index zero first derivative sweep return value verification exercises ',
	49	'exp_eps_rev2 exp_eps: Second Order Reverse Sweep ',' mode example purpose mathematical form epsilon f_7 index 7: f_6 6: f_5 5: f_4 4: f_3 3: f_2 2: f_1 verification exercises ',
	50	'exp_eps_for0.cpp exp_eps: Verify Zero Order Forward Sweep ',' ',
	51	'exp_eps_for1.cpp exp_eps: Verify First Order Forward Sweep ',' exp_2 ',
	52	'exp_eps_rev1.cpp exp_eps: Verify First Order Reverse Sweep ',' ',
	53	'exp_eps_for2.cpp exp_eps: Verify Second Order Forward Sweep ',' first exp_2 ',
	54	'exp_eps_rev2.cpp exp_eps: Verify Second Order Reverse Sweep ',' ',
	55	'exp_eps_cppad exp_eps: CppAD Forward and Reverse Sweeps ',' purpose exercises ',
	56	'exp_apx_main.cpp Correctness Tests For Exponential Approximation in Introduction ',' run running ',
	57	'AD AD Objects ',' purpose base type requirements ',
	58	'ad_ctor AD Constructors ',' convert base vecad syntax purpose implicit explicit deprecated example ',
	59	'ad_ctor.cpp AD Constructors: Example and Test ',' object ',
	60	'ad_assign AD Assignment Operator ',' base vecad syntax purpose example ',
	61	'ad_assign.cpp AD Assignment: Example and Test ',' object ',
	62	'Convert Conversion and I/O of AD Objects ',' from ',
	63	'Value Convert From an AD Type to its Base Type ',' syntax purpose operation sequence restriction example ',
	64	'value.cpp Convert From AD to its Base Type: Example and Test ',' record ',
	65	'Integer Convert From AD to Integer ',' syntax purpose real types complex operation sequence example ',
	66	'integer.cpp Convert From AD to Integer: Example and Test ',' ',
	67	'ad_input AD Output Stream Operator ',' >> write syntax purpose is result operation sequence example ',
	68	'ad_output AD Output Stream Operator ',' << write syntax purpose assumption result operation sequence example ',
	69	'ad_input.cpp AD Output Operator: Example and Test ',' << ',
	70	'ad_output.cpp AD Output Operator: Example and Test ',' << ',
	71	'PrintFor Printing AD Values During Forward Mode ',' text output debug syntax purpose f.forward(0 x) before var after discussion alternative example ',
	72	'print_for_cout.cpp Printing During Forward Mode: Example and Test ',' running source code output ',
	73	'print_for_string.cpp Print During Zero Order Forward Mode: Example and Test ',' ',
	74	'Var2Par Convert an AD Variable to a Parameter ',' from value_ obtain during taping syntax purpose example ',
	75	'var2par.cpp Convert an AD Variable to a Parameter: Example and Test ',' value during taping ',
	76	'ADValued AD Valued Operations and Functions ',' ',
	77	'Arithmetic AD Arithmetic Operators and Computed Assignments ',' ',
	78	'UnaryPlus AD Unary Plus Operator ',' + syntax purpose operation sequence derivative example ',
	79	'unary_plus.cpp AD Unary Plus Operator: Example and Test ',' ',
	80	'UnaryMinus AD Unary Minus Operator ',' - syntax purpose base operation sequence derivative example ',
	81	'unary_minus.cpp AD Unary Minus Operator: Example and Test ',' ',
	82	'ad_binary AD Binary Arithmetic Operators ',' + add plus - subtract minus * multiply times / divide syntax purpose base z operation sequence example derivative addition subtraction multiplication division ',
	83	'add.cpp AD Binary Addition: Example and Test ',' + plus ',
	84	'sub.cpp AD Binary Subtraction: Example and Test ',' - minus ',
	85	'mul.cpp AD Binary Multiplication: Example and Test ',' * multiply times ',
	86	'div.cpp AD Binary Division: Example and Test ',' / divide quotient ',
	87	'compute_assign AD Computed Assignment Operators ',' + add plus - subtract minus * multiply times / divide syntax purpose base result multiple operation sequence example derivative addition subtraction multiplication division ',
	88	'AddEq.cpp AD Computed Assignment Addition: Example and Test ',' += plus ',
	89	'sub_eq.cpp AD Computed Assignment Subtraction: Example and Test ',' -= plus add ',
	90	'mul_eq.cpp AD Computed Assignment Multiplication: Example and Test ',' *= multiply plus add ',
	91	'div_eq.cpp AD Computed Assignment Division: Example and Test ',' /= divide plus add ',
	92	'std_math_ad AD Standard Math Unary Functions ',' acos asin atan cosh exp fabs log log10 sinh sqrt tanh syntax purpose operation sequence examples derivatives ',
	93	'Acos.cpp The AD acos Function: Example and Test ',' ',
	94	'Asin.cpp The AD asin Function: Example and Test ',' ',
	95	'atan.cpp The AD atan Function: Example and Test ',' ',
	96	'cos.cpp The AD cos Function: Example and Test ',' ',
	97	'cosh.cpp The AD cosh Function: Example and Test ',' ',
	98	'exp.cpp The AD exp Function: Example and Test ',' ',
	99	'log.cpp The AD log Function: Example and Test ',' ',
	100	'log10.cpp The AD log10 Function: Example and Test ',' ',
	101	'sin.cpp The AD sin Function: Example and Test ',' ',
	102	'sinh.cpp The AD sinh Function: Example and Test ',' ',
	103	'sqrt.cpp The AD sqrt Function: Example and Test ',' ',
	104	'tan.cpp The AD tan Function: Example and Test ',' ',
	105	'tanh.cpp The AD tanh Function: Example and Test ',' ',
	106	'MathOther Other AD Math Functions ',' ',
	107	'abs AD Absolute Value Function ',' fabs syntax purpose operation sequence complex types derivative example old ',
	108	'abs.cpp AD Absolute Value Function: Example and Test ',' fabs ',
	109	'sign Sign Function ',' ad syntax purpose operation sequence complex types derivative example ',
	110	'sign.cpp Sign Function: Example and Test ',' ',
	111	'atan2 AD Two Argument Inverse Tangent Function ',' syntax purpose theta operation sequence example ',
	112	'atan2.cpp The AD atan2 Function: Example and Test ',' ',
	113	'erf The AD Error Function ',' syntax description operation sequence method cppad_compiler_has_erf other example ',
	114	'erf.cpp The AD erf Function: Example and Test ',' ',
	115	'pow The AD Power Function ',' exponent syntax see also purpose z operation sequence example ',
	116	'pow.cpp The AD Power Function: Example and Test ',' ',
	117	'limits Numeric Limits For an AD and Base Types ',' epsilon max min syntax purpose float example ',
	118	'limits.cpp Numeric Limits: Example and Test ',' ',
	119	'CondExp AD Conditional Expressions ',' assign syntax purpose rel type left right if_true if_false result optimize deprecated operation sequence example test atan2 ',
	120	'cond_exp.cpp Conditional Expressions: Example and Test ',' condexp description ',
	121	'Discrete Discrete AD Functions ',' syntax purpose base name ay create version cppad_discrete_function operation sequence derivatives parallel mode example deprecated cppadcreatediscrete ',
	122	'tape_index.cpp Taping Array Index Operation: Example and Test ',' ',
	123	'interp_onetape.cpp Interpolation With Out Retaping: Example and Test ',' interpolate retape see also ',
	124	'interp_retape.cpp Interpolation With Retaping: Example and Test ',' interpolate see also ',
	125	'atomic Atomic AD Functions ',' operation ',
	126	'checkpoint Checkpointing Functions ',' syntax purpose method constructor base advector name ay option algo afun clear restriction example ',
	127	'checkpoint.cpp Simple Checkpointing: Example and Test ',' purpose ',
	128	'atomic_base User Defined Atomic AD Functions ',' operation syntax purpose virtual examples getting started scalar vector range hessian sparsity patterns general case ',
	129	'atomic_ctor Atomic Function Constructor ',' syntax atomic_user ctor_arg_list afun implementation atomic_base restrictions name examples define ',
	130	'atomic_option Set Atomic Function Options ',' syntax atomic_sparsity bool_sparsity_enum set_sparsity_enum ',
	131	'atomic_afun Using AD Version of Atomic Function ',' use syntax purpose advector ay examples ',
	132	'atomic_forward Atomic Forward Mode ',' callback virtual syntax purpose implementation q vx vy tx ty ok discussion examples define use ',
	133	'atomic_reverse Atomic Reverse Mode ',' callback virtual syntax purpose implementation q tx ty f g h py px ok examples define use ',
	134	'atomic_for_sparse_jac Atomic Forward Jacobian Sparsity Patterns ',' callback virtual syntax purpose implementation q ok examples define use ',
	135	'atomic_rev_sparse_jac Atomic Reverse Jacobian Sparsity Patterns ',' callback virtual syntax purpose implementation q st ok examples define use ',
	136	'atomic_rev_sparse_hes Atomic Reverse Hessian Sparsity Patterns ',' callback virtual syntax purpose implementation vx q examples define use ',
	137	'atomic_base_clear Free Static Variables ',' syntax purpose future use restriction ',
	138	'atomic_get_started.cpp Getting Started with Atomic Operations: Example and Test ',' purpose class definition constructor forward end use function recording ',
	139	'atomic_norm_sq.cpp Euclidean Norm Squared: Example and Test ',' operation theory start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording ',
	140	'atomic_reciprocal.cpp Reciprocal as an Atomic Operation: Example and Test ',' simple theory start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording ',
	141	'atomic_tangent.cpp Tan and Tanh as User Atomic Operations: Example and Test ',' theory start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end function recording large values ',
	142	'atomic_hes_sparse.cpp Atomic Operation Hessian Sparsity: Example and Test ',' purpose start class definition constructor forward for_sparse_jac rev_sparse_hes use function with x_1 both variable parameter ',
	143	'atomic_mat_mul.cpp User Atomic Matrix Multiply: Example and Test ',' class definition function constructor recording forward reverse option for_sparse_jac rev_sparse_jac rev_sparse_hes ',
	144	'atomic_matrix_mul.hpp Matrix Multiply as an Atomic Operation ',' start class definition constructor left operand element index right result forward multipliy reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end ',
	145	'BoolValued Bool Valued Operations and Functions with AD Arguments ',' ',
	146	'Compare AD Binary Comparison Operators ',' < <= > >= == != syntax purpose operation sequence assumptions example ',
	147	'compare.cpp AD Binary Comparison Operators: Example and Test ',' < <= > >= == != ',
	148	'NearEqualExt Compare AD and Base Objects for Nearly Equal ',' with syntax purpose type operation sequence example ',
	149	'near_equal_ext.cpp Compare AD with Base Objects: Example and Test ',' nearequalext ',
	150	'BoolFun AD Boolean Functions ',' unary binary syntax purpose unary_name create cppad_bool_unary binary_name v cppad_bool_binary operation sequence example deprecated ',
	151	'bool_fun.cpp AD Boolean Functions: Example and Test ',' ',
	152	'ParVar Is an AD Object a Parameter or Variable ',' syntax purpose operation sequence example ',
	153	'par_var.cpp AD Parameter and Variable Functions: Example and Test ',' ',
	154	'EqualOpSeq Check if Two Value are Identically Equal ',' operation sequence syntax purpose motivation b example ',
	155	'equal_op_seq.cpp EqualOpSeq: Example and Test ',' ',
	156	'VecAD AD Vectors that Record Index Operations ',' tape syntax purpose alternatives vecad<base>::reference exceptions constructor size size_t indexing example speed and memory ',
	157	'vec_ad.cpp AD Vectors that Record Index Operations: Example and Test ',' vecad ',
	158	'base_require AD<Base> Requirements for Base Type ',' syntax warning purpose standard types include order numeric output operator integer suggestion ',
	159	'base_member Required Base Class Member Functions ',' notation default constructor double copy unary operators assignment binary bool example ',
	160	'base_cond_exp Base Type Requirements for Conditional Expressions ',' condexp purpose compareop condexptemplate ordered not condexprel cppad_cond_exp_rel ',
	161	'base_identical Base Type Requirements for Identically Equal Comparisons ',' equalopseq the simple case more complicated cases identicalpar prototypes functions examples ',
	162	'base_ordered Base Type Requirements for Ordered Comparisons ',' purpose not ',
	163	'base_std_math Base Type Requirements for Standard Math Functions ',' purpose unary cppad_standard_math_unary erf sign pow isnan limits numeric numeric_limits epsilon ',
	164	'base_example Example AD Base Types That are not AD<OtherBase> ',' ',
	165	'base_alloc.hpp Example AD<Base> Where Base Constructor Allocates Memory ',' purpose include file computed assignment macro binary operator boolean class definition condexpop condexprel equalopseq identical output integer ordered unary standard math erf pow limits ',
	166	'base_require.cpp Using a User Defined AD Base Type: Example and Test ',' purpose ',
	167	'base_adolc.hpp Enable use of AD<Base> where Base is Adolc\'s adouble Type ',' syntax example include files condexpop equalopseq identical integer ordered unary standard math erf sign abs pow limits ',
	168	'mul_level_adolc.cpp Using Adolc with Multiple Levels of Taping: Example and Test ',' purpose memory management configuration requirement ',
	169	'base_float.hpp Enable use of AD<Base> where Base is float ',' condexpop condexprel equalopseq identical integer ordered unary standard math sign pow limits ',
	170	'base_double.hpp Enable use of AD<Base> where Base is double ',' condexpop condexprel equalopseq identical integer ordered unary standard math sign pow limits ',
	171	'base_complex.hpp Enable use of AD<Base> where Base is std::complex<double> ',' example see also include order condexpop condexprel equalopseq identical ordered erf integer isnan valid unary math invalid pow limits ',
	172	'complex_poly.cpp Complex Polynomial: Example and Test ',' see also ',
	173	'not_complex_ad.cpp Not Complex Differentiable: Example and Test ',' polynomial imag() real() see also ',
	174	'ADFun ADFun Objects ',' purpose ',
	175	'Independent Declare Independent Variables and Start Recording ',' syntax purpose stop vectorad parallel mode example ',
	176	'independent.cpp Independent and ADFun Constructor: Example and Test ',' ',
	177	'FunConstruct Construct an ADFun Object and Stop Recording ',' tape syntax purpose vectorad default constructor sequence copy assignment operator taylor coefficients sparsity patterns parallel mode example ',
	178	'fun_assign.cpp ADFun Assignment: Example and Test ',' ',
	179	'Dependent Stop Recording and Store Operation Sequence ',' adfun tape syntax purpose advector taping forward parallel mode example ',
	180	'abort_recording Abort Recording of an Operation Sequence ',' tape syntax purpose example ',
	181	'abort_recording.cpp Abort Current Recording: Example and Test ',' ',
	182	'seq_property ADFun Sequence Properties ',' syntax see also purpose domain range parameter size_var size_par size_op size_op_arg size_text size_vecad size_op_seq example ',
	183	'seq_property.cpp ADFun Sequence Properties: Example and Test ',' domain range parameter size_var size_par size_op size_op_arg size_vecad ',
	184	'FunEval Evaluate ADFun Functions, Derivatives, and Sparsity Patterns ',' ',
	185	'Forward Forward Mode ',' ',
	186	'forward_zero Zero Order Forward Mode: Function Values ',' syntax purpose x0 y0 vector example special case ',
	187	'forward_one First Order Forward Mode: Derivative Values ',' syntax purpose x0 x1 vector example special case ',
	188	'forward_two Second Order Forward Mode: Derivative Values ',' syntax purpose x0 x1 x2 y2 vector example special case ',
	189	'forward_order Multiple Order Forward Mode ',' any syntax purpose function values derivative notation one q xq orders restrictions x(t) y(t) yq vector zero first second example ',
	190	'forward.cpp Forward Mode: Example and Test ',' ',
	191	'forward_order.cpp Forward Mode: Example and Test of Multiple Orders ',' ',
	192	'forward_dir Multiple Directions Forward Mode ',' syntax purpose notation q xq zero order non-zero lower orders x(t) y(t) yq vector example ',
	193	'forward_dir.cpp Forward Mode: Example and Test of Multiple Directions ',' orders ',
	194	'size_order Number Taylor Coefficient Orders Currently Stored ',' syntax see also purpose constructor forward capacity_order example ',
	195	'CompareChange Comparison Changes During Zero Order Forward Mode ',' adfun syntax purpose discussion restrictions ndebug example ',
	196	'compare_change.cpp CompareChange and Re-Tape: Example and Test ',' ',
	197	'capacity_order Controlling Taylor Coefficients Memory Allocation ',' forward syntax see also purpose pre-allocating freeing original state example ',
	198	'capacity_order.cpp Controlling Taylor Coefficient Memory Allocation: Example and Test ',' ',
	199	'number_skip Number of Variables that Can be Skipped ',' syntax see also purpose example ',
	200	'number_skip.cpp Number of Variables That Can be Skipped: Example and Test ',' optimize conditional expression ',
	201	'Reverse Reverse Mode ',' multiple directions ',
	202	'reverse_one First Order Reverse Mode ',' derivative syntax purpose w dw vector example ',
	203	'reverse_one.cpp First Order Reverse Mode: Example and Test ',' ',
	204	'reverse_two Second Order Reverse Mode ',' derivative syntax purpose x^(k) f dw first partials vector hessian times direction example ',
	205	'reverse_two.cpp Second Order Reverse ModeExample and Test ',' ',
	206	'hes_times_dir.cpp Hessian Times Direction: Example and Test ',' ',
	207	'reverse_any Any Order Reverse Mode ',' derivative syntax purpose notation u^(k) x(t u) y(t w^(k) w(u) f q dw first second vector example ',
	208	'reverse_three.cpp Third Order Reverse Mode: Example and Test ',' taylor coefficients ',
	209	'reverse_any.cpp Reverse Mode General Case: Example and Test ',' purpose processing steps ',
	210	'Sparse Calculating Sparsity Patterns ',' ',
	211	'ForSparseJac Jacobian Sparsity Pattern: Forward Mode ',' syntax purpose size_forward_bool size_forward_set q transpose false true vectorset entire example ',
	212	'for_sparse_jac.cpp Forward Mode Jacobian Sparsity: Example and Test ',' forsparsejac ',
	213	'RevSparseJac Jacobian Sparsity Pattern: Reverse Mode ',' syntax purpose f q transpose nz_compare false true vectorset entire example ',
	214	'rev_sparse_jac.cpp Reverse Mode Jacobian Sparsity: Example and Test ',' revsparsejac ',
	215	'RevSparseHes Hessian Sparsity Pattern: Reverse Mode ',' syntax purpose f q transpose false true vectorset entire example ',
	216	'rev_sparse_hes.cpp Reverse Mode Hessian Sparsity: Example and Test ',' revsparsehes ',
	217	'Drivers First and Second Derivatives: Easy Drivers ',' forward reverse ',
	218	'Jacobian Jacobian: Driver Routine ',' first derivative syntax purpose vector forward reverse example ',
	219	'jacobian.cpp Jacobian: Example and Test ',' ',
	220	'ForOne First Order Partial Derivative: Driver Routine ',' easy syntax purpose j dy vector uses forward example ',
	221	'for_one.cpp First Order Partial Driver: Example and Test ',' ',
	222	'RevOne First Order Derivative: Driver Routine ',' easy syntax purpose dw vector uses forward example ',
	223	'rev_one.cpp First Order Derivative Driver: Example and Test ',' ',
	224	'Hessian Hessian: Easy Driver ',' second derivative syntax purpose f l w vector uses forward example ',
	225	'hessian.cpp Hessian: Example and Test ',' ',
	226	'hes_lagrangian.cpp Hessian of Lagrangian and ADFun Default Constructor: Example and Test ',' heslagrangian ',
	227	'ForTwo Forward Mode Second Partial Derivative Driver ',' order easy syntax purpose j k ddy vectorbase vectorsize_t uses examples ',
	228	'for_two.cpp Subset of Second Order Partials: Example and Test ',' ',
	229	'RevTwo Reverse Mode Second Partial Derivative Driver ',' order easy syntax purpose f j ddw vectorbase vectorsize_t uses forward examples ',
	230	'rev_two.cpp Second Partials Reverse Driver: Example and Test ',' ',
	231	'sparse_jacobian Sparse Jacobian: Easy Driver ',' sparsejacobian syntax purpose f row col work color_method n_sweep vectorbase vectorset restrictions vectorsize uses forward example ',
	232	'sparse_jacobian.cpp Sparse Jacobian: Example and Test ',' spare ',
	233	'sparse_hessian Sparse Hessian: Easy Driver ',' sparsehessian syntax purpose f w row col work n_sweep vectorbase vectorset restrictions vectorsize uses forward example ',
	234	'sparse_hessian.cpp Sparse Hessian: Example and Test ',' spare ',
	235	'FunCheck Check an ADFun Sequence of Operations ',' syntax purpose g ok vector uses forward discussion example ',
	236	'fun_check.cpp ADFun Check and Re-Tape: Example and Test ',' funcheck dependent ',
	237	'optimize Optimize an ADFun Object Tape ',' sequence operations speed memory syntax purpose improvements testing efficiency comparison operators atomic functions rev_sparse_jac nan checking optimization ndebug example ',
	238	'optimize.cpp ADFun Operation Sequence Optimization: Example and Test ',' ',
	239	'check_for_nan Check an ADFun Object For Nan ',' in syntax purpose default example ',
	240	'check_for_nan.cpp ADFun Checking For Nan: Example and Test ',' ',
	241	'preprocessor CppAD API Preprocessor Symbols ',' cppad_ purpose documented here cppad_null pointer cppad_package_string elsewhere deprecated ',
	242	'multi_thread Using CppAD in a Multi-Threading Environment ',' parallel mode execution purpose cppad_max_num_threads maximum number of parallel_setup hold_memory initialization same prohibited ',
	243	'parallel_ad Enable AD Calculations During Parallel Mode ',' syntax purpose discussion checksimplevector example restriction ',
	244	'thread_test.cpp Run Multi-Threading Examples and Speed Tests ',' syntax running openmp pthread bthread purpose a11c simple_ad team_example harmonic test_time max_threads mega_sum multi_newton num_zero num_sub num_sum use_ad implementations source ',
	245	'a11c_openmp.cpp A Simple OpenMP Example and Test ',' a.1.1c thread purpose source code ',
	246	'a11c_bthread.cpp A Simple Boost Thread Example and Test ',' a.1.1c purpose source code ',
	247	'a11c_pthread.cpp A Simple Parallel Pthread Example and Test ',' openmp a.1.1c purpose source code ',
	248	'simple_ad_openmp.cpp A Simple OpenMP AD: Example and Test ',' purpose source code ',
	249	'simple_ad_bthread.cpp A Simple Boost Threading AD: Example and Test ',' purpose source code ',
	250	'simple_ad_pthread.cpp A Simple pthread AD: Example and Test ',' purpose source code ',
	251	'team_example.cpp Using a Team of AD Threads: Example and Test ',' purpose thread_team source code ',
	252	'harmonic.cpp Multi-Threaded Implementation of Summation of 1/i ',' multi_thread syntax ok num_sum num_threads source ',
	253	'harmonic_time.cpp Timing Test of Multi-Threaded Summation of 1/i ',' multi_thread speed syntax purpose ok time_out test_time num_threads mega_sum source ',
	254	'harmonic_work.cpp Multi-threading Sum of 1/i Utility Routines ',' harmonic_setup harmonic_worker harmonic_combine syntax purpose num_sum num_threads source ',
	255	'multi_newton.cpp A Multi-Threaded Newton\'s Method ',' threading multi-threading syntax purpose ok xout fun num_sub xlow xup epsilon max_itr num_threads source ',
	256	'multi_newton_time.cpp Timing Test of Multi-Threaded Newton Method ',' multi_thread speed syntax purpose ok time_out test_time num_threads num_zero num_sub num_sum use_ad source ',
	257	'multi_newton_work.cpp Multi-threading Newton Method Utility Routines ',' multi_newton_setup multi_newton_worker multi_newton_combine syntax purpose fun num_sub xlow xup epsilon max_itr num_threads xout source ',
	258	'team_thread.hpp Specifications for A Team of AD Threads ',' syntax purpose restrictions team_create team_work team_destroy team_name ok example use implementation speed test source ',
	259	'team_openmp.cpp OpenMP Implementation of a Team of AD Threads ',' ',
	260	'team_bthread.cpp Boost Thread Implementation of a Team of AD Threads ',' ',
	261	'team_pthread.cpp Pthread Implementation of a Team of AD Threads ',' bug in cygwin pthread_exit ',
	262	'library The CppAD General Purpose Library ',' numerical c++ template error handler testing utilities concepts ',
	263	'ErrorHandler Replacing the CppAD Error Handler ',' replace assert exception syntax constructor parallel mode call info known line file exp msg example ',
	264	'error_handler.cpp Replacing The CppAD Error Handler: Example and Test ',' ',
	265	'cppad_assert CppAD Assertions During Execution ',' error macro syntax purpose ndebug restriction known cppad_assert_known unknown cppad_assert_unknown exp msg handler ',
	266	'NearEqual Determine if Two Values Are Nearly Equal ',' absolute difference relative syntax purpose type include files example exercise ',
	267	'near_equal.cpp NearEqual Function: Example and Test ',' file name ',
	268	'speed_test Run One Speed Test and Return Results ',' syntax purpose motivation include vector size repeat size_vec time_min rate_vec timing example ',
	269	'SpeedTest Run One Speed Test and Print Results ',' syntax purpose motivation include size repeat name first last rate errors example ',
	270	'speed_test.cpp speed_test: Example and test ',' ',
	271	'speed_program.cpp Example Use of SpeedTest ',' running this output ',
	272	'time_test Determine Amount of Time to Execute a Test ',' speed syntax purpose motivation include size repeat time_min test_size timing example ',
	273	'elapsed_seconds Returns Elapsed Number of Seconds ',' time syntax purpose microsoft systems example ',
	274	'elapsed_seconds.cpp Elapsed Seconds: Example and Test ',' timer ',
	275	'time_test.cpp time_test: Example and test ',' ',
	276	'NumericType Definition of a Numeric Type ',' requirements default constructor from integer copy assignment operators example exercise ',
	277	'numeric_type.cpp The NumericType: Example and Test ',' ',
	278	'CheckNumericType Check NumericType Class Concept ',' syntax purpose include parallel mode example ',
	279	'check_numeric_type.cpp The CheckNumericType Function: Example and Test ',' ',
	280	'SimpleVector Definition of a Simple Vector ',' class template requirements elements specified type default constructor sizing size copy and destructor assignment resize value value_type access [] using example exercise ndebug ',
	281	'simple_vector.cpp Simple Vector Template Class: Example and Test ',' ',
	282	'CheckSimpleVector Check Simple Vector Concept ',' syntax purpose restrictions include parallel mode example ',
	283	'check_simple_vector.cpp The CheckSimpleVector Function: Example and Test ',' ',
	284	'nan Obtain Nan or Determine if a Value is Nan ',' isnan hasnan syntax purpose include macros z scalar vector example ',
	285	'nan.cpp nan: Example and Test ',' ',
	286	'pow_int The Integer Power Function ',' exponent syntax see also purpose include z type operation sequence example ',
	287	'pow_int.cpp The Pow Integer Exponent: Example and Test ',' ',
	288	'Poly Evaluate a Polynomial or its Derivative ',' template syntax description include k z type operations vector sequence example source ',
	289	'poly.cpp Polynomial Evaluation: Example and Test ',' ',
	290	'poly.hpp Source: Poly ',' ',
	291	'LuDetAndSolve Compute Determinants and Solve Equations by LU Factorization ',' matrix linear ',
	292	'LuSolve Compute Determinant and Solve Linear Equations ',' syntax description include factor invert matrix storage signdet b logdet float floatvector leqzero absgeq example source ',
	293	'lu_solve.cpp LuSolve With Complex Arguments: Example and Test ',' ',
	294	'lu_solve.hpp Source: LuSolve ',' ',
	295	'LuFactor LU Factorization of A Square Matrix ',' linear equation determinant solve syntax description include storage sign jp sizevector floatvector absgeq example source ',
	296	'lu_factor.cpp LuFactor: Example and Test ',' ',
	297	'lu_factor.hpp Source: LuFactor ',' ',
	298	'LuInvert Invert an LU Factored Equation ',' linear syntax description include matrix storage jp example source ',
	299	'lu_invert.cpp LuInvert: Example and Test ',' ',
	300	'lu_invert.hpp Source: LuInvert ',' ',
	301	'RombergOne One DimensionalRomberg Integration ',' integrate syntax description include f float example source code ',
	302	'romberg_one.cpp One Dimensional Romberg Integration: Example and Test ',' ',
	303	'RombergMul Multi-dimensional Romberg Integration ',' integrate syntax description include f float floatvector example source code ',
	304	'Rombergmul.cpp One Dimensional Romberg Integration: Example and Test ',' ',
	305	'Runge45 An Embedded 4th and 5th Order Runge-Kutta ODE Solver ',' differential equation syntax purpose operation sequence include xf fun warning tf xi scalar fabs vector parallel mode example source code ',
	306	'runge45_1.cpp Runge45: Example and Test ',' ',
	307	'runge45_2.cpp Runge45: Example and Test ',' ',
	308	'Rosen34 A 3rd and 4th Order Rosenbrock ODE Solver ',' stiff differential equation syntax description include xf fun f_t f_x nan warning optimization tf xi scalar vector parallel mode example source code ',
	309	'rosen_34.cpp Rosen34: Example and Test ',' ',
	310	'OdeErrControl An Error Controller for ODE Solvers ',' differential equation syntax description include notation xf method step nan order tf xi smin smax scur eabs erel ef maxabs nstep criteria discussion scalar vector example theory source code ',
	311	'ode_err_control.cpp OdeErrControl: Example and Test ',' nan ',
	312	'ode_err_maxabs.cpp OdeErrControl: Example and Test Using Maxabs Argument ',' ',
	313	'OdeGear An Arbitrary Order Gear Method ',' stiff differential equation syntax purpose include fun f_x warning scalar vector example source code theory gear\'s ',
	314	'ode_gear.cpp OdeGear: Example and Test ',' ',
	315	'OdeGearControl An Error Controller for Gear\'s Ode Solvers ',' differential equation syntax purpose include notation xf fun f_x warning m tf xi smin smax sini eabs erel ef maxabs nstep criteria discussion scalar vector example theory source code ',
	316	'ode_gear_control.cpp OdeGearControl: Example and Test ',' ',
	317	'CppAD_vector The CppAD::vector Template Class ',' syntax description include capacity assignment check size return reference move semantics element access [] push_back push_vector output resize clear data vectorbool memory type and parallel mode thread_alloc example exercise ',
	318	'cppad_vector.cpp CppAD::vector Template Class: Example and Test ',' ',
	319	'vector_bool.cpp CppAD::vectorBool Class: Example and Test ',' ',
	320	'thread_alloc A Fast Multi-Threading Memory Allocator ',' allocation syntax purpose include ',
	321	'thread_alloc.cpp Fast Multi-Threading Memory Allocator: Example and Test ',' openmp allocation pthread boost ',
	322	'ta_parallel_setup Setup thread_alloc For Use in Multi-Threading Environment ',' num_threads in_parallel thread_num initialize syntax purpose speed restrictions example ',
	323	'ta_num_threads Get Number of Threads ',' thread_alloc syntax purpose example ',
	324	'ta_in_parallel Is The Current Execution in Parallel Mode ',' thread_alloc sequential syntax purpose flag example ',
	325	'ta_thread_num Get the Current Thread Number ',' thread_alloc syntax purpose example ',
	326	'ta_get_memory Get At Least A Specified Amount of Memory ',' thread_num thread_alloc allocate syntax purpose min_bytes cap_bytes v_ptr allocation speed alignment example ',
	327	'ta_return_memory Return Memory to thread_alloc ',' available syntax purpose v_ptr ndebug example ',
	328	'ta_free_available Free Memory Currently Available for Quick Use by a Thread ',' thread_alloc syntax purpose extra example ',
	329	'ta_hold_memory Control When Thread Alloc Retains Memory For Future Use ',' thread_alloc syntax purpose value free_available ',
	330	'ta_inuse Amount of Memory a Thread is Currently Using ',' thread_alloc syntax purpose num_bytes example ',
	331	'ta_available Amount of Memory Available for Quick Use by a Thread ',' thread_alloc syntax purpose num_bytes example ',
	332	'ta_create_array Allocate An Array and Call Default Constructor for its Elements ',' thread_alloc syntax purpose type size_min size_out delta alignment example ',
	333	'ta_delete_array Deallocate An Array and Call Destructor for its Elements ',' thread_alloc syntax purpose type delta example ',
	334	'ta_free_all Free All Memory That Was Allocated for Use by thread_alloc ',' syntax purpose ok restrictions example ',
	335	'index_sort Returns Indices that Sort a Vector ',' syntax keys example ',
	336	'index_sort.cpp Index Sort: Example and Test ',' ',
	337	'BenderQuad Computing Jacobian and Hessian of Bender\'s Reduced Objective ',' syntax see also problem purpose fun fun.f fun.h fun.dy gx gxx bavector advector example ',
	338	'bender_quad.cpp BenderQuad: Example and Test ',' ',
	339	'opt_val_hes Jacobian and Hessian of Optimal Values ',' syntax see also reference purpose basevector fun fun::ad_vector fun.ell fun.s fun.sy signdet example ',
	340	'opt_val_hes.cpp opt_val_hes: Example and Test ',' ',
	341	'LuRatio LU Factorization of A Square Matrix and Stability Calculation ',' linear equation determinant solve syntax description include storage sign jp purpose sizevector advector example ',
	342	'lu_ratio.cpp LuRatio: Example and Test ',' ',
	343	'ipopt_solve Use Ipopt to Solve a Nonlinear Programming Problem ',' syntax purpose include file bvector dvector options retape sparse string numeric integer xi xl xu gl gu fg_eval advector solution status zl zu lambda obj_value example get_started ode_inverse ',
	344	'ipopt_solve_get_started.cpp Nonlinear Programming Using CppAD and Ipopt: Example and Test ',' purpose configuration requirement ',
	345	'ipopt_solve_retape.cpp Nonlinear Programming Retaping: Example and Test ',' purpose ',
	346	'ipopt_solve_ode_inverse.cpp ODE Inverse Problem Definitions: Source Code ',' example purpose forward measurements simulation analytic solution parameter values simulated trapezoidal approximation method ',
	347	'Example Examples ',' introduction running the cppad test vector template class ',
	348	'General General Examples ',' realistic description ',
	349	'ExampleUtility Utility Routines used by CppAD Examples ',' ',
	350	'ListAllExamples List of All the CppAD Examples ',' ',
	351	'ad_fun.cpp Creating Your Own Interface to an ADFun Object ',' example test ',
	352	'ad_in_c.cpp Example and Test Linking CppAD to Languages Other than C++ ',' algorithmic differentiation automatic ',
	353	'conj_grad.cpp Differentiate Conjugate Gradient Algorithm: Example and Test ',' purpose ',
	354	'cppad_eigen.hpp Enable Use of Eigen Linear Algebra Package with CppAD ',' syntax purpose example include files numtraits namespace ',
	355	'eigen_plugin.hpp Source Code for eigen_plugin.hpp ',' ',
	356	'eigen_array.cpp Using Eigen Arrays: Example and Test ',' ',
	357	'eigen_det.cpp Using Eigen To Compute Determinant: Example and Test ',' ',
	358	'hes_minor_det.cpp Gradient of Determinant Using Expansion by Minors: Example and Test ',' ',
	359	'hes_lu_det.cpp Gradient of Determinant Using LU Factorization: Example and Test ',' ',
	360	'interface2c.cpp Interfacing to C: Example and Test ',' difference central ',
	361	'jac_minor_det.cpp Gradient of Determinant Using Expansion by Minors: Example and Test ',' ',
	362	'jac_lu_det.cpp Gradient of Determinant Using Lu Factorization: Example and Test ',' ',
	363	'mul_level Using Multiple Levels of AD ',' background motivation general solution procedure start adbasetape addbasetape inner function calculations derivative outer example ',
	364	'mul_level.cpp Multiple Tapes: Example and Test ',' ad purpose ',
	365	'change_const.cpp Computing a Jacobian With Constants that Change ',' multiple ad level purpose ',
	366	'ode_stiff.cpp A Stiff Ode: Example and Test ',' ',
	367	'mul_level_ode.cpp Taylor\'s Ode Solver: An Example and Test ',' purpose solution derivative of method using ad ',
	368	'mul_level_adolc_ode.cpp Using Adolc with Taylor\'s Ode Solver: An Example and Test ',' purpose solution derivative of method base_adolc.hpp memory management configuration requirement ',
	369	'ode_taylor.cpp Taylor\'s Ode Solver: An Example and Test ',' purpose solution forward mode ',
	370	'stack_machine.cpp Example Differentiating a Stack Machine Interpreter ',' test ',
	371	'example.cpp CppAD Examples and Tests ',' running ',
	372	'speed_example.cpp Run the Speed Examples ',' program running tests ',
	373	'lu_vec_ad.cpp Lu Factor and Solve with Recorded Pivoting ',' luvecad linear equation determinant syntax purpose storage convention matrix rhs result logdet example ',
	374	'lu_vec_ad_ok.cpp Lu Factor and Solve With Recorded Pivoting: Example and Test ',' ',
	375	'testvector Using The CppAD Test Vector Template Class ',' cppad_testvector syntax introduction cppad::vector std::vector boost::numeric::ublas::vector eigen vectors ',
	376	'speed Speed Test an Operator Overloading AD Package ',' purpose ',
	377	'speed_main Running the Speed Test Program ',' cppad syntax purpose package double profile correct seed uniform_01 option_list onetape optimize atomic memory sparsity options boolsparsity colpack correctness results sparse_jacobian link functions ',
	378	'link_det_lu Speed Testing Gradient of Determinant Using Lu Factorization ',' prototype purpose method return value size repeat matrix double ',
	379	'link_det_minor Speed Testing Gradient of Determinant by Minor Expansion ',' prototype purpose method return value size repeat matrix double ',
	380	'link_mat_mul Speed Testing Derivative of Matrix Multiply ',' multiple prototype purpose return value repeat z dz ',
	381	'link_ode Speed Testing the Jacobian of Ode Solution ',' prototype purpose method return value size repeat x double ',
	382	'link_poly Speed Testing Second Derivative of a Polynomial ',' prototype purpose method return value size repeat ddp double ',
	383	'link_sparse_hessian Speed Testing Sparse Hessian ',' prototype method size repeat x row col double ',
	384	'link_sparse_jacobian Speed Testing Sparse Jacobian ',' prototype method size repeat row col x n_sweep double ',
	385	'microsoft_timer Microsoft Version of Elapsed Number of Seconds ',' syntax purpose linking ',
	386	'speed_utility Speed Testing Utilities ',' main program routines library source code ',
	387	'det_by_lu Determinant Using Expansion by Lu Factorization ',' syntax inclusion constructor scalar vector example source code ',
	388	'det_by_lu.cpp Determinant Using Lu Factorization: Example and Test ',' minors ',
	389	'det_by_lu.hpp Source: det_by_lu ',' ',
	390	'det_of_minor Determinant of a Minor ',' matrix syntax inclusion purpose scalar example source code ',
	391	'det_of_minor.cpp Determinant of a Minor: Example and Test ',' ',
	392	'det_of_minor.hpp Source: det_of_minor ',' ',
	393	'det_by_minor Determinant Using Expansion by Minors ',' syntax inclusion constructor scalar vector example source code ',
	394	'det_by_minor.cpp Determinant Using Expansion by Minors: Example and Test ',' ',
	395	'det_by_minor.hpp Source: det_by_minor ',' ',
	396	'det_33 Check Determinant of 3 by 3 matrix ',' correct syntax purpose inclusion vector ok source code ',
	397	'det_33.hpp Source: det_33 ',' ',
	398	'det_grad_33 Check Gradient of Determinant of 3 by 3 matrix ',' correct syntax purpose inclusion vector ok source code ',
	399	'det_grad_33.hpp Source: det_grad_33 ',' ',
	400	'mat_sum_sq Sum Elements of a Matrix Times Itself ',' multiply speed test syntax purpose inclusion z vector example source code ',
	401	'mat_sum_sq.cpp Sum of the Elements of the Square of a Matrix: Example and Test ',' ',
	402	'mat_sum_sq.hpp Source: mat_sum_sq ',' ',
	403	'ode_evaluate Evaluate a Function Defined in Terms of an ODE ',' syntax purpose inclusion float operation sequence fabs == 0 1 fp gradient example source code ',
	404	'ode_evaluate.cpp ode_evaluate: Example and test ',' ',
	405	'ode_evaluate.hpp Source: ode_evaluate ',' ',
	406	'sparse_jac_fun Evaluate a Function That Has a Sparse Jacobian ',' syntax purpose inclusion float floatvector m row col fp example source code ',
	407	'sparse_jac_fun.cpp sparse_jac_fun: Example and test ',' ',
	408	'sparse_jac_fun.hpp Source: sparse_jac_fun ',' ',
	409	'sparse_hes_fun Evaluate a Function That Has a Sparse Hessian ',' syntax purpose inclusion float floatvector row col fp gradient example source code ',
	410	'sparse_hes_fun.cpp sparse_hes_fun: Example and test ',' ',
	411	'sparse_hes_fun.hpp Source: sparse_hes_fun ',' ',
	412	'uniform_01 Simulate a [0,1] Uniform Random Variate ',' [01] vector syntax purpose inclusion seed source code ',
	413	'uniform_01.hpp Source: uniform_01 ',' ',
	414	'speed_double Speed Test of Functions in Double ',' purpose running tests ',
	415	'double_det_minor.cpp Double Speed: Determinant by Minor Expansion ',' link_det_minor specifications implementation ',
	416	'double_det_lu.cpp Double Speed: Determinant Using Lu Factorization ',' link_det_lu matrix specifications implementation ',
	417	'double_mat_mul.cpp CppAD Speed: Matrix Multiplication (Double Version) ',' multiply specifications implementation link_mat_mul ',
	418	'double_ode.cpp Double Speed: Ode Solution ',' link_ode specifications implementation ',
	419	'double_poly.cpp Double Speed: Evaluate a Polynomial ',' link_poly specifications implementation ',
	420	'double_sparse_hessian.cpp Double Speed: Sparse Hessian ',' link_sparse_hessian specifications implementation ',
	421	'double_sparse_jacobian.cpp Double Speed: Sparse Jacobian ',' link_sparse_jacobian specifications implementation ',
	422	'speed_adolc Speed Test of Derivatives Using Adolc ',' purpose adolc_prefix running tests ',
	423	'adolc_det_minor.cpp Adolc Speed: Gradient of Determinant by Minor Expansion ',' link_det_minor specifications implementation ',
	424	'adolc_det_lu.cpp Adolc Speed: Gradient of Determinant Using Lu Factorization ',' link_det_lu matrix specifications implementation ',
	425	'adolc_mat_mul.cpp Adolc Speed: Matrix Multiplication ',' link_mat_mul multiply specifications implementation ',
	426	'adolc_ode.cpp Adolc Speed: Ode ',' link_ode specifications implementation ',
	427	'adolc_poly.cpp Adolc Speed: Second Derivative of a Polynomial ',' link_poly specifications implementation ',
	428	'adolc_sparse_hessian.cpp Adolc Speed: Sparse Hessian ',' link_sparse_hessian specifications implementation ',
	429	'adolc_sparse_jacobian.cpp adolc Speed: Sparse Jacobian ',' link_sparse_jacobian specifications implementation ',
	430	'adolc_alloc_mat Adolc Test Utility: Allocate and Free Memory For a Matrix ',' syntax purpose ',
	431	'speed_cppad Speed Test Derivatives Using CppAD ',' purpose running tests ',
	432	'cppad_det_minor.cpp CppAD Speed: Gradient of Determinant by Minor Expansion ',' link_det_minor specifications implementation ',
	433	'cppad_det_lu.cpp CppAD Speed: Gradient of Determinant Using Lu Factorization ',' link_det_lu matrix specifications implementation ',
	434	'cppad_mat_mul.cpp CppAD Speed: Matrix Multiplication ',' link_mat_mul multiply specifications implementation ',
	435	'cppad_ode.cpp CppAD Speed: Gradient of Ode Solution ',' link_ode specifications implementation ',
	436	'cppad_poly.cpp CppAD Speed: Second Derivative of a Polynomial ',' link_poly specifications implementation ',
	437	'cppad_sparse_hessian.cpp CppAD Speed: Sparse Hessian ',' link_sparse_hessian specifications implementation ',
	438	'cppad_sparse_jacobian.cpp CppAD Speed: Sparse Jacobian ',' link_sparse_jacobian specifications implementation ',
	439	'speed_fadbad Speed Test Derivatives Using Fadbad ',' purpose fadbad_prefix running tests ',
	440	'fadbad_det_minor.cpp Fadbad Speed: Gradient of Determinant by Minor Expansion ',' link_det_minor specifications implementation ',
	441	'fadbad_det_lu.cpp Fadbad Speed: Gradient of Determinant Using Lu Factorization ',' link_det_lu matrix specifications implementation ',
	442	'fadbad_mat_mul.cpp Fadbad Speed: Matrix Multiplication ',' link_mat_mul multiply specifications implementation ',
	443	'fadbad_ode.cpp Fadbad Speed: Ode ',' link_ode specifications implementation ',
	444	'fadbad_poly.cpp Fadbad Speed: Second Derivative of a Polynomial ',' link_poly specifications implementation ',
	445	'fadbad_sparse_hessian.cpp Fadbad Speed: Sparse Hessian ',' ',
	446	'fadbad_sparse_jacobian.cpp fadbad Speed: sparse_jacobian ',' ',
	447	'speed_sacado Speed Test Derivatives Using Sacado ',' purpose sacado_prefix running tests ',
	448	'sacado_det_minor.cpp Sacado Speed: Gradient of Determinant by Minor Expansion ',' link_det_minor specifications implementation ',
	449	'sacado_det_lu.cpp Sacado Speed: Gradient of Determinant Using Lu Factorization ',' link_det_lu matrix specifications implementation ',
	450	'sacado_mat_mul.cpp Sacado Speed: Matrix Multiplication ',' link_mat_mul multiply specifications implementation ',
	451	'sacado_ode.cpp Sacado Speed: Gradient of Ode Solution ',' link_ode specifications implementation ',
	452	'sacado_poly.cpp Sacado Speed: Second Derivative of a Polynomial ',' link_poly specifications implementation ',
	453	'sacado_sparse_hessian.cpp Sacado Speed: Sparse Hessian ',' ',
	454	'sacado_sparse_jacobian.cpp sacado Speed: sparse_jacobian ',' ',
	455	'Appendix Appendix ',' ',
	456	'Faq Frequently Asked Questions and Answers ',' assignment independent operator bugs reporting comparechange ndebug complex types exceptions test errorhandler variables tape avoid record speed taping math functions matrix inverse mode: forward reverse namespace vector preprocessor symbol cppad_testvector symbols using standard optimize memory allocation storage: disk ',
	457	'Theory The Theory of Derivative Calculations ',' ',
	458	'ForwardTheory The Theory of Forward Mode ',' taylor notation binary operators addition subtraction multiplication division standard math functions differential equation coefficients recursion formula cases that apply above special ',
	459	'ExpForward Exponential Function Forward Taylor Polynomial Theory ',' ',
	460	'LogForward Logarithm Function Forward Taylor Polynomial Theory ',' ',
	461	'SqrtForward Square Root Function Forward Taylor Polynomial Theory ',' ',
	462	'SinCosForward Trigonometric and Hyperbolic Sine and Cosine Forward Theory ',' sinh cosh differential equation ',
	463	'AtanForward Arctangent Function Forward Taylor Polynomial Theory ',' ',
	464	'AsinForward Arcsine Function Forward Taylor Polynomial Theory ',' ',
	465	'AcosForward Arccosine Function Forward Taylor Polynomial Theory ',' ',
	466	'tan_forward Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory ',' derivatives coefficients recursion ',
	467	'erf_forward Error Function Forward Taylor Polynomial Theory ',' derivatives coefficients recursion ',
	468	'ReverseTheory The Theory of Reverse Mode ',' taylor notation binary operators addition subtraction multiplication division standard math functions ',
	469	'ExpReverse Exponential Function Reverse Mode Theory ',' ',
	470	'LogReverse Logarithm Function Reverse Mode Theory ',' ',
	471	'SqrtReverse Square Root Function Reverse Mode Theory ',' ',
	472	'SinCosReverse Trigonometric and Hyperbolic Sine and Cosine Reverse Theory ',' sinh cosh ',
	473	'AtanReverse Arctangent Function Reverse Mode Theory ',' ',
	474	'AsinReverse Arcsine Function Reverse Mode Theory ',' ',
	475	'AcosReverse Arccosine Function Reverse Mode Theory ',' ',
	476	'tan_reverse Tangent and Hyperbolic Tangent Reverse Mode Theory ',' notation eliminating y(t) positive orders z(t) zero ',
	477	'erf_reverse Error Function Reverse Mode Theory ',' notation positive orders z(t) zero ',
	478	'reverse_identity An Important Reverse Mode Identity ',' notation sweep theorem proof ',
	479	'glossary Glossary ',' ad function of base levels above type elementary vector operation atomic sequence dependent independent parameter sparsity pattern efficient boolean sets tape active inactive variable variables taylor coefficient ',
	480	'Bib Bibliography ',' abramowitz and stegun the c++ programming language evaluating derivatives numerical recipes shampine l.f. ',
	481	'Bugs Know Bugs and Problems Using CppAD ',' gcc 3.4.4 -o2 example adolc ',
	482	'WishList The CppAD Wish List ',' new features adolc atan2 benderquad checkpointing conditional expressions nesting sparsity forward mode recomputation iterator interface library compile speed ad<double> multiple directions numeric limits testing machine epsilon operation sequence optimization optimize tape hashing variable pairs preprocessor symbols software guidelines boost tracing ',
	483	'whats_new Changes and Additions to CppAD ',' introduction this year previous years ',
	484	'whats_new_14 CppAD Changes and Additions During 2014 ',' introduction 12-27 12-26 12-25 12-23 12-22 12-17 12-16 12-15 11-28 11-27 09-28 09-27 09-25 09-21 05-28 05-27 05-23 05-22 05-20 05-19 05-16 05-14 03-18 03-17 03-09 03-05 03-02 03-01 02-28 02-27 02-26 02-23 02-22 02-17 02-15 01-26 01-21 01-10 ',
	485	'whats_new_13 CppAD Changes and Additions During 2013 ',' introduction 12-29 12-27 12-26 12-24 11-27 11-13 11-12 10-29 10-23 10-22 10-16 10-15 10-14 10-13 10-12 09-20 09-19 09-18 09-07 08-12 08-11 08-06 07-26 05-28 05-21 05-17 05-15 05-14 05-12 05-11 05-04 04-28 04-27 04-26 ',
	486	'whats_new_12 CppAD Changes and Additions During 2012 ',' introduction 12-30 12-29 12-28 12-27 12-26 12-23 12-22 12-20 12-19 12-17 12-15 12-14 12-13 11-28 11-21 11-20 11-17 11-16 11-14 11-09 11-06 11-04 10-31 10-30 10-25 10-24 10-12 10-04 10-03 10-02 09-24 09-11 08-05 07-30 07-08 07-07 07-05 07-04 07-03 07-02 07-01 06-17 06-16 06-15 06-12 06-10 06-09 06-08 06-07 06-05 06-04 06-03 06-02 06-01 05-31 05-30 05-29 05-27 05-24 04-19 04-18 04-17 04-10 04-06 04-05 04-01 03-27 03-26 03-23 03-21 03-17 03-11 03-03 03-02 02-11 02-10 02-09 01-30 01-27 01-24 01-23 01-20 01-19 01-16 01-15 01-12 01-07 01-02 ',
	487	'whats_new_11 Changes and Additions to CppAD During 2011 ',' introduction 12-30 12-28 12-21 12-20 11-29 11-27 11-24 11-21 11-20 11-18 11-17 11-09 11-07 11-06 11-04 11-01 10-30 10-29 10-14 10-12 09-06 09-05 09-02 09-01 08-31 08-30 08-25 08-23 08-21 08-11 08-10 08-09 08-08 08-07 08-06 08-04 08-03 08-02 07-31 07-29 07-28 07-27 07-25 07-18 07-17 07-14 07-13 07-11 openmp/run.sh 07-10 07-09 07-07 06-23 06-21 06-18 05-29 05-28 05-26 05-22 05-11 05-03 04-29 04-20 04-19 03-19 03-11 03-05 02-22 02-19 02-17 02-15 02-09 02-06 02-02 02-01 01-19 01-16 01-09 ',
	488	'whats_new_10 Changes and Additions to CppAD During 2010 ',' introduction 12-31 11-27 09-26 09-22 08-21 07-14 07-11 06-01 04-28 04-26 04-24 04-01 03-11 03-10 03-09 03-03 02-11 02-08 02-06 02-05 02-03 01-26 01-24 01-23 01-20 01-18 01-04 ',
	489	'whats_new_09 Changes and Additions to CppAD During 2009 ',' introduction 12-23 12-22 12-18 12-12 12-04 12-02 11-28 11-27 11-26 10-30 10-29 10-28 10-27 10-24 10-23 10-21 10-16 10-14 10-03 09-30 09-29 09-28 09-26 09-20 09-19 09-18 08-25 08-14 08_13 08-13 08-11 08-10 08-09 08-06 08-02 08-01 07-31 07-26 07-25 07-24 07-23 07-06 07-04 07-03 07-02 07-01 06-30 06-29 06-28 06-25 06-22 06-21 06-20 06-06 05-20 03-24 02-20 02-15 02-01 01-31 01-18 01-06 ',
	490	'whats_new_08 Changes and Additions to CppAD During 2008 ',' introduction 12-19 12-14 12-04 11-22 11-21 11-20 erf 10-27 10-17 10-16 09-30 09-26 09-18 09-17 09-16 09-12 09-10 09-09 09-07 09-06 09-05 09-04 09-03 09-01 08-29 ipopt_cppad_nlp 08-19 08-08 07-02 06-18 06-15 06-11 06-10 05-08 05-03 04-20 04-18 04-10 04-06 04-04 03-27 02-05 02-03 01-26 01-24 01-21 01-20 01-11 01-08 ',
	491	'whats_new_07 Changes and Additions to CppAD During 2007 ',' introduction 12-29 12-25 12-21 12-08 12-05 12-04 12-03 12-02 11-29 11-23 11-18 11-06 11-05 11-04 11-03 11-02 11-01 10-30 10-27 10-23 10-22 10-16 10-13 10-05 10-02 09-06 08-09 08-07 07-30 07-29 07-28 07-26 07-25 07-23 07-22 07-21 07-20 07-19 07-18 07-14 07-13 06-22 06-20 06-14 05-26 05-25 05-24 05-22 05-08 05-05 04-19 04-17 04-14 04-11 04-10 04-07 04-06 04-05 03-31 03-30 03-29 03-20 03-15 03-14 03-13 03-09 03-28 02-27 02-22 02-17 02-16 02-15 02-06 02-04 02-03 02-02 02-01 01-29 ',
	492	'whats_new_06 Changes and Additions to CppAD During 2006 ',' introduction 12-24 12-23 12-22 12-21 12-19 12-18 12-17 12-15 12-13 12-12 12-11 12-10 12-09 12-07 12-05 12-03 12-02 12-01 11-30 11-29 11-28 11-23 11-18 11-12 11-08 11-06 11-05 11-04 11-02 11-01 10-31 10-29 10-28 10-27 10-26 10-25 10-18 10-16 10-10 09-30 08-17 07-14 07-12 06-29 06-22 06-19 06-17 06-18 06-15 06-09 06-07 06-05 06-02 05-31 05-29 05-27 05-03 04-29 04-28 04-26 04-25 04-19 04-18 04-17 04-15 04-14 04-13 04-08 04-06 04-05 04-04 04-03 04-02 04-01 03-31 03-30 03-29 03-28 03-27 03-26 03-24 03-23 03-22 03-18 03-17 03-16 03-15 03-11 03-10 03-09 03-07 03-05 02-28 02-25 02-24 02-23 02-21 02-15 02-14 02-13 02-11 02-10 02-04 01-20 01-18 01-08 aclocal 01-07 01-02 01-05 ',
	493	'whats_new_05 Changes and Additions to CppAD During 2005 ',' 12-24 12-23 12-22 12-20 12-19 12-16 12-15 12-14 12-11 12-08 12-07 12-06 12-05 12-03 12-02 12-01 11-23 11-22 11-20 11-19 11-15 11-12 11-09 11-07 11-06 11-01 10-20 10-18 10-14 10-12 10-06 09-29 09-27 09-24 09-20 09-14 09-09 09-07 08-30 08-24 08-20 08-19 08-15 08-14 08-13 08-07 07-21 07-19 07-15 07-11 07-08 07-05 07-04 07-03 07-02 07-01 06-25 06-24 06-18 06-14 06-13 06-06 05-19 05-18 05-16 05-12 05-06 05-01 04-21 04-20 04-19 03-26 03-23 03-22 03-09 03-04 03-01 02-24 01-08 ',
	494	'whats_new_04 Changes and Additions to CppAD During 2004 ',' introduction 12-11 12-09 12-03 11-17 11-16 11-15 11-14 11-13 11-12 11-10 11-04 11-02 11-01 10-29 10-28 10-27 10-21 10-19 10-16 10-06 09-29 09-26 09-23 09-21 09-13 09-10 09-09 09-07 09-04 09-02 08-27 08-25 08-24 08-12 07-31 07-08 07-07 07-03 07-02 06-29 06-25 06-12 06-04 06-03 06-01 05-30 05-29 05-26 05-25 05-14 05-12 05-09 05-07 05-04 05-03 04-29 04-28 04-25 04-24 04-22 04-21 04-20 04-19 04-09 04-08 04-07 04-03 04-02 04-01 03-30 03-28 03-25 03-18 03-17 03-15 03-12 03-11 03-09 03-07 03-06 03-05 03-04 03-03 03-01 02-29 02-28 02-21 02-20 02-17 02-16 02-15 02-12 02-01 01-29 01-28 01-22 ',
	495	'whats_new_03 Changes and Additions to CppAD During 2003 ',' introduction 12-24 12-22 12-14 12-13 12-12 12-10 12-05 12-01 11-21 11-20 11-16 11-15 11-14 11-12 11-11 11-06 11-04 11-02 10-21 10-16 10-14 10-10 10-06 10-05 09-30 09-20 09-19 09-18 09-15 09-14 09-13 09-06 09-05 09-04 09-03 08-23 08-22 08-19 08-17 08-16 08-11 08-10 08-07 08-06 08-05 08-04 08-03 08-01 07-30 07-29 07-26 07-22 07-20 07-18 07-16 07-14 ',
	496	'deprecated CppAD Deprecated API Features ',' ',
	497	'include_deprecated Deprecated Include Files ',' purpose linking new to commands ',
	498	'FunDeprecated ADFun Object Deprecated Member Functions ',' syntax purpose dependent order memory size taylor_size use_vecad size_taylor capacity_taylor ',
	499	'omp_max_thread OpenMP Parallel Setup ',' deprecated depreciated syntax purpose number independent restriction ',
	500	'TrackNewDel Routines That Track Use of New and Delete ',' memory deprecated syntax purpose include file line oldptr newlen head newptr ncopy tracknewvec ndebug macro cppad_track_new_vec previously cppadtracknewvec trackdelvec cppad_track_del_vec cppadtrackdelvec trackextend cppad_track_extend cppadtrackextend trackcount cppad_track_count multi-threading example ',
	501	'TrackNewDel.cpp Tracking Use of New and Delete: Example and Test ',' ',
	502	'omp_alloc A Quick OpenMP Memory Allocator Used by CppAD ',' multi-threading allocation syntax purpose include ',
	503	'omp_max_num_threads Set and Get Maximum Number of Threads for omp_alloc Allocator ',' deprecated set_max_num_threads get_max_num_threads syntax purpose restrictions ',
	504	'omp_in_parallel Is The Current Execution in OpenMP Parallel Mode ',' deprecated omp_alloc syntax purpose flag example ',
	505	'omp_get_thread_num Get the Current OpenMP Thread Number ',' deprecated omp_alloc syntax purpose example ',
	506	'omp_get_memory Get At Least A Specified Amount of Memory ',' deprecated get_thread_num omp_alloc syntax purpose min_bytes cap_bytes v_ptr allocation speed example ',
	507	'omp_return_memory Return Memory to omp_alloc ',' deprecated syntax purpose v_ptr thread ndebug example ',
	508	'omp_free_available Free Memory Currently Available for Quick Use by a Thread ',' deprecated omp_alloc syntax purpose example ',
	509	'omp_inuse Amount of Memory a Thread is Currently Using ',' deprecated omp_alloc syntax purpose num_bytes example ',
	510	'omp_available Amount of Memory Available for Quick Use by a Thread ',' deprecated omp_alloc syntax purpose num_bytes example ',
	511	'omp_create_array Allocate Memory and Create A Raw Array ',' deprecated omp_alloc syntax purpose type size_min size_out delta example ',
	512	'omp_delete_array Return A Raw Array to The Available Memory for a Thread ',' deprecated omp_alloc syntax purpose type delta example ',
	513	'omp_efficient Check If A Memory Allocation is Efficient for Another Use ',' removed omp_alloc syntax purpose v_ptr num_bytes flag thread ndebug ',
	514	'old_max_num_threads Set Maximum Number of Threads for omp_alloc Allocator ',' removed syntax purpose restrictions ',
	515	'omp_alloc.cpp OpenMP Memory Allocator: Example and Test ',' allocation multi-thread deprecated ',
	516	'memory_leak Memory Leak Detection ',' check static deprecated syntax purpose thread add_static flag inuse available track_count error message ',
	517	'epsilon Machine Epsilon For AD Types ',' deprecated syntax purpose float ',
	518	'test_vector Choosing The Vector Testing Template Class ',' cppad_test_vector deprecated syntax introduction ms windows cppad::vector std::vector boost::numeric::ublas::vector cppadvector ',
	519	'cppad_ipopt_nlp Nonlinear Programming Using the CppAD Interface to Ipopt ',' deprecated syntax purpose namespace ipopt_library_paths fg(x) index vector projection injection representation simple sizevector numbervector adnumber advector x_i x_l x_u g_l g_u fg_info fg_info.number_functions fg_info.eval_r fg_info.retape fg_info.domain_size fg_info.range_size fg_info.number_terms fg_info.index solution status z_l z_u lambda obj_value example wish list ',
	520	'ipopt_nlp_get_started.cpp Nonlinear Programming Using CppAD and Ipopt: Example and Test ',' purpose configuration requirement ',
	521	'ipopt_nlp_ode Example Simultaneous Solution of Forward and Inverse Problem ',' ',
	522	'ipopt_nlp_ode_problem An ODE Inverse Problem Example ',' notation forward measurements simulation analytic solution parameter values simulated trapezoidal approximation time grid black box method two levels of iteration derivatives simultaneous source ',
	523	'ipopt_nlp_ode_simple ODE Fitting Using Simple Representation ',' cppad_ipopt_nlp purpose argument vector objective function initial condition constraint trapezoidal approximation source ',
	524	'ipopt_nlp_ode_fast ODE Fitting Using Fast Representation ',' cppad_ipopt_nlp purpose objective function range indices i(k0) domain j(k0) initial condition trapezoidal approximation source ',
	525	'ipopt_nlp_ode_problem.hpp ODE Inverse Problem Definitions: Source Code ',' example ',
	526	'ipopt_nlp_ode_simple.hpp ODE Fitting Using Simple Representation ',' cppad_ipopt_nlp example source ',
	527	'ipopt_nlp_ode_fast.hpp ODE Fitting Using Fast Representation ',' cppad_ipopt_nlp example source ',
	528	'ipopt_nlp_ode_run.hpp Driver for Running the Ipopt ODE Example ',' ',
	529	'ipopt_nlp_ode_check.cpp Correctness Check for Both Simple and Fast Representations ',' ',
	530	'ipopt_ode_speed.cpp Speed Test for Both Simple and Fast Representations ',' ',
	531	'old_atomic User Defined Atomic AD Functions ',' cppad_user_atomic operation syntax callback routines free static memory purpose partial implementation tvector base ok id tx ty forward reverse afun ay parallel mode usage vx vy py px for_jac_sparse q rev_jac_sparse rev_hes_sparse clear restriction example simple tangent matrix multiplication ',
	532	'old_reciprocal.cpp Old Atomic Operation Reciprocal: Example and Test ',' user deprecated theory ',
	533	'old_usead_1.cpp Using AD to Compute Atomic Function Derivatives ',' inside user checkpoint deprecated purpose simple case ',
	534	'old_usead_2.cpp Using AD to Compute Atomic Function Derivatives ',' inside user checkpoint deprecated purpose ',
	535	'old_tan.cpp Tan and Tanh as User Atomic Operations: Example and Test ',' old_atomic deprecated theory ',
	536	'old_mat_mul.cpp Matrix Multiply as a User Atomic Operation: Example and Test ',' old_atomic deprecated include file ',
	537	'old_mat_mul.hpp Define Matrix Multiply as a User Atomic Operation ',' old_atomic test example syntax begin source extra call information indexing one reverse partials order set union cppad callback functions declare ',
	538	'compare_c Compare Speed of C and C++ ',' with syntax purpose ',
	539	'det_of_minor_c Determinant of a Minor ',' syntax purpose source code ',
	540	'det_by_minor_c Compute Determinant using Expansion by Minors ',' syntax purpose source code ',
	541	'uniform_01_c Simulate a [0,1] Uniform Random Variate ',' [01] syntax purpose seed source code ',
	542	'correct_det_by_minor_c Correctness Test of det_by_minor Routine ',' syntax flag source code ',
	543	'repeat_det_by_minor_c Repeat det_by_minor Routine A Specified Number of Times ',' syntax size source code ',
	544	'elapsed_seconds_c Returns Elapsed Number of Seconds ',' syntax purpose source code ',
	545	'time_det_by_minor_c Determine Amount of Time to Execute det_by_minor ',' syntax purpose time_min source code ',
	546	'main_compare_c Main Program For Comparing C and C++ Speed ',' source code ',
	547	'License Your License for the CppAD Software ',' '
540	548	]
541	549
542	550	var MaxList = 100;
543		var Choice = "";
544	551	var Nstring = -1;
545		var Nkeyword = Keyword.length;
	552	var Nkeyword = Keyword.length / 2;
546	553	Initialize();
547	554
548	555	function Initialize()
549	556	{
550		var i;
551		var line;
552		for(i = 0; (i < Nkeyword) && (i < MaxList) ; i++)
553		{
554		line = Keyword[i].split(/\s+/)
555		line[0] = line[0].toUpperCase();
556		line = line.join(" ");
557		Keyword[i] = line;
558		}
559	557	UpdateList();
560		document.search.string.focus();
	558	document.search.keywords.focus();
561	559	}
562	560	function UpdateList(event)
563	561	{

567	565	else if( event )
568	566	key = event.which;
569	567	if( key == 13 )
570		{ Choose();
	568	{ Goto();
571	569	return;
572	570	}
573		var string = document.search.string.value;
	571	var string = document.search.keywords.value;
574	572	if( Nstring == string.length )
575	573	return;
576	574	Nstring = string.length;

582	580
583	581	var pattern = new Array(nword);
584	582	for(var j = 0; j < nword; j++)
585		pattern[j] = new RegExp(word[j], "i");
	583	pattern[j] = new RegExp(word[j], 'i');
586	584
587	585	var nlist = 0;
588		var list = "";
589		Choice = "";
590
	586	var list = '';
591	587	for(i = 0; (i < Nkeyword) && (nlist < MaxList) ; i++)
592	588	{
593	589	var match = true;
594	590	for(j = 0; j < nword; j++)
595		match = match && pattern[j].test(Keyword[i]);
	591	{ var flag = pattern[j].test(Keyword[2*i]);
	592	flag = flag \|\| pattern[j].test(Keyword[2*i+1]);
	593	match = match && flag;
	594	}
596	595
597	596	if( match )
598	597	{
599		line = Keyword[i].split(/\s+/);
600
601		if( Choice == "" )
602		Choice = line[0];
603
604		line = line.join(" ");
605		list = list + line + "\n";
	598	line = Keyword[2*i].split(/\s+/);
	599	line = line.join(' ');
	600	list = list + line + '\n';
606	601	nlist = nlist + 1;
607	602	}
608	603	}
609		document.search.choice.value = Choice.toLowerCase();
610	604	document.search.list.value = list;
611	605	}
612		function Choose()
	606	function Choose(textarea)
	607	{ var start_select = textarea.value.substring(0, textarea.selectionStart);
	608	var start_pos = Math.max(0, start_select.lastIndexOf('\n') );
	609	var length = textarea.value.length;
	610	var end_select =
	611	textarea.value.substring(textarea.selectionEnd, length);
	612	var end_pos = end_select.indexOf('\n');
	613	if( end_pos >= 0 )
	614	{ end_pos = textarea.selectionEnd + end_pos;
	615	} else
	616	{ end_pos = length;
	617	}
	618	// highlight the selected line
	619	textarea.selectionStart = start_pos;
	620	textarea.selectionEnd = end_pos;
	621	// get the choice from the beginning of the line
	622	var line = textarea.value.substring(start_pos, length);
	623	var end_choice = line.indexOf(' ');
	624	if( end_choice >= 0 )
	625	{ var choice = line.substring(0, end_choice);
	626	document.search.choice.value = choice.toLowerCase();
	627	}
	628
	629	return true;
	630	}
	631	function Goto()
613	632	{
614		parent.location = document.search.choice.value.toLowerCase() + ".xml";
	633	parent.location = document.search.choice.value + '.xml';
615	634	}

+28

-29

doc/_search_xml.htm less more

0	0	<html>
1	1	<head>
2	2	<title>Search This Web Site</title>
	3	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
3	4	<meta name="description" id="description" content="Search This Web Site"/>
4	5	<style type='text/css'>
5	6	body { color : black }

60	61	and Javascript is disabled in your browser.
61	62	</h1></noscript>
62	63	<h2>Search This Web Site</h2>
63		Enter words separated by spaces in Keyword field.
64		When First Match field contains section you want,
65		select it using the return key or using the First Match button.
66		<form name="search">
	64	<form name='search'>
67	65	<p><table>
68		<tr>
69		<td>Keywords
	66	<tr><td>
	67	1: Enter keywords separated by spaces
	68	</td><td>
	69	3: <input
	70	type='button'
	71	value='Goto'
	72	onclick='Goto()'
	73	/>
	74	section
	75	</td><tr><td>
	76	<input
	77	type='text'
	78	name='keywords'
	79	onkeydown='UpdateList(event)'
	80	size='50'
	81	/></td>
70	82	</td><td>
71	83	<input
72		type="text"
73		name="string"
74		onkeydown="UpdateList(event)"
75		size="80"
76		></input></td>
77		</tr><tr>
78		<td><input
79		name="select"
80		type="button"
81		value="First Match"
82		onclick="Choose()"
83		></input></td><td>
84		<input
85		type="text"
86		name="choice"
87		size="20"
88		></input></td>
89		</tr>
	84	type='text'
	85	name='choice'
	86	size='20'
	87	/>
	88	</td></tr>
90	89	</table></p>
91	90	<p><table>
92		<tr><td>All Matches and Corresponding Keywords</td></tr>
	91	<tr><td>2: Select from following list of keyword matches</td></tr>
93	92	<tr><td><textarea
94		name="list"
95		rows="20"
96		cols="80"
97		></textarea></td></tr>
	93	name='list'
	94	rows='20'
	95	cols='80'
	96	onclick='Choose(this)' ></textarea></td></tr>
98	97	</table></p>
99	98	</form>
100	99	<script type='text/javascript' src='_search.xml.js'>

-1

doc/_sincosforward_xml.js less more

36	36	'atanforward.xml',
37	37	'asinforward.xml',
38	38	'acosforward.xml',
39		'tan_forward.xml'
	39	'tan_forward.xml',
	40	'erf_forward.xml'
40	41	];
41	42	var list_current0 = [
42	43	'sincosforward.xml#Differential Equation'

-1

doc/_sincosreverse_xml.js less more

36	36	'atanreverse.xml',
37	37	'asinreverse.xml',
38	38	'acosreverse.xml',
39		'tan_reverse.xml'
	39	'tan_reverse.xml',
	40	'erf_reverse.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

+95

-0

doc/_size_order_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'adfun.xml',
	10	'funeval.xml',
	11	'forward.xml',
	12	'size_order.xml'
	13	];
	14	var list_down3 = [
	15	'independent.xml',
	16	'funconstruct.xml',
	17	'dependent.xml',
	18	'abort_recording.xml',
	19	'seq_property.xml',
	20	'funeval.xml',
	21	'drivers.xml',
	22	'funcheck.xml',
	23	'optimize.xml',
	24	'check_for_nan.xml'
	25	];
	26	var list_down2 = [
	27	'forward.xml',
	28	'reverse.xml',
	29	'sparse.xml'
	30	];
	31	var list_down1 = [
	32	'forward_zero.xml',
	33	'forward_one.xml',
	34	'forward_two.xml',
	35	'forward_order.xml',
	36	'forward_dir.xml',
	37	'size_order.xml',
	38	'comparechange.xml',
	39	'capacity_order.xml',
	40	'number_skip.xml'
	41	];
	42	var list_current0 = [
	43	'size_order.xml#Syntax',
	44	'size_order.xml#Syntax.See Also',
	45	'size_order.xml#Purpose',
	46	'size_order.xml#f',
	47	'size_order.xml#s',
	48	'size_order.xml#Constructor',
	49	'size_order.xml#Forward',
	50	'size_order.xml#capacity_order',
	51	'size_order.xml#Example'
	52	];
	53	function choose_across0(item)
	54	{ var index = item.selectedIndex;
	55	item.selectedIndex = 0;
	56	if(index > 0)
	57	document.location = list_across0[index-1];
	58	}
	59	function choose_up0(item)
	60	{ var index = item.selectedIndex;
	61	item.selectedIndex = 0;
	62	if(index > 0)
	63	document.location = list_up0[index-1];
	64	}
	65	function choose_down3(item)
	66	{ var index = item.selectedIndex;
	67	item.selectedIndex = 0;
	68	if(index > 0)
	69	document.location = list_down3[index-1];
	70	}
	71	function choose_down2(item)
	72	{ var index = item.selectedIndex;
	73	item.selectedIndex = 0;
	74	if(index > 0)
	75	document.location = list_down2[index-1];
	76	}
	77	function choose_down1(item)
	78	{ var index = item.selectedIndex;
	79	item.selectedIndex = 0;
	80	if(index > 0)
	81	document.location = list_down1[index-1];
	82	}
	83	function choose_down0(item)
	84	{ var index = item.selectedIndex;
	85	item.selectedIndex = 0;
	86	if(index > 0)
	87	document.location = list_down0[index-1];
	88	}
	89	function choose_current0(item)
	90	{ var index = item.selectedIndex;
	91	item.selectedIndex = 0;
	92	if(index > 0)
	93	document.location = list_current0[index-1];
	94	}

-95

~~doc/_size_taylor_xml.js~~ less more

0		var list_across0 = [
1		'_contents_xml.htm',
2		'_reference.xml',
3		'_index.xml',
4		'_search_xml.htm',
5		'_external.xml'
6		];
7		var list_up0 = [
8		'cppad.xml',
9		'adfun.xml',
10		'funeval.xml',
11		'forward.xml',
12		'size_taylor.xml'
13		];
14		var list_down3 = [
15		'independent.xml',
16		'funconstruct.xml',
17		'dependent.xml',
18		'abort_recording.xml',
19		'seq_property.xml',
20		'funeval.xml',
21		'drivers.xml',
22		'funcheck.xml',
23		'optimize.xml',
24		'check_for_nan.xml'
25		];
26		var list_down2 = [
27		'forward.xml',
28		'reverse.xml',
29		'sparse.xml'
30		];
31		var list_down1 = [
32		'forwardzero.xml',
33		'forwardone.xml',
34		'forwardany.xml',
35		'size_taylor.xml',
36		'comparechange.xml',
37		'capacity_taylor.xml',
38		'number_skip.xml',
39		'forward.cpp.xml',
40		'forward_mul.cpp.xml'
41		];
42		var list_current0 = [
43		'size_taylor.xml#Syntax',
44		'size_taylor.xml#Syntax.See Also',
45		'size_taylor.xml#Purpose',
46		'size_taylor.xml#f',
47		'size_taylor.xml#s',
48		'size_taylor.xml#Constructor',
49		'size_taylor.xml#Forward',
50		'size_taylor.xml#capacity_taylor',
51		'size_taylor.xml#Example'
52		];
53		function choose_across0(item)
54		{ var index = item.selectedIndex;
55		item.selectedIndex = 0;
56		if(index > 0)
57		document.location = list_across0[index-1];
58		}
59		function choose_up0(item)
60		{ var index = item.selectedIndex;
61		item.selectedIndex = 0;
62		if(index > 0)
63		document.location = list_up0[index-1];
64		}
65		function choose_down3(item)
66		{ var index = item.selectedIndex;
67		item.selectedIndex = 0;
68		if(index > 0)
69		document.location = list_down3[index-1];
70		}
71		function choose_down2(item)
72		{ var index = item.selectedIndex;
73		item.selectedIndex = 0;
74		if(index > 0)
75		document.location = list_down2[index-1];
76		}
77		function choose_down1(item)
78		{ var index = item.selectedIndex;
79		item.selectedIndex = 0;
80		if(index > 0)
81		document.location = list_down1[index-1];
82		}
83		function choose_down0(item)
84		{ var index = item.selectedIndex;
85		item.selectedIndex = 0;
86		if(index > 0)
87		document.location = list_down0[index-1];
88		}
89		function choose_current0(item)
90		{ var index = item.selectedIndex;
91		item.selectedIndex = 0;
92		if(index > 0)
93		document.location = list_current0[index-1];
94		}

-0

doc/_sparse_jacobian_xml.js less more

57	57	'sparse_jacobian.xml#row, col',
58	58	'sparse_jacobian.xml#jac',
59	59	'sparse_jacobian.xml#work',
	60	'sparse_jacobian.xml#work.color_method',
60	61	'sparse_jacobian.xml#n_sweep',
61	62	'sparse_jacobian.xml#VectorBase',
62	63	'sparse_jacobian.xml#VectorSet',

-2

doc/_speed_adolc_xml.js less more

43	43	];
44	44	var list_current0 = [
45	45	'speed_adolc.xml#Purpose',
46		'speed_adolc.xml#adolc_dir',
	46	'speed_adolc.xml#adolc_prefix',
47	47	'speed_adolc.xml#Running Tests',
48		'speed_adolc.xml#C++ Compiler Flags',
49	48	'speed_adolc.xml#Contents'
50	49	];
51	50	function choose_across0(item)

-3

doc/_speed_cppad_xml.js less more

38	38	'cppad_ode.cpp.xml',
39	39	'cppad_poly.cpp.xml',
40	40	'cppad_sparse_hessian.cpp.xml',
41		'cppad_sparse_jacobian.cpp.xml',
42		'cppad_print_optimize.xml'
	41	'cppad_sparse_jacobian.cpp.xml'
43	42	];
44	43	var list_current0 = [
45	44	'speed_cppad.xml#Purpose',
46	45	'speed_cppad.xml#Running Tests',
47		'speed_cppad.xml#C++ Compiler Flags',
48	46	'speed_cppad.xml#Contents'
49	47	];
50	48	function choose_across0(item)

-1

doc/_speed_double_xml.js less more

43	43	var list_current0 = [
44	44	'speed_double.xml#Purpose',
45	45	'speed_double.xml#Running Tests',
46		'speed_double.xml#C++ Compiler Flags',
47	46	'speed_double.xml#Contents'
48	47	];
49	48	function choose_across0(item)

-2

doc/_speed_fadbad_xml.js less more

42	42	];
43	43	var list_current0 = [
44	44	'speed_fadbad.xml#Purpose',
45		'speed_fadbad.xml#fadbad_dir',
	45	'speed_fadbad.xml#fadbad_prefix',
46	46	'speed_fadbad.xml#Running Tests',
47		'speed_fadbad.xml#C++ Compiler Flags',
48	47	'speed_fadbad.xml#Contents'
49	48	];
50	49	function choose_across0(item)

-1

doc/_speed_main_xml.js less more

53	53	'speed_main.xml#test.speed',
54	54	'speed_main.xml#seed',
55	55	'speed_main.xml#option_list',
56		'speed_main.xml#option_list.retape',
	56	'speed_main.xml#option_list.onetape',
57	57	'speed_main.xml#option_list.optimize',
58	58	'speed_main.xml#option_list.atomic',
59	59	'speed_main.xml#option_list.memory',
	60	'speed_main.xml#Sparsity Options',
	61	'speed_main.xml#Sparsity Options.boolsparsity',
	62	'speed_main.xml#Sparsity Options.colpack',
60	63	'speed_main.xml#Correctness Results',
61	64	'speed_main.xml#Speed Results',
	65	'speed_main.xml#Speed Results.sparse_jacobian',
62	66	'speed_main.xml#Link Functions'
63	67	];
64	68	function choose_across0(item)

-2

doc/_speed_sacado_xml.js less more

42	42	];
43	43	var list_current0 = [
44	44	'speed_sacado.xml#Purpose',
45		'speed_sacado.xml#sacado_dir',
	45	'speed_sacado.xml#sacado_prefix',
46	46	'speed_sacado.xml#Running Tests',
47		'speed_sacado.xml#C++ Compiler Flags',
48	47	'speed_sacado.xml#Contents'
49	48	];
50	49	function choose_across0(item)

-1

doc/_speed_xml.js less more

32	32	];
33	33	var list_current0 = [
34	34	'speed.xml#Purpose',
35		'speed.xml#Windows',
36	35	'speed.xml#Contents'
37	36	];
38	37	function choose_across0(item)

-1

doc/_sqrtforward_xml.js less more

36	36	'atanforward.xml',
37	37	'asinforward.xml',
38	38	'acosforward.xml',
39		'tan_forward.xml'
	39	'tan_forward.xml',
	40	'erf_forward.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-1

doc/_sqrtreverse_xml.js less more

36	36	'atanreverse.xml',
37	37	'asinreverse.xml',
38	38	'acosreverse.xml',
39		'tan_reverse.xml'
	39	'tan_reverse.xml',
	40	'erf_reverse.xml'
40	41	];
41	42	function choose_across0(item)
42	43	{ var index = item.selectedIndex;

-0

doc/_ta_create_array_xml.js less more

75	75	'ta_create_array.xml#size_out',
76	76	'ta_create_array.xml#array',
77	77	'ta_create_array.xml#Delta',
	78	'ta_create_array.xml#Alignment',
78	79	'ta_create_array.xml#Example'
79	80	];
80	81	function choose_across0(item)

-0

doc/_ta_get_memory_xml.js less more

74	74	'ta_get_memory.xml#cap_bytes',
75	75	'ta_get_memory.xml#v_ptr',
76	76	'ta_get_memory.xml#Allocation Speed',
	77	'ta_get_memory.xml#Alignment',
77	78	'ta_get_memory.xml#Example'
78	79	];
79	80	function choose_across0(item)

-1

doc/_tan_forward_xml.js less more

36	36	'atanforward.xml',
37	37	'asinforward.xml',
38	38	'acosforward.xml',
39		'tan_forward.xml'
	39	'tan_forward.xml',
	40	'erf_forward.xml'
40	41	];
41	42	var list_current0 = [
42	43	'tan_forward.xml#Derivatives',

-1

doc/_tan_reverse_xml.js less more

36	36	'atanreverse.xml',
37	37	'asinreverse.xml',
38	38	'acosreverse.xml',
39		'tan_reverse.xml'
	39	'tan_reverse.xml',
	40	'erf_reverse.xml'
40	41	];
41	42	var list_current0 = [
42	43	'tan_reverse.xml#Notation',

-0

doc/_whats_new_03_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_04_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_05_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_06_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_07_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_08_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_09_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_10_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_11_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_12_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

-0

doc/_whats_new_13_xml.js less more

36	36	'license.xml'
37	37	];
38	38	var list_down1 = [
	39	'whats_new_14.xml',
39	40	'whats_new_13.xml',
40	41	'whats_new_12.xml',
41	42	'whats_new_11.xml',

+135

-0

doc/_whats_new_14_xml.js less more

	0	var list_across0 = [
	1	'_contents_xml.htm',
	2	'_reference.xml',
	3	'_index.xml',
	4	'_search_xml.htm',
	5	'_external.xml'
	6	];
	7	var list_up0 = [
	8	'cppad.xml',
	9	'appendix.xml',
	10	'whats_new.xml',
	11	'whats_new_14.xml'
	12	];
	13	var list_down3 = [
	14	'install.xml',
	15	'introduction.xml',
	16	'ad.xml',
	17	'adfun.xml',
	18	'preprocessor.xml',
	19	'multi_thread.xml',
	20	'library.xml',
	21	'ipopt_solve.xml',
	22	'example.xml',
	23	'speed.xml',
	24	'appendix.xml'
	25	];
	26	var list_down2 = [
	27	'faq.xml',
	28	'theory.xml',
	29	'glossary.xml',
	30	'bib.xml',
	31	'bugs.xml',
	32	'wishlist.xml',
	33	'whats_new.xml',
	34	'deprecated.xml',
	35	'compare_c.xml',
	36	'license.xml'
	37	];
	38	var list_down1 = [
	39	'whats_new_14.xml',
	40	'whats_new_13.xml',
	41	'whats_new_12.xml',
	42	'whats_new_11.xml',
	43	'whats_new_10.xml',
	44	'whats_new_09.xml',
	45	'whats_new_08.xml',
	46	'whats_new_07.xml',
	47	'whats_new_06.xml',
	48	'whats_new_05.xml',
	49	'whats_new_04.xml',
	50	'whats_new_03.xml'
	51	];
	52	var list_current0 = [
	53	'whats_new_14.xml#Introduction',
	54	'whats_new_14.xml#12-27',
	55	'whats_new_14.xml#12-26',
	56	'whats_new_14.xml#12-25',
	57	'whats_new_14.xml#12-23',
	58	'whats_new_14.xml#12-22',
	59	'whats_new_14.xml#12-17',
	60	'whats_new_14.xml#12-16',
	61	'whats_new_14.xml#12-15',
	62	'whats_new_14.xml#11-28',
	63	'whats_new_14.xml#11-27',
	64	'whats_new_14.xml#09-28',
	65	'whats_new_14.xml#09-27',
	66	'whats_new_14.xml#09-25',
	67	'whats_new_14.xml#09-21',
	68	'whats_new_14.xml#05-28',
	69	'whats_new_14.xml#05-27',
	70	'whats_new_14.xml#05-23',
	71	'whats_new_14.xml#05-22',
	72	'whats_new_14.xml#05-20',
	73	'whats_new_14.xml#05-19',
	74	'whats_new_14.xml#05-16',
	75	'whats_new_14.xml#05-14',
	76	'whats_new_14.xml#03-18',
	77	'whats_new_14.xml#03-17',
	78	'whats_new_14.xml#03-09',
	79	'whats_new_14.xml#03-05',
	80	'whats_new_14.xml#03-02',
	81	'whats_new_14.xml#03-01',
	82	'whats_new_14.xml#02-28',
	83	'whats_new_14.xml#02-27',
	84	'whats_new_14.xml#02-26',
	85	'whats_new_14.xml#02-23',
	86	'whats_new_14.xml#02-22',
	87	'whats_new_14.xml#02-17',
	88	'whats_new_14.xml#02-15',
	89	'whats_new_14.xml#01-26',
	90	'whats_new_14.xml#01-21',
	91	'whats_new_14.xml#01-10'
	92	];
	93	function choose_across0(item)
	94	{ var index = item.selectedIndex;
	95	item.selectedIndex = 0;
	96	if(index > 0)
	97	document.location = list_across0[index-1];
	98	}
	99	function choose_up0(item)
	100	{ var index = item.selectedIndex;
	101	item.selectedIndex = 0;
	102	if(index > 0)
	103	document.location = list_up0[index-1];
	104	}
	105	function choose_down3(item)
	106	{ var index = item.selectedIndex;
	107	item.selectedIndex = 0;
	108	if(index > 0)
	109	document.location = list_down3[index-1];
	110	}
	111	function choose_down2(item)
	112	{ var index = item.selectedIndex;
	113	item.selectedIndex = 0;
	114	if(index > 0)
	115	document.location = list_down2[index-1];
	116	}
	117	function choose_down1(item)
	118	{ var index = item.selectedIndex;
	119	item.selectedIndex = 0;
	120	if(index > 0)
	121	document.location = list_down1[index-1];
	122	}
	123	function choose_down0(item)
	124	{ var index = item.selectedIndex;
	125	item.selectedIndex = 0;
	126	if(index > 0)
	127	document.location = list_down0[index-1];
	128	}
	129	function choose_current0(item)
	130	{ var index = item.selectedIndex;
	131	item.selectedIndex = 0;
	132	if(index > 0)
	133	document.location = list_current0[index-1];
	134	}

-0

doc/_whats_new_xml.js less more

35	35	'license.xml'
36	36	];
37	37	var list_down0 = [
	38	'whats_new_14.xml',
38	39	'whats_new_13.xml',
39	40	'whats_new_12.xml',
40	41	'whats_new_11.xml',

-1

doc/_wishlist_xml.js less more

45	45	'wishlist.xml#Forward Mode Recomputation',
46	46	'wishlist.xml#Iterator Interface',
47	47	'wishlist.xml#Library',
48		'wishlist.xml#Multiple Argument Forward',
	48	'wishlist.xml#Multiple Directions',
49	49	'wishlist.xml#Numeric Limits',
50	50	'wishlist.xml#Operation Sequence',
51	51	'wishlist.xml#Optimization',

-1

doc/a11c_bthread.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>A Simple Boost Thread Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Simple Boost Thread Example and Test"/>
7		<meta name="keywords" id="keywords" content=" boost thread example A.1.1c "/>
	8	<meta name="keywords" id="keywords" content=" boost thread example A.1.1c a simple and test purpose source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/a11c_openmp.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>A Simple OpenMP Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Simple OpenMP Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Openmp example A.1.1c thread "/>
	8	<meta name="keywords" id="keywords" content=" Openmp example A.1.1c thread a simple openmp and test purpose source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/a11c_pthread.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>A Simple Parallel Pthread Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Simple Parallel Pthread Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Openmp example A.1.1c thread "/>
	8	<meta name="keywords" id="keywords" content=" Openmp example A.1.1c thread a simple parallel pthread and test purpose source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/abort_recording.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Abort Current Recording: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Abort Current Recording: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" abort example test recording "/>
	8	<meta name="keywords" id="keywords" content=" abort current recording: example and test recording "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/abort_recording.xml less more

3	3	>
4	4	<head>
5	5	<title>Abort Recording of an Operation Sequence</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Abort Recording of an Operation Sequence"/>
7		<meta name="keywords" id="keywords" content=" abort operation sequence recording tape "/>
	8	<meta name="keywords" id="keywords" content=" abort recording of an operation sequence tape syntax purpose example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/abs.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Absolute Value Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Absolute Value Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" abs example fabs test "/>
	8	<meta name="keywords" id="keywords" content=" ad absolute value function: example and test abs fabs "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/abs.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Absolute Value Function</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Absolute Value Function"/>
7		<meta name="keywords" id="keywords" content=" abs Ad fabs absolute value "/>
	8	<meta name="keywords" id="keywords" content=" abs Ad fabs absolute value ad function syntax purpose x y operation sequence complex types derivative example old "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/acos.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD acos Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD acos Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" acos Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad acos function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/acosforward.xml less more

3	3	>
4	4	<head>
5	5	<title>Arccosine Function Forward Taylor Polynomial Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Arccosine Function Forward Taylor Polynomial Theory"/>
7		<meta name="keywords" id="keywords" content=" acos forward theory "/>
	8	<meta name="keywords" id="keywords" content=" acos forward theory arccosine function taylor polynomial "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinForward</option>
77	78	<option>AcosForward</option>
78	79	<option>tan_forward</option>
	80	<option>erf_forward</option>
79	81	</select>
80	82	</td>
81	83	<td>AcosForward</td>

727	729	</mrow></math>
728	730
729	731
730		<hr/>Input File: omh/acos_forward.omh
	732	<hr/>Input File: omh/theory/acos_forward.omh
731	733
732	734	</body>
733	735	</html>

-3

doc/acosreverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Arccosine Function Reverse Mode Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Arccosine Function Reverse Mode Theory"/>
7		<meta name="keywords" id="keywords" content=" acos reverse theory "/>
	8	<meta name="keywords" id="keywords" content=" acos reverse theory arccosine function mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinReverse</option>
77	78	<option>AcosReverse</option>
78	79	<option>tan_reverse</option>
	80	<option>erf_reverse</option>
79	81	</select>
80	82	</td>
81	83	<td>AcosReverse</td>

109	111	</mrow></math>
110	112
111	113
112		for the <i>p</i>-th order Taylor coefficient
	114	for the <code><i>p</i></code>-th order Taylor coefficient
113	115	row vectors corresponding to functions
114	116
115	117	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>

1557	1559	</mrow></math>
1558	1560
1559	1561
1560		<hr/>Input File: omh/acos_reverse.omh
	1562	<hr/>Input File: omh/theory/acos_reverse.omh
1561	1563
1562	1564	</body>
1563	1565	</html>

-1

doc/ad.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Objects</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Objects"/>
7		<meta name="keywords" id="keywords" content=" Ad object Base require "/>
	8	<meta name="keywords" id="keywords" content=" ad objects Ad object purpose base type requirements Base require "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_assign.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Assignment: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Assignment: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" assign Ad object example test "/>
	8	<meta name="keywords" id="keywords" content=" ad assignment: example and test assign Ad object "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_assign.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Assignment Operator</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Assignment Operator"/>
7		<meta name="keywords" id="keywords" content=" assignment Ad assign to Base Vecad "/>
	8	<meta name="keywords" id="keywords" content=" assignment Ad assign to Base Vecad ad operator syntax purpose x y example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_binary.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Binary Arithmetic Operators</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Binary Arithmetic Operators"/>
7		<meta name="keywords" id="keywords" content=" binary operator + add plus - subtract minus * multiply times / divide "/>
	8	<meta name="keywords" id="keywords" content=" ad binary arithmetic operators operator + add plus - subtract minus * multiply times / divide syntax purpose op base x y z operation sequence example derivative addition subtraction multiplication division "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_ctor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Constructors: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Constructors: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" constructor Ad object example test "/>
	8	<meta name="keywords" id="keywords" content=" ad constructors: example and test constructor Ad object "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_ctor.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Constructors</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Constructors"/>
7		<meta name="keywords" id="keywords" content=" Ad constructor convert to Base Vecad deprecated "/>
	8	<meta name="keywords" id="keywords" content=" Ad constructor convert to Base Vecad ad constructors syntax purpose x implicit explicit deprecated y example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_fun.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Creating Your Own Interface to an ADFun Object</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Creating Your Own Interface to an ADFun Object"/>
7		<meta name="keywords" id="keywords" content=" Adfun example test "/>
	8	<meta name="keywords" id="keywords" content=" creating your own interface to an adfun object Adfun example test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_in_c.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Example and Test Linking CppAD to Languages Other than C++</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Example and Test Linking CppAD to Languages Other than C++"/>
7		<meta name="keywords" id="keywords" content=" C Ad algorithmic differentiation automatic example test link Cppad to language "/>
	8	<meta name="keywords" id="keywords" content=" example and test linking cppad to languages other than c++ C Ad algorithmic differentiation automatic link Cppad language "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_input.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Output Operator: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Output Operator: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" << Ad example input test "/>
	8	<meta name="keywords" id="keywords" content=" ad output operator: example and test << Ad input "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_input.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Output Stream Operator</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Output Stream Operator"/>
7		<meta name="keywords" id="keywords" content=" >> Ad input stream write "/>
	8	<meta name="keywords" id="keywords" content=" >> Ad input stream write ad output operator syntax purpose is x result operation sequence example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_output.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Output Operator: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Output Operator: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" << Ad example output test "/>
	8	<meta name="keywords" id="keywords" content=" ad output operator: example and test << Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ad_output.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Output Stream Operator</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Output Stream Operator"/>
7		<meta name="keywords" id="keywords" content=" << Ad output stream write "/>
	8	<meta name="keywords" id="keywords" content=" << Ad output stream write ad operator syntax purpose assumption os x result operation sequence example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/add.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Binary Addition: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Binary Addition: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" + Ad example add plus test "/>
	8	<meta name="keywords" id="keywords" content=" ad binary addition: example and test + Ad add plus "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/addeq.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Computed Assignment Addition: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Computed Assignment Addition: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" += Ad example computed assignment add test assign plus "/>
	8	<meta name="keywords" id="keywords" content=" ad computed assignment addition: example and test += Ad add assign plus "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/adfun.xml less more

3	3	>
4	4	<head>
5	5	<title>ADFun Objects</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ADFun Objects"/>
7		<meta name="keywords" id="keywords" content=" Adfun object "/>
	8	<meta name="keywords" id="keywords" content=" adfun objects Adfun object purpose "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/adolc_alloc_mat.xml less more

3	3	>
4	4	<head>
5	5	<title>Adolc Test Utility: Allocate and Free Memory For a Matrix</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Adolc Test Utility: Allocate and Free Memory For a Matrix"/>
7		<meta name="keywords" id="keywords" content=" adolc_alloc_mat alloc adolc matrix "/>
	8	<meta name="keywords" id="keywords" content=" adolc test utility: allocate and free memory for a matrix adolc_alloc_mat alloc syntax purpose m n mat "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-4

doc/adolc_det_lu.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Adolc Speed: Gradient of Determinant Using Lu Factorization</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Adolc Speed: Gradient of Determinant Using Lu Factorization"/>
7		<meta name="keywords" id="keywords" content=" link_det_lu adolc speed lu matrix factor "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: gradient of determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

112	113	# include <cppad/speed/uniform_01.hpp>
113	114	# include <cppad/track_new_del.hpp>
114	115
	116	// list of possible options
	117	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	118
115	119	bool link_det_lu(
116	120	size_t size ,
117	121	size_t repeat ,

119	123	CppAD::vector<double> &gradient )
120	124	{
121	125	// speed test global option values
122		extern bool global_retape, global_atomic, global_optimize;
123		if( ! global_retape \|\| global_optimize \|\| global_atomic )
	126	if( global_onetape \|\| global_atomic )
124	127	return false;
125
	128	if( global_memory \|\| global_optimize )
	129	return false;
126	130	// -----------------------------------------------------
127	131	// setup
128	132	int tag = 0; // tape identifier

-5

doc/adolc_det_minor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Adolc Speed: Gradient of Determinant by Minor Expansion</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Adolc Speed: Gradient of Determinant by Minor Expansion"/>
7		<meta name="keywords" id="keywords" content=" link_det_minor adolc speed minor determinant "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: gradient of determinant by minor expansion link_det_minor speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

108	109	# include <cppad/speed/det_by_minor.hpp>
109	110	# include <cppad/speed/uniform_01.hpp>
110	111
	112	// list of possible options
	113	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	114
111	115	bool link_det_minor(
112	116	size_t size ,
113	117	size_t repeat ,

115	119	CppAD::vector<double> &gradient )
116	120	{
117	121	// speed test global option values
118		extern bool global_retape, global_atomic, global_optimize;
119		if( global_atomic \|\| global_optimize )
	122	if( global_atomic )
120	123	return false;
121
	124	if( global_memory \|\| global_optimize )
	125	return false;
122	126	// -----------------------------------------------------
123	127	// setup
124	128	typedef adouble ADScalar;

154	158	double* grad = thread_alloc::create_array<double>(size_t(n), capacity);
155	159
156	160	// ----------------------------------------------------------------------
157		if( global_retape ) while(repeat--)
	161	if( ! global_onetape ) while(repeat--)
158	162	{ // choose a matrix
159	163	CppAD::uniform_01(n, mat);
160	164

-6

doc/adolc_mat_mul.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Adolc Speed: Matrix Multiplication</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Adolc Speed: Matrix Multiplication"/>
7		<meta name="keywords" id="keywords" content=" link_mat_mul adolc speed matrix multiply "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: matrix multiplication link_mat_mul speed multiply specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

112	113	# include <cppad/speed/mat_sum_sq.hpp>
113	114	# include <cppad/speed/uniform_01.hpp>
114	115	# include <cppad/vector.hpp>
	116
	117	// list of possible options
	118	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	119
115	120	bool link_mat_mul(
116	121	size_t size ,
117	122	size_t repeat ,

120	125	CppAD::vector<double>& dz )
121	126	{
122	127	// speed test global option values
123		extern bool global_retape, global_atomic, global_optimize;
124		if( global_atomic \|\| global_optimize )
125		return false;
126
	128	if( global_memory \|\| global_atomic \|\| global_optimize )
	129	return false;
127	130	// -----------------------------------------------------
128	131	// setup
129	132	typedef adouble ADScalar;

159	162	double* grad = thread_alloc::create_array<double>(size_t(n), capacity);
160	163
161	164	// ----------------------------------------------------------------------
162		if( global_retape ) while(repeat--)
	165	if( ! global_onetape ) while(repeat--)
163	166	{ // choose a matrix
164	167	CppAD::uniform_01(n, mat);
165	168

+12

-9

doc/adolc_ode.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Adolc Speed: Ode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Adolc Speed: Ode"/>
7		<meta name="keywords" id="keywords" content=" link_ode adolc speed ode "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: ode link_ode speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

113	114	# include <cppad/speed/ode_evaluate.hpp>
114	115	# include <cppad/speed/uniform_01.hpp>
115	116
	117	// list of possible options
	118	extern bool global_memory, global_onetape, global_atomic, global_optimize;
116	119
117	120	bool link_ode(
118	121	size_t size ,

121	124	CppAD::vector<double> &jac
122	125	)
123	126	{
	127	// speed test global option values
	128	if( global_atomic )
	129	return false;
	130	if( global_memory \|\| global_optimize )
	131	return false;
	132	// -------------------------------------------------------------
	133	// setup
124	134	assert( x.size() == size );
125	135	assert( jac.size() == size * size );
126	136
127		// speed test global option values
128		extern bool global_retape, global_atomic, global_optimize;
129		if( global_atomic \|\| global_optimize )
130		return false;
131
132		// -------------------------------------------------------------
133		// setup
134	137	typedef CppAD::vector<adouble> ADVector;
135	138	typedef CppAD::vector<double> DblVector;
136	139

159	162	jac_ptr[i] = jac_raw + i * n;
160	163
161	164	// -------------------------------------------------------------
162		if( global_retape) while(repeat--)
	165	if( ! global_onetape ) while(repeat--)
163	166	{ // choose next x value
164	167	uniform_01(n, x);
165	168

+11

-8

doc/adolc_poly.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Adolc Speed: Second Derivative of a Polynomial</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Adolc Speed: Second Derivative of a Polynomial"/>
7		<meta name="keywords" id="keywords" content=" link_poly adolc speed polynomial "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: second derivative of a polynomial link_poly speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

114	115	# include <cppad/poly.hpp>
115	116	# include <cppad/vector.hpp>
116	117	# include <cppad/thread_alloc.hpp>
117
118		# include "alloc_mat.hpp"
	118	# include "adolc_alloc_mat.hpp"
	119
	120	// list of possible options
	121	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	122
119	123	bool link_poly(
120	124	size_t size ,
121	125	size_t repeat ,

123	127	CppAD::vector<double> &z , // polynomial argument value
124	128	CppAD::vector<double> &ddp ) // second derivative w.r.t z
125	129	{
126		// speed test global option values
127		extern bool global_retape, global_atomic, global_optimize;
128		if( global_atomic \|\| global_optimize )
	130	if( global_atomic )
129	131	return false;
130
	132	if( global_memory \|\| global_optimize )
	133	return false;
131	134	// -----------------------------------------------------
132	135	// setup
133	136	size_t i;

164	167	x[0][1] = 0.; // second order
165	168
166	169	// ----------------------------------------------------------------------
167		if( global_retape ) while(repeat--)
	170	if( ! global_onetape ) while(repeat--)
168	171	{ // choose an argument value
169	172	CppAD::uniform_01(1, z);
170	173

-2

doc/adolc_prefix.xml less more

3	3	>
4	4	<head>
5	5	<title>Including the ADOL-C Examples and Tests</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Including the ADOL-C Examples and Tests"/>
7		<meta name="keywords" id="keywords" content=" adolc example test prefix examples speed unix cygwin get "/>
	8	<meta name="keywords" id="keywords" content=" including the adol-c examples and tests adolc example test purpose adolc_prefix prefix speed unix cygwin get_adolc get "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

62	63	<option>Install-></option>
63	64	<option>download</option>
64	65	<option>cmake</option>
65		<option>cppad_test</option>
	66	<option>cmake_check</option>
66	67	<option>pkgconfig</option>
67	68	<option>InstallUnix</option>
68	69	</select>

71	72	<select onchange='choose_down1(this)'>
72	73	<option>cmake-></option>
73	74	<option>adolc_prefix</option>
	75	<option>colpack_prefix</option>
74	76	<option>eigen_prefix</option>
75	77	<option>fadbad_prefix</option>
76	78	<option>ipopt_prefix</option>

+14

-10

doc/adolc_sparse_hessian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Adolc Speed: Sparse Hessian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Adolc Speed: Sparse Hessian"/>
7		<meta name="keywords" id="keywords" content=" link_sparse_hessian adolc speed sparse hessian "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: sparse hessian link_sparse_hessian speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

114	115	# include <cppad/thread_alloc.hpp>
115	116	# include <cppad/speed/sparse_hes_fun.hpp>
116	117
	118	// list of possible options
	119	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	120	extern bool global_colpack, global_boolsparsity;
	121
117	122	bool link_sparse_hessian(
118	123	size_t size ,
119	124	size_t repeat ,
120		CppAD::vector<double> &x_return ,
121		const CppAD::vector<size_t> &row ,
122		const CppAD::vector<size_t> &col ,
123		CppAD::vector<double> &hessian )
	125	const CppAD::vector<size_t>& row ,
	126	const CppAD::vector<size_t>& col ,
	127	CppAD::vector<double>& x_return ,
	128	CppAD::vector<double>& hessian )
124	129	{
125		// speed test global option values
126		extern bool global_retape, global_atomic, global_optimize;
127		if( global_atomic \|\| global_optimize )
	130	if( global_atomic \|\| (! global_colpack) )
128	131	return false;
129
	132	if( global_memory \|\| global_optimize \|\| global_boolsparsity )
	133	return false;
130	134	// -----------------------------------------------------
131	135	// setup
132	136	typedef unsigned int* SizeVector;

172	176	hessian[ i * n + j ] = 0.;
173	177	}
174	178	// ----------------------------------------------------------------------
175		if( global_retape ) while(repeat--)
	179	if( ! global_onetape ) while(repeat--)
176	180	{ // choose a value for x
177	181	CppAD::uniform_01(n, x);
178	182

+54

-40

doc/adolc_sparse_jacobian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>adolc Speed: Sparse Jacobian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="adolc Speed: Sparse Jacobian"/>
7		<meta name="keywords" id="keywords" content=" link_sparse_jacobian adolc speed sparse jacobian "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: sparse jacobian link_sparse_jacobian speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

113	114	# include <cppad/speed/uniform_01.hpp>
114	115	# include <cppad/speed/sparse_jac_fun.hpp>
115	116
	117	// list of possible options
	118	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	119	extern bool global_colpack, global_boolsparsity;
	120
116	121	bool link_sparse_jacobian(
117		size_t size ,
118		size_t repeat ,
119		size_t m ,
120		CppAD::vector<double> &x_return ,
121		CppAD::vector<size_t> &row ,
122		CppAD::vector<size_t> &col ,
123		CppAD::vector<double> &jacobian )
	122	size_t size ,
	123	size_t repeat ,
	124	size_t m ,
	125	const CppAD::vector<size_t>& row ,
	126	const CppAD::vector<size_t>& col ,
	127	CppAD::vector<double>& x_return ,
	128	CppAD::vector<double>& jacobian ,
	129	size_t& n_sweep )
124	130	{
125		// speed test global option values
126		extern bool global_retape, global_atomic, global_optimize;
127		if( global_atomic \|\| global_optimize )
	131	if( global_atomic \|\| (! global_colpack) )
128	132	return false;
129
	133	if( global_memory \|\| global_optimize )
	134	return false;
130	135	// -----------------------------------------------------
131	136	// setup
132	137	typedef unsigned int* SizeVector;

153	158	// function value in double
154	159	DblVector y = thread_alloc::create_array<double>(m, capacity);
155	160
	161
156	162	// options that control sparse_jac
157	163	int options[4];
158		options[0] = 0; // sparsity pattern by index domains
159		options[1] = 0; // safe mode
160		options[2] = 0; // not used if options[0] == 0
161		options[3] = 0; // forward mode (column compression)
	164	extern bool global_boolsparsity;
	165	if( global_boolsparsity )
	166	options[0] = 1; // sparsity by propagation of bit pattern
	167	else
	168	options[0] = 0; // sparsity pattern by index domains
	169	options[1] = 0; // (0 = safe mode, 1 = tight mode)
	170	options[2] = 0; // see changing to -1 and back to 0 below
	171	options[3] = 0; // (0 = column compression, 1 = row compression)
162	172
163	173	// structure that holds some of the work done by sparse_jac
164	174	int nnz; // number of non-zero values

171	181	{ for(j = 0; j < n; j++)
172	182	jacobian[ i * n + j ] = 0.;
173	183	}
	184
	185	// choose a value for x
	186	CppAD::uniform_01(n, x);
	187
	188	// declare independent variables
	189	int keep = 0; // keep forward mode results
	190	trace_on(tag, keep);
	191	for(j = 0; j < n; j++)
	192	a_x[j] <<= x[j];
	193
	194	// AD computation of f (x)
	195	CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
	196
	197	// create function object f : x -> y
	198	for(i = 0; i < m; i++)
	199	a_y[i] >>= y[i];
	200	trace_off();
	201
	202	// Retrieve n_sweep using undocumented feature of sparsedrivers.cpp
	203	int same_pattern = 0;
	204	options[2] = -1;
	205	n_sweep = sparse_jac(tag, int(m), int(n),
	206	same_pattern, x, &nnz, &rind, &cind, &values, options
	207	);
	208	options[2] = 0;
174	209	// ----------------------------------------------------------------------
175		if( global_retape ) while(repeat--)
	210	if( ! global_onetape ) while(repeat--)
176	211	{ // choose a value for x
177	212	CppAD::uniform_01(n, x);
178	213
179	214	// declare independent variables
180		int keep = 0; // keep forward mode results
181	215	trace_on(tag, keep);
182	216	for(j = 0; j < n; j++)
183	217	a_x[j] <<= x[j];

191	225	trace_off();
192	226
193	227	// is this a repeat call with the same sparsity pattern
194		int same_pattern = 0;
	228	same_pattern = 0;
195	229
196	230	// calculate the jacobian at this x
197	231	rind = CPPAD_NULL;

210	244	free(values);
211	245	}
212	246	else
213		{ // choose a value for x
214		CppAD::uniform_01(n, x);
215
216		// declare independent variables
217		int keep = 0; // keep forward mode results
218		trace_on(tag, keep);
219		for(j = 0; j < n; j++)
220		a_x[j] <<= x[j];
221
222		// AD computation of f (x)
223		CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
224
225		// create function object f : x -> y
226		for(i = 0; i < m; i++)
227		a_y[i] >>= y[i];
228		trace_off();
229
230		// is this a repeat call at the same argument
231		int same_pattern = 0;
232
233		while(repeat--)
	247	{ while(repeat--)
234	248	{ // choose a value for x
235	249	CppAD::uniform_01(n, x);
236	250

-1

doc/advalued.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Valued Operations and Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Valued Operations and Functions"/>
7		<meta name="keywords" id="keywords" content=" operation Ad valued function "/>
	8	<meta name="keywords" id="keywords" content=" operation Ad valued function ad operations and functions "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/appendix.xml less more

3	3	>
4	4	<head>
5	5	<title>Appendix</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Appendix"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" appendix "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/arithmetic.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Arithmetic Operators and Computed Assignments</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Arithmetic Operators and Computed Assignments"/>
7		<meta name="keywords" id="keywords" content=" operator Ad arithmetic computed assignment "/>
	8	<meta name="keywords" id="keywords" content=" operator Ad arithmetic computed assignment ad operators and assignments "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/asin.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD asin Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD asin Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" asin Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad asin function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/asinforward.xml less more

3	3	>
4	4	<head>
5	5	<title>Arcsine Function Forward Taylor Polynomial Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Arcsine Function Forward Taylor Polynomial Theory"/>
7		<meta name="keywords" id="keywords" content=" asin forward theory "/>
	8	<meta name="keywords" id="keywords" content=" asin forward theory arcsine function taylor polynomial "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinForward</option>
77	78	<option>AcosForward</option>
78	79	<option>tan_forward</option>
	80	<option>erf_forward</option>
79	81	</select>
80	82	</td>
81	83	<td>AsinForward</td>

726	728	</mrow></math>
727	729
728	730
729		<hr/>Input File: omh/asin_forward.omh
	731	<hr/>Input File: omh/theory/asin_forward.omh
730	732
731	733	</body>
732	734	</html>

-3

doc/asinreverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Arcsine Function Reverse Mode Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Arcsine Function Reverse Mode Theory"/>
7		<meta name="keywords" id="keywords" content=" asin reverse theory "/>
	8	<meta name="keywords" id="keywords" content=" asin reverse theory arcsine function mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinReverse</option>
77	78	<option>AcosReverse</option>
78	79	<option>tan_reverse</option>
	80	<option>erf_reverse</option>
79	81	</select>
80	82	</td>
81	83	<td>AsinReverse</td>

109	111	</mrow></math>
110	112
111	113
112		for the <i>p</i>-th order Taylor coefficient
	114	for the <code><i>p</i></code>-th order Taylor coefficient
113	115	row vectors corresponding to functions
114	116
115	117	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>

1556	1558	</mrow></math>
1557	1559
1558	1560
1559		<hr/>Input File: omh/asin_reverse.omh
	1561	<hr/>Input File: omh/theory/asin_reverse.omh
1560	1562
1561	1563	</body>
1562	1564	</html>

-1

doc/atan.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD atan Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD atan Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" atan Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad atan function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/atan2.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD atan2 Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD atan2 Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" atan2 Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad atan2 function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/atan2.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Two Argument Inverse Tangent Function</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Two Argument Inverse Tangent Function"/>
7		<meta name="keywords" id="keywords" content=" tan Ad inverse atan2 "/>
	8	<meta name="keywords" id="keywords" content=" tan Ad inverse atan2 ad two argument tangent function syntax purpose y x theta operation sequence example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/atanforward.xml less more

3	3	>
4	4	<head>
5	5	<title>Arctangent Function Forward Taylor Polynomial Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Arctangent Function Forward Taylor Polynomial Theory"/>
7		<meta name="keywords" id="keywords" content=" atan forward theory "/>
	8	<meta name="keywords" id="keywords" content=" atan forward theory arctangent function taylor polynomial "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinForward</option>
77	78	<option>AcosForward</option>
78	79	<option>tan_forward</option>
	80	<option>erf_forward</option>
79	81	</select>
80	82	</td>
81	83	<td>AtanForward</td>

562	564	</mrow></math>
563	565
564	566
565		<hr/>Input File: omh/atan_forward.omh
	567	<hr/>Input File: omh/theory/atan_forward.omh
566	568
567	569	</body>
568	570	</html>

-3

doc/atanreverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Arctangent Function Reverse Mode Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Arctangent Function Reverse Mode Theory"/>
7		<meta name="keywords" id="keywords" content=" atan reverse theory "/>
	8	<meta name="keywords" id="keywords" content=" atan reverse theory arctangent function mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinReverse</option>
77	78	<option>AcosReverse</option>
78	79	<option>tan_reverse</option>
	80	<option>erf_reverse</option>
79	81	</select>
80	82	</td>
81	83	<td>AtanReverse</td>

104	106	</mrow></math>
105	107
106	108
107		for the <i>p</i>-th order Taylor coefficient
	109	for the <code><i>p</i></code>-th order Taylor coefficient
108	110	row vectors corresponding to
109	111
110	112	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

1292	1294	</mrow></math>
1293	1295
1294	1296
1295		<hr/>Input File: omh/atan_reverse.omh
	1297	<hr/>Input File: omh/theory/atan_reverse.omh
1296	1298
1297	1299	</body>
1298	1300	</html>

-1

doc/atomic.xml less more

3	3	>
4	4	<head>
5	5	<title>Atomic AD Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Atomic AD Functions"/>
7		<meta name="keywords" id="keywords" content=" atomic ad function operation "/>
	8	<meta name="keywords" id="keywords" content=" atomic ad functions function operation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/atomic_afun.xml less more

3	3	>
4	4	<head>
5	5	<title>Using AD Version of Atomic Function</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using AD Version of Atomic Function"/>
7		<meta name="keywords" id="keywords" content=" atomic use function "/>
	8	<meta name="keywords" id="keywords" content=" using ad version of atomic function use syntax purpose advector afun ax ay examples "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

+17

-6

doc/atomic_base.xml less more

3	3	>
4	4	<head>
5	5	<title>User Defined Atomic AD Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="User Defined Atomic AD Functions"/>
7		<meta name="keywords" id="keywords" content=" atomic user function operation "/>
	8	<meta name="keywords" id="keywords" content=" user defined atomic ad functions function operation syntax purpose virtual examples getting started scalar vector range hessian sparsity patterns general case "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

88	89	<option>atomic_norm_sq.cpp</option>
89	90	<option>atomic_reciprocal.cpp</option>
90	91	<option>atomic_tangent.cpp</option>
	92	<option>atomic_hes_sparse.cpp</option>
91	93	<option>atomic_mat_mul.cpp</option>
92	94	</select>
93	95	</td>

102	104	<option>---..Getting Started</option>
103	105	<option>---..Scalar Function</option>
104	106	<option>---..Vector Range</option>
	107	<option>---..Hessian Sparsity Patterns</option>
105	108	<option>General Case</option>
106	109	</select>
107	110	</td>

119	122	<code><font color="blue"><span style='white-space: nowrap'><br/>
120	123	</span></font><i><font color="black"><span style='white-space: nowrap'>atomic_user</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>(</span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>use_set</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>user_arg_list</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
121	124	</span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>(</span></font><i><font color="black"><span style='white-space: nowrap'>ax</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>ay</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
122		</span></font><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.forward(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>vx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>vy</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
123		</span></font><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.reverse(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>px</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>py</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	125	</span></font><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.forward(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>vx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>vy</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	126	</span></font><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.reverse(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>px</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>py</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
124	127	</span></font><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.for_sparse_jac(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
125	128	</span></font><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.rev_sparse_jac(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
126	129	</span></font><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.rev_sparse_hes(</span></font><i><font color="black"><span style='white-space: nowrap'>vx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>t</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>u</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>v</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>

201	204	.
202	205	The <code><font color="blue">forward</font></code> function,
203	206	for the case
204		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
	207	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
205	208	, must be implemented.
206	209	Otherwise, only those functions
207	210	required by the your calculations need to be implemented.

209	212
210	213	<code><i><font color="black"><span style='white-space: nowrap'>forward</span></font></i></code>
211	214	for the case
212		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> == 2</span></font></code>
	215	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> == 2</span></font></code>
213	216	can just return
214	217
215	218	<code><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> == false</span></font></code>

221	224	<b><big><a name="Contents" id="Contents">Contents</a></big></b>
222	225	<br/>
223	226	<table>
224		<tr><td><a href="atomic_ctor.xml" target="_top">atomic_ctor</a></td><td>Atomic Function Constructor</td></tr><tr><td><a href="atomic_option.xml" target="_top">atomic_option</a></td><td>Set Atomic Function Options</td></tr><tr><td><a href="atomic_afun.xml" target="_top">atomic_afun</a></td><td>Using AD Version of Atomic Function</td></tr><tr><td><a href="atomic_forward.xml" target="_top">atomic_forward</a></td><td>Atomic Forward Mode</td></tr><tr><td><a href="atomic_reverse.xml" target="_top">atomic_reverse</a></td><td>Atomic Reverse Mode</td></tr><tr><td><a href="atomic_for_sparse_jac.xml" target="_top">atomic_for_sparse_jac</a></td><td>Atomic Forward Jacobian Sparsity Patterns</td></tr><tr><td><a href="atomic_rev_sparse_jac.xml" target="_top">atomic_rev_sparse_jac</a></td><td>Atomic Reverse Jacobian Sparsity Patterns</td></tr><tr><td><a href="atomic_rev_sparse_hes.xml" target="_top">atomic_rev_sparse_hes</a></td><td>Atomic Reverse Hessian Sparsity Patterns</td></tr><tr><td><a href="atomic_base_clear.xml" target="_top">atomic_base_clear</a></td><td>Free Static Variables</td></tr><tr><td><a href="atomic_get_started.cpp.xml" target="_top">atomic_get_started.cpp</a></td><td>Getting Started with Atomic Operations: Example and Test</td></tr><tr><td><a href="atomic_norm_sq.cpp.xml" target="_top">atomic_norm_sq.cpp</a></td><td>Euclidean Norm Squared: Example and Test</td></tr><tr><td><a href="atomic_reciprocal.cpp.xml" target="_top">atomic_reciprocal.cpp</a></td><td>Reciprocal as an Atomic Operation: Example and Test</td></tr><tr><td><a href="atomic_tangent.cpp.xml" target="_top">atomic_tangent.cpp</a></td><td>Tan and Tanh as User Atomic Operations: Example and Test</td></tr><tr><td><a href="atomic_mat_mul.cpp.xml" target="_top">atomic_mat_mul.cpp</a></td><td>User Atomic Matrix Multiply: Example and Test</td></tr></table><br/>
	227	<tr><td><a href="atomic_ctor.xml" target="_top">atomic_ctor</a></td><td>Atomic Function Constructor</td></tr><tr><td><a href="atomic_option.xml" target="_top">atomic_option</a></td><td>Set Atomic Function Options</td></tr><tr><td><a href="atomic_afun.xml" target="_top">atomic_afun</a></td><td>Using AD Version of Atomic Function</td></tr><tr><td><a href="atomic_forward.xml" target="_top">atomic_forward</a></td><td>Atomic Forward Mode</td></tr><tr><td><a href="atomic_reverse.xml" target="_top">atomic_reverse</a></td><td>Atomic Reverse Mode</td></tr><tr><td><a href="atomic_for_sparse_jac.xml" target="_top">atomic_for_sparse_jac</a></td><td>Atomic Forward Jacobian Sparsity Patterns</td></tr><tr><td><a href="atomic_rev_sparse_jac.xml" target="_top">atomic_rev_sparse_jac</a></td><td>Atomic Reverse Jacobian Sparsity Patterns</td></tr><tr><td><a href="atomic_rev_sparse_hes.xml" target="_top">atomic_rev_sparse_hes</a></td><td>Atomic Reverse Hessian Sparsity Patterns</td></tr><tr><td><a href="atomic_base_clear.xml" target="_top">atomic_base_clear</a></td><td>Free Static Variables</td></tr><tr><td><a href="atomic_get_started.cpp.xml" target="_top">atomic_get_started.cpp</a></td><td>Getting Started with Atomic Operations: Example and Test</td></tr><tr><td><a href="atomic_norm_sq.cpp.xml" target="_top">atomic_norm_sq.cpp</a></td><td>Euclidean Norm Squared: Example and Test</td></tr><tr><td><a href="atomic_reciprocal.cpp.xml" target="_top">atomic_reciprocal.cpp</a></td><td>Reciprocal as an Atomic Operation: Example and Test</td></tr><tr><td><a href="atomic_tangent.cpp.xml" target="_top">atomic_tangent.cpp</a></td><td>Tan and Tanh as User Atomic Operations: Example and Test</td></tr><tr><td><a href="atomic_hes_sparse.cpp.xml" target="_top">atomic_hes_sparse.cpp</a></td><td>Atomic Operation Hessian Sparsity: Example and Test</td></tr><tr><td><a href="atomic_mat_mul.cpp.xml" target="_top">atomic_mat_mul.cpp</a></td><td>User Atomic Matrix Multiply: Example and Test</td></tr></table><br/>
225	228	<b><big><a name="Examples" id="Examples">Examples</a></big></b>
226	229
227	230

251	254	contains another example
252	255	where the user provides the code for computing derivatives.
253	256	This example is more complex because the range has two components.
	257
	258	<br/>
	259	<br/>
	260	<b><a name="Examples.Hessian Sparsity Patterns" id="Examples.Hessian Sparsity Patterns">Hessian Sparsity Patterns</a></b>
	261	<br/>
	262	The file <a href="atomic_hes_sparse.cpp.xml" target="_top"><span style='white-space: nowrap'>atomic_hes_sparse.cpp</span></a>
	263	contains an minimal example
	264	where the user provides the code for computing Hessian sparsity patterns.
254	265
255	266	<br/>
256	267	<br/>

-1

doc/atomic_base_clear.xml less more

3	3	>
4	4	<head>
5	5	<title>Free Static Variables</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Free Static Variables"/>
7		<meta name="keywords" id="keywords" content=" free atomic static clear "/>
	8	<meta name="keywords" id="keywords" content=" free static variables atomic clear syntax purpose future use restriction "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

-1

doc/atomic_ctor.xml less more

3	3	>
4	4	<head>
5	5	<title>Atomic Function Constructor</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Atomic Function Constructor"/>
7		<meta name="keywords" id="keywords" content=" constructor atomic function "/>
	8	<meta name="keywords" id="keywords" content=" atomic function constructor syntax atomic_user ctor_arg_list afun implementation atomic_base restrictions base name examples define use "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

-1

doc/atomic_for_sparse_jac.xml less more

3	3	>
4	4	<head>
5	5	<title>Atomic Forward Jacobian Sparsity Patterns</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Atomic Forward Jacobian Sparsity Patterns"/>
7		<meta name="keywords" id="keywords" content=" atomic for_sparse_jac callback virtual "/>
	8	<meta name="keywords" id="keywords" content=" atomic forward jacobian sparsity patterns for_sparse_jac callback virtual syntax purpose implementation q r s ok examples define use "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

+38

-36

doc/atomic_forward.xml less more

3	3	>
4	4	<head>
5	5	<title>Atomic Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Atomic Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" atomic forward callback virtual "/>
	8	<meta name="keywords" id="keywords" content=" atomic forward mode callback virtual syntax purpose implementation p q vx vy tx ty ok discussion examples define use "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

87	89	<option>Syntax</option>
88	90	<option>Purpose</option>
89	91	<option>Implementation</option>
	92	<option>p</option>
90	93	<option>q</option>
91		<option>p</option>
92	94	<option>vx</option>
93	95	<option>vy</option>
94	96	<option>tx</option>

110	112
111	113	<br/>
112	114
113		<code><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.forward(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>vx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>vy</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
	115	<code><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.forward(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>vx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>vy</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
114	116
115	117
116	118	<br/>

136	138
137	139	(and not compute anything) for values
138	140	of
139		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> > 0</span></font></code>
	141	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> > 0</span></font></code>
140	142	that are greater than those used by your
141	143	<a href="forward.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
142	144	mode calculations.
143	145
144	146	<br/>
145	147	<br/>
146		<b><big><a name="q" id="q">q</a></big></b>
	148	<b><big><a name="p" id="p">p</a></big></b>
147	149	<br/>
148	150	The argument
149		<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
	151	<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
150	152	has prototype
151	153
152	154	<code><font color="blue"><span style='white-space: nowrap'><br/>
153		size_t </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	155	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
154	156	</span></font></code>
155	157	It specifies the lowest order Taylor coefficient that we are evaluating.
156	158	During calls to <a href="atomic_afun.xml" target="_top"><span style='white-space: nowrap'>atomic_afun</span></a>
157	159	,
158		<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
159		.
160
161		<br/>
162		<br/>
163		<b><big><a name="p" id="p">p</a></big></b>
	160	<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
	161	.
	162
	163	<br/>
	164	<br/>
	165	<b><big><a name="q" id="q">q</a></big></b>
164	166	<br/>
165	167	The argument
166		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
	168	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
167	169	has prototype
168	170
169	171	<code><font color="blue"><span style='white-space: nowrap'><br/>
170		size_t </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	172	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
171	173	</span></font></code>
172	174	It specifies the highest order Taylor coefficient that we are evaluating.
173	175	During calls to <a href="atomic_afun.xml" target="_top"><span style='white-space: nowrap'>atomic_afun</span></a>
174	176	,
175		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
	177	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
176	178	.
177	179
178	180	<br/>

193	195	.
194	196	In this case,
195	197
196		<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> == </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
	198	<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> == </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
197	199	,
198	200
199	201	<code><i><font color="black"><span style='white-space: nowrap'>vx</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>

247	249	, it should not be used.
248	250	Otherwise,
249	251
250		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
	252	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
251	253	and
252	254	<code><i><font color="black"><span style='white-space: nowrap'>vy</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
253	255	.

290	292	const CppAD::vector<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>>& </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
291	293	</span></font></code>
292	294	and
293		<code><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == (</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)*</span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	295	<code><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == (</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)*</span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
294	296	.
295	297	For
296	298	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

312	314	<mo stretchy="false">,</mo>
313	315	<mo stretchy="false">…</mo>
314	316	<mo stretchy="false">,</mo>
315		<mi mathvariant='italic'>p</mi>
	317	<mi mathvariant='italic'>q</mi>
316	318	</mrow></math>
317	319
318	320	,

332	334	<mi mathvariant='italic'>j</mi>
333	335	<mo stretchy="false">*</mo>
334	336	<mo stretchy="false">(</mo>
335		<mi mathvariant='italic'>p</mi>
	337	<mi mathvariant='italic'>q</mi>
336	338	<mo stretchy="false">+</mo>
337	339	<mn>1</mn>
338	340	<mo stretchy="false">)</mo>

366	368	<mo stretchy="false">+</mo>
367	369	<msubsup><mi mathvariant='italic'>x</mi>
368	370	<mi mathvariant='italic'>j</mi>
369		<mi mathvariant='italic'>p</mi>
	371	<mi mathvariant='italic'>q</mi>
370	372	</msubsup>
371	373	<msup><mi mathvariant='italic'>t</mi>
372		<mi mathvariant='italic'>p</mi>
	374	<mi mathvariant='italic'>q</mi>
373	375	</msup>
374	376	</mtd></mtr></mtable>
375	377	</mrow></math>

452	454	CppAD::vector<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>>& </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
453	455	</span></font></code>
454	456	and
455		<code><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == (</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)*</span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
	457	<code><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == (</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)*</span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
456	458	.
457	459	Upon return,
458	460	For

475	477	<mo stretchy="false">,</mo>
476	478	<mo stretchy="false">…</mo>
477	479	<mo stretchy="false">,</mo>
478		<mi mathvariant='italic'>p</mi>
	480	<mi mathvariant='italic'>q</mi>
479	481	</mrow></math>
480	482
481	483	,

527	529	<mo stretchy="false">+</mo>
528	530	<msubsup><mi mathvariant='italic'>y</mi>
529	531	<mi mathvariant='italic'>i</mi>
530		<mi mathvariant='italic'>p</mi>
	532	<mi mathvariant='italic'>q</mi>
531	533	</msubsup>
532	534	<msup><mi mathvariant='italic'>t</mi>
533		<mi mathvariant='italic'>p</mi>
	535	<mi mathvariant='italic'>q</mi>
534	536	</msup>
535	537	<mo stretchy="false">+</mo>
536	538	<mi mathvariant='italic'>o</mi>
537	539	<mo stretchy="false">(</mo>
538	540	<msup><mi mathvariant='italic'>t</mi>
539		<mi mathvariant='italic'>p</mi>
	541	<mi mathvariant='italic'>q</mi>
540	542	</msup>
541	543	<mo stretchy="false">)</mo>
542	544	</mtd></mtr><mtr><mtd columnalign="right" >

545	547	<mi mathvariant='italic'>i</mi>
546	548	<mo stretchy="false">*</mo>
547	549	<mo stretchy="false">(</mo>
548		<mi mathvariant='italic'>p</mi>
	550	<mi mathvariant='italic'>q</mi>
549	551	<mo stretchy="false">+</mo>
550	552	<mn>1</mn>
551	553	<mo stretchy="false">)</mo>

567	569	<mi mathvariant='italic'>o</mi>
568	570	<mo stretchy="false">(</mo>
569	571	<msup><mi mathvariant='italic'>t</mi>
570		<mi mathvariant='italic'>p</mi>
	572	<mi mathvariant='italic'>q</mi>
571	573	</msup>
572	574	<mo stretchy="false">)</mo>
573	575	<mo stretchy="false">/</mo>
574	576	<msup><mi mathvariant='italic'>t</mi>
575		<mi mathvariant='italic'>p</mi>
	577	<mi mathvariant='italic'>q</mi>
576	578	</msup>
577	579	<mo stretchy="false">→</mo>
578	580	<mn>0</mn>

655	657
656	658	If
657	659	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
658		<mi mathvariant='italic'>q</mi>
	660	<mi mathvariant='italic'>p</mi>
659	661	<mo stretchy="false">></mo>
660	662	<mn>0</mn>
661	663	</mrow></math>

681	683	<mo stretchy="false">,</mo>
682	684	<mo stretchy="false">…</mo>
683	685	<mo stretchy="false">,</mo>
684		<mi mathvariant='italic'>q</mi>
	686	<mi mathvariant='italic'>p</mi>
685	687	<mn>-1</mn>
686	688	</mrow></math>
687	689

696	698	<mi mathvariant='italic'>i</mi>
697	699	<mo stretchy="false">*</mo>
698	700	<mo stretchy="false">(</mo>
699		<mi mathvariant='italic'>p</mi>
	701	<mi mathvariant='italic'>q</mi>
700	702	<mo stretchy="false">+</mo>
701	703	<mn>1</mn>
702	704	<mo stretchy="false">)</mo>

726	728	<b><big><a name="Discussion" id="Discussion">Discussion</a></big></b>
727	729	<br/>
728	730	For example, suppose that
729		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> == 2</span></font></code>
	731	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> == 2</span></font></code>
730	732	,
731	733	and you know how to compute the function
732	734	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

1021	1023	<mi mathvariant='italic'>i</mi>
1022	1024	<mo stretchy="false">*</mo>
1023	1025	<mo stretchy="false">(</mo>
1024		<mi mathvariant='italic'>p</mi>
	1026	<mi mathvariant='italic'>q</mi>
1025	1027	<mo stretchy="false">+</mo>
1026	1028	<mn>1</mn>
1027	1029	<mo stretchy="false">)</mo>

+14

-12

doc/atomic_get_started.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Getting Started with Atomic Operations: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Getting Started with Atomic Operations: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" get_started atomic operation "/>
	8	<meta name="keywords" id="keywords" content=" getting started with atomic operations: example and test get_started operation purpose start class definition constructor forward end use function recording "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

140	142	<code><font color='blue'><pre style='display:inline'>
141	143	// forward mode routine called by CppAD
142	144	virtual bool forward(
	145	size_t p ,
143	146	size_t q ,
144		size_t p ,
145	147	const vector<bool>& vx ,
146	148	vector<bool>& vy ,
147	149	const vector<double>& tx ,
148	150	vector<double>& ty
149	151	)
150		{ size_t n = tx.size() / (p + 1);
151		size_t m = ty.size() / (p + 1);
	152	{ size_t n = tx.size() / (q + 1);
	153	size_t m = ty.size() / (q + 1);
152	154	assert( n == 1 );
153	155	assert( m == 1 );
154	156
155	157	// return flag
156		bool ok = p == 0;
	158	bool ok = q == 0;
157	159	if( ! ok )
158	160	return ok;
159	161

166	168	// This case must always be implemented
167	169	// y^0 = f( x^0 ) = 1 / x^0
168	170	double f = 1. / tx[0];
169		if( q <= 0 )
	171	if( p <= 0 )
170	172	ty[0] = f;
171	173	return ok;
172	174	}

245	247	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
246	248
247	249	// check zero order forward mode
248		size_t p;
249		vector<double> x_p(n), y_p(m);
250		p = 0;
251		x_p[0] = x0;
252		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
253		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	250	size_t q;
	251	vector<double> x_q(n), y_q(m);
	252	q = 0;
	253	x_q[0] = x0;
	254	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	255	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
254	256
255	257	return ok;
256	258	}

+387

-0

doc/atomic_hes_sparse.cpp.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Atomic Operation Hessian Sparsity: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Atomic Operation Hessian Sparsity: Example and Test"/>
	8	<meta name="keywords" id="keywords" content=" atomic operation hessian sparsity: example and test sparsity purpose start class definition constructor forward for_sparse_jac rev_sparse_hes use function with x_1 both a variable parameter "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_atomic_hes_sparse.cpp_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="atomic_tangent.cpp.xml" target="_top">Prev</a>
	25	</td><td><a href="atomic_mat_mul.cpp.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>AD</option>
	41	<option>ADValued</option>
	42	<option>atomic</option>
	43	<option>atomic_base</option>
	44	<option>atomic_hes_sparse.cpp</option>
	45	</select>
	46	</td>
	47	<td>
	48	<select onchange='choose_down3(this)'>
	49	<option>ADValued-></option>
	50	<option>Arithmetic</option>
	51	<option>std_math_ad</option>
	52	<option>MathOther</option>
	53	<option>CondExp</option>
	54	<option>Discrete</option>
	55	<option>atomic</option>
	56	</select>
	57	</td>
	58	<td>
	59	<select onchange='choose_down2(this)'>
	60	<option>atomic-></option>
	61	<option>checkpoint</option>
	62	<option>atomic_base</option>
	63	</select>
	64	</td>
	65	<td>
	66	<select onchange='choose_down1(this)'>
	67	<option>atomic_base-></option>
	68	<option>atomic_ctor</option>
	69	<option>atomic_option</option>
	70	<option>atomic_afun</option>
	71	<option>atomic_forward</option>
	72	<option>atomic_reverse</option>
	73	<option>atomic_for_sparse_jac</option>
	74	<option>atomic_rev_sparse_jac</option>
	75	<option>atomic_rev_sparse_hes</option>
	76	<option>atomic_base_clear</option>
	77	<option>atomic_get_started.cpp</option>
	78	<option>atomic_norm_sq.cpp</option>
	79	<option>atomic_reciprocal.cpp</option>
	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
	82	<option>atomic_mat_mul.cpp</option>
	83	</select>
	84	</td>
	85	<td>atomic_hes_sparse.cpp</td>
	86	<td>
	87	<select onchange='choose_current0(this)'>
	88	<option>Headings-></option>
	89	<option>Purpose</option>
	90	<option>Start Class Definition</option>
	91	<option>Constructor</option>
	92	<option>forward</option>
	93	<option>for_sparse_jac</option>
	94	<option>rev_sparse_hes</option>
	95	<option>Use Atomic Function</option>
	96	<option>Test with x_1 Both a Variable and a Parameter</option>
	97	</select>
	98	</td>
	99	</tr></table><br/>
	100
	101
	102	<center><b><big><big>Atomic Operation Hessian Sparsity: Example and Test</big></big></b></center>
	103	<br/>
	104	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	105	<br/>
	106	This example demonstrates calculation of the Hessian sparsity pattern
	107	for an atomic operation.
	108
	109
	110
	111	<br/>
	112	<br/>
	113	<b><big><a name="Start Class Definition" id="Start Class Definition">Start Class Definition</a></big></b>
	114
	115	<code><font color='blue'><pre style='display:inline'>
	116	# include <cppad/cppad.hpp>
	117	namespace { // isolate items below to this file
	118	using CppAD::vector; // abbreviate as vector
	119	//
	120	// a utility to compute the union of two sets.
	121	void my_union(
	122	std::set<size_t>& result ,
	123	const std::set<size_t>& left ,
	124	const std::set<size_t>& right )
	125	{ std::set<size_t> temp;
	126	std::set_union(
	127	left.begin() ,
	128	left.end() ,
	129	right.begin() ,
	130	right.end() ,
	131	std::inserter(temp, temp.begin())
	132	);
	133	result.swap(temp);
	134	}
	135	//
	136	class atomic_hes_sparse : public CppAD::atomic_base<double> {
	137	</pre></font></code>
	138
	139	<br/>
	140	<br/>
	141	<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
	142
	143	<code><font color='blue'><pre style='display:inline'>
	144	public:
	145	// constructor (could use const char* for name)
	146	atomic_hes_sparse(const std::string& name) :
	147	CppAD::atomic_base<double>(name)
	148	{ }
	149	private:
	150	</pre></font></code>
	151
	152	<br/>
	153	<br/>
	154	<b><big><a name="forward" id="forward">forward</a></big></b>
	155
	156	<code><font color='blue'><pre style='display:inline'>
	157	// forward mode routine called by CppAD
	158	virtual bool forward(
	159	size_t p ,
	160	size_t q ,
	161	const vector<bool>& vx ,
	162	vector<bool>& vy ,
	163	const vector<double>& tx ,
	164	vector<double>& ty
	165	)
	166	{ size_t n = tx.size() / (q + 1);
	167	size_t m = ty.size() / (q + 1);
	168	assert( n == 2 );
	169	assert( m == 2 );
	170
	171	// return flag
	172	bool ok = q == 0;
	173	if( ! ok )
	174	return ok;
	175
	176	// check for defining variable information
	177	// This case must always be implemented
	178	if( vx.size() > 0 )
	179	{ vy[0] = vx[0];
	180	vy[1] = vx[0] \|\| vy[0];
	181	}
	182
	183	// Order zero forward mode.
	184	// This case must always be implemented
	185	// y^0 = f( x^0 ) = [ x0_0 * x0_0 , x0_0 * x0_1 ]^T
	186	assert( p <= 0 );
	187	if( p <= 0 )
	188	{ ty[0] = tx[0] * tx[0];
	189	ty[1] = tx[0] * tx[1];
	190	}
	191	return ok;
	192	}
	193	</pre></font></code>
	194
	195	<br/>
	196	<br/>
	197	<b><big><a name="for_sparse_jac" id="for_sparse_jac">for_sparse_jac</a></big></b>
	198
	199	<code><font color='blue'><pre style='display:inline'>
	200	// forward Jacobian set sparsity routine called by CppAD
	201	virtual bool for_sparse_jac(
	202	size_t p ,
	203	const vector< std::set<size_t> >& r ,
	204	vector< std::set<size_t> >& s )
	205	{ // This function needed if using f.ForSparseJac
	206	// with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
	207	size_t n = r.size();
	208	size_t m = s.size();
	209	assert( n == 2 );
	210	assert( m == 2 );
	211
	212	// sparsity for S(x) = f'(x) * R is union of rows of R
	213	s[0] = r[0];
	214	my_union(s[1], r[0], r[1]);
	215
	216	return true;
	217	}
	218	</pre></font></code>
	219
	220	<br/>
	221	<br/>
	222	<b><big><a name="rev_sparse_hes" id="rev_sparse_hes">rev_sparse_hes</a></big></b>
	223
	224	<code><font color='blue'><pre style='display:inline'>
	225	// reverse Hessian set sparsity routine called by CppAD
	226	virtual bool rev_sparse_hes(
	227	const vector<bool>& vx,
	228	const vector<bool>& s ,
	229	vector<bool>& t ,
	230	size_t p ,
	231	const vector< std::set<size_t> >& r ,
	232	const vector< std::set<size_t> >& u ,
	233	vector< std::set<size_t> >& v )
	234	{ // This function needed if using RevSparseHes
	235	// with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
	236	size_t n = vx.size();
	237	size_t m = s.size();
	238	assert( t.size() == n );
	239	assert( r.size() == n );
	240	assert( u.size() == m );
	241	assert( v.size() == n );
	242	assert( n == 2 );
	243	assert( m == 2 );
	244
	245	// There are no cross term second derivatives for this case,
	246	// so it is not necessary to vx.
	247
	248	// sparsity for T(x) = S(x) * f'(x)
	249	t[0] = s[0];
	250	t[1] = s[0] \|\| s[1];
	251
	252	// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
	253	// U(x) = g''(y) * f'(x) * R
	254	// S(x) = g'(y)
	255
	256	// back propagate the sparsity for U,
	257	// note both components of f'(x) may be non-zero;
	258	v[0] = u[0];
	259	my_union(v[1], u[0], u[1]);
	260
	261	// include forward Jacobian sparsity in Hessian sparsity
	262	// f_0''(x) * R
	263	if( s[0] )
	264	my_union(v[0], v[0], r[0] );
	265	// f_1''(x) * R
	266	if( s[1] )
	267	{ my_union(v[1], v[1], r[0] );
	268	my_union(v[0], v[0], r[1] );
	269	}
	270	return true;
	271	}
	272	}; // End of atomic_hes_sparse class
	273
	274	</pre></font></code>
	275
	276	<br/>
	277	<br/>
	278	<b><big><a name="Use Atomic Function" id="Use Atomic Function">Use Atomic Function</a></big></b>
	279
	280	<code><font color='blue'><pre style='display:inline'>
	281	bool use_atomic_hes_sparse(bool x_1_variable)
	282	{ bool ok = true;
	283	using CppAD::AD;
	284	using CppAD::NearEqual;
	285	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	286	//
	287	// Create the atomic hes_sparse object
	288	atomic_hes_sparse afun("atomic_hes_sparse");
	289	//
	290	// Create the function f(u)
	291	//
	292	// domain space vector
	293	size_t n = 2;
	294	double x0_0 = 0.75, x0_1 = 2.00;
	295	vector< <a href="ad.xml" target="_top">AD</a><double> > au(n);
	296	au[0] = x0_0;
	297	au[1] = x0_1;
	298
	299	// declare independent variables and start tape recording
	300	CppAD::<a href="independent.xml" target="_top">Independent</a>(au);
	301
	302	// range space vector
	303	size_t m = 2;
	304	vector< <a href="ad.xml" target="_top">AD</a><double> > ay(m);
	305
	306	// call user function
	307	vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
	308	ax[0] = au[0];
	309	if( x_1_variable )
	310	ax[1] = au[1];
	311	else
	312	ax[1] = x0_1;
	313	afun(ax, ay); // y = [ x[0] * x[0] , x[0] * x[1] ] ^T
	314
	315	// create f: u -> y and stop tape recording
	316	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
	317	f.Dependent (au, ay); // f(u) = y
	318	//
	319	// check function value
	320	double check_y0_0 = x0_0 * x0_0;
	321	double check_y0_1 = x0_0 * x0_1;
	322	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check_y0_0, eps, eps);
	323	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[1]) , check_y0_1, eps, eps);
	324
	325	// check zero order forward mode
	326	size_t q;
	327	vector<double> uq(n), yq(m);
	328	q = 0;
	329	uq[0] = x0_0;
	330	uq[1] = x0_1;
	331	yq = f.<a href="forward.xml" target="_top">Forward</a>(q, uq);
	332	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(yq[0] , check_y0_0, eps, eps);
	333	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(yq[1] , check_y0_1, eps, eps);
	334
	335	// forward sparse jacobian
	336	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
	337	vector< std::set<size_t> > r(2), jac_s(2), check_s(2);
	338	r[0].insert(0);
	339	r[1].insert(1);
	340	jac_s = f.ForSparseJac(n, r);
	341	check_s[0].insert(0);
	342	ok &= jac_s[0] == check_s[0];
	343	check_s[1].insert(0);
	344	if( x_1_variable )
	345	check_s[1].insert(1);
	346	ok &= jac_s[1] == check_s[1];
	347
	348	// reverse sparse Hessian
	349	vector< std::set<size_t> > h(2), check_h(2), hes_s(1);
	350	hes_s[0].insert(0);
	351	hes_s[0].insert(1);
	352	h = f.RevSparseHes(n, hes_s);
	353	check_h[0].insert(0);
	354	if( x_1_variable )
	355	check_h[0].insert(1);
	356	ok &= h[0] == check_h[0];
	357	if( x_1_variable )
	358	check_h[1].insert(0);
	359	ok &= h[1] == check_h[1];
	360
	361	return ok;
	362	}
	363	} // End empty namespace
	364	</pre></font></code>
	365
	366	<br/>
	367	<br/>
	368	<b><big><a name="Test with x_1 Both a Variable and a Parameter" id="Test with x_1 Both a Variable and a Parameter">Test with x_1 Both a Variable and a Parameter</a></big></b>
	369
	370	<code><font color='blue'><pre style='display:inline'>
	371	bool hes_sparse(void)
	372	{ bool ok = true;
	373	// test with x_1 a variable
	374	ok &= use_atomic_hes_sparse(true);
	375	// test with x_1 a parameter
	376	ok &= use_atomic_hes_sparse(false);
	377	return ok;
	378	}
	379	</pre></font></code>
	380
	381
	382
	383	<hr/>Input File: example/atomic/hes_sparse.cpp
	384
	385	</body>
	386	</html>

-2

doc/atomic_mat_mul.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>User Atomic Matrix Multiply: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="User Atomic Matrix Multiply: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" atomic matrix multiply example "/>
	8	<meta name="keywords" id="keywords" content=" user atomic matrix multiply: example and test multiply class definition use function constructor recording forward reverse option for_sparse_jac rev_sparse_jac rev_sparse_hes "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="atomic_tangent.cpp.xml" target="_top">Prev</a>
	24	<td><a href="atomic_hes_sparse.cpp.xml" target="_top">Prev</a>
24	25	</td><td><a href="atomic_matrix_mul.hpp.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

-1

doc/atomic_matrix_mul.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Matrix Multiply as an Atomic Operation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Matrix Multiply as an Atomic Operation"/>
7		<meta name="keywords" id="keywords" content=" multiply matrix atomic operation "/>
	8	<meta name="keywords" id="keywords" content=" matrix multiply as an atomic operation start class definition constructor left operand element index right result forward multipliy reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

67	68	<option>atomic_norm_sq.cpp</option>
68	69	<option>atomic_reciprocal.cpp</option>
69	70	<option>atomic_tangent.cpp</option>
	71	<option>atomic_hes_sparse.cpp</option>
70	72	<option>atomic_mat_mul.cpp</option>
71	73	</select>
72	74	</td>

+76

-74

doc/atomic_norm_sq.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Euclidean Norm Squared: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Euclidean Norm Squared: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" norm_sq atomic operation Euclidean norm example "/>
	8	<meta name="keywords" id="keywords" content=" euclidean norm squared: example and test norm_sq atomic operation Euclidean theory start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

210	212	<code><font color='blue'><pre style='display:inline'>
211	213	// forward mode routine called by CppAD
212	214	virtual bool forward(
	215	size_t p ,
213	216	size_t q ,
214		size_t p ,
215	217	const vector<bool>& vx ,
216	218	vector<bool>& vy ,
217	219	const vector<double>& tx ,
218	220	vector<double>& ty
219	221	)
220		{ size_t n = tx.size() / (p+1);
221		size_t m = ty.size() / (p+1);
222		assert( n == 2 );
223		assert( m == 1 );
224		assert( q <= p );
	222	{ size_t n = tx.size() / (q+1);
	223	size_t m = ty.size() / (q+1);
	224	assert( n == 2 );
	225	assert( m == 1 );
	226	assert( p <= q );
225	227
226	228	// return flag
227		bool ok = p <= 1;
	229	bool ok = q <= 1;
228	230
229	231	// Variable information must always be implemented.
230	232	// y_0 is a variable if and only if x_0 or x_1 is a variable.

233	235
234	236	// Order zero forward mode must always be implemented.
235	237	// y^0 = f( x^0 )
236		double x_00 = tx[ 0*(p+1) + 0]; // x_0^0
237		double x_10 = tx[ 1*(p+1) + 0]; // x_10
	238	double x_00 = tx[ 0*(q+1) + 0]; // x_0^0
	239	double x_10 = tx[ 1*(q+1) + 0]; // x_10
238	240	double f = x_00 * x_00 + x_10 * x_10; // f( x^0 )
	241	if( p <= 0 )
	242	ty[0] = f; // y_0^0
239	243	if( q <= 0 )
240		ty[0] = f; // y_0^0
241		if( p <= 0 )
242	244	return ok;
243	245	assert( vx.size() == 0 );
244	246
245	247	// Order one forward mode.
246	248	// This case needed if first order forward mode is used.
247	249	// y^1 = f'( x^0 ) x^1
248		double x_01 = tx[ 0*(p+1) + 1]; // x_0^1
249		double x_11 = tx[ 1*(p+1) + 1]; // x_1^1
	250	double x_01 = tx[ 0*(q+1) + 1]; // x_0^1
	251	double x_11 = tx[ 1*(q+1) + 1]; // x_1^1
250	252	double fp_0 = 2.0 * x_00; // partial f w.r.t x_0^0
251	253	double fp_1 = 2.0 * x_10; // partial f w.r.t x_1^0
	254	if( p <= 1 )
	255	ty[1] = fp_0 * x_01 + fp_1 * x_11; // f'( x^0 ) * x^1
252	256	if( q <= 1 )
253		ty[1] = fp_0 * x_01 + fp_1 * x_11; // f'( x^0 ) * x^1
254		if( p <= 1 )
255	257	return ok;
256	258
257	259	// Assume we are not using forward mode with order > 1

267	269	<code><font color='blue'><pre style='display:inline'>
268	270	// reverse mode routine called by CppAD
269	271	virtual bool reverse(
270		size_t p ,
	272	size_t q ,
271	273	const vector<double>& tx ,
272	274	const vector<double>& ty ,
273	275	vector<double>& px ,
274	276	const vector<double>& py
275	277	)
276		{ size_t n = tx.size() / (p+1);
277		size_t m = ty.size() / (p+1);
278		assert( px.size() == n * (p+1) );
279		assert( py.size() == m * (p+1) );
280		assert( n == 2 );
281		assert( m == 1 );
282		bool ok = p <= 1;
	278	{ size_t n = tx.size() / (q+1);
	279	size_t m = ty.size() / (q+1);
	280	assert( px.size() == n * (q+1) );
	281	assert( py.size() == m * (q+1) );
	282	assert( n == 2 );
	283	assert( m == 1 );
	284	bool ok = q <= 1;
283	285
284	286	double fp_0, fp_1;
285		switch(p)
	287	switch(q)
286	288	{ case 0:
287	289	// This case needed if first order reverse mode is used
288	290	// F ( {x} ) = f( x^0 ) = y^0

294	296	break;
295	297
296	298	default:
297		// Assume we are not using reverse with order > 1 (p > 0)
	299	// Assume we are not using reverse with order > 1 (q > 0)
298	300	assert(!ok);
299	301	}
300	302	return ok;

308	310	<code><font color='blue'><pre style='display:inline'>
309	311	// forward Jacobian bool sparsity routine called by CppAD
310	312	virtual bool for_sparse_jac(
311		size_t q ,
	313	size_t p ,
312	314	const vector<bool>& r ,
313	315	vector<bool>& s )
314	316	{ // This function needed if using f.ForSparseJac
315	317	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
316		size_t n = r.size() / q;
317		size_t m = s.size() / q;
	318	size_t n = r.size() / p;
	319	size_t m = s.size() / p;
318	320	assert( n == 2 );
319	321	assert( m == 1 );
320	322
321	323	// sparsity for S(x) = f'(x) * R
322	324	// where f'(x) = 2 * [ x_0, x_1 ]
323		for(size_t j = 0; j < q; j++)
	325	for(size_t j = 0; j < p; j++)
324	326	{ s[j] = false;
325	327	for(size_t i = 0; i < n; i++)
326		s[j] \|= r[i * q + j];
	328	s[j] \|= r[i * p + j];
327	329	}
328	330	return true;
329	331	}
330	332	// forward Jacobian set sparsity routine called by CppAD
331	333	virtual bool for_sparse_jac(
332		size_t q ,
	334	size_t p ,
333	335	const vector< std::set<size_t> >& r ,
334	336	vector< std::set<size_t> >& s )
335	337	{ // This function needed if using f.ForSparseJac

354	356	<code><font color='blue'><pre style='display:inline'>
355	357	// reverse Jacobian bool sparsity routine called by CppAD
356	358	virtual bool rev_sparse_jac(
357		size_t q ,
	359	size_t p ,
358	360	const vector<bool>& rt ,
359	361	vector<bool>& st )
360	362	{ // This function needed if using RevSparseJac or optimize
361	363	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
362		size_t n = st.size() / q;
363		size_t m = rt.size() / q;
	364	size_t n = st.size() / p;
	365	size_t m = rt.size() / p;
364	366	assert( n == 2 );
365	367	assert( m == 1 );
366	368
367	369	// sparsity for S(x)^T = f'(x)^T * R^T
368	370	// where f'(x)^T = 2 * [ x_0, x_1]^T
369		for(size_t j = 0; j < q; j++)
	371	for(size_t j = 0; j < p; j++)
370	372	for(size_t i = 0; i < n; i++)
371		st[i * q + j] = rt[j];
	373	st[i * p + j] = rt[j];
372	374
373	375	return true;
374	376	}
375	377	// reverse Jacobian set sparsity routine called by CppAD
376	378	virtual bool rev_sparse_jac(
377		size_t q ,
	379	size_t p ,
378	380	const vector< std::set<size_t> >& rt ,
379	381	vector< std::set<size_t> >& st )
380	382	{ // This function needed if using RevSparseJac or optimize

403	405	const vector<bool>& vx,
404	406	const vector<bool>& s ,
405	407	vector<bool>& t ,
406		size_t q ,
	408	size_t p ,
407	409	const vector<bool>& r ,
408	410	const vector<bool>& u ,
409	411	vector<bool>& v )

411	413	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
412	414	size_t m = s.size();
413	415	size_t n = t.size();
414		assert( r.size() == n * q );
415		assert( u.size() == m * q );
416		assert( v.size() == n * q );
	416	assert( r.size() == n * p );
	417	assert( u.size() == m * p );
	418	assert( v.size() == n * p );
417	419	assert( n == 2 );
418	420	assert( m == 1 );
419	421

430	432
431	433	// back propagate the sparsity for U
432	434	size_t j;
433		for(j = 0; j < q; j++)
	435	for(j = 0; j < p; j++)
434	436	for(size_t i = 0; i < n; i++)
435		v[ i * q + j] = u[j];
	437	v[ i * p + j] = u[j];
436	438
437	439	// include forward Jacobian sparsity in Hessian sparsity
438	440	// sparsity for g'(y) * f''(x) * R (Note f''(x) has same sparsity
439	441	// as the identity matrix)
440	442	if( s[0] )
441		{ for(j = 0; j < q; j++)
	443	{ for(j = 0; j < p; j++)
442	444	for(size_t i = 0; i < n; i++)
443		v[ i * q + j] \|= r[ i * q + j];
	445	v[ i * p + j] \|= r[ i * p + j];
444	446	}
445	447
446	448	return true;

450	452	const vector<bool>& vx,
451	453	const vector<bool>& s ,
452	454	vector<bool>& t ,
453		size_t q ,
	455	size_t p ,
454	456	const vector< std::set<size_t> >& r ,
455	457	const vector< std::set<size_t> >& u ,
456	458	vector< std::set<size_t> >& v )

567	569	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
568	570
569	571	// check zero order forward mode
570		size_t p;
571		vector<double> x_p(n), y_p(m);
572		p = 0;
573		x_p[0] = x0;
574		x_p[1] = x1;
575		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
576		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	572	size_t q;
	573	vector<double> x_q(n), y_q(m);
	574	q = 0;
	575	x_q[0] = x0;
	576	x_q[1] = x1;
	577	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	578	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
577	579
578	580	// check first order forward mode
579		p = 1;
580		x_p[0] = 0.3;
581		x_p[1] = 0.7;
582		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
583		check = 2.0 * x0 * x_p[0] + 2.0 * x1 * x_p[1];
584		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	581	q = 1;
	582	x_q[0] = 0.3;
	583	x_q[1] = 0.7;
	584	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	585	check = 2.0 * x0 * x_q[0] + 2.0 * x1 * x_q[1];
	586	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
585	587
586	588	</pre></font></code>
587	589

591	593
592	594	<code><font color='blue'><pre style='display:inline'>
593	595	// first order reverse mode
594		p = 1;
595		vector<double> w(m), dw(n * p);
	596	q = 1;
	597	vector<double> w(m), dw(n * q);
596	598	w[0] = 1.;
597		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(p, w);
	599	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(q, w);
598	600	check = 2.0 * x0;
599	601	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0] , check, eps, eps);
600	602	check = 2.0 * x1;

607	609
608	610	<code><font color='blue'><pre style='display:inline'>
609	611	// forward mode sparstiy pattern
610		size_t q = n;
611		CppAD::vectorBool r1(n * q), s1(m * q);
	612	size_t p = n;
	613	CppAD::vectorBool r1(n * p), s1(m * p);
612	614	r1[0] = true; r1[1] = false; // sparsity pattern identity
613	615	r1[2] = false; r1[3] = true;
614	616	//
615	617	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
616		s1 = f.ForSparseJac(q, r1);
	618	s1 = f.ForSparseJac(p, r1);
617	619	ok &= s1[0] == true; // f[0] depends on x[0]
618	620	ok &= s1[1] == true; // f[0] depends on x[1]
619	621	//
620	622	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
621		s1 = f.ForSparseJac(q, r1);
	623	s1 = f.ForSparseJac(p, r1);
622	624	ok &= s1[0] == true; // f[0] depends on x[0]
623	625	ok &= s1[1] == true; // f[0] depends on x[1]
624	626	</pre></font></code>

629	631
630	632	<code><font color='blue'><pre style='display:inline'>
631	633	// reverse mode sparstiy pattern
632		p = m;
633		CppAD::vectorBool s2(p * m), r2(p * n);
	634	q = m;
	635	CppAD::vectorBool s2(q * m), r2(q * n);
634	636	s2[0] = true; // compute sparsity pattern for f[0]
635	637	//
636	638	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
637		r2 = f.RevSparseJac(p, s2);
	639	r2 = f.RevSparseJac(q, s2);
638	640	ok &= r2[0] == true; // f[0] depends on x[0]
639	641	ok &= r2[1] == true; // f[0] depends on x[1]
640	642	//
641	643	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
642		r2 = f.RevSparseJac(p, s2);
	644	r2 = f.RevSparseJac(q, s2);
643	645	ok &= r2[0] == true; // f[0] depends on x[0]
644	646	ok &= r2[1] == true; // f[0] depends on x[1]
645	647	</pre></font></code>

650	652
651	653	<code><font color='blue'><pre style='display:inline'>
652	654	// Hessian sparsity (using previous ForSparseJac call)
653		CppAD::vectorBool s3(m), h(q * n);
	655	CppAD::vectorBool s3(m), h(p * n);
654	656	s3[0] = true; // compute sparsity pattern for f[0]
655	657	//
656	658	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
657		h = f.RevSparseHes(q, s3);
	659	h = f.RevSparseHes(p, s3);
658	660	ok &= h[0] == true; // partial of f[0] w.r.t. x[0],x[0] is non-zero
659	661	ok &= h[1] == false; // partial of f[0] w.r.t. x[0],x[1] is zero
660	662	ok &= h[2] == false; // partial of f[0] w.r.t. x[1],x[0] is zero
661	663	ok &= h[3] == true; // partial of f[0] w.r.t. x[1],x[1] is non-zero
662	664	//
663	665	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
664		h = f.RevSparseHes(q, s3);
	666	h = f.RevSparseHes(p, s3);
665	667	ok &= h[0] == true; // partial of f[0] w.r.t. x[0],x[0] is non-zero
666	668	ok &= h[1] == false; // partial of f[0] w.r.t. x[0],x[1] is zero
667	669	ok &= h[2] == false; // partial of f[0] w.r.t. x[1],x[0] is zero

-1

doc/atomic_option.xml less more

3	3	>
4	4	<head>
5	5	<title>Set Atomic Function Options</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Set Atomic Function Options"/>
7		<meta name="keywords" id="keywords" content=" atomic options atomic_sparsity sparsity bool_sparsity_enum set_sparsity_enum "/>
	8	<meta name="keywords" id="keywords" content=" set atomic function options syntax atomic_sparsity sparsity bool_sparsity_enum set_sparsity_enum "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

+69

-67

doc/atomic_reciprocal.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Reciprocal as an Atomic Operation: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Reciprocal as an Atomic Operation: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" reciprocal atomic operation simple "/>
	8	<meta name="keywords" id="keywords" content=" reciprocal as an atomic operation: example and test operation simple theory start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

207	209	<code><font color='blue'><pre style='display:inline'>
208	210	// forward mode routine called by CppAD
209	211	virtual bool forward(
	212	size_t p ,
210	213	size_t q ,
211		size_t p ,
212	214	const vector<bool>& vx ,
213	215	vector<bool>& vy ,
214	216	const vector<double>& tx ,
215	217	vector<double>& ty
216	218	)
217		{ size_t n = tx.size() / (p + 1);
218		size_t m = ty.size() / (p + 1);
219		assert( n == 1 );
220		assert( m == 1 );
221		assert( q <= p );
	219	{ size_t n = tx.size() / (q + 1);
	220	size_t m = ty.size() / (q + 1);
	221	assert( n == 1 );
	222	assert( m == 1 );
	223	assert( p <= q );
222	224
223	225	// return flag
224		bool ok = p <= 2;
	226	bool ok = q <= 2;
225	227
226	228	// check for defining variable information
227	229	// This case must always be implemented

232	234	// This case must always be implemented
233	235	// y^0 = f( x^0 ) = 1 / x^0
234	236	double f = 1. / tx[0];
	237	if( p <= 0 )
	238	ty[0] = f;
235	239	if( q <= 0 )
236		ty[0] = f;
237		if( p <= 0 )
238	240	return ok;
239	241	assert( vx.size() == 0 );
240	242

242	244	// This case needed if first order forward mode is used.
243	245	// y^1 = f'( x^0 ) x^1
244	246	double fp = - f / tx[0];
	247	if( p <= 1 )
	248	ty[1] = fp * tx[1];
245	249	if( q <= 1 )
246		ty[1] = fp * tx[1];
247		if( p <= 1 )
248	250	return ok;
249	251
250	252	// Order two forward mode.

253	255	// 2 y^2 = x^1 * f''( x^0 ) x^1 + 2 f'( x^0 ) x^2
254	256	double fpp = - 2.0 * fp / tx[0];
255	257	ty[2] = tx[1] * fpp * tx[1] / 2.0 + fp * tx[2];
256		if( p <= 2 )
	258	if( q <= 2 )
257	259	return ok;
258	260
259	261	// Assume we are not using forward mode with order > 2

269	271	<code><font color='blue'><pre style='display:inline'>
270	272	// reverse mode routine called by CppAD
271	273	virtual bool reverse(
272		size_t p ,
	274	size_t q ,
273	275	const vector<double>& tx ,
274	276	const vector<double>& ty ,
275	277	vector<double>& px ,
276	278	const vector<double>& py
277	279	)
278		{ size_t n = tx.size() / (p + 1);
279		size_t m = ty.size() / (p + 1);
280		assert( px.size() == n * (p + 1) );
281		assert( py.size() == m * (p + 1) );
282		assert( n == 1 );
283		assert( m == 1 );
284		bool ok = p <= 2;
	280	{ size_t n = tx.size() / (q + 1);
	281	size_t m = ty.size() / (q + 1);
	282	assert( px.size() == n * (q + 1) );
	283	assert( py.size() == m * (q + 1) );
	284	assert( n == 1 );
	285	assert( m == 1 );
	286	bool ok = q <= 2;
285	287
286	288	double f, fp, fpp, fppp;
287		switch(p)
	289	switch(q)
288	290	{ case 0:
289	291	// This case needed if first order reverse mode is used
290	292	// reverse: F^0 ( tx ) = y^0 = f( x^0 )

340	342	<code><font color='blue'><pre style='display:inline'>
341	343	// forward Jacobian bool sparsity routine called by CppAD
342	344	virtual bool for_sparse_jac(
343		size_t q ,
	345	size_t p ,
344	346	const vector<bool>& r ,
345	347	vector<bool>& s )
346	348	{ // This function needed if using f.ForSparseJac
347	349	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
348		size_t n = r.size() / q;
349		size_t m = s.size() / q;
	350	size_t n = r.size() / p;
	351	size_t m = s.size() / p;
350	352	assert( n == 1 );
351	353	assert( m == 1 );
352	354
353	355	// sparsity for S(x) = f'(x) * R is same as sparsity for R
354		for(size_t j = 0; j < q; j++)
	356	for(size_t j = 0; j < p; j++)
355	357	s[j] = r[j];
356	358
357	359	return true;
358	360	}
359	361	// forward Jacobian set sparsity routine called by CppAD
360	362	virtual bool for_sparse_jac(
361		size_t q ,
	363	size_t p ,
362	364	const vector< std::set<size_t> >& r ,
363	365	vector< std::set<size_t> >& s )
364	366	{ // This function needed if using f.ForSparseJac

382	384	<code><font color='blue'><pre style='display:inline'>
383	385	// reverse Jacobian bool sparsity routine called by CppAD
384	386	virtual bool rev_sparse_jac(
385		size_t q ,
	387	size_t p ,
386	388	const vector<bool>& rt ,
387	389	vector<bool>& st )
388	390	{ // This function needed if using RevSparseJac or optimize
389	391	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
390		size_t n = st.size() / q;
391		size_t m = rt.size() / q;
	392	size_t n = st.size() / p;
	393	size_t m = rt.size() / p;
392	394	assert( n == 1 );
393	395	assert( m == 1 );
394	396
395	397	// sparsity for S(x)^T = f'(x)^T * R^T is same as sparsity for R^T
396		for(size_t i = 0; i < q; i++)
	398	for(size_t i = 0; i < p; i++)
397	399	st[i] = rt[i];
398	400
399	401	return true;
400	402	}
401	403	// reverse Jacobian set sparsity routine called by CppAD
402	404	virtual bool rev_sparse_jac(
403		size_t q ,
	405	size_t p ,
404	406	const vector< std::set<size_t> >& rt ,
405	407	vector< std::set<size_t> >& st )
406	408	{ // This function needed if using RevSparseJac or optimize

427	429	const vector<bool>& vx,
428	430	const vector<bool>& s ,
429	431	vector<bool>& t ,
430		size_t q ,
	432	size_t p ,
431	433	const vector<bool>& r ,
432	434	const vector<bool>& u ,
433	435	vector<bool>& v )

435	437	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
436	438	size_t m = s.size();
437	439	size_t n = t.size();
438		assert( r.size() == n * q );
439		assert( u.size() == m * q );
440		assert( v.size() == n * q );
	440	assert( r.size() == n * p );
	441	assert( u.size() == m * p );
	442	assert( v.size() == n * p );
441	443	assert( n == 1 );
442	444	assert( m == 1 );
443	445

453	455
454	456	// back propagate the sparsity for U, note f'(x) may be non-zero;
455	457	size_t j;
456		for(j = 0; j < q; j++)
	458	for(j = 0; j < p; j++)
457	459	v[j] = u[j];
458	460
459	461	// include forward Jacobian sparsity in Hessian sparsity
460	462	// (note sparsty for f''(x) * R same as for R)
461	463	if( s[0] )
462		{ for(j = 0; j < q; j++)
	464	{ for(j = 0; j < p; j++)
463	465	v[j] \|= r[j];
464	466	}
465	467

470	472	const vector<bool>& vx,
471	473	const vector<bool>& s ,
472	474	vector<bool>& t ,
473		size_t q ,
	475	size_t p ,
474	476	const vector< std::set<size_t> >& r ,
475	477	const vector< std::set<size_t> >& u ,
476	478	vector< std::set<size_t> >& v )

581	583	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
582	584
583	585	// check zero order forward mode
584		size_t p;
585		vector<double> x_p(n), y_p(m);
586		p = 0;
587		x_p[0] = x0;
588		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
589		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	586	size_t q;
	587	vector<double> x_q(n), y_q(m);
	588	q = 0;
	589	x_q[0] = x0;
	590	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	591	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
590	592
591	593	// check first order forward mode
592		p = 1;
593		x_p[0] = 1;
594		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
	594	q = 1;
	595	x_q[0] = 1;
	596	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
595	597	check = 1.;
596		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	598	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
597	599
598	600	// check second order forward mode
599		p = 2;
600		x_p[0] = 0;
601		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
	601	q = 2;
	602	x_q[0] = 0;
	603	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
602	604	check = 0.;
603		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	605	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
604	606	</pre></font></code>
605	607
606	608	<br/>

609	611
610	612	<code><font color='blue'><pre style='display:inline'>
611	613	// third order reverse mode
612		p = 3;
613		vector<double> w(m), dw(n * p);
	614	q = 3;
	615	vector<double> w(m), dw(n * q);
614	616	w[0] = 1.;
615		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(p, w);
	617	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(q, w);
616	618	check = 1.;
617	619	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0] , check, eps, eps);
618	620	check = 0.;

626	628
627	629	<code><font color='blue'><pre style='display:inline'>
628	630	// forward mode sparstiy pattern
629		size_t q = n;
630		CppAD::vectorBool r1(n * q), s1(m * q);
	631	size_t p = n;
	632	CppAD::vectorBool r1(n * p), s1(m * p);
631	633	r1[0] = true; // compute sparsity pattern for x[0]
632	634	//
633	635	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
634		s1 = f.ForSparseJac(q, r1);
	636	s1 = f.ForSparseJac(p, r1);
635	637	ok &= s1[0] == true; // f[0] depends on x[0]
636	638	//
637	639	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
638		s1 = f.ForSparseJac(q, r1);
	640	s1 = f.ForSparseJac(p, r1);
639	641	ok &= s1[0] == true; // f[0] depends on x[0]
640	642	</pre></font></code>
641	643

645	647
646	648	<code><font color='blue'><pre style='display:inline'>
647	649	// reverse mode sparstiy pattern
648		p = m;
649		CppAD::vectorBool s2(p * m), r2(p * n);
	650	q = m;
	651	CppAD::vectorBool s2(q * m), r2(q * n);
650	652	s2[0] = true; // compute sparsity pattern for f[0]
651	653	//
652	654	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
653		r2 = f.RevSparseJac(p, s2);
	655	r2 = f.RevSparseJac(q, s2);
654	656	ok &= r2[0] == true; // f[0] depends on x[0]
655	657	//
656	658	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
657		r2 = f.RevSparseJac(p, s2);
	659	r2 = f.RevSparseJac(q, s2);
658	660	ok &= r2[0] == true; // f[0] depends on x[0]
659	661	</pre></font></code>
660	662

664	666
665	667	<code><font color='blue'><pre style='display:inline'>
666	668	// Hessian sparsity (using previous ForSparseJac call)
667		CppAD::vectorBool s3(m), h(q * n);
	669	CppAD::vectorBool s3(m), h(p * n);
668	670	s3[0] = true; // compute sparsity pattern for f[0]
669	671	//
670	672	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
671		h = f.RevSparseHes(q, s3);
	673	h = f.RevSparseHes(p, s3);
672	674	ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
673	675	//
674	676	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
675		h = f.RevSparseHes(q, s3);
	677	h = f.RevSparseHes(p, s3);
676	678	ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
677	679
678	680	return ok;

-1

doc/atomic_rev_sparse_hes.xml less more

3	3	>
4	4	<head>
5	5	<title>Atomic Reverse Hessian Sparsity Patterns</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Atomic Reverse Hessian Sparsity Patterns"/>
7		<meta name="keywords" id="keywords" content=" atomic rev_sparse_hes callback virtual "/>
	8	<meta name="keywords" id="keywords" content=" atomic reverse hessian sparsity patterns rev_sparse_hes callback virtual syntax purpose implementation vx s t q r u v examples define use "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

-1

doc/atomic_rev_sparse_jac.xml less more

3	3	>
4	4	<head>
5	5	<title>Atomic Reverse Jacobian Sparsity Patterns</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Atomic Reverse Jacobian Sparsity Patterns"/>
7		<meta name="keywords" id="keywords" content=" atomic rev_sparse_jac callback virtual "/>
	8	<meta name="keywords" id="keywords" content=" atomic reverse jacobian sparsity patterns rev_sparse_jac callback virtual syntax purpose implementation q rt st ok examples define use "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

+39

-37

doc/atomic_reverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Atomic Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Atomic Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" atomic reverse callback virtual "/>
	8	<meta name="keywords" id="keywords" content=" atomic reverse mode callback virtual syntax purpose implementation q tx ty f g h py px ok examples define use "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

87	89	<option>Syntax</option>
88	90	<option>Purpose</option>
89	91	<option>Implementation</option>
90		<option>p</option>
	92	<option>q</option>
91	93	<option>tx</option>
92	94	<option>ty</option>
93	95	<option>F, G, H</option>

109	111
110	112	<br/>
111	113
112		<code><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.reverse(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>px</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>py</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
	114	<code><i><font color="black"><span style='white-space: nowrap'>ok</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>afun</span></font></i><font color="blue"><span style='white-space: nowrap'>.reverse(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>px</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>py</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
113	115
114	116
115	117	<br/>

135	137
136	138	(and not compute anything) for values
137	139	of
138		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
	140	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
139	141	that are greater than those used by your
140	142	<a href="reverse.xml" target="_top"><span style='white-space: nowrap'>reverse</span></a>
141	143	mode calculations.
142	144
143	145	<br/>
144	146	<br/>
145		<b><big><a name="p" id="p">p</a></big></b>
	147	<b><big><a name="q" id="q">q</a></big></b>
146	148	<br/>
147	149	The argument
148		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
	150	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
149	151	has prototype
150	152
151	153	<code><font color="blue"><span style='white-space: nowrap'><br/>
152		size_t </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	154	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
153	155	</span></font></code>
154	156	It specifies the highest order Taylor coefficient that
155	157	computing the derivative of.

166	168	const CppAD::vector<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>>& </span></font><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
167	169	</span></font></code>
168	170	and
169		<code><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == (</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)*</span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	171	<code><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == (</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)*</span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
170	172	.
171	173	For
172	174	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

188	190	<mo stretchy="false">,</mo>
189	191	<mo stretchy="false">…</mo>
190	192	<mo stretchy="false">,</mo>
191		<mi mathvariant='italic'>p</mi>
	193	<mi mathvariant='italic'>q</mi>
192	194	</mrow></math>
193	195
194	196	,

208	210	<mi mathvariant='italic'>j</mi>
209	211	<mo stretchy="false">*</mo>
210	212	<mo stretchy="false">(</mo>
211		<mi mathvariant='italic'>p</mi>
	213	<mi mathvariant='italic'>q</mi>
212	214	<mo stretchy="false">+</mo>
213	215	<mn>1</mn>
214	216	<mo stretchy="false">)</mo>

242	244	<mo stretchy="false">+</mo>
243	245	<msubsup><mi mathvariant='italic'>x</mi>
244	246	<mi mathvariant='italic'>j</mi>
245		<mi mathvariant='italic'>p</mi>
	247	<mi mathvariant='italic'>q</mi>
246	248	</msubsup>
247	249	<msup><mi mathvariant='italic'>t</mi>
248		<mi mathvariant='italic'>p</mi>
	250	<mi mathvariant='italic'>q</mi>
249	251	</msup>
250	252	</mtd></mtr></mtable>
251	253	</mrow></math>

328	330	const CppAD::vector<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>>& </span></font><i><font color="black"><span style='white-space: nowrap'>ty</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
329	331	</span></font></code>
330	332	and
331		<code><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == (</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)*</span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
	333	<code><i><font color="black"><span style='white-space: nowrap'>tx</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == (</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)*</span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
332	334	.
333	335	For
334	336	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

350	352	<mo stretchy="false">,</mo>
351	353	<mo stretchy="false">…</mo>
352	354	<mo stretchy="false">,</mo>
353		<mi mathvariant='italic'>p</mi>
	355	<mi mathvariant='italic'>q</mi>
354	356	</mrow></math>
355	357
356	358	,

403	405	<mo stretchy="false">+</mo>
404	406	<msubsup><mi mathvariant='italic'>y</mi>
405	407	<mi mathvariant='italic'>i</mi>
406		<mi mathvariant='italic'>p</mi>
	408	<mi mathvariant='italic'>q</mi>
407	409	</msubsup>
408	410	<msup><mi mathvariant='italic'>t</mi>
409		<mi mathvariant='italic'>p</mi>
	411	<mi mathvariant='italic'>q</mi>
410	412	</msup>
411	413	<mo stretchy="false">+</mo>
412	414	<mi mathvariant='italic'>o</mi>
413	415	<mo stretchy="false">(</mo>
414	416	<msup><mi mathvariant='italic'>t</mi>
415		<mi mathvariant='italic'>p</mi>
	417	<mi mathvariant='italic'>q</mi>
416	418	</msup>
417	419	<mo stretchy="false">)</mo>
418	420	</mtd></mtr><mtr><mtd columnalign="right" >

428	430	<mi mathvariant='italic'>i</mi>
429	431	<mo stretchy="false">*</mo>
430	432	<mo stretchy="false">(</mo>
431		<mi mathvariant='italic'>p</mi>
	433	<mi mathvariant='italic'>q</mi>
432	434	<mo stretchy="false">+</mo>
433	435	<mn>1</mn>
434	436	<mo stretchy="false">)</mo>

443	445	<mi mathvariant='italic'>o</mi>
444	446	<mo stretchy="false">(</mo>
445	447	<msup><mi mathvariant='italic'>t</mi>
446		<mi mathvariant='italic'>p</mi>
	448	<mi mathvariant='italic'>q</mi>
447	449	</msup>
448	450	<mo stretchy="false">)</mo>
449	451	<mo stretchy="false">/</mo>
450	452	<msup><mi mathvariant='italic'>t</mi>
451		<mi mathvariant='italic'>p</mi>
	453	<mi mathvariant='italic'>q</mi>
452	454	</msup>
453	455	<mo stretchy="false">→</mo>
454	456	<mn>0</mn>

545	547	<mrow><mi mathvariant='italic'>n</mi>
546	548	<mo stretchy="false">×</mo>
547	549	<mo stretchy="false">(</mo>
548		<mi mathvariant='italic'>p</mi>
	550	<mi mathvariant='italic'>q</mi>
549	551	<mo stretchy="false">+</mo>
550	552	<mn>1</mn>
551	553	<mo stretchy="false">)</mo>

579	581	<mo stretchy="false">,</mo>
580	582	<mo stretchy="false">…</mo>
581	583	<mo stretchy="false">,</mo>
582		<mi mathvariant='italic'>p</mi>
	584	<mi mathvariant='italic'>q</mi>
583	585	<mo stretchy="false">}</mo>
584	586	</mrow></math>
585	587

596	598	<mrow><mi mathvariant='italic'>m</mi>
597	599	<mo stretchy="false">×</mo>
598	600	<mo stretchy="false">(</mo>
599		<mi mathvariant='italic'>p</mi>
	601	<mi mathvariant='italic'>q</mi>
600	602	<mo stretchy="false">+</mo>
601	603	<mn>1</mn>
602	604	<mo stretchy="false">)</mo>

630	632	<mo stretchy="false">,</mo>
631	633	<mo stretchy="false">…</mo>
632	634	<mo stretchy="false">,</mo>
633		<mi mathvariant='italic'>p</mi>
	635	<mi mathvariant='italic'>q</mi>
634	636	<mo stretchy="false">}</mo>
635	637	</mrow></math>
636	638

643	645	<mrow><mi mathvariant='italic'>n</mi>
644	646	<mo stretchy="false">×</mo>
645	647	<mo stretchy="false">(</mo>
646		<mi mathvariant='italic'>p</mi>
	648	<mi mathvariant='italic'>q</mi>
647	649	<mo stretchy="false">+</mo>
648	650	<mn>1</mn>
649	651	<mo stretchy="false">)</mo>

654	656	<mrow><mi mathvariant='italic'>m</mi>
655	657	<mo stretchy="false">×</mo>
656	658	<mo stretchy="false">(</mo>
657		<mi mathvariant='italic'>p</mi>
	659	<mi mathvariant='italic'>q</mi>
658	660	<mo stretchy="false">+</mo>
659	661	<mn>1</mn>
660	662	<mo stretchy="false">)</mo>

692	694	<mrow><mi mathvariant='italic'>m</mi>
693	695	<mo stretchy="false">×</mo>
694	696	<mo stretchy="false">(</mo>
695		<mi mathvariant='italic'>p</mi>
	697	<mi mathvariant='italic'>q</mi>
696	698	<mo stretchy="false">+</mo>
697	699	<mn>1</mn>
698	700	<mo stretchy="false">)</mo>

722	724	<mrow><mi mathvariant='italic'>n</mi>
723	725	<mo stretchy="false">×</mo>
724	726	<mo stretchy="false">(</mo>
725		<mi mathvariant='italic'>p</mi>
	727	<mi mathvariant='italic'>q</mi>
726	728	<mo stretchy="false">+</mo>
727	729	<mn>1</mn>
728	730	<mo stretchy="false">)</mo>

771	773	const CppAD::vector<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>>& </span></font><i><font color="black"><span style='white-space: nowrap'>py</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
772	774	</span></font></code>
773	775	and
774		<code><i><font color="black"><span style='white-space: nowrap'>py</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == m * (</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
	776	<code><i><font color="black"><span style='white-space: nowrap'>py</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == m * (</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
775	777	.
776	778	For
777	779	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

793	795	<mo stretchy="false">,</mo>
794	796	<mo stretchy="false">…</mo>
795	797	<mo stretchy="false">,</mo>
796		<mi mathvariant='italic'>p</mi>
	798	<mi mathvariant='italic'>q</mi>
797	799	</mrow></math>
798	800
799	801	,

804	806	<mi mathvariant='italic'>i</mi>
805	807	<mo stretchy="false">*</mo>
806	808	<mo stretchy="false">(</mo>
807		<mi mathvariant='italic'>p</mi>
	809	<mi mathvariant='italic'>q</mi>
808	810	<mo stretchy="false">+</mo>
809	811	<mn>1</mn>
810	812	<mo stretchy="false">)</mo>

833	835	CppAD::vector<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>>& </span></font><i><font color="black"><span style='white-space: nowrap'>px</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
834	836	</span></font></code>
835	837	and
836		<code><i><font color="black"><span style='white-space: nowrap'>px</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == n * (</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
	838	<code><i><font color="black"><span style='white-space: nowrap'>px</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == n * (</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
837	839	.
838	840	The input values of the elements of
839	841	<code><i><font color="black"><span style='white-space: nowrap'>px</span></font></i></code>

860	862	<mo stretchy="false">,</mo>
861	863	<mo stretchy="false">…</mo>
862	864	<mo stretchy="false">,</mo>
863		<mi mathvariant='italic'>p</mi>
	865	<mi mathvariant='italic'>q</mi>
864	866	</mrow></math>
865	867
866	868	,

872	874	<mi mathvariant='italic'>j</mi>
873	875	<mo stretchy="false">*</mo>
874	876	<mo stretchy="false">(</mo>
875		<mi mathvariant='italic'>p</mi>
	877	<mi mathvariant='italic'>q</mi>
876	878	<mo stretchy="false">+</mo>
877	879	<mn>1</mn>
878	880	<mo stretchy="false">)</mo>

939	941	<mo stretchy="false">=</mo>
940	942	<mn>0</mn>
941	943	</mrow>
942		<mi mathvariant='italic'>p</mi>
	944	<mi mathvariant='italic'>q</mi>
943	945	</munderover>
944	946	<mo stretchy="false">(</mo>
945	947	<mo stretchy="false">∂</mo>

982	984	<mo stretchy="false">=</mo>
983	985	<mo stretchy="false">ℓ</mo>
984	986	</mrow>
985		<mi mathvariant='italic'>p</mi>
	987	<mi mathvariant='italic'>q</mi>
986	988	</munderover>
987	989	<mi mathvariant='italic'>py</mi>
988	990	<mo stretchy="false">[</mo>
989	991	<mi mathvariant='italic'>i</mi>
990	992	<mo stretchy="false">*</mo>
991	993	<mo stretchy="false">(</mo>
992		<mi mathvariant='italic'>p</mi>
	994	<mi mathvariant='italic'>q</mi>
993	995	<mo stretchy="false">+</mo>
994	996	<mn>1</mn>
995	997	<mo stretchy="false">)</mo>

+64

-62

doc/atomic_tangent.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Tan and Tanh as User Atomic Operations: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Tan and Tanh as User Atomic Operations: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" tangent atomic operation tan "/>
	8	<meta name="keywords" id="keywords" content=" tan and tanh as user atomic operations: example test tangent operation theory start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording large x values "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="atomic_reciprocal.cpp.xml" target="_top">Prev</a>
24		</td><td><a href="atomic_mat_mul.cpp.xml" target="_top">Next</a>
	25	</td><td><a href="atomic_hes_sparse.cpp.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

77	78	<option>atomic_norm_sq.cpp</option>
78	79	<option>atomic_reciprocal.cpp</option>
79	80	<option>atomic_tangent.cpp</option>
	81	<option>atomic_hes_sparse.cpp</option>
80	82	<option>atomic_mat_mul.cpp</option>
81	83	</select>
82	84	</td>

171	173	<code><font color='blue'><pre style='display:inline'>
172	174	// forward mode routine called by CppAD
173	175	bool forward(
	176	size_t p ,
174	177	size_t q ,
175		size_t p ,
176	178	const vector<bool>& vx ,
177	179	vector<bool>& vzy ,
178	180	const vector<float>& tx ,
179	181	vector<float>& tzy
180	182	)
181		{ size_t p1 = p + 1;
182		size_t n = tx.size() / p1;
183		size_t m = tzy.size() / p1;
184		assert( n == 1 );
185		assert( m == 2 );
186		assert( q <= p );
	183	{ size_t q1 = q + 1;
	184	size_t n = tx.size() / q1;
	185	size_t m = tzy.size() / q1;
	186	assert( n == 1 );
	187	assert( m == 2 );
	188	assert( p <= q );
187	189	size_t j, k;
188	190
189	191	// check if this is during the call to old_tan(id, ax, ay)

193	195	vzy[1] = vx[0];
194	196	}
195	197
196		if( q == 0 )
	198	if( p == 0 )
197	199	{ // z^{(0)} = tan( x^{(0)} ) or tanh( x^{(0)} )
198	200	if( hyperbolic_ )
199	201	tzy[0] = tanh( tx[0] );
200	202	else tzy[0] = tan( tx[0] );
201	203
202	204	// y^{(0)} = z^{(0)} * z^{(0)}
203		tzy[p1 + 0] = tzy[0] * tzy[0];
	205	tzy[q1 + 0] = tzy[0] * tzy[0];
204	206
205		q++;
	207	p++;
206	208	}
207		for(j = q; j <= p; j++)
	209	for(j = p; j <= q; j++)
208	210	{ float j_inv = 1.f / float(j);
209	211	if( hyperbolic_ )
210	212	j_inv = - j_inv;

212	214	// z^{(j)} = x^{(j)} +- sum_{k=1}^j k x^{(k)} y^{(j-k)} / j
213	215	tzy[j] = tx[j];
214	216	for(k = 1; k <= j; k++)
215		tzy[j] += tx[k] * tzy[p1 + j-k] * k * j_inv;
	217	tzy[j] += tx[k] * tzy[q1 + j-k] * k * j_inv;
216	218
217	219	// y^{(j)} = sum_{k=0}^j z^{(k)} z^{(j-k)}
218		tzy[p1 + j] = 0.;
	220	tzy[q1 + j] = 0.;
219	221	for(k = 0; k <= j; k++)
220		tzy[p1 + j] += tzy[k] * tzy[j-k];
	222	tzy[q1 + j] += tzy[k] * tzy[j-k];
221	223	}
222	224
223	225	// All orders are implemented and there are no possible errors

232	234	<code><font color='blue'><pre style='display:inline'>
233	235	// reverse mode routine called by CppAD
234	236	virtual bool reverse(
235		size_t p ,
	237	size_t q ,
236	238	const vector<float>& tx ,
237	239	const vector<float>& tzy ,
238	240	vector<float>& px ,
239	241	const vector<float>& pzy
240	242	)
241		{ size_t p1 = p + 1;
242		size_t n = tx.size() / p1;
243		size_t m = tzy.size() / p1;
244		assert( px.size() == n * p1 );
245		assert( pzy.size() == m * p1 );
	243	{ size_t q1 = q + 1;
	244	size_t n = tx.size() / q1;
	245	size_t m = tzy.size() / q1;
	246	assert( px.size() == n * q1 );
	247	assert( pzy.size() == m * q1 );
246	248	assert( n == 1 );
247	249	assert( m == 2 );
248	250

252	254	vector<float> qzy = pzy;
253	255
254	256	// initialize accumultion of reverse mode partials
255		for(k = 0; k < p1; k++)
	257	for(k = 0; k < q1; k++)
256	258	px[k] = 0.;
257	259
258	260	// eliminate positive orders
259		for(j = p; j > 0; j--)
	261	for(j = q; j > 0; j--)
260	262	{ float j_inv = 1.f / float(j);
261	263	if( hyperbolic_ )
262	264	j_inv = - j_inv;

264	266	// H_{x^{(k)}} += delta(j-k) +- H_{z^{(j)} y^{(j-k)} * k / j
265	267	px[j] += qzy[j];
266	268	for(k = 1; k <= j; k++)
267		px[k] += qzy[j] * tzy[p1 + j-k] * k * j_inv;
	269	px[k] += qzy[j] * tzy[q1 + j-k] * k * j_inv;
268	270
269	271	// H_{y^{j-k)} += +- H_{z^{(j)} x^{(k)} * k / j
270	272	for(k = 1; k <= j; k++)
271		qzy[p1 + j-k] += qzy[j] * tx[k] * k * j_inv;
	273	qzy[q1 + j-k] += qzy[j] * tx[k] * k * j_inv;
272	274
273	275	// H_{z^{(k)}} += H_{y^{(j-1)}} * z^{(j-k-1)} * 2.
274	276	for(k = 0; k < j; k++)
275		qzy[k] += qzy[p1 + j-1] * tzy[j-k-1] * 2.f;
	277	qzy[k] += qzy[q1 + j-1] * tzy[j-k-1] * 2.f;
276	278	}
277	279
278	280	// eliminate order zero
279	281	if( hyperbolic_ )
280		px[0] += qzy[0] * (1.f - tzy[p1 + 0]);
	282	px[0] += qzy[0] * (1.f - tzy[q1 + 0]);
281	283	else
282		px[0] += qzy[0] * (1.f + tzy[p1 + 0]);
	284	px[0] += qzy[0] * (1.f + tzy[q1 + 0]);
283	285
284	286	return true;
285	287	}

292	294	<code><font color='blue'><pre style='display:inline'>
293	295	// forward Jacobian sparsity routine called by CppAD
294	296	virtual bool for_sparse_jac(
295		size_t q ,
	297	size_t p ,
296	298	const vector<bool>& r ,
297	299	vector<bool>& s )
298		{ size_t n = r.size() / q;
299		size_t m = s.size() / q;
	300	{ size_t n = r.size() / p;
	301	size_t m = s.size() / p;
300	302	assert( n == 1 );
301	303	assert( m == 2 );
302	304
303	305	// sparsity for S(x) = f'(x) * R
304		for(size_t j = 0; j < q; j++)
305		{ s[0 * q + j] = r[j];
306		s[1 * q + j] = r[j];
	306	for(size_t j = 0; j < p; j++)
	307	{ s[0 * p + j] = r[j];
	308	s[1 * p + j] = r[j];
307	309	}
308	310
309	311	return true;
310	312	}
311	313	// forward Jacobian sparsity routine called by CppAD
312	314	virtual bool for_sparse_jac(
313		size_t q ,
	315	size_t p ,
314	316	const vector< std::set<size_t> >& r ,
315	317	vector< std::set<size_t> >& s )
316	318	{ size_t n = r.size();

333	335	<code><font color='blue'><pre style='display:inline'>
334	336	// reverse Jacobian sparsity routine called by CppAD
335	337	virtual bool rev_sparse_jac(
336		size_t q ,
	338	size_t p ,
337	339	const vector<bool>& rt ,
338	340	vector<bool>& st )
339		{ size_t n = st.size() / q;
340		size_t m = rt.size() / q;
	341	{ size_t n = st.size() / p;
	342	size_t m = rt.size() / p;
341	343	assert( n == 1 );
342	344	assert( m == 2 );
343	345
344	346	// sparsity for S(x)^T = f'(x)^T * R^T
345		for(size_t j = 0; j < q; j++)
346		st[j] = rt[0 * q + j] \| rt[1 * q + j];
	347	for(size_t j = 0; j < p; j++)
	348	st[j] = rt[0 * p + j] \| rt[1 * p + j];
347	349
348	350	return true;
349	351	}
350	352	// reverse Jacobian sparsity routine called by CppAD
351	353	virtual bool rev_sparse_jac(
352		size_t q ,
	354	size_t p ,
353	355	const vector< std::set<size_t> >& rt ,
354	356	vector< std::set<size_t> >& st )
355	357	{ size_t n = st.size();

373	375	const vector<bool>& vx,
374	376	const vector<bool>& s ,
375	377	vector<bool>& t ,
376		size_t q ,
	378	size_t p ,
377	379	const vector<bool>& r ,
378	380	const vector<bool>& u ,
379	381	vector<bool>& v )
380	382	{
381	383	size_t m = s.size();
382	384	size_t n = t.size();
383		assert( r.size() == n * q );
384		assert( u.size() == m * q );
385		assert( v.size() == n * q );
	385	assert( r.size() == n * p );
	386	assert( u.size() == m * p );
	387	assert( v.size() == n * p );
386	388	assert( n == 1 );
387	389	assert( m == 2 );
388	390

399	401	// back propagate the sparsity for U, note both components
400	402	// of f'(x) may be non-zero;
401	403	size_t j;
402		for(j = 0; j < q; j++)
403		v[j] = u[ 0 * q + j ] \| u[ 1 * q + j ];
	404	for(j = 0; j < p; j++)
	405	v[j] = u[ 0 * p + j ] \| u[ 1 * p + j ];
404	406
405	407	// include forward Jacobian sparsity in Hessian sparsity
406	408	// (note sparsty for f''(x) * R same as for R)
407	409	if( s[0] \| s[1] )
408		{ for(j = 0; j < q; j++)
	410	{ for(j = 0; j < p; j++)
409	411	v[j] \|= r[j];
410	412	}
411	413

416	418	const vector<bool>& vx,
417	419	const vector<bool>& s ,
418	420	vector<bool>& t ,
419		size_t q ,
	421	size_t p ,
420	422	const vector< std::set<size_t> >& r ,
421	423	const vector< std::set<size_t> >& u ,
422	424	vector< std::set<size_t> >& v )

596	598
597	599	<code><font color='blue'><pre style='display:inline'>
598	600	// Forward mode computation of sparsity pattern for F.
599		size_t q = n;
	601	size_t p = n;
600	602	// user vectorBool because m and n are small
601		CppAD::vectorBool r1(q), s1(m * q);
	603	CppAD::vectorBool r1(p), s1(m * p);
602	604	r1[0] = true; // propagate sparsity for x[0]
603		s1 = F.ForSparseJac(q, r1);
	605	s1 = F.ForSparseJac(p, r1);
604	606	ok &= (s1[0] == true); // f[0] depends on x[0]
605	607	ok &= (s1[1] == true); // f[1] depends on x[0]
606	608	ok &= (s1[2] == false); // f[2] does not depend on x[0]

612	614
613	615	<code><font color='blue'><pre style='display:inline'>
614	616	// Reverse mode computation of sparsity pattern for F.
615		size_t p = m;
616		CppAD::vectorBool s2(p * m), r2(p * n);
	617	size_t q = m;
	618	CppAD::vectorBool s2(q * m), r2(q * n);
617	619	// Sparsity pattern for identity matrix
618	620	size_t i, j;
619		for(i = 0; i < p; i++)
	621	for(i = 0; i < q; i++)
620	622	{ for(j = 0; j < m; j++)
621		s2[i * p + j] = (i == j);
622		}
623		r2 = F.RevSparseJac(p, s2);
	623	s2[i * q + j] = (i == j);
	624	}
	625	r2 = F.RevSparseJac(q, s2);
624	626	ok &= (r2[0] == true); // f[0] depends on x[0]
625	627	ok &= (r2[1] == true); // f[1] depends on x[0]
626	628	ok &= (r2[2] == false); // f[2] does not depend on x[0]

632	634
633	635	<code><font color='blue'><pre style='display:inline'>
634	636	// Hessian sparsity for f[0]
635		CppAD::vectorBool s3(m), h(q * n);
	637	CppAD::vectorBool s3(m), h(p * n);
636	638	s3[0] = true;
637	639	s3[1] = false;
638	640	s3[2] = false;
639		h = F.RevSparseHes(q, s3);
	641	h = F.RevSparseHes(p, s3);
640	642	ok &= (h[0] == true); // Hessian is non-zero
641	643
642	644	// Hessian sparsity for f[2]
643	645	s3[0] = false;
644	646	s3[2] = true;
645		h = F.RevSparseHes(q, s3);
	647	h = F.RevSparseHes(p, s3);
646	648	ok &= (h[0] == false); // Hessian is zero
647	649	</pre></font></code>
648	650

+31

-1

doc/base_adolc.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Enable use of AD<Base> where Base is Adolc's adouble Type</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Enable use of AD<Base> where Base is Adolc's adouble Type"/>
7		<meta name="keywords" id="keywords" content=" Adolc adouble as Base Adolc's "/>
	8	<meta name="keywords" id="keywords" content=" Adolc adouble as Base Adolc's enable use of ad<base> where base is adolc's type syntax example include files condexpop equalopseq identical integer ordered unary standard math erf sign abs pow limits "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

94	95	<option>Integer</option>
95	96	<option>Ordered</option>
96	97	<option>Unary Standard Math</option>
	98	<option>erf</option>
97	99	<option>sign</option>
98	100	<option>abs</option>
99	101	<option>pow</option>

303	305
304	306	<br/>
305	307	<br/>
	308	<b><big><a name="erf" id="erf">erf</a></big></b>
	309	<br/>
	310	If the error function is supported by the compiler,
	311	it must also be supported by a
	312	<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
	313	type;
	314	see <a href="base_std_math.xml#erf" target="_top"><span style='white-space: nowrap'>erf</span></a>
	315	.
	316	The adolc package does not support this function:
	317	<code><font color='blue'><pre style='display:inline'>
	318	namespace CppAD {
	319	# if CPPAD_COMPILER_HAS_ERF
	320	inline adouble erf(const adouble& x)
	321	{ CPPAD_ASSERT_KNOWN(
	322	false,
	323	"erf: adolc does not support the error function"
	324	);
	325	return 0;
	326	}
	327	# endif
	328	}
	329	</pre></font></code>
	330
	331
	332
	333
	334	<br/>
	335	<br/>
306	336	<b><big><a name="sign" id="sign">sign</a></big></b>
307	337	<br/>
308	338	This <a href="base_require.xml" target="_top"><span style='white-space: nowrap'>required</span></a>

+17

-1

doc/base_alloc.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Example AD<Base> Where Base Constructor Allocates Memory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Example AD<Base> Where Base Constructor Allocates Memory"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" example ad<base> where base constructor allocates memory purpose include file computed assignment macro binary operator boolean class definition condexpop condexprel equalopseq identical output integer ordered unary standard math erf sign pow limits "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

94	95	<option>Integer</option>
95	96	<option>Ordered</option>
96	97	<option>Unary Standard Math</option>
	98	<option>erf</option>
97	99	<option>sign</option>
98	100	<option>pow</option>
99	101	<option>limits</option>

437	439
438	440	<br/>
439	441	<br/>
	442	<b><big><a name="erf" id="erf">erf</a></big></b>
	443	<br/>
	444	The following defines the <code><font color="blue">CppAD::erf</font></code> function that
	445	is required th use <code><font color="blue">AD<Base_alloc></font></code>:
	446	<code><font color='blue'><pre style='display:inline'>
	447	# if CPPAD_COMPILER_HAS_ERF
	448	inline base_alloc erf(const base_alloc& x)
	449	{ return std::erf(*x.ptrdbl_); }
	450	# endif
	451	</pre></font></code>
	452
	453
	454	<br/>
	455	<br/>
440	456	<b><big><a name="sign" id="sign">sign</a></big></b>
441	457	<br/>
442	458	The following defines the <code><font color="blue">CppAD::sign</font></code> function that

+19

-1

doc/base_complex.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Enable use of AD<Base> where Base is std::complex<double></title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Enable use of AD<Base> where Base is std::complex<double>"/>
7		<meta name="keywords" id="keywords" content=" complex double Base "/>
	8	<meta name="keywords" id="keywords" content=" complex double Base enable use of ad<base> where base is std::complex<double> example see also include order condexpop condexprel equalopseq identical ordered erf integer isnan valid unary math invalid pow limits "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

94	95	<option>EqualOpSeq</option>
95	96	<option>Identical</option>
96	97	<option>Ordered</option>
	98	<option>erf</option>
97	99	<option>Integer</option>
98	100	<option>isnan</option>
99	101	<option>Valid Unary Math</option>

261	263	{ return std::abs(x) >= std::abs(y); }
262	264	}
263	265	</pre></font></code>
	266
	267
	268	<br/>
	269	<br/>
	270	<b><big><a name="erf" id="erf">erf</a></big></b>
	271	<br/>
	272	Complex types do not support the error function
	273	(use CPPAD_USER_MACRO define above).
	274	<code><font color='blue'><pre style='display:inline'>
	275	# if CPPAD_COMPILER_HAS_ERF
	276	namespace CppAD {
	277	CPPAD_USER_MACRO(erf)
	278	}
	279	# endif
	280	</pre></font></code>
	281
264	282
265	283
266	284	<br/>

-1

doc/base_cond_exp.xml less more

3	3	>
4	4	<head>
5	5	<title>Base Type Requirements for Conditional Expressions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Base Type Requirements for Conditional Expressions"/>
7		<meta name="keywords" id="keywords" content=" Condexp base require Cppad_cond_exp_rel "/>
	8	<meta name="keywords" id="keywords" content=" base type requirements for conditional expressions Condexp require purpose compareop condexptemplate ordered not condexprel Cppad_cond_exp_rel "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/base_double.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Enable use of AD<Base> where Base is double</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Enable use of AD<Base> where Base is double"/>
7		<meta name="keywords" id="keywords" content=" double Base "/>
	8	<meta name="keywords" id="keywords" content=" double Base enable use of ad<base> where base is condexpop condexprel equalopseq identical integer ordered unary standard math sign pow limits "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

231	232	CPPAD_STANDARD_MATH_UNARY(double, sqrt)
232	233	CPPAD_STANDARD_MATH_UNARY(double, tan)
233	234	CPPAD_STANDARD_MATH_UNARY(double, tanh)
	235	# if CPPAD_COMPILER_HAS_ERF
	236	CPPAD_STANDARD_MATH_UNARY(double, erf)
	237	# endif
234	238	}
235	239	</pre></font></code>
236	240

-1

doc/base_example.xml less more

3	3	>
4	4	<head>
5	5	<title>Example AD Base Types That are not AD<OtherBase></title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Example AD Base Types That are not AD<OtherBase>"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" example ad base types that are not ad<otherbase> "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/base_float.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Enable use of AD<Base> where Base is float</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Enable use of AD<Base> where Base is float"/>
7		<meta name="keywords" id="keywords" content=" float Base "/>
	8	<meta name="keywords" id="keywords" content=" float Base enable use of ad<base> where base is condexpop condexprel equalopseq identical integer ordered unary standard math sign pow limits "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

232	233	CPPAD_STANDARD_MATH_UNARY(float, sqrt)
233	234	CPPAD_STANDARD_MATH_UNARY(float, tan)
234	235	CPPAD_STANDARD_MATH_UNARY(float, tanh)
	236	# if CPPAD_COMPILER_HAS_ERF
	237	CPPAD_STANDARD_MATH_UNARY(float, erf)
	238	# endif
235	239	}
236	240	</pre></font></code>
237	241

-1

doc/base_identical.xml less more

3	3	>
4	4	<head>
5	5	<title>Base Type Requirements for Identically Equal Comparisons</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Base Type Requirements for Identically Equal Comparisons"/>
7		<meta name="keywords" id="keywords" content=" Equalopseq base require identical "/>
	8	<meta name="keywords" id="keywords" content=" base type requirements for identically equal comparisons equalopseq Equalopseq require the simple case more complicated cases identical identicalpar prototypes functions examples "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/base_member.xml less more

3	3	>
4	4	<head>
5	5	<title>Required Base Class Member Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Required Base Class Member Functions"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" required base class member functions notation default constructor double copy unary operators assignment binary bool example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/base_ordered.xml less more

3	3	>
4	4	<head>
5	5	<title>Base Type Requirements for Ordered Comparisons</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Base Type Requirements for Ordered Comparisons"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" base type requirements for ordered comparisons purpose not "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/base_require.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Using a User Defined AD Base Type: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using a User Defined AD Base Type: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" base type example test "/>
	8	<meta name="keywords" id="keywords" content=" using a user defined ad base type: example and test type purpose "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/base_require.xml less more

3	3	>
4	4	<head>
5	5	<title>AD<Base> Requirements for Base Type</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD<Base> Requirements for Base Type"/>
7		<meta name="keywords" id="keywords" content=" Base require type output base operator Integer "/>
	8	<meta name="keywords" id="keywords" content=" Base require type ad<base> requirements for base syntax warning purpose standard types include order numeric output operator integer Integer suggestion "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+35

-15

doc/base_std_math.xml less more

3	3	>
4	4	<head>
5	5	<title>Base Type Requirements for Standard Math Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Base Type Requirements for Standard Math Functions"/>
7		<meta name="keywords" id="keywords" content=" math base require unary Cppad_standard_math_unary sign pow isnan type numeric limits Base numeric_limits "/>
	8	<meta name="keywords" id="keywords" content=" base type requirements for standard math functions require purpose unary cppad_standard_math_unary Cppad_standard_math_unary erf sign pow isnan limits numeric Base numeric_limits epsilon "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

87	88	<option>Purpose</option>
88	89	<option>Unary Standard Math</option>
89	90	<option>CPPAD_STANDARD_MATH_UNARY</option>
	91	<option>erf</option>
90	92	<option>sign</option>
91	93	<option>pow</option>
92	94	<option>isnan</option>

228	230
229	231	<br/>
230	232	<br/>
	233	<b><big><a name="erf" id="erf">erf</a></big></b>
	234
	235
	236
	237	<br/>
	238	If the error function is supported by the compiler,
	239	<a href="erf.xml#Method.CPPAD_COMPILER_HAS_ERF" target="_top"><span style='white-space: nowrap'>CPPAD_COMPILER_HAS_ERF</span></a>
	240
	241	is one,
	242	the type
	243	<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
	244	must support the syntax
	245
	246	<code><font color="blue"><span style='white-space: nowrap'><br/>
	247	</span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'> = CppAD::erf(</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	248	</span></font></code>
	249	where
	250	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
	251	and
	252	<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
	253	have the same prototype as above.
	254	For example, see
	255	<a href="base_alloc.hpp.xml#erf" target="_top"><span style='white-space: nowrap'>base_alloc</span></a>
	256	.
	257
	258	<br/>
	259	<br/>
231	260	<b><big><a name="sign" id="sign">sign</a></big></b>
232	261
233	262

243	272	which computes
244	273
245	274	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
246		<mi mathvariant='italic'>z</mi>
	275	<mi mathvariant='italic'>y</mi>
247	276	<mo stretchy="false">=</mo>
248	277	<mrow><mo stretchy="true">{</mo><mrow><mtable rowalign="center" ><mtr><mtd columnalign="left" >
249	278	<mo stretchy="false">+</mo>

277	306	</mrow><mo stretchy="true"> </mo></mrow>
278	307	</mrow></math>
279	308
280		The arguments
	309	where
281	310	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
282		has prototype
283
284		<code><font color="blue"><span style='white-space: nowrap'><br/>
285		const </span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>& </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
286		</span></font></code>
287		and the return value
288		<code><i><font color="black"><span style='white-space: nowrap'>z</span></font></i></code>
289		has prototype
290
291		<code><font color="blue"><span style='white-space: nowrap'><br/>
292		</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>z</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
293		</span></font></code>
	311	and
	312	<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
	313	have the same prototype as above.
294	314	For example, see
295	315	<a href="base_alloc.hpp.xml#sign" target="_top"><span style='white-space: nowrap'>base_alloc</span></a>
296	316	.

-1

doc/bender_quad.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>BenderQuad: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="BenderQuad: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Benderquad example test "/>
	8	<meta name="keywords" id="keywords" content=" benderquad: example and test Benderquad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/benderquad.xml less more

3	3	>
4	4	<head>
5	5	<title>Computing Jacobian and Hessian of Bender's Reduced Objective</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Computing Jacobian and Hessian of Bender's Reduced Objective"/>
7		<meta name="keywords" id="keywords" content=" Hessian Bender Jacobian Benderquad "/>
	8	<meta name="keywords" id="keywords" content=" Hessian Bender Jacobian Benderquad computing jacobian and hessian of bender's reduced objective syntax see also problem purpose x y fun fun.f fun.h fun.dy g gx gxx bavector advector example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/bib.xml less more

3	3	>
4	4	<head>
5	5	<title>Bibliography</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Bibliography"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" bibliography abramowitz and stegun the c++ programming language evaluating derivatives numerical recipes shampine l.f. "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/bool_fun.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Boolean Functions: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Boolean Functions: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" example Ad bool test "/>
	8	<meta name="keywords" id="keywords" content=" ad boolean functions: example and test Ad bool "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/boolfun.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Boolean Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Boolean Functions"/>
7		<meta name="keywords" id="keywords" content=" bool Ad function unary binary Cppad_bool_unary Cppad_bool_binary "/>
	8	<meta name="keywords" id="keywords" content=" bool Ad function unary binary ad boolean functions syntax purpose unary_name u x b create Cppad_bool_unary binary_name v y Cppad_bool_binary operation sequence example deprecated "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/boolvalued.xml less more

3	3	>
4	4	<head>
5	5	<title>Bool Valued Operations and Functions with AD Arguments</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Bool Valued Operations and Functions with AD Arguments"/>
7		<meta name="keywords" id="keywords" content=" operation Ad Bool valued function "/>
	8	<meta name="keywords" id="keywords" content=" operation Ad Bool valued function bool operations and functions with ad arguments "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/bugs.xml less more

3	3	>
4	4	<head>
5	5	<title>Know Bugs and Problems Using CppAD</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Know Bugs and Problems Using CppAD"/>
7		<meta name="keywords" id="keywords" content=" bugs using Cppad problem gcc 3.4.4 bug "/>
	8	<meta name="keywords" id="keywords" content=" know bugs and problems using cppad Cppad problem gcc 3.4.4 -o2 bug example adolc "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+183

-0

doc/capacity_order.cpp.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Controlling Taylor Coefficient Memory Allocation: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Controlling Taylor Coefficient Memory Allocation: Example and Test"/>
	8	<meta name="keywords" id="keywords" content=" controlling taylor coefficient memory allocation: example and test capacity_order "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_capacity_order.cpp_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="capacity_order.xml" target="_top">Prev</a>
	25	</td><td><a href="number_skip.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>capacity_order</option>
	44	<option>capacity_order.cpp</option>
	45	</select>
	46	</td>
	47	<td>
	48	<select onchange='choose_down3(this)'>
	49	<option>FunEval-></option>
	50	<option>Forward</option>
	51	<option>Reverse</option>
	52	<option>Sparse</option>
	53	</select>
	54	</td>
	55	<td>
	56	<select onchange='choose_down2(this)'>
	57	<option>Forward-></option>
	58	<option>forward_zero</option>
	59	<option>forward_one</option>
	60	<option>forward_two</option>
	61	<option>forward_order</option>
	62	<option>forward_dir</option>
	63	<option>size_order</option>
	64	<option>CompareChange</option>
	65	<option>capacity_order</option>
	66	<option>number_skip</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>capacity_order-></option>
	72	<option>capacity_order.cpp</option>
	73	</select>
	74	</td>
	75	<td>capacity_order.cpp</td>
	76	<td>Headings</td>
	77	</tr></table><br/>
	78
	79
	80
	81	<center><b><big><big>Controlling Taylor Coefficient Memory Allocation: Example and Test</big></big></b></center>
	82	<code><font color="blue"><pre style='display:inline'>
	83	# include <cppad/cppad.hpp>
	84
	85	namespace {
	86	bool test(void)
	87	{ bool ok = true;
	88	using CppAD::AD;
	89	using CppAD::NearEqual;
	90	using CppAD::thread_alloc;
	91
	92	// domain space vector
	93	size_t n(1), m(1);
	94	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ax(n), ay(n);
	95
	96	// declare independent variables and start tape recording
	97	ax[0] = 1.0;
	98	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
	99
	100	// Set y = x^3, use enough variables so more that the minimal amount
	101	// of memory is allocated for Taylor coefficients
	102	ay[0] = 0.;
	103	for( size_t i = 0; i < 10; i++)
	104	ay[0] += ax[0] * ax[0] * ax[0];
	105	ay[0] = ay[0] / 10.;
	106
	107	// create f: x -> y and stop tape recording
	108	// (without running zero order forward mode).
	109	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
	110	f.Dependent(ax, ay);
	111
	112	// check that this is master thread
	113	size_t thread = thread_alloc::thread_num();
	114	ok &= thread == 0; // this should be master thread
	115
	116	// The highest order forward mode calculation below is first order.
	117	// This corresponds to two Taylor coefficient per variable,direction
	118	// (orders zero and one). Preallocate memory for speed.
	119	size_t inuse = thread_alloc::inuse(thread);
	120	f.capacity_order(2);
	121	ok &= thread_alloc::inuse(thread) > inuse;
	122
	123	// zero order forward mode
	124	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x(n), y(m);
	125	x[0] = 0.5;
	126	y = f.<a href="forward.xml" target="_top">Forward</a>(0, x);
	127	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	128	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y[0], x[0] * x[0] * x[0], eps, eps);
	129
	130	// forward computation of partials w.r.t. x
	131	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) dx(n), dy(m);
	132	dx[0] = 1.;
	133	dy = f.<a href="forward.xml" target="_top">Forward</a>(1, dx);
	134	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0], 3. * x[0] * x[0], eps, eps);
	135
	136	// Suppose we no longer need the first order Taylor coefficients.
	137	inuse = thread_alloc::inuse(thread);
	138	f.capacity_order(1); // just keep zero order coefficients
	139	ok &= thread_alloc::inuse(thread) < inuse;
	140
	141	// Suppose we no longer need the zero order Taylor coefficients
	142	// (could have done this first and not used f.capacity_order(1)).
	143	inuse = thread_alloc::inuse(thread);
	144	f.capacity_order(0);
	145	ok &= thread_alloc::inuse(thread) < inuse;
	146
	147	// turn off memory holding
	148	thread_alloc::hold_memory(false);
	149
	150	return ok;
	151	}
	152	}
	153	bool capacity_order(void)
	154	{ bool ok = true;
	155	using CppAD::thread_alloc;
	156
	157	// original amount of memory inuse
	158	size_t thread = thread_alloc::thread_num();
	159	ok &= thread == 0; // this should be master thread
	160	size_t inuse = thread_alloc::inuse(thread);
	161
	162	// do test in separate routine so all objects are destroyed
	163	ok &= test();
	164
	165	// check that the amount of memroy inuse has not changed
	166	ok &= thread_alloc::inuse(thread) == inuse;
	167
	168	// Test above uses hold_memory, so return available memory
	169	thread_alloc::free_available(thread);
	170
	171	return ok;
	172	}
	173
	174	</pre>
	175
	176	</font></code>
	177
	178
	179	<hr/>Input File: example/capacity_order.cpp
	180
	181	</body>
	182	</html>

+285

-0

doc/capacity_order.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Controlling Taylor Coefficients Memory Allocation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Controlling Taylor Coefficients Memory Allocation"/>
	8	<meta name="keywords" id="keywords" content=" Forward capacity capacity_order control memory controlling taylor coefficients allocation syntax see also purpose f c pre-allocating freeing original state example "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_capacity_order_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="compare_change.cpp.xml" target="_top">Prev</a>
	25	</td><td><a href="capacity_order.cpp.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>capacity_order</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>ADFun-></option>
	49	<option>Independent</option>
	50	<option>FunConstruct</option>
	51	<option>Dependent</option>
	52	<option>abort_recording</option>
	53	<option>seq_property</option>
	54	<option>FunEval</option>
	55	<option>Drivers</option>
	56	<option>FunCheck</option>
	57	<option>optimize</option>
	58	<option>check_for_nan</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>FunEval-></option>
	64	<option>Forward</option>
	65	<option>Reverse</option>
	66	<option>Sparse</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>Forward-></option>
	72	<option>forward_zero</option>
	73	<option>forward_one</option>
	74	<option>forward_two</option>
	75	<option>forward_order</option>
	76	<option>forward_dir</option>
	77	<option>size_order</option>
	78	<option>CompareChange</option>
	79	<option>capacity_order</option>
	80	<option>number_skip</option>
	81	</select>
	82	</td>
	83	<td>
	84	<select onchange='choose_down0(this)'>
	85	<option>capacity_order-></option>
	86	<option>capacity_order.cpp</option>
	87	</select>
	88	</td>
	89	<td>
	90	<select onchange='choose_current0(this)'>
	91	<option>Headings-></option>
	92	<option>Syntax</option>
	93	<option>---..See Also</option>
	94	<option>Purpose</option>
	95	<option>f</option>
	96	<option>c</option>
	97	<option>---..Pre-Allocating Memory</option>
	98	<option>---..Freeing Memory</option>
	99	<option>Original State</option>
	100	<option>Example</option>
	101	</select>
	102	</td>
	103	</tr></table><br/>
	104
	105
	106
	107
	108
	109
	110
	111
	112
	113	<center><b><big><big>Controlling Taylor Coefficients Memory Allocation</big></big></b></center>
	114	<br/>
	115	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
	116
	117	<br/>
	118
	119	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity_order(</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
	120
	121
	122	<br/>
	123	<br/>
	124	<b><a name="Syntax.See Also" id="Syntax.See Also">See Also</a></b>
	125
	126	<br/>
	127	<a href="seq_property.xml" target="_top"><span style='white-space: nowrap'>seq_property</span></a>
	128
	129
	130	<br/>
	131	<br/>
	132	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	133	<br/>
	134	The Taylor coefficients calculated by <a href="forward.xml" target="_top"><span style='white-space: nowrap'>Forward</span></a>
	135	mode calculations
	136	are retained in an <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
	137	object for subsequent use during
	138	<a href="reverse.xml" target="_top"><span style='white-space: nowrap'>Reverse</span></a>
	139	mode and higher order Forward mode calculations.
	140	For example, a call to <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>Forward</span></a>
	141	with the syntax
	142
	143	<code><font color="blue"><span style='white-space: nowrap'><br/>
	144	</span></font><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	145	</span></font></code>
	146	where
	147	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> > 0</span></font></code>
	148	and <code><font color="blue">%xq%.size() == %f%.Domain()%</font></code>,
	149	uses the lower order Taylor coefficients and
	150	computes the <code><i>q</i></code>-th order Taylor coefficients for all
	151	the variables in the operation sequence corresponding to
	152	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	153	.
	154	The <code><font color="blue">capacity_order</font></code> operation allows you to control that
	155	amount of memory that is retained by an AD function object
	156	(to hold <code><font color="blue">Forward</font></code> results for subsequent calculations).
	157
	158	<br/>
	159	<br/>
	160	<b><big><a name="f" id="f">f</a></big></b>
	161	<br/>
	162	The object
	163	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	164	has prototype
	165
	166	<code><font color="blue"><span style='white-space: nowrap'><br/>
	167	ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	168	</span></font></code>
	169	<br/>
	170	<b><big><a name="c" id="c">c</a></big></b>
	171	<br/>
	172	The argument
	173	<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
	174	has prototype
	175
	176	<code><font color="blue"><span style='white-space: nowrap'><br/>
	177	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	178	</span></font></code>
	179	It specifies the number of Taylor coefficient orders that are allocated
	180	in the AD operation sequence corresponding to
	181	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	182	.
	183
	184	<br/>
	185	<br/>
	186	<b><a name="c.Pre-Allocating Memory" id="c.Pre-Allocating Memory">Pre-Allocating Memory</a></b>
	187	<br/>
	188	If you plan to make calls to <code><font color="blue">Forward</font></code> with the maximum value of
	189
	190	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
	191	equal to
	192	<code><i><font color="black"><span style='white-space: nowrap'>Q</span></font></i></code>
	193	,
	194	it should be faster to pre-allocate memory for these calls using
	195
	196	<code><font color="blue"><span style='white-space: nowrap'><br/>
	197	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity_order(</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	198	</span></font></code>
	199	with
	200	<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
	201	equal to
	202	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	203	<mi mathvariant='italic'>Q</mi>
	204	<mo stretchy="false">+</mo>
	205	<mn>1</mn>
	206	</mrow></math>
	207
	208	.
	209	If you do no do this, <code><font color="blue">Forward</font></code> will automatically allocate memory
	210	and will copy the results to a larger buffer, when necessary.
	211	<code><span style='white-space: nowrap'><br/>
	212	<br/>
	213	</span></code>Note that each call to <a href="dependent.xml" target="_top"><span style='white-space: nowrap'>Dependent</span></a>
	214	frees the old memory
	215	connected to the function object and sets the corresponding
	216	taylor capacity to zero.
	217
	218	<br/>
	219	<br/>
	220	<b><a name="c.Freeing Memory" id="c.Freeing Memory">Freeing Memory</a></b>
	221	<br/>
	222	If you no longer need the Taylor coefficients of order
	223	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
	224
	225	and higher (that are stored in
	226	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	227	),
	228	you can reduce the memory allocated to
	229	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	230	using
	231
	232	<code><font color="blue"><span style='white-space: nowrap'><br/>
	233	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity_order(</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	234	</span></font></code>
	235	with
	236	<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
	237	equal to
	238	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
	239	.
	240	Note that, if <a href="ta_hold_memory.xml" target="_top"><span style='white-space: nowrap'>ta_hold_memory</span></a>
	241	is true, this memory is not actually
	242	returned to the system, but rather held for future use by the same thread.
	243
	244	<br/>
	245	<br/>
	246	<b><big><a name="Original State" id="Original State">Original State</a></big></b>
	247	<br/>
	248	If
	249	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	250	is <a href="funconstruct.xml" target="_top"><span style='white-space: nowrap'>constructed</span></a>
	251	with the syntax
	252
	253	<code><font color="blue"><span style='white-space: nowrap'><br/>
	254	ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>(</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	255	</span></font></code>
	256	,
	257	there is an implicit call to <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
	258	with
	259	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i></code>
	260	equal to
	261	the value of the
	262	<a href="glossary.xml#Tape.Independent Variable" target="_top"><span style='white-space: nowrap'>independent variables</span></a>
	263
	264	when the AD operation sequence was recorded.
	265	This corresponds to
	266	<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'> == 1</span></font></code>
	267	.
	268
	269
	270	<br/>
	271	<br/>
	272	<b><big><a name="Example" id="Example">Example</a></big></b>
	273	<br/>
	274	The file
	275	<a href="capacity_order.cpp.xml" target="_top"><span style='white-space: nowrap'>capacity_order.cpp</span></a>
	276
	277	contains an example and test of these operations.
	278	It returns true if it succeeds and false otherwise.
	279
	280
	281	<hr/>Input File: cppad/local/capacity_order.hpp
	282
	283	</body>
	284	</html>

-182

~~doc/capacity_taylor.cpp.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>Controlling Taylor Coefficient Memory Allocation: Example and Test</title>
6		<meta name="description" id="description" content="Controlling Taylor Coefficient Memory Allocation: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" capacity_taylor example "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_capacity_taylor.cpp_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td><a href="capacity_taylor.xml" target="_top">Prev</a>
24		</td><td><a href="number_skip.xml" target="_top">Next</a>
25		</td><td>
26		<select onchange='choose_across0(this)'>
27		<option>Index-></option>
28		<option>contents</option>
29		<option>reference</option>
30		<option>index</option>
31		<option>search</option>
32		<option>external</option>
33		</select>
34		</td>
35		<td>
36		<select onchange='choose_up0(this)'>
37		<option>Up-></option>
38		<option>CppAD</option>
39		<option>ADFun</option>
40		<option>FunEval</option>
41		<option>Forward</option>
42		<option>capacity_taylor</option>
43		<option>capacity_taylor.cpp</option>
44		</select>
45		</td>
46		<td>
47		<select onchange='choose_down3(this)'>
48		<option>FunEval-></option>
49		<option>Forward</option>
50		<option>Reverse</option>
51		<option>Sparse</option>
52		</select>
53		</td>
54		<td>
55		<select onchange='choose_down2(this)'>
56		<option>Forward-></option>
57		<option>ForwardZero</option>
58		<option>ForwardOne</option>
59		<option>ForwardAny</option>
60		<option>size_taylor</option>
61		<option>CompareChange</option>
62		<option>capacity_taylor</option>
63		<option>number_skip</option>
64		<option>forward.cpp</option>
65		<option>forward_mul.cpp</option>
66		</select>
67		</td>
68		<td>
69		<select onchange='choose_down1(this)'>
70		<option>capacity_taylor-></option>
71		<option>capacity_taylor.cpp</option>
72		</select>
73		</td>
74		<td>capacity_taylor.cpp</td>
75		<td>Headings</td>
76		</tr></table><br/>
77
78
79
80		<center><b><big><big>Controlling Taylor Coefficient Memory Allocation: Example and Test</big></big></b></center>
81		<code><font color="blue"><pre style='display:inline'>
82		# include <cppad/cppad.hpp>
83
84		namespace {
85		bool test(void)
86		{ bool ok = true;
87		using CppAD::AD;
88		using CppAD::NearEqual;
89		using CppAD::thread_alloc;
90
91		// domain space vector
92		size_t n(1), m(1);
93		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ax(n), ay(n);
94
95		// declare independent variables and start tape recording
96		ax[0] = 1.0;
97		CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
98
99		// Set y = x^3, use enough variables so more that the minimal amount
100		// of memory is allocated for Taylor coefficients
101		ay[0] = 0.;
102		for( size_t i = 0; i < 10; i++)
103		ay[0] += ax[0] * ax[0] * ax[0];
104		ay[0] = ay[0] / 10.;
105
106		// create f: x -> y and stop tape recording
107		// (without running zero order forward mode).
108		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
109		f.Dependent(ax, ay);
110
111		// check that this is master thread
112		size_t thread = thread_alloc::thread_num();
113		ok &= thread == 0; // this should be master thread
114
115		// The highest order forward mode calculation below is first order.
116		// This corresponds to two Taylor coefficient per variable
117		// (orders zero and one). Preallocate memory for speed.
118		size_t inuse = thread_alloc::inuse(thread);
119		f.capacity_taylor(2);
120		ok &= thread_alloc::inuse(thread) > inuse;
121
122		// zero order forward mode
123		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x(n), y(m);
124		x[0] = 0.5;
125		y = f.<a href="forward.xml" target="_top">Forward</a>(0, x);
126		double eps = 10. * CppAD::numeric_limits<double>::epsilon();
127		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y[0], x[0] * x[0] * x[0], eps, eps);
128
129		// forward computation of partials w.r.t. x
130		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) dx(n), dy(m);
131		dx[0] = 1.;
132		dy = f.<a href="forward.xml" target="_top">Forward</a>(1, dx);
133		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0], 3. * x[0] * x[0], eps, eps);
134
135		// Suppose we no longer need the first order Taylor coefficients.
136		inuse = thread_alloc::inuse(thread);
137		f.capacity_taylor(1); // just keep zero order coefficients
138		ok &= thread_alloc::inuse(thread) < inuse;
139
140		// Suppose we no longer need the zero order Taylor coefficients
141		// (could have done this first and not used f.capacity_taylor(1)).
142		inuse = thread_alloc::inuse(thread);
143		f.capacity_taylor(0);
144		ok &= thread_alloc::inuse(thread) < inuse;
145
146		// turn off memory holding
147		thread_alloc::hold_memory(false);
148
149		return ok;
150		}
151		}
152		bool capacity_taylor(void)
153		{ bool ok = true;
154		using CppAD::thread_alloc;
155
156		// original amount of memory inuse
157		size_t thread = thread_alloc::thread_num();
158		ok &= thread == 0; // this should be master thread
159		size_t inuse = thread_alloc::inuse(thread);
160
161		// do test in separate routine so all objects are destroyed
162		ok &= test();
163
164		// check that the amount of memroy inuse has not changed
165		ok &= thread_alloc::inuse(thread) == inuse;
166
167		// Test above uses hold_memory, so return available memory
168		thread_alloc::free_available(thread);
169
170		return ok;
171		}
172
173		</pre>
174
175		</font></code>
176
177
178		<hr/>Input File: example/capacity_taylor.cpp
179
180		</body>
181		</html>

-284

~~doc/capacity_taylor.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>Controlling Taylor Coefficients Memory Allocation</title>
6		<meta name="description" id="description" content="Controlling Taylor Coefficients Memory Allocation"/>
7		<meta name="keywords" id="keywords" content=" Forward capacity capacity_taylor control memory "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_capacity_taylor_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td><a href="compare_change.cpp.xml" target="_top">Prev</a>
24		</td><td><a href="capacity_taylor.cpp.xml" target="_top">Next</a>
25		</td><td>
26		<select onchange='choose_across0(this)'>
27		<option>Index-></option>
28		<option>contents</option>
29		<option>reference</option>
30		<option>index</option>
31		<option>search</option>
32		<option>external</option>
33		</select>
34		</td>
35		<td>
36		<select onchange='choose_up0(this)'>
37		<option>Up-></option>
38		<option>CppAD</option>
39		<option>ADFun</option>
40		<option>FunEval</option>
41		<option>Forward</option>
42		<option>capacity_taylor</option>
43		</select>
44		</td>
45		<td>
46		<select onchange='choose_down3(this)'>
47		<option>ADFun-></option>
48		<option>Independent</option>
49		<option>FunConstruct</option>
50		<option>Dependent</option>
51		<option>abort_recording</option>
52		<option>seq_property</option>
53		<option>FunEval</option>
54		<option>Drivers</option>
55		<option>FunCheck</option>
56		<option>optimize</option>
57		<option>check_for_nan</option>
58		</select>
59		</td>
60		<td>
61		<select onchange='choose_down2(this)'>
62		<option>FunEval-></option>
63		<option>Forward</option>
64		<option>Reverse</option>
65		<option>Sparse</option>
66		</select>
67		</td>
68		<td>
69		<select onchange='choose_down1(this)'>
70		<option>Forward-></option>
71		<option>ForwardZero</option>
72		<option>ForwardOne</option>
73		<option>ForwardAny</option>
74		<option>size_taylor</option>
75		<option>CompareChange</option>
76		<option>capacity_taylor</option>
77		<option>number_skip</option>
78		<option>forward.cpp</option>
79		<option>forward_mul.cpp</option>
80		</select>
81		</td>
82		<td>
83		<select onchange='choose_down0(this)'>
84		<option>capacity_taylor-></option>
85		<option>capacity_taylor.cpp</option>
86		</select>
87		</td>
88		<td>
89		<select onchange='choose_current0(this)'>
90		<option>Headings-></option>
91		<option>Syntax</option>
92		<option>---..See Also</option>
93		<option>Purpose</option>
94		<option>f</option>
95		<option>c</option>
96		<option>---..Pre-Allocating Memory</option>
97		<option>---..Freeing Memory</option>
98		<option>Original State</option>
99		<option>Example</option>
100		</select>
101		</td>
102		</tr></table><br/>
103
104
105
106
107
108
109
110
111
112		<center><b><big><big>Controlling Taylor Coefficients Memory Allocation</big></big></b></center>
113		<br/>
114		<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
115
116		<br/>
117
118		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity_taylor(</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
119
120
121		<br/>
122		<br/>
123		<b><a name="Syntax.See Also" id="Syntax.See Also">See Also</a></b>
124
125		<br/>
126		<a href="seq_property.xml" target="_top"><span style='white-space: nowrap'>seq_property</span></a>
127
128
129		<br/>
130		<br/>
131		<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
132		<br/>
133		The Taylor coefficients calculated by <a href="forward.xml" target="_top"><span style='white-space: nowrap'>Forward</span></a>
134		mode calculations
135		are retained in an <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
136		object for subsequent use during
137		<a href="reverse.xml" target="_top"><span style='white-space: nowrap'>Reverse</span></a>
138		mode or higher order Forward mode calculations.
139		To be specific, a call to <a href="forwardany.xml" target="_top"><span style='white-space: nowrap'>Forward</span></a>
140		with the syntax
141
142		<code><font color="blue"><span style='white-space: nowrap'><br/>
143		</span></font><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
144		</span></font></code>
145		uses the lower order Taylor coefficients and
146		computes the <i>p</i>-th order Taylor coefficients for all
147		the variables in the operation sequence corresponding to
148		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
149		.
150		You can determine the number of variables in the operation sequence
151		using the <a href="seq_property.xml#size_var" target="_top"><span style='white-space: nowrap'>size_var</span></a>
152		function.
153		The <code><font color="blue">capacity_taylor</font></code> operation allows you to control that
154		amount of memory that is retained by an AD function object
155		(to hold <code><font color="blue">Forward</font></code> results for subsequent calculations).
156
157		<br/>
158		<br/>
159		<b><big><a name="f" id="f">f</a></big></b>
160		<br/>
161		The object
162		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
163		has prototype
164
165		<code><font color="blue"><span style='white-space: nowrap'><br/>
166		ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
167		</span></font></code>
168		<br/>
169		<b><big><a name="c" id="c">c</a></big></b>
170		<br/>
171		The argument
172		<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
173		has prototype
174
175		<code><font color="blue"><span style='white-space: nowrap'><br/>
176		size_t </span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
177		</span></font></code>
178		It specifies the number of Taylor coefficients that are allocated for
179		each variable in the AD operation sequence corresponding to
180		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
181		.
182
183
184		<br/>
185		<br/>
186		<b><a name="c.Pre-Allocating Memory" id="c.Pre-Allocating Memory">Pre-Allocating Memory</a></b>
187		<br/>
188		If you plan to make calls to <code><font color="blue">Forward</font></code> with the maximum value of
189
190		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
191		equal to
192		<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
193		,
194		it should be faster to pre-allocate memory for these calls using
195
196		<code><font color="blue"><span style='white-space: nowrap'><br/>
197		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity_taylor(</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
198		</span></font></code>
199		with
200		<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
201		equal to
202		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
203		<mi mathvariant='italic'>q</mi>
204		<mo stretchy="false">+</mo>
205		<mn>1</mn>
206		</mrow></math>
207
208		.
209		If you do no do this, <code><font color="blue">Forward</font></code> will automatically allocate memory
210		and will copy the results to a larger buffer, when necessary.
211		<code><span style='white-space: nowrap'><br/>
212		<br/>
213		</span></code>Note that each call to <a href="dependent.xml" target="_top"><span style='white-space: nowrap'>Dependent</span></a>
214		frees the old memory
215		connected to the function object and sets the corresponding
216		taylor capacity to zero.
217
218		<br/>
219		<br/>
220		<b><a name="c.Freeing Memory" id="c.Freeing Memory">Freeing Memory</a></b>
221		<br/>
222		If you no longer need the Taylor coefficients of order
223		<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
224
225		and higher (that are stored in
226		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
227		),
228		you can reduce the memory allocated to
229		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
230		using
231
232		<code><font color="blue"><span style='white-space: nowrap'><br/>
233		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity_taylor(</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
234		</span></font></code>
235		with
236		<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
237		equal to
238		<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
239		.
240		Note that, if <a href="ta_hold_memory.xml" target="_top"><span style='white-space: nowrap'>ta_hold_memory</span></a>
241		is true, this memory is not actually
242		returned to the system, but rather held for future use by the same thread.
243
244		<br/>
245		<br/>
246		<b><big><a name="Original State" id="Original State">Original State</a></big></b>
247		<br/>
248		If
249		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
250		is <a href="funconstruct.xml" target="_top"><span style='white-space: nowrap'>constructed</span></a>
251		with the syntax
252
253		<code><font color="blue"><span style='white-space: nowrap'><br/>
254		ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>(</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
255		</span></font></code>
256		,
257		there is an implicit call to <code><font color="blue">Forward</font></code> with
258		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
259		equal to zero
260		and
261		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i></code>
262		equal to
263		the value of the
264		<a href="glossary.xml#Tape.Independent Variable" target="_top"><span style='white-space: nowrap'>independent variables</span></a>
265
266		when the AD operation sequence was recorded.
267
268
269		<br/>
270		<br/>
271		<b><big><a name="Example" id="Example">Example</a></big></b>
272		<br/>
273		The file
274		<a href="capacity_taylor.cpp.xml" target="_top"><span style='white-space: nowrap'>capacity_taylor.cpp</span></a>
275
276		contains an example and test of these operations.
277		It returns true if it succeeds and false otherwise.
278
279
280		<hr/>Input File: cppad/local/cap_taylor.hpp
281
282		</body>
283		</html>

-1

doc/change_const.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Computing a Jacobian With Constants that Change</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Computing a Jacobian With Constants that Change"/>
7		<meta name="keywords" id="keywords" content=" multiple Ad level constant that change "/>
	8	<meta name="keywords" id="keywords" content=" computing a jacobian with constants that change multiple Ad level constant purpose "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/check_for_nan.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ADFun Checking For Nan: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ADFun Checking For Nan: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" check_for_nan example test "/>
	8	<meta name="keywords" id="keywords" content=" adfun checking for nan: example and test check_for_nan "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+15

-2

doc/check_for_nan.xml less more

3	3	>
4	4	<head>
5	5	<title>Check an ADFun Object For Nan</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Check an ADFun Object For Nan"/>
7		<meta name="keywords" id="keywords" content=" nan check Adfun in "/>
	8	<meta name="keywords" id="keywords" content=" check an adfun object for nan Adfun in syntax purpose f b default example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

84	85	<option>Purpose</option>
85	86	<option>f</option>
86	87	<option>b</option>
	88	<option>Default</option>
87	89	<option>Example</option>
88	90	</select>
89	91	</td>

108	110	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
109	111	<br/>
110	112	If <code><font color="blue">NDEBUG</font></code> is not defined and
111		the result of a <a href="forwardany.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
	113	the result of a <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
112	114	or <a href="reverse_any.xml" target="_top"><span style='white-space: nowrap'>reverse</span></a>
113	115
114	116	calculation contains a <a href="nan.xml" target="_top"><span style='white-space: nowrap'>nan</span></a>

161	163
162	164	<br/>
163	165	<br/>
	166	<b><big><a name="Default" id="Default">Default</a></big></b>
	167	<br/>
	168	The value for this setting after construction of
	169	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	170	) is true.
	171	The value of this setting is not affected by calling
	172	<a href="dependent.xml" target="_top"><span style='white-space: nowrap'>Dependent</span></a>
	173	for this function object.
	174
	175	<br/>
	176	<br/>
164	177	<b><big><a name="Example" id="Example">Example</a></big></b>
165	178
166	179	<br/>

-1

doc/check_numeric_type.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The CheckNumericType Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The CheckNumericType Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Checknumerictype example check Numerictype test "/>
	8	<meta name="keywords" id="keywords" content=" the checknumerictype function: example and test Checknumerictype check Numerictype "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/check_simple_vector.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The CheckSimpleVector Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The CheckSimpleVector Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Checksimplevector example check Simplevector test "/>
	8	<meta name="keywords" id="keywords" content=" the checksimplevector function: example and test Checksimplevector check Simplevector "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/checknumerictype.xml less more

3	3	>
4	4	<head>
5	5	<title>Check NumericType Class Concept</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Check NumericType Class Concept"/>
7		<meta name="keywords" id="keywords" content=" numeric check concept parallel Checknumerictype "/>
	8	<meta name="keywords" id="keywords" content=" check numerictype class concept numeric syntax purpose include parallel mode Checknumerictype example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+19

-18

doc/checkpoint.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Simple Checkpointing: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Simple Checkpointing: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" checkpoint example test "/>
	8	<meta name="keywords" id="keywords" content=" simple checkpointing: example and test checkpoint purpose "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

265	266	ok &= check_yes.size_var() < check_not.size_var();
266	267
267	268	// compare forward mode results for orders 0, 1, 2
268		size_t p = 2;
269		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x_p(n(p+1)), z_not(m(p+1)), z_yes(m*(p+1));
	269	size_t q = 2;
	270	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x_q(n(q+1)), z_not(m(q+1)), z_yes(m*(q+1));
270	271	for(j = 0; j < n; j++)
271		{ for(k = 0; k <= p; k++)
272		x_p[ j * (p+1) + k ] = 1.0 / (p + 1 - k);
273		}
274		z_not = check_not.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
275		z_yes = check_yes.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
276		for(i = 0; i < m; i++)
277		{ for(k = 0; k <= p; k++)
278		{ double zik_not = z_not[ i * (p+1) + k];
279		double zik_yes = z_yes[ i * (p+1) + k];
	272	{ for(k = 0; k <= q; k++)
	273	x_q[ j * (q+1) + k ] = 1.0 / (q + 1 - k);
	274	}
	275	z_not = check_not.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	276	z_yes = check_yes.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	277	for(i = 0; i < m; i++)
	278	{ for(k = 0; k <= q; k++)
	279	{ double zik_not = z_not[ i * (q+1) + k];
	280	double zik_yes = z_yes[ i * (q+1) + k];
280	281	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(zik_not, zik_yes, eps, eps);
281	282	}
282	283	}
283	284
284	285	// compare reverse mode results
285		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) w(m(p+1)), dw_not(n(p+1)), dw_yes(n*(p+1));
286		dw_not = check_not.<a href="reverse.xml" target="_top">Reverse</a>(p+1, w);
287		dw_yes = check_yes.<a href="reverse.xml" target="_top">Reverse</a>(p+1, w);
	286	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) w(m(q+1)), dw_not(n(q+1)), dw_yes(n*(q+1));
	287	dw_not = check_not.<a href="reverse.xml" target="_top">Reverse</a>(q+1, w);
	288	dw_yes = check_yes.<a href="reverse.xml" target="_top">Reverse</a>(q+1, w);
288	289	for(j = 0; j < n; j++)
289		{ for(k = 0; k <= p; k++)
290		{ double dwjk_not = dw_not[ j * (p+1) + k];
291		double dwjk_yes = dw_yes[ j * (p+1) + k];
	290	{ for(k = 0; k <= q; k++)
	291	{ double dwjk_not = dw_not[ j * (q+1) + k];
	292	double dwjk_yes = dw_yes[ j * (q+1) + k];
292	293	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dwjk_not, dwjk_yes, eps, eps);
293	294	}
294	295	}

-1

doc/checkpoint.xml less more

3	3	>
4	4	<head>
5	5	<title>Checkpointing Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Checkpointing Functions"/>
7		<meta name="keywords" id="keywords" content=" function checkpoint "/>
	8	<meta name="keywords" id="keywords" content=" checkpointing functions function checkpoint syntax purpose method constructor base advector name ax ay option algo afun clear restriction example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/checksimplevector.xml less more

3	3	>
4	4	<head>
5	5	<title>Check Simple Vector Concept</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Check Simple Vector Concept"/>
7		<meta name="keywords" id="keywords" content=" simple vector check concept parallel Checksimplevector "/>
	8	<meta name="keywords" id="keywords" content=" check simple vector concept syntax purpose x y restrictions include parallel mode Checksimplevector example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+83

-69

doc/cmake.xml less more

3	3	>
4	4	<head>
5	5	<title>Using CMake to Configure CppAD</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using CMake to Configure CppAD"/>
7		<meta name="keywords" id="keywords" content=" cmake configure cppad command makefile generator install prefix include directories data directory library postfix package c++ compile flags documentation maximum number threads sparsity internal structure vector of sets memory usage tape ctor implicit or explicit "/>
	8	<meta name="keywords" id="keywords" content=" using cmake to configure cppad the program command build directory generator makefile cmake_install_prefix install prefix cmake_install_includedirs include directories cmake_install_datadir data cmake_install_docdir cmake_install_libdirs library cmake_install_postfix postfix package_prefix package cppad_cxx_flags c++ compile flags cppad_testvector cppad_max_num_threads maximum number threads cppad_sparse_list sparsity internal structure vector of sets cppad_tape_id_type memory usage tape cstdint cppad_tape_addr_type cppad_implicit_ctor_from_any_type ctor implicit or explicit "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

61	62	<option>Install-></option>
62	63	<option>download</option>
63	64	<option>cmake</option>
64		<option>cppad_test</option>
	65	<option>cmake_check</option>
65	66	<option>pkgconfig</option>
66	67	<option>InstallUnix</option>
67	68	</select>

70	71	<select onchange='choose_down0(this)'>
71	72	<option>cmake-></option>
72	73	<option>adolc_prefix</option>
	74	<option>colpack_prefix</option>
73	75	<option>eigen_prefix</option>
74	76	<option>fadbad_prefix</option>
75	77	<option>ipopt_prefix</option>

82	84	<option>Headings-></option>
83	85	<option>The CMake Program</option>
84	86	<option>CMake Command</option>
	87	<option>---..Build Directory</option>
85	88	<option>generator</option>
86	89	<option>cmake_install_prefix</option>
87	90	<option>cmake_install_includedirs</option>
88	91	<option>cmake_install_datadir</option>
	92	<option>cmake_install_docdir</option>
89	93	<option>cmake_install_libdirs</option>
90	94	<option>cmake_install_postfix</option>
91	95	<option>package_prefix</option>
92	96	<option>cppad_cxx_flags</option>
93		<option>cppad_documentation</option>
94	97	<option>cppad_testvector</option>
95	98	<option>cppad_max_num_threads</option>
96	99	<option>cppad_sparse_list</option>
97	100	<option>cppad_tape_id_type</option>
	101	<option>---..cstdint</option>
98	102	<option>cppad_tape_addr_type</option>
	103	<option>---..cstdint</option>
99	104	<option>cppad_implicit_ctor_from_any_type</option>
100	105	</select>
101	106	</td>

125	130
126	131
127	132	<br/>
128		The command below assume that <code><font color="blue">cmake</font></code> is in your execution
	133	The command below assumes that <code><font color="blue">cmake</font></code> is in your execution
129	134	path. If not, you can put the path to <code><font color="blue">cmake</font></code> in font the command.
130	135	Only the <code><font color="blue">cmake</font></code> command and the path to the distribution directory
131	136	(<code><font color="blue">..</font></code> at the end of the command below) are required.
132	137	In other words, the first and last lines below are required
133	138	and all of the other lines are optional.
	139
	140	<br/>
	141	<br/>
	142	<b><a name="CMake Command.Build Directory" id="CMake Command.Build Directory">Build Directory</a></b>
	143	<br/>
134	144	Create a <code><font color="blue">build</font></code> subdirectory of the
135	145	<a href="download.xml#Distribution Directory" target="_top"><span style='white-space: nowrap'>distribution directory</span></a>
136	146	,

143	153	-D cmake_install_prefix=</span></font><i><font color="black"><span style='white-space: nowrap'>cmake_install_prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>                           \<br/>
144	154	-D cmake_install_includedirs=</span></font><i><font color="black"><span style='white-space: nowrap'>cmake_install_includedirs</span></font></i><font color="blue"><span style='white-space: nowrap'>                 \<br/>
145	155	-D cmake_install_datadir=</span></font><i><font color="black"><span style='white-space: nowrap'>cmake_install_datadir</span></font></i><font color="blue"><span style='white-space: nowrap'>                         \<br/>
	156	-D cmake_install_docdir=</span></font><i><font color="black"><span style='white-space: nowrap'>cmake_install_docdir</span></font></i><font color="blue"><span style='white-space: nowrap'>                           \<br/>
146	157	-D cmake_install_libdirs=</span></font><i><font color="black"><span style='white-space: nowrap'>cmake_install_libdirs</span></font></i><font color="blue"><span style='white-space: nowrap'>                         \<br/>
147	158	-D cmake_install_postfix=</span></font><i><font color="black"><span style='white-space: nowrap'>cmake_install_postfix</span></font></i><font color="blue"><span style='white-space: nowrap'>                         \<br/>
148	159	\<br/>
149	160	-D adolc_prefix=</span></font><i><font color="black"><span style='white-space: nowrap'>adolc_prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>                                           \<br/>
	161	-D colpack_prefix=</span></font><i><font color="black"><span style='white-space: nowrap'>colpack_prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>                                       \<br/>
150	162	-D eigen_prefix=</span></font><i><font color="black"><span style='white-space: nowrap'>eigen_prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>                                           \<br/>
151	163	-D fadbad_prefix=</span></font><i><font color="black"><span style='white-space: nowrap'>fadbad_prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>                                         \<br/>
152	164	-D ipopt_prefix=</span></font><i><font color="black"><span style='white-space: nowrap'>ipopt_prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>                                           \<br/>
153	165	-D sacado_prefix=</span></font><i><font color="black"><span style='white-space: nowrap'>sacado_prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>                                         \<br/>
154	166	\<br/>
155	167	-D cppad_cxx_flags=</span></font><i><font color="black"><span style='white-space: nowrap'>cppad_cxx_flags</span></font></i><font color="blue"><span style='white-space: nowrap'>                                     \<br/>
156		-D cppad_documentation=</span></font><i><font color="black"><span style='white-space: nowrap'>cppad_documentation</span></font></i><font color="blue"><span style='white-space: nowrap'>                             \<br/>
157	168	\<br/>
158	169	-D cppad_testvector=</span></font><i><font color="black"><span style='white-space: nowrap'>cppad_testvector</span></font></i><font color="blue"><span style='white-space: nowrap'>                                   \<br/>
159	170	-D cppad_max_num_threads=</span></font><i><font color="black"><span style='white-space: nowrap'>cppad_max_num_threads</span></font></i><font color="blue"><span style='white-space: nowrap'>                         \<br/>

251	262	and
252	263
253	264	<code><i><font color="black"><span style='white-space: nowrap'>cmake_install_postfix</span></font></i></code>
	265	are not specified,
	266	the <a href="pkgconfig.xml" target="_top"><span style='white-space: nowrap'>pkgconfig</span></a>
	267	file <code><font color="blue">cppad.pc</font></code> will be installed in the location
	268
	269	<code><font color="blue"><span style='white-space: nowrap'><br/>
	270	/usr/share/pkgconfig/cppad.pc<br/>
	271	</span></font></code>
	272	<br/>
	273	<b><big><a name="cmake_install_docdir" id="cmake_install_docdir">cmake_install_docdir</a></big></b>
	274
	275
	276	<br/>
	277	This is the directory is present, the documentation files are installed
	278	in this sub-directory below the
	279	<code><i><font color="black"><span style='white-space: nowrap'>cmake_install_prefix</span></font></i></code>
	280	.
	281	For example, if
	282
	283	<code><i><font color="black"><span style='white-space: nowrap'>cmake_install_prefix</span></font></i></code>
	284	and
	285
	286	<code><i><font color="black"><span style='white-space: nowrap'>cmake_install_postfix</span></font></i></code>
254	287	are not specified, and
255	288
256		<code><i><font color="black"><span style='white-space: nowrap'>cppad_documentation</span></font></i></code>
257		is <code><font color="blue">YES</font></code>,
258		the file <code><font color="blue">doc/cppad.xml</font></code> will be installed in the location
259
260		<code><font color="blue"><span style='white-space: nowrap'><br/>
261		/usr/share/doc/cppad-</span></font><i><font color="black"><span style='white-space: nowrap'>version</span></font></i><font color="blue"><span style='white-space: nowrap'>/cppad.xml<br/>
262		</span></font></code>
263		where
264		<code><i><font color="black"><span style='white-space: nowrap'>version</span></font></i></code>
265		is version number for this copy of CppAD.
266
267		<br/>
	289	<code><font color="blue"><span style='white-space: nowrap'><br/>
	290	-D cmake_install_docdir=share/doc<br/>
	291	</span></font></code>
	292	the file <code><font color="blue">cppad.xml</font></code> will be installed in the location
	293
	294	<code><font color="blue"><span style='white-space: nowrap'><br/>
	295	/usr/share/doc/cppad/cppad.xml<br/>
	296	</span></font></code>
268	297	<br/>
269	298	<b><big><a name="cmake_install_libdirs" id="cmake_install_libdirs">cmake_install_libdirs</a></big></b>
270	299

317	346	are not specified, and
318	347
319	348	<code><font color="blue"><span style='white-space: nowrap'><br/>
320		-D cppad_documentation=YES<br/>
321	349	-D cmake_install_postfix=coin<br/>
322	350	</span></font></code>
323		the file <code><font color="blue">cppad.xml</font></code> will be installed in the location
324
325		<code><font color="blue"><span style='white-space: nowrap'><br/>
326		/usr/share/coin/doc/cppad-</span></font><i><font color="black"><span style='white-space: nowrap'>version</span></font></i><font color="blue"><span style='white-space: nowrap'>/cppad.xml<br/>
	351	the <a href="pkgconfig.xml" target="_top"><span style='white-space: nowrap'>pkgconfig</span></a>
	352	file <code><font color="blue">cppad.pc</font></code> will be installed in the location
	353
	354	<code><font color="blue"><span style='white-space: nowrap'><br/>
	355	/usr/share/coin/pkgconfig/cppad.pc<br/>
327	356	</span></font></code>
328	357	<br/>
329	358	<b><big><a name="package_prefix" id="package_prefix">package_prefix</a></big></b>

334	363
335	364	<a href="adolc_prefix.xml" target="_top">adolc_prefix</a></td><td>
336	365	Including the ADOL-C Examples and Tests</td></tr>
	366	<tr><td>
	367
	368	<a href="colpack_prefix.xml" target="_top">colpack_prefix</a></td><td>
	369	Including the ColPack Sparsity Calculations</td></tr>
337	370	<tr><td>
338	371
339	372	<a href="eigen_prefix.xml" target="_top">eigen_prefix</a></td><td>

378	411	currently generate a lot of shadowed variable warnings.
379	412	Hence the <code><font color="blue">-Wshadow</font></code> flag is automatically removed when
380	413	compiling examples and test that use these packages.
381
382		<br/>
383		<br/>
384		<b><big><a name="cppad_documentation" id="cppad_documentation">cppad_documentation</a></big></b>
385
386
387
388		<br/>
389		The default value for
390		<code><i><font color="black"><span style='white-space: nowrap'>cppad_documentation</span></font></i></code>
391		is <code><font color="blue">NO</font></code>.
392		If
393		<code><i><font color="black"><span style='white-space: nowrap'>cppad_documentation</span></font></i></code>
394		is <code><font color="blue">YES</font></code>,
395		and <a href="cmake.xml#cmake_install_postfix" target="_top"><span style='white-space: nowrap'>cmake_install_postfix</span></a>
396		is empty,
397		the CppAD XML documentation files will be installed in the directory
398
399		<code><font color="blue"><span style='white-space: nowrap'><br/>
400		</span></font><i><font color="black"><span style='white-space: nowrap'>prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>/</span></font><i><font color="black"><span style='white-space: nowrap'>datadir</span></font></i><font color="blue"><span style='white-space: nowrap'>/doc/cppad-</span></font><i><font color="black"><span style='white-space: nowrap'>version</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
401		</span></font></code>
402		where
403		<code><i><font color="black"><span style='white-space: nowrap'>prefix</span></font></i></code>
404		is
405		<a href="cmake.xml#cmake_install_prefix" target="_top"><span style='white-space: nowrap'>cmake_install_prefix</span></a>
406		,
407
408		<code><i><font color="black"><span style='white-space: nowrap'>datadir</span></font></i></code>
409		is
410		<a href="cmake.xml#cmake_install_datadir" target="_top"><span style='white-space: nowrap'>cmake_install_datadir</span></a>
411		,
412		and
413		<code><i><font color="black"><span style='white-space: nowrap'>version</span></font></i></code>
414		is the version number for this copy of CppAD.
415		If
416		<code><i><font color="black"><span style='white-space: nowrap'>cmake_install_postfix</span></font></i></code>
417		is non-empty,
418		the CppAD XML documentation files will be installed in the directory
419
420		<code><font color="blue"><span style='white-space: nowrap'><br/>
421		</span></font><i><font color="black"><span style='white-space: nowrap'>prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>/</span></font><i><font color="black"><span style='white-space: nowrap'>datadir</span></font></i><font color="blue"><span style='white-space: nowrap'>/doc/</span></font><i><font color="black"><span style='white-space: nowrap'>postfix</span></font></i><font color="blue"><span style='white-space: nowrap'>/cppad-</span></font><i><font color="black"><span style='white-space: nowrap'>version</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
422		</span></font></code>
423		where
424		<code><i><font color="black"><span style='white-space: nowrap'>postfix</span></font></i></code>
425		is
426		<code><i><font color="black"><span style='white-space: nowrap'>cmake_install_postfix</span></font></i></code>
427		.
428	414
429	415	<br/>
430	416	<br/>

497	483
498	484	is used for identifying different tapes.
499	485	The valid values for this type are
	486	<code><font color="blue">unsigned char</font></code>,
500	487	<code><font color="blue">unsigned short int</font></code>,
501	488	<code><font color="blue">unsigned int</font></code>, and
502	489	<code><font color="blue">size_t</font></code>.

515	502
516	503	<br/>
517	504	<br/>
	505	<b><a name="cppad_tape_id_type.cstdint" id="cppad_tape_id_type.cstdint">cstdint</a></b>
	506	<br/>
	507	If all of the following <code><font color="blue">cstdint</font></code> types are defined,
	508	they can also be used as the value of
	509	<code><i><font color="black"><span style='white-space: nowrap'>cppad_tape_addr_type</span></font></i></code>
	510	:
	511	<code><font color="blue">uint8_t</font></code>,
	512	<code><font color="blue">uint16_t</font></code>,
	513	<code><font color="blue">uint32_t</font></code>,
	514	<code><font color="blue">uint64_t</font></code>.
	515
	516	<br/>
	517	<br/>
518	518	<b><big><a name="cppad_tape_addr_type" id="cppad_tape_addr_type">cppad_tape_addr_type</a></big></b>
519	519
520	520

525	525
526	526	is used for address in the AD recordings (tapes).
527	527	The valid values for this argument are
	528	<code><font color="blue">unsigned char</font></code>,
528	529	<code><font color="blue">unsigned short int</font></code>,
529	530	<code><font color="blue">unsigned int</font></code>,
530	531	<code><font color="blue">size_t</font></code>.

551	552
552	553	<br/>
553	554	<br/>
	555	<b><a name="cppad_tape_addr_type.cstdint" id="cppad_tape_addr_type.cstdint">cstdint</a></b>
	556	<br/>
	557	If all of the following <code><font color="blue">cstdint</font></code> types are defined,
	558	they can also be used as the value of
	559	<code><i><font color="black"><span style='white-space: nowrap'>cppad_tape_addr_type</span></font></i></code>
	560	:
	561	<code><font color="blue">uint8_t</font></code>,
	562	<code><font color="blue">uint16_t</font></code>,
	563	<code><font color="blue">uint32_t</font></code>,
	564	<code><font color="blue">uint64_t</font></code>.
	565
	566	<br/>
	567	<br/>
554	568	<b><big><a name="cppad_implicit_ctor_from_any_type" id="cppad_implicit_ctor_from_any_type">cppad_implicit_ctor_from_any_type</a></big></b>
555	569
556	570

+180

-0

doc/cmake_check.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Checking the CppAD Examples and Tests</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Checking the CppAD Examples and Tests"/>
	8	<meta name="keywords" id="keywords" content=" checking the cppad examples and tests purpose check all subsets "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_cmake_check_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="cppad_testvector.xml" target="_top">Prev</a>
	25	</td><td><a href="pkgconfig.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>Install</option>
	41	<option>cmake_check</option>
	42	</select>
	43	</td>
	44	<td>
	45	<select onchange='choose_down2(this)'>
	46	<option>CppAD-></option>
	47	<option>Install</option>
	48	<option>Introduction</option>
	49	<option>AD</option>
	50	<option>ADFun</option>
	51	<option>preprocessor</option>
	52	<option>multi_thread</option>
	53	<option>library</option>
	54	<option>ipopt_solve</option>
	55	<option>Example</option>
	56	<option>speed</option>
	57	<option>Appendix</option>
	58	</select>
	59	</td>
	60	<td>
	61	<select onchange='choose_down1(this)'>
	62	<option>Install-></option>
	63	<option>download</option>
	64	<option>cmake</option>
	65	<option>cmake_check</option>
	66	<option>pkgconfig</option>
	67	<option>InstallUnix</option>
	68	</select>
	69	</td>
	70	<td>cmake_check</td>
	71	<td>
	72	<select onchange='choose_current0(this)'>
	73	<option>Headings-></option>
	74	<option>Purpose</option>
	75	<option>Check All</option>
	76	<option>Subsets</option>
	77	</select>
	78	</td>
	79	</tr></table><br/>
	80
	81
	82
	83	<center><b><big><big>Checking the CppAD Examples and Tests</big></big></b></center>
	84	<br/>
	85	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	86	<br/>
	87	After you configure your system with the
	88	<a href="cmake.xml#CMake Command" target="_top"><span style='white-space: nowrap'>cmake command</span></a>
	89	you
	90	can run the CppAD example and tests to make sure that
	91	CppAD functions properly on your system.
	92
	93
	94	<br/>
	95	<br/>
	96	<b><big><a name="Check All" id="Check All">Check All</a></big></b>
	97	<br/>
	98	In the <code><font color="blue">build</font></code> subdirectory of the
	99	<a href="download.xml#Distribution Directory" target="_top"><span style='white-space: nowrap'>distribution directory</span></a>
	100
	101	execute the command
	102	<code><font color='blue'><pre style='display:inline'>
	103	make check
	104	</pre></font></code>
	105
	106	This will build and run all of the tests that are support
	107	by your system and the <a href="cmake.xml" target="_top"><span style='white-space: nowrap'>cmake</span></a>
	108	command options.
	109	If you created <code><font color="blue">nmake</font></code> makefiles, you will have
	110	to use <code><font color="blue">nmake</font></code> instead of <code><font color="blue">make</font></code> in the command above; see
	111	the <a href="cmake.xml#generator" target="_top"><span style='white-space: nowrap'>generator</span></a>
	112	option for the <code><font color="blue">cmake</font></code> command.
	113
	114	<br/>
	115	<br/>
	116	<b><big><a name="Subsets" id="Subsets">Subsets</a></big></b>
	117	<br/>
	118	It is possible to build and run the following subsets of the
	119	examples and tests:
	120	<table><tr><td align='left' valign='top'>
	121
	122	Command </td><td align='left' valign='top'>
	123
	124	Description
	125	</td></tr><tr><td align='left' valign='top'>
	126
	127	<code><font color="blue">make check_compare_c</font></code> </td><td align='left' valign='top'>
	128
	129	<a href="compare_c.xml" target="_top">Compare Speed of C and C++</a>
	130	</td></tr><tr><td align='left' valign='top'>
	131
	132	<code><font color="blue">make check_introduction</font></code> </td><td align='left' valign='top'>
	133
	134	the programs in the <a href="introduction.xml" target="_top"><span style='white-space: nowrap'>Introduction</span></a>
	135
	136	</td></tr><tr><td align='left' valign='top'>
	137
	138	<code><font color="blue">make check_example</font></code> </td><td align='left' valign='top'>
	139
	140	most of the <a href="example.xml" target="_top"><span style='white-space: nowrap'>Example</span></a>
	141	programs
	142	</td></tr><tr><td align='left' valign='top'>
	143
	144	<code><font color="blue">make check_print_for</font></code> </td><td align='left' valign='top'>
	145
	146	the <a href="printfor.xml" target="_top"><span style='white-space: nowrap'>PrintFor</span></a>
	147	command
	148	</td></tr><tr><td align='left' valign='top'>
	149
	150	<code><font color="blue">make check_test_more</font></code> </td><td align='left' valign='top'>
	151
	152	correctness tests that are not examples
	153	</td></tr><tr><td align='left' valign='top'>
	154
	155	<code><font color="blue">make check_multi_thread</font></code> </td><td align='left' valign='top'>
	156
	157	<a href="multi_thread.xml" target="_top"><span style='white-space: nowrap'>multi_thread</span></a>
	158	tests (run correctness only)
	159	</td></tr><tr><td align='left' valign='top'>
	160
	161	<code><font color="blue">make check_speed</font></code> </td><td align='left' valign='top'>
	162
	163	single threading <a href="speed.xml" target="_top"><span style='white-space: nowrap'>speed</span></a>
	164	tests (run correctness only)
	165	</td></tr><tr><td align='left' valign='top'>
	166
	167	<code><font color="blue">make check_cppad_ipopt</font></code> </td><td align='left' valign='top'>
	168
	169	the <a href="cppad_ipopt_nlp.xml" target="_top"><span style='white-space: nowrap'>cppad_ipopt_nlp</span></a>
	170	speed and correctness tests
	171	</td></tr><tr><td align='left' valign='top'>
	172
	173	</td></tr>
	174	</table>
	175
	176	<hr/>Input File: omh/install/cmake_check.omh
	177
	178	</body>
	179	</html>

+183

-0

doc/colpack.cpp.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Using ColPack: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Using ColPack: Example and Test"/>
	8	<meta name="keywords" id="keywords" content=" using colpack: example and test colpack spare "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_colpack.cpp_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="colpack_prefix.xml" target="_top">Prev</a>
	25	</td><td><a href="get_colpack.sh.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>Install</option>
	41	<option>cmake</option>
	42	<option>colpack_prefix</option>
	43	<option>colpack.cpp</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>Install-></option>
	49	<option>download</option>
	50	<option>cmake</option>
	51	<option>cmake_check</option>
	52	<option>pkgconfig</option>
	53	<option>InstallUnix</option>
	54	</select>
	55	</td>
	56	<td>
	57	<select onchange='choose_down2(this)'>
	58	<option>cmake-></option>
	59	<option>adolc_prefix</option>
	60	<option>colpack_prefix</option>
	61	<option>eigen_prefix</option>
	62	<option>fadbad_prefix</option>
	63	<option>ipopt_prefix</option>
	64	<option>sacado_prefix</option>
	65	<option>cppad_testvector</option>
	66	</select>
	67	</td>
	68	<td>
	69	<select onchange='choose_down1(this)'>
	70	<option>colpack_prefix-></option>
	71	<option>colpack.cpp</option>
	72	<option>get_colpack.sh</option>
	73	</select>
	74	</td>
	75	<td>colpack.cpp</td>
	76	<td>Headings</td>
	77	</tr></table><br/>
	78
	79
	80
	81	<center><b><big><big>Using ColPack: Example and Test</big></big></b></center>
	82	<code><font color="blue"><pre style='display:inline'>
	83
	84	# include <cppad/cppad.hpp>
	85	bool colpack(void)
	86	{ bool ok = true;
	87	using CppAD::AD;
	88	using CppAD::NearEqual;
	89	typedef <a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) a_vector;
	90	typedef <a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) d_vector;
	91	typedef CppAD::vector<size_t> i_vector;
	92	size_t i, j, k, ell;
	93	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	94
	95	// domain space vector
	96	size_t n = 4;
	97	a_vector a_x(n);
	98	for(j = 0; j < n; j++)
	99	a_x[j] = <a href="ad.xml" target="_top">AD</a><double> (0);
	100
	101	// declare independent variables and starting recording
	102	CppAD::<a href="independent.xml" target="_top">Independent</a>(a_x);
	103
	104	size_t m = 3;
	105	a_vector a_y(m);
	106	a_y[0] = a_x[0] + a_x[1];
	107	a_y[1] = a_x[2] + a_x[3];
	108	a_y[2] = a_x[0] + a_x[1] + a_x[2] + a_x[3] * a_x[3] / 2.;
	109
	110	// create f: x -> y and stop tape recording
	111	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(a_x, a_y);
	112
	113	// new value for the independent variable vector
	114	d_vector x(n);
	115	for(j = 0; j < n; j++)
	116	x[j] = double(j);
	117
	118	/*
	119	[ 1 1 0 0 ]
	120	jac = [ 0 0 1 1 ]
	121	[ 1 1 1 x_3]
	122	*/
	123	d_vector check(m * n);
	124	check[0] = 1.; check[1] = 1.; check[2] = 0.; check[3] = 0.;
	125	check[4] = 0.; check[5] = 0.; check[6] = 1.; check[7] = 1.;
	126	check[8] = 1.; check[9] = 1.; check[10] = 1.; check[11] = x[3];
	127
	128	// Normally one would use f.ForSparseJac or f.RevSparseJac to compute
	129	// sparsity pattern, but for this example we extract it from check.
	130	std::vector< std::set<size_t> > p(m);
	131
	132	// using row and column indices to compute non-zero in rows 1 and 2
	133	i_vector row, col;
	134	for(i = 0; i < m; i++)
	135	{ for(j = 0; j < n; j++)
	136	{ ell = i * n + j;
	137	if( check[ell] != 0. )
	138	{ row.push_back(i);
	139	col.push_back(j);
	140	p[i].insert(j);
	141	}
	142	}
	143	}
	144	size_t K = row.size();
	145	d_vector jac(K);
	146
	147	// empty work structure
	148	CppAD::sparse_jacobian_work work;
	149	ok &= work.color_method == "cppad";
	150
	151	// choose to use ColPack
	152	work.color_method = "colpack";
	153
	154	// forward mode
	155	size_t n_sweep = f.SparseJacobianForward(x, p, row, col, jac, work);
	156	for(k = 0; k < K; k++)
	157	{ ell = row[k] * n + col[k];
	158	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(check[ell], jac[k], eps, eps);
	159	}
	160	ok &= n_sweep == 4;
	161
	162	// reverse mode
	163	work.clear();
	164	work.color_method = "colpack";
	165	n_sweep = f.SparseJacobianReverse(x, p, row, col, jac, work);
	166	for(k = 0; k < K; k++)
	167	{ ell = row[k] * n + col[k];
	168	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(check[ell], jac[k], eps, eps);
	169	}
	170	ok &= n_sweep == 2;
	171
	172	return ok;
	173	}
	174	</pre>
	175
	176	</font></code>
	177
	178
	179	<hr/>Input File: example/colpack.cpp
	180
	181	</body>
	182	</html>

+206

-0

doc/colpack_prefix.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Including the ColPack Sparsity Calculations</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Including the ColPack Sparsity Calculations"/>
	8	<meta name="keywords" id="keywords" content=" including the colpack sparsity calculations purpose colpack_prefix prefix cppad_colpack.cpp example get_colpack get "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_colpack_prefix_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="get_adolc.sh.xml" target="_top">Prev</a>
	25	</td><td><a href="colpack.cpp.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>Install</option>
	41	<option>cmake</option>
	42	<option>colpack_prefix</option>
	43	</select>
	44	</td>
	45	<td>
	46	<select onchange='choose_down3(this)'>
	47	<option>CppAD-></option>
	48	<option>Install</option>
	49	<option>Introduction</option>
	50	<option>AD</option>
	51	<option>ADFun</option>
	52	<option>preprocessor</option>
	53	<option>multi_thread</option>
	54	<option>library</option>
	55	<option>ipopt_solve</option>
	56	<option>Example</option>
	57	<option>speed</option>
	58	<option>Appendix</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>Install-></option>
	64	<option>download</option>
	65	<option>cmake</option>
	66	<option>cmake_check</option>
	67	<option>pkgconfig</option>
	68	<option>InstallUnix</option>
	69	</select>
	70	</td>
	71	<td>
	72	<select onchange='choose_down1(this)'>
	73	<option>cmake-></option>
	74	<option>adolc_prefix</option>
	75	<option>colpack_prefix</option>
	76	<option>eigen_prefix</option>
	77	<option>fadbad_prefix</option>
	78	<option>ipopt_prefix</option>
	79	<option>sacado_prefix</option>
	80	<option>cppad_testvector</option>
	81	</select>
	82	</td>
	83	<td>
	84	<select onchange='choose_down0(this)'>
	85	<option>colpack_prefix-></option>
	86	<option>colpack.cpp</option>
	87	<option>get_colpack.sh</option>
	88	</select>
	89	</td>
	90	<td>
	91	<select onchange='choose_current0(this)'>
	92	<option>Headings-></option>
	93	<option>Purpose</option>
	94	<option>colpack_prefix</option>
	95	<option>cppad_colpack.cpp</option>
	96	<option>Example</option>
	97	<option>get_colpack</option>
	98	</select>
	99	</td>
	100	</tr></table><br/>
	101
	102
	103
	104
	105	<center><b><big><big>Including the ColPack Sparsity Calculations</big></big></b></center>
	106	<br/>
	107	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	108	<br/>
	109	If you specify a
	110	<code><i><font color="black"><span style='white-space: nowrap'>colpack_prefix</span></font></i></code>
	111	on the
	112	<a href="cmake.xml#CMake Command" target="_top"><span style='white-space: nowrap'>cmake command</span></a>
	113	line,
	114	the CppAD <a href="sparse_jacobian.xml" target="_top"><span style='white-space: nowrap'>sparse_jacobian</span></a>
	115	calculations use the
	116	<a href="http://http://cscapes.cs.purdue.edu/coloringpage/" target="_top"><span style='white-space: nowrap'>ColPack</span></a>
	117	package.
	118
	119	<br/>
	120	<br/>
	121	<b><big><a name="colpack_prefix" id="colpack_prefix">colpack_prefix</a></big></b>
	122
	123
	124	<br/>
	125	If ColPack is installed on your system, you can
	126	specify a value for its install
	127	<code><i><font color="black"><span style='white-space: nowrap'>colpack_prefix</span></font></i></code>
	128	on the
	129	<a href="cmake.xml" target="_top"><span style='white-space: nowrap'>cmake</span></a>
	130	command line.
	131	The value of
	132	<code><i><font color="black"><span style='white-space: nowrap'>colpack_prefix</span></font></i></code>
	133	must be such that,
	134	for one of the directories
	135	<code><i><font color="black"><span style='white-space: nowrap'>dir</span></font></i></code>
	136	in
	137	<a href="cmake.xml#cmake_install_includedirs" target="_top"><span style='white-space: nowrap'>cmake_install_includedirs</span></a>
	138	,
	139
	140	<code><font color="blue"><span style='white-space: nowrap'><br/>
	141	</span></font><i><font color="black"><span style='white-space: nowrap'>colpack_prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>/</span></font><i><font color="black"><span style='white-space: nowrap'>dir</span></font></i><font color="blue"><span style='white-space: nowrap'>/ColPack/ColPackHeaders.h<br/>
	142	</span></font></code>
	143	is a valid way to reference to the include file <code><font color="blue">ColPackHeaders.h</font></code>.
	144
	145	<br/>
	146	<br/>
	147	<b><big><a name="cppad_colpack.cpp" id="cppad_colpack.cpp">cppad_colpack.cpp</a></big></b>
	148
	149	<br/>
	150	The ColPack header files has a
	151
	152	<code><font color="blue"><span style='white-space: nowrap'><br/>
	153	using namespace std<br/>
	154	</span></font></code>
	155	at the global level.
	156	For this reason, CppAD does not include these files.
	157	It is therefore necessary to compile and link the short file
	158
	159	<code><font color="blue"><span style='white-space: nowrap'><br/>
	160	</span></font><i><font color="black"><span style='white-space: nowrap'>prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>/</span></font><i><font color="black"><span style='white-space: nowrap'>dir</span></font></i><font color="blue"><span style='white-space: nowrap'>/cppad/cppad_colpack.cpp<br/>
	161	</span></font></code>
	162	where
	163	<code><i><font color="black"><span style='white-space: nowrap'>dir</span></font></i></code>
	164	is the
	165	<a href="cmake.xml#cmake_install_datadir" target="_top"><span style='white-space: nowrap'>cmake_install_datadir</span></a>
	166	and
	167	where
	168	<code><i><font color="black"><span style='white-space: nowrap'>prefix</span></font></i></code>
	169	is such that <code><font color="blue">cppad.hpp</font></code> was installed in
	170
	171	<code><font color="blue"><span style='white-space: nowrap'><br/>
	172	</span></font><i><font color="black"><span style='white-space: nowrap'>prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>/include/cppad/cppad.hpp<br/>
	173	</span></font></code>
	174	Hopefully, future versions of ColPack will not have this problem
	175	and it will no longer be necessary to do this.
	176
	177
	178	<br/>
	179	<br/>
	180	<b><big><a name="Example" id="Example">Example</a></big></b>
	181	<br/>
	182	The file <a href="colpack.cpp.xml" target="_top"><span style='white-space: nowrap'>colpack.cpp</span></a>
	183	contains an example and test of using
	184	ColPack to compute the coloring for sparse Jacobians.
	185	It returns true, if it succeeds and false otherwise.
	186
	187	<br/>
	188	<br/>
	189	<b><big><a name="get_colpack" id="get_colpack">get_colpack</a></big></b>
	190
	191
	192	<br/>
	193	If you are using Unix, you can download and install
	194	a copy of ColPack using <a href="get_colpack.sh.xml" target="_top"><span style='white-space: nowrap'>get_colpack.sh</span></a>
	195	.
	196	The corresponding
	197	<code><i><font color="black"><span style='white-space: nowrap'>colpack_prefix</span></font></i></code>
	198	would be
	199	<code><font color="blue">build/prefix</font></code>.
	200
	201
	202	<hr/>Input File: omh/install/colpack_prefix.omh
	203
	204	</body>
	205	</html>

-1

doc/compare.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Binary Comparison Operators: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Binary Comparison Operators: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" compare Ad example test < <= > >= == != "/>
	8	<meta name="keywords" id="keywords" content=" ad binary comparison operators: example and test compare Ad < <= > >= == != "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/compare.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Binary Comparison Operators</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Binary Comparison Operators"/>
7		<meta name="keywords" id="keywords" content=" binary Ad compare operator < <= > >= == != "/>
	8	<meta name="keywords" id="keywords" content=" binary Ad compare operator < <= > >= == != ad comparison operators syntax purpose op x y b operation sequence assumptions example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/compare_c.xml less more

3	3	>
4	4	<head>
5	5	<title>Compare Speed of C and C++</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Compare Speed of C and C++"/>
7		<meta name="keywords" id="keywords" content=" compare speed C and C++ with "/>
	8	<meta name="keywords" id="keywords" content=" compare speed of c and c++ C C++ with syntax purpose "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+10

-9

doc/compare_change.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CompareChange and Re-Tape: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CompareChange and Re-Tape: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" compare change example Comparechange test re-tape "/>
	8	<meta name="keywords" id="keywords" content=" comparechange and re-tape: example test compare change Comparechange re-tape "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="comparechange.xml" target="_top">Prev</a>
24		</td><td><a href="capacity_taylor.xml" target="_top">Next</a>
	25	</td><td><a href="capacity_order.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

54	55	<td>
55	56	<select onchange='choose_down2(this)'>
56	57	<option>Forward-></option>
57		<option>ForwardZero</option>
58		<option>ForwardOne</option>
59		<option>ForwardAny</option>
60		<option>size_taylor</option>
	58	<option>forward_zero</option>
	59	<option>forward_one</option>
	60	<option>forward_two</option>
	61	<option>forward_order</option>
	62	<option>forward_dir</option>
	63	<option>size_order</option>
61	64	<option>CompareChange</option>
62		<option>capacity_taylor</option>
	65	<option>capacity_order</option>
63	66	<option>number_skip</option>
64		<option>forward.cpp</option>
65		<option>forward_mul.cpp</option>
66	67	</select>
67	68	</td>
68	69	<td>

+12

-11

doc/comparechange.xml less more

3	3	>
4	4	<head>
5	5	<title>Comparison Changes During Zero Order Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Comparison Changes During Zero Order Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" Adfun Comparechange zero order forward Ndebug "/>
	8	<meta name="keywords" id="keywords" content=" comparison changes during zero order forward mode Adfun Comparechange syntax purpose f c discussion restrictions Ndebug example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="size_taylor.xml" target="_top">Prev</a>
	24	<td><a href="size_order.xml" target="_top">Prev</a>
24	25	</td><td><a href="compare_change.cpp.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

68	69	<td>
69	70	<select onchange='choose_down1(this)'>
70	71	<option>Forward-></option>
71		<option>ForwardZero</option>
72		<option>ForwardOne</option>
73		<option>ForwardAny</option>
74		<option>size_taylor</option>
	72	<option>forward_zero</option>
	73	<option>forward_one</option>
	74	<option>forward_two</option>
	75	<option>forward_order</option>
	76	<option>forward_dir</option>
	77	<option>size_order</option>
75	78	<option>CompareChange</option>
76		<option>capacity_taylor</option>
	79	<option>capacity_order</option>
77	80	<option>number_skip</option>
78		<option>forward.cpp</option>
79		<option>forward_mul.cpp</option>
80	81	</select>
81	82	</td>
82	83	<td>

214	215	(so AD operation sequence properly represents the algorithm
215	216	for this value of independent variables).
216	217	On the other hand, re-taping the AD operation sequence usually takes
217		significantly more time than evaluation using <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>ForwardZero</span></a>
	218	significantly more time than evaluation using <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
218	219	.
219	220	If the functions values have not changed (see <a href="funcheck.xml" target="_top"><span style='white-space: nowrap'>FunCheck</span></a>
220	221	)

248	249	They return true if they succeed and false otherwise.
249	250
250	251
251		<hr/>Input File: omh/forward.omh
	252	<hr/>Input File: omh/forward/compare_change.omh
252	253
253	254	</body>
254	255	</html>

-1

doc/complex_poly.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Complex Polynomial: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Complex Polynomial: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" complex polynomial example test "/>
	8	<meta name="keywords" id="keywords" content=" complex polynomial: example and test polynomial see also poly "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/compute_assign.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Computed Assignment Operators</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Computed Assignment Operators"/>
7		<meta name="keywords" id="keywords" content=" assignment operator + computed add plus - subtract minus * multiply times / divide multiple "/>
	8	<meta name="keywords" id="keywords" content=" ad computed assignment operators operator + add plus - subtract minus * multiply times / divide syntax purpose op base x y result multiple operation sequence example derivative addition subtraction multiplication division "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/cond_exp.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Conditional Expressions: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Conditional Expressions: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Condexp example test "/>
	8	<meta name="keywords" id="keywords" content=" conditional expressions: example and test Condexp description "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/condexp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Conditional Expressions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Conditional Expressions"/>
7		<meta name="keywords" id="keywords" content=" conditional expression assign "/>
	8	<meta name="keywords" id="keywords" content=" conditional expression assign ad expressions syntax purpose rel type left right if_true if_false result optimize deprecated operation sequence example test atan2 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

272	273	The <a href="optimize.xml" target="_top"><span style='white-space: nowrap'>optimize</span></a>
273	274	method will optimize conditional expressions
274	275	in the following way:
275		During <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>zero order forward mode</span></a>
	276	During <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>zero order forward mode</span></a>
276	277	,
277	278	once the value of the
278	279	<code><i><font color="black"><span style='white-space: nowrap'>left</span></font></i></code>

-1

doc/conj_grad.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Differentiate Conjugate Gradient Algorithm: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Differentiate Conjugate Gradient Algorithm: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" gradient conjugate example test "/>
	8	<meta name="keywords" id="keywords" content=" differentiate conjugate gradient algorithm: example and test purpose algorithm "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/convert.xml less more

3	3	>
4	4	<head>
5	5	<title>Conversion and I/O of AD Objects</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Conversion and I/O of AD Objects"/>
7		<meta name="keywords" id="keywords" content=" convert from Ad "/>
	8	<meta name="keywords" id="keywords" content=" convert from Ad conversion and i/o of ad objects "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/correct_det_by_minor_c.xml less more

3	3	>
4	4	<head>
5	5	<title>Correctness Test of det_by_minor Routine</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Correctness Test of det_by_minor Routine"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" correctness test of det_by_minor routine syntax flag source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/cos.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD cos Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD cos Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" cos Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad cos function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/cosh.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD cosh Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD cosh Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" cosh Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad cosh function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-5

doc/cppad.xml less more

2	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
3	3	>
4	4	<head>
5		<title>cppad-20140000.3: A Package for Differentiation of C++ Algorithms</title>
6		<meta name="description" id="description" content="cppad-20140000.3: A Package for Differentiation of C++ Algorithms"/>
7		<meta name="keywords" id="keywords" content=" Ad algorithmic differentiation automatic C++ algorithm derivative Cppad version introduction include cppad.hpp symbol preprocessor namespace "/>
	5	<title>cppad-20150000.0: A Package for Differentiation of C++ Algorithms</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="cppad-20150000.0: A Package for Differentiation of C++ Algorithms"/>
	8	<meta name="keywords" id="keywords" content=" Ad algorithmic differentiation automatic C++ algorithm derivative Cppad version cppad-20150000.0: a package for of c++ algorithms syntax introduction example include file cppad.hpp preprocessor symbols symbol namespace "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

74	75
75	76
76	77
77		<center><b><big><big>cppad-20140000.3: A Package for Differentiation of C++ Algorithms</big></big></b></center>
	78	<center><b><big><big>cppad-20150000.0: A Package for Differentiation of C++ Algorithms</big></big></b></center>
78	79	<br/>
79	80	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
80	81

268	269	<b><big><a name="Contents" id="Contents">Contents</a></big></b>
269	270	<br/>
270	271	<table>
271		<tr><td><a href="_contents_xml.htm" target="_top">_contents</a></td><td>Table of Contents</td></tr><tr><td><a href="install.xml" target="_top">Install</a></td><td>CppAD Download, Test, and Install Instructions</td></tr><tr><td><a href="introduction.xml" target="_top">Introduction</a></td><td>An Introduction by Example to Algorithmic Differentiation</td></tr><tr><td><a href="ad.xml" target="_top">AD</a></td><td>AD Objects</td></tr><tr><td><a href="adfun.xml" target="_top">ADFun</a></td><td>ADFun Objects</td></tr><tr><td><a href="preprocessor.xml" target="_top">preprocessor</a></td><td>CppAD API Preprocessor Symbols</td></tr><tr><td><a href="multi_thread.xml" target="_top">multi_thread</a></td><td>Using CppAD in a Multi-Threading Environment</td></tr><tr><td><a href="library.xml" target="_top">library</a></td><td>The CppAD General Purpose Library</td></tr><tr><td><a href="ipopt_solve.xml" target="_top">ipopt_solve</a></td><td>Use Ipopt to Solve a Nonlinear Programming Problem</td></tr><tr><td><a href="example.xml" target="_top">Example</a></td><td>Examples</td></tr><tr><td><a href="speed.xml" target="_top">speed</a></td><td>AD Speed Test Routines</td></tr><tr><td><a href="appendix.xml" target="_top">Appendix</a></td><td>Appendix</td></tr><tr><td><a href="_reference.xml" target="_top">_reference</a></td><td>Alphabetic Listing of Cross Reference Tags</td></tr><tr><td><a href="_index.xml" target="_top">_index</a></td><td>Keyword Index</td></tr><tr><td><a href="_search_xml.htm" target="_top">_search</a></td><td>Search This Web Site</td></tr><tr><td><a href="_external.xml" target="_top">_external</a></td><td>External Internet References</td></tr></table>
	272	<tr><td><a href="_contents_xml.htm" target="_top">_contents</a></td><td>Table of Contents</td></tr><tr><td><a href="install.xml" target="_top">Install</a></td><td>CppAD Download, Test, and Install Instructions</td></tr><tr><td><a href="introduction.xml" target="_top">Introduction</a></td><td>An Introduction by Example to Algorithmic Differentiation</td></tr><tr><td><a href="ad.xml" target="_top">AD</a></td><td>AD Objects</td></tr><tr><td><a href="adfun.xml" target="_top">ADFun</a></td><td>ADFun Objects</td></tr><tr><td><a href="preprocessor.xml" target="_top">preprocessor</a></td><td>CppAD API Preprocessor Symbols</td></tr><tr><td><a href="multi_thread.xml" target="_top">multi_thread</a></td><td>Using CppAD in a Multi-Threading Environment</td></tr><tr><td><a href="library.xml" target="_top">library</a></td><td>The CppAD General Purpose Library</td></tr><tr><td><a href="ipopt_solve.xml" target="_top">ipopt_solve</a></td><td>Use Ipopt to Solve a Nonlinear Programming Problem</td></tr><tr><td><a href="example.xml" target="_top">Example</a></td><td>Examples</td></tr><tr><td><a href="speed.xml" target="_top">speed</a></td><td>Speed Test an Operator Overloading AD Package</td></tr><tr><td><a href="appendix.xml" target="_top">Appendix</a></td><td>Appendix</td></tr><tr><td><a href="_reference.xml" target="_top">_reference</a></td><td>Alphabetic Listing of Cross Reference Tags</td></tr><tr><td><a href="_index.xml" target="_top">_index</a></td><td>Keyword Index</td></tr><tr><td><a href="_search_xml.htm" target="_top">_search</a></td><td>Search This Web Site</td></tr><tr><td><a href="_external.xml" target="_top">_external</a></td><td>External Internet References</td></tr></table>
272	273	<hr/>Input File: doc.omh
273	274
274	275	</body>

-1

doc/cppad_assert.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Assertions During Execution</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Assertions During Execution"/>
7		<meta name="keywords" id="keywords" content=" assert error macro Ndebug Cppad_assert_known Cppad_assert_unknown "/>
	8	<meta name="keywords" id="keywords" content=" assert error macro cppad assertions during execution syntax purpose ndebug Ndebug restriction known Cppad_assert_known unknown Cppad_assert_unknown exp msg handler "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-15

doc/cppad_det_lu.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Speed: Gradient of Determinant Using Lu Factorization</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Speed: Gradient of Determinant Using Lu Factorization"/>
7		<meta name="keywords" id="keywords" content=" link_det_lu cppad speed lu matrix factor "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: gradient of determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

79	80	<option>cppad_poly.cpp</option>
80	81	<option>cppad_sparse_hessian.cpp</option>
81	82	<option>cppad_sparse_jacobian.cpp</option>
82		<option>cppad_print_optimize</option>
83	83	</select>
84	84	</td>
85	85	<td>cppad_det_lu.cpp</td>

109	109	# include <cppad/vector.hpp>
110	110	# include <cppad/speed/det_by_lu.hpp>
111	111	# include <cppad/speed/uniform_01.hpp>
112		# include "print_optimize.hpp"
	112
	113	// Note that CppAD uses global_memory at the main program level
	114	extern bool
	115	global_onetape, global_atomic, global_optimize;
113	116
114	117	bool link_det_lu(
115	118	size_t size ,

118	121	CppAD::vector<double> &gradient )
119	122	{
120	123	// speed test global option values
121		extern bool global_retape, global_atomic, global_optimize;
122		if( ! global_retape \|\| global_atomic )
	124	if( global_onetape \|\| global_atomic )
123	125	return false;
124	126
125	127	// -----------------------------------------------------

139	141	CppAD::vector<double> w(1);
140	142	w[0] = 1.;
141	143
142		// use the unspecified fact that size is non-decreasing between calls
143		static size_t previous_size = 0;
144		bool print = (repeat > 1) & (previous_size != size);
145		previous_size = size;
146
147
148	144	// ------------------------------------------------------
149	145	while(repeat--)
150	146	{ // get the next matrix

160	156
161	157	// create function object f : A -> detA
162	158	f.Dependent(A, detA);
163
164	159	if( global_optimize )
165		{ print_optimize(f, print, "cppad_det_lu_optimize", size);
166		print = false;
167		}
	160	f.optimize();
168	161
169	162	// evaluate and return gradient using reverse mode
170	163	f.<a href="forward.xml" target="_top">Forward</a>(0, matrix);

-16

doc/cppad_det_minor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Speed: Gradient of Determinant by Minor Expansion</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Speed: Gradient of Determinant by Minor Expansion"/>
7		<meta name="keywords" id="keywords" content=" link_det_minor cppad speed minor determinant "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: gradient of determinant by minor expansion link_det_minor speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

79	80	<option>cppad_poly.cpp</option>
80	81	<option>cppad_sparse_hessian.cpp</option>
81	82	<option>cppad_sparse_jacobian.cpp</option>
82		<option>cppad_print_optimize</option>
83	83	</select>
84	84	</td>
85	85	<td>cppad_det_minor.cpp</td>

106	106	# include <cppad/vector.hpp>
107	107	# include <cppad/speed/det_by_minor.hpp>
108	108	# include <cppad/speed/uniform_01.hpp>
109		# include "print_optimize.hpp"
	109
	110	// Note that CppAD uses global_memory at the main program level
	111	extern bool
	112	global_onetape, global_atomic, global_optimize;
110	113
111	114	bool link_det_minor(
112	115	size_t size ,

115	118	CppAD::vector<double> &gradient )
116	119	{
117	120	// speed test global option values
118		extern bool global_retape, global_atomic, global_optimize;
119	121	if( global_atomic )
120	122	return false;
121	123

140	142	// the AD function object
141	143	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
142	144
143		// use the unspecified fact that size is non-decreasing between calls
144		static size_t previous_size = 0;
145		bool print = (repeat > 1) & (previous_size != size);
146		previous_size = size;
147
148	145	// ---------------------------------------------------------------------
149		if( global_retape ) while(repeat--)
	146	if( ! global_onetape ) while(repeat--)
150	147	{
151	148	// choose a matrix
152	149	CppAD::uniform_01(n, matrix);

163	160	f.Dependent(A, detA);
164	161
165	162	if( global_optimize )
166		{ print_optimize(f, print, "cppad_det_minor_optimize", size);
167		print = false;
168		}
	163	f.optimize();
169	164
170	165	// evaluate the determinant at the new matrix value
171	166	f.<a href="forward.xml" target="_top">Forward</a>(0, matrix);

190	185	f.Dependent(A, detA);
191	186
192	187	if( global_optimize )
193		{ print_optimize(f, print, "cppad_det_minor_optimize", size);
194		print = false;
195		}
	188	f.optimize();
196	189
197	190	// ------------------------------------------------------
198	191	while(repeat--)

-1

doc/cppad_eigen.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Enable Use of Eigen Linear Algebra Package with CppAD</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Enable Use of Eigen Linear Algebra Package with CppAD"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" enable use of eigen linear algebra package with cppad syntax purpose example include files numtraits namespace "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/cppad_ipopt_nlp.xml less more

3	3	>
4	4	<head>
5	5	<title>Nonlinear Programming Using the CppAD Interface to Ipopt</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Nonlinear Programming Using the CppAD Interface to Ipopt"/>
7		<meta name="keywords" id="keywords" content=" nonlinear programming Cppad deprecated ipopt interface Ipopt Ad "/>
	8	<meta name="keywords" id="keywords" content=" nonlinear programming using the cppad interface to ipopt Cppad deprecated Ipopt Ad syntax purpose cppad_ipopt namespace ipopt_library_paths fg(x) index vector projection injection representation simple sizevector numbervector adnumber advector n m x_i x_l x_u g_l g_u fg_info fg_info.number_functions fg_info.eval_r fg_info.retape fg_info.domain_size fg_info.range_size fg_info.number_terms fg_info.index solution status x z_l z_u g lambda obj_value example wish list "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-18

doc/cppad_mat_mul.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Speed: Matrix Multiplication</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Speed: Matrix Multiplication"/>
7		<meta name="keywords" id="keywords" content=" link_mat_mul cppad speed matrix multiply "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: matrix multiplication link_mat_mul speed multiply specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

79	80	<option>cppad_poly.cpp</option>
80	81	<option>cppad_sparse_hessian.cpp</option>
81	82	<option>cppad_sparse_jacobian.cpp</option>
82		<option>cppad_print_optimize</option>
83	83	</select>
84	84	</td>
85	85	<td>cppad_mat_mul.cpp</td>

111	111	# include <cppad/speed/mat_sum_sq.hpp>
112	112	# include <cppad/speed/uniform_01.hpp>
113	113	# include <cppad/example/matrix_mul.hpp>
114		# include "print_optimize.hpp"
	114
	115	// Note that CppAD uses global_memory at the main program level
	116	extern bool
	117	global_onetape, global_atomic, global_optimize;
115	118
116	119	bool link_mat_mul(
117	120	size_t size ,

121	124	CppAD::vector<double>& dz
122	125	)
123	126	{
124		// speed test global option values
125		extern bool global_retape, global_atomic, global_optimize;
126
127	127	// -----------------------------------------------------
128	128	// setup
129	129	typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;

148	148	size_t nc_result = size;
149	149	matrix_mul atom_mul(nr_result, n_middle, nc_result);
150	150
151		// use the unspecified fact that size is non-decreasing between calls
152		static size_t previous_size = 0;
153		bool print = (repeat > 1) & (previous_size != size);
154		previous_size = size;
155
156	151	// ------------------------------------------------------
157		if( global_retape ) while(repeat--)
	152	if( ! global_onetape ) while(repeat--)
158	153	{ // get the next matrix
159	154	CppAD::uniform_01(n, x);
160	155	for( j = 0; j < n; j++)

181	176	f.Dependent(X, Z);
182	177
183	178	if( global_optimize )
184		{ print_optimize(f, print, "cppad_mat_mul_optimize", size);
185		print = false;
186		}
	179	f.optimize();
187	180
188	181	// evaluate and return gradient using reverse mode
189	182	z = f.<a href="forward.xml" target="_top">Forward</a>(0, x);

217	210	f.Dependent(X, Z);
218	211
219	212	if( global_optimize )
220		{ print_optimize(f, print, "cppad_mat_mul_optimize", size);
221		print = false;
222		}
	213	f.optimize();
223	214	while(repeat--)
224	215	{ // get a next matrix
225	216	CppAD::uniform_01(n, x);

+16

-22

doc/cppad_ode.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Speed: Gradient of Ode Solution</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Speed: Gradient of Ode Solution"/>
7		<meta name="keywords" id="keywords" content=" link_ode cppad speed ode "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: gradient of ode solution link_ode speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

79	80	<option>cppad_poly.cpp</option>
80	81	<option>cppad_sparse_hessian.cpp</option>
81	82	<option>cppad_sparse_jacobian.cpp</option>
82		<option>cppad_print_optimize</option>
83	83	</select>
84	84	</td>
85	85	<td>cppad_ode.cpp</td>

111	111	# include <cppad/speed/ode_evaluate.hpp>
112	112	# include <cppad/speed/uniform_01.hpp>
113	113	# include <cassert>
114		# include "print_optimize.hpp"
	114
	115	// Note that CppAD uses global_memory at the main program level
	116	extern bool
	117	global_onetape, global_atomic, global_optimize;
115	118
116	119	bool link_ode(
117	120	size_t size ,

120	123	CppAD::vector<double> &jacobian
121	124	)
122	125	{
	126	// speed test global option values
	127	if( global_atomic )
	128	return false;
	129
	130	// --------------------------------------------------------------------
	131	// setup
123	132	assert( x.size() == size );
124	133	assert( jacobian.size() == size * size );
125	134
126		// speed test global option values
127		extern bool global_retape, global_atomic, global_optimize;
128		if( global_atomic )
129		return false;
130
131		// -------------------------------------------------------------
132		// setup
133	135	typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
134	136	typedef CppAD::vector<ADScalar> ADVector;
135	137

140	142	ADVector X(n), Y(m); // independent and dependent variables
141	143	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function
142	144
143		// use the unspecified fact that size is non-decreasing between calls
144		static size_t previous_size = 0;
145		bool print = (repeat > 1) & (previous_size != size);
146		previous_size = size;
147
148	145	// -------------------------------------------------------------
149		if( global_retape) while(repeat--)
	146	if( ! global_onetape ) while(repeat--)
150	147	{ // choose next x value
151	148	uniform_01(n, x);
152	149	for(j = 0; j < n; j++)

162	159	f.Dependent(X, Y);
163	160
164	161	if( global_optimize )
165		{ print_optimize(f, print, "cppad_ode_optimize", size);
166		print = false;
167		}
	162	f.optimize();
	163
168	164	jacobian = f.<a href="jacobian.xml" target="_top">Jacobian</a>(x);
169	165	}
170	166	else

183	179	f.Dependent(X, Y);
184	180
185	181	if( global_optimize )
186		{ print_optimize(f, print, "cppad_ode_optimize", size);
187		print = false;
188		}
	182	f.optimize();
189	183	while(repeat--)
190	184	{ // get next argument value
191	185	uniform_01(n, x);

+10

-18

doc/cppad_poly.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Speed: Second Derivative of a Polynomial</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Speed: Second Derivative of a Polynomial"/>
7		<meta name="keywords" id="keywords" content=" link_poly cppad speed polynomial "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: second derivative of a polynomial link_poly speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

79	80	<option>cppad_poly.cpp</option>
80	81	<option>cppad_sparse_hessian.cpp</option>
81	82	<option>cppad_sparse_jacobian.cpp</option>
82		<option>cppad_print_optimize</option>
83	83	</select>
84	84	</td>
85	85	<td>cppad_poly.cpp</td>

109	109	<code><font color='blue'><pre style='display:inline'>
110	110	# include <cppad/cppad.hpp>
111	111	# include <cppad/speed/uniform_01.hpp>
112		# include "print_optimize.hpp"
	112
	113	// Note that CppAD uses global_memory at the main program level
	114	extern bool
	115	global_onetape, global_atomic, global_optimize;
113	116
114	117	bool link_poly(
115	118	size_t size ,

119	122	CppAD::vector<double> &ddp ) // second derivative w.r.t z
120	123	{
121	124	// speed test global option values
122		extern bool global_retape, global_atomic, global_optimize;
123	125	if( global_atomic )
124	126	return false;
125	127

150	152	// AD function object
151	153	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
152	154
153		// use the unspecified fact that size is non-decreasing between calls
154		static size_t previous_size = 0;
155		bool print = (repeat > 1) & (previous_size != size);
156		previous_size = size;
157
158	155	// --------------------------------------------------------------------
159		if( global_retape ) while(repeat--)
	156	if( ! global_onetape ) while(repeat--)
160	157	{
161	158	// choose an argument value
162	159	CppAD::uniform_01(1, z);

172	169	f.Dependent(Z, P);
173	170
174	171	if( global_optimize )
175		{ print_optimize(f, print, "cppad_poly_optimize", size);
176		print = false;
177		}
	172	f.optimize();
178	173
179	174	// pre-allocate memory for three forward mode calculations
180		f.capacity_taylor(3);
	175	f.capacity_order(3);
181	176
182	177	// evaluate the polynomial
183	178	p = f.<a href="forward.xml" target="_top">Forward</a>(0, z);

204	199	// create function object f : A -> detA
205	200	f.Dependent(Z, P);
206	201
207		extern bool global_optimize;
208	202	if( global_optimize )
209		{ print_optimize(f, print, "cppad_poly_optimize", size);
210		print = false;
211		}
	203	f.optimize();
212	204
213	205	while(repeat--)
214	206	{ // sufficient memory is allocated by second repetition

-193

~~doc/cppad_print_optimize.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>Speed Test Utility: Optimize Operation Sequences and Print Results</title>
6		<meta name="description" id="description" content="Speed Test Utility: Optimize Operation Sequences and Print Results"/>
7		<meta name="keywords" id="keywords" content=" print_optimize cppad speed test optimize print "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_cppad_print_optimize_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td><a href="cppad_sparse_jacobian.cpp.xml" target="_top">Prev</a>
24		</td><td><a href="speed_fadbad.xml" target="_top">Next</a>
25		</td><td>
26		<select onchange='choose_across0(this)'>
27		<option>Index-></option>
28		<option>contents</option>
29		<option>reference</option>
30		<option>index</option>
31		<option>search</option>
32		<option>external</option>
33		</select>
34		</td>
35		<td>
36		<select onchange='choose_up0(this)'>
37		<option>Up-></option>
38		<option>CppAD</option>
39		<option>speed</option>
40		<option>speed_cppad</option>
41		<option>cppad_print_optimize</option>
42		</select>
43		</td>
44		<td>
45		<select onchange='choose_down3(this)'>
46		<option>CppAD-></option>
47		<option>Install</option>
48		<option>Introduction</option>
49		<option>AD</option>
50		<option>ADFun</option>
51		<option>preprocessor</option>
52		<option>multi_thread</option>
53		<option>library</option>
54		<option>ipopt_solve</option>
55		<option>Example</option>
56		<option>speed</option>
57		<option>Appendix</option>
58		</select>
59		</td>
60		<td>
61		<select onchange='choose_down2(this)'>
62		<option>speed-></option>
63		<option>speed_main</option>
64		<option>speed_utility</option>
65		<option>speed_double</option>
66		<option>speed_adolc</option>
67		<option>speed_cppad</option>
68		<option>speed_fadbad</option>
69		<option>speed_sacado</option>
70		</select>
71		</td>
72		<td>
73		<select onchange='choose_down1(this)'>
74		<option>speed_cppad-></option>
75		<option>cppad_det_minor.cpp</option>
76		<option>cppad_det_lu.cpp</option>
77		<option>cppad_mat_mul.cpp</option>
78		<option>cppad_ode.cpp</option>
79		<option>cppad_poly.cpp</option>
80		<option>cppad_sparse_hessian.cpp</option>
81		<option>cppad_sparse_jacobian.cpp</option>
82		<option>cppad_print_optimize</option>
83		</select>
84		</td>
85		<td>cppad_print_optimize</td>
86		<td>
87		<select onchange='choose_current0(this)'>
88		<option>Headings-></option>
89		<option>Syntax</option>
90		<option>Purpose</option>
91		<option>f</option>
92		<option>print</option>
93		<option>label</option>
94		<option>test_id</option>
95		</select>
96		</td>
97		</tr></table><br/>
98
99
100
101		<center><b><big><big>Speed Test Utility: Optimize Operation Sequences and Print Results</big></big></b></center>
102		<br/>
103		<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
104
105		<br/>
106
107		<code><font color="blue"><span style='white-space: nowrap'>print_optimize(</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>print</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>label</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>test_id</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
108
109
110		<br/>
111		<br/>
112		<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
113		<br/>
114		This routine <a href="optimize.xml" target="_top"><span style='white-space: nowrap'>optimizes</span></a>
115		the operation sequences
116		and prints the results of the optimization.
117		It is used by the CppAD speed tests when the
118		<a href="speed_main.xml#option_list.optimize" target="_top"><span style='white-space: nowrap'>optimize</span></a>
119		option is true.
120		This helps when improving optimization of operation sequences.
121
122		<br/>
123		<br/>
124		<b><big><a name="f" id="f">f</a></big></b>
125		<br/>
126		The argument
127		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
128		has prototype
129
130		<code><font color="blue"><span style='white-space: nowrap'><br/>
131		ADFun<double>& </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
132		</span></font></code>
133		It contains the operation sequences that is
134		<a href="optimize.xml" target="_top"><span style='white-space: nowrap'>optimized</span></a>
135		.
136
137		<br/>
138		<br/>
139		<b><big><a name="print" id="print">print</a></big></b>
140		<br/>
141		The argument
142		<code><i><font color="black"><span style='white-space: nowrap'>print</span></font></i></code>
143		has prototype
144
145		<code><font color="blue"><span style='white-space: nowrap'><br/>
146		bool </span></font><i><font color="black"><span style='white-space: nowrap'>print</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
147		</span></font></code>
148		If it is true, the following values are printed on <code><font color="blue">std::cout</font></code>:
149
150		<code><font color="blue"><span style='white-space: nowrap'><br/>
151		</span></font><i><font color="black"><span style='white-space: nowrap'>label</span></font></i><font color="blue"><span style='white-space: nowrap'> = [ </span></font><i><font color="black"><span style='white-space: nowrap'>test_id</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>size_before</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>size_after</span></font></i><font color="blue"><span style='white-space: nowrap'> ]<br/>
152		</span></font></code>
153		Where
154		<code><i><font color="black"><span style='white-space: nowrap'>size_before</span></font></i></code>
155		and
156		<code><i><font color="black"><span style='white-space: nowrap'>size_after</span></font></i></code>
157		are the value
158		corresponding to
159		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_var()</span></font></code>
160		before and after the optimization.
161
162		<br/>
163		<br/>
164		<b><big><a name="label" id="label">label</a></big></b>
165		<br/>
166		The argument
167		<code><i><font color="black"><span style='white-space: nowrap'>label</span></font></i></code>
168		has prototype
169
170		<code><font color="blue"><span style='white-space: nowrap'><br/>
171		const char* </span></font><i><font color="black"><span style='white-space: nowrap'>label</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
172		</span></font></code>
173		It is the label that is used when printing the optimization results.
174
175		<br/>
176		<br/>
177		<b><big><a name="test_id" id="test_id">test_id</a></big></b>
178		<br/>
179		The argument
180		<code><i><font color="black"><span style='white-space: nowrap'>test_id</span></font></i></code>
181		has prototype
182
183		<code><font color="blue"><span style='white-space: nowrap'><br/>
184		size_t </span></font><i><font color="black"><span style='white-space: nowrap'>test_id</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
185		</span></font></code>
186		and is an identifier for this speed test.
187
188
189		<hr/>Input File: speed/cppad/print_optimize.cpp
190
191		</body>
192		</html>

+33

-33

doc/cppad_sparse_hessian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Speed: Sparse Hessian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Speed: Sparse Hessian"/>
7		<meta name="keywords" id="keywords" content=" link_sparse_hessian cppad speed sparse hessian "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: sparse hessian link_sparse_hessian speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

79	80	<option>cppad_poly.cpp</option>
80	81	<option>cppad_sparse_hessian.cpp</option>
81	82	<option>cppad_sparse_jacobian.cpp</option>
82		<option>cppad_print_optimize</option>
83	83	</select>
84	84	</td>
85	85	<td>cppad_sparse_hessian.cpp</td>

110	110	# include <cppad/cppad.hpp>
111	111	# include <cppad/speed/uniform_01.hpp>
112	112	# include <cppad/speed/sparse_hes_fun.hpp>
113		# include "print_optimize.hpp"
114
115		// determines if we are using bool or set sparsity patterns
116		# define USE_SET_SPARSITY 1
	113
	114	// Note that CppAD uses global_memory at the main program level
	115	extern bool
	116	global_onetape, global_colpack,
	117	global_atomic, global_optimize, global_boolsparsity;
117	118
118	119	namespace {
119	120	using CppAD::vector;

158	159	bool link_sparse_hessian(
159	160	size_t size ,
160	161	size_t repeat ,
161		CppAD::vector<double>& x ,
162	162	const CppAD::vector<size_t>& row ,
163	163	const CppAD::vector<size_t>& col ,
164		CppAD::vector<double>& hessian )
	164	CppAD::vector<double>& x ,
	165	CppAD::vector<double>& hessian )
165	166	{
	167	if( global_atomic \|\| global_colpack )
	168	return false;
166	169	// -----------------------------------------------------
167	170	// setup
168	171	typedef vector<double> DblVector;

184	187	// weights for hessian calculation (only one component of f)
185	188	w[0] = 1.;
186	189
187		// use the unspecified fact that size is non-decreasing between calls
188		static size_t previous_size = 0;
189		bool print = (repeat > 1) & (previous_size != size);
190		previous_size = size;
191
192	190	// declare sparsity pattern
193		# if USE_SET_SPARSITY
194		SetVector sparsity(n);
195		# else
196		typedef vector<bool> BoolVector;
197		BoolVector sparsity(n * n);
198		# endif
	191	SetVector set_sparsity(n);
	192	BoolVector bool_sparsity(n * n);
	193
199	194	// initialize all entries as zero
200	195	for(i = 0; i < n; i++)
201	196	{ for(j = 0; j < n; j++)
202	197	hessian[ i * n + j] = 0.;
203	198	}
204	199	// ------------------------------------------------------
205		extern bool global_retape;
206		if( global_retape) while(repeat--)
	200	if( ! global_onetape ) while(repeat--)
207	201	{ // choose a value for x
208	202	CppAD::uniform_01(n, x);
209	203	for(j = 0; j < n; j++)

218	212	// create function object f : X -> Y
219	213	f.Dependent(a_x, a_y);
220	214
221		extern bool global_optimize;
222	215	if( global_optimize )
223		{ print_optimize(f, print, "cppad_sparse_hessian_optimize", size);
224		print = false;
225		}
	216	f.optimize();
226	217
227	218	// calculate the Hessian sparsity pattern for this function
228		calc_sparsity(sparsity, f);
	219	if( global_boolsparsity )
	220	calc_sparsity(bool_sparsity, f);
	221	else
	222	calc_sparsity(set_sparsity, f);
229	223
230	224	// structure that holds some of work done by SparseHessian
231	225	CppAD::sparse_hessian_work work;
232	226
233	227	// calculate this Hessian at this x
234		f.SparseHessian(x, w, sparsity, row, col, hes, work);
	228	if( global_boolsparsity)
	229	f.SparseHessian(x, w, bool_sparsity, row, col, hes, work);
	230	else
	231	f.SparseHessian(x, w, set_sparsity, row, col, hes, work);
235	232	for(k = 0; k < K; k++)
236	233	{ hessian[ row[k] * n + col[k] ] = hes[k];
237	234	hessian[ col[k] * n + row[k] ] = hes[k];

252	249	// create function object f : X -> Y
253	250	f.Dependent(a_x, a_y);
254	251
255		extern bool global_optimize;
256	252	if( global_optimize )
257		{ print_optimize(f, print, "cppad_sparse_hessian_optimize", size);
258		print = false;
259		}
	253	f.optimize();
260	254
261	255	// calculate the Hessian sparsity pattern for this function
262		calc_sparsity(sparsity, f);
	256	if( global_boolsparsity)
	257	calc_sparsity(bool_sparsity, f);
	258	else
	259	calc_sparsity(set_sparsity, f);
263	260
264	261	// declare structure that holds some of work done by SparseHessian
265	262	CppAD::sparse_hessian_work work;

269	266	CppAD::uniform_01(n, x);
270	267
271	268	// calculate sparsity at this x
272		f.SparseHessian(x, w, sparsity, row, col, hes, work);
	269	if( global_boolsparsity )
	270	f.SparseHessian(x, w, bool_sparsity, row, col, hes, work);
	271	else
	272	f.SparseHessian(x, w, set_sparsity, row, col, hes, work);
273	273
274	274	for(k = 0; k < K; k++)
275	275	{ hessian[ row[k] * n + col[k] ] = hes[k];

+56

-40

doc/cppad_sparse_jacobian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Speed: Sparse Jacobian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Speed: Sparse Jacobian"/>
7		<meta name="keywords" id="keywords" content=" link_sparse_jacobian cppad speed sparse jacobian "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: sparse jacobian link_sparse_jacobian speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="cppad_sparse_hessian.cpp.xml" target="_top">Prev</a>
24		</td><td><a href="cppad_print_optimize.xml" target="_top">Next</a>
	25	</td><td><a href="speed_fadbad.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

79	80	<option>cppad_poly.cpp</option>
80	81	<option>cppad_sparse_hessian.cpp</option>
81	82	<option>cppad_sparse_jacobian.cpp</option>
82		<option>cppad_print_optimize</option>
83	83	</select>
84	84	</td>
85	85	<td>cppad_sparse_jacobian.cpp</td>

110	110	# include <cppad/cppad.hpp>
111	111	# include <cppad/speed/uniform_01.hpp>
112	112	# include <cppad/speed/sparse_jac_fun.hpp>
113		# include "print_optimize.hpp"
114
115		// determines if we are using bool or set sparsity patterns
116		# define USE_SET_SPARSITY 1
	113
	114	// Note that CppAD uses global_memory at the main program level
	115	extern bool
	116	global_onetape, global_colpack,
	117	global_atomic, global_optimize, global_boolsparsity;
117	118
118	119	namespace {
119	120	using CppAD::vector;

142	143	}
143	144
144	145	bool link_sparse_jacobian(
145		size_t size ,
146		size_t repeat ,
147		size_t m ,
148		CppAD::vector<double> &x ,
149		CppAD::vector<size_t> &row ,
150		CppAD::vector<size_t> &col ,
151		CppAD::vector<double> &jacobian )
	146	size_t size ,
	147	size_t repeat ,
	148	size_t m ,
	149	const CppAD::vector<size_t>& row ,
	150	const CppAD::vector<size_t>& col ,
	151	CppAD::vector<double>& x ,
	152	CppAD::vector<double>& jacobian ,
	153	size_t& n_sweep )
152	154	{
	155	if( global_atomic )
	156	return false;
	157	# ifndef CPPAD_COLPACK_SPEED
	158	if( global_colpack )
	159	return false;
	160	# endif
153	161	// -----------------------------------------------------
154	162	// setup
155	163	typedef vector< std::set<size_t> > SetVector;

166	174	DblVector jac(K); // non-zeros in Jacobian
167	175	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function object
168	176
169		// use the unspecified fact that size is non-decreasing between calls
170		static size_t previous_size = 0;
171		bool print = (repeat > 1) & (previous_size != size);
172		previous_size = size;
173
174	177	// declare sparsity pattern
175		# if USE_SET_SPARSITY
176		SetVector sparsity(m);
177		# else
178		typedef vector<bool> BoolVector;
179		BoolVector sparsity(m * n);
180		# endif
	178	SetVector set_sparsity(m);
	179	BoolVector bool_sparsity(m * n);
	180
181	181	// initialize all entries as zero
182	182	for(i = 0; i < m; i++)
183	183	{ for(j = 0; j < n; j++)
184	184	jacobian[ i * n + j ] = 0.;
185	185	}
186	186	// ------------------------------------------------------
187		extern bool global_retape;
188		if( global_retape ) while(repeat--)
	187	if( ! global_onetape ) while(repeat--)
189	188	{ // choose a value for x
190	189	CppAD::uniform_01(n, x);
191	190	for(k = 0; k < n; k++)

200	199	// create function object f : X -> Y
201	200	f.Dependent(a_x, a_y);
202	201
203		extern bool global_optimize;
204	202	if( global_optimize )
205		{ print_optimize(f, print, "cppad_sparse_jacobian_optimize", size);
206		print = false;
207		}
	203	f.optimize();
208	204
209	205	// calculate the Jacobian sparsity pattern for this function
210		calc_sparsity(sparsity, f);
	206	if( global_boolsparsity )
	207	calc_sparsity(bool_sparsity, f);
	208	else
	209	calc_sparsity(set_sparsity, f);
211	210
212	211	// structure that holds some of the work done by SparseJacobian
213	212	CppAD::sparse_jacobian_work work;
214
	213	# ifdef CPPAD_COLPACK_SPEED
	214	if( global_colpack )
	215	work.color_method = "colpack";
	216	# endif
215	217	// calculate the Jacobian at this x
216	218	// (use forward mode because m > n ?)
217		f.SparseJacobianForward(x, sparsity, row, col, jac, work);
	219	if( global_boolsparsity) n_sweep = f.SparseJacobianForward(
	220	x, bool_sparsity, row, col, jac, work
	221	);
	222	else n_sweep = f.SparseJacobianForward(
	223	x, set_sparsity, row, col, jac, work
	224	);
218	225	for(k = 0; k < K; k++)
219	226	jacobian[ row[k] * n + col[k] ] = jac[k];
220	227	}

233	240	// create function object f : X -> Y
234	241	f.Dependent(a_x, a_y);
235	242
236		extern bool global_optimize;
237	243	if( global_optimize )
238		{ print_optimize(f, print, "cppad_sparse_jacobian_optimize", size);
239		print = false;
240		}
	244	f.optimize();
241	245
242	246	// calculate the Jacobian sparsity pattern for this function
243		calc_sparsity(sparsity, f);
	247	if( global_boolsparsity )
	248	calc_sparsity(bool_sparsity, f);
	249	else
	250	calc_sparsity(set_sparsity, f);
244	251
245	252	// structure that holds some of the work done by SparseJacobian
246	253	CppAD::sparse_jacobian_work work;
	254	# ifdef CPPAD_COLPACK_SPEED
	255	if( global_colpack )
	256	work.color_method = "colpack";
	257	# endif
247	258
248	259	while(repeat--)
249	260	{ // choose a value for x

251	262
252	263	// calculate the Jacobian at this x
253	264	// (use forward mode because m > n ?)
254		f.SparseJacobianForward(x, sparsity, row, col, jac, work);
	265	if( global_boolsparsity ) n_sweep = f.SparseJacobianForward(
	266	x, bool_sparsity, row, col, jac, work
	267	);
	268	else n_sweep = f.SparseJacobianForward(
	269	x, set_sparsity, row, col, jac, work
	270	);
255	271	for(k = 0; k < K; k++)
256	272	jacobian[ row[k] * n + col[k] ] = jac[k];
257	273	}

-178

~~doc/cppad_test.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>Running the CppAD Examples and Tests</title>
6		<meta name="description" id="description" content="Running the CppAD Examples and Tests"/>
7		<meta name="keywords" id="keywords" content=" "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_cppad_test_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td><a href="cppad_testvector.xml" target="_top">Prev</a>
24		</td><td><a href="pkgconfig.xml" target="_top">Next</a>
25		</td><td>
26		<select onchange='choose_across0(this)'>
27		<option>Index-></option>
28		<option>contents</option>
29		<option>reference</option>
30		<option>index</option>
31		<option>search</option>
32		<option>external</option>
33		</select>
34		</td>
35		<td>
36		<select onchange='choose_up0(this)'>
37		<option>Up-></option>
38		<option>CppAD</option>
39		<option>Install</option>
40		<option>cppad_test</option>
41		</select>
42		</td>
43		<td>
44		<select onchange='choose_down2(this)'>
45		<option>CppAD-></option>
46		<option>Install</option>
47		<option>Introduction</option>
48		<option>AD</option>
49		<option>ADFun</option>
50		<option>preprocessor</option>
51		<option>multi_thread</option>
52		<option>library</option>
53		<option>ipopt_solve</option>
54		<option>Example</option>
55		<option>speed</option>
56		<option>Appendix</option>
57		</select>
58		</td>
59		<td>
60		<select onchange='choose_down1(this)'>
61		<option>Install-></option>
62		<option>download</option>
63		<option>cmake</option>
64		<option>cppad_test</option>
65		<option>pkgconfig</option>
66		<option>InstallUnix</option>
67		</select>
68		</td>
69		<td>cppad_test</td>
70		<td>
71		<select onchange='choose_current0(this)'>
72		<option>Headings-></option>
73		<option>Purpose</option>
74		<option>Run All</option>
75		<option>Subsets</option>
76		</select>
77		</td>
78		</tr></table><br/>
79
80
81
82		<center><b><big><big>Running the CppAD Examples and Tests</big></big></b></center>
83		<br/>
84		<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
85		<br/>
86		After you configure your system with the
87		<a href="cmake.xml#CMake Command" target="_top"><span style='white-space: nowrap'>cmake command</span></a>
88		you
89		can run the CppAD example and tests to make sure that
90		CppAD functions properly on your system.
91
92
93		<br/>
94		<br/>
95		<b><big><a name="Run All" id="Run All">Run All</a></big></b>
96		<br/>
97		In the <code><font color="blue">build</font></code> subdirectory of the
98		<a href="download.xml#Distribution Directory" target="_top"><span style='white-space: nowrap'>distribution directory</span></a>
99
100		execute the command
101		<code><font color='blue'><pre style='display:inline'>
102		make check
103		</pre></font></code>
104
105		This will build and run all of the tests that are support
106		by your system and the <a href="cmake.xml" target="_top"><span style='white-space: nowrap'>cmake</span></a>
107		command options.
108		If you created <code><font color="blue">nmake</font></code> makefiles, you will have
109		to use <code><font color="blue">nmake</font></code> instead of <code><font color="blue">make</font></code> in the command above; see
110		the <a href="cmake.xml#generator" target="_top"><span style='white-space: nowrap'>generator</span></a>
111		option for the <code><font color="blue">cmake</font></code> command.
112
113		<br/>
114		<br/>
115		<b><big><a name="Subsets" id="Subsets">Subsets</a></big></b>
116		<br/>
117		It is possible to build and run the following subsets of the
118		examples and tests:
119		<table><tr><td align='left' valign='top'>
120
121		Command </td><td align='left' valign='top'>
122
123		Description
124		</td></tr><tr><td align='left' valign='top'>
125
126		<code><font color="blue">make check_compare_c</font></code> </td><td align='left' valign='top'>
127
128		<a href="compare_c.xml" target="_top">Compare Speed of C and C++</a>
129		</td></tr><tr><td align='left' valign='top'>
130
131		<code><font color="blue">make check_example</font></code> </td><td align='left' valign='top'>
132
133		most of the <a href="example.xml" target="_top"><span style='white-space: nowrap'>Example</span></a>
134		programs
135		</td></tr><tr><td align='left' valign='top'>
136
137		<code><font color="blue">make check_introduction</font></code> </td><td align='left' valign='top'>
138
139		the programs in the <a href="introduction.xml" target="_top"><span style='white-space: nowrap'>Introduction</span></a>
140
141		</td></tr><tr><td align='left' valign='top'>
142
143		<code><font color="blue">make check_print_for</font></code> </td><td align='left' valign='top'>
144
145		the print_for command
146		</td></tr><tr><td align='left' valign='top'>
147
148		<code><font color="blue">make check_test_more</font></code> </td><td align='left' valign='top'>
149
150		correctness tests that are not examples
151		</td></tr><tr><td align='left' valign='top'>
152
153		<code><font color="blue">make check_multi_thread</font></code> </td><td align='left' valign='top'>
154
155		<a href="multi_thread.xml" target="_top"><span style='white-space: nowrap'>multi_thread</span></a>
156		tests (run correctness only)
157		</td></tr><tr><td align='left' valign='top'>
158
159		<code><font color="blue">make check_speed</font></code> </td><td align='left' valign='top'>
160
161		single threading <a href="speed.xml" target="_top"><span style='white-space: nowrap'>speed</span></a>
162		tests (run correctness only)
163		</td></tr><tr><td align='left' valign='top'>
164
165		<code><font color="blue">make check_ipopt_nlp</font></code> </td><td align='left' valign='top'>
166
167		the <a href="cppad_ipopt_nlp.xml" target="_top"><span style='white-space: nowrap'>cppad_ipopt_nlp</span></a>
168		speed and correctness tests
169		</td></tr><tr><td align='left' valign='top'>
170
171		</td></tr>
172		</table>
173
174		<hr/>Input File: omh/install/cppad_test.omh
175
176		</body>
177		</html>

-3

doc/cppad_testvector.xml less more

3	3	>
4	4	<head>
5	5	<title>Choosing the CppAD Test Vector Template Class</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Choosing the CppAD Test Vector Template Class"/>
7		<meta name="keywords" id="keywords" content=" cppad test vector cppad_testvector boost eigen "/>
	8	<meta name="keywords" id="keywords" content=" choosing the cppad test vector template class purpose cppad_testvector boost eigen "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="get_sacado.sh.xml" target="_top">Prev</a>
24		</td><td><a href="cppad_test.xml" target="_top">Next</a>
	25	</td><td><a href="cmake_check.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

62	63	<option>Install-></option>
63	64	<option>download</option>
64	65	<option>cmake</option>
65		<option>cppad_test</option>
	66	<option>cmake_check</option>
66	67	<option>pkgconfig</option>
67	68	<option>InstallUnix</option>
68	69	</select>

71	72	<select onchange='choose_down1(this)'>
72	73	<option>cmake-></option>
73	74	<option>adolc_prefix</option>
	75	<option>colpack_prefix</option>
74	76	<option>eigen_prefix</option>
75	77	<option>fadbad_prefix</option>
76	78	<option>ipopt_prefix</option>

+13

-3

doc/cppad_vector.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD::vector Template Class: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD::vector Template Class: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" vector Cppad Cppad::vector example test "/>
	8	<meta name="keywords" id="keywords" content=" cppad::vector template class: example and test vector Cppad Cppad::vector "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

168	169	for(i = 0; i < N; i++)
169	170	ok &= ( x[i] == Type(i) );
170	171
	172	// test of data
	173	Type* data = x.data();
	174	for(i = 0; i < N; i++)
	175	{ ok &= data[i] == Type(i);
	176	data[i] = Type(N - i);
	177	ok &= x[i] == Type(N - i);
	178	}
	179
171	180	// test of push_vector
172	181	x.push_vector(x);
173	182	ok &= (x.size() == 2 * N);
174	183	for(i = 0; i < N; i++)
175		{ ok &= ( x[i] == Type(i) );
176		ok &= ( x[i+N] == Type(i) );
	184	{ ok &= x[i] == Type(N - i);
	185	ok &= x[i+N] == Type(N - i);
177	186	}
	187
178	188
179	189	return ok;
180	190	}

+70

-2

doc/cppad_vector.xml less more

3	3	>
4	4	<head>
5	5	<title>The CppAD::vector Template Class</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The CppAD::vector Template Class"/>
7		<meta name="keywords" id="keywords" content=" vector Cppad template class assignment [] push_back push_vector push vectorbool thread_alloc exercise Cppad::vector "/>
	8	<meta name="keywords" id="keywords" content=" vector Cppad template class the cppad::vector syntax description include capacity assignment check size return reference move semantics element access [] push_back push_vector push output resize clear data vectorbool memory type and parallel mode thread_alloc example exercise Cppad::vector "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

104	105	<option>Assignment</option>
105	106	<option>---..Check Size</option>
106	107	<option>---..Return Reference</option>
	108	<option>---..Move Semantics</option>
107	109	<option>Element Access</option>
108	110	<option>push_back</option>
109	111	<option>push_vector</option>
110	112	<option>Output</option>
111	113	<option>resize</option>
112	114	<option>clear</option>
	115	<option>data</option>
113	116	<option>vectorBool</option>
114	117	<option>---..Memory</option>
	118	<option>---..data</option>
115	119	<option>---..Output</option>
116	120	<option>---..Element Type</option>
117	121	<option>Memory and Parallel Mode</option>

236	240	</span></font><i><font color="black"><span style='white-space: nowrap'>z</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
237	241	</span></font></code>
238	242	<br/>
	243	<b><a name="Assignment.Move Semantics" id="Assignment.Move Semantics">Move Semantics</a></b>
	244	<br/>
	245	If the C++ compiler supports move semantic rvalues using the <code><font color="blue">&&</font></code>
	246	syntax, then it will be used during the vector assignment statement.
	247	This means that return values and other temporaries are not be copied,
	248	but rather pointers are transferred.
	249
	250	<br/>
	251	<br/>
239	252	<b><big><a name="Element Access" id="Element Access">Element Access</a></big></b>
240	253
241	254

313	326	<code><i><font color="black"><span style='white-space: nowrap'>Scalar</span></font></i></code>
314	327	assignment operator).
315	328
316
317	329	<br/>
318	330	<br/>
319	331	<b><big><a name="push_vector" id="push_vector">push_vector</a></big></b>

436	448
437	449	<br/>
438	450	<br/>
	451	<b><big><a name="data" id="data">data</a></big></b>
	452
	453
	454	<br/>
	455	If
	456	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
	457	is a
	458	<code><font color="blue"><span style='white-space: nowrap'>CppAD::vector<</span></font><i><font color="black"><span style='white-space: nowrap'>Scalar</span></font></i><font color="blue"><span style='white-space: nowrap'>></span></font></code>
	459	object
	460
	461	<code><font color="blue"><span style='white-space: nowrap'><br/>
	462	</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>.data()<br/>
	463	</span></font></code>
	464	returns a pointer to a
	465	<code><i><font color="black"><span style='white-space: nowrap'>Scalar</span></font></i></code>
	466	object such that for
	467
	468	<code><font color="blue"><span style='white-space: nowrap'>0 <= </span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'> < </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>.size()</span></font></code>
	469	,
	470
	471	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'>]</span></font></code>
	472	and
	473	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>.data()[</span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'>]</span></font></code>
	474
	475	are the same
	476	<code><i><font color="black"><span style='white-space: nowrap'>Scalar</span></font></i></code>
	477	object.
	478	If
	479	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
	480	is <code><font color="blue">const</font></code>, the pointer is <code><font color="blue">const</font></code>.
	481	If
	482	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity()</span></font></code>
	483	is zero, the value of the pointer is not defined.
	484	The pointer may no longer be valid after the following operations on
	485
	486	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
	487	:
	488	its destructor,
	489	<code><font color="blue">clear</font></code>,
	490	<code><font color="blue">resize</font></code>,
	491	<code><font color="blue">push_back</font></code>,
	492	<code><font color="blue">push_vector</font></code>,
	493	assignment to another vector when original size of
	494	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
	495	is zero.
	496
	497	<br/>
	498	<br/>
439	499	<b><big><a name="vectorBool" id="vectorBool">vectorBool</a></big></b>
440	500
441	501	<br/>

451	511	The class <code><font color="blue">vectorBool</font></code> conserves on memory
452	512	(on the other hand, <code><font color="blue">CppAD::vector<bool></font></code> is expected to be faster
453	513	than <code><font color="blue">vectorBool</font></code>).
	514
	515	<br/>
	516	<br/>
	517	<b><a name="vectorBool.data" id="vectorBool.data">data</a></b>
	518	<br/>
	519	The <a href="cppad_vector.xml#data" target="_top"><span style='white-space: nowrap'>data</span></a>
	520	function is not supported by
	521	<code><font color="blue">vectorBool</font></code>.
454	522
455	523	<br/>
456	524	<br/>

-4

doc/dependent.xml less more

3	3	>
4	4	<head>
5	5	<title>Stop Recording and Store Operation Sequence</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Stop Recording and Store Operation Sequence"/>
7		<meta name="keywords" id="keywords" content=" Adfun operation sequence store recording stop tape Dependent parallel "/>
	8	<meta name="keywords" id="keywords" content=" stop recording and store operation sequence Adfun tape Dependent syntax purpose f x y advector taping forward parallel mode example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

270	271	Thus, directly after this operation,
271	272
272	273	<code><font color="blue"><span style='white-space: nowrap'><br/>
273		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()<br/>
274		</span></font></code>
275		is zero (see <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	274	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()<br/>
	275	</span></font></code>
	276	is zero (see <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
276	277	).
277	278
278	279	<br/>

-2

doc/deprecated.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Deprecated API Features</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Deprecated API Features"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" cppad deprecated api features "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

117	118	<a href="installunix.xml" target="_top"><span style='white-space: nowrap'>InstallUnix</span></a>
118	119	</td><td align='left' valign='top'>
119	120
120		Unix Test and Installation
	121	Deprecated Unix Test and Installation
121	122	</td></tr>
122	123	</table>
123	124

-1

doc/det_33.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: det_33</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: det_33"/>
7		<meta name="keywords" id="keywords" content=" det_33 source "/>
	8	<meta name="keywords" id="keywords" content=" source: det_33 source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/det_33.xml less more

3	3	>
4	4	<head>
5	5	<title>Check Determinant of 3 by 3 matrix</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Check Determinant of 3 by 3 matrix"/>
7		<meta name="keywords" id="keywords" content=" det_33 determinant check correct "/>
	8	<meta name="keywords" id="keywords" content=" check determinant of 3 by matrix det_33 correct syntax purpose inclusion x d vector ok source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

216	217	where
217	218	<code><i><font color="black"><span style='white-space: nowrap'>i</span></font></i></code>
218	219	has type <code><font color="blue">size_t</font></code> with value less than 9.
219		This must return a <code><font color="blue">double</font></code> value corresponding to the <i>i</i>-th
	220	This must return a <code><font color="blue">double</font></code> value corresponding to the <code><i>i</i></code>-th
220	221	element of the vector
221	222	<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
222	223	.

-1

doc/det_by_lu.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Determinant Using Lu Factorization: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determinant Using Lu Factorization: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" determinant by minors example test "/>
	8	<meta name="keywords" id="keywords" content=" determinant using lu factorization: example and test by minors "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/det_by_lu.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: det_by_lu</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: det_by_lu"/>
7		<meta name="keywords" id="keywords" content=" det_by_lu source "/>
	8	<meta name="keywords" id="keywords" content=" source: det_by_lu source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/det_by_lu.xml less more

3	3	>
4	4	<head>
5	5	<title>Determinant Using Expansion by Lu Factorization</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determinant Using Expansion by Lu Factorization"/>
7		<meta name="keywords" id="keywords" content=" det_by_lu determinant lu factor "/>
	8	<meta name="keywords" id="keywords" content=" determinant using expansion by lu factorization det_by_lu factor syntax inclusion constructor scalar n det a d vector example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

315	316	.
316	317	This must return a
317	318	<code><i><font color="black"><span style='white-space: nowrap'>Scalar</span></font></i></code>
318		value corresponding to the <i>i</i>-th
	319	value corresponding to the <code><i>i</i></code>-th
319	320	element of the vector
320	321	<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
321	322	.

-1

doc/det_by_minor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Determinant Using Expansion by Minors: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determinant Using Expansion by Minors: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" determinant by minors example test "/>
	8	<meta name="keywords" id="keywords" content=" determinant using expansion by minors: example and test minors "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/det_by_minor.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: det_by_minor</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: det_by_minor"/>
7		<meta name="keywords" id="keywords" content=" det_by_minor source "/>
	8	<meta name="keywords" id="keywords" content=" source: det_by_minor source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/det_by_minor.xml less more

3	3	>
4	4	<head>
5	5	<title>Determinant Using Expansion by Minors</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determinant Using Expansion by Minors"/>
7		<meta name="keywords" id="keywords" content=" determinant minor expansion "/>
	8	<meta name="keywords" id="keywords" content=" determinant using expansion by minors minor syntax inclusion constructor scalar n det a d vector example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

313	314	.
314	315	This must return a
315	316	<code><i><font color="black"><span style='white-space: nowrap'>Scalar</span></font></i></code>
316		value corresponding to the <i>i</i>-th
	317	value corresponding to the <code><i>i</i></code>-th
317	318	element of the vector
318	319	<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
319	320	.

-1

doc/det_by_minor_c.xml less more

3	3	>
4	4	<head>
5	5	<title>Compute Determinant using Expansion by Minors</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Compute Determinant using Expansion by Minors"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" compute determinant using expansion by minors syntax purpose a m source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/det_grad_33.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: det_grad_33</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: det_grad_33"/>
7		<meta name="keywords" id="keywords" content=" det_grad_33 source "/>
	8	<meta name="keywords" id="keywords" content=" source: det_grad_33 source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/det_grad_33.xml less more

3	3	>
4	4	<head>
5	5	<title>Check Gradient of Determinant of 3 by 3 matrix</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Check Gradient of Determinant of 3 by 3 matrix"/>
7		<meta name="keywords" id="keywords" content=" det_grad_33 determinant check correct "/>
	8	<meta name="keywords" id="keywords" content=" check gradient of determinant 3 by matrix det_grad_33 correct syntax purpose inclusion x g vector ok source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

241	242	where
242	243	<code><i><font color="black"><span style='white-space: nowrap'>i</span></font></i></code>
243	244	has type <code><font color="blue">size_t</font></code> with value less than 9.
244		This must return a <code><font color="blue">double</font></code> value corresponding to the <i>i</i>-th
	245	This must return a <code><font color="blue">double</font></code> value corresponding to the <code><i>i</i></code>-th
245	246	element of the vector
246	247	<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
247	248	.

-1

doc/det_of_minor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Determinant of a Minor: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determinant of a Minor: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" det_of_minor example test "/>
	8	<meta name="keywords" id="keywords" content=" determinant of a minor: example and test det_of_minor "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/det_of_minor.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: det_of_minor</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: det_of_minor"/>
7		<meta name="keywords" id="keywords" content=" det_of_minor source "/>
	8	<meta name="keywords" id="keywords" content=" source: det_of_minor source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/det_of_minor.xml less more

3	3	>
4	4	<head>
5	5	<title>Determinant of a Minor</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determinant of a Minor"/>
7		<meta name="keywords" id="keywords" content=" det_of_minor determinant matrix minor "/>
	8	<meta name="keywords" id="keywords" content=" det_of_minor determinant matrix minor of a syntax inclusion purpose m n r c d scalar example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/det_of_minor_c.xml less more

3	3	>
4	4	<head>
5	5	<title>Determinant of a Minor</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determinant of a Minor"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" determinant of a minor syntax purpose m n r c d source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/discrete.xml less more

3	3	>
4	4	<head>
5	5	<title>Discrete AD Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Discrete AD Functions"/>
7		<meta name="keywords" id="keywords" content=" discrete Ad function Cppad_discrete_function parallel Cppadcreatediscrete deprecated "/>
	8	<meta name="keywords" id="keywords" content=" discrete ad functions Ad function syntax purpose base name x y ax ay create version Cppad_discrete_function operation sequence derivatives parallel mode example deprecated Cppadcreatediscrete "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/div.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Binary Division: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Binary Division: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" / Ad example divide quotient test "/>
	8	<meta name="keywords" id="keywords" content=" ad binary division: example and test / Ad divide quotient "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/div_eq.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Computed Assignment Division: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Computed Assignment Division: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" /= Ad example computed assignment divide test assign plus add "/>
	8	<meta name="keywords" id="keywords" content=" ad computed assignment division: example and test /= Ad divide assign plus add "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/double_det_lu.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Double Speed: Determinant Using Lu Factorization</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Double Speed: Determinant Using Lu Factorization"/>
7		<meta name="keywords" id="keywords" content=" link_det_lu double speed lu matrix factor "/>
	8	<meta name="keywords" id="keywords" content=" double speed: determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

109	110	# include <cppad/speed/det_by_lu.hpp>
110	111	# include <cppad/speed/uniform_01.hpp>
111	112
	113	// Note that CppAD uses global_memory at the main program level
	114	extern bool
	115	global_onetape, global_atomic, global_optimize;
	116
112	117	bool link_det_lu(
113	118	size_t size ,
114	119	size_t repeat ,
115	120	CppAD::vector<double> &matrix ,
116	121	CppAD::vector<double> &det )
117	122	{
	123	if(global_onetape\|\|global_atomic\|\|global_optimize)
	124	return false;
118	125	// -----------------------------------------------------
119	126	// setup
120	127	CppAD::det_by_lu<double> Det(size);

-1

doc/double_det_minor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Double Speed: Determinant by Minor Expansion</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Double Speed: Determinant by Minor Expansion"/>
7		<meta name="keywords" id="keywords" content=" link_det_minor double speed minor determinant "/>
	8	<meta name="keywords" id="keywords" content=" double speed: determinant by minor expansion link_det_minor speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

107	108	# include <cppad/speed/det_by_minor.hpp>
108	109	# include <cppad/speed/uniform_01.hpp>
109	110
	111	// Note that CppAD uses global_memory at the main program level
	112	extern bool
	113	global_onetape, global_atomic, global_optimize;
	114
110	115	bool link_det_minor(
111	116	size_t size ,
112	117	size_t repeat ,
113	118	CppAD::vector<double> &matrix ,
114	119	CppAD::vector<double> &det )
115	120	{
	121	if(global_onetape\|\|global_atomic\|\|global_optimize)
	122	return false;
116	123	// -----------------------------------------------------
117	124	// setup
118	125	CppAD::det_by_minor<double> Det(size);

-1

doc/double_mat_mul.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Speed: Matrix Multiplication (Double Version)</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Speed: Matrix Multiplication (Double Version)"/>
7		<meta name="keywords" id="keywords" content=" cppad speed matrix multiply link_mat_mul "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: matrix multiplication (double version) speed multiply specifications implementation link_mat_mul "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

111	112	# include <cppad/speed/mat_sum_sq.hpp>
112	113	# include <cppad/speed/uniform_01.hpp>
113	114
	115	// Note that CppAD uses global_memory at the main program level
	116	extern bool
	117	global_onetape, global_atomic, global_optimize;
	118
114	119	bool link_mat_mul(
115	120	size_t size ,
116	121	size_t repeat ,

119	124	CppAD::vector<double>& dz
120	125	)
121	126	{
	127	if(global_onetape\|\|global_atomic\|\|global_optimize)
	128	return false;
122	129	// -----------------------------------------------------
123	130	size_t n = size * size; // number of independent variables
124	131	CppAD::vector<double> y(n);

-3

doc/double_ode.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Double Speed: Ode Solution</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Double Speed: Ode Solution"/>
7		<meta name="keywords" id="keywords" content=" link_ode double speed ode "/>
	8	<meta name="keywords" id="keywords" content=" double speed: ode solution link_ode speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

111	112	# include <cppad/speed/ode_evaluate.hpp>
112	113	# include <cppad/speed/uniform_01.hpp>
113	114
	115	// Note that CppAD uses global_memory at the main program level
	116	extern bool
	117	global_onetape, global_atomic, global_optimize;
	118
114	119	bool link_ode(
115	120	size_t size ,
116	121	size_t repeat ,

118	123	CppAD::vector<double> &jacobian
119	124	)
120	125	{
121		assert( x.size() == size );
122
	126	if(global_onetape\|\|global_atomic\|\|global_optimize)
	127	return false;
123	128	// -------------------------------------------------------------
124	129	// setup
	130	assert( x.size() == size );
125	131
126	132	size_t n = size;
127	133

-1

doc/double_poly.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Double Speed: Evaluate a Polynomial</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Double Speed: Evaluate a Polynomial"/>
7		<meta name="keywords" id="keywords" content=" link_poly double speed polynomial "/>
	8	<meta name="keywords" id="keywords" content=" double speed: evaluate a polynomial link_poly speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

109	110	# include <cppad/cppad.hpp>
110	111	# include <cppad/speed/uniform_01.hpp>
111	112
	113	// Note that CppAD uses global_memory at the main program level
	114	extern bool
	115	global_onetape, global_atomic, global_optimize;
	116
112	117	bool link_poly(
113	118	size_t size ,
114	119	size_t repeat ,

116	121	CppAD::vector<double> &z , // polynomial argument value
117	122	CppAD::vector<double> &p ) // second derivative w.r.t z
118	123	{
	124	if(global_onetape\|\|global_atomic\|\|global_optimize)
	125	return false;
119	126	// -----------------------------------------------------
120	127	// setup
121	128

+12

-5

doc/double_sparse_hessian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Double Speed: Sparse Hessian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Double Speed: Sparse Hessian"/>
7		<meta name="keywords" id="keywords" content=" link_sparse_hessian double speed sparse hessian "/>
	8	<meta name="keywords" id="keywords" content=" double speed: sparse hessian link_sparse_hessian speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

110	111	# include <cppad/speed/uniform_01.hpp>
111	112	# include <cppad/speed/sparse_hes_fun.hpp>
112	113
	114	// Note that CppAD uses global_memory at the main program level
	115	extern bool
	116	global_onetape, global_atomic, global_optimize, global_boolsparsity;
	117
113	118	bool link_sparse_hessian(
114	119	size_t size ,
115	120	size_t repeat ,
116		CppAD::vector<double> &x ,
117		const CppAD::vector<size_t> &row ,
118		const CppAD::vector<size_t> &col ,
119		CppAD::vector<double> &hessian )
	121	const CppAD::vector<size_t>& row ,
	122	const CppAD::vector<size_t>& col ,
	123	CppAD::vector<double>& x ,
	124	CppAD::vector<double>& hessian )
120	125	{
	126	if(global_onetape\|\|global_atomic\|\|global_optimize\|\|global_boolsparsity)
	127	return false;
121	128	// -----------------------------------------------------
122	129	// setup
123	130	using CppAD::vector;

+21

-29

doc/double_sparse_jacobian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Double Speed: Sparse Jacobian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Double Speed: Sparse Jacobian"/>
7		<meta name="keywords" id="keywords" content=" link_sparse_jacobian double speed sparse jacobian "/>
	8	<meta name="keywords" id="keywords" content=" double speed: sparse jacobian link_sparse_jacobian speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

110	111	# include <cppad/speed/uniform_01.hpp>
111	112	# include <cppad/speed/sparse_jac_fun.hpp>
112	113
	114	// Note that CppAD uses global_memory at the main program level
	115	extern bool
	116	global_onetape, global_atomic, global_optimize, global_boolsparsity;
	117
113	118	bool link_sparse_jacobian(
114		size_t size ,
115		size_t repeat ,
116		size_t m ,
117		CppAD::vector<double> &x ,
118		CppAD::vector<size_t> &row ,
119		CppAD::vector<size_t> &col ,
120		CppAD::vector<double> &jacobian )
	119	size_t size ,
	120	size_t repeat ,
	121	size_t m ,
	122	const CppAD::vector<size_t>& row ,
	123	const CppAD::vector<size_t>& col ,
	124	CppAD::vector<double>& x ,
	125	CppAD::vector<double>& jacobian ,
	126	size_t& n_sweep )
121	127	{
	128	if(global_onetape\|\|global_atomic\|\|global_optimize\|\|global_boolsparsity)
	129	return false;
122	130	// -----------------------------------------------------
123	131	// setup
124	132	using CppAD::vector;
125		size_t i, k;
	133	size_t i;
126	134	size_t order = 0; // order for computing function value
127	135	size_t n = size; // argument space dimension
128		size_t K = row.size(); // size of index vectors
129	136	vector<double> yp(m); // function value yp = f(x)
130	137
131		// temporaries
132		vector<double> tmp(2 * K);
133
134		// choose a value for x
135		CppAD::uniform_01(n, x);
	138	// ------------------------------------------------------
	139	while(repeat--)
	140	{ // choose a value for x
	141	CppAD::uniform_01(n, x);
136	142
137		// ------------------------------------------------------
138
139		while(repeat--)
140		{
141		// get the next set of indices
142		CppAD::uniform_01(2 * K, tmp);
143		for(k = 0; k < K; k++)
144		{ row[k] = size_t( n * tmp[k] );
145		row[k] = std::min(n-1, row[k]);
146		//
147		col[k] = size_t( n * tmp[k + K] );
148		col[k] = std::min(n-1, col[k]);
149		}
150
151	143	// computation of the function
152	144	CppAD::sparse_jac_fun<double>(m, n, x, row, col, order, yp);
153	145	}

-4

doc/download.xml less more

3	3	>
4	4	<head>
5	5	<title>Download The CppAD Source Code</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Download The CppAD Source Code"/>
7		<meta name="keywords" id="keywords" content=" download cppad "/>
	8	<meta name="keywords" id="keywords" content=" download the cppad source code purpose distribution directory compressed tar file current version monthly versions release unix extraction windows install instructions subversion limitations stable "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

61	62	<option>Install-></option>
62	63	<option>download</option>
63	64	<option>cmake</option>
64		<option>cppad_test</option>
	65	<option>cmake_check</option>
65	66	<option>pkgconfig</option>
66	67	<option>InstallUnix</option>
67	68	</select>

120	121	<table><tr><td align='left' valign='top'>
121	122
122	123	EPL License <code><span style='white-space: nowrap'>  </span></code> </td><td align='left' valign='top'>
123		<a href="cppad-20140000.3.epl.tgz" target="_top"><span style='white-space: nowrap'>cppad-20140000.3.epl.tgz</span></a>
	124	<a href="http://www.coin-or.org/download/source/CppAD/cppad-20150000.0.epl.tgz" target="_top"><span style='white-space: nowrap'>cppad-20150000.0.epl.tgz</span></a>
124	125
125	126	</td></tr><tr><td align='left' valign='top'>
126	127
127	128	GPL License <code><span style='white-space: nowrap'>  </span></code> </td><td align='left' valign='top'>
128		<a href="cppad-20140000.3.gpl.tgz" target="_top"><span style='white-space: nowrap'>cppad-20140000.3.gpl.tgz</span></a>
	129	<a href="http://www.coin-or.org/download/source/CppAD/cppad-20150000.0.gpl.tgz" target="_top"><span style='white-space: nowrap'>cppad-20150000.0.gpl.tgz</span></a>
129	130
130	131	</td></tr>
131	132	</table>

-1

doc/drivers.xml less more

3	3	>
4	4	<head>
5	5	<title>First and Second Derivatives: Easy Drivers</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="First and Second Derivatives: Easy Drivers"/>
7		<meta name="keywords" id="keywords" content=" forward easy driver reverse "/>
	8	<meta name="keywords" id="keywords" content=" forward easy driver reverse first and second derivatives: drivers "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/eigen_array.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Using Eigen Arrays: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using Eigen Arrays: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" array eigen example test "/>
	8	<meta name="keywords" id="keywords" content=" using eigen arrays: example and test array "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/eigen_det.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Using Eigen To Compute Determinant: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using Eigen To Compute Determinant: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" determinant eigen example test "/>
	8	<meta name="keywords" id="keywords" content=" using eigen to compute determinant: example and test determinant "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/eigen_plugin.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source Code for eigen_plugin.hpp</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source Code for eigen_plugin.hpp"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" source code for eigen_plugin.hpp "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/eigen_prefix.xml less more

3	3	>
4	4	<head>
5	5	<title>Including the Eigen Examples and Tests</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Including the Eigen Examples and Tests"/>
7		<meta name="keywords" id="keywords" content=" eigen example test prefix vector get "/>
	8	<meta name="keywords" id="keywords" content=" including the eigen examples and tests example test purpose eigen_prefix prefix vector get_eigen get "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

62	63	<option>Install-></option>
63	64	<option>download</option>
64	65	<option>cmake</option>
65		<option>cppad_test</option>
	66	<option>cmake_check</option>
66	67	<option>pkgconfig</option>
67	68	<option>InstallUnix</option>
68	69	</select>

71	72	<select onchange='choose_down1(this)'>
72	73	<option>cmake-></option>
73	74	<option>adolc_prefix</option>
	75	<option>colpack_prefix</option>
74	76	<option>eigen_prefix</option>
75	77	<option>fadbad_prefix</option>
76	78	<option>ipopt_prefix</option>

-1

doc/elapsed_seconds.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Elapsed Seconds: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Elapsed Seconds: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" elapsed seconds example timer test "/>
	8	<meta name="keywords" id="keywords" content=" elapsed seconds: example and test seconds timer "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/elapsed_seconds.xml less more

3	3	>
4	4	<head>
5	5	<title>Returns Elapsed Number of Seconds</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Returns Elapsed Number of Seconds"/>
7		<meta name="keywords" id="keywords" content=" elapsed_seconds seconds time "/>
	8	<meta name="keywords" id="keywords" content=" returns elapsed number of seconds elapsed_seconds time syntax purpose s microsoft systems example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/elapsed_seconds_c.xml less more

3	3	>
4	4	<head>
5	5	<title>Returns Elapsed Number of Seconds</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Returns Elapsed Number of Seconds"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" returns elapsed number of seconds syntax purpose s source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/epsilon.xml less more

3	3	>
4	4	<head>
5	5	<title>Machine Epsilon For AD Types</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Machine Epsilon For AD Types"/>
7		<meta name="keywords" id="keywords" content=" Ad epsilon deprecated "/>
	8	<meta name="keywords" id="keywords" content=" Ad epsilon machine for ad types deprecated syntax purpose float eps "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/equal_op_seq.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>EqualOpSeq: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="EqualOpSeq: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Equalopseq example test "/>
	8	<meta name="keywords" id="keywords" content=" equalopseq: example and test Equalopseq "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/equalopseq.xml less more

3	3	>
4	4	<head>
5	5	<title>Check if Two Value are Identically Equal</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Check if Two Value are Identically Equal"/>
7		<meta name="keywords" id="keywords" content=" Equalopseq operation equal sequence "/>
	8	<meta name="keywords" id="keywords" content=" Equalopseq operation equal sequence check if two value are identically syntax purpose motivation x y b example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+23

-15

doc/erf.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD erf Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD erf Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" erf example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad erf function: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

94	95	// domain space vector
95	96	size_t n = 1;
96	97	double x0 = 0.5;
97		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) x(n);
98		x[0] = x0;
	98	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ax(n);
	99	ax[0] = x0;
99	100
100	101	// declare independent variables and start tape recording
101		CppAD::<a href="independent.xml" target="_top">Independent</a>(x);
102
103		// a temporary value
	102	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
104	103
105	104	// range space vector
106	105	size_t m = 1;
107		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) y(m);
108		y[0] = CppAD::erf(x[0]);
	106	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ay(m);
	107	ay[0] = CppAD::erf(ax[0]);
109	108
110	109	// create f: x -> y and stop tape recording
111		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(x, y);
	110	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(ax, ay);
112	111
113	112	// check relative erorr
114		double erf_x0 = 0.5205;
115		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y[0] , erf_x0, 4e-4 , 0.);
	113	double erf_x0 = 0.52050;
	114	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ay[0] , erf_x0, 0., 4e-4);
	115	# if CPPAD_COMPILER_HAS_ERF
	116	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ay[0] , erf_x0, 0., 1e-5);
	117	# endif
116	118
117	119	// value of derivative of erf at x0
118	120	double pi = 4. * std::atan(1.);

124	126	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) dy(m);
125	127	dx[0] = 1.;
126	128	dy = f.<a href="forward.xml" target="_top">Forward</a>(1, dx);
127		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0], check, 4e-4, 0.);
	129	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0], check, 0., 1e-3);
	130	# if CPPAD_COMPILER_HAS_ERF
	131	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0], check, 0., eps);
	132	# endif
128	133
129	134	// reverse computation of derivative of y[0]
130	135	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) w(m);
131	136	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) dw(n);
132	137	w[0] = 1.;
133	138	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
134		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0], check, 4e-4, 0.);
	139	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0], check, 0., 1e-1);
	140	# if CPPAD_COMPILER_HAS_ERF
	141	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0], check, 0., eps);
	142	# endif
135	143
136	144	// use a VecAD<Base>::reference object with erf
137	145	CppAD::VecAD<double> v(1);
138	146	<a href="ad.xml" target="_top">AD</a><double> zero(0);
139	147	v[zero] = x0;
140	148	<a href="ad.xml" target="_top">AD</a><double> result = CppAD::erf(v[zero]);
141		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(result, y[0], eps, eps);
	149	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(result, ay[0], eps, eps);
142	150
143	151	// use a double with erf
144		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(CppAD::erf(x0), y[0], eps, eps);
	152	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(CppAD::erf(x0), ay[0], eps, eps);
145	153
146	154	return ok;
147	155	}

+30

-3

doc/erf.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD Error Function</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD Error Function"/>
7		<meta name="keywords" id="keywords" content=" erf Ad function error "/>
	8	<meta name="keywords" id="keywords" content=" the ad error function erf Ad syntax description x operation sequence method cppad_compiler_has_erf Cppad_compiler_has_erf other example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

90	91	<option>x</option>
91	92	<option>Operation Sequence</option>
92	93	<option>Method</option>
	94	<option>---..CPPAD_COMPILER_HAS_ERF</option>
	95	<option>---..Other</option>
93	96	<option>Example</option>
94	97	</select>
95	98	</td>

177	180	<br/>
178	181	<br/>
179	182	<b><big><a name="Method" id="Method">Method</a></big></b>
180		<br/>
181		This is a fast approximation (few numerical operations)
	183
	184
	185	<br/>
	186	<br/>
	187	<b><a name="Method.CPPAD_COMPILER_HAS_ERF" id="Method.CPPAD_COMPILER_HAS_ERF">CPPAD_COMPILER_HAS_ERF</a></b>
	188
	189	<br/>
	190	This preprocessor symbol is one if
	191	the function
	192	<code><font color="blue"><span style='white-space: nowrap'>std::erf(double </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
	193	is defined the in the
	194	include file <code><font color="blue"><cmath></font></code>.
	195	Otherwise this preprocessor symbol is zero.
	196	If this preprocessor symbols is one,
	197	CppAD uses the compiler's version of <code><font color="blue">erf</font></code>
	198	and it corresponds to an <a href="glossary.xml#Operation.Atomic" target="_top"><span style='white-space: nowrap'>atomic</span></a>
	199	operation.
	200
	201	<br/>
	202	<br/>
	203	<b><a name="Method.Other" id="Method.Other">Other</a></b>
	204	<br/>
	205	If the function
	206	<code><font color="blue"><span style='white-space: nowrap'>std::erf(double </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
	207	is not defined,
	208	CppAD uses a fast approximation (few numerical operations)
182	209	with relative error bound
183	210	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
184	211	<mn>4</mn>

+445

-0

doc/erf_forward.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Error Function Forward Taylor Polynomial Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Error Function Forward Taylor Polynomial Theory"/>
	8	<meta name="keywords" id="keywords" content=" erf forward theory error function taylor polynomial derivatives coefficients recursion "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_erf_forward_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="tan_forward.xml" target="_top">Prev</a>
	25	</td><td><a href="reversetheory.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>Appendix</option>
	41	<option>Theory</option>
	42	<option>ForwardTheory</option>
	43	<option>erf_forward</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>Appendix-></option>
	49	<option>Faq</option>
	50	<option>Theory</option>
	51	<option>glossary</option>
	52	<option>Bib</option>
	53	<option>Bugs</option>
	54	<option>WishList</option>
	55	<option>whats_new</option>
	56	<option>deprecated</option>
	57	<option>compare_c</option>
	58	<option>License</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>Theory-></option>
	64	<option>ForwardTheory</option>
	65	<option>ReverseTheory</option>
	66	<option>reverse_identity</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>ForwardTheory-></option>
	72	<option>ExpForward</option>
	73	<option>LogForward</option>
	74	<option>SqrtForward</option>
	75	<option>SinCosForward</option>
	76	<option>AtanForward</option>
	77	<option>AsinForward</option>
	78	<option>AcosForward</option>
	79	<option>tan_forward</option>
	80	<option>erf_forward</option>
	81	</select>
	82	</td>
	83	<td>erf_forward</td>
	84	<td>
	85	<select onchange='choose_current0(this)'>
	86	<option>Headings-></option>
	87	<option>Derivatives</option>
	88	<option>Taylor Coefficients Recursion</option>
	89	</select>
	90	</td>
	91	</tr></table><br/>
	92	<center><b><big><big>Error Function Forward Taylor Polynomial Theory</big></big></b></center>
	93	<br/>
	94	<b><big><a name="Derivatives" id="Derivatives">Derivatives</a></big></b>
	95	<br/>
	96	Given
	97	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	98	<mi mathvariant='italic'>X</mi>
	99	<mo stretchy="false">(</mo>
	100	<mi mathvariant='italic'>t</mi>
	101	<mo stretchy="false">)</mo>
	102	</mrow></math>
	103
	104	, we define the function
	105
	106	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	107	<mi mathvariant='italic'>Z</mi>
	108	<mo stretchy="false">(</mo>
	109	<mi mathvariant='italic'>t</mi>
	110	<mo stretchy="false">)</mo>
	111	<mo stretchy="false">=</mo>
	112	<mrow><mstyle mathvariant='normal'><mi mathvariant='normal'>erf</mi>
	113	</mstyle></mrow>
	114	<mo stretchy="false">[</mo>
	115	<mi mathvariant='italic'>X</mi>
	116	<mo stretchy="false">(</mo>
	117	<mi mathvariant='italic'>t</mi>
	118	<mo stretchy="false">)</mo>
	119	<mo stretchy="false">]</mo>
	120	</mrow></math>
	121
	122	It follows that
	123
	124	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	125	<mtable rowalign="center" ><mtr><mtd columnalign="right" >
	126	<msup><mrow><mstyle mathvariant='normal'><mi mathvariant='normal'>erf</mi>
	127	</mstyle></mrow>
	128	<mrow><mo stretchy="false">(</mo>
	129	<mn>1</mn>
	130	<mo stretchy="false">)</mo>
	131	</mrow>
	132	</msup>
	133	<mo stretchy="false">(</mo>
	134	<mi mathvariant='italic'>u</mi>
	135	<mo stretchy="false">)</mo>
	136	</mtd><mtd columnalign="center" >
	137	<mo stretchy="false">=</mo>
	138	</mtd><mtd columnalign="left" >
	139	<mo stretchy="false">(</mo>
	140	<mn>2</mn>
	141	<mo stretchy="false">/</mo>
	142	<msqrt><mrow><mi mathvariant='normal'>π</mi>
	143	</mrow>
	144	</msqrt>
	145	<mo stretchy="false">)</mo>
	146	<mi>exp</mi>
	147	<mrow><mo stretchy="true">(</mo><mrow><mo stretchy="false">-</mo>
	148	<msup><mi mathvariant='italic'>u</mi>
	149	<mn>2</mn>
	150	</msup>
	151	</mrow><mo stretchy="true">)</mo></mrow>
	152	</mtd></mtr><mtr><mtd columnalign="right" >
	153	<msup><mi mathvariant='italic'>Z</mi>
	154	<mrow><mo stretchy="false">(</mo>
	155	<mn>1</mn>
	156	<mo stretchy="false">)</mo>
	157	</mrow>
	158	</msup>
	159	<mo stretchy="false">(</mo>
	160	<mi mathvariant='italic'>t</mi>
	161	<mo stretchy="false">)</mo>
	162	</mtd><mtd columnalign="center" >
	163	<mo stretchy="false">=</mo>
	164	</mtd><mtd columnalign="left" >
	165	<msup><mrow><mstyle mathvariant='normal'><mi mathvariant='normal'>erf</mi>
	166	</mstyle></mrow>
	167	<mrow><mo stretchy="false">(</mo>
	168	<mn>1</mn>
	169	<mo stretchy="false">)</mo>
	170	</mrow>
	171	</msup>
	172	<mo stretchy="false">[</mo>
	173	<mi mathvariant='italic'>X</mi>
	174	<mo stretchy="false">(</mo>
	175	<mi mathvariant='italic'>t</mi>
	176	<mo stretchy="false">)</mo>
	177	<mo stretchy="false">]</mo>
	178	<msup><mi mathvariant='italic'>X</mi>
	179	<mrow><mo stretchy="false">(</mo>
	180	<mn>1</mn>
	181	<mo stretchy="false">)</mo>
	182	</mrow>
	183	</msup>
	184	<mo stretchy="false">(</mo>
	185	<mi mathvariant='italic'>t</mi>
	186	<mo stretchy="false">)</mo>
	187	<mo stretchy="false">=</mo>
	188	<mi mathvariant='italic'>Y</mi>
	189	<mo stretchy="false">(</mo>
	190	<mi mathvariant='italic'>t</mi>
	191	<mo stretchy="false">)</mo>
	192	<msup><mi mathvariant='italic'>X</mi>
	193	<mrow><mo stretchy="false">(</mo>
	194	<mn>1</mn>
	195	<mo stretchy="false">)</mo>
	196	</mrow>
	197	</msup>
	198	<mo stretchy="false">(</mo>
	199	<mi mathvariant='italic'>t</mi>
	200	<mo stretchy="false">)</mo>
	201	</mtd></mtr></mtable>
	202	</mrow></math>
	203
	204	where we define the function
	205
	206	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	207	<mi mathvariant='italic'>Y</mi>
	208	<mo stretchy="false">(</mo>
	209	<mi mathvariant='italic'>t</mi>
	210	<mo stretchy="false">)</mo>
	211	<mo stretchy="false">=</mo>
	212	<mfrac><mrow><mn>2</mn>
	213	</mrow>
	214	<mrow><msqrt><mrow><mi mathvariant='normal'>π</mi>
	215	</mrow>
	216	</msqrt>
	217	</mrow>
	218	</mfrac>
	219	<mi>exp</mi>
	220	<mrow><mo stretchy="true">[</mo><mrow><mo stretchy="false">-</mo>
	221	<mi mathvariant='italic'>X</mi>
	222	<mo stretchy="false">(</mo>
	223	<mi mathvariant='italic'>t</mi>
	224	<msup><mo stretchy="false">)</mo>
	225	<mn>2</mn>
	226	</msup>
	227	</mrow><mo stretchy="true">]</mo></mrow>
	228	</mrow></math>
	229
	230	<br/>
	231	<b><big><a name="Taylor Coefficients Recursion" id="Taylor Coefficients Recursion">Taylor Coefficients Recursion</a></big></b>
	232	<br/>
	233	Suppose that we are given the Taylor coefficients
	234	up to order
	235	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	236	<mi mathvariant='italic'>j</mi>
	237	</mrow></math>
	238
	239	for the function
	240	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	241	<mi mathvariant='italic'>X</mi>
	242	<mo stretchy="false">(</mo>
	243	<mi mathvariant='italic'>t</mi>
	244	<mo stretchy="false">)</mo>
	245	</mrow></math>
	246
	247	and
	248	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	249	<mi mathvariant='italic'>Y</mi>
	250	<mo stretchy="false">(</mo>
	251	<mi mathvariant='italic'>t</mi>
	252	<mo stretchy="false">)</mo>
	253	</mrow></math>
	254
	255	.
	256	We need a formula that computes the coefficient of order
	257	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	258	<mi mathvariant='italic'>j</mi>
	259	</mrow></math>
	260
	261
	262	for
	263	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	264	<mi mathvariant='italic'>Z</mi>
	265	<mo stretchy="false">(</mo>
	266	<mi mathvariant='italic'>t</mi>
	267	<mo stretchy="false">)</mo>
	268	</mrow></math>
	269
	270	.
	271	Using the equation above for
	272	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	273	<msup><mi mathvariant='italic'>Z</mi>
	274	<mrow><mo stretchy="false">(</mo>
	275	<mn>1</mn>
	276	<mo stretchy="false">)</mo>
	277	</mrow>
	278	</msup>
	279	<mo stretchy="false">(</mo>
	280	<mi mathvariant='italic'>t</mi>
	281	<mo stretchy="false">)</mo>
	282	</mrow></math>
	283
	284	, we have
	285
	286	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	287	<mtable rowalign="center" ><mtr><mtd columnalign="right" >
	288	<munderover><mo displaystyle='true' largeop='true'>∑</mo>
	289	<mrow><mi mathvariant='italic'>k</mi>
	290	<mo stretchy="false">=</mo>
	291	<mn>1</mn>
	292	</mrow>
	293	<mi mathvariant='italic'>j</mi>
	294	</munderover>
	295	<mi mathvariant='italic'>k</mi>
	296	<msup><mi mathvariant='italic'>z</mi>
	297	<mrow><mo stretchy="false">(</mo>
	298	<mi mathvariant='italic'>k</mi>
	299	<mo stretchy="false">)</mo>
	300	</mrow>
	301	</msup>
	302	<msup><mi mathvariant='italic'>t</mi>
	303	<mrow><mi mathvariant='italic'>k</mi>
	304	<mn>-1</mn>
	305	</mrow>
	306	</msup>
	307	</mtd><mtd columnalign="center" >
	308	<mo stretchy="false">=</mo>
	309	</mtd><mtd columnalign="left" >
	310	<mrow><mo stretchy="true">[</mo><mrow><munderover><mo displaystyle='true' largeop='true'>∑</mo>
	311	<mrow><mi mathvariant='italic'>k</mi>
	312	<mo stretchy="false">=</mo>
	313	<mn>0</mn>
	314	</mrow>
	315	<mi mathvariant='italic'>j</mi>
	316	</munderover>
	317	<msup><mi mathvariant='italic'>y</mi>
	318	<mrow><mo stretchy="false">(</mo>
	319	<mi mathvariant='italic'>k</mi>
	320	<mo stretchy="false">)</mo>
	321	</mrow>
	322	</msup>
	323	<msup><mi mathvariant='italic'>t</mi>
	324	<mi mathvariant='italic'>k</mi>
	325	</msup>
	326	</mrow><mo stretchy="true">]</mo></mrow>
	327	<mrow><mo stretchy="true">[</mo><mrow><munderover><mo displaystyle='true' largeop='true'>∑</mo>
	328	<mrow><mi mathvariant='italic'>k</mi>
	329	<mo stretchy="false">=</mo>
	330	<mn>1</mn>
	331	</mrow>
	332	<mi mathvariant='italic'>j</mi>
	333	</munderover>
	334	<mi mathvariant='italic'>k</mi>
	335	<msup><mi mathvariant='italic'>x</mi>
	336	<mrow><mo stretchy="false">(</mo>
	337	<mi mathvariant='italic'>k</mi>
	338	<mo stretchy="false">)</mo>
	339	</mrow>
	340	</msup>
	341	<msup><mi mathvariant='italic'>t</mi>
	342	<mrow><mi mathvariant='italic'>k</mi>
	343	<mn>-1</mn>
	344	</mrow>
	345	</msup>
	346	</mrow><mo stretchy="true">]</mo></mrow>
	347	<mo stretchy="false">+</mo>
	348	<mi mathvariant='italic'>o</mi>
	349	<mo stretchy="false">(</mo>
	350	<msup><mi mathvariant='italic'>t</mi>
	351	<mrow><mi mathvariant='italic'>j</mi>
	352	<mn>-1</mn>
	353	</mrow>
	354	</msup>
	355	<mo stretchy="false">)</mo>
	356	</mtd></mtr></mtable>
	357	</mrow></math>
	358
	359	Setting the coefficients of
	360	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	361	<msup><mi mathvariant='italic'>t</mi>
	362	<mrow><mi mathvariant='italic'>j</mi>
	363	<mn>-1</mn>
	364	</mrow>
	365	</msup>
	366	</mrow></math>
	367
	368	equal, we have
	369
	370	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	371	<mtable rowalign="center" ><mtr><mtd columnalign="right" >
	372	<mi mathvariant='italic'>j</mi>
	373	<msup><mi mathvariant='italic'>z</mi>
	374	<mrow><mo stretchy="false">(</mo>
	375	<mi mathvariant='italic'>j</mi>
	376	<mo stretchy="false">)</mo>
	377	</mrow>
	378	</msup>
	379	<mo stretchy="false">=</mo>
	380	<munderover><mo displaystyle='true' largeop='true'>∑</mo>
	381	<mrow><mi mathvariant='italic'>k</mi>
	382	<mo stretchy="false">=</mo>
	383	<mn>1</mn>
	384	</mrow>
	385	<mi mathvariant='italic'>j</mi>
	386	</munderover>
	387	<mi mathvariant='italic'>k</mi>
	388	<msup><mi mathvariant='italic'>x</mi>
	389	<mrow><mo stretchy="false">(</mo>
	390	<mi mathvariant='italic'>k</mi>
	391	<mo stretchy="false">)</mo>
	392	</mrow>
	393	</msup>
	394	<msup><mi mathvariant='italic'>y</mi>
	395	<mrow><mo stretchy="false">(</mo>
	396	<mi mathvariant='italic'>j</mi>
	397	<mo stretchy="false">-</mo>
	398	<mi mathvariant='italic'>k</mi>
	399	<mo stretchy="false">)</mo>
	400	</mrow>
	401	</msup>
	402	</mtd></mtr><mtr><mtd columnalign="right" >
	403	<msup><mi mathvariant='italic'>z</mi>
	404	<mrow><mo stretchy="false">(</mo>
	405	<mi mathvariant='italic'>j</mi>
	406	<mo stretchy="false">)</mo>
	407	</mrow>
	408	</msup>
	409	<mo stretchy="false">=</mo>
	410	<mfrac><mrow><mn>1</mn>
	411	</mrow>
	412	<mrow><mi mathvariant='italic'>j</mi>
	413	</mrow>
	414	</mfrac>
	415	<munderover><mo displaystyle='true' largeop='true'>∑</mo>
	416	<mrow><mi mathvariant='italic'>k</mi>
	417	<mo stretchy="false">=</mo>
	418	<mn>1</mn>
	419	</mrow>
	420	<mi mathvariant='italic'>j</mi>
	421	</munderover>
	422	<mi mathvariant='italic'>k</mi>
	423	<msup><mi mathvariant='italic'>x</mi>
	424	<mrow><mo stretchy="false">(</mo>
	425	<mi mathvariant='italic'>k</mi>
	426	<mo stretchy="false">)</mo>
	427	</mrow>
	428	</msup>
	429	<msup><mi mathvariant='italic'>y</mi>
	430	<mrow><mo stretchy="false">(</mo>
	431	<mi mathvariant='italic'>j</mi>
	432	<mo stretchy="false">-</mo>
	433	<mi mathvariant='italic'>k</mi>
	434	<mo stretchy="false">)</mo>
	435	</mrow>
	436	</msup>
	437	</mtd></mtr></mtable>
	438	</mrow></math>
	439
	440
	441	<hr/>Input File: omh/theory/erf_forward.omh
	442
	443	</body>
	444	</html>

+559

-0

doc/erf_reverse.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Error Function Reverse Mode Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Error Function Reverse Mode Theory"/>
	8	<meta name="keywords" id="keywords" content=" erf reverse theory error function mode notation positive orders z(t) order zero "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_erf_reverse_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="tan_reverse.xml" target="_top">Prev</a>
	25	</td><td><a href="reverse_identity.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>Appendix</option>
	41	<option>Theory</option>
	42	<option>ReverseTheory</option>
	43	<option>erf_reverse</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>Appendix-></option>
	49	<option>Faq</option>
	50	<option>Theory</option>
	51	<option>glossary</option>
	52	<option>Bib</option>
	53	<option>Bugs</option>
	54	<option>WishList</option>
	55	<option>whats_new</option>
	56	<option>deprecated</option>
	57	<option>compare_c</option>
	58	<option>License</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>Theory-></option>
	64	<option>ForwardTheory</option>
	65	<option>ReverseTheory</option>
	66	<option>reverse_identity</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>ReverseTheory-></option>
	72	<option>ExpReverse</option>
	73	<option>LogReverse</option>
	74	<option>SqrtReverse</option>
	75	<option>SinCosReverse</option>
	76	<option>AtanReverse</option>
	77	<option>AsinReverse</option>
	78	<option>AcosReverse</option>
	79	<option>tan_reverse</option>
	80	<option>erf_reverse</option>
	81	</select>
	82	</td>
	83	<td>erf_reverse</td>
	84	<td>
	85	<select onchange='choose_current0(this)'>
	86	<option>Headings-></option>
	87	<option>Notation</option>
	88	<option>Positive Orders Z(t)</option>
	89	<option>Order Zero Z(t)</option>
	90	</select>
	91	</td>
	92	</tr></table><br/>
	93	<center><b><big><big>Error Function Reverse Mode Theory</big></big></b></center>
	94	<br/>
	95	<b><big><a name="Notation" id="Notation">Notation</a></big></b>
	96	<br/>
	97	We use the reverse theory
	98	<a href="reversetheory.xml#Standard Math Functions" target="_top"><span style='white-space: nowrap'>standard math function</span></a>
	99
	100	definition for the functions
	101	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	102	<mi mathvariant='italic'>H</mi>
	103	</mrow></math>
	104
	105	and
	106	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	107	<mi mathvariant='italic'>G</mi>
	108	</mrow></math>
	109
	110	.
	111
	112	<br/>
	113	<br/>
	114	<b><big><a name="Positive Orders Z(t)" id="Positive Orders Z(t)">Positive Orders Z(t)</a></big></b>
	115	<br/>
	116	For order
	117	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	118	<mi mathvariant='italic'>j</mi>
	119	<mo stretchy="false">></mo>
	120	<mn>0</mn>
	121	</mrow></math>
	122
	123	,
	124	suppose that
	125	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	126	<mi mathvariant='italic'>H</mi>
	127	</mrow></math>
	128
	129	is the same as
	130	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	131	<mi mathvariant='italic'>G</mi>
	132	</mrow></math>
	133
	134	.
	135
	136	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	137	<msup><mi mathvariant='italic'>z</mi>
	138	<mrow><mo stretchy="false">(</mo>
	139	<mi mathvariant='italic'>j</mi>
	140	<mo stretchy="false">)</mo>
	141	</mrow>
	142	</msup>
	143	<mo stretchy="false">=</mo>
	144	<mfrac><mrow><mn>1</mn>
	145	</mrow>
	146	<mrow><mi mathvariant='italic'>j</mi>
	147	</mrow>
	148	</mfrac>
	149	<munderover><mo displaystyle='true' largeop='true'>∑</mo>
	150	<mrow><mi mathvariant='italic'>k</mi>
	151	<mo stretchy="false">=</mo>
	152	<mn>1</mn>
	153	</mrow>
	154	<mi mathvariant='italic'>j</mi>
	155	</munderover>
	156	<mi mathvariant='italic'>k</mi>
	157	<msup><mi mathvariant='italic'>x</mi>
	158	<mrow><mo stretchy="false">(</mo>
	159	<mi mathvariant='italic'>k</mi>
	160	<mo stretchy="false">)</mo>
	161	</mrow>
	162	</msup>
	163	<msup><mi mathvariant='italic'>y</mi>
	164	<mrow><mo stretchy="false">(</mo>
	165	<mi mathvariant='italic'>j</mi>
	166	<mo stretchy="false">-</mo>
	167	<mi mathvariant='italic'>k</mi>
	168	<mo stretchy="false">)</mo>
	169	</mrow>
	170	</msup>
	171	</mrow></math>
	172
	173	For
	174	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	175	<mi mathvariant='italic'>k</mi>
	176	<mo stretchy="false">=</mo>
	177	<mn>1</mn>
	178	<mo stretchy="false">,</mo>
	179	<mo stretchy="false">…</mo>
	180	<mo stretchy="false">,</mo>
	181	<mi mathvariant='italic'>j</mi>
	182	</mrow></math>
	183
	184	,
	185	the partial of
	186	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	187	<mi mathvariant='italic'>H</mi>
	188	</mrow></math>
	189
	190	with respect to
	191	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	192	<msup><mi mathvariant='italic'>x</mi>
	193	<mrow><mo stretchy="false">(</mo>
	194	<mi mathvariant='italic'>k</mi>
	195	<mo stretchy="false">)</mo>
	196	</mrow>
	197	</msup>
	198	</mrow></math>
	199
	200	is given by
	201
	202	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	203	<mfrac><mrow><mo stretchy="false">∂</mo>
	204	<mi mathvariant='italic'>H</mi>
	205	</mrow>
	206	<mrow><mo stretchy="false">∂</mo>
	207	<msup><mi mathvariant='italic'>x</mi>
	208	<mrow><mo stretchy="false">(</mo>
	209	<mi mathvariant='italic'>k</mi>
	210	<mo stretchy="false">)</mo>
	211	</mrow>
	212	</msup>
	213	</mrow>
	214	</mfrac>
	215	<mo stretchy="false">=</mo>
	216	<mfrac><mrow><mo stretchy="false">∂</mo>
	217	<mi mathvariant='italic'>G</mi>
	218	</mrow>
	219	<mrow><mo stretchy="false">∂</mo>
	220	<msup><mi mathvariant='italic'>x</mi>
	221	<mrow><mo stretchy="false">(</mo>
	222	<mi mathvariant='italic'>k</mi>
	223	<mo stretchy="false">)</mo>
	224	</mrow>
	225	</msup>
	226	</mrow>
	227	</mfrac>
	228	<mo stretchy="false">+</mo>
	229	<mfrac><mrow><mo stretchy="false">∂</mo>
	230	<mi mathvariant='italic'>G</mi>
	231	</mrow>
	232	<mrow><mo stretchy="false">∂</mo>
	233	<msup><mi mathvariant='italic'>z</mi>
	234	<mrow><mo stretchy="false">(</mo>
	235	<mi mathvariant='italic'>j</mi>
	236	<mo stretchy="false">)</mo>
	237	</mrow>
	238	</msup>
	239	</mrow>
	240	</mfrac>
	241	<mfrac><mrow><mo stretchy="false">∂</mo>
	242	<msup><mi mathvariant='italic'>z</mi>
	243	<mrow><mo stretchy="false">(</mo>
	244	<mi mathvariant='italic'>j</mi>
	245	<mo stretchy="false">)</mo>
	246	</mrow>
	247	</msup>
	248	</mrow>
	249	<mrow><mo stretchy="false">∂</mo>
	250	<msup><mi mathvariant='italic'>x</mi>
	251	<mrow><mo stretchy="false">(</mo>
	252	<mi mathvariant='italic'>k</mi>
	253	<mo stretchy="false">)</mo>
	254	</mrow>
	255	</msup>
	256	</mrow>
	257	</mfrac>
	258	<mo stretchy="false">=</mo>
	259	<mfrac><mrow><mo stretchy="false">∂</mo>
	260	<mi mathvariant='italic'>G</mi>
	261	</mrow>
	262	<mrow><mo stretchy="false">∂</mo>
	263	<msup><mi mathvariant='italic'>x</mi>
	264	<mrow><mo stretchy="false">(</mo>
	265	<mi mathvariant='italic'>k</mi>
	266	<mo stretchy="false">)</mo>
	267	</mrow>
	268	</msup>
	269	</mrow>
	270	</mfrac>
	271	<mo stretchy="false">+</mo>
	272	<mfrac><mrow><mo stretchy="false">∂</mo>
	273	<mi mathvariant='italic'>G</mi>
	274	</mrow>
	275	<mrow><mo stretchy="false">∂</mo>
	276	<msup><mi mathvariant='italic'>z</mi>
	277	<mrow><mo stretchy="false">(</mo>
	278	<mi mathvariant='italic'>j</mi>
	279	<mo stretchy="false">)</mo>
	280	</mrow>
	281	</msup>
	282	</mrow>
	283	</mfrac>
	284	<mfrac><mrow><mi mathvariant='italic'>k</mi>
	285	</mrow>
	286	<mrow><mi mathvariant='italic'>j</mi>
	287	</mrow>
	288	</mfrac>
	289	<msup><mi mathvariant='italic'>y</mi>
	290	<mrow><mo stretchy="false">(</mo>
	291	<mi mathvariant='italic'>j</mi>
	292	<mo stretchy="false">-</mo>
	293	<mi mathvariant='italic'>k</mi>
	294	<mo stretchy="false">)</mo>
	295	</mrow>
	296	</msup>
	297	</mrow></math>
	298
	299	For
	300	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	301	<mi mathvariant='italic'>k</mi>
	302	<mo stretchy="false">=</mo>
	303	<mn>1</mn>
	304	<mo stretchy="false">,</mo>
	305	<mo stretchy="false">…</mo>
	306	<mo stretchy="false">,</mo>
	307	<mi mathvariant='italic'>j</mi>
	308	</mrow></math>
	309
	310
	311	The partial of
	312	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	313	<mi mathvariant='italic'>H</mi>
	314	</mrow></math>
	315
	316	with respect to
	317	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	318	<msup><mi mathvariant='italic'>y</mi>
	319	<mrow><mi mathvariant='italic'>j</mi>
	320	<mo stretchy="false">-</mo>
	321	<mi mathvariant='italic'>k</mi>
	322	</mrow>
	323	</msup>
	324	</mrow></math>
	325
	326	,
	327	is given by
	328
	329	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	330	<mfrac><mrow><mo stretchy="false">∂</mo>
	331	<mi mathvariant='italic'>H</mi>
	332	</mrow>
	333	<mrow><mo stretchy="false">∂</mo>
	334	<msup><mi mathvariant='italic'>y</mi>
	335	<mrow><mo stretchy="false">(</mo>
	336	<mi mathvariant='italic'>j</mi>
	337	<mo stretchy="false">-</mo>
	338	<mi mathvariant='italic'>k</mi>
	339	<mo stretchy="false">)</mo>
	340	</mrow>
	341	</msup>
	342	</mrow>
	343	</mfrac>
	344	<mo stretchy="false">=</mo>
	345	<mfrac><mrow><mo stretchy="false">∂</mo>
	346	<mi mathvariant='italic'>G</mi>
	347	</mrow>
	348	<mrow><mo stretchy="false">∂</mo>
	349	<msup><mi mathvariant='italic'>y</mi>
	350	<mrow><mo stretchy="false">(</mo>
	351	<mi mathvariant='italic'>j</mi>
	352	<mo stretchy="false">-</mo>
	353	<mi mathvariant='italic'>k</mi>
	354	<mo stretchy="false">)</mo>
	355	</mrow>
	356	</msup>
	357	</mrow>
	358	</mfrac>
	359	<mo stretchy="false">+</mo>
	360	<mfrac><mrow><mo stretchy="false">∂</mo>
	361	<mi mathvariant='italic'>G</mi>
	362	</mrow>
	363	<mrow><mo stretchy="false">∂</mo>
	364	<msup><mi mathvariant='italic'>z</mi>
	365	<mrow><mo stretchy="false">(</mo>
	366	<mi mathvariant='italic'>j</mi>
	367	<mo stretchy="false">)</mo>
	368	</mrow>
	369	</msup>
	370	</mrow>
	371	</mfrac>
	372	<mfrac><mrow><mo stretchy="false">∂</mo>
	373	<msup><mi mathvariant='italic'>z</mi>
	374	<mrow><mo stretchy="false">(</mo>
	375	<mi mathvariant='italic'>j</mi>
	376	<mo stretchy="false">)</mo>
	377	</mrow>
	378	</msup>
	379	</mrow>
	380	<mrow><mo stretchy="false">∂</mo>
	381	<msup><mi mathvariant='italic'>y</mi>
	382	<mrow><mo stretchy="false">(</mo>
	383	<mi mathvariant='italic'>j</mi>
	384	<mo stretchy="false">-</mo>
	385	<mi mathvariant='italic'>k</mi>
	386	<mo stretchy="false">)</mo>
	387	</mrow>
	388	</msup>
	389	</mrow>
	390	</mfrac>
	391	<mo stretchy="false">=</mo>
	392	<mfrac><mrow><mo stretchy="false">∂</mo>
	393	<mi mathvariant='italic'>G</mi>
	394	</mrow>
	395	<mrow><mo stretchy="false">∂</mo>
	396	<msup><mi mathvariant='italic'>y</mi>
	397	<mrow><mo stretchy="false">(</mo>
	398	<mi mathvariant='italic'>j</mi>
	399	<mo stretchy="false">-</mo>
	400	<mi mathvariant='italic'>k</mi>
	401	<mo stretchy="false">)</mo>
	402	</mrow>
	403	</msup>
	404	</mrow>
	405	</mfrac>
	406	<mo stretchy="false">+</mo>
	407	<mfrac><mrow><mo stretchy="false">∂</mo>
	408	<mi mathvariant='italic'>G</mi>
	409	</mrow>
	410	<mrow><mo stretchy="false">∂</mo>
	411	<msup><mi mathvariant='italic'>z</mi>
	412	<mrow><mo stretchy="false">(</mo>
	413	<mi mathvariant='italic'>j</mi>
	414	<mo stretchy="false">)</mo>
	415	</mrow>
	416	</msup>
	417	</mrow>
	418	</mfrac>
	419	<mfrac><mrow><mi mathvariant='italic'>k</mi>
	420	</mrow>
	421	<mrow><mi mathvariant='italic'>j</mi>
	422	</mrow>
	423	</mfrac>
	424	<msup><mi mathvariant='italic'>x</mi>
	425	<mrow><mi mathvariant='italic'>k</mi>
	426	</mrow>
	427	</msup>
	428	</mrow></math>
	429
	430	<br/>
	431	<b><big><a name="Order Zero Z(t)" id="Order Zero Z(t)">Order Zero Z(t)</a></big></b>
	432	<br/>
	433	The
	434	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	435	<msup><mi mathvariant='italic'>z</mi>
	436	<mrow><mo stretchy="false">(</mo>
	437	<mn>0</mn>
	438	<mo stretchy="false">)</mo>
	439	</mrow>
	440	</msup>
	441	</mrow></math>
	442
	443	coefficient
	444	is expressed as a function of the Taylor coefficients
	445	for
	446	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	447	<mi mathvariant='italic'>X</mi>
	448	<mo stretchy="false">(</mo>
	449	<mi mathvariant='italic'>t</mi>
	450	<mo stretchy="false">)</mo>
	451	</mrow></math>
	452
	453	and
	454	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	455	<mi mathvariant='italic'>Y</mi>
	456	<mo stretchy="false">(</mo>
	457	<mi mathvariant='italic'>t</mi>
	458	<mo stretchy="false">)</mo>
	459	</mrow></math>
	460
	461	as follows:
	462	In this case,
	463
	464	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	465	<mfrac><mrow><mo stretchy="false">∂</mo>
	466	<mi mathvariant='italic'>H</mi>
	467	</mrow>
	468	<mrow><mo stretchy="false">∂</mo>
	469	<msup><mi mathvariant='italic'>x</mi>
	470	<mrow><mo stretchy="false">(</mo>
	471	<mn>0</mn>
	472	<mo stretchy="false">)</mo>
	473	</mrow>
	474	</msup>
	475	</mrow>
	476	</mfrac>
	477	<mo stretchy="false">=</mo>
	478	<mfrac><mrow><mo stretchy="false">∂</mo>
	479	<mi mathvariant='italic'>G</mi>
	480	</mrow>
	481	<mrow><mo stretchy="false">∂</mo>
	482	<msup><mi mathvariant='italic'>x</mi>
	483	<mrow><mo stretchy="false">(</mo>
	484	<mn>0</mn>
	485	<mo stretchy="false">)</mo>
	486	</mrow>
	487	</msup>
	488	</mrow>
	489	</mfrac>
	490	<mo stretchy="false">+</mo>
	491	<mfrac><mrow><mo stretchy="false">∂</mo>
	492	<mi mathvariant='italic'>G</mi>
	493	</mrow>
	494	<mrow><mo stretchy="false">∂</mo>
	495	<msup><mi mathvariant='italic'>z</mi>
	496	<mrow><mo stretchy="false">(</mo>
	497	<mn>0</mn>
	498	<mo stretchy="false">)</mo>
	499	</mrow>
	500	</msup>
	501	</mrow>
	502	</mfrac>
	503	<mfrac><mrow><mo stretchy="false">∂</mo>
	504	<msup><mi mathvariant='italic'>z</mi>
	505	<mrow><mo stretchy="false">(</mo>
	506	<mn>0</mn>
	507	<mo stretchy="false">)</mo>
	508	</mrow>
	509	</msup>
	510	</mrow>
	511	<mrow><mo stretchy="false">∂</mo>
	512	<msup><mi mathvariant='italic'>x</mi>
	513	<mrow><mo stretchy="false">(</mo>
	514	<mn>0</mn>
	515	<mo stretchy="false">)</mo>
	516	</mrow>
	517	</msup>
	518	</mrow>
	519	</mfrac>
	520	<mo stretchy="false">=</mo>
	521	<mfrac><mrow><mo stretchy="false">∂</mo>
	522	<mi mathvariant='italic'>G</mi>
	523	</mrow>
	524	<mrow><mo stretchy="false">∂</mo>
	525	<msup><mi mathvariant='italic'>x</mi>
	526	<mrow><mo stretchy="false">(</mo>
	527	<mn>0</mn>
	528	<mo stretchy="false">)</mo>
	529	</mrow>
	530	</msup>
	531	</mrow>
	532	</mfrac>
	533	<mo stretchy="false">+</mo>
	534	<mfrac><mrow><mo stretchy="false">∂</mo>
	535	<mi mathvariant='italic'>G</mi>
	536	</mrow>
	537	<mrow><mo stretchy="false">∂</mo>
	538	<msup><mi mathvariant='italic'>z</mi>
	539	<mrow><mo stretchy="false">(</mo>
	540	<mn>0</mn>
	541	<mo stretchy="false">)</mo>
	542	</mrow>
	543	</msup>
	544	</mrow>
	545	</mfrac>
	546	<msup><mi mathvariant='italic'>y</mi>
	547	<mrow><mo stretchy="false">(</mo>
	548	<mn>0</mn>
	549	<mo stretchy="false">)</mo>
	550	</mrow>
	551	</msup>
	552	</mrow></math>
	553
	554
	555	<hr/>Input File: omh/theory/erf_reverse.omh
	556
	557	</body>
	558	</html>

-1

doc/error_handler.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Replacing The CppAD Error Handler: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Replacing The CppAD Error Handler: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" error handler example test "/>
	8	<meta name="keywords" id="keywords" content=" replacing the cppad error handler: example and test handler "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/errorhandler.xml less more

3	3	>
4	4	<head>
5	5	<title>Replacing the CppAD Error Handler</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Replacing the CppAD Error Handler"/>
7		<meta name="keywords" id="keywords" content=" error handler replace assert exception parallel Errorhandler "/>
	8	<meta name="keywords" id="keywords" content=" replacing the cppad error handler replace assert exception syntax constructor parallel mode Errorhandler call info known line file exp msg example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+13

-6

doc/example.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Examples and Tests</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Examples and Tests"/>
7		<meta name="keywords" id="keywords" content=" example Cppad test "/>
	8	<meta name="keywords" id="keywords" content=" cppad examples and tests example Cppad test running "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

89	90	<br/>
90	91	<b><big><a name="Running Tests" id="Running Tests">Running Tests</a></big></b>
91	92	<br/>
92		To build this program and run its correctness tests see <a href="cppad_test.xml" target="_top"><span style='white-space: nowrap'>cppad_test</span></a>
	93	To build this program and run its correctness tests see <a href="cmake_check.xml" target="_top"><span style='white-space: nowrap'>cmake_check</span></a>
93	94	.
94	95
95	96	<code><font color="blue">

125	126	extern bool base_require(void);
126	127	extern bool BenderQuad(void);
127	128	extern bool BoolFun(void);
128		extern bool capacity_taylor(void);
	129	extern bool capacity_order(void);
129	130	extern bool change_const(void);
130	131	extern bool check_for_nan(void);
131	132	extern bool CheckNumericType(void);
132	133	extern bool CheckSimpleVector(void);
	134	extern bool colpack(void);
133	135	extern bool Compare(void);
134	136	extern bool CompareChange(void);
135	137	extern bool complex_poly(void);

150	152	extern bool ForTwo(void);
151	153	extern bool ForSparseJac(void);
152	154	extern bool Forward(void);
153		extern bool forward_mul(void);
	155	extern bool forward_dir(void);
	156	extern bool forward_order(void);
154	157	extern bool fun_assign(void);
155	158	extern bool FunCheck(void);
156	159	extern bool HesLagrangian(void);

284	287	ok &= Run( Atan2, "Atan2" );
285	288	ok &= Run( BenderQuad, "BenderQuad" );
286	289	ok &= Run( BoolFun, "BoolFun" );
287		ok &= Run( capacity_taylor, "capacity_taylor" );
	290	ok &= Run( capacity_order, "capacity_order" );
288	291	ok &= Run( change_const, "change_const" );
289	292	ok &= Run( check_for_nan, "check_for_nan" );
290	293	ok &= Run( CheckNumericType, "CheckNumericType" );

306	309	ok &= Run( ForOne, "ForOne" );
307	310	ok &= Run( ForTwo, "ForTwo" );
308	311	ok &= Run( Forward, "Forward" );
309		ok &= Run( forward_mul, "forward_mul" );
	312	ok &= Run( forward_dir, "forward_dir" );
	313	ok &= Run( forward_order, "forward_order" );
310	314	ok &= Run( ForSparseJac, "ForSparseJac" );
311	315	ok &= Run( fun_assign, "fun_assign" );
312	316	ok &= Run( FunCheck, "FunCheck" );

393	397	ok &= Run( mul_level_adolc, "mul_level_adolc" );
394	398	ok &= Run( mul_level_adolc_ode, "mul_level_adolc_ode" );
395	399	# endif
	400	# ifdef CPPAD_COLPACK_EXAMPLES
	401	ok &= Run( colpack, "colpack" );
	402	# endif
396	403	# ifdef CPPAD_EIGEN_EXAMPLES
397	404	ok &= Run( eigen_array, "eigen_array" );
398	405	ok &= Run( eigen_det, "eigen_det" );

-1

doc/example.xml less more

3	3	>
4	4	<head>
5	5	<title>Examples</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Examples"/>
7		<meta name="keywords" id="keywords" content=" example "/>
	8	<meta name="keywords" id="keywords" content=" examples example introduction running the cppad test vector template class "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exampleutility.xml less more

3	3	>
4	4	<head>
5	5	<title>Utility Routines used by CppAD Examples</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Utility Routines used by CppAD Examples"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" utility routines used by cppad examples "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD exp Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD exp Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" exp Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad exp function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Test"/>
7		<meta name="keywords" id="keywords" content=" test exp_2 "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: test exp_2 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Implementation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Implementation"/>
7		<meta name="keywords" id="keywords" content=" implementation exp_2 "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: implementation exp_2 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2.xml less more

3	3	>
4	4	<head>
5	5	<title>Second Order Exponential Approximation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Second Order Exponential Approximation"/>
7		<meta name="keywords" id="keywords" content=" exp_2 example algorithm exp "/>
	8	<meta name="keywords" id="keywords" content=" second order exponential approximation exp_2 example algorithm exp syntax purpose mathematical form include x y type implementation test exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2_cppad.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: CppAD Forward and Reverse Sweeps</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: CppAD Forward and Reverse Sweeps"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: cppad forward and reverse sweeps purpose exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2_for0.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Verify Zero Order Forward Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Verify Zero Order Forward Sweep"/>
7		<meta name="keywords" id="keywords" content=" zero order exp_2 "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: verify zero order forward sweep exp_2 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2_for0.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Operation Sequence and Zero Order Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Operation Sequence and Zero Order Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" exp_2 operation sequence example zero order forward expansion "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: operation sequence and zero order forward mode exp_2 example mathematical form expansion index code sweep return value verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2_for1.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Verify First Order Forward Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Verify First Order Forward Sweep"/>
7		<meta name="keywords" id="keywords" content=" first order exp_2 "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: verify first order forward sweep exp_2 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2_for1.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: First Order Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: First Order Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" exp_2 forward mode example first order expansion "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: first order forward mode exp_2 example expansion purpose mathematical form operation sequence index zero derivative sweep return value verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2_for2.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Verify Second Order Forward Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Verify Second Order Forward Sweep"/>
7		<meta name="keywords" id="keywords" content=" second order exp_2 "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: verify second order forward sweep exp_2 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/exp_2_for2.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Second Order Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Second Order Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" exp_2 forward mode example second order expansion "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: second order forward mode exp_2 example expansion purpose mathematical form operation sequence index zero first derivative sweep return value verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

350	351	<br/>
351	352	The Second column contains the second order derivatives
352	353	for the corresponding variable in the operation sequence; i.e.,
353		the second order expansion for the <i>i</i>-th variable is given by
	354	the second order expansion for the <code><i>i</i></code>-th variable is given by
354	355
355	356	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
356	357	<msub><mi mathvariant='italic'>v</mi>

-1

doc/exp_2_rev1.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Verify First Order Reverse Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Verify First Order Reverse Sweep"/>
7		<meta name="keywords" id="keywords" content=" reverse exp_2 mode "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: verify first order reverse sweep exp_2 mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2_rev1.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: First Order Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: First Order Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" exp_2 reverse mode example first order "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: first order reverse mode exp_2 example purpose mathematical form f_5 index 5: f_4 4: f_3 3: f_2 2: f_1 verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2_rev2.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Verify Second Order Reverse Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Verify Second Order Reverse Sweep"/>
7		<meta name="keywords" id="keywords" content=" reverse exp_2 mode "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: verify second order reverse sweep exp_2 mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_2_rev2.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_2: Second Order Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_2: Second Order Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" exp_2 reverse mode example second order "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: second order reverse mode exp_2 example purpose mathematical form f_5 index 5: f_4 4: f_3 3: f_2 2: f_1 verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/exp_apx_main.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Correctness Tests For Exponential Approximation in Introduction</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Correctness Tests For Exponential Approximation in Introduction"/>
7		<meta name="keywords" id="keywords" content=" exp_apx main test run "/>
	8	<meta name="keywords" id="keywords" content=" correctness tests for exponential approximation in introduction exp_apx main test run running main.cpp "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

81	82	<br/>
82	83	<b><big><a name="Running Tests" id="Running Tests">Running Tests</a></big></b>
83	84	<br/>
84		To build this program and run its correctness tests see <a href="cppad_test.xml" target="_top"><span style='white-space: nowrap'>cppad_test</span></a>
	85	To build this program and run its correctness tests see <a href="cmake_check.xml" target="_top"><span style='white-space: nowrap'>cmake_check</span></a>
85	86	.
86	87
87	88	<br/>

-1

doc/exp_eps.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Test of exp_eps</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Test of exp_eps"/>
7		<meta name="keywords" id="keywords" content=" test exp_eps "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: test of exp_eps "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Implementation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Implementation"/>
7		<meta name="keywords" id="keywords" content=" implementation exp_eps "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: implementation exp_eps "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps.xml less more

3	3	>
4	4	<head>
5	5	<title>An Epsilon Accurate Exponential Approximation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="An Epsilon Accurate Exponential Approximation"/>
7		<meta name="keywords" id="keywords" content=" exp_eps example algorithm exp "/>
	8	<meta name="keywords" id="keywords" content=" an epsilon accurate exponential approximation exp_eps example algorithm exp syntax purpose mathematical function include x y type implementation test exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps_cppad.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: CppAD Forward and Reverse Sweeps</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: CppAD Forward and Reverse Sweeps"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: cppad forward and reverse sweeps purpose exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps_for0.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Verify Zero Order Forward Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Verify Zero Order Forward Sweep"/>
7		<meta name="keywords" id="keywords" content=" zero order exp_eps "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: verify zero order forward sweep exp_eps "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps_for0.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Operation Sequence and Zero Order Forward Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Operation Sequence and Zero Order Forward Sweep"/>
7		<meta name="keywords" id="keywords" content=" exp_eps operation sequence example zero order forward "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: operation sequence and zero order forward sweep exp_eps example mathematical form variable parameter index code return value comparisons verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps_for1.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Verify First Order Forward Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Verify First Order Forward Sweep"/>
7		<meta name="keywords" id="keywords" content=" first order exp_2 "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: verify first order forward sweep exp_2 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps_for1.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: First Order Forward Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: First Order Forward Sweep"/>
7		<meta name="keywords" id="keywords" content=" first order forward expansion "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: first order forward sweep expansion mathematical form operation sequence index zero derivative return value verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps_for2.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Verify Second Order Forward Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Verify Second Order Forward Sweep"/>
7		<meta name="keywords" id="keywords" content=" first order exp_2 "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: verify second order forward sweep first exp_2 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/exp_eps_for2.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Second Order Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Second Order Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" exp_eps forward mode example second order expansion "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: second order forward mode exp_eps example expansion purpose mathematical form operation sequence index zero first derivative sweep return value verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

441	442	<br/>
442	443	The Second column contains the second order derivatives
443	444	for the corresponding variable in the operation sequence; i.e.,
444		the second order expansion for the <i>i</i>-th variable is given by
	445	the second order expansion for the <code><i>i</i></code>-th variable is given by
445	446
446	447	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
447	448	<msub><mi mathvariant='italic'>v</mi>

-1

doc/exp_eps_rev1.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Verify First Order Reverse Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Verify First Order Reverse Sweep"/>
7		<meta name="keywords" id="keywords" content=" reverse exp_eps "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: verify first order reverse sweep exp_eps "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps_rev1.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: First Order Reverse Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: First Order Reverse Sweep"/>
7		<meta name="keywords" id="keywords" content=" exp_eps reverse mode example first order "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: first order reverse sweep exp_eps mode example purpose mathematical form epsilon f_7 index 7: f_6 6: f_5 5: f_4 4: f_3 3: f_2 2: f_1 verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps_rev2.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Verify Second Order Reverse Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Verify Second Order Reverse Sweep"/>
7		<meta name="keywords" id="keywords" content=" reverse exp_eps "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: verify second order reverse sweep exp_eps "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/exp_eps_rev2.xml less more

3	3	>
4	4	<head>
5	5	<title>exp_eps: Second Order Reverse Sweep</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="exp_eps: Second Order Reverse Sweep"/>
7		<meta name="keywords" id="keywords" content=" exp_eps reverse mode example second order "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: second order reverse sweep exp_eps mode example purpose mathematical form epsilon f_7 index 7: f_6 6: f_5 5: f_4 4: f_3 3: f_2 2: f_1 verification exercises "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/expforward.xml less more

3	3	>
4	4	<head>
5	5	<title>Exponential Function Forward Taylor Polynomial Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Exponential Function Forward Taylor Polynomial Theory"/>
7		<meta name="keywords" id="keywords" content=" exp forward theory "/>
	8	<meta name="keywords" id="keywords" content=" exp forward theory exponential function taylor polynomial "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinForward</option>
77	78	<option>AcosForward</option>
78	79	<option>tan_forward</option>
	80	<option>erf_forward</option>
79	81	</select>
80	82	</td>
81	83	<td>ExpForward</td>

437	439	</mrow></math>
438	440
439	441
440		<hr/>Input File: omh/exp_forward.omh
	442	<hr/>Input File: omh/theory/exp_forward.omh
441	443
442	444	</body>
443	445	</html>

-2

doc/expreverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Exponential Function Reverse Mode Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Exponential Function Reverse Mode Theory"/>
7		<meta name="keywords" id="keywords" content=" exp reverse theory "/>
	8	<meta name="keywords" id="keywords" content=" exp reverse theory exponential function mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinReverse</option>
77	78	<option>AcosReverse</option>
78	79	<option>tan_reverse</option>
	80	<option>erf_reverse</option>
79	81	</select>
80	82	</td>
81	83	<td>ExpReverse</td>

374	376	</mrow></math>
375	377
376	378
377		<hr/>Input File: omh/exp_reverse.omh
	379	<hr/>Input File: omh/theory/exp_reverse.omh
378	380
379	381	</body>
380	382	</html>

+11

-7

doc/fadbad_det_lu.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Fadbad Speed: Gradient of Determinant Using Lu Factorization</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Fadbad Speed: Gradient of Determinant Using Lu Factorization"/>
7		<meta name="keywords" id="keywords" content=" link_det_lu fadbad speed lu matrix factor "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: gradient of determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

110	111	# include <cppad/speed/uniform_01.hpp>
111	112	# include <cppad/vector.hpp>
112	113
	114	// list of possible options
	115	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	116
113	117	bool link_det_lu(
114	118	size_t size ,
115	119	size_t repeat ,
116		CppAD::vector<double> &matrix ,
117		CppAD::vector<double> &gradient )
	120	CppAD::vector<double> &matrix ,
	121	CppAD::vector<double> &gradient )
118	122	{
119	123	// speed test global option values
120		extern bool global_retape, global_atomic, global_optimize;
121		if( ! global_retape \|\| global_optimize \|\| global_atomic )
	124	if( global_onetape \|\| global_atomic )
122	125	return false;
123
	126	if( global_memory \|\| global_optimize )
	127	return false;
124	128	// -----------------------------------------------------
125	129	// setup
126
	130	//
127	131	// object for computing determinant
128	132	typedef fadbad::B<double> ADScalar;
129	133	typedef CppAD::vector<ADScalar> ADVector;

+10

-5

doc/fadbad_det_minor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Fadbad Speed: Gradient of Determinant by Minor Expansion</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Fadbad Speed: Gradient of Determinant by Minor Expansion"/>
7		<meta name="keywords" id="keywords" content=" link_det_minor fadbad speed minor determinant "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: gradient of determinant by minor expansion link_det_minor speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

107	108	# include <cppad/speed/det_by_minor.hpp>
108	109	# include <cppad/speed/uniform_01.hpp>
109	110	# include <cppad/vector.hpp>
	111
	112	// list of possible options
	113	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	114
110	115	bool link_det_minor(
111	116	size_t size ,
112	117	size_t repeat ,

114	119	CppAD::vector<double> &gradient )
115	120	{
116	121	// speed test global option values
117		extern bool global_retape, global_atomic, global_optimize;
118		if( ! global_retape \|\| global_atomic \|\| global_optimize )
119		return false;
120
	122	if( global_atomic )
	123	return false;
	124	if( global_memory \|\| global_onetape \|\| global_optimize )
	125	return false;
121	126	// -----------------------------------------------------
122	127	// setup
123	128

-4

doc/fadbad_mat_mul.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Fadbad Speed: Matrix Multiplication</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Fadbad Speed: Matrix Multiplication"/>
7		<meta name="keywords" id="keywords" content=" link_mat_mul fadbad speed matrix multiply "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: matrix multiplication link_mat_mul speed multiply specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

110	111	# include <cppad/speed/mat_sum_sq.hpp>
111	112	# include <cppad/speed/uniform_01.hpp>
112	113	# include <cppad/vector.hpp>
	114
	115	// list of possible options
	116	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	117
113	118	bool link_mat_mul(
114	119	size_t size ,
115	120	size_t repeat ,

118	123	CppAD::vector<double>& dz )
119	124	{
120	125	// speed test global option values
121		extern bool global_retape, global_atomic, global_optimize;
122		if( ! global_retape \|\| global_atomic \|\| global_optimize )
	126	if( global_memory \|\| global_onetape \|\| global_atomic \|\| global_optimize )
123	127	return false;
124
125	128	// The correctness check for this test is failing, so abort (for now).
126	129	return false;
127	130

+12

-8

doc/fadbad_ode.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Fadbad Speed: Ode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Fadbad Speed: Ode"/>
7		<meta name="keywords" id="keywords" content=" link_ode fadbad speed ode "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: ode link_ode speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

113	114	# include <cppad/speed/uniform_01.hpp>
114	115	# include <cppad/speed/ode_evaluate.hpp>
115	116
	117	// list of possible options
	118	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	119
116	120	namespace fadbad {
117	121	// define fabs for use by ode_evaluate
118	122	fadbad::F<double> fabs(const fadbad::F<double>& x)

126	130	CppAD::vector<double> &jacobian
127	131	)
128	132	{
	133	// speed test global option values
	134	if( global_atomic )
	135	return false;
	136	if( global_memory \|\| global_onetape \|\| global_optimize )
	137	return false;
	138	// -------------------------------------------------------------
	139	// setup
129	140	assert( x.size() == size );
130	141	assert( jacobian.size() == size * size );
131	142
132		// speed test global option values
133		extern bool global_retape, global_atomic, global_optimize;
134		if( ! global_retape \|\| global_atomic \|\| global_optimize )
135		return false;
136
137		// -------------------------------------------------------------
138		// setup
139	143	typedef fadbad::F<double> ADScalar;
140	144	typedef CppAD::vector<ADScalar> ADVector;
141	145

-5

doc/fadbad_poly.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Fadbad Speed: Second Derivative of a Polynomial</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Fadbad Speed: Second Derivative of a Polynomial"/>
7		<meta name="keywords" id="keywords" content=" link_poly fadbad speed polynomial "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: second derivative of a polynomial link_poly speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

111	112	# include <cppad/speed/uniform_01.hpp>
112	113	# include <FADBAD++/tadiff.h>
113	114
	115	// list of possible options
	116	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	117
114	118	bool link_poly(
115	119	size_t size ,
116	120	size_t repeat ,

118	122	CppAD::vector<double> &z , // polynomial argument value
119	123	CppAD::vector<double> &ddp ) // second derivative w.r.t z
120	124	{
121		// speed test global option values
122		extern bool global_retape, global_atomic, global_optimize;
123		if( ! global_retape \|\| global_atomic \|\| global_optimize )
	125	if( global_atomic )
124	126	return false;
125
	127	if( global_memory \|\| global_onetape \|\| global_optimize )
	128	return false;
126	129	// -----------------------------------------------------
127	130	// setup
128	131	size_t i; // temporary index

-2

doc/fadbad_prefix.xml less more

3	3	>
4	4	<head>
5	5	<title>Including the FADBAD Speed Tests</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Including the FADBAD Speed Tests"/>
7		<meta name="keywords" id="keywords" content=" fadbad speed prefix get "/>
	8	<meta name="keywords" id="keywords" content=" including the fadbad speed tests purpose fadbad_prefix prefix get_fadbad get "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

62	63	<option>Install-></option>
63	64	<option>download</option>
64	65	<option>cmake</option>
65		<option>cppad_test</option>
	66	<option>cmake_check</option>
66	67	<option>pkgconfig</option>
67	68	<option>InstallUnix</option>
68	69	</select>

71	72	<select onchange='choose_down1(this)'>
72	73	<option>cmake-></option>
73	74	<option>adolc_prefix</option>
	75	<option>colpack_prefix</option>
74	76	<option>eigen_prefix</option>
75	77	<option>fadbad_prefix</option>
76	78	<option>ipopt_prefix</option>

-6

doc/fadbad_sparse_hessian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Fadbad Speed: Sparse Hessian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Fadbad Speed: Sparse Hessian"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: sparse hessian "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

88	89
89	90
90	91	<center><b><big><big>Fadbad Speed: Sparse Hessian</big></big></b></center>
91		<code><font color='blue'><pre style='display:inline'> // The fadbad version of this test is not yet available
	92	<code><font color='blue'><pre style='display:inline'> // A fadbad version of this test is not yet available
92	93	bool link_sparse_hessian(
93	94	size_t size ,
94	95	size_t repeat ,
95		CppAD::vector<double> &x ,
96		const CppAD::vector<size_t> &row ,
97		const CppAD::vector<size_t> &col ,
98		CppAD::vector<double> &hessian
	96	const CppAD::vector<size_t>& row ,
	97	const CppAD::vector<size_t>& col ,
	98	CppAD::vector<double>& x ,
	99	CppAD::vector<double>& hessian
99	100	)
100	101	{
101	102	return false;

+11

-9

doc/fadbad_sparse_jacobian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>fadbad Speed: sparse_jacobian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="fadbad Speed: sparse_jacobian"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: sparse_jacobian "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

88	89
89	90
90	91	<center><b><big><big>fadbad Speed: sparse_jacobian</big></big></b></center>
91		<code><font color='blue'><pre style='display:inline'> // The fadbad version of this test is not yet available
	92	<code><font color='blue'><pre style='display:inline'> // A fadbad version of this test is not yet available
92	93	bool link_sparse_jacobian(
93		size_t size ,
94		size_t repeat ,
95		size_t m ,
96		CppAD::vector<double> &x ,
97		CppAD::vector<size_t> &i ,
98		CppAD::vector<size_t> &j ,
99		CppAD::vector<double> &jacobian )
	94	size_t size ,
	95	size_t repeat ,
	96	size_t m ,
	97	const CppAD::vector<size_t>& row ,
	98	const CppAD::vector<size_t>& col ,
	99	CppAD::vector<double>& x ,
	100	CppAD::vector<double>& jacobian ,
	101	size_t& n_sweep )
100	102	{
101	103	return false;
102	104	}

-2

doc/faq.xml less more

3	3	>
4	4	<head>
5	5	<title>Frequently Asked Questions and Answers</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Frequently Asked Questions and Answers"/>
7		<meta name="keywords" id="keywords" content=" Faq assignment operator independent bugs reporting Comparechange Ndebug complex faq test exception Errorhandler variable tape avoid record speed taping math functions function inverse matrix forward reverse mode namespace Cppad_testvector preprocessor symbols standard using storage memory disk "/>
	8	<meta name="keywords" id="keywords" content=" Faq frequently asked questions and answers assignment independent operator bugs reporting comparechange Comparechange Ndebug complex types faq exceptions test exception Errorhandler variables variable tape avoid record speed taping math functions function matrix inverse mode: forward or reverse mode namespace vector preprocessor symbol Cppad_testvector symbols using standard ndebug optimize memory allocation storage: disk storage "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

233	234	for the independent variables ?
234	235	<code><span style='white-space: nowrap'><br/>
235	236	<br/>
236		</span></code>Yes (see <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>ForwardZero</span></a>
	237	</span></code>Yes (see <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
237	238	).
238	239
239	240	<br/>

-1

doc/for_one.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>First Order Partial Driver: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="First Order Partial Driver: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" partial example test "/>
	8	<meta name="keywords" id="keywords" content=" partial example test first order driver: and "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/for_sparse_jac.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Forward Mode Jacobian Sparsity: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Forward Mode Jacobian Sparsity: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Forsparsejac example sparsity forward test "/>
	8	<meta name="keywords" id="keywords" content=" forward mode jacobian sparsity: example and test Forsparsejac sparsity "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/for_two.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Subset of Second Order Partials: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Subset of Second Order Partials: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" second partial example test "/>
	8	<meta name="keywords" id="keywords" content=" subset of second order partials: example and test partial "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/forone.xml less more

3	3	>
4	4	<head>
5	5	<title>First Order Partial Derivative: Driver Routine</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="First Order Partial Derivative: Driver Routine"/>
7		<meta name="keywords" id="keywords" content=" partial first order driver easy "/>
	8	<meta name="keywords" id="keywords" content=" partial first order driver easy derivative: routine syntax purpose f x j dy vector forone uses forward example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/forsparsejac.xml less more

3	3	>
4	4	<head>
5	5	<title>Jacobian Sparsity Pattern: Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Jacobian Sparsity Pattern: Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" Forsparsejac forward sparsity Jacobian pattern "/>
	8	<meta name="keywords" id="keywords" content=" jacobian sparsity pattern: forward mode Forsparsejac Jacobian pattern syntax purpose f size_forward_bool size_forward_set x q transpose r false true s vectorset entire example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/fortwo.xml less more

3	3	>
4	4	<head>
5	5	<title>Forward Mode Second Partial Derivative Driver</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Forward Mode Second Partial Derivative Driver"/>
7		<meta name="keywords" id="keywords" content=" partial second order driver easy "/>
	8	<meta name="keywords" id="keywords" content=" partial second order driver easy forward mode derivative syntax purpose f x j k ddy vectorbase vectorsize_t fortwo uses examples "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+58

-65

doc/forward.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Forward Mode: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Forward Mode: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Forward example test "/>
	8	<meta name="keywords" id="keywords" content=" forward mode: example and test Forward "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="number_skip.cpp.xml" target="_top">Prev</a>
24		</td><td><a href="forward_mul.cpp.xml" target="_top">Next</a>
	24	<td><a href="forward_order.xml" target="_top">Prev</a>
	25	</td><td><a href="forward_order.cpp.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

39	40	<option>ADFun</option>
40	41	<option>FunEval</option>
41	42	<option>Forward</option>
	43	<option>forward_order</option>
42	44	<option>forward.cpp</option>
43	45	</select>
44	46	</td>
45	47	<td>
46	48	<select onchange='choose_down3(this)'>
47		<option>ADFun-></option>
48		<option>Independent</option>
49		<option>FunConstruct</option>
50		<option>Dependent</option>
51		<option>abort_recording</option>
52		<option>seq_property</option>
53		<option>FunEval</option>
54		<option>Drivers</option>
55		<option>FunCheck</option>
56		<option>optimize</option>
57		<option>check_for_nan</option>
58		</select>
59		</td>
60		<td>
61		<select onchange='choose_down2(this)'>
62	49	<option>FunEval-></option>
63	50	<option>Forward</option>
64	51	<option>Reverse</option>

66	53	</select>
67	54	</td>
68	55	<td>
	56	<select onchange='choose_down2(this)'>
	57	<option>Forward-></option>
	58	<option>forward_zero</option>
	59	<option>forward_one</option>
	60	<option>forward_two</option>
	61	<option>forward_order</option>
	62	<option>forward_dir</option>
	63	<option>size_order</option>
	64	<option>CompareChange</option>
	65	<option>capacity_order</option>
	66	<option>number_skip</option>
	67	</select>
	68	</td>
	69	<td>
69	70	<select onchange='choose_down1(this)'>
70		<option>Forward-></option>
71		<option>ForwardZero</option>
72		<option>ForwardOne</option>
73		<option>ForwardAny</option>
74		<option>size_taylor</option>
75		<option>CompareChange</option>
76		<option>capacity_taylor</option>
77		<option>number_skip</option>
	71	<option>forward_order-></option>
78	72	<option>forward.cpp</option>
79		<option>forward_mul.cpp</option>
	73	<option>forward_order.cpp</option>
80	74	</select>
81	75	</td>
82	76	<td>forward.cpp</td>

87	81
88	82	<center><b><big><big>Forward Mode: Example and Test</big></big></b></center>
89	83	<code><font color="blue"><pre style='display:inline'>
	84	# include <limits>
90	85	# include <cppad/cppad.hpp>
91	86	namespace { // --------------------------------------------------------
92	87	// define the template function ForwardCases<Vector> in empty namespace

95	90	{ bool ok = true;
96	91	using CppAD::AD;
97	92	using CppAD::NearEqual;
	93	double eps = 10. * std::numeric_limits<double>::epsilon();
98	94
99	95	// domain space vector
100	96	size_t n = 2;
101		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) X(n);
102		X[0] = 0.;
103		X[1] = 1.;
	97	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ax(n);
	98	ax[0] = 0.;
	99	ax[1] = 1.;
104	100
105	101	// declare independent variables and starting recording
106		CppAD::<a href="independent.xml" target="_top">Independent</a>(X);
	102	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
107	103
108	104	// range space vector
109	105	size_t m = 1;
110		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) Y(m);
111		Y[0] = X[0] * X[0] * X[1];
	106	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ay(m);
	107	ay[0] = ax[0] * ax[0] * ax[1];
112	108
113		// create f: X -> Y and stop tape recording
114		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(X, Y);
	109	// create f: x -> y and stop tape recording
	110	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(ax, ay);
115	111
116	112	// initially, the variable values during taping are stored in f
117		ok &= f.size_taylor() == 1;
	113	ok &= f.size_order() == 1;
118	114
119		// zero order forward mode using notaiton in ForwardZero
	115	// zero order forward mode using notation in forward_zero
120	116	// use the template parameter Vector for the vector type
121		Vector x(n);
122		Vector y(m);
123		x[0] = 3.;
124		x[1] = 4.;
125		y = f.<a href="forward.xml" target="_top">Forward</a>(0, x);
126		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y[0] , x[0]x[0]x[1], 1e-10, 1e-10);
127		ok &= f.size_taylor() == 1;
	117	Vector x0(n), y0(m);
	118	x0[0] = 3.;
	119	x0[1] = 4.;
	120	y0 = f.<a href="forward.xml" target="_top">Forward</a>(0, x0);
	121	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y0[0] , x0[0]x0[0]x0[1], eps, eps);
	122	ok &= f.size_order() == 1;
128	123
129		// first order forward mode using notation in ForwardOne
130		// X(t) = x + dx * t
131		// Y(t) = F[X(t)] = y + dy * t + o(t)
132		Vector dx(n);
133		Vector dy(m);
134		dx[0] = 1.;
135		dx[1] = 0.;
136		dy = f.<a href="forward.xml" target="_top">Forward</a>(1, dx); // partial F w.r.t. x[0]
137		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0] , 2.x[0]x[1], 1e-10, 1e-10);
138		ok &= f.size_taylor() == 2;
	124	// first order forward mode using notation in forward_one
	125	// X(t) = x0 + x1 * t
	126	// Y(t) = F[X(t)] = y0 + y1 * t + o(t)
	127	Vector x1(n), y1(m);
	128	x1[0] = 1.;
	129	x1[1] = 0.;
	130	y1 = f.<a href="forward.xml" target="_top">Forward</a>(1, x1); // partial F w.r.t. x_0
	131	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y1[0] , 2.x0[0]x0[1], eps, eps);
	132	ok &= f.size_order() == 2;
139	133
140		// second order forward mode using notaiton in ForwardAny
141		// X(t) = x + dx * t + x_2 * t^2
142		// Y(t) = F[X(t)] = y + dy * t + y_2 * t^2 + o(t^3)
143		Vector x_2(n);
144		Vector y_2(m);
145		x_2[0] = 0.;
146		x_2[1] = 0.;
147		y_2 = f.<a href="forward.xml" target="_top">Forward</a>(2, x_2);
148		double F_00 = 2. * y_2[0]; // second partial F w.r.t. x[0], x[0]
149		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(F_00, 2.*x[1], 1e-10, 1e-10);
150		ok &= f.size_taylor() == 3;
	134	// second order forward mode using notation in forward_order
	135	// X(t) = x0 + x1 * t + x2 * t^2
	136	// Y(t) = F[X(t)] = y0 + y1 * t + y2 * t^2 + o(t^3)
	137	Vector x2(n), y2(m);
	138	x2[0] = 0.;
	139	x2[1] = 0.;
	140	y2 = f.<a href="forward.xml" target="_top">Forward</a>(2, x2);
	141	double F_00 = 2. * y2[0]; // second partial F w.r.t. x_0, x_0
	142	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(F_00, 2.*x0[1], eps, eps);
	143	ok &= f.size_order() == 3;
151	144
152	145	return ok;
153	146	}

+12

-11

doc/forward.xml less more

3	3	>
4	4	<head>
5	5	<title>Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" forward mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="funeval.xml" target="_top">Prev</a>
24		</td><td><a href="forwardzero.xml" target="_top">Next</a>
	25	</td><td><a href="forward_zero.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

83	84	<td>
84	85	<select onchange='choose_down0(this)'>
85	86	<option>Forward-></option>
86		<option>ForwardZero</option>
87		<option>ForwardOne</option>
88		<option>ForwardAny</option>
89		<option>size_taylor</option>
	87	<option>forward_zero</option>
	88	<option>forward_one</option>
	89	<option>forward_two</option>
	90	<option>forward_order</option>
	91	<option>forward_dir</option>
	92	<option>size_order</option>
90	93	<option>CompareChange</option>
91		<option>capacity_taylor</option>
	94	<option>capacity_order</option>
92	95	<option>number_skip</option>
93		<option>forward.cpp</option>
94		<option>forward_mul.cpp</option>
95	96	</select>
96	97	</td>
97	98	<td>

106	107	<b><big><a name="Contents" id="Contents">Contents</a></big></b>
107	108	<br/>
108	109	<table>
109		<tr><td><a href="forwardzero.xml" target="_top">ForwardZero</a></td><td>Zero Order Forward Mode: Function Values</td></tr><tr><td><a href="forwardone.xml" target="_top">ForwardOne</a></td><td>First Order Forward Mode: Derivative Values</td></tr><tr><td><a href="forwardany.xml" target="_top">ForwardAny</a></td><td>Any Order Forward Mode</td></tr><tr><td><a href="size_taylor.xml" target="_top">size_taylor</a></td><td>Number Taylor Coefficients, Per Variable, Currently Stored</td></tr><tr><td><a href="comparechange.xml" target="_top">CompareChange</a></td><td>Comparison Changes During Zero Order Forward Mode</td></tr><tr><td><a href="capacity_taylor.xml" target="_top">capacity_taylor</a></td><td>Controlling Taylor Coefficients Memory Allocation</td></tr><tr><td><a href="number_skip.xml" target="_top">number_skip</a></td><td>Number of Variables that Can be Skipped</td></tr><tr><td><a href="forward.cpp.xml" target="_top">forward.cpp</a></td><td>Forward Mode: Example and Test</td></tr><tr><td><a href="forward_mul.cpp.xml" target="_top">forward_mul.cpp</a></td><td>Forward Mode: Example and Test of Multiple Orders</td></tr></table>
110		<hr/>Input File: cppad/local/forward.hpp
	110	<tr><td><a href="forward_zero.xml" target="_top">forward_zero</a></td><td>Zero Order Forward Mode: Function Values</td></tr><tr><td><a href="forward_one.xml" target="_top">forward_one</a></td><td>First Order Forward Mode: Derivative Values</td></tr><tr><td><a href="forward_two.xml" target="_top">forward_two</a></td><td>Second Order Forward Mode: Derivative Values</td></tr><tr><td><a href="forward_order.xml" target="_top">forward_order</a></td><td>Multiple Order Forward Mode</td></tr><tr><td><a href="forward_dir.xml" target="_top">forward_dir</a></td><td>Multiple Directions Forward Mode</td></tr><tr><td><a href="size_order.xml" target="_top">size_order</a></td><td>Number Taylor Coefficient Orders Currently Stored</td></tr><tr><td><a href="comparechange.xml" target="_top">CompareChange</a></td><td>Comparison Changes During Zero Order Forward Mode</td></tr><tr><td><a href="capacity_order.xml" target="_top">capacity_order</a></td><td>Controlling Taylor Coefficients Memory Allocation</td></tr><tr><td><a href="number_skip.xml" target="_top">number_skip</a></td><td>Number of Variables that Can be Skipped</td></tr></table>
	111	<hr/>Input File: omh/forward/forward.omh
111	112
112	113	</body>
113	114	</html>

+173

-0

doc/forward_dir.cpp.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Forward Mode: Example and Test of Multiple Directions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Forward Mode: Example and Test of Multiple Directions"/>
	8	<meta name="keywords" id="keywords" content=" forward mode: example and test of multiple directions orders order "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_forward_dir.cpp_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="forward_dir.xml" target="_top">Prev</a>
	25	</td><td><a href="size_order.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>forward_dir</option>
	44	<option>forward_dir.cpp</option>
	45	</select>
	46	</td>
	47	<td>
	48	<select onchange='choose_down3(this)'>
	49	<option>FunEval-></option>
	50	<option>Forward</option>
	51	<option>Reverse</option>
	52	<option>Sparse</option>
	53	</select>
	54	</td>
	55	<td>
	56	<select onchange='choose_down2(this)'>
	57	<option>Forward-></option>
	58	<option>forward_zero</option>
	59	<option>forward_one</option>
	60	<option>forward_two</option>
	61	<option>forward_order</option>
	62	<option>forward_dir</option>
	63	<option>size_order</option>
	64	<option>CompareChange</option>
	65	<option>capacity_order</option>
	66	<option>number_skip</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>forward_dir-></option>
	72	<option>forward_dir.cpp</option>
	73	</select>
	74	</td>
	75	<td>forward_dir.cpp</td>
	76	<td>Headings</td>
	77	</tr></table><br/>
	78
	79
	80
	81	<center><b><big><big>Forward Mode: Example and Test of Multiple Directions</big></big></b></center>
	82	<code><font color="blue"><pre style='display:inline'>
	83	# include <limits>
	84	# include <cppad/cppad.hpp>
	85	bool forward_dir(void)
	86	{ bool ok = true;
	87	using CppAD::AD;
	88	using CppAD::NearEqual;
	89	double eps = 10. * std::numeric_limits<double>::epsilon();
	90	size_t j;
	91
	92	// domain space vector
	93	size_t n = 3;
	94	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ax(n);
	95	ax[0] = 0.;
	96	ax[1] = 1.;
	97	ax[2] = 2.;
	98
	99	// declare independent variables and starting recording
	100	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
	101
	102	// range space vector
	103	size_t m = 1;
	104	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ay(m);
	105	ay[0] = ax[0] * ax[1] * ax[2];
	106
	107	// create f: x -> y and stop tape recording
	108	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(ax, ay);
	109
	110	// initially, the variable values during taping are stored in f
	111	ok &= f.size_order() == 1;
	112
	113	// zero order Taylor coefficients
	114	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x0(n), y0;
	115	for(j = 0; j < n; j++)
	116	x0[j] = double(j+1);
	117	y0 = f.<a href="forward.xml" target="_top">Forward</a>(0, x0);
	118	ok &= y0.size() == m;
	119	double y_0 = 1.2.3.;
	120	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y0[0], y_0, eps, eps);
	121
	122	// first order Taylor coefficients
	123	size_t r = 2, ell;
	124	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x1(r*n), y1;
	125	for(ell = 0; ell < r; ell++)
	126	{ for(j = 0; j < n; j++)
	127	x1[ r * j + ell ] = double(j + 1 + ell);
	128	}
	129	y1 = f.<a href="forward.xml" target="_top">Forward</a>(1, r, x1);
	130	ok &= y1.size() == r*m;
	131
	132	// secondorder Taylor coefficients
	133	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x2(r*n), y2;
	134	for(ell = 0; ell < r; ell++)
	135	{ for(j = 0; j < n; j++)
	136	x2[ r * j + ell ] = 0.0;
	137	}
	138	y2 = f.<a href="forward.xml" target="_top">Forward</a>(2, r, x2);
	139	ok &= y2.size() == r*m;
	140	//
	141	// Y_0 (t) = F[X_0(t)]
	142	// = (1 + 1t)(2 + 2t)(3 + 3t)
	143	double y_1_0 = 1.2.3. + 2.1.3. + 3.1.2.;
	144	double y_2_0 = 1.2.3. + 2.1.3. + 3.1.2.;
	145	//
	146	// Y_1 (t) = F[X_1(t)]
	147	// = (1 + 2t)(2 + 3t)(3 + 4t)
	148	double y_1_1 = 2.2.3. + 3.1.3. + 4.1.2.;
	149	double y_2_1 = 1.3.4. + 2.2.4. + 3.2.3.;
	150	//
	151	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y1[0] , y_1_0, eps, eps);
	152	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y1[1] , y_1_1, eps, eps);
	153	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y2[0] , y_2_0, eps, eps);
	154	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y2[1] , y_2_1, eps, eps);
	155	//
	156	// check number of orders
	157	ok &= f.size_order() == 3;
	158	//
	159	// check number of directions
	160	ok &= f.size_direction() == 2;
	161	//
	162	return ok;
	163	}
	164	</pre>
	165
	166	</font></code>
	167
	168
	169	<hr/>Input File: example/forward_dir.cpp
	170
	171	</body>
	172	</html>

+977

-0

doc/forward_dir.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Multiple Directions Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Multiple Directions Forward Mode"/>
	8	<meta name="keywords" id="keywords" content=" multiple directions forward mode direction syntax purpose notation n m f q r xq zero order non-zero lower orders x(t) y(t) yq vector example "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_forward_dir_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="forward_order.cpp.xml" target="_top">Prev</a>
	25	</td><td><a href="forward_dir.cpp.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>forward_dir</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>ADFun-></option>
	49	<option>Independent</option>
	50	<option>FunConstruct</option>
	51	<option>Dependent</option>
	52	<option>abort_recording</option>
	53	<option>seq_property</option>
	54	<option>FunEval</option>
	55	<option>Drivers</option>
	56	<option>FunCheck</option>
	57	<option>optimize</option>
	58	<option>check_for_nan</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>FunEval-></option>
	64	<option>Forward</option>
	65	<option>Reverse</option>
	66	<option>Sparse</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>Forward-></option>
	72	<option>forward_zero</option>
	73	<option>forward_one</option>
	74	<option>forward_two</option>
	75	<option>forward_order</option>
	76	<option>forward_dir</option>
	77	<option>size_order</option>
	78	<option>CompareChange</option>
	79	<option>capacity_order</option>
	80	<option>number_skip</option>
	81	</select>
	82	</td>
	83	<td>
	84	<select onchange='choose_down0(this)'>
	85	<option>forward_dir-></option>
	86	<option>forward_dir.cpp</option>
	87	</select>
	88	</td>
	89	<td>
	90	<select onchange='choose_current0(this)'>
	91	<option>Headings-></option>
	92	<option>Syntax</option>
	93	<option>Purpose</option>
	94	<option>Notation</option>
	95	<option>---..n</option>
	96	<option>---..m</option>
	97	<option>f</option>
	98	<option>q</option>
	99	<option>r</option>
	100	<option>xq</option>
	101	<option>Zero Order</option>
	102	<option>Non-Zero Lower Orders</option>
	103	<option>X(t)</option>
	104	<option>Y(t)</option>
	105	<option>yq</option>
	106	<option>Vector</option>
	107	<option>Example</option>
	108	</select>
	109	</td>
	110	</tr></table><br/>
	111
	112
	113
	114	<center><b><big><big>Multiple Directions Forward Mode</big></big></b></center>
	115	<br/>
	116	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
	117
	118	<br/>
	119
	120	<code><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>) <br/>
	121	</span></font></code>
	122	<br/>
	123	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	124	<br/>
	125	We use
	126	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	127	<mi mathvariant='italic'>F</mi>
	128	<mo stretchy="false">:</mo>
	129	<msup><mi mathvariant='italic'>B</mi>
	130	<mi mathvariant='italic'>n</mi>
	131	</msup>
	132	<mo stretchy="false">→</mo>
	133	<msup><mi mathvariant='italic'>B</mi>
	134	<mi mathvariant='italic'>m</mi>
	135	</msup>
	136	</mrow></math>
	137
	138	to denote the
	139	<a href="glossary.xml#AD Function" target="_top"><span style='white-space: nowrap'>AD function</span></a>
	140	corresponding to
	141	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	142	.
	143	Given a function
	144	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	145	<mi mathvariant='italic'>X</mi>
	146	<mo stretchy="false">:</mo>
	147	<mi mathvariant='italic'>B</mi>
	148	<mo stretchy="false">→</mo>
	149	<msup><mi mathvariant='italic'>B</mi>
	150	<mi mathvariant='italic'>n</mi>
	151	</msup>
	152	</mrow></math>
	153
	154	,
	155	defined by its
	156	<a href="glossary.xml#Taylor Coefficient" target="_top"><span style='white-space: nowrap'>Taylor coefficients</span></a>
	157	,
	158	forward mode computes the Taylor coefficients for the function
	159
	160	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	161	<mi mathvariant='italic'>Y</mi>
	162	<mo stretchy="false">(</mo>
	163	<mi mathvariant='italic'>t</mi>
	164	<mo stretchy="false">)</mo>
	165	<mo stretchy="false">=</mo>
	166	<mi mathvariant='italic'>F</mi>
	167	<mo stretchy="false">[</mo>
	168	<mi mathvariant='italic'>X</mi>
	169	<mo stretchy="false">(</mo>
	170	<mi mathvariant='italic'>t</mi>
	171	<mo stretchy="false">)</mo>
	172	<mo stretchy="false">]</mo>
	173	</mrow></math>
	174
	175	<br/>
	176	<b><big><a name="Notation" id="Notation">Notation</a></big></b>
	177
	178
	179	<br/>
	180	<br/>
	181	<b><a name="Notation.n" id="Notation.n">n</a></b>
	182	<br/>
	183	We use
	184	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	185	to denote the dimension of the
	186	<a href="seq_property.xml#Domain" target="_top"><span style='white-space: nowrap'>domain</span></a>
	187	space for
	188	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	189	.
	190
	191	<br/>
	192	<br/>
	193	<b><a name="Notation.m" id="Notation.m">m</a></b>
	194	<br/>
	195	We use
	196	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
	197	to denote the dimension of the
	198	<a href="seq_property.xml#Range" target="_top"><span style='white-space: nowrap'>range</span></a>
	199	space for
	200	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	201	.
	202
	203	<br/>
	204	<br/>
	205	<b><big><a name="f" id="f">f</a></big></b>
	206	<br/>
	207	The <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
	208	object
	209	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	210	has prototype
	211
	212	<code><font color="blue"><span style='white-space: nowrap'><br/>
	213	ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	214	</span></font></code>
	215	Note that the <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
	216	object
	217	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	218	is not <code><font color="blue">const</font></code>.
	219	After this call we will have
	220
	221	<code><font color="blue"><span style='white-space: nowrap'><br/>
	222	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()     == </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> + 1<br/>
	223	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_direction() == </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	224	</span></font></code>
	225	<br/>
	226	<b><big><a name="q" id="q">q</a></big></b>
	227	<br/>
	228	This argument has prototype
	229
	230	<code><font color="blue"><span style='white-space: nowrap'><br/>
	231	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	232	</span></font></code>
	233	It specifies the order of Taylor Coefficient that we are calculating
	234	and must be greater than zero.
	235	The zero order coefficients can only have one direction computed
	236	and stored in
	237	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	238	so use <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
	239
	240	to compute the zero order coefficients.
	241
	242	<br/>
	243	<br/>
	244	<b><big><a name="r" id="r">r</a></big></b>
	245	<br/>
	246	This argument has prototype
	247
	248	<code><font color="blue"><span style='white-space: nowrap'><br/>
	249	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	250	</span></font></code>
	251	It specifies the number of directions that are computed together.
	252	If (
	253	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'> == 1</span></font></code>
	254	), you are only using one direction and
	255	<a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward_order</span></a>
	256	is simpler, and should be faster,
	257	than this more general case.
	258
	259	<br/>
	260	<br/>
	261	<b><big><a name="xq" id="xq">xq</a></big></b>
	262	<br/>
	263	The argument
	264	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i></code>
	265	has prototype
	266
	267	<code><font color="blue"><span style='white-space: nowrap'><br/>
	268	const </span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'>& </span></font><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	269	</span></font></code>
	270	and its size must be
	271	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i><font color="blue"><span style='white-space: nowrap'>*</span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i></code>
	272
	273	(see <a href="forward_dir.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
	274	below).
	275	For
	276	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	277	<mo stretchy="false">ℓ</mo>
	278	<mo stretchy="false">=</mo>
	279	<mn>0</mn>
	280	<mo stretchy="false">,</mo>
	281	<mo stretchy="false">…</mo>
	282	<mo stretchy="false">,</mo>
	283	<mi mathvariant='italic'>r</mi>
	284	<mn>-1</mn>
	285	</mrow></math>
	286
	287	,
	288
	289	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	290	<mi mathvariant='italic'>j</mi>
	291	<mo stretchy="false">=</mo>
	292	<mn>0</mn>
	293	<mo stretchy="false">,</mo>
	294	<mo stretchy="false">…</mo>
	295	<mo stretchy="false">,</mo>
	296	<mi mathvariant='italic'>n</mi>
	297	<mn>-1</mn>
	298	</mrow></math>
	299
	300	,
	301	the <code><i>j</i></code>-th component of the <code><i>q</i></code>-th order Taylor coefficient
	302	for
	303	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	304	<msub><mi mathvariant='italic'>X</mi>
	305	<mo stretchy="false">ℓ</mo>
	306	</msub>
	307	<mo stretchy="false">(</mo>
	308	<mi mathvariant='italic'>t</mi>
	309	<mo stretchy="false">)</mo>
	310	</mrow></math>
	311
	312	is defined by
	313	<code><span style='white-space: nowrap'><br/>
	314	</span></code>
	315	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	316	<msubsup><mi mathvariant='italic'>x</mi>
	317	<mi mathvariant='italic'>j</mi>
	318	<mrow><mo stretchy="false">(</mo>
	319	<mi mathvariant='italic'>q</mi>
	320	<mo stretchy="false">)</mo>
	321	<mo stretchy="false">,</mo>
	322	<mo stretchy="false">ℓ</mo>
	323	</mrow>
	324	</msubsup>
	325	<mo stretchy="false">=</mo>
	326	</mrow></math>
	327
	328
	329	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>[ </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>j</span></font></i><font color="blue"><span style='white-space: nowrap'> + </span></font><i><font color="black"><span style='white-space: nowrap'>ell</span></font></i><font color="blue"><span style='white-space: nowrap'> ]</span></font></code>
	330
	331
	332	<br/>
	333	<br/>
	334	<b><big><a name="Zero Order" id="Zero Order">Zero Order</a></big></b>
	335	<br/>
	336	For
	337	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	338	<mi mathvariant='italic'>j</mi>
	339	<mo stretchy="false">=</mo>
	340	<mn>0</mn>
	341	<mo stretchy="false">,</mo>
	342	<mo stretchy="false">…</mo>
	343	<mo stretchy="false">,</mo>
	344	<mi mathvariant='italic'>n</mi>
	345	<mn>-1</mn>
	346	</mrow></math>
	347
	348	,
	349	the <code><i>j</i></code>-th component of the zero order Taylor coefficient
	350	for
	351	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	352	<msub><mi mathvariant='italic'>X</mi>
	353	<mo stretchy="false">ℓ</mo>
	354	</msub>
	355	<mo stretchy="false">(</mo>
	356	<mi mathvariant='italic'>t</mi>
	357	<mo stretchy="false">)</mo>
	358	</mrow></math>
	359
	360	is defined by
	361	<code><span style='white-space: nowrap'><br/>
	362	</span></code>
	363	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	364	<msubsup><mi mathvariant='italic'>x</mi>
	365	<mi mathvariant='italic'>j</mi>
	366	<mrow><mo stretchy="false">(</mo>
	367	<mn>0</mn>
	368	<mo stretchy="false">)</mo>
	369	</mrow>
	370	</msubsup>
	371	<mo stretchy="false">=</mo>
	372	</mrow></math>
	373
	374
	375	<code><i><font color="black"><span style='white-space: nowrap'>xk</span></font></i><font color="blue"><span style='white-space: nowrap'>[ </span></font><i><font color="black"><span style='white-space: nowrap'>j</span></font></i><font color="blue"><span style='white-space: nowrap'> ]</span></font></code>
	376
	377	where
	378	<code><i><font color="black"><span style='white-space: nowrap'>xk</span></font></i></code>
	379	corresponds to the previous call
	380
	381	<code><font color="blue"><span style='white-space: nowrap'><br/>
	382	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>xk</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	383	</span></font></code>
	384	with
	385	<code><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'> = 0</span></font></code>
	386	.
	387
	388	<br/>
	389	<br/>
	390	<b><big><a name="Non-Zero Lower Orders" id="Non-Zero Lower Orders">Non-Zero Lower Orders</a></big></b>
	391	<br/>
	392	For
	393	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	394	<mo stretchy="false">ℓ</mo>
	395	<mo stretchy="false">=</mo>
	396	<mn>0</mn>
	397	<mo stretchy="false">,</mo>
	398	<mo stretchy="false">…</mo>
	399	<mo stretchy="false">,</mo>
	400	<mi mathvariant='italic'>r</mi>
	401	<mn>-1</mn>
	402	</mrow></math>
	403
	404	,
	405
	406	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	407	<mi mathvariant='italic'>j</mi>
	408	<mo stretchy="false">=</mo>
	409	<mn>0</mn>
	410	<mo stretchy="false">,</mo>
	411	<mo stretchy="false">…</mo>
	412	<mo stretchy="false">,</mo>
	413	<mi mathvariant='italic'>n</mi>
	414	<mn>-1</mn>
	415	</mrow></math>
	416
	417	,
	418
	419	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	420	<mi mathvariant='italic'>k</mi>
	421	<mo stretchy="false">=</mo>
	422	<mn>1</mn>
	423	<mo stretchy="false">,</mo>
	424	<mo stretchy="false">…</mo>
	425	<mo stretchy="false">,</mo>
	426	<mi mathvariant='italic'>q</mi>
	427	<mn>-1</mn>
	428	</mrow></math>
	429
	430	,
	431	the <code><i>j</i></code>-th component of the <code><i>k</i></code>-th order Taylor coefficient
	432	for
	433	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	434	<msub><mi mathvariant='italic'>X</mi>
	435	<mo stretchy="false">ℓ</mo>
	436	</msub>
	437	<mo stretchy="false">(</mo>
	438	<mi mathvariant='italic'>t</mi>
	439	<mo stretchy="false">)</mo>
	440	</mrow></math>
	441
	442	is defined by
	443	<code><span style='white-space: nowrap'><br/>
	444	</span></code>
	445	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	446	<msubsup><mi mathvariant='italic'>x</mi>
	447	<mi mathvariant='italic'>j</mi>
	448	<mrow><mo stretchy="false">(</mo>
	449	<mi mathvariant='italic'>k</mi>
	450	<mo stretchy="false">)</mo>
	451	<mo stretchy="false">,</mo>
	452	<mo stretchy="false">ℓ</mo>
	453	</mrow>
	454	</msubsup>
	455	<mo stretchy="false">=</mo>
	456	</mrow></math>
	457
	458
	459	<code><i><font color="black"><span style='white-space: nowrap'>xk</span></font></i><font color="blue"><span style='white-space: nowrap'>[ </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>j</span></font></i><font color="blue"><span style='white-space: nowrap'> + </span></font><i><font color="black"><span style='white-space: nowrap'>ell</span></font></i><font color="blue"><span style='white-space: nowrap'> ]</span></font></code>
	460
	461	where
	462	<code><i><font color="black"><span style='white-space: nowrap'>xk</span></font></i></code>
	463	corresponds to the previous call
	464
	465	<code><font color="blue"><span style='white-space: nowrap'><br/>
	466	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>xk</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	467	</span></font></code>
	468	Note that
	469	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i></code>
	470	must have the same value in this previous call.
	471
	472	<br/>
	473	<br/>
	474	<b><big><a name="X(t)" id="X(t)">X(t)</a></big></b>
	475	<br/>
	476	For
	477	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	478	<mo stretchy="false">ℓ</mo>
	479	<mo stretchy="false">=</mo>
	480	<mn>0</mn>
	481	<mo stretchy="false">,</mo>
	482	<mo stretchy="false">…</mo>
	483	<mo stretchy="false">,</mo>
	484	<mi mathvariant='italic'>r</mi>
	485	<mn>-1</mn>
	486	</mrow></math>
	487
	488	, the function
	489
	490	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	491	<msub><mi mathvariant='italic'>X</mi>
	492	<mo stretchy="false">ℓ</mo>
	493	</msub>
	494	<mo stretchy="false">:</mo>
	495	<mi mathvariant='italic'>B</mi>
	496	<mo stretchy="false">→</mo>
	497	<msup><mi mathvariant='italic'>B</mi>
	498	<mi mathvariant='italic'>n</mi>
	499	</msup>
	500	</mrow></math>
	501
	502	is defined using
	503	the Taylor coefficients
	504	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	505	<msup><mi mathvariant='italic'>x</mi>
	506	<mrow><mo stretchy="false">(</mo>
	507	<mi mathvariant='italic'>k</mi>
	508	<mo stretchy="false">)</mo>
	509	<mo stretchy="false">,</mo>
	510	<mo stretchy="false">ℓ</mo>
	511	</mrow>
	512	</msup>
	513	<mo stretchy="false">∈</mo>
	514	<msup><mi mathvariant='italic'>B</mi>
	515	<mi mathvariant='italic'>n</mi>
	516	</msup>
	517	</mrow></math>
	518
	519	:
	520
	521	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	522	<msub><mi mathvariant='italic'>X</mi>
	523	<mo stretchy="false">ℓ</mo>
	524	</msub>
	525	<mo stretchy="false">(</mo>
	526	<mi mathvariant='italic'>t</mi>
	527	<mo stretchy="false">)</mo>
	528	<mo stretchy="false">=</mo>
	529	<msup><mi mathvariant='italic'>x</mi>
	530	<mrow><mo stretchy="false">(</mo>
	531	<mn>0</mn>
	532	<mo stretchy="false">)</mo>
	533	</mrow>
	534	</msup>
	535	<mo stretchy="false">+</mo>
	536	<msup><mi mathvariant='italic'>x</mi>
	537	<mrow><mo stretchy="false">(</mo>
	538	<mn>1</mn>
	539	<mo stretchy="false">)</mo>
	540	<mo stretchy="false">,</mo>
	541	<mo stretchy="false">ℓ</mo>
	542	</mrow>
	543	</msup>
	544	<mo stretchy="false">*</mo>
	545	<msup><mi mathvariant='italic'>t</mi>
	546	<mn>1</mn>
	547	</msup>
	548	<mo stretchy="false">+</mo>
	549	<mo stretchy="false">⋯</mo>
	550	<mo stretchy="false">+</mo>
	551	<msup><mi mathvariant='italic'>x</mi>
	552	<mrow><mo stretchy="false">(</mo>
	553	<mi mathvariant='italic'>q</mi>
	554	<mo stretchy="false">)</mo>
	555	<mo stretchy="false">,</mo>
	556	<mo stretchy="false">ℓ</mo>
	557	</mrow>
	558	</msup>
	559	<msup><mi mathvariant='italic'>t</mi>
	560	<mi mathvariant='italic'>q</mi>
	561	</msup>
	562	</mrow></math>
	563
	564	Note that the <code><i>k</i></code>-th derivative of
	565	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	566	<msub><mi mathvariant='italic'>X</mi>
	567	<mo stretchy="false">ℓ</mo>
	568	</msub>
	569	<mo stretchy="false">(</mo>
	570	<mi mathvariant='italic'>t</mi>
	571	<mo stretchy="false">)</mo>
	572	</mrow></math>
	573
	574	is related to
	575	its Taylor coefficients by
	576
	577	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	578	<mtable rowalign="center" ><mtr><mtd columnalign="right" >
	579	<msup><mi mathvariant='italic'>x</mi>
	580	<mrow><mo stretchy="false">(</mo>
	581	<mn>0</mn>
	582	<mo stretchy="false">)</mo>
	583	</mrow>
	584	</msup>
	585	</mtd><mtd columnalign="center" >
	586	<mo stretchy="false">=</mo>
	587	</mtd><mtd columnalign="left" >
	588	<msub><mi mathvariant='italic'>X</mi>
	589	<mo stretchy="false">ℓ</mo>
	590	</msub>
	591	<mo stretchy="false">(</mo>
	592	<mn>0</mn>
	593	<mo stretchy="false">)</mo>
	594	</mtd></mtr><mtr><mtd columnalign="right" >
	595	<msup><mi mathvariant='italic'>x</mi>
	596	<mrow><mo stretchy="false">(</mo>
	597	<mi mathvariant='italic'>k</mi>
	598	<mo stretchy="false">)</mo>
	599	<mo stretchy="false">,</mo>
	600	<mo stretchy="false">ℓ</mo>
	601	</mrow>
	602	</msup>
	603	</mtd><mtd columnalign="center" >
	604	<mo stretchy="false">=</mo>
	605	</mtd><mtd columnalign="left" >
	606	<mfrac><mrow><mn>1</mn>
	607	</mrow>
	608	<mrow><mi mathvariant='italic'>k</mi>
	609	<mo stretchy="false">!</mo>
	610	</mrow>
	611	</mfrac>
	612	<msubsup><mi mathvariant='italic'>X</mi>
	613	<mo stretchy="false">ℓ</mo>
	614	<mrow><mo stretchy="false">(</mo>
	615	<mi mathvariant='italic'>k</mi>
	616	<mo stretchy="false">)</mo>
	617	</mrow>
	618	</msubsup>
	619	<mo stretchy="false">(</mo>
	620	<mn>0</mn>
	621	<mo stretchy="false">)</mo>
	622	</mtd></mtr></mtable>
	623	</mrow></math>
	624
	625	for
	626	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	627	<mi mathvariant='italic'>k</mi>
	628	<mo stretchy="false">=</mo>
	629	<mn>1</mn>
	630	<mo stretchy="false">,</mo>
	631	<mo stretchy="false">…</mo>
	632	<mo stretchy="false">,</mo>
	633	<mi mathvariant='italic'>q</mi>
	634	</mrow></math>
	635
	636	.
	637
	638	<br/>
	639	<br/>
	640	<b><big><a name="Y(t)" id="Y(t)">Y(t)</a></big></b>
	641	<br/>
	642	For
	643	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	644	<mo stretchy="false">ℓ</mo>
	645	<mo stretchy="false">=</mo>
	646	<mn>0</mn>
	647	<mo stretchy="false">,</mo>
	648	<mo stretchy="false">…</mo>
	649	<mo stretchy="false">,</mo>
	650	<mi mathvariant='italic'>r</mi>
	651	<mn>-1</mn>
	652	</mrow></math>
	653
	654	, the function
	655
	656	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	657	<msub><mi mathvariant='italic'>Y</mi>
	658	<mo stretchy="false">ℓ</mo>
	659	</msub>
	660	<mo stretchy="false">:</mo>
	661	<mi mathvariant='italic'>B</mi>
	662	<mo stretchy="false">→</mo>
	663	<msup><mi mathvariant='italic'>B</mi>
	664	<mi mathvariant='italic'>m</mi>
	665	</msup>
	666	</mrow></math>
	667
	668	is defined by
	669
	670	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	671	<msub><mi mathvariant='italic'>Y</mi>
	672	<mo stretchy="false">ℓ</mo>
	673	</msub>
	674	<mo stretchy="false">(</mo>
	675	<mi mathvariant='italic'>t</mi>
	676	<mo stretchy="false">)</mo>
	677	<mo stretchy="false">=</mo>
	678	<mi mathvariant='italic'>F</mi>
	679	<mo stretchy="false">[</mo>
	680	<msub><mi mathvariant='italic'>X</mi>
	681	<mo stretchy="false">ℓ</mo>
	682	</msub>
	683	<mo stretchy="false">(</mo>
	684	<mi mathvariant='italic'>t</mi>
	685	<mo stretchy="false">)</mo>
	686	<mo stretchy="false">]</mo>
	687	</mrow></math>
	688
	689	.
	690	We use
	691	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	692	<msup><mi mathvariant='italic'>y</mi>
	693	<mrow><mo stretchy="false">(</mo>
	694	<mn>0</mn>
	695	<mo stretchy="false">)</mo>
	696	</mrow>
	697	</msup>
	698	</mrow></math>
	699
	700	for the zero order coefficient
	701	and
	702	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	703	<msup><mi mathvariant='italic'>y</mi>
	704	<mrow><mo stretchy="false">(</mo>
	705	<mi mathvariant='italic'>k</mi>
	706	<mo stretchy="false">)</mo>
	707	<mo stretchy="false">,</mo>
	708	<mo stretchy="false">ℓ</mo>
	709	</mrow>
	710	</msup>
	711	<mo stretchy="false">∈</mo>
	712	<msup><mi mathvariant='italic'>B</mi>
	713	<mi mathvariant='italic'>m</mi>
	714	</msup>
	715	</mrow></math>
	716
	717	to denote the
	718	hight order coefficients; i.e.,
	719
	720	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	721	<msub><mi mathvariant='italic'>Y</mi>
	722	<mo stretchy="false">ℓ</mo>
	723	</msub>
	724	<mo stretchy="false">(</mo>
	725	<mi mathvariant='italic'>t</mi>
	726	<mo stretchy="false">)</mo>
	727	<mo stretchy="false">=</mo>
	728	<msup><mi mathvariant='italic'>y</mi>
	729	<mrow><mo stretchy="false">(</mo>
	730	<mn>0</mn>
	731	<mo stretchy="false">)</mo>
	732	</mrow>
	733	</msup>
	734	<mo stretchy="false">+</mo>
	735	<msup><mi mathvariant='italic'>y</mi>
	736	<mrow><mo stretchy="false">(</mo>
	737	<mn>1</mn>
	738	<mo stretchy="false">)</mo>
	739	<mo stretchy="false">,</mo>
	740	<mo stretchy="false">ℓ</mo>
	741	</mrow>
	742	</msup>
	743	<mo stretchy="false">*</mo>
	744	<msup><mi mathvariant='italic'>t</mi>
	745	<mn>1</mn>
	746	</msup>
	747	<mo stretchy="false">+</mo>
	748	<mo stretchy="false">⋯</mo>
	749	<mo stretchy="false">+</mo>
	750	<msup><mi mathvariant='italic'>y</mi>
	751	<mrow><mo stretchy="false">(</mo>
	752	<mi mathvariant='italic'>q</mi>
	753	<mo stretchy="false">)</mo>
	754	<mo stretchy="false">,</mo>
	755	<mo stretchy="false">ℓ</mo>
	756	</mrow>
	757	</msup>
	758	<mo stretchy="false">*</mo>
	759	<msup><mi mathvariant='italic'>t</mi>
	760	<mi mathvariant='italic'>q</mi>
	761	</msup>
	762	<mo stretchy="false">+</mo>
	763	<mi mathvariant='italic'>o</mi>
	764	<mo stretchy="false">(</mo>
	765	<msup><mi mathvariant='italic'>t</mi>
	766	<mi mathvariant='italic'>q</mi>
	767	</msup>
	768	<mo stretchy="false">)</mo>
	769	</mrow></math>
	770
	771	where
	772	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	773	<mi mathvariant='italic'>o</mi>
	774	<mo stretchy="false">(</mo>
	775	<msup><mi mathvariant='italic'>t</mi>
	776	<mi mathvariant='italic'>q</mi>
	777	</msup>
	778	<mo stretchy="false">)</mo>
	779	<mo stretchy="false">*</mo>
	780	<msup><mi mathvariant='italic'>t</mi>
	781	<mrow><mo stretchy="false">-</mo>
	782	<mi mathvariant='italic'>q</mi>
	783	</mrow>
	784	</msup>
	785	<mo stretchy="false">→</mo>
	786	<mn>0</mn>
	787	</mrow></math>
	788
	789	as
	790	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	791	<mi mathvariant='italic'>t</mi>
	792	<mo stretchy="false">→</mo>
	793	<mn>0</mn>
	794	</mrow></math>
	795
	796	.
	797	Note that the <code><i>k</i></code>-th derivative of
	798	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	799	<msub><mi mathvariant='italic'>Y</mi>
	800	<mo stretchy="false">ℓ</mo>
	801	</msub>
	802	<mo stretchy="false">(</mo>
	803	<mi mathvariant='italic'>t</mi>
	804	<mo stretchy="false">)</mo>
	805	</mrow></math>
	806
	807	is related to
	808	its Taylor coefficients by
	809
	810	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	811	<mtable rowalign="center" ><mtr><mtd columnalign="right" >
	812	<msup><mi mathvariant='italic'>y</mi>
	813	<mrow><mo stretchy="false">(</mo>
	814	<mn>0</mn>
	815	<mo stretchy="false">)</mo>
	816	</mrow>
	817	</msup>
	818	</mtd><mtd columnalign="center" >
	819	<mo stretchy="false">=</mo>
	820	</mtd><mtd columnalign="left" >
	821	<msub><mi mathvariant='italic'>Y</mi>
	822	<mo stretchy="false">ℓ</mo>
	823	</msub>
	824	<mo stretchy="false">(</mo>
	825	<mn>0</mn>
	826	<mo stretchy="false">)</mo>
	827	</mtd></mtr><mtr><mtd columnalign="right" >
	828	<msup><mi mathvariant='italic'>y</mi>
	829	<mrow><mo stretchy="false">(</mo>
	830	<mi mathvariant='italic'>k</mi>
	831	<mo stretchy="false">)</mo>
	832	<mo stretchy="false">,</mo>
	833	<mo stretchy="false">ℓ</mo>
	834	</mrow>
	835	</msup>
	836	</mtd><mtd columnalign="center" >
	837	<mo stretchy="false">=</mo>
	838	</mtd><mtd columnalign="left" >
	839	<mfrac><mrow><mn>1</mn>
	840	</mrow>
	841	<mrow><mi mathvariant='italic'>k</mi>
	842	<mo stretchy="false">!</mo>
	843	</mrow>
	844	</mfrac>
	845	<msubsup><mi mathvariant='italic'>Y</mi>
	846	<mo stretchy="false">ℓ</mo>
	847	<mrow><mo stretchy="false">(</mo>
	848	<mi mathvariant='italic'>k</mi>
	849	<mo stretchy="false">)</mo>
	850	</mrow>
	851	</msubsup>
	852	<mo stretchy="false">(</mo>
	853	<mn>0</mn>
	854	<mo stretchy="false">)</mo>
	855	</mtd></mtr></mtable>
	856	</mrow></math>
	857
	858	for
	859	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	860	<mi mathvariant='italic'>k</mi>
	861	<mo stretchy="false">=</mo>
	862	<mn>1</mn>
	863	<mo stretchy="false">,</mo>
	864	<mo stretchy="false">…</mo>
	865	<mo stretchy="false">,</mo>
	866	<mi mathvariant='italic'>q</mi>
	867	</mrow></math>
	868
	869	.
	870
	871	<br/>
	872	<br/>
	873	<b><big><a name="yq" id="yq">yq</a></big></b>
	874	<br/>
	875	The argument
	876	<code><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i></code>
	877	has prototype
	878
	879	<code><font color="blue"><span style='white-space: nowrap'><br/>
	880	</span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	881	</span></font></code>
	882	and its size is
	883	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'>*</span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i></code>
	884
	885	(see <a href="forward_dir.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
	886	below).
	887	For
	888	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	889	<mo stretchy="false">ℓ</mo>
	890	<mo stretchy="false">=</mo>
	891	<mn>0</mn>
	892	<mo stretchy="false">,</mo>
	893	<mo stretchy="false">…</mo>
	894	<mo stretchy="false">,</mo>
	895	<mi mathvariant='italic'>r</mi>
	896	<mn>-1</mn>
	897	</mrow></math>
	898
	899	,
	900
	901	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	902	<mi mathvariant='italic'>i</mi>
	903	<mo stretchy="false">=</mo>
	904	<mn>0</mn>
	905	<mo stretchy="false">,</mo>
	906	<mo stretchy="false">…</mo>
	907	<mo stretchy="false">,</mo>
	908	<mi mathvariant='italic'>m</mi>
	909	<mn>-1</mn>
	910	</mrow></math>
	911
	912	,
	913	the <code><i>i</i></code>-th component of the <code><i>q</i></code>-th order Taylor coefficient
	914	for
	915	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	916	<msub><mi mathvariant='italic'>Y</mi>
	917	<mo stretchy="false">ℓ</mo>
	918	</msub>
	919	<mo stretchy="false">(</mo>
	920	<mi mathvariant='italic'>t</mi>
	921	<mo stretchy="false">)</mo>
	922	</mrow></math>
	923
	924	is given by
	925	<code><span style='white-space: nowrap'><br/>
	926	</span></code>
	927	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	928	<msubsup><mi mathvariant='italic'>y</mi>
	929	<mi mathvariant='italic'>i</mi>
	930	<mrow><mo stretchy="false">(</mo>
	931	<mi mathvariant='italic'>q</mi>
	932	<mo stretchy="false">)</mo>
	933	<mo stretchy="false">,</mo>
	934	<mo stretchy="false">ℓ</mo>
	935	</mrow>
	936	</msubsup>
	937	<mo stretchy="false">=</mo>
	938	</mrow></math>
	939
	940
	941	<code><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i><font color="blue"><span style='white-space: nowrap'>[ </span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'> + </span></font><i><font color="black"><span style='white-space: nowrap'>ell</span></font></i><font color="blue"><span style='white-space: nowrap'> ]</span></font></code>
	942
	943
	944	<br/>
	945	<br/>
	946	<b><big><a name="Vector" id="Vector">Vector</a></big></b>
	947	<br/>
	948	The type
	949	<code><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i></code>
	950	must be a <a href="simplevector.xml" target="_top"><span style='white-space: nowrap'>SimpleVector</span></a>
	951	class with
	952	<a href="simplevector.xml#Elements of Specified Type" target="_top"><span style='white-space: nowrap'>elements of type</span></a>
	953
	954
	955	<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
	956	.
	957	The routine <a href="checksimplevector.xml" target="_top"><span style='white-space: nowrap'>CheckSimpleVector</span></a>
	958	will generate an error message
	959	if this is not the case.
	960
	961
	962	<br/>
	963	<br/>
	964	<b><big><a name="Example" id="Example">Example</a></big></b>
	965	<br/>
	966	The file
	967	<a href="forward_dir.cpp.xml" target="_top"><span style='white-space: nowrap'>forward_dir.cpp</span></a>
	968
	969	contains an example and test using one order (multiple orders).
	970	They return true if they succeed and false otherwise.
	971
	972
	973	<hr/>Input File: omh/forward/forward_dir.omh
	974
	975	</body>
	976	</html>

-155

~~doc/forward_mul.cpp.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>Forward Mode: Example and Test of Multiple Orders</title>
6		<meta name="description" id="description" content="Forward Mode: Example and Test of Multiple Orders"/>
7		<meta name="keywords" id="keywords" content=" forward multiple orders order "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_forward_mul.cpp_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td><a href="forward.cpp.xml" target="_top">Prev</a>
24		</td><td><a href="reverse.xml" target="_top">Next</a>
25		</td><td>
26		<select onchange='choose_across0(this)'>
27		<option>Index-></option>
28		<option>contents</option>
29		<option>reference</option>
30		<option>index</option>
31		<option>search</option>
32		<option>external</option>
33		</select>
34		</td>
35		<td>
36		<select onchange='choose_up0(this)'>
37		<option>Up-></option>
38		<option>CppAD</option>
39		<option>ADFun</option>
40		<option>FunEval</option>
41		<option>Forward</option>
42		<option>forward_mul.cpp</option>
43		</select>
44		</td>
45		<td>
46		<select onchange='choose_down3(this)'>
47		<option>ADFun-></option>
48		<option>Independent</option>
49		<option>FunConstruct</option>
50		<option>Dependent</option>
51		<option>abort_recording</option>
52		<option>seq_property</option>
53		<option>FunEval</option>
54		<option>Drivers</option>
55		<option>FunCheck</option>
56		<option>optimize</option>
57		<option>check_for_nan</option>
58		</select>
59		</td>
60		<td>
61		<select onchange='choose_down2(this)'>
62		<option>FunEval-></option>
63		<option>Forward</option>
64		<option>Reverse</option>
65		<option>Sparse</option>
66		</select>
67		</td>
68		<td>
69		<select onchange='choose_down1(this)'>
70		<option>Forward-></option>
71		<option>ForwardZero</option>
72		<option>ForwardOne</option>
73		<option>ForwardAny</option>
74		<option>size_taylor</option>
75		<option>CompareChange</option>
76		<option>capacity_taylor</option>
77		<option>number_skip</option>
78		<option>forward.cpp</option>
79		<option>forward_mul.cpp</option>
80		</select>
81		</td>
82		<td>forward_mul.cpp</td>
83		<td>Headings</td>
84		</tr></table><br/>
85
86
87
88		<center><b><big><big>Forward Mode: Example and Test of Multiple Orders</big></big></b></center>
89		<code><font color="blue"><pre style='display:inline'>
90		# include <cppad/cppad.hpp>
91		bool forward_mul(void)
92		{ bool ok = true;
93		using CppAD::AD;
94		using CppAD::NearEqual;
95		double eps = 10. * std::numeric_limits<double>::epsilon();
96
97		// domain space vector
98		size_t n = 2;
99		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) X(n);
100		X[0] = 0.;
101		X[1] = 1.;
102
103		// declare independent variables and starting recording
104		CppAD::<a href="independent.xml" target="_top">Independent</a>(X);
105
106		// range space vector
107		size_t m = 1;
108		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) Y(m);
109		Y[0] = X[0] * X[0] * X[1];
110
111		// create f: X -> Y and stop tape recording
112		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(X, Y);
113
114		// initially, the variable values during taping are stored in f
115		ok &= f.size_taylor() == 1;
116
117		// Compute three forward orders at one
118		size_t p = 2, p1 = p+1;
119		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x_p(n * (p+1)), y_p(m * (p+1));
120		x_p[0 * p1 + 0] = 3.; x_p[1 * p1 + 0] = 4.; // order 0
121		x_p[0 * p1 + 1] = 1.; x_p[1 * p1 + 1] = 0.; // order 1
122		x_p[0 * p1 + 2] = 0.; x_p[1 * p1 + 2] = 0.; // order 2
123		// X(t) = x^0 + x^1 * t + x^2 * t^2
124		// = [ 3 + t, 4 ]
125		//
126		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
127		// Y(t) = F[X(t)] = y^0 + y^1 * t + y^2 * t^2 + o(t^3)
128		//
129		// check order zero
130		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x(n);
131		x[0] = x_p[0 * p1 + 0];
132		x[1] = x_p[1 * p1 + 0];
133		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0 * p1 + 0] , x[0]x[0]x[1], eps, eps);
134		//
135		// check order one
136		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0 * p1 + 1] , 2.x[0]x[1], eps, eps);
137		// check order two
138		double F_00 = 2. * y_p[0 * p1 + 2]; // second partial F w.r.t. x[0], x[0]
139		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(F_00, 2.*x[1], eps, eps);
140
141		// check number of orders per variable
142		ok &= f.size_taylor() == 3;
143
144		return ok;
145		}
146		</pre>
147
148		</font></code>
149
150
151		<hr/>Input File: example/forward_mul.cpp
152
153		</body>
154		</html>

+598

-0

doc/forward_one.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>First Order Forward Mode: Derivative Values</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="First Order Forward Mode: Derivative Values"/>
	8	<meta name="keywords" id="keywords" content=" first order forward mode: derivative values Forward one syntax purpose f x0 x1 vector example special case "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_forward_one_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="forward_zero.xml" target="_top">Prev</a>
	25	</td><td><a href="forward_two.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>forward_one</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>ADFun-></option>
	49	<option>Independent</option>
	50	<option>FunConstruct</option>
	51	<option>Dependent</option>
	52	<option>abort_recording</option>
	53	<option>seq_property</option>
	54	<option>FunEval</option>
	55	<option>Drivers</option>
	56	<option>FunCheck</option>
	57	<option>optimize</option>
	58	<option>check_for_nan</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>FunEval-></option>
	64	<option>Forward</option>
	65	<option>Reverse</option>
	66	<option>Sparse</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>Forward-></option>
	72	<option>forward_zero</option>
	73	<option>forward_one</option>
	74	<option>forward_two</option>
	75	<option>forward_order</option>
	76	<option>forward_dir</option>
	77	<option>size_order</option>
	78	<option>CompareChange</option>
	79	<option>capacity_order</option>
	80	<option>number_skip</option>
	81	</select>
	82	</td>
	83	<td>forward_one</td>
	84	<td>
	85	<select onchange='choose_current0(this)'>
	86	<option>Headings-></option>
	87	<option>Syntax</option>
	88	<option>Purpose</option>
	89	<option>f</option>
	90	<option>x0</option>
	91	<option>x1</option>
	92	<option>Vector</option>
	93	<option>Example</option>
	94	<option>Special Case</option>
	95	</select>
	96	</td>
	97	</tr></table><br/>
	98
	99
	100
	101	<center><b><big><big>First Order Forward Mode: Derivative Values</big></big></b></center>
	102	<br/>
	103	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
	104
	105	<br/>
	106
	107	<code><i><font color="black"><span style='white-space: nowrap'>y1</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(1, </span></font><i><font color="black"><span style='white-space: nowrap'>x1</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
	108
	109
	110	<br/>
	111	<br/>
	112	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	113	<br/>
	114	We use
	115	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	116	<mi mathvariant='italic'>F</mi>
	117	<mo stretchy="false">:</mo>
	118	<msup><mi mathvariant='italic'>B</mi>
	119	<mi mathvariant='italic'>n</mi>
	120	</msup>
	121	<mo stretchy="false">→</mo>
	122	<msup><mi mathvariant='italic'>B</mi>
	123	<mi mathvariant='italic'>m</mi>
	124	</msup>
	125	</mrow></math>
	126
	127	to denote the
	128	<a href="glossary.xml#AD Function" target="_top"><span style='white-space: nowrap'>AD function</span></a>
	129	corresponding to
	130	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	131	.
	132	The result of the syntax above is
	133
	134	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	135	<mi mathvariant='italic'>y</mi>
	136	<mn>1</mn>
	137	<mo stretchy="false">=</mo>
	138	<msup><mi mathvariant='italic'>F</mi>
	139	<mrow><mo stretchy="false">(</mo>
	140	<mn>1</mn>
	141	<mo stretchy="false">)</mo>
	142	</mrow>
	143	</msup>
	144	<mo stretchy="false">(</mo>
	145	<mi mathvariant='italic'>x</mi>
	146	<mn>0</mn>
	147	<mo stretchy="false">)</mo>
	148	<mo stretchy="false">*</mo>
	149	<mi mathvariant='italic'>x</mi>
	150	<mn>1</mn>
	151	</mrow></math>
	152
	153	where
	154	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	155	<msup><mi mathvariant='italic'>F</mi>
	156	<mrow><mo stretchy="false">(</mo>
	157	<mn>1</mn>
	158	<mo stretchy="false">)</mo>
	159	</mrow>
	160	</msup>
	161	<mo stretchy="false">(</mo>
	162	<mi mathvariant='italic'>x</mi>
	163	<mn>0</mn>
	164	<mo stretchy="false">)</mo>
	165	</mrow></math>
	166
	167	is the Jacobian of
	168	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	169	<mi mathvariant='italic'>F</mi>
	170	</mrow></math>
	171
	172
	173	evaluated at
	174	<code><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	175	.
	176
	177	<br/>
	178	<br/>
	179	<b><big><a name="f" id="f">f</a></big></b>
	180	<br/>
	181	The object
	182	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	183	has prototype
	184
	185	<code><font color="blue"><span style='white-space: nowrap'><br/>
	186	ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	187	</span></font></code>
	188	Note that the <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
	189	object
	190	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	191	is not <code><font color="blue">const</font></code>.
	192	Before this call to <code><font color="blue">Forward</font></code>, the value returned by
	193
	194	<code><font color="blue"><span style='white-space: nowrap'><br/>
	195	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()<br/>
	196	</span></font></code>
	197	must be greater than or equal one.
	198	After this call it will be will be two (see <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
	199	).
	200
	201	<br/>
	202	<br/>
	203	<b><big><a name="x0" id="x0">x0</a></big></b>
	204	<br/>
	205	The vector
	206	<code><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	207	in the formula
	208
	209	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	210	<mi mathvariant='italic'>y</mi>
	211	<mn>1</mn>
	212	<mo stretchy="false">=</mo>
	213	<msup><mi mathvariant='italic'>F</mi>
	214	<mrow><mo stretchy="false">(</mo>
	215	<mn>1</mn>
	216	<mo stretchy="false">)</mo>
	217	</mrow>
	218	</msup>
	219	<mo stretchy="false">(</mo>
	220	<mi mathvariant='italic'>x</mi>
	221	<mn>0</mn>
	222	<mo stretchy="false">)</mo>
	223	<mo stretchy="false">*</mo>
	224	<mi mathvariant='italic'>x</mi>
	225	<mn>1</mn>
	226	</mrow></math>
	227
	228	corresponds to the previous call to <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
	229
	230	using this ADFun object
	231	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	232	; i.e.,
	233
	234	<code><font color="blue"><span style='white-space: nowrap'><br/>
	235	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(0, </span></font><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	236	</span></font></code>
	237	If there is no previous call with the first argument zero,
	238	the value of the <a href="independent.xml" target="_top"><span style='white-space: nowrap'>independent</span></a>
	239	variables
	240	during the recording of the AD sequence of operations is used
	241	for
	242	<code><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	243	.
	244
	245	<br/>
	246	<br/>
	247	<b><big><a name="x1" id="x1">x1</a></big></b>
	248	<br/>
	249	The argument
	250	<code><i><font color="black"><span style='white-space: nowrap'>x1</span></font></i></code>
	251	has prototype
	252
	253	<code><font color="blue"><span style='white-space: nowrap'><br/>
	254	const </span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'>& </span></font><i><font color="black"><span style='white-space: nowrap'>x1</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	255	</span></font></code>
	256	(see <a href="forward_one.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
	257	below)
	258	and its size must be equal to
	259	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	260	, the dimension of the
	261	<a href="seq_property.xml#Domain" target="_top"><span style='white-space: nowrap'>domain</span></a>
	262	space for
	263	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	264	.
	265
	266	<br/>
	267	<br/>
	268	<b><big><a name="Vector" id="Vector">Vector</a></big></b>
	269	<br/>
	270	The type
	271	<code><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i></code>
	272	must be a <a href="simplevector.xml" target="_top"><span style='white-space: nowrap'>SimpleVector</span></a>
	273	class with
	274	<a href="simplevector.xml#Elements of Specified Type" target="_top"><span style='white-space: nowrap'>elements of type</span></a>
	275
	276
	277	<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
	278	.
	279	The routine <a href="checksimplevector.xml" target="_top"><span style='white-space: nowrap'>CheckSimpleVector</span></a>
	280	will generate an error message
	281	if this is not the case.
	282
	283	<br/>
	284	<br/>
	285	<b><big><a name="Example" id="Example">Example</a></big></b>
	286	<br/>
	287	The file
	288	<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
	289
	290	contains an example and test of this operation.
	291	It returns true if it succeeds and false otherwise.
	292
	293	<br/>
	294	<br/>
	295	<b><big><a name="Special Case" id="Special Case">Special Case</a></big></b>
	296	<br/>
	297	This is special case of <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward_order</span></a>
	298	where
	299
	300	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	301	<mtable rowalign="center" ><mtr><mtd columnalign="right" >
	302	<mi mathvariant='italic'>Y</mi>
	303	<mo stretchy="false">(</mo>
	304	<mi mathvariant='italic'>t</mi>
	305	<mo stretchy="false">)</mo>
	306	</mtd><mtd columnalign="center" >
	307	<mo stretchy="false">=</mo>
	308	</mtd><mtd columnalign="left" >
	309	<mi mathvariant='italic'>F</mi>
	310	<mo stretchy="false">[</mo>
	311	<mi mathvariant='italic'>X</mi>
	312	<mo stretchy="false">(</mo>
	313	<mi mathvariant='italic'>t</mi>
	314	<mo stretchy="false">)</mo>
	315	<mo stretchy="false">]</mo>
	316	</mtd></mtr><mtr><mtd columnalign="right" >
	317	<mi mathvariant='italic'>X</mi>
	318	<mo stretchy="false">(</mo>
	319	<mi mathvariant='italic'>t</mi>
	320	<mo stretchy="false">)</mo>
	321	</mtd><mtd columnalign="center" >
	322	<mo stretchy="false">=</mo>
	323	</mtd><mtd columnalign="left" >
	324	<msup><mi mathvariant='italic'>x</mi>
	325	<mrow><mo stretchy="false">(</mo>
	326	<mn>0</mn>
	327	<mo stretchy="false">)</mo>
	328	</mrow>
	329	</msup>
	330	<msup><mi mathvariant='italic'>t</mi>
	331	<mn>0</mn>
	332	</msup>
	333	<mo stretchy="false">+</mo>
	334	<msup><mi mathvariant='italic'>x</mi>
	335	<mrow><mo stretchy="false">(</mo>
	336	<mn>1</mn>
	337	<mo stretchy="false">)</mo>
	338	</mrow>
	339	</msup>
	340	<mo stretchy="false">*</mo>
	341	<msup><mi mathvariant='italic'>t</mi>
	342	<mn>1</mn>
	343	</msup>
	344	<mo stretchy="false">+</mo>
	345	<mo stretchy="false">⋯</mo>
	346	<mo stretchy="false">,</mo>
	347	<mo stretchy="false">+</mo>
	348	<msup><mi mathvariant='italic'>x</mi>
	349	<mrow><mo stretchy="false">(</mo>
	350	<mi mathvariant='italic'>q</mi>
	351	<mo stretchy="false">)</mo>
	352	</mrow>
	353	</msup>
	354	<mo stretchy="false">*</mo>
	355	<msup><mi mathvariant='italic'>t</mi>
	356	<mi mathvariant='italic'>q</mi>
	357	</msup>
	358	<mo stretchy="false">+</mo>
	359	<mi mathvariant='italic'>o</mi>
	360	<mo stretchy="false">(</mo>
	361	<msup><mi mathvariant='italic'>t</mi>
	362	<mi mathvariant='italic'>q</mi>
	363	</msup>
	364	<mo stretchy="false">)</mo>
	365	</mtd></mtr><mtr><mtd columnalign="right" >
	366	<mi mathvariant='italic'>Y</mi>
	367	<mo stretchy="false">(</mo>
	368	<mi mathvariant='italic'>t</mi>
	369	<mo stretchy="false">)</mo>
	370	</mtd><mtd columnalign="center" >
	371	<mo stretchy="false">=</mo>
	372	</mtd><mtd columnalign="left" >
	373	<msup><mi mathvariant='italic'>y</mi>
	374	<mrow><mo stretchy="false">(</mo>
	375	<mn>0</mn>
	376	<mo stretchy="false">)</mo>
	377	</mrow>
	378	</msup>
	379	<msup><mi mathvariant='italic'>t</mi>
	380	<mn>0</mn>
	381	</msup>
	382	<mo stretchy="false">+</mo>
	383	<msup><mi mathvariant='italic'>y</mi>
	384	<mrow><mo stretchy="false">(</mo>
	385	<mn>1</mn>
	386	<mo stretchy="false">)</mo>
	387	</mrow>
	388	</msup>
	389	<mo stretchy="false">*</mo>
	390	<msup><mi mathvariant='italic'>t</mi>
	391	<mn>1</mn>
	392	</msup>
	393	<mo stretchy="false">+</mo>
	394	<mo stretchy="false">⋯</mo>
	395	<mo stretchy="false">,</mo>
	396	<mo stretchy="false">+</mo>
	397	<msup><mi mathvariant='italic'>y</mi>
	398	<mrow><mo stretchy="false">(</mo>
	399	<mi mathvariant='italic'>q</mi>
	400	<mo stretchy="false">)</mo>
	401	</mrow>
	402	</msup>
	403	<mo stretchy="false">*</mo>
	404	<msup><mi mathvariant='italic'>t</mi>
	405	<mi mathvariant='italic'>q</mi>
	406	</msup>
	407	<mo stretchy="false">+</mo>
	408	<mi mathvariant='italic'>o</mi>
	409	<mo stretchy="false">(</mo>
	410	<msup><mi mathvariant='italic'>t</mi>
	411	<mi mathvariant='italic'>q</mi>
	412	</msup>
	413	<mo stretchy="false">)</mo>
	414	</mtd></mtr></mtable>
	415	</mrow></math>
	416
	417	and
	418	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	419	<mi mathvariant='italic'>o</mi>
	420	<mo stretchy="false">(</mo>
	421	<msup><mi mathvariant='italic'>t</mi>
	422	<mi mathvariant='italic'>q</mi>
	423	</msup>
	424	<mo stretchy="false">)</mo>
	425	<mo stretchy="false">*</mo>
	426	<msup><mi mathvariant='italic'>t</mi>
	427	<mrow><mo stretchy="false">-</mo>
	428	<mi mathvariant='italic'>q</mi>
	429	</mrow>
	430	</msup>
	431	<mo stretchy="false">→</mo>
	432	<mn>0</mn>
	433	</mrow></math>
	434
	435	as
	436	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	437	<mi mathvariant='italic'>t</mi>
	438	<mo stretchy="false">→</mo>
	439	<mn>0</mn>
	440	</mrow></math>
	441
	442	.
	443	For this special case,
	444	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	445	<mi mathvariant='italic'>q</mi>
	446	<mo stretchy="false">=</mo>
	447	<mn>1</mn>
	448	</mrow></math>
	449
	450	,
	451
	452	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	453	<msup><mi mathvariant='italic'>x</mi>
	454	<mrow><mo stretchy="false">(</mo>
	455	<mn>0</mn>
	456	<mo stretchy="false">)</mo>
	457	</mrow>
	458	</msup>
	459	</mrow></math>
	460
	461
	462	<code><font color="blue"><span style='white-space: nowrap'>= </span></font><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	463	,
	464
	465	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	466	<msup><mi mathvariant='italic'>x</mi>
	467	<mrow><mo stretchy="false">(</mo>
	468	<mn>1</mn>
	469	<mo stretchy="false">)</mo>
	470	</mrow>
	471	</msup>
	472	</mrow></math>
	473
	474
	475	<code><font color="blue"><span style='white-space: nowrap'>= </span></font><i><font color="black"><span style='white-space: nowrap'>x1</span></font></i></code>
	476	,
	477
	478	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	479	<mi mathvariant='italic'>X</mi>
	480	<mo stretchy="false">(</mo>
	481	<mi mathvariant='italic'>t</mi>
	482	<mo stretchy="false">)</mo>
	483	<mo stretchy="false">=</mo>
	484	<msup><mi mathvariant='italic'>x</mi>
	485	<mrow><mo stretchy="false">(</mo>
	486	<mn>0</mn>
	487	<mo stretchy="false">)</mo>
	488	</mrow>
	489	</msup>
	490	<mo stretchy="false">+</mo>
	491	<msup><mi mathvariant='italic'>x</mi>
	492	<mrow><mo stretchy="false">(</mo>
	493	<mn>1</mn>
	494	<mo stretchy="false">)</mo>
	495	</mrow>
	496	</msup>
	497	<mi mathvariant='italic'>t</mi>
	498	</mrow></math>
	499
	500	, and
	501
	502	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	503	<msup><mi mathvariant='italic'>y</mi>
	504	<mrow><mo stretchy="false">(</mo>
	505	<mn>0</mn>
	506	<mo stretchy="false">)</mo>
	507	</mrow>
	508	</msup>
	509	<mo stretchy="false">+</mo>
	510	<msup><mi mathvariant='italic'>y</mi>
	511	<mrow><mo stretchy="false">(</mo>
	512	<mn>1</mn>
	513	<mo stretchy="false">)</mo>
	514	</mrow>
	515	</msup>
	516	<mi mathvariant='italic'>t</mi>
	517	<mo stretchy="false">=</mo>
	518	<mi mathvariant='italic'>F</mi>
	519	<mo stretchy="false">[</mo>
	520	<msup><mi mathvariant='italic'>x</mi>
	521	<mrow><mo stretchy="false">(</mo>
	522	<mn>0</mn>
	523	<mo stretchy="false">)</mo>
	524	</mrow>
	525	</msup>
	526	<mo stretchy="false">+</mo>
	527	<msup><mi mathvariant='italic'>x</mi>
	528	<mrow><mo stretchy="false">(</mo>
	529	<mn>1</mn>
	530	<mo stretchy="false">)</mo>
	531	</mrow>
	532	</msup>
	533	<mi mathvariant='italic'>t</mi>
	534	<mo stretchy="false">]</mo>
	535	<mo stretchy="false">+</mo>
	536	<mi mathvariant='italic'>o</mi>
	537	<mo stretchy="false">(</mo>
	538	<mi mathvariant='italic'>t</mi>
	539	<mo stretchy="false">)</mo>
	540	</mrow></math>
	541
	542	Taking the derivative with respect to
	543	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	544	<mi mathvariant='italic'>t</mi>
	545	</mrow></math>
	546
	547	, at
	548	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	549	<mi mathvariant='italic'>t</mi>
	550	<mo stretchy="false">=</mo>
	551	<mn>0</mn>
	552	</mrow></math>
	553
	554	,
	555	we obtain
	556
	557	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	558	<msup><mi mathvariant='italic'>y</mi>
	559	<mrow><mo stretchy="false">(</mo>
	560	<mn>1</mn>
	561	<mo stretchy="false">)</mo>
	562	</mrow>
	563	</msup>
	564	<mo stretchy="false">=</mo>
	565	<msup><mi mathvariant='italic'>F</mi>
	566	<mrow><mo stretchy="false">(</mo>
	567	<mn>1</mn>
	568	<mo stretchy="false">)</mo>
	569	</mrow>
	570	</msup>
	571	<mo stretchy="false">[</mo>
	572	<msup><mi mathvariant='italic'>x</mi>
	573	<mrow><mo stretchy="false">(</mo>
	574	<mn>0</mn>
	575	<mo stretchy="false">)</mo>
	576	</mrow>
	577	</msup>
	578	<mo stretchy="false">]</mo>
	579	<msup><mi mathvariant='italic'>x</mi>
	580	<mrow><mo stretchy="false">(</mo>
	581	<mn>1</mn>
	582	<mo stretchy="false">)</mo>
	583	</mrow>
	584	</msup>
	585	</mrow></math>
	586
	587	which agrees with the specifications for
	588
	589	<code><i><font color="black"><span style='white-space: nowrap'>y1</span></font></i></code>
	590	in the <a href="forward_one.xml#Purpose" target="_top"><span style='white-space: nowrap'>purpose</span></a>
	591	above.
	592
	593
	594	<hr/>Input File: omh/forward/forward_one.omh
	595
	596	</body>
	597	</html>

+153

-0

doc/forward_order.cpp.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Forward Mode: Example and Test of Multiple Orders</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Forward Mode: Example and Test of Multiple Orders"/>
	8	<meta name="keywords" id="keywords" content=" forward mode: example and test of multiple orders order "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_forward_order.cpp_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="forward.cpp.xml" target="_top">Prev</a>
	25	</td><td><a href="forward_dir.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>forward_order</option>
	44	<option>forward_order.cpp</option>
	45	</select>
	46	</td>
	47	<td>
	48	<select onchange='choose_down3(this)'>
	49	<option>FunEval-></option>
	50	<option>Forward</option>
	51	<option>Reverse</option>
	52	<option>Sparse</option>
	53	</select>
	54	</td>
	55	<td>
	56	<select onchange='choose_down2(this)'>
	57	<option>Forward-></option>
	58	<option>forward_zero</option>
	59	<option>forward_one</option>
	60	<option>forward_two</option>
	61	<option>forward_order</option>
	62	<option>forward_dir</option>
	63	<option>size_order</option>
	64	<option>CompareChange</option>
	65	<option>capacity_order</option>
	66	<option>number_skip</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>forward_order-></option>
	72	<option>forward.cpp</option>
	73	<option>forward_order.cpp</option>
	74	</select>
	75	</td>
	76	<td>forward_order.cpp</td>
	77	<td>Headings</td>
	78	</tr></table><br/>
	79
	80
	81
	82	<center><b><big><big>Forward Mode: Example and Test of Multiple Orders</big></big></b></center>
	83	<code><font color="blue"><pre style='display:inline'>
	84	# include <limits>
	85	# include <cppad/cppad.hpp>
	86	bool forward_order(void)
	87	{ bool ok = true;
	88	using CppAD::AD;
	89	using CppAD::NearEqual;
	90	double eps = 10. * std::numeric_limits<double>::epsilon();
	91
	92	// domain space vector
	93	size_t n = 2;
	94	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ax(n);
	95	ax[0] = 0.;
	96	ax[1] = 1.;
	97
	98	// declare independent variables and starting recording
	99	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
	100
	101	// range space vector
	102	size_t m = 1;
	103	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ay(m);
	104	ay[0] = ax[0] * ax[0] * ax[1];
	105
	106	// create f: x -> y and stop tape recording
	107	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(ax, ay);
	108
	109	// initially, the variable values during taping are stored in f
	110	ok &= f.size_order() == 1;
	111
	112	// Compute three forward orders at one
	113	size_t q = 2, q1 = q+1;
	114	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) xq(n*q1), yq;
	115	xq[q10 + 0] = 3.; xq[q11 + 0] = 4.; // x^0 (order zero)
	116	xq[q10 + 1] = 1.; xq[q11 + 1] = 0.; // x^1 (order one)
	117	xq[q10 + 2] = 0.; xq[q11 + 2] = 0.; // x^2 (order two)
	118	// X(t) = x^0 + x^1 * t + x^2 * t^2
	119	// = [ 3 + t, 4 ]
	120	yq = f.<a href="forward.xml" target="_top">Forward</a>(q, xq);
	121	ok &= yq.size() == m*q1;
	122	// Y(t) = F[X(t)]
	123	// = (3 + t) * (3 + t) * 4
	124	// = y^0 + y^1 * t + y^2 * t^2 + o(t^3)
	125	//
	126	// check y^0 (order zero)
	127	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x0(n);
	128	x0[0] = xq[q1*0 + 0];
	129	x0[1] = xq[q1*1 + 0];
	130	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(yq[q10 + 0] , x0[0]x0[0]*x0[1], eps, eps);
	131	//
	132	// check y^1 (order one)
	133	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(yq[q10 + 1] , 2.x0[0]*x0[1], eps, eps);
	134	//
	135	// check y^2 (order two)
	136	double F_00 = 2. * yq[q1*0 + 2]; // second partial F w.r.t. x_0, x_0
	137	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(F_00, 2.*x0[1], eps, eps);
	138
	139	// check number of orders per variable
	140	ok &= f.size_order() == 3;
	141
	142	return ok;
	143	}
	144	</pre>
	145
	146	</font></code>
	147
	148
	149	<hr/>Input File: example/forward_order.cpp
	150
	151	</body>
	152	</html>

+1004

-0

doc/forward_order.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Multiple Order Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Multiple Order Forward Mode"/>
	8	<meta name="keywords" id="keywords" content=" multiple order forward mode any syntax purpose function values derivative notation n m f one q xq orders restrictions s x(t) y(t) yq vector zero first second example "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_forward_order_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="forward_two.xml" target="_top">Prev</a>
	25	</td><td><a href="forward.cpp.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>forward_order</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>ADFun-></option>
	49	<option>Independent</option>
	50	<option>FunConstruct</option>
	51	<option>Dependent</option>
	52	<option>abort_recording</option>
	53	<option>seq_property</option>
	54	<option>FunEval</option>
	55	<option>Drivers</option>
	56	<option>FunCheck</option>
	57	<option>optimize</option>
	58	<option>check_for_nan</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>FunEval-></option>
	64	<option>Forward</option>
	65	<option>Reverse</option>
	66	<option>Sparse</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>Forward-></option>
	72	<option>forward_zero</option>
	73	<option>forward_one</option>
	74	<option>forward_two</option>
	75	<option>forward_order</option>
	76	<option>forward_dir</option>
	77	<option>size_order</option>
	78	<option>CompareChange</option>
	79	<option>capacity_order</option>
	80	<option>number_skip</option>
	81	</select>
	82	</td>
	83	<td>
	84	<select onchange='choose_down0(this)'>
	85	<option>forward_order-></option>
	86	<option>forward.cpp</option>
	87	<option>forward_order.cpp</option>
	88	</select>
	89	</td>
	90	<td>
	91	<select onchange='choose_current0(this)'>
	92	<option>Headings-></option>
	93	<option>Syntax</option>
	94	<option>Purpose</option>
	95	<option>---..Function Values</option>
	96	<option>---..Derivative Values</option>
	97	<option>Notation</option>
	98	<option>---..n</option>
	99	<option>---..m</option>
	100	<option>f</option>
	101	<option>One Order</option>
	102	<option>q</option>
	103	<option>xq</option>
	104	<option>---..One Order</option>
	105	<option>---..Multiple Orders</option>
	106	<option>---..Restrictions</option>
	107	<option>s</option>
	108	<option>X(t)</option>
	109	<option>Y(t)</option>
	110	<option>yq</option>
	111	<option>---..One Order</option>
	112	<option>---..Multiple Orders</option>
	113	<option>Vector</option>
	114	<option>Zero Order</option>
	115	<option>First Order</option>
	116	<option>Second Order</option>
	117	<option>Example</option>
	118	</select>
	119	</td>
	120	</tr></table><br/>
	121
	122
	123
	124	<center><b><big><big>Multiple Order Forward Mode</big></big></b></center>
	125	<br/>
	126	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
	127
	128	<br/>
	129
	130	<code><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'> )<br/>
	131	</span></font></code>
	132
	133	<code><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	134	</span></font></code>
	135	<br/>
	136	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	137	<br/>
	138	We use
	139	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	140	<mi mathvariant='italic'>F</mi>
	141	<mo stretchy="false">:</mo>
	142	<msup><mi mathvariant='italic'>B</mi>
	143	<mi mathvariant='italic'>n</mi>
	144	</msup>
	145	<mo stretchy="false">→</mo>
	146	<msup><mi mathvariant='italic'>B</mi>
	147	<mi mathvariant='italic'>m</mi>
	148	</msup>
	149	</mrow></math>
	150
	151	to denote the
	152	<a href="glossary.xml#AD Function" target="_top"><span style='white-space: nowrap'>AD function</span></a>
	153	corresponding to
	154	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	155	.
	156	Given a function
	157	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	158	<mi mathvariant='italic'>X</mi>
	159	<mo stretchy="false">:</mo>
	160	<mi mathvariant='italic'>B</mi>
	161	<mo stretchy="false">→</mo>
	162	<msup><mi mathvariant='italic'>B</mi>
	163	<mi mathvariant='italic'>n</mi>
	164	</msup>
	165	</mrow></math>
	166
	167	,
	168	defined by its
	169	<a href="glossary.xml#Taylor Coefficient" target="_top"><span style='white-space: nowrap'>Taylor coefficients</span></a>
	170	,
	171	forward mode computes the Taylor coefficients for the function
	172
	173	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	174	<mi mathvariant='italic'>Y</mi>
	175	<mo stretchy="false">(</mo>
	176	<mi mathvariant='italic'>t</mi>
	177	<mo stretchy="false">)</mo>
	178	<mo stretchy="false">=</mo>
	179	<mi mathvariant='italic'>F</mi>
	180	<mo stretchy="false">[</mo>
	181	<mi mathvariant='italic'>X</mi>
	182	<mo stretchy="false">(</mo>
	183	<mi mathvariant='italic'>t</mi>
	184	<mo stretchy="false">)</mo>
	185	<mo stretchy="false">]</mo>
	186	</mrow></math>
	187
	188	<br/>
	189	<b><a name="Purpose.Function Values" id="Purpose.Function Values">Function Values</a></b>
	190	<br/>
	191	If you are using forward mode to compute values for
	192	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	193	<mi mathvariant='italic'>F</mi>
	194	<mo stretchy="false">(</mo>
	195	<mi mathvariant='italic'>x</mi>
	196	<mo stretchy="false">)</mo>
	197	</mrow></math>
	198
	199	,
	200	<a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
	201	is simpler to understand
	202	than this explanation of the general case.
	203
	204	<br/>
	205	<br/>
	206	<b><a name="Purpose.Derivative Values" id="Purpose.Derivative Values">Derivative Values</a></b>
	207	<br/>
	208	If you are using forward mode to compute values for
	209	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	210	<msup><mi mathvariant='italic'>F</mi>
	211	<mrow><mo stretchy="false">(</mo>
	212	<mn>1</mn>
	213	<mo stretchy="false">)</mo>
	214	</mrow>
	215	</msup>
	216	<mo stretchy="false">(</mo>
	217	<mi mathvariant='italic'>x</mi>
	218	<mo stretchy="false">)</mo>
	219	<mo stretchy="false">*</mo>
	220	<mi mathvariant='italic'>dx</mi>
	221	</mrow></math>
	222
	223	,
	224	<a href="forward_one.xml" target="_top"><span style='white-space: nowrap'>forward_one</span></a>
	225	is simpler to understand
	226	than this explanation of the general case.
	227
	228	<br/>
	229	<br/>
	230	<b><big><a name="Notation" id="Notation">Notation</a></big></b>
	231
	232
	233	<br/>
	234	<br/>
	235	<b><a name="Notation.n" id="Notation.n">n</a></b>
	236	<br/>
	237	We use
	238	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	239	to denote the dimension of the
	240	<a href="seq_property.xml#Domain" target="_top"><span style='white-space: nowrap'>domain</span></a>
	241	space for
	242	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	243	.
	244
	245	<br/>
	246	<br/>
	247	<b><a name="Notation.m" id="Notation.m">m</a></b>
	248	<br/>
	249	We use
	250	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
	251	to denote the dimension of the
	252	<a href="seq_property.xml#Range" target="_top"><span style='white-space: nowrap'>range</span></a>
	253	space for
	254	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	255	.
	256
	257
	258	<br/>
	259	<br/>
	260	<b><big><a name="f" id="f">f</a></big></b>
	261	<br/>
	262	The <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
	263	object
	264	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	265	has prototype
	266
	267	<code><font color="blue"><span style='white-space: nowrap'><br/>
	268	ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	269	</span></font></code>
	270	Note that the <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
	271	object
	272	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	273	is not <code><font color="blue">const</font></code>.
	274	After this call we will have
	275
	276	<code><font color="blue"><span style='white-space: nowrap'><br/>
	277	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()     == </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> + 1<br/>
	278	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_direction() == 1<br/>
	279	</span></font></code>
	280	<br/>
	281	<b><big><a name="One Order" id="One Order">One Order</a></big></b>
	282	<br/>
	283	If
	284	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	285	,
	286	then we are only computing one order.
	287	In this case, before this call we must have
	288
	289	<code><font color="blue"><span style='white-space: nowrap'><br/>
	290	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()     >= </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	291	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_direction() == 1<br/>
	292	</span></font></code>
	293	<br/>
	294	<b><big><a name="q" id="q">q</a></big></b>
	295	<br/>
	296	The argument
	297	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
	298	has prototype
	299
	300	<code><font color="blue"><span style='white-space: nowrap'><br/>
	301	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	302	</span></font></code>
	303	and specifies the highest order of the Taylor coefficients to be calculated.
	304
	305	<br/>
	306	<br/>
	307	<b><big><a name="xq" id="xq">xq</a></big></b>
	308	<br/>
	309	The argument
	310	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i></code>
	311	has prototype
	312
	313	<code><font color="blue"><span style='white-space: nowrap'><br/>
	314	const </span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'>& </span></font><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	315	</span></font></code>
	316	(see <a href="forward_order.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
	317	below).
	318	As above, we use
	319	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	320	to denote the dimension of the
	321	<a href="seq_property.xml#Domain" target="_top"><span style='white-space: nowrap'>domain</span></a>
	322	space for
	323	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	324	.
	325	The size of
	326	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i></code>
	327	must be either
	328	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	329	or
	330
	331	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i><font color="blue"><span style='white-space: nowrap'>*(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
	332	.
	333	After this call we will have
	334
	335	<code><font color="blue"><span style='white-space: nowrap'><br/>
	336	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()     == </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> + 1<br/>
	337	</span></font></code>
	338	<br/>
	339	<b><a name="xq.One Order" id="xq.One Order">One Order</a></b>
	340	<br/>
	341	If
	342	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	343	,
	344	the <code><i>q</i></code>-th order Taylor coefficient for
	345	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	346	<mi mathvariant='italic'>X</mi>
	347	<mo stretchy="false">(</mo>
	348	<mi mathvariant='italic'>t</mi>
	349	<mo stretchy="false">)</mo>
	350	</mrow></math>
	351
	352
	353	is defined by
	354	<code><span style='white-space: nowrap'><br/>
	355	</span></code>
	356	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	357	<msup><mi mathvariant='italic'>x</mi>
	358	<mrow><mo stretchy="false">(</mo>
	359	<mi mathvariant='italic'>q</mi>
	360	<mo stretchy="false">)</mo>
	361	</mrow>
	362	</msup>
	363	<mo stretchy="false">=</mo>
	364	</mrow></math>
	365
	366
	367	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i></code>
	368	.
	369	For
	370	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	371	<mi mathvariant='italic'>k</mi>
	372	<mo stretchy="false">=</mo>
	373	<mn>0</mn>
	374	<mo stretchy="false">,</mo>
	375	<mo stretchy="false">…</mo>
	376	<mo stretchy="false">,</mo>
	377	<mi mathvariant='italic'>q</mi>
	378	<mn>-1</mn>
	379	</mrow></math>
	380
	381	,
	382	the Taylor coefficient
	383	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	384	<msup><mi mathvariant='italic'>x</mi>
	385	<mrow><mo stretchy="false">(</mo>
	386	<mi mathvariant='italic'>k</mi>
	387	<mo stretchy="false">)</mo>
	388	</mrow>
	389	</msup>
	390	</mrow></math>
	391
	392
	393	is defined by
	394	<code><i><font color="black"><span style='white-space: nowrap'>xk</span></font></i></code>
	395	in the previous call to
	396
	397	<code><font color="blue"><span style='white-space: nowrap'><br/>
	398	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>xk</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	399	</span></font></code>
	400	<br/>
	401	<b><a name="xq.Multiple Orders" id="xq.Multiple Orders">Multiple Orders</a></b>
	402	<br/>
	403	If
	404	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i><font color="blue"><span style='white-space: nowrap'>*(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
	405	,
	406	For
	407	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	408	<mi mathvariant='italic'>k</mi>
	409	<mo stretchy="false">=</mo>
	410	<mn>0</mn>
	411	<mo stretchy="false">,</mo>
	412	<mo stretchy="false">…</mo>
	413	<mo stretchy="false">,</mo>
	414	<mi mathvariant='italic'>q</mi>
	415	</mrow></math>
	416
	417	,
	418
	419	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	420	<mi mathvariant='italic'>j</mi>
	421	<mo stretchy="false">=</mo>
	422	<mn>0</mn>
	423	<mo stretchy="false">,</mo>
	424	<mo stretchy="false">…</mo>
	425	<mo stretchy="false">,</mo>
	426	<mi mathvariant='italic'>n</mi>
	427	<mn>-1</mn>
	428	</mrow></math>
	429
	430	,
	431	the <code><i>j</i></code>-th component of the <code><i>k</i></code>-th order Taylor coefficient
	432	for
	433	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	434	<mi mathvariant='italic'>X</mi>
	435	<mo stretchy="false">(</mo>
	436	<mi mathvariant='italic'>t</mi>
	437	<mo stretchy="false">)</mo>
	438	</mrow></math>
	439
	440	is defined by
	441	<code><span style='white-space: nowrap'><br/>
	442	</span></code>
	443	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	444	<msubsup><mi mathvariant='italic'>x</mi>
	445	<mi mathvariant='italic'>j</mi>
	446	<mrow><mo stretchy="false">(</mo>
	447	<mi mathvariant='italic'>k</mi>
	448	<mo stretchy="false">)</mo>
	449	</mrow>
	450	</msubsup>
	451	<mo stretchy="false">=</mo>
	452	</mrow></math>
	453
	454
	455	<code><i><font color="black"></font></i><font color="blue"><span style='white-space: nowrap'>xq</span></font><i><font color="black"><span style='white-space: nowrap'>[ (</span></font></i><font color="blue"><span style='white-space: nowrap'>q</span></font><i><font color="black"><span style='white-space: nowrap'>+1) * </span></font></i><font color="blue"><span style='white-space: nowrap'>j</span></font><i><font color="black"><span style='white-space: nowrap'> + </span></font></i><font color="blue"><span style='white-space: nowrap'>k</span></font><i><font color="black"><span style='white-space: nowrap'> ]</span></font></i></code>
	456
	457
	458	<br/>
	459	<br/>
	460	<b><a name="xq.Restrictions" id="xq.Restrictions">Restrictions</a></b>
	461	<br/>
	462	Note if
	463	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	464	uses <a href="old_atomic.xml" target="_top"><span style='white-space: nowrap'>old_atomic</span></a>
	465	functions,
	466	the size of
	467	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i></code>
	468	must be
	469	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	470	.
	471
	472	<br/>
	473	<br/>
	474	<b><big><a name="s" id="s">s</a></big></b>
	475	<br/>
	476	If the argument
	477	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
	478	is not present, <code><font color="blue">std::cout</font></code>
	479	is used in its place.
	480	Otherwise, this argument has prototype
	481
	482	<code><font color="blue"><span style='white-space: nowrap'><br/>
	483	std::ostream& </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	484	</span></font></code>
	485	If order zero is begin calculated,
	486
	487	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
	488	specifies where the output corresponding to <a href="printfor.xml" target="_top"><span style='white-space: nowrap'>PrintFor</span></a>
	489
	490	will be written.
	491	If order zero is not being calculated,
	492
	493	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
	494	is not used
	495
	496	<br/>
	497	<br/>
	498	<b><big><a name="X(t)" id="X(t)">X(t)</a></big></b>
	499	<br/>
	500	The function
	501
	502	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	503	<mi mathvariant='italic'>X</mi>
	504	<mo stretchy="false">:</mo>
	505	<mi mathvariant='italic'>B</mi>
	506	<mo stretchy="false">→</mo>
	507	<msup><mi mathvariant='italic'>B</mi>
	508	<mi mathvariant='italic'>n</mi>
	509	</msup>
	510	</mrow></math>
	511
	512	is defined using
	513	the Taylor coefficients
	514	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	515	<msup><mi mathvariant='italic'>x</mi>
	516	<mrow><mo stretchy="false">(</mo>
	517	<mi mathvariant='italic'>k</mi>
	518	<mo stretchy="false">)</mo>
	519	</mrow>
	520	</msup>
	521	<mo stretchy="false">∈</mo>
	522	<msup><mi mathvariant='italic'>B</mi>
	523	<mi mathvariant='italic'>n</mi>
	524	</msup>
	525	</mrow></math>
	526
	527	:
	528
	529	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	530	<mi mathvariant='italic'>X</mi>
	531	<mo stretchy="false">(</mo>
	532	<mi mathvariant='italic'>t</mi>
	533	<mo stretchy="false">)</mo>
	534	<mo stretchy="false">=</mo>
	535	<msup><mi mathvariant='italic'>x</mi>
	536	<mrow><mo stretchy="false">(</mo>
	537	<mn>0</mn>
	538	<mo stretchy="false">)</mo>
	539	</mrow>
	540	</msup>
	541	<mo stretchy="false">*</mo>
	542	<msup><mi mathvariant='italic'>t</mi>
	543	<mn>0</mn>
	544	</msup>
	545	<mo stretchy="false">+</mo>
	546	<msup><mi mathvariant='italic'>x</mi>
	547	<mrow><mo stretchy="false">(</mo>
	548	<mn>1</mn>
	549	<mo stretchy="false">)</mo>
	550	</mrow>
	551	</msup>
	552	<mo stretchy="false">*</mo>
	553	<msup><mi mathvariant='italic'>t</mi>
	554	<mn>1</mn>
	555	</msup>
	556	<mo stretchy="false">+</mo>
	557	<mo stretchy="false">⋯</mo>
	558	<mo stretchy="false">+</mo>
	559	<msup><mi mathvariant='italic'>x</mi>
	560	<mrow><mo stretchy="false">(</mo>
	561	<mi mathvariant='italic'>q</mi>
	562	<mo stretchy="false">)</mo>
	563	</mrow>
	564	</msup>
	565	<mo stretchy="false">*</mo>
	566	<msup><mi mathvariant='italic'>t</mi>
	567	<mi mathvariant='italic'>q</mi>
	568	</msup>
	569	</mrow></math>
	570
	571	Note that for
	572	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	573	<mi mathvariant='italic'>k</mi>
	574	<mo stretchy="false">=</mo>
	575	<mn>0</mn>
	576	<mo stretchy="false">,</mo>
	577	<mo stretchy="false">…</mo>
	578	<mo stretchy="false">,</mo>
	579	<mi mathvariant='italic'>q</mi>
	580	</mrow></math>
	581
	582	,
	583	the <code><i>k</i></code>-th derivative of
	584	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	585	<mi mathvariant='italic'>X</mi>
	586	<mo stretchy="false">(</mo>
	587	<mi mathvariant='italic'>t</mi>
	588	<mo stretchy="false">)</mo>
	589	</mrow></math>
	590
	591	is related to the
	592	Taylor coefficients by the equation
	593
	594	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	595	<msup><mi mathvariant='italic'>x</mi>
	596	<mrow><mo stretchy="false">(</mo>
	597	<mi mathvariant='italic'>k</mi>
	598	<mo stretchy="false">)</mo>
	599	</mrow>
	600	</msup>
	601	<mo stretchy="false">=</mo>
	602	<mfrac><mrow><mn>1</mn>
	603	</mrow>
	604	<mrow><mi mathvariant='italic'>k</mi>
	605	<mo stretchy="false">!</mo>
	606	</mrow>
	607	</mfrac>
	608	<msup><mi mathvariant='italic'>X</mi>
	609	<mrow><mo stretchy="false">(</mo>
	610	<mi mathvariant='italic'>k</mi>
	611	<mo stretchy="false">)</mo>
	612	</mrow>
	613	</msup>
	614	<mo stretchy="false">(</mo>
	615	<mn>0</mn>
	616	<mo stretchy="false">)</mo>
	617	</mrow></math>
	618
	619	<br/>
	620	<b><big><a name="Y(t)" id="Y(t)">Y(t)</a></big></b>
	621	<br/>
	622	The function
	623
	624	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	625	<mi mathvariant='italic'>Y</mi>
	626	<mo stretchy="false">:</mo>
	627	<mi mathvariant='italic'>B</mi>
	628	<mo stretchy="false">→</mo>
	629	<msup><mi mathvariant='italic'>B</mi>
	630	<mi mathvariant='italic'>m</mi>
	631	</msup>
	632	</mrow></math>
	633
	634	is defined by
	635
	636	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	637	<mi mathvariant='italic'>Y</mi>
	638	<mo stretchy="false">(</mo>
	639	<mi mathvariant='italic'>t</mi>
	640	<mo stretchy="false">)</mo>
	641	<mo stretchy="false">=</mo>
	642	<mi mathvariant='italic'>F</mi>
	643	<mo stretchy="false">[</mo>
	644	<mi mathvariant='italic'>X</mi>
	645	<mo stretchy="false">(</mo>
	646	<mi mathvariant='italic'>t</mi>
	647	<mo stretchy="false">)</mo>
	648	<mo stretchy="false">]</mo>
	649	</mrow></math>
	650
	651	.
	652	We use
	653	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	654	<msup><mi mathvariant='italic'>y</mi>
	655	<mrow><mo stretchy="false">(</mo>
	656	<mi mathvariant='italic'>k</mi>
	657	<mo stretchy="false">)</mo>
	658	</mrow>
	659	</msup>
	660	<mo stretchy="false">∈</mo>
	661	<msup><mi mathvariant='italic'>B</mi>
	662	<mi mathvariant='italic'>m</mi>
	663	</msup>
	664	</mrow></math>
	665
	666
	667	to denote the <code><i>k</i></code>-th order Taylor coefficient of
	668	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	669	<mi mathvariant='italic'>Y</mi>
	670	<mo stretchy="false">(</mo>
	671	<mi mathvariant='italic'>t</mi>
	672	<mo stretchy="false">)</mo>
	673	</mrow></math>
	674
	675	; i.e.,
	676
	677	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	678	<mi mathvariant='italic'>Y</mi>
	679	<mo stretchy="false">(</mo>
	680	<mi mathvariant='italic'>t</mi>
	681	<mo stretchy="false">)</mo>
	682	<mo stretchy="false">=</mo>
	683	<msup><mi mathvariant='italic'>y</mi>
	684	<mrow><mo stretchy="false">(</mo>
	685	<mn>0</mn>
	686	<mo stretchy="false">)</mo>
	687	</mrow>
	688	</msup>
	689	<mo stretchy="false">*</mo>
	690	<msup><mi mathvariant='italic'>t</mi>
	691	<mn>0</mn>
	692	</msup>
	693	<mo stretchy="false">+</mo>
	694	<msup><mi mathvariant='italic'>y</mi>
	695	<mrow><mo stretchy="false">(</mo>
	696	<mn>1</mn>
	697	<mo stretchy="false">)</mo>
	698	</mrow>
	699	</msup>
	700	<mo stretchy="false">*</mo>
	701	<msup><mi mathvariant='italic'>t</mi>
	702	<mn>1</mn>
	703	</msup>
	704	<mo stretchy="false">+</mo>
	705	<mo stretchy="false">⋯</mo>
	706	<mo stretchy="false">+</mo>
	707	<msup><mi mathvariant='italic'>y</mi>
	708	<mrow><mo stretchy="false">(</mo>
	709	<mi mathvariant='italic'>q</mi>
	710	<mo stretchy="false">)</mo>
	711	</mrow>
	712	</msup>
	713	<mo stretchy="false">*</mo>
	714	<msup><mi mathvariant='italic'>t</mi>
	715	<mi mathvariant='italic'>q</mi>
	716	</msup>
	717	<mo stretchy="false">+</mo>
	718	<mi mathvariant='italic'>o</mi>
	719	<mo stretchy="false">(</mo>
	720	<msup><mi mathvariant='italic'>t</mi>
	721	<mi mathvariant='italic'>q</mi>
	722	</msup>
	723	<mo stretchy="false">)</mo>
	724	</mrow></math>
	725
	726	where
	727	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	728	<mi mathvariant='italic'>o</mi>
	729	<mo stretchy="false">(</mo>
	730	<msup><mi mathvariant='italic'>t</mi>
	731	<mi mathvariant='italic'>q</mi>
	732	</msup>
	733	<mo stretchy="false">)</mo>
	734	<mo stretchy="false">*</mo>
	735	<msup><mi mathvariant='italic'>t</mi>
	736	<mrow><mo stretchy="false">-</mo>
	737	<mi mathvariant='italic'>q</mi>
	738	</mrow>
	739	</msup>
	740	<mo stretchy="false">→</mo>
	741	<mn>0</mn>
	742	</mrow></math>
	743
	744	as
	745	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	746	<mi mathvariant='italic'>t</mi>
	747	<mo stretchy="false">→</mo>
	748	<mn>0</mn>
	749	</mrow></math>
	750
	751	.
	752	Note that
	753	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	754	<msup><mi mathvariant='italic'>y</mi>
	755	<mrow><mo stretchy="false">(</mo>
	756	<mi mathvariant='italic'>k</mi>
	757	<mo stretchy="false">)</mo>
	758	</mrow>
	759	</msup>
	760	</mrow></math>
	761
	762	is related to
	763	the <code><i>k</i></code>-th derivative of
	764	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	765	<mi mathvariant='italic'>Y</mi>
	766	<mo stretchy="false">(</mo>
	767	<mi mathvariant='italic'>t</mi>
	768	<mo stretchy="false">)</mo>
	769	</mrow></math>
	770
	771	by the equation
	772
	773	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	774	<msup><mi mathvariant='italic'>y</mi>
	775	<mrow><mo stretchy="false">(</mo>
	776	<mi mathvariant='italic'>k</mi>
	777	<mo stretchy="false">)</mo>
	778	</mrow>
	779	</msup>
	780	<mo stretchy="false">=</mo>
	781	<mfrac><mrow><mn>1</mn>
	782	</mrow>
	783	<mrow><mi mathvariant='italic'>k</mi>
	784	<mo stretchy="false">!</mo>
	785	</mrow>
	786	</mfrac>
	787	<msup><mi mathvariant='italic'>Y</mi>
	788	<mrow><mo stretchy="false">(</mo>
	789	<mi mathvariant='italic'>k</mi>
	790	<mo stretchy="false">)</mo>
	791	</mrow>
	792	</msup>
	793	<mo stretchy="false">(</mo>
	794	<mn>0</mn>
	795	<mo stretchy="false">)</mo>
	796	</mrow></math>
	797
	798	<br/>
	799	<b><big><a name="yq" id="yq">yq</a></big></b>
	800	<br/>
	801	The return value
	802	<code><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i></code>
	803	has prototype
	804
	805	<code><font color="blue"><span style='white-space: nowrap'><br/>
	806	</span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	807	</span></font></code>
	808	(see <a href="forward_order.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
	809	below).
	810
	811	<br/>
	812	<br/>
	813	<b><a name="yq.One Order" id="yq.One Order">One Order</a></b>
	814	<br/>
	815	If
	816	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	817	,
	818	the vector
	819	<code><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i></code>
	820	has size
	821	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
	822	.
	823	The <code><i>q</i></code>-th order Taylor coefficient for
	824	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	825	<mi mathvariant='italic'>Y</mi>
	826	<mo stretchy="false">(</mo>
	827	<mi mathvariant='italic'>t</mi>
	828	<mo stretchy="false">)</mo>
	829	</mrow></math>
	830
	831
	832	is returned as
	833
	834	<code><font color="blue"><span style='white-space: nowrap'><br/>
	835	</span></font><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i></code>
	836
	837	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	838	<mo stretchy="false">=</mo>
	839	<msup><mi mathvariant='italic'>y</mi>
	840	<mrow><mo stretchy="false">(</mo>
	841	<mi mathvariant='italic'>q</mi>
	842	<mo stretchy="false">)</mo>
	843	</mrow>
	844	</msup>
	845	</mrow></math>
	846
	847	.
	848
	849	<br/>
	850	<br/>
	851	<b><a name="yq.Multiple Orders" id="yq.Multiple Orders">Multiple Orders</a></b>
	852	<br/>
	853	If
	854	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i><font color="blue"><span style='white-space: nowrap'>*(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
	855	,
	856	the vector
	857	<code><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i></code>
	858	has size
	859	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'>*(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
	860	.
	861	For
	862	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	863	<mi mathvariant='italic'>k</mi>
	864	<mo stretchy="false">=</mo>
	865	<mn>0</mn>
	866	<mo stretchy="false">,</mo>
	867	<mo stretchy="false">…</mo>
	868	<mo stretchy="false">,</mo>
	869	<mi mathvariant='italic'>q</mi>
	870	</mrow></math>
	871
	872	,
	873	for
	874	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	875	<mi mathvariant='italic'>i</mi>
	876	<mo stretchy="false">=</mo>
	877	<mn>0</mn>
	878	<mo stretchy="false">,</mo>
	879	<mo stretchy="false">…</mo>
	880	<mo stretchy="false">,</mo>
	881	<mi mathvariant='italic'>m</mi>
	882	<mn>-1</mn>
	883	</mrow></math>
	884
	885	,
	886	the <code><i>i</i></code>-th component of the <code><i>k</i></code>-th order Taylor coefficient
	887	for
	888	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	889	<mi mathvariant='italic'>Y</mi>
	890	<mo stretchy="false">(</mo>
	891	<mi mathvariant='italic'>t</mi>
	892	<mo stretchy="false">)</mo>
	893	</mrow></math>
	894
	895	is returned as
	896
	897	<code><font color="blue"><span style='white-space: nowrap'><br/>
	898	</span></font><i><font color="black"><span style='white-space: nowrap'>yq</span></font></i><font color="blue"><span style='white-space: nowrap'>[ (</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>+1) * </span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'> + </span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'> ]</span></font></code>
	899
	900	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	901	<mo stretchy="false">=</mo>
	902	<msubsup><mi mathvariant='italic'>y</mi>
	903	<mi mathvariant='italic'>i</mi>
	904	<mrow><mo stretchy="false">(</mo>
	905	<mi mathvariant='italic'>k</mi>
	906	<mo stretchy="false">)</mo>
	907	</mrow>
	908	</msubsup>
	909	</mrow></math>
	910
	911
	912
	913	<br/>
	914	<br/>
	915	<b><big><a name="Vector" id="Vector">Vector</a></big></b>
	916	<br/>
	917	The type
	918	<code><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i></code>
	919	must be a <a href="simplevector.xml" target="_top"><span style='white-space: nowrap'>SimpleVector</span></a>
	920	class with
	921	<a href="simplevector.xml#Elements of Specified Type" target="_top"><span style='white-space: nowrap'>elements of type</span></a>
	922
	923
	924	<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
	925	.
	926	The routine <a href="checksimplevector.xml" target="_top"><span style='white-space: nowrap'>CheckSimpleVector</span></a>
	927	will generate an error message
	928	if this is not the case.
	929
	930	<br/>
	931	<br/>
	932	<b><big><a name="Zero Order" id="Zero Order">Zero Order</a></big></b>
	933	<br/>
	934	The case where
	935
	936	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	937	<mi mathvariant='italic'>q</mi>
	938	<mo stretchy="false">=</mo>
	939	<mn>0</mn>
	940	</mrow></math>
	941
	942	and
	943	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	944	,
	945	corresponds to the zero order
	946	<a href="forward_zero.xml#Special Case" target="_top"><span style='white-space: nowrap'>special case</span></a>
	947	.
	948
	949	<br/>
	950	<br/>
	951	<b><big><a name="First Order" id="First Order">First Order</a></big></b>
	952	<br/>
	953	The case where
	954
	955	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	956	<mi mathvariant='italic'>q</mi>
	957	<mo stretchy="false">=</mo>
	958	<mn>1</mn>
	959	</mrow></math>
	960
	961	and
	962	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	963	,
	964	corresponds to the first order
	965	<a href="forward_one.xml#Special Case" target="_top"><span style='white-space: nowrap'>special case</span></a>
	966	.
	967
	968	<br/>
	969	<br/>
	970	<b><big><a name="Second Order" id="Second Order">Second Order</a></big></b>
	971	<br/>
	972	The case where
	973
	974	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	975	<mi mathvariant='italic'>q</mi>
	976	<mo stretchy="false">=</mo>
	977	<mn>2</mn>
	978	</mrow></math>
	979
	980	and
	981	<code><i><font color="black"><span style='white-space: nowrap'>xq</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	982	,
	983	corresponds to the second order
	984	<a href="forward_two.xml#Special Case" target="_top"><span style='white-space: nowrap'>special case</span></a>
	985	.
	986
	987
	988	<br/>
	989	<br/>
	990	<b><big><a name="Example" id="Example">Example</a></big></b>
	991	<br/>
	992	The file
	993	<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
	994	( <a href="forward_order.cpp.xml" target="_top"><span style='white-space: nowrap'>forward_order.cpp</span></a>
	995	)
	996	contains an example and test using one order (multiple orders).
	997	They return true if they succeed and false otherwise.
	998
	999
	1000	<hr/>Input File: omh/forward/forward_order.omh
	1001
	1002	</body>
	1003	</html>

+831

-0

doc/forward_two.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Second Order Forward Mode: Derivative Values</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Second Order Forward Mode: Derivative Values"/>
	8	<meta name="keywords" id="keywords" content=" second order forward mode: derivative values Forward two syntax purpose f x0 x1 x2 y2 vector example special case "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_forward_two_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="forward_one.xml" target="_top">Prev</a>
	25	</td><td><a href="forward_order.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>forward_two</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>ADFun-></option>
	49	<option>Independent</option>
	50	<option>FunConstruct</option>
	51	<option>Dependent</option>
	52	<option>abort_recording</option>
	53	<option>seq_property</option>
	54	<option>FunEval</option>
	55	<option>Drivers</option>
	56	<option>FunCheck</option>
	57	<option>optimize</option>
	58	<option>check_for_nan</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>FunEval-></option>
	64	<option>Forward</option>
	65	<option>Reverse</option>
	66	<option>Sparse</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>Forward-></option>
	72	<option>forward_zero</option>
	73	<option>forward_one</option>
	74	<option>forward_two</option>
	75	<option>forward_order</option>
	76	<option>forward_dir</option>
	77	<option>size_order</option>
	78	<option>CompareChange</option>
	79	<option>capacity_order</option>
	80	<option>number_skip</option>
	81	</select>
	82	</td>
	83	<td>forward_two</td>
	84	<td>
	85	<select onchange='choose_current0(this)'>
	86	<option>Headings-></option>
	87	<option>Syntax</option>
	88	<option>Purpose</option>
	89	<option>f</option>
	90	<option>x0</option>
	91	<option>x1</option>
	92	<option>x2</option>
	93	<option>y2</option>
	94	<option>Vector</option>
	95	<option>Example</option>
	96	<option>Special Case</option>
	97	</select>
	98	</td>
	99	</tr></table><br/>
	100
	101
	102
	103	<center><b><big><big>Second Order Forward Mode: Derivative Values</big></big></b></center>
	104	<br/>
	105	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
	106
	107	<br/>
	108
	109	<code><i><font color="black"><span style='white-space: nowrap'>y2</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(1, </span></font><i><font color="black"><span style='white-space: nowrap'>x2</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
	110
	111
	112	<br/>
	113	<br/>
	114	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	115	<br/>
	116	We use
	117	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	118	<mi mathvariant='italic'>F</mi>
	119	<mo stretchy="false">:</mo>
	120	<msup><mi mathvariant='italic'>B</mi>
	121	<mi mathvariant='italic'>n</mi>
	122	</msup>
	123	<mo stretchy="false">→</mo>
	124	<msup><mi mathvariant='italic'>B</mi>
	125	<mi mathvariant='italic'>m</mi>
	126	</msup>
	127	</mrow></math>
	128
	129	to denote the
	130	<a href="glossary.xml#AD Function" target="_top"><span style='white-space: nowrap'>AD function</span></a>
	131	corresponding to
	132	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	133	.
	134	The result of the syntax above is that for
	135
	136	<code><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'> = 0 , </span></font><i><font color="black"><span style='white-space: nowrap'>...</span></font></i><font color="blue"><span style='white-space: nowrap'> , </span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'>-1</span></font></code>
	137	,
	138
	139	<code><font color="blue"><span style='white-space: nowrap'><br/>
	140	</span></font><i><font color="black"><span style='white-space: nowrap'>y2</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'>]</span></font></code>
	141
	142
	143	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	144	<mo stretchy="false">=</mo>
	145	<msubsup><mi mathvariant='italic'>F</mi>
	146	<mi mathvariant='italic'>i</mi>
	147	<mrow><mo stretchy="false">(</mo>
	148	<mn>1</mn>
	149	<mo stretchy="false">)</mo>
	150	</mrow>
	151	</msubsup>
	152	<mo stretchy="false">(</mo>
	153	<mi mathvariant='italic'>x</mi>
	154	<mn>0</mn>
	155	<mo stretchy="false">)</mo>
	156	<mo stretchy="false">*</mo>
	157	<mi mathvariant='italic'>x</mi>
	158	<mn>2</mn>
	159	<mo stretchy="false">+</mo>
	160	<mfrac><mrow><mn>1</mn>
	161	</mrow>
	162	<mrow><mn>2</mn>
	163	</mrow>
	164	</mfrac>
	165	<mi mathvariant='italic'>x</mi>
	166	<msup><mn>1</mn>
	167	<mi mathvariant='italic'>T</mi>
	168	</msup>
	169	<mo stretchy="false">*</mo>
	170	<msubsup><mi mathvariant='italic'>F</mi>
	171	<mi mathvariant='italic'>i</mi>
	172	<mrow><mo stretchy="false">(</mo>
	173	<mn>2</mn>
	174	<mo stretchy="false">)</mo>
	175	</mrow>
	176	</msubsup>
	177	<mo stretchy="false">(</mo>
	178	<mi mathvariant='italic'>x</mi>
	179	<mn>0</mn>
	180	<mo stretchy="false">)</mo>
	181	<mo stretchy="false">*</mo>
	182	<mi mathvariant='italic'>x</mi>
	183	<mn>1</mn>
	184	</mrow></math>
	185
	186
	187	<code><span style='white-space: nowrap'><br/>
	188	</span></code>where
	189
	190	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	191	<msup><mi mathvariant='italic'>F</mi>
	192	<mrow><mo stretchy="false">(</mo>
	193	<mn>1</mn>
	194	<mo stretchy="false">)</mo>
	195	</mrow>
	196	</msup>
	197	<mo stretchy="false">(</mo>
	198	<mi mathvariant='italic'>x</mi>
	199	<mn>0</mn>
	200	<mo stretchy="false">)</mo>
	201	</mrow></math>
	202
	203	is the Jacobian of
	204	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	205	<mi mathvariant='italic'>F</mi>
	206	</mrow></math>
	207
	208	, and
	209
	210	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	211	<msubsup><mi mathvariant='italic'>F</mi>
	212	<mi mathvariant='italic'>i</mi>
	213	<mrow><mo stretchy="false">(</mo>
	214	<mn>2</mn>
	215	<mo stretchy="false">)</mo>
	216	</mrow>
	217	</msubsup>
	218	<mo stretchy="false">(</mo>
	219	<mi mathvariant='italic'>x</mi>
	220	<mn>0</mn>
	221	<mo stretchy="false">)</mo>
	222	</mrow></math>
	223
	224	is the Hessian of th <code><i>i</i></code>-th component of
	225	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	226	<mi mathvariant='italic'>F</mi>
	227	</mrow></math>
	228
	229	,
	230	evaluated at
	231	<code><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	232	.
	233
	234	<br/>
	235	<br/>
	236	<b><big><a name="f" id="f">f</a></big></b>
	237	<br/>
	238	The object
	239	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	240	has prototype
	241
	242	<code><font color="blue"><span style='white-space: nowrap'><br/>
	243	ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	244	</span></font></code>
	245	Note that the <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
	246	object
	247	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	248	is not <code><font color="blue">const</font></code>.
	249	Before this call to <code><font color="blue">Forward</font></code>, the value returned by
	250
	251	<code><font color="blue"><span style='white-space: nowrap'><br/>
	252	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()<br/>
	253	</span></font></code>
	254	must be greater than or equal two.
	255	After this call it will be will be three (see <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
	256	).
	257
	258	<br/>
	259	<br/>
	260	<b><big><a name="x0" id="x0">x0</a></big></b>
	261	<br/>
	262	The vector
	263	<code><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	264	in the formula for
	265	<code><i><font color="black"><span style='white-space: nowrap'>y2</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'>]</span></font></code>
	266
	267	corresponds to the previous call to <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
	268
	269	using this ADFun object
	270	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	271	; i.e.,
	272
	273	<code><font color="blue"><span style='white-space: nowrap'><br/>
	274	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(0, </span></font><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	275	</span></font></code>
	276	If there is no previous call with the first argument zero,
	277	the value of the <a href="independent.xml" target="_top"><span style='white-space: nowrap'>independent</span></a>
	278	variables
	279	during the recording of the AD sequence of operations is used
	280	for
	281	<code><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	282	.
	283
	284	<br/>
	285	<br/>
	286	<b><big><a name="x1" id="x1">x1</a></big></b>
	287	<br/>
	288	The vector
	289	<code><i><font color="black"><span style='white-space: nowrap'>x1</span></font></i></code>
	290	in the formula for
	291	<code><i><font color="black"><span style='white-space: nowrap'>y2</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'>]</span></font></code>
	292
	293	corresponds to the previous call to <a href="forward_one.xml" target="_top"><span style='white-space: nowrap'>forward_one</span></a>
	294
	295	using this ADFun object
	296	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	297	; i.e.,
	298
	299	<code><font color="blue"><span style='white-space: nowrap'><br/>
	300	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(1, </span></font><i><font color="black"><span style='white-space: nowrap'>x1</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	301	</span></font></code>
	302	<br/>
	303	<b><big><a name="x2" id="x2">x2</a></big></b>
	304	<br/>
	305	The argument
	306	<code><i><font color="black"><span style='white-space: nowrap'>x2</span></font></i></code>
	307	has prototype
	308
	309	<code><font color="blue"><span style='white-space: nowrap'><br/>
	310	const </span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'>& </span></font><i><font color="black"><span style='white-space: nowrap'>x2</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	311	</span></font></code>
	312	(see <a href="forward_two.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
	313	below)
	314	and its size must be equal to
	315	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	316	, the dimension of the
	317	<a href="seq_property.xml#Domain" target="_top"><span style='white-space: nowrap'>domain</span></a>
	318	space for
	319	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	320	.
	321
	322	<br/>
	323	<br/>
	324	<b><big><a name="y2" id="y2">y2</a></big></b>
	325	<br/>
	326	The result
	327	<code><i><font color="black"><span style='white-space: nowrap'>y2</span></font></i></code>
	328	has prototype
	329
	330	<code><font color="blue"><span style='white-space: nowrap'><br/>
	331	</span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>y2</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	332	</span></font></code>
	333	(see <a href="forward_two.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
	334	below)
	335	The size of
	336	<code><i><font color="black"><span style='white-space: nowrap'>y1</span></font></i></code>
	337	is equal to
	338	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
	339	, the dimension of the
	340	<a href="seq_property.xml#Range" target="_top"><span style='white-space: nowrap'>range</span></a>
	341	space for
	342	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	343	.
	344	Its value is given element-wise by the formula in the
	345	<a href="forward_two.xml#Purpose" target="_top"><span style='white-space: nowrap'>purpose</span></a>
	346	above.
	347
	348	<br/>
	349	<br/>
	350	<b><big><a name="Vector" id="Vector">Vector</a></big></b>
	351	<br/>
	352	The type
	353	<code><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i></code>
	354	must be a <a href="simplevector.xml" target="_top"><span style='white-space: nowrap'>SimpleVector</span></a>
	355	class with
	356	<a href="simplevector.xml#Elements of Specified Type" target="_top"><span style='white-space: nowrap'>elements of type</span></a>
	357
	358
	359	<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
	360	.
	361	The routine <a href="checksimplevector.xml" target="_top"><span style='white-space: nowrap'>CheckSimpleVector</span></a>
	362	will generate an error message
	363	if this is not the case.
	364
	365	<br/>
	366	<br/>
	367	<b><big><a name="Example" id="Example">Example</a></big></b>
	368	<br/>
	369	The file
	370	<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
	371
	372	contains an example and test of this operation.
	373	It returns true if it succeeds and false otherwise.
	374
	375	<br/>
	376	<br/>
	377	<b><big><a name="Special Case" id="Special Case">Special Case</a></big></b>
	378	<br/>
	379	This is special case of <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward_order</span></a>
	380	where
	381
	382	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	383	<mtable rowalign="center" ><mtr><mtd columnalign="right" >
	384	<mi mathvariant='italic'>Y</mi>
	385	<mo stretchy="false">(</mo>
	386	<mi mathvariant='italic'>t</mi>
	387	<mo stretchy="false">)</mo>
	388	</mtd><mtd columnalign="center" >
	389	<mo stretchy="false">=</mo>
	390	<mi mathvariant='italic'>F</mi>
	391	<mo stretchy="false">[</mo>
	392	<mi mathvariant='italic'>X</mi>
	393	<mo stretchy="false">(</mo>
	394	<mi mathvariant='italic'>t</mi>
	395	<mo stretchy="false">)</mo>
	396	<mo stretchy="false">]</mo>
	397	</mtd></mtr><mtr><mtd columnalign="right" >
	398	<mi mathvariant='italic'>X</mi>
	399	<mo stretchy="false">(</mo>
	400	<mi mathvariant='italic'>t</mi>
	401	<mo stretchy="false">)</mo>
	402	</mtd><mtd columnalign="center" >
	403	<mo stretchy="false">=</mo>
	404	</mtd><mtd columnalign="left" >
	405	<msup><mi mathvariant='italic'>x</mi>
	406	<mrow><mo stretchy="false">(</mo>
	407	<mn>0</mn>
	408	<mo stretchy="false">)</mo>
	409	</mrow>
	410	</msup>
	411	<msup><mi mathvariant='italic'>t</mi>
	412	<mn>0</mn>
	413	</msup>
	414	<mo stretchy="false">+</mo>
	415	<msup><mi mathvariant='italic'>x</mi>
	416	<mrow><mo stretchy="false">(</mo>
	417	<mn>1</mn>
	418	<mo stretchy="false">)</mo>
	419	</mrow>
	420	</msup>
	421	<mo stretchy="false">*</mo>
	422	<msup><mi mathvariant='italic'>t</mi>
	423	<mn>1</mn>
	424	</msup>
	425	<mo stretchy="false">+</mo>
	426	<mo stretchy="false">⋯</mo>
	427	<mo stretchy="false">,</mo>
	428	<mo stretchy="false">+</mo>
	429	<msup><mi mathvariant='italic'>x</mi>
	430	<mrow><mo stretchy="false">(</mo>
	431	<mi mathvariant='italic'>q</mi>
	432	<mo stretchy="false">)</mo>
	433	</mrow>
	434	</msup>
	435	<mo stretchy="false">*</mo>
	436	<msup><mi mathvariant='italic'>t</mi>
	437	<mi mathvariant='italic'>q</mi>
	438	</msup>
	439	<mo stretchy="false">+</mo>
	440	<mi mathvariant='italic'>o</mi>
	441	<mo stretchy="false">(</mo>
	442	<msup><mi mathvariant='italic'>t</mi>
	443	<mi mathvariant='italic'>q</mi>
	444	</msup>
	445	<mo stretchy="false">)</mo>
	446	</mtd></mtr><mtr><mtd columnalign="right" >
	447	<mi mathvariant='italic'>Y</mi>
	448	<mo stretchy="false">(</mo>
	449	<mi mathvariant='italic'>t</mi>
	450	<mo stretchy="false">)</mo>
	451	</mtd><mtd columnalign="center" >
	452	<mo stretchy="false">=</mo>
	453	</mtd><mtd columnalign="left" >
	454	<msup><mi mathvariant='italic'>y</mi>
	455	<mrow><mo stretchy="false">(</mo>
	456	<mn>0</mn>
	457	<mo stretchy="false">)</mo>
	458	</mrow>
	459	</msup>
	460	<msup><mi mathvariant='italic'>t</mi>
	461	<mn>0</mn>
	462	</msup>
	463	<mo stretchy="false">+</mo>
	464	<msup><mi mathvariant='italic'>y</mi>
	465	<mrow><mo stretchy="false">(</mo>
	466	<mn>1</mn>
	467	<mo stretchy="false">)</mo>
	468	</mrow>
	469	</msup>
	470	<mo stretchy="false">*</mo>
	471	<msup><mi mathvariant='italic'>t</mi>
	472	<mn>1</mn>
	473	</msup>
	474	<mo stretchy="false">+</mo>
	475	<mo stretchy="false">⋯</mo>
	476	<mo stretchy="false">,</mo>
	477	<mo stretchy="false">+</mo>
	478	<msup><mi mathvariant='italic'>y</mi>
	479	<mrow><mo stretchy="false">(</mo>
	480	<mi mathvariant='italic'>q</mi>
	481	<mo stretchy="false">)</mo>
	482	</mrow>
	483	</msup>
	484	<mo stretchy="false">*</mo>
	485	<msup><mi mathvariant='italic'>t</mi>
	486	<mi mathvariant='italic'>q</mi>
	487	</msup>
	488	<mo stretchy="false">+</mo>
	489	<mi mathvariant='italic'>o</mi>
	490	<mo stretchy="false">(</mo>
	491	<msup><mi mathvariant='italic'>t</mi>
	492	<mi mathvariant='italic'>q</mi>
	493	</msup>
	494	<mo stretchy="false">)</mo>
	495	</mtd></mtr></mtable>
	496	</mrow></math>
	497
	498	and
	499	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	500	<mi mathvariant='italic'>o</mi>
	501	<mo stretchy="false">(</mo>
	502	<msup><mi mathvariant='italic'>t</mi>
	503	<mi mathvariant='italic'>q</mi>
	504	</msup>
	505	<mo stretchy="false">)</mo>
	506	<mo stretchy="false">*</mo>
	507	<msup><mi mathvariant='italic'>t</mi>
	508	<mrow><mo stretchy="false">-</mo>
	509	<mi mathvariant='italic'>q</mi>
	510	</mrow>
	511	</msup>
	512	<mo stretchy="false">→</mo>
	513	<mn>0</mn>
	514	</mrow></math>
	515
	516	as
	517	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	518	<mi mathvariant='italic'>t</mi>
	519	<mo stretchy="false">→</mo>
	520	<mn>0</mn>
	521	</mrow></math>
	522
	523	.
	524	For this special case,
	525	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	526	<mi mathvariant='italic'>q</mi>
	527	<mo stretchy="false">=</mo>
	528	<mn>2</mn>
	529	</mrow></math>
	530
	531	,
	532
	533	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	534	<msup><mi mathvariant='italic'>x</mi>
	535	<mrow><mo stretchy="false">(</mo>
	536	<mn>0</mn>
	537	<mo stretchy="false">)</mo>
	538	</mrow>
	539	</msup>
	540	</mrow></math>
	541
	542
	543	<code><font color="blue"><span style='white-space: nowrap'>= </span></font><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	544	,
	545
	546	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	547	<msup><mi mathvariant='italic'>x</mi>
	548	<mrow><mo stretchy="false">(</mo>
	549	<mn>1</mn>
	550	<mo stretchy="false">)</mo>
	551	</mrow>
	552	</msup>
	553	</mrow></math>
	554
	555
	556	<code><font color="blue"><span style='white-space: nowrap'>= </span></font><i><font color="black"><span style='white-space: nowrap'>x1</span></font></i></code>
	557	,
	558
	559	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	560	<mi mathvariant='italic'>X</mi>
	561	<mo stretchy="false">(</mo>
	562	<mi mathvariant='italic'>t</mi>
	563	<mo stretchy="false">)</mo>
	564	<mo stretchy="false">=</mo>
	565	<msup><mi mathvariant='italic'>x</mi>
	566	<mrow><mo stretchy="false">(</mo>
	567	<mn>0</mn>
	568	<mo stretchy="false">)</mo>
	569	</mrow>
	570	</msup>
	571	<mo stretchy="false">+</mo>
	572	<msup><mi mathvariant='italic'>x</mi>
	573	<mrow><mo stretchy="false">(</mo>
	574	<mn>1</mn>
	575	<mo stretchy="false">)</mo>
	576	</mrow>
	577	</msup>
	578	<mi mathvariant='italic'>t</mi>
	579	<mo stretchy="false">+</mo>
	580	<msup><mi mathvariant='italic'>x</mi>
	581	<mrow><mo stretchy="false">(</mo>
	582	<mn>2</mn>
	583	<mo stretchy="false">)</mo>
	584	</mrow>
	585	</msup>
	586	<msup><mi mathvariant='italic'>t</mi>
	587	<mn>2</mn>
	588	</msup>
	589	</mrow></math>
	590
	591	, and
	592
	593	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	594	<msup><mi mathvariant='italic'>y</mi>
	595	<mrow><mo stretchy="false">(</mo>
	596	<mn>0</mn>
	597	<mo stretchy="false">)</mo>
	598	</mrow>
	599	</msup>
	600	<mo stretchy="false">+</mo>
	601	<msup><mi mathvariant='italic'>y</mi>
	602	<mrow><mo stretchy="false">(</mo>
	603	<mn>1</mn>
	604	<mo stretchy="false">)</mo>
	605	</mrow>
	606	</msup>
	607	<mi mathvariant='italic'>t</mi>
	608	<mo stretchy="false">+</mo>
	609	<msup><mi mathvariant='italic'>y</mi>
	610	<mrow><mo stretchy="false">(</mo>
	611	<mn>2</mn>
	612	<mo stretchy="false">)</mo>
	613	</mrow>
	614	</msup>
	615	<msup><mi mathvariant='italic'>t</mi>
	616	<mn>2</mn>
	617	</msup>
	618	<mo stretchy="false">=</mo>
	619	<mi mathvariant='italic'>F</mi>
	620	<mo stretchy="false">[</mo>
	621	<msup><mi mathvariant='italic'>x</mi>
	622	<mrow><mo stretchy="false">(</mo>
	623	<mn>0</mn>
	624	<mo stretchy="false">)</mo>
	625	</mrow>
	626	</msup>
	627	<mo stretchy="false">+</mo>
	628	<msup><mi mathvariant='italic'>x</mi>
	629	<mrow><mo stretchy="false">(</mo>
	630	<mn>1</mn>
	631	<mo stretchy="false">)</mo>
	632	</mrow>
	633	</msup>
	634	<mi mathvariant='italic'>t</mi>
	635	<mo stretchy="false">+</mo>
	636	<msup><mi mathvariant='italic'>x</mi>
	637	<mrow><mo stretchy="false">(</mo>
	638	<mn>2</mn>
	639	<mo stretchy="false">)</mo>
	640	</mrow>
	641	</msup>
	642	<msup><mi mathvariant='italic'>t</mi>
	643	<mn>2</mn>
	644	</msup>
	645	<mo stretchy="false">]</mo>
	646	<mo stretchy="false">+</mo>
	647	<mi mathvariant='italic'>o</mi>
	648	<mo stretchy="false">(</mo>
	649	<msup><mi mathvariant='italic'>t</mi>
	650	<mn>2</mn>
	651	</msup>
	652	<mo stretchy="false">)</mo>
	653	</mrow></math>
	654
	655	Restricting our attention to the <code><i>i</i></code>-th component, and
	656	taking the derivative with respect to
	657	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	658	<mi mathvariant='italic'>t</mi>
	659	</mrow></math>
	660
	661	, we obtain
	662
	663	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	664	<msubsup><mi mathvariant='italic'>y</mi>
	665	<mi mathvariant='italic'>i</mi>
	666	<mrow><mo stretchy="false">(</mo>
	667	<mn>1</mn>
	668	<mo stretchy="false">)</mo>
	669	</mrow>
	670	</msubsup>
	671	<mo stretchy="false">+</mo>
	672	<mn>2</mn>
	673	<msubsup><mi mathvariant='italic'>y</mi>
	674	<mi mathvariant='italic'>i</mi>
	675	<mrow><mo stretchy="false">(</mo>
	676	<mn>2</mn>
	677	<mo stretchy="false">)</mo>
	678	</mrow>
	679	</msubsup>
	680	<mi mathvariant='italic'>t</mi>
	681	<mo stretchy="false">=</mo>
	682	<msubsup><mi mathvariant='italic'>F</mi>
	683	<mi mathvariant='italic'>i</mi>
	684	<mrow><mo stretchy="false">(</mo>
	685	<mn>1</mn>
	686	<mo stretchy="false">)</mo>
	687	</mrow>
	688	</msubsup>
	689	<mo stretchy="false">[</mo>
	690	<msup><mi mathvariant='italic'>x</mi>
	691	<mrow><mo stretchy="false">(</mo>
	692	<mn>0</mn>
	693	<mo stretchy="false">)</mo>
	694	</mrow>
	695	</msup>
	696	<mo stretchy="false">+</mo>
	697	<msup><mi mathvariant='italic'>x</mi>
	698	<mrow><mo stretchy="false">(</mo>
	699	<mn>1</mn>
	700	<mo stretchy="false">)</mo>
	701	</mrow>
	702	</msup>
	703	<mi mathvariant='italic'>t</mi>
	704	<mo stretchy="false">+</mo>
	705	<msup><mi mathvariant='italic'>x</mi>
	706	<mrow><mo stretchy="false">(</mo>
	707	<mn>2</mn>
	708	<mo stretchy="false">)</mo>
	709	</mrow>
	710	</msup>
	711	<msup><mi mathvariant='italic'>t</mi>
	712	<mn>2</mn>
	713	</msup>
	714	<mo stretchy="false">]</mo>
	715	<mo stretchy="false">[</mo>
	716	<msup><mi mathvariant='italic'>x</mi>
	717	<mrow><mo stretchy="false">(</mo>
	718	<mn>1</mn>
	719	<mo stretchy="false">)</mo>
	720	</mrow>
	721	</msup>
	722	<mo stretchy="false">+</mo>
	723	<mn>2</mn>
	724	<msup><mi mathvariant='italic'>x</mi>
	725	<mrow><mo stretchy="false">(</mo>
	726	<mn>2</mn>
	727	<mo stretchy="false">)</mo>
	728	</mrow>
	729	</msup>
	730	<mi mathvariant='italic'>t</mi>
	731	<mo stretchy="false">]</mo>
	732	<mo stretchy="false">+</mo>
	733	<mi mathvariant='italic'>o</mi>
	734	<mo stretchy="false">(</mo>
	735	<mi mathvariant='italic'>t</mi>
	736	<mo stretchy="false">)</mo>
	737	</mrow></math>
	738
	739	Taking a second derivative with respect to
	740	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	741	<mi mathvariant='italic'>t</mi>
	742	</mrow></math>
	743
	744	,
	745	and evaluating at
	746	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	747	<mi mathvariant='italic'>t</mi>
	748	<mo stretchy="false">=</mo>
	749	<mn>0</mn>
	750	</mrow></math>
	751
	752	, we obtain
	753
	754	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	755	<mn>2</mn>
	756	<msubsup><mi mathvariant='italic'>y</mi>
	757	<mi mathvariant='italic'>i</mi>
	758	<mrow><mo stretchy="false">(</mo>
	759	<mn>2</mn>
	760	<mo stretchy="false">)</mo>
	761	</mrow>
	762	</msubsup>
	763	<mo stretchy="false">=</mo>
	764	<mo stretchy="false">[</mo>
	765	<msup><mi mathvariant='italic'>x</mi>
	766	<mrow><mo stretchy="false">(</mo>
	767	<mn>1</mn>
	768	<mo stretchy="false">)</mo>
	769	</mrow>
	770	</msup>
	771	<msup><mo stretchy="false">]</mo>
	772	<mi mathvariant='italic'>T</mi>
	773	</msup>
	774	<msubsup><mi mathvariant='italic'>F</mi>
	775	<mi mathvariant='italic'>i</mi>
	776	<mrow><mo stretchy="false">(</mo>
	777	<mn>2</mn>
	778	<mo stretchy="false">)</mo>
	779	</mrow>
	780	</msubsup>
	781	<mo stretchy="false">[</mo>
	782	<msup><mi mathvariant='italic'>x</mi>
	783	<mrow><mo stretchy="false">(</mo>
	784	<mn>0</mn>
	785	<mo stretchy="false">)</mo>
	786	</mrow>
	787	</msup>
	788	<mo stretchy="false">]</mo>
	789	<msup><mi mathvariant='italic'>x</mi>
	790	<mrow><mo stretchy="false">(</mo>
	791	<mn>1</mn>
	792	<mo stretchy="false">)</mo>
	793	</mrow>
	794	</msup>
	795	<mo stretchy="false">+</mo>
	796	<msubsup><mi mathvariant='italic'>F</mi>
	797	<mi mathvariant='italic'>i</mi>
	798	<mrow><mo stretchy="false">(</mo>
	799	<mn>1</mn>
	800	<mo stretchy="false">)</mo>
	801	</mrow>
	802	</msubsup>
	803	<mo stretchy="false">[</mo>
	804	<msup><mi mathvariant='italic'>x</mi>
	805	<mrow><mo stretchy="false">(</mo>
	806	<mn>0</mn>
	807	<mo stretchy="false">)</mo>
	808	</mrow>
	809	</msup>
	810	<mo stretchy="false">]</mo>
	811	<mn>2</mn>
	812	<msup><mi mathvariant='italic'>x</mi>
	813	<mrow><mo stretchy="false">(</mo>
	814	<mn>2</mn>
	815	<mo stretchy="false">)</mo>
	816	</mrow>
	817	</msup>
	818	</mrow></math>
	819
	820	which agrees with the specification for
	821	<code><i><font color="black"><span style='white-space: nowrap'>y2</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'>]</span></font></code>
	822	in the
	823	<a href="forward_two.xml#Purpose" target="_top"><span style='white-space: nowrap'>purpose</span></a>
	824	above.
	825
	826
	827	<hr/>Input File: omh/forward/forward_two.omh
	828
	829	</body>
	830	</html>

+514

-0

doc/forward_zero.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Zero Order Forward Mode: Function Values</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Zero Order Forward Mode: Function Values"/>
	8	<meta name="keywords" id="keywords" content=" Forward order zero forward mode: function values syntax purpose f x0 s y0 vector example special case "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_forward_zero_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="forward.xml" target="_top">Prev</a>
	25	</td><td><a href="forward_one.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>forward_zero</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>ADFun-></option>
	49	<option>Independent</option>
	50	<option>FunConstruct</option>
	51	<option>Dependent</option>
	52	<option>abort_recording</option>
	53	<option>seq_property</option>
	54	<option>FunEval</option>
	55	<option>Drivers</option>
	56	<option>FunCheck</option>
	57	<option>optimize</option>
	58	<option>check_for_nan</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>FunEval-></option>
	64	<option>Forward</option>
	65	<option>Reverse</option>
	66	<option>Sparse</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>Forward-></option>
	72	<option>forward_zero</option>
	73	<option>forward_one</option>
	74	<option>forward_two</option>
	75	<option>forward_order</option>
	76	<option>forward_dir</option>
	77	<option>size_order</option>
	78	<option>CompareChange</option>
	79	<option>capacity_order</option>
	80	<option>number_skip</option>
	81	</select>
	82	</td>
	83	<td>forward_zero</td>
	84	<td>
	85	<select onchange='choose_current0(this)'>
	86	<option>Headings-></option>
	87	<option>Syntax</option>
	88	<option>Purpose</option>
	89	<option>f</option>
	90	<option>x0</option>
	91	<option>s</option>
	92	<option>y0</option>
	93	<option>Vector</option>
	94	<option>Example</option>
	95	<option>Special Case</option>
	96	</select>
	97	</td>
	98	</tr></table><br/>
	99	<center><b><big><big>Zero Order Forward Mode: Function Values</big></big></b></center>
	100	<br/>
	101	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
	102
	103	<br/>
	104
	105	<code><i><font color="black"><span style='white-space: nowrap'>y0</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(0, </span></font><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	106	</span></font></code>
	107
	108	<code><i><font color="black"><span style='white-space: nowrap'>y0</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(0, </span></font><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
	109
	110
	111	<br/>
	112	<br/>
	113	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	114	<br/>
	115	We use
	116	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	117	<mi mathvariant='italic'>F</mi>
	118	<mo stretchy="false">:</mo>
	119	<msup><mi mathvariant='italic'>B</mi>
	120	<mi mathvariant='italic'>n</mi>
	121	</msup>
	122	<mo stretchy="false">→</mo>
	123	<msup><mi mathvariant='italic'>B</mi>
	124	<mi mathvariant='italic'>m</mi>
	125	</msup>
	126	</mrow></math>
	127
	128	to denote the
	129	<a href="glossary.xml#AD Function" target="_top"><span style='white-space: nowrap'>AD function</span></a>
	130	corresponding to
	131	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	132	.
	133	The result of the syntax above is
	134
	135	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	136	<mi mathvariant='italic'>y</mi>
	137	<mn>0</mn>
	138	<mo stretchy="false">=</mo>
	139	<mi mathvariant='italic'>F</mi>
	140	<mo stretchy="false">(</mo>
	141	<mi mathvariant='italic'>x</mi>
	142	<mn>0</mn>
	143	<mo stretchy="false">)</mo>
	144	</mrow></math>
	145
	146	See the <a href="funcheck.xml#Discussion" target="_top"><span style='white-space: nowrap'>FunCheck discussion</span></a>
	147	for
	148	possible differences between
	149	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	150	<mi mathvariant='italic'>F</mi>
	151	<mo stretchy="false">(</mo>
	152	<mi mathvariant='italic'>x</mi>
	153	<mo stretchy="false">)</mo>
	154	</mrow></math>
	155
	156	and the algorithm that defined
	157	the operation sequence.
	158
	159	<br/>
	160	<br/>
	161	<b><big><a name="f" id="f">f</a></big></b>
	162	<br/>
	163	The object
	164	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	165	has prototype
	166
	167	<code><font color="blue"><span style='white-space: nowrap'><br/>
	168	ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	169	</span></font></code>
	170	Note that the <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
	171	object
	172	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	173	is not <code><font color="blue">const</font></code>.
	174	After this call to <code><font color="blue">Forward</font></code>, the value returned by
	175
	176	<code><font color="blue"><span style='white-space: nowrap'><br/>
	177	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()<br/>
	178	</span></font></code>
	179	will be equal to one (see <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
	180	).
	181
	182	<br/>
	183	<br/>
	184	<b><big><a name="x0" id="x0">x0</a></big></b>
	185	<br/>
	186	The argument
	187	<code><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	188	has prototype
	189
	190	<code><font color="blue"><span style='white-space: nowrap'><br/>
	191	const </span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'>& </span></font><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	192	</span></font></code>
	193	(see <a href="forward_zero.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
	194	below)
	195	and its size must be equal to
	196	<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
	197	, the dimension of the
	198	<a href="seq_property.xml#Domain" target="_top"><span style='white-space: nowrap'>domain</span></a>
	199	space for
	200	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	201	.
	202
	203	<br/>
	204	<br/>
	205	<b><big><a name="s" id="s">s</a></big></b>
	206	<br/>
	207	If the argument
	208	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
	209	is not present, <code><font color="blue">std::cout</font></code>
	210	is used in its place.
	211	Otherwise, this argument has prototype
	212
	213	<code><font color="blue"><span style='white-space: nowrap'><br/>
	214	std::ostream& </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	215	</span></font></code>
	216	It specifies where the output corresponding to <a href="printfor.xml" target="_top"><span style='white-space: nowrap'>PrintFor</span></a>
	217	,
	218	and this zero order forward mode call, will be written.
	219
	220	<br/>
	221	<br/>
	222	<b><big><a name="y0" id="y0">y0</a></big></b>
	223	<br/>
	224	The result
	225	<code><i><font color="black"><span style='white-space: nowrap'>y0</span></font></i></code>
	226	has prototype
	227
	228	<code><font color="blue"><span style='white-space: nowrap'><br/>
	229	</span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>y0</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	230	</span></font></code>
	231	(see <a href="forward_zero.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
	232	below)
	233	and its value is
	234	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	235	<mi mathvariant='italic'>F</mi>
	236	<mo stretchy="false">(</mo>
	237	<mi mathvariant='italic'>x</mi>
	238	<mo stretchy="false">)</mo>
	239	</mrow></math>
	240
	241	at
	242	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	243	.
	244	The size of
	245	<code><i><font color="black"><span style='white-space: nowrap'>y0</span></font></i></code>
	246	is equal to
	247	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
	248	, the dimension of the
	249	<a href="seq_property.xml#Range" target="_top"><span style='white-space: nowrap'>range</span></a>
	250	space for
	251	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	252	.
	253
	254	<br/>
	255	<br/>
	256	<b><big><a name="Vector" id="Vector">Vector</a></big></b>
	257	<br/>
	258	The type
	259	<code><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i></code>
	260	must be a <a href="simplevector.xml" target="_top"><span style='white-space: nowrap'>SimpleVector</span></a>
	261	class with
	262	<a href="simplevector.xml#Elements of Specified Type" target="_top"><span style='white-space: nowrap'>elements of type</span></a>
	263
	264
	265	<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
	266	.
	267	The routine <a href="checksimplevector.xml" target="_top"><span style='white-space: nowrap'>CheckSimpleVector</span></a>
	268	will generate an error message
	269	if this is not the case.
	270
	271	<br/>
	272	<br/>
	273	<b><big><a name="Example" id="Example">Example</a></big></b>
	274	<br/>
	275	The file
	276	<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
	277
	278	contains an example and test of this operation.
	279	It returns true if it succeeds and false otherwise.
	280
	281	<br/>
	282	<br/>
	283	<b><big><a name="Special Case" id="Special Case">Special Case</a></big></b>
	284	<br/>
	285	This is special case of <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward_order</span></a>
	286	where
	287
	288	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	289	<mtable rowalign="center" ><mtr><mtd columnalign="right" >
	290	<mi mathvariant='italic'>Y</mi>
	291	<mo stretchy="false">(</mo>
	292	<mi mathvariant='italic'>t</mi>
	293	<mo stretchy="false">)</mo>
	294	</mtd><mtd columnalign="center" >
	295	<mo stretchy="false">=</mo>
	296	</mtd><mtd columnalign="left" >
	297	<mi mathvariant='italic'>F</mi>
	298	<mo stretchy="false">[</mo>
	299	<mi mathvariant='italic'>X</mi>
	300	<mo stretchy="false">(</mo>
	301	<mi mathvariant='italic'>t</mi>
	302	<mo stretchy="false">)</mo>
	303	<mo stretchy="false">]</mo>
	304	</mtd></mtr><mtr><mtd columnalign="right" >
	305	<mi mathvariant='italic'>X</mi>
	306	<mo stretchy="false">(</mo>
	307	<mi mathvariant='italic'>t</mi>
	308	<mo stretchy="false">)</mo>
	309	</mtd><mtd columnalign="center" >
	310	<mo stretchy="false">=</mo>
	311	</mtd><mtd columnalign="left" >
	312	<msup><mi mathvariant='italic'>x</mi>
	313	<mrow><mo stretchy="false">(</mo>
	314	<mn>0</mn>
	315	<mo stretchy="false">)</mo>
	316	</mrow>
	317	</msup>
	318	<msup><mi mathvariant='italic'>t</mi>
	319	<mn>0</mn>
	320	</msup>
	321	<mo stretchy="false">+</mo>
	322	<msup><mi mathvariant='italic'>x</mi>
	323	<mrow><mo stretchy="false">(</mo>
	324	<mn>1</mn>
	325	<mo stretchy="false">)</mo>
	326	</mrow>
	327	</msup>
	328	<mo stretchy="false">*</mo>
	329	<msup><mi mathvariant='italic'>t</mi>
	330	<mn>1</mn>
	331	</msup>
	332	<mo stretchy="false">+</mo>
	333	<mo stretchy="false">⋯</mo>
	334	<mo stretchy="false">,</mo>
	335	<mo stretchy="false">+</mo>
	336	<msup><mi mathvariant='italic'>x</mi>
	337	<mrow><mo stretchy="false">(</mo>
	338	<mi mathvariant='italic'>q</mi>
	339	<mo stretchy="false">)</mo>
	340	</mrow>
	341	</msup>
	342	<mo stretchy="false">*</mo>
	343	<msup><mi mathvariant='italic'>t</mi>
	344	<mi mathvariant='italic'>q</mi>
	345	</msup>
	346	<mo stretchy="false">+</mo>
	347	<mi mathvariant='italic'>o</mi>
	348	<mo stretchy="false">(</mo>
	349	<msup><mi mathvariant='italic'>t</mi>
	350	<mi mathvariant='italic'>q</mi>
	351	</msup>
	352	<mo stretchy="false">)</mo>
	353	</mtd></mtr><mtr><mtd columnalign="right" >
	354	<mi mathvariant='italic'>Y</mi>
	355	<mo stretchy="false">(</mo>
	356	<mi mathvariant='italic'>t</mi>
	357	<mo stretchy="false">)</mo>
	358	</mtd><mtd columnalign="center" >
	359	<mo stretchy="false">=</mo>
	360	</mtd><mtd columnalign="left" >
	361	<msup><mi mathvariant='italic'>y</mi>
	362	<mrow><mo stretchy="false">(</mo>
	363	<mn>0</mn>
	364	<mo stretchy="false">)</mo>
	365	</mrow>
	366	</msup>
	367	<msup><mi mathvariant='italic'>t</mi>
	368	<mn>0</mn>
	369	</msup>
	370	<mo stretchy="false">+</mo>
	371	<msup><mi mathvariant='italic'>y</mi>
	372	<mrow><mo stretchy="false">(</mo>
	373	<mn>1</mn>
	374	<mo stretchy="false">)</mo>
	375	</mrow>
	376	</msup>
	377	<mo stretchy="false">*</mo>
	378	<msup><mi mathvariant='italic'>t</mi>
	379	<mn>1</mn>
	380	</msup>
	381	<mo stretchy="false">+</mo>
	382	<mo stretchy="false">⋯</mo>
	383	<mo stretchy="false">,</mo>
	384	<mo stretchy="false">+</mo>
	385	<msup><mi mathvariant='italic'>y</mi>
	386	<mrow><mo stretchy="false">(</mo>
	387	<mi mathvariant='italic'>q</mi>
	388	<mo stretchy="false">)</mo>
	389	</mrow>
	390	</msup>
	391	<mo stretchy="false">*</mo>
	392	<msup><mi mathvariant='italic'>t</mi>
	393	<mi mathvariant='italic'>q</mi>
	394	</msup>
	395	<mo stretchy="false">+</mo>
	396	<mi mathvariant='italic'>o</mi>
	397	<mo stretchy="false">(</mo>
	398	<msup><mi mathvariant='italic'>t</mi>
	399	<mi mathvariant='italic'>q</mi>
	400	</msup>
	401	<mo stretchy="false">)</mo>
	402	</mtd></mtr></mtable>
	403	</mrow></math>
	404
	405	and
	406	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	407	<mi mathvariant='italic'>o</mi>
	408	<mo stretchy="false">(</mo>
	409	<msup><mi mathvariant='italic'>t</mi>
	410	<mi mathvariant='italic'>q</mi>
	411	</msup>
	412	<mo stretchy="false">)</mo>
	413	<mo stretchy="false">*</mo>
	414	<msup><mi mathvariant='italic'>t</mi>
	415	<mrow><mo stretchy="false">-</mo>
	416	<mi mathvariant='italic'>q</mi>
	417	</mrow>
	418	</msup>
	419	<mo stretchy="false">→</mo>
	420	<mn>0</mn>
	421	</mrow></math>
	422
	423	as
	424	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	425	<mi mathvariant='italic'>t</mi>
	426	<mo stretchy="false">→</mo>
	427	<mn>0</mn>
	428	</mrow></math>
	429
	430	.
	431	For this special case,
	432	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	433	<mi mathvariant='italic'>q</mi>
	434	<mo stretchy="false">=</mo>
	435	<mn>0</mn>
	436	</mrow></math>
	437
	438	,
	439
	440	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	441	<msup><mi mathvariant='italic'>x</mi>
	442	<mrow><mo stretchy="false">(</mo>
	443	<mn>0</mn>
	444	<mo stretchy="false">)</mo>
	445	</mrow>
	446	</msup>
	447	</mrow></math>
	448
	449
	450	<code><font color="blue"><span style='white-space: nowrap'>= </span></font><i><font color="black"><span style='white-space: nowrap'>x0</span></font></i></code>
	451	,
	452
	453	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	454	<mi mathvariant='italic'>X</mi>
	455	<mo stretchy="false">(</mo>
	456	<mi mathvariant='italic'>t</mi>
	457	<mo stretchy="false">)</mo>
	458	<mo stretchy="false">=</mo>
	459	<msup><mi mathvariant='italic'>x</mi>
	460	<mrow><mo stretchy="false">(</mo>
	461	<mn>0</mn>
	462	<mo stretchy="false">)</mo>
	463	</mrow>
	464	</msup>
	465	</mrow></math>
	466
	467	, and
	468
	469	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
	470	<msup><mi mathvariant='italic'>y</mi>
	471	<mrow><mo stretchy="false">(</mo>
	472	<mn>0</mn>
	473	<mo stretchy="false">)</mo>
	474	</mrow>
	475	</msup>
	476	<mo stretchy="false">=</mo>
	477	<mi mathvariant='italic'>Y</mi>
	478	<mo stretchy="false">(</mo>
	479	<mi mathvariant='italic'>t</mi>
	480	<mo stretchy="false">)</mo>
	481	<mo stretchy="false">=</mo>
	482	<mi mathvariant='italic'>F</mi>
	483	<mo stretchy="false">[</mo>
	484	<mi mathvariant='italic'>X</mi>
	485	<mo stretchy="false">(</mo>
	486	<mi mathvariant='italic'>t</mi>
	487	<mo stretchy="false">)</mo>
	488	<mo stretchy="false">]</mo>
	489	<mo stretchy="false">=</mo>
	490	<mi mathvariant='italic'>F</mi>
	491	<mo stretchy="false">(</mo>
	492	<msup><mi mathvariant='italic'>x</mi>
	493	<mrow><mo stretchy="false">(</mo>
	494	<mn>0</mn>
	495	<mo stretchy="false">)</mo>
	496	</mrow>
	497	</msup>
	498	<mo stretchy="false">)</mo>
	499	</mrow></math>
	500
	501	which agrees with the specifications for
	502
	503	<code><i><font color="black"><span style='white-space: nowrap'>y0</span></font></i></code>
	504	in the <a href="forward_zero.xml#Purpose" target="_top"><span style='white-space: nowrap'>purpose</span></a>
	505	above.
	506
	507
	508
	509
	510	<hr/>Input File: omh/forward/forward_zero.omh
	511
	512	</body>
	513	</html>

-1721

~~doc/forwardany.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>Any Order Forward Mode</title>
6		<meta name="description" id="description" content="Any Order Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" forward mode derivative calculate "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_forwardany_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td><a href="forwardone.xml" target="_top">Prev</a>
24		</td><td><a href="size_taylor.xml" target="_top">Next</a>
25		</td><td>
26		<select onchange='choose_across0(this)'>
27		<option>Index-></option>
28		<option>contents</option>
29		<option>reference</option>
30		<option>index</option>
31		<option>search</option>
32		<option>external</option>
33		</select>
34		</td>
35		<td>
36		<select onchange='choose_up0(this)'>
37		<option>Up-></option>
38		<option>CppAD</option>
39		<option>ADFun</option>
40		<option>FunEval</option>
41		<option>Forward</option>
42		<option>ForwardAny</option>
43		</select>
44		</td>
45		<td>
46		<select onchange='choose_down3(this)'>
47		<option>ADFun-></option>
48		<option>Independent</option>
49		<option>FunConstruct</option>
50		<option>Dependent</option>
51		<option>abort_recording</option>
52		<option>seq_property</option>
53		<option>FunEval</option>
54		<option>Drivers</option>
55		<option>FunCheck</option>
56		<option>optimize</option>
57		<option>check_for_nan</option>
58		</select>
59		</td>
60		<td>
61		<select onchange='choose_down2(this)'>
62		<option>FunEval-></option>
63		<option>Forward</option>
64		<option>Reverse</option>
65		<option>Sparse</option>
66		</select>
67		</td>
68		<td>
69		<select onchange='choose_down1(this)'>
70		<option>Forward-></option>
71		<option>ForwardZero</option>
72		<option>ForwardOne</option>
73		<option>ForwardAny</option>
74		<option>size_taylor</option>
75		<option>CompareChange</option>
76		<option>capacity_taylor</option>
77		<option>number_skip</option>
78		<option>forward.cpp</option>
79		<option>forward_mul.cpp</option>
80		</select>
81		</td>
82		<td>ForwardAny</td>
83		<td>
84		<select onchange='choose_current0(this)'>
85		<option>Headings-></option>
86		<option>Syntax</option>
87		<option>Purpose</option>
88		<option>---..Function Values</option>
89		<option>---..Derivative Values</option>
90		<option>X(t)</option>
91		<option>Y(t)</option>
92		<option>f</option>
93		<option>p</option>
94		<option>x_p</option>
95		<option>---..Restrictions</option>
96		<option>---..One Order</option>
97		<option>---..Multiple Orders</option>
98		<option>s</option>
99		<option>y_p</option>
100		<option>---..One Order</option>
101		<option>---..Multiple Orders</option>
102		<option>Vector</option>
103		<option>Zero Order</option>
104		<option>First Order</option>
105		<option>Second Order</option>
106		<option>Example</option>
107		</select>
108		</td>
109		</tr></table><br/>
110
111
112
113		<center><b><big><big>Any Order Forward Mode</big></big></b></center>
114		<br/>
115		<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
116
117		<br/>
118
119		<code><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'> )<br/>
120		</span></font></code>
121
122		<code><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
123		</span></font></code>
124		<br/>
125		<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
126		<br/>
127		We use
128		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
129		<mi mathvariant='italic'>F</mi>
130		<mo stretchy="false">:</mo>
131		<msup><mi mathvariant='italic'>B</mi>
132		<mi mathvariant='italic'>n</mi>
133		</msup>
134		<mo stretchy="false">→</mo>
135		<msup><mi mathvariant='italic'>B</mi>
136		<mi mathvariant='italic'>m</mi>
137		</msup>
138		</mrow></math>
139
140		to denote the
141		<a href="glossary.xml#AD Function" target="_top"><span style='white-space: nowrap'>AD function</span></a>
142		corresponding to
143		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
144		.
145		Given a function
146		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
147		<mi mathvariant='italic'>X</mi>
148		<mo stretchy="false">:</mo>
149		<mi mathvariant='italic'>B</mi>
150		<mo stretchy="false">→</mo>
151		<msup><mi mathvariant='italic'>B</mi>
152		<mi mathvariant='italic'>n</mi>
153		</msup>
154		</mrow></math>
155
156		,
157		defined by its
158		<a href="glossary.xml#Taylor Coefficient" target="_top"><span style='white-space: nowrap'>Taylor coefficients</span></a>
159		,
160		forward mode computes the Taylor coefficients for the function
161
162		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
163		<mi mathvariant='italic'>Y</mi>
164		<mo stretchy="false">(</mo>
165		<mi mathvariant='italic'>t</mi>
166		<mo stretchy="false">)</mo>
167		<mo stretchy="false">=</mo>
168		<mi mathvariant='italic'>F</mi>
169		<mo stretchy="false">[</mo>
170		<mi mathvariant='italic'>X</mi>
171		<mo stretchy="false">(</mo>
172		<mi mathvariant='italic'>t</mi>
173		<mo stretchy="false">)</mo>
174		<mo stretchy="false">]</mo>
175		</mrow></math>
176
177		<br/>
178		<b><a name="Purpose.Function Values" id="Purpose.Function Values">Function Values</a></b>
179		<br/>
180		If you are using forward mode to compute values for
181		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
182		<mi mathvariant='italic'>F</mi>
183		<mo stretchy="false">(</mo>
184		<mi mathvariant='italic'>x</mi>
185		<mo stretchy="false">)</mo>
186		</mrow></math>
187
188		,
189		<a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>ForwardZero</span></a>
190		is simpler to understand
191		than this explanation of the general case.
192
193		<br/>
194		<br/>
195		<b><a name="Purpose.Derivative Values" id="Purpose.Derivative Values">Derivative Values</a></b>
196		<br/>
197		If you are using forward mode to compute values for
198		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
199		<msup><mi mathvariant='italic'>F</mi>
200		<mrow><mo stretchy="false">(</mo>
201		<mn>1</mn>
202		<mo stretchy="false">)</mo>
203		</mrow>
204		</msup>
205		<mo stretchy="false">(</mo>
206		<mi mathvariant='italic'>x</mi>
207		<mo stretchy="false">)</mo>
208		<mo stretchy="false">*</mo>
209		<mi mathvariant='italic'>dx</mi>
210		</mrow></math>
211
212		,
213		<a href="forwardone.xml" target="_top"><span style='white-space: nowrap'>ForwardOne</span></a>
214		is simpler to understand
215		than this explanation of the general case.
216
217		<br/>
218		<br/>
219		<b><big><a name="X(t)" id="X(t)">X(t)</a></big></b>
220		<br/>
221		The function
222
223		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
224		<mi mathvariant='italic'>X</mi>
225		<mo stretchy="false">:</mo>
226		<mi mathvariant='italic'>B</mi>
227		<mo stretchy="false">→</mo>
228		<msup><mi mathvariant='italic'>B</mi>
229		<mi mathvariant='italic'>n</mi>
230		</msup>
231		</mrow></math>
232
233		is defined using
234		a sequence of Taylor coefficients
235		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
236		<msup><mi mathvariant='italic'>x</mi>
237		<mrow><mo stretchy="false">(</mo>
238		<mi mathvariant='italic'>k</mi>
239		<mo stretchy="false">)</mo>
240		</mrow>
241		</msup>
242		<mo stretchy="false">∈</mo>
243		<msup><mi mathvariant='italic'>B</mi>
244		<mi mathvariant='italic'>n</mi>
245		</msup>
246		</mrow></math>
247
248		:
249
250		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
251		<mi mathvariant='italic'>X</mi>
252		<mo stretchy="false">(</mo>
253		<mi mathvariant='italic'>t</mi>
254		<mo stretchy="false">)</mo>
255		<mo stretchy="false">=</mo>
256		<msup><mi mathvariant='italic'>x</mi>
257		<mrow><mo stretchy="false">(</mo>
258		<mn>0</mn>
259		<mo stretchy="false">)</mo>
260		</mrow>
261		</msup>
262		<mo stretchy="false">+</mo>
263		<msup><mi mathvariant='italic'>x</mi>
264		<mrow><mo stretchy="false">(</mo>
265		<mn>1</mn>
266		<mo stretchy="false">)</mo>
267		</mrow>
268		</msup>
269		<mo stretchy="false">*</mo>
270		<mi mathvariant='italic'>t</mi>
271		<mo stretchy="false">+</mo>
272		<mo stretchy="false">⋯</mo>
273		<mo stretchy="false">+</mo>
274		<msup><mi mathvariant='italic'>x</mi>
275		<mrow><mo stretchy="false">(</mo>
276		<mi mathvariant='italic'>p</mi>
277		<mo stretchy="false">)</mo>
278		</mrow>
279		</msup>
280		<mo stretchy="false">*</mo>
281		<msup><mi mathvariant='italic'>t</mi>
282		<mi mathvariant='italic'>p</mi>
283		</msup>
284		</mrow></math>
285
286		For
287		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
288		<mi mathvariant='italic'>k</mi>
289		<mo stretchy="false">=</mo>
290		<mn>0</mn>
291		<mo stretchy="false">,</mo>
292		<mo stretchy="false">…</mo>
293		<mo stretchy="false">,</mo>
294		<mi mathvariant='italic'>p</mi>
295		</mrow></math>
296
297		,
298		the vector
299		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
300		<msup><mi mathvariant='italic'>x</mi>
301		<mrow><mo stretchy="false">(</mo>
302		<mi mathvariant='italic'>k</mi>
303		<mo stretchy="false">)</mo>
304		</mrow>
305		</msup>
306		</mrow></math>
307
308		above is defined as the value of
309
310		<code><i><font color="black"><span style='white-space: nowrap'>x_k</span></font></i></code>
311		in the previous call (counting this call) of the form
312
313		<code><font color="blue"><span style='white-space: nowrap'><br/>
314		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>x_k</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
315		</span></font></code>
316		If there is no previous call with
317		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
318		<mi mathvariant='italic'>k</mi>
319		<mo stretchy="false">=</mo>
320		<mn>0</mn>
321		</mrow></math>
322
323		,
324
325		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
326		<msup><mi mathvariant='italic'>x</mi>
327		<mrow><mo stretchy="false">(</mo>
328		<mn>0</mn>
329		<mo stretchy="false">)</mo>
330		</mrow>
331		</msup>
332		</mrow></math>
333
334		is the value of the independent variables when the
335		corresponding
336		AD of
337		<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
338
339		<a href="glossary.xml#Operation.Sequence" target="_top"><span style='white-space: nowrap'>operation sequence</span></a>
340		was recorded.
341		Note that
342
343		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
344		<msup><mi mathvariant='italic'>x</mi>
345		<mrow><mo stretchy="false">(</mo>
346		<mi mathvariant='italic'>k</mi>
347		<mo stretchy="false">)</mo>
348		</mrow>
349		</msup>
350		</mrow></math>
351
352		is related to the <i>k</i>-th derivative of
353		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
354		<mi mathvariant='italic'>X</mi>
355		<mo stretchy="false">(</mo>
356		<mi mathvariant='italic'>t</mi>
357		<mo stretchy="false">)</mo>
358		</mrow></math>
359
360		by
361
362		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
363		<msup><mi mathvariant='italic'>x</mi>
364		<mrow><mo stretchy="false">(</mo>
365		<mi mathvariant='italic'>k</mi>
366		<mo stretchy="false">)</mo>
367		</mrow>
368		</msup>
369		<mo stretchy="false">=</mo>
370		<mfrac><mrow><mn>1</mn>
371		</mrow>
372		<mrow><mi mathvariant='italic'>k</mi>
373		<mo stretchy="false">!</mo>
374		</mrow>
375		</mfrac>
376		<msup><mi mathvariant='italic'>X</mi>
377		<mrow><mo stretchy="false">(</mo>
378		<mi mathvariant='italic'>k</mi>
379		<mo stretchy="false">)</mo>
380		</mrow>
381		</msup>
382		<mo stretchy="false">(</mo>
383		<mn>0</mn>
384		<mo stretchy="false">)</mo>
385		</mrow></math>
386
387		<br/>
388		<b><big><a name="Y(t)" id="Y(t)">Y(t)</a></big></b>
389		<br/>
390		The function
391
392		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
393		<mi mathvariant='italic'>Y</mi>
394		<mo stretchy="false">:</mo>
395		<mi mathvariant='italic'>B</mi>
396		<mo stretchy="false">→</mo>
397		<msup><mi mathvariant='italic'>B</mi>
398		<mi mathvariant='italic'>m</mi>
399		</msup>
400		</mrow></math>
401
402		is defined by
403
404		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
405		<mi mathvariant='italic'>Y</mi>
406		<mo stretchy="false">(</mo>
407		<mi mathvariant='italic'>t</mi>
408		<mo stretchy="false">)</mo>
409		<mo stretchy="false">=</mo>
410		<mi mathvariant='italic'>F</mi>
411		<mo stretchy="false">[</mo>
412		<mi mathvariant='italic'>X</mi>
413		<mo stretchy="false">(</mo>
414		<mi mathvariant='italic'>t</mi>
415		<mo stretchy="false">)</mo>
416		<mo stretchy="false">]</mo>
417		</mrow></math>
418
419		.
420		We use
421		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
422		<msup><mi mathvariant='italic'>y</mi>
423		<mrow><mo stretchy="false">(</mo>
424		<mi mathvariant='italic'>k</mi>
425		<mo stretchy="false">)</mo>
426		</mrow>
427		</msup>
428		<mo stretchy="false">∈</mo>
429		<msup><mi mathvariant='italic'>B</mi>
430		<mi mathvariant='italic'>m</mi>
431		</msup>
432		</mrow></math>
433
434
435		to denote the <i>k</i>-th order Taylor coefficient of
436		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
437		<mi mathvariant='italic'>Y</mi>
438		<mo stretchy="false">(</mo>
439		<mi mathvariant='italic'>t</mi>
440		<mo stretchy="false">)</mo>
441		</mrow></math>
442
443		; i.e.,
444
445		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
446		<mi mathvariant='italic'>Y</mi>
447		<mo stretchy="false">(</mo>
448		<mi mathvariant='italic'>t</mi>
449		<mo stretchy="false">)</mo>
450		<mo stretchy="false">=</mo>
451		<msup><mi mathvariant='italic'>y</mi>
452		<mrow><mo stretchy="false">(</mo>
453		<mn>0</mn>
454		<mo stretchy="false">)</mo>
455		</mrow>
456		</msup>
457		<mo stretchy="false">+</mo>
458		<msup><mi mathvariant='italic'>y</mi>
459		<mrow><mo stretchy="false">(</mo>
460		<mn>1</mn>
461		<mo stretchy="false">)</mo>
462		</mrow>
463		</msup>
464		<mo stretchy="false">*</mo>
465		<mi mathvariant='italic'>t</mi>
466		<mo stretchy="false">+</mo>
467		<mo stretchy="false">⋯</mo>
468		<mo stretchy="false">,</mo>
469		<mo stretchy="false">+</mo>
470		<msup><mi mathvariant='italic'>y</mi>
471		<mrow><mo stretchy="false">(</mo>
472		<mi mathvariant='italic'>p</mi>
473		<mo stretchy="false">)</mo>
474		</mrow>
475		</msup>
476		<mo stretchy="false">*</mo>
477		<msup><mi mathvariant='italic'>t</mi>
478		<mi mathvariant='italic'>p</mi>
479		</msup>
480		<mo stretchy="false">+</mo>
481		<mi mathvariant='italic'>o</mi>
482		<mo stretchy="false">(</mo>
483		<msup><mi mathvariant='italic'>t</mi>
484		<mi mathvariant='italic'>p</mi>
485		</msup>
486		<mo stretchy="false">)</mo>
487		</mrow></math>
488
489		where
490		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
491		<mi mathvariant='italic'>o</mi>
492		<mo stretchy="false">(</mo>
493		<msup><mi mathvariant='italic'>t</mi>
494		<mi mathvariant='italic'>p</mi>
495		</msup>
496		<mo stretchy="false">)</mo>
497		<mo stretchy="false">*</mo>
498		<msup><mi mathvariant='italic'>t</mi>
499		<mrow><mo stretchy="false">-</mo>
500		<mi mathvariant='italic'>p</mi>
501		</mrow>
502		</msup>
503		<mo stretchy="false">→</mo>
504		<mn>0</mn>
505		</mrow></math>
506
507
508		as
509		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
510		<mi mathvariant='italic'>t</mi>
511		<mo stretchy="false">→</mo>
512		<mn>0</mn>
513		</mrow></math>
514
515		.
516		Note that
517		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
518		<msup><mi mathvariant='italic'>y</mi>
519		<mrow><mo stretchy="false">(</mo>
520		<mi mathvariant='italic'>k</mi>
521		<mo stretchy="false">)</mo>
522		</mrow>
523		</msup>
524		</mrow></math>
525
526		is related to
527		the <i>k</i>-th derivative of
528		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
529		<mi mathvariant='italic'>Y</mi>
530		<mo stretchy="false">(</mo>
531		<mi mathvariant='italic'>t</mi>
532		<mo stretchy="false">)</mo>
533		</mrow></math>
534
535		by
536
537		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
538		<msup><mi mathvariant='italic'>y</mi>
539		<mrow><mo stretchy="false">(</mo>
540		<mi mathvariant='italic'>k</mi>
541		<mo stretchy="false">)</mo>
542		</mrow>
543		</msup>
544		<mo stretchy="false">=</mo>
545		<mfrac><mrow><mn>1</mn>
546		</mrow>
547		<mrow><mi mathvariant='italic'>k</mi>
548		<mo stretchy="false">!</mo>
549		</mrow>
550		</mfrac>
551		<msup><mi mathvariant='italic'>Y</mi>
552		<mrow><mo stretchy="false">(</mo>
553		<mi mathvariant='italic'>k</mi>
554		<mo stretchy="false">)</mo>
555		</mrow>
556		</msup>
557		<mo stretchy="false">(</mo>
558		<mn>0</mn>
559		<mo stretchy="false">)</mo>
560		</mrow></math>
561
562		<br/>
563		<b><big><a name="f" id="f">f</a></big></b>
564		<br/>
565		The <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
566		object
567		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
568		has prototype
569
570		<code><font color="blue"><span style='white-space: nowrap'><br/>
571		ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
572		</span></font></code>
573		Note that the <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
574		object
575		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
576		is not <code><font color="blue">const</font></code>.
577		Before this call to <code><font color="blue">Forward</font></code>, the value returned by
578
579		<code><font color="blue"><span style='white-space: nowrap'><br/>
580		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()<br/>
581		</span></font></code>
582		must be greater than or equal
583		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
584		<mi mathvariant='italic'>p</mi>
585		</mrow></math>
586
587		.
588		After this call it will be will be
589		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
590		<mi mathvariant='italic'>p</mi>
591		<mo stretchy="false">+</mo>
592		<mn>1</mn>
593		</mrow></math>
594
595		(see <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
596		).
597
598		<br/>
599		<br/>
600		<b><big><a name="p" id="p">p</a></big></b>
601		<br/>
602		The argument
603		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
604		has prototype
605
606		<code><font color="blue"><span style='white-space: nowrap'><br/>
607		size_t </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
608		</span></font></code>
609		and specifies the order of the Taylor coefficients to be calculated.
610
611		<br/>
612		<br/>
613		<b><big><a name="x_p" id="x_p">x_p</a></big></b>
614		<br/>
615		The argument
616		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i></code>
617		has prototype
618
619		<code><font color="blue"><span style='white-space: nowrap'><br/>
620		const </span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'>& </span></font><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
621		</span></font></code>
622		(see <a href="forwardany.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
623		below).
624		As above, we use
625		<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
626		to denote the dimension of the
627		<a href="seq_property.xml#Domain" target="_top"><span style='white-space: nowrap'>domain</span></a>
628		space for
629		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
630		.
631		The size of
632		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i></code>
633		must be either
634		<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
635		or
636
637		<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i><font color="blue"><span style='white-space: nowrap'>*(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
638		.
639
640		<br/>
641		<br/>
642		<b><a name="x_p.Restrictions" id="x_p.Restrictions">Restrictions</a></b>
643		<br/>
644		Note if
645		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
646		uses <a href="old_atomic.xml" target="_top"><span style='white-space: nowrap'>old_atomic</span></a>
647		functions,
648		the size of
649		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i></code>
650		must be
651		<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
652		.
653
654		<br/>
655		<br/>
656		<b><a name="x_p.One Order" id="x_p.One Order">One Order</a></b>
657		<br/>
658		If
659		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
660		,
661		The <i>p</i>-th order Taylor coefficient for
662		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
663		<mi mathvariant='italic'>X</mi>
664		<mo stretchy="false">(</mo>
665		<mi mathvariant='italic'>t</mi>
666		<mo stretchy="false">)</mo>
667		</mrow></math>
668
669
670		is defined by this value; i.e.,
671		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
672		<msup><mi mathvariant='italic'>x</mi>
673		<mrow><mo stretchy="false">(</mo>
674		<mi mathvariant='italic'>p</mi>
675		<mo stretchy="false">)</mo>
676		</mrow>
677		</msup>
678		<mo stretchy="false">=</mo>
679		<mi mathvariant='italic'>x</mi>
680		<mo stretchy="false">_</mo>
681		<mi mathvariant='italic'>p</mi>
682		</mrow></math>
683
684		.
685		For
686		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
687		<mi mathvariant='italic'>k</mi>
688		<mo stretchy="false">=</mo>
689		<mn>0</mn>
690		<mo stretchy="false">,</mo>
691		<mo stretchy="false">…</mo>
692		<mo stretchy="false">,</mo>
693		<mi mathvariant='italic'>p</mi>
694		<mn>-1</mn>
695		</mrow></math>
696
697		,
698		the <i>k</i>-th order Taylor coefficient
699		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
700		<msup><mi mathvariant='italic'>x</mi>
701		<mrow><mo stretchy="false">(</mo>
702		<mi mathvariant='italic'>k</mi>
703		<mo stretchy="false">)</mo>
704		</mrow>
705		</msup>
706		</mrow></math>
707
708
709		is defined by
710		<code><i><font color="black"><span style='white-space: nowrap'>x_k</span></font></i></code>
711		in the previous call to
712
713		<code><font color="blue"><span style='white-space: nowrap'><br/>
714		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>x_k</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
715		</span></font></code>
716		<br/>
717		<b><a name="x_p.Multiple Orders" id="x_p.Multiple Orders">Multiple Orders</a></b>
718		<br/>
719		If
720		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i><font color="blue"><span style='white-space: nowrap'>*(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
721		,
722		For
723		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
724		<mi mathvariant='italic'>k</mi>
725		<mo stretchy="false">=</mo>
726		<mn>0</mn>
727		<mo stretchy="false">,</mo>
728		<mo stretchy="false">…</mo>
729		<mo stretchy="false">,</mo>
730		<mi mathvariant='italic'>p</mi>
731		</mrow></math>
732
733		,
734		for
735		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
736		<mi mathvariant='italic'>j</mi>
737		<mo stretchy="false">=</mo>
738		<mn>0</mn>
739		<mo stretchy="false">,</mo>
740		<mo stretchy="false">…</mo>
741		<mo stretchy="false">,</mo>
742		<mi mathvariant='italic'>n</mi>
743		</mrow></math>
744
745		,
746		the <i>j</i>-th component of the <i>k</i>-th order Taylor coefficient
747
748		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
749		<msubsup><mi mathvariant='italic'>x</mi>
750		<mi mathvariant='italic'>j</mi>
751		<mrow><mo stretchy="false">(</mo>
752		<mi mathvariant='italic'>k</mi>
753		<mo stretchy="false">)</mo>
754		</mrow>
755		</msubsup>
756		</mrow></math>
757
758
759		is defined by
760		<code><i><font color="black"><span style='white-space: nowrap'>x_j^k</span></font></i></code>
761		were
762
763		<code><font color="blue"><span style='white-space: nowrap'><br/>
764		</span></font><i><font color="black"><span style='white-space: nowrap'>x_j^k</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>[ </span></font><i><font color="black"><span style='white-space: nowrap'>j</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> + </span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'> ]<br/>
765		</span></font></code>
766		<br/>
767		<b><big><a name="s" id="s">s</a></big></b>
768		<br/>
769		If the argument
770		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
771		is not present, <code><font color="blue">std::cout</font></code>
772		is used in its place.
773		Otherwise, this argument has prototype
774
775		<code><font color="blue"><span style='white-space: nowrap'><br/>
776		std::ostream& </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
777		</span></font></code>
778		If
779		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> == 0</span></font></code>
780		,
781
782		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
783		specifies where the output corresponding to <a href="printfor.xml" target="_top"><span style='white-space: nowrap'>PrintFor</span></a>
784
785		will be written.
786		If
787		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> != 0</span></font></code>
788		,
789		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
790		is not used.
791
792		<br/>
793		<br/>
794		<b><big><a name="y_p" id="y_p">y_p</a></big></b>
795		<br/>
796		The return value
797		<code><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i></code>
798		has prototype
799
800		<code><font color="blue"><span style='white-space: nowrap'><br/>
801		</span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
802		</span></font></code>
803		(see <a href="forwardany.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
804		below).
805		As above, we use
806		<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
807		to denote the dimension of the
808		<a href="seq_property.xml#Range" target="_top"><span style='white-space: nowrap'>range</span></a>
809		space for
810		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
811		.
812
813		<br/>
814		<br/>
815		<b><a name="y_p.One Order" id="y_p.One Order">One Order</a></b>
816		<br/>
817		If
818		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
819		,
820		the vector
821		<code><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i></code>
822		has size
823		<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
824		.
825		The <i>p</i>-th order Taylor coefficient for
826		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
827		<mi mathvariant='italic'>Y</mi>
828		<mo stretchy="false">(</mo>
829		<mi mathvariant='italic'>t</mi>
830		<mo stretchy="false">)</mo>
831		</mrow></math>
832
833
834		is defined by this value; i.e.,
835		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
836		<msup><mi mathvariant='italic'>y</mi>
837		<mrow><mo stretchy="false">(</mo>
838		<mi mathvariant='italic'>p</mi>
839		<mo stretchy="false">)</mo>
840		</mrow>
841		</msup>
842		<mo stretchy="false">=</mo>
843		<mi mathvariant='italic'>y</mi>
844		<mo stretchy="false">_</mo>
845		<mi mathvariant='italic'>p</mi>
846		</mrow></math>
847
848		.
849
850		<br/>
851		<br/>
852		<b><a name="y_p.Multiple Orders" id="y_p.Multiple Orders">Multiple Orders</a></b>
853		<br/>
854		If
855		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i><font color="blue"><span style='white-space: nowrap'>*(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
856		,
857		the vector
858		<code><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i></code>
859		has size
860		<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'>*(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>+1)</span></font></code>
861		.
862		For
863		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
864		<mi mathvariant='italic'>k</mi>
865		<mo stretchy="false">=</mo>
866		<mn>0</mn>
867		<mo stretchy="false">,</mo>
868		<mo stretchy="false">…</mo>
869		<mo stretchy="false">,</mo>
870		<mi mathvariant='italic'>p</mi>
871		</mrow></math>
872
873		,
874		for
875		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
876		<mi mathvariant='italic'>i</mi>
877		<mo stretchy="false">=</mo>
878		<mn>0</mn>
879		<mo stretchy="false">,</mo>
880		<mo stretchy="false">…</mo>
881		<mo stretchy="false">,</mo>
882		<mi mathvariant='italic'>m</mi>
883		</mrow></math>
884
885		,
886		the <i>i</i>-th component of the <i>k</i>-th order Taylor coefficient
887
888		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
889		<msubsup><mi mathvariant='italic'>y</mi>
890		<mi mathvariant='italic'>i</mi>
891		<mrow><mo stretchy="false">(</mo>
892		<mi mathvariant='italic'>k</mi>
893		<mo stretchy="false">)</mo>
894		</mrow>
895		</msubsup>
896		</mrow></math>
897
898
899		is defined by
900		<code><i><font color="black"><span style='white-space: nowrap'>y_i^k</span></font></i></code>
901		were
902
903		<code><font color="blue"><span style='white-space: nowrap'><br/>
904		</span></font><i><font color="black"><span style='white-space: nowrap'>y_i^k</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i><font color="blue"><span style='white-space: nowrap'>[ </span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> + </span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'> ]<br/>
905		</span></font></code>
906		<br/>
907		<b><big><a name="Vector" id="Vector">Vector</a></big></b>
908		<br/>
909		The type
910		<code><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i></code>
911		must be a <a href="simplevector.xml" target="_top"><span style='white-space: nowrap'>SimpleVector</span></a>
912		class with
913		<a href="simplevector.xml#Elements of Specified Type" target="_top"><span style='white-space: nowrap'>elements of type</span></a>
914
915
916		<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
917		.
918		The routine <a href="checksimplevector.xml" target="_top"><span style='white-space: nowrap'>CheckSimpleVector</span></a>
919		will generate an error message
920		if this is not the case.
921
922		<br/>
923		<br/>
924		<b><big><a name="Zero Order" id="Zero Order">Zero Order</a></big></b>
925		<br/>
926		In the case where
927		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
928		<mi mathvariant='italic'>p</mi>
929		<mo stretchy="false">=</mo>
930		<mn>0</mn>
931		</mrow></math>
932
933		and
934		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
935		,
936		the result
937		<code><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i></code>
938		is given by
939
940		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
941		<mtable rowalign="center" ><mtr><mtd columnalign="right" >
942		<msup><mi mathvariant='italic'>y</mi>
943		<mrow><mo stretchy="false">(</mo>
944		<mn>0</mn>
945		<mo stretchy="false">)</mo>
946		</mrow>
947		</msup>
948		</mtd><mtd columnalign="center" >
949		<mo stretchy="false">=</mo>
950		</mtd><mtd columnalign="left" >
951		<mo stretchy="false">(</mo>
952		<mi mathvariant='italic'>F</mi>
953		<mo stretchy="false">∘</mo>
954		<mi mathvariant='italic'>X</mi>
955		<mo stretchy="false">)</mo>
956		<mo stretchy="false">(</mo>
957		<mn>0</mn>
958		<mo stretchy="false">)</mo>
959		</mtd></mtr><mtr><mtd columnalign="right" >
960		</mtd><mtd columnalign="center" >
961		<mo stretchy="false">=</mo>
962		</mtd><mtd columnalign="left" >
963		<mi mathvariant='italic'>F</mi>
964		<mo stretchy="false">[</mo>
965		<msup><mi mathvariant='italic'>x</mi>
966		<mrow><mo stretchy="false">(</mo>
967		<mn>0</mn>
968		<mo stretchy="false">)</mo>
969		</mrow>
970		</msup>
971		<mo stretchy="false">]</mo>
972		</mtd></mtr></mtable>
973		</mrow></math>
974
975		The agrees with the simplification where
976
977		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
978		<mi mathvariant='italic'>p</mi>
979		</mrow></math>
980
981		,
982
983		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
984		<msup><mi mathvariant='italic'>x</mi>
985		<mrow><mo stretchy="false">(</mo>
986		<mn>0</mn>
987		<mo stretchy="false">)</mo>
988		</mrow>
989		</msup>
990		</mrow></math>
991
992		, and
993
994		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
995		<msup><mi mathvariant='italic'>y</mi>
996		<mrow><mo stretchy="false">(</mo>
997		<mn>0</mn>
998		<mo stretchy="false">)</mo>
999		</mrow>
1000		</msup>
1001		</mrow></math>
1002
1003		above are replaced by
1004		<code><font color="blue">0</font></code>,
1005
1006		<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
1007		, and
1008
1009		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
1010
1011		in <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>ForwardZero</span></a>
1012		.
1013
1014		<br/>
1015		<br/>
1016		<b><big><a name="First Order" id="First Order">First Order</a></big></b>
1017		<br/>
1018		In the case where
1019		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1020		<mi mathvariant='italic'>p</mi>
1021		<mo stretchy="false">=</mo>
1022		<mn>1</mn>
1023		</mrow></math>
1024
1025		and
1026		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
1027		,
1028		the result
1029		<code><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i></code>
1030		is given by
1031
1032		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
1033		<mtable rowalign="center" ><mtr><mtd columnalign="right" >
1034		<msup><mi mathvariant='italic'>y</mi>
1035		<mrow><mo stretchy="false">(</mo>
1036		<mn>1</mn>
1037		<mo stretchy="false">)</mo>
1038		</mrow>
1039		</msup>
1040		</mtd><mtd columnalign="center" >
1041		<mo stretchy="false">=</mo>
1042		</mtd><mtd columnalign="left" >
1043		<mo stretchy="false">(</mo>
1044		<mi mathvariant='italic'>F</mi>
1045		<mo stretchy="false">∘</mo>
1046		<mi mathvariant='italic'>X</mi>
1047		<msup><mo stretchy="false">)</mo>
1048		<mrow><mo stretchy="false">(</mo>
1049		<mn>1</mn>
1050		<mo stretchy="false">)</mo>
1051		</mrow>
1052		</msup>
1053		<mo stretchy="false">(</mo>
1054		<mn>0</mn>
1055		<mo stretchy="false">)</mo>
1056		</mtd></mtr><mtr><mtd columnalign="right" >
1057		</mtd><mtd columnalign="center" >
1058		<mo stretchy="false">=</mo>
1059		</mtd><mtd columnalign="left" >
1060		<msup><mi mathvariant='italic'>F</mi>
1061		<mrow><mo stretchy="false">(</mo>
1062		<mn>1</mn>
1063		<mo stretchy="false">)</mo>
1064		</mrow>
1065		</msup>
1066		<mo stretchy="false">[</mo>
1067		<mi mathvariant='italic'>X</mi>
1068		<mo stretchy="false">(</mo>
1069		<mn>0</mn>
1070		<mo stretchy="false">)</mo>
1071		<mo stretchy="false">]</mo>
1072		<mo stretchy="false">*</mo>
1073		<msup><mi mathvariant='italic'>X</mi>
1074		<mrow><mo stretchy="false">(</mo>
1075		<mn>1</mn>
1076		<mo stretchy="false">)</mo>
1077		</mrow>
1078		</msup>
1079		<mo stretchy="false">(</mo>
1080		<mn>0</mn>
1081		<mo stretchy="false">)</mo>
1082		</mtd></mtr><mtr><mtd columnalign="right" >
1083		</mtd><mtd columnalign="center" >
1084		<mo stretchy="false">=</mo>
1085		</mtd><mtd columnalign="left" >
1086		<msup><mi mathvariant='italic'>F</mi>
1087		<mrow><mo stretchy="false">(</mo>
1088		<mn>1</mn>
1089		<mo stretchy="false">)</mo>
1090		</mrow>
1091		</msup>
1092		<mo stretchy="false">(</mo>
1093		<msup><mi mathvariant='italic'>x</mi>
1094		<mrow><mo stretchy="false">(</mo>
1095		<mn>0</mn>
1096		<mo stretchy="false">)</mo>
1097		</mrow>
1098		</msup>
1099		<mo stretchy="false">)</mo>
1100		<mo stretchy="false">*</mo>
1101		<msup><mi mathvariant='italic'>x</mi>
1102		<mrow><mo stretchy="false">(</mo>
1103		<mn>1</mn>
1104		<mo stretchy="false">)</mo>
1105		</mrow>
1106		</msup>
1107		</mtd></mtr></mtable>
1108		</mrow></math>
1109
1110		The agrees with the simplification where
1111
1112		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1113		<mi mathvariant='italic'>p</mi>
1114		</mrow></math>
1115
1116		,
1117
1118		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1119		<msup><mi mathvariant='italic'>x</mi>
1120		<mrow><mo stretchy="false">(</mo>
1121		<mn>0</mn>
1122		<mo stretchy="false">)</mo>
1123		</mrow>
1124		</msup>
1125		</mrow></math>
1126
1127		,
1128
1129		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1130		<msup><mi mathvariant='italic'>x</mi>
1131		<mrow><mo stretchy="false">(</mo>
1132		<mn>1</mn>
1133		<mo stretchy="false">)</mo>
1134		</mrow>
1135		</msup>
1136		</mrow></math>
1137
1138		, and
1139
1140		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1141		<msup><mi mathvariant='italic'>y</mi>
1142		<mrow><mo stretchy="false">(</mo>
1143		<mn>1</mn>
1144		<mo stretchy="false">)</mo>
1145		</mrow>
1146		</msup>
1147		</mrow></math>
1148
1149		above are replaced by
1150		<code><font color="blue">1</font></code>,
1151
1152		<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
1153		,
1154
1155		<code><i><font color="black"><span style='white-space: nowrap'>dx</span></font></i></code>
1156		, and
1157
1158		<code><i><font color="black"><span style='white-space: nowrap'>dy</span></font></i></code>
1159
1160		in <a href="forwardone.xml" target="_top"><span style='white-space: nowrap'>ForwardOne</span></a>
1161		.
1162		<code><span style='white-space: nowrap'><br/>
1163		<br/>
1164		</span></code>Note that if
1165		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1166		<msup><mi mathvariant='italic'>x</mi>
1167		<mrow><mo stretchy="false">(</mo>
1168		<mn>1</mn>
1169		<mo stretchy="false">)</mo>
1170		</mrow>
1171		</msup>
1172		</mrow></math>
1173
1174		is the <i>j</i>-th
1175		<a href="glossary.xml#Elementary Vector" target="_top"><span style='white-space: nowrap'>elementary vector</span></a>
1176
1177
1178		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
1179		<msup><mi mathvariant='italic'>y</mi>
1180		<mrow><mo stretchy="false">(</mo>
1181		<mn>1</mn>
1182		<mo stretchy="false">)</mo>
1183		</mrow>
1184		</msup>
1185		<mo stretchy="false">=</mo>
1186		<mfrac><mrow><mo stretchy="false">∂</mo>
1187		<mi mathvariant='italic'>F</mi>
1188		</mrow>
1189		<mrow><mo stretchy="false">∂</mo>
1190		<msub><mi mathvariant='italic'>x</mi>
1191		<mi mathvariant='italic'>j</mi>
1192		</msub>
1193		</mrow>
1194		</mfrac>
1195		<mo stretchy="false">(</mo>
1196		<msup><mi mathvariant='italic'>x</mi>
1197		<mrow><mo stretchy="false">(</mo>
1198		<mn>0</mn>
1199		<mo stretchy="false">)</mo>
1200		</mrow>
1201		</msup>
1202		<mo stretchy="false">)</mo>
1203		</mrow></math>
1204
1205		<br/>
1206		<b><big><a name="Second Order" id="Second Order">Second Order</a></big></b>
1207		<br/>
1208		In the case where
1209		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1210		<mi mathvariant='italic'>p</mi>
1211		<mo stretchy="false">=</mo>
1212		<mn>2</mn>
1213		</mrow></math>
1214
1215		and
1216		<code><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
1217		,
1218		the <i>i</i>-th element of
1219		the result
1220		<code><i><font color="black"><span style='white-space: nowrap'>y_p</span></font></i></code>
1221		is given by
1222
1223		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
1224		<mtable rowalign="center" ><mtr><mtd columnalign="right" >
1225		<msubsup><mi mathvariant='italic'>y</mi>
1226		<mi mathvariant='italic'>i</mi>
1227		<mrow><mo stretchy="false">(</mo>
1228		<mn>2</mn>
1229		<mo stretchy="false">)</mo>
1230		</mrow>
1231		</msubsup>
1232		</mtd><mtd columnalign="center" >
1233		<mo stretchy="false">=</mo>
1234		</mtd><mtd columnalign="left" >
1235		<mfrac><mrow><mn>1</mn>
1236		</mrow>
1237		<mrow><mn>2</mn>
1238		</mrow>
1239		</mfrac>
1240		<mo stretchy="false">(</mo>
1241		<msub><mi mathvariant='italic'>F</mi>
1242		<mi mathvariant='italic'>i</mi>
1243		</msub>
1244		<mo stretchy="false">∘</mo>
1245		<mi mathvariant='italic'>X</mi>
1246		<msup><mo stretchy="false">)</mo>
1247		<mrow><mo stretchy="false">(</mo>
1248		<mn>2</mn>
1249		<mo stretchy="false">)</mo>
1250		</mrow>
1251		</msup>
1252		<mo stretchy="false">(</mo>
1253		<mn>0</mn>
1254		<mo stretchy="false">)</mo>
1255		</mtd></mtr><mtr><mtd columnalign="right" >
1256		</mtd><mtd columnalign="center" >
1257		<mo stretchy="false">=</mo>
1258		</mtd><mtd columnalign="left" >
1259		<mfrac><mrow><mn>1</mn>
1260		</mrow>
1261		<mrow><mn>2</mn>
1262		</mrow>
1263		</mfrac>
1264		<mrow><mo stretchy="true">[</mo><mrow><msubsup><mi mathvariant='italic'>F</mi>
1265		<mi mathvariant='italic'>i</mi>
1266		<mrow><mo stretchy="false">(</mo>
1267		<mn>1</mn>
1268		<mo stretchy="false">)</mo>
1269		</mrow>
1270		</msubsup>
1271		<mo stretchy="false">[</mo>
1272		<mi mathvariant='italic'>X</mi>
1273		<mo stretchy="false">(</mo>
1274		<mn>0</mn>
1275		<mo stretchy="false">)</mo>
1276		<mo stretchy="false">]</mo>
1277		<mo stretchy="false">*</mo>
1278		<msup><mi mathvariant='italic'>X</mi>
1279		<mrow><mo stretchy="false">(</mo>
1280		<mn>2</mn>
1281		<mo stretchy="false">)</mo>
1282		</mrow>
1283		</msup>
1284		<mo stretchy="false">(</mo>
1285		<mn>0</mn>
1286		<mo stretchy="false">)</mo>
1287		<mo stretchy="false">+</mo>
1288		<msup><mi mathvariant='italic'>X</mi>
1289		<mrow><mo stretchy="false">(</mo>
1290		<mn>1</mn>
1291		<mo stretchy="false">)</mo>
1292		</mrow>
1293		</msup>
1294		<mo stretchy="false">(</mo>
1295		<mn>0</mn>
1296		<msup><mo stretchy="false">)</mo>
1297		<mi mathvariant='italic'>T</mi>
1298		</msup>
1299		<mo stretchy="false">*</mo>
1300		<msubsup><mi mathvariant='italic'>F</mi>
1301		<mi mathvariant='italic'>i</mi>
1302		<mrow><mo stretchy="false">(</mo>
1303		<mn>2</mn>
1304		<mo stretchy="false">)</mo>
1305		</mrow>
1306		</msubsup>
1307		<mo stretchy="false">[</mo>
1308		<mi mathvariant='italic'>X</mi>
1309		<mo stretchy="false">(</mo>
1310		<mn>0</mn>
1311		<mo stretchy="false">)</mo>
1312		<mo stretchy="false">]</mo>
1313		<mo stretchy="false">*</mo>
1314		<msup><mi mathvariant='italic'>X</mi>
1315		<mrow><mo stretchy="false">(</mo>
1316		<mn>1</mn>
1317		<mo stretchy="false">)</mo>
1318		</mrow>
1319		</msup>
1320		<mo stretchy="false">(</mo>
1321		<mn>0</mn>
1322		<mo stretchy="false">)</mo>
1323		</mrow><mo stretchy="true">]</mo></mrow>
1324		</mtd></mtr><mtr><mtd columnalign="right" >
1325		</mtd><mtd columnalign="center" >
1326		<mo stretchy="false">=</mo>
1327		</mtd><mtd columnalign="left" >
1328		<mfrac><mrow><mn>1</mn>
1329		</mrow>
1330		<mrow><mn>2</mn>
1331		</mrow>
1332		</mfrac>
1333		<mrow><mo stretchy="true">[</mo><mrow><mn>2</mn>
1334		<mo stretchy="false">*</mo>
1335		<msubsup><mi mathvariant='italic'>F</mi>
1336		<mi mathvariant='italic'>i</mi>
1337		<mrow><mo stretchy="false">(</mo>
1338		<mn>1</mn>
1339		<mo stretchy="false">)</mo>
1340		</mrow>
1341		</msubsup>
1342		<mo stretchy="false">(</mo>
1343		<msup><mi mathvariant='italic'>x</mi>
1344		<mrow><mo stretchy="false">(</mo>
1345		<mn>0</mn>
1346		<mo stretchy="false">)</mo>
1347		</mrow>
1348		</msup>
1349		<mo stretchy="false">)</mo>
1350		<mo stretchy="false">*</mo>
1351		<msup><mi mathvariant='italic'>x</mi>
1352		<mrow><mo stretchy="false">(</mo>
1353		<mn>2</mn>
1354		<mo stretchy="false">)</mo>
1355		</mrow>
1356		</msup>
1357		<mo stretchy="false">+</mo>
1358		<mo stretchy="false">(</mo>
1359		<msup><mi mathvariant='italic'>x</mi>
1360		<mrow><mo stretchy="false">(</mo>
1361		<mn>1</mn>
1362		<mo stretchy="false">)</mo>
1363		</mrow>
1364		</msup>
1365		<msup><mo stretchy="false">)</mo>
1366		<mi mathvariant='italic'>T</mi>
1367		</msup>
1368		<mo stretchy="false">*</mo>
1369		<msubsup><mi mathvariant='italic'>F</mi>
1370		<mi mathvariant='italic'>i</mi>
1371		<mrow><mo stretchy="false">(</mo>
1372		<mn>2</mn>
1373		<mo stretchy="false">)</mo>
1374		</mrow>
1375		</msubsup>
1376		<mo stretchy="false">(</mo>
1377		<msup><mi mathvariant='italic'>x</mi>
1378		<mrow><mo stretchy="false">(</mo>
1379		<mn>0</mn>
1380		<mo stretchy="false">)</mo>
1381		</mrow>
1382		</msup>
1383		<mo stretchy="false">)</mo>
1384		<mo stretchy="false">*</mo>
1385		<msup><mi mathvariant='italic'>x</mi>
1386		<mrow><mo stretchy="false">(</mo>
1387		<mn>1</mn>
1388		<mo stretchy="false">)</mo>
1389		</mrow>
1390		</msup>
1391		</mrow><mo stretchy="true">]</mo></mrow>
1392		</mtd></mtr></mtable>
1393		</mrow></math>
1394
1395		Note that if
1396		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1397		<msup><mi mathvariant='italic'>x</mi>
1398		<mrow><mo stretchy="false">(</mo>
1399		<mn>1</mn>
1400		<mo stretchy="false">)</mo>
1401		</mrow>
1402		</msup>
1403		</mrow></math>
1404
1405		is the <i>j</i>-th
1406		<a href="glossary.xml#Elementary Vector" target="_top"><span style='white-space: nowrap'>elementary vector</span></a>
1407
1408		and
1409		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1410		<msup><mi mathvariant='italic'>x</mi>
1411		<mrow><mo stretchy="false">(</mo>
1412		<mn>2</mn>
1413		<mo stretchy="false">)</mo>
1414		</mrow>
1415		</msup>
1416		</mrow></math>
1417
1418		is zero,
1419
1420		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
1421		<mtable rowalign="center" ><mtr><mtd columnalign="right" >
1422		<mfrac><mrow><msup><mo stretchy="false">∂</mo>
1423		<mn>2</mn>
1424		</msup>
1425		<msub><mi mathvariant='italic'>F</mi>
1426		<mi mathvariant='italic'>i</mi>
1427		</msub>
1428		</mrow>
1429		<mrow><mo stretchy="false">∂</mo>
1430		<msub><mi mathvariant='italic'>x</mi>
1431		<mi mathvariant='italic'>j</mi>
1432		</msub>
1433		<mo stretchy="false">∂</mo>
1434		<msub><mi mathvariant='italic'>x</mi>
1435		<mi mathvariant='italic'>j</mi>
1436		</msub>
1437		</mrow>
1438		</mfrac>
1439		<mo stretchy="false">(</mo>
1440		<msup><mi mathvariant='italic'>x</mi>
1441		<mrow><mo stretchy="false">(</mo>
1442		<mn>0</mn>
1443		<mo stretchy="false">)</mo>
1444		</mrow>
1445		</msup>
1446		<mo stretchy="false">)</mo>
1447		<mo stretchy="false">=</mo>
1448		<mn>2</mn>
1449		<msubsup><mi mathvariant='italic'>y</mi>
1450		<mi mathvariant='italic'>i</mi>
1451		<mrow><mo stretchy="false">(</mo>
1452		<mn>2</mn>
1453		<mo stretchy="false">)</mo>
1454		</mrow>
1455		</msubsup>
1456		</mtd></mtr></mtable>
1457		</mrow></math>
1458
1459		If
1460		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1461		<msup><mi mathvariant='italic'>x</mi>
1462		<mrow><mo stretchy="false">(</mo>
1463		<mn>1</mn>
1464		<mo stretchy="false">)</mo>
1465		</mrow>
1466		</msup>
1467		</mrow></math>
1468
1469		is the sum of the <i>j</i>-th and <i>l</i>-th
1470		<a href="glossary.xml#Elementary Vector" target="_top"><span style='white-space: nowrap'>elementary vectors</span></a>
1471
1472		and
1473		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1474		<msup><mi mathvariant='italic'>x</mi>
1475		<mrow><mo stretchy="false">(</mo>
1476		<mn>2</mn>
1477		<mo stretchy="false">)</mo>
1478		</mrow>
1479		</msup>
1480		</mrow></math>
1481
1482		is zero,
1483
1484		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
1485		<mtable rowalign="center" ><mtr><mtd columnalign="right" >
1486		<msubsup><mi mathvariant='italic'>y</mi>
1487		<mi mathvariant='italic'>i</mi>
1488		<mrow><mo stretchy="false">(</mo>
1489		<mn>2</mn>
1490		<mo stretchy="false">)</mo>
1491		</mrow>
1492		</msubsup>
1493		</mtd><mtd columnalign="center" >
1494		<mo stretchy="false">=</mo>
1495		</mtd><mtd columnalign="left" >
1496		<mfrac><mrow><mn>1</mn>
1497		</mrow>
1498		<mrow><mn>2</mn>
1499		</mrow>
1500		</mfrac>
1501		<mrow><mo stretchy="true">[</mo><mrow><mfrac><mrow><msup><mo stretchy="false">∂</mo>
1502		<mn>2</mn>
1503		</msup>
1504		<msub><mi mathvariant='italic'>F</mi>
1505		<mi mathvariant='italic'>i</mi>
1506		</msub>
1507		</mrow>
1508		<mrow><mo stretchy="false">∂</mo>
1509		<msub><mi mathvariant='italic'>x</mi>
1510		<mi mathvariant='italic'>j</mi>
1511		</msub>
1512		<mo stretchy="false">∂</mo>
1513		<msub><mi mathvariant='italic'>x</mi>
1514		<mi mathvariant='italic'>j</mi>
1515		</msub>
1516		</mrow>
1517		</mfrac>
1518		<mo stretchy="false">(</mo>
1519		<msup><mi mathvariant='italic'>x</mi>
1520		<mrow><mo stretchy="false">(</mo>
1521		<mn>0</mn>
1522		<mo stretchy="false">)</mo>
1523		</mrow>
1524		</msup>
1525		<mo stretchy="false">)</mo>
1526		<mo stretchy="false">+</mo>
1527		<mfrac><mrow><msup><mo stretchy="false">∂</mo>
1528		<mn>2</mn>
1529		</msup>
1530		<msub><mi mathvariant='italic'>F</mi>
1531		<mi mathvariant='italic'>i</mi>
1532		</msub>
1533		</mrow>
1534		<mrow><mo stretchy="false">∂</mo>
1535		<msub><mi mathvariant='italic'>x</mi>
1536		<mi mathvariant='italic'>j</mi>
1537		</msub>
1538		<mo stretchy="false">∂</mo>
1539		<msub><mi mathvariant='italic'>x</mi>
1540		<mo stretchy="false">ℓ</mo>
1541		</msub>
1542		</mrow>
1543		</mfrac>
1544		<mo stretchy="false">(</mo>
1545		<msup><mi mathvariant='italic'>x</mi>
1546		<mrow><mo stretchy="false">(</mo>
1547		<mn>0</mn>
1548		<mo stretchy="false">)</mo>
1549		</mrow>
1550		</msup>
1551		<mo stretchy="false">)</mo>
1552		<mo stretchy="false">+</mo>
1553		<mfrac><mrow><msup><mo stretchy="false">∂</mo>
1554		<mn>2</mn>
1555		</msup>
1556		<msub><mi mathvariant='italic'>F</mi>
1557		<mi mathvariant='italic'>i</mi>
1558		</msub>
1559		</mrow>
1560		<mrow><mo stretchy="false">∂</mo>
1561		<msub><mi mathvariant='italic'>x</mi>
1562		<mo stretchy="false">ℓ</mo>
1563		</msub>
1564		<mo stretchy="false">∂</mo>
1565		<msub><mi mathvariant='italic'>x</mi>
1566		<mi mathvariant='italic'>j</mi>
1567		</msub>
1568		</mrow>
1569		</mfrac>
1570		<mo stretchy="false">(</mo>
1571		<msup><mi mathvariant='italic'>x</mi>
1572		<mrow><mo stretchy="false">(</mo>
1573		<mn>0</mn>
1574		<mo stretchy="false">)</mo>
1575		</mrow>
1576		</msup>
1577		<mo stretchy="false">)</mo>
1578		<mo stretchy="false">+</mo>
1579		<mfrac><mrow><msup><mo stretchy="false">∂</mo>
1580		<mn>2</mn>
1581		</msup>
1582		<msub><mi mathvariant='italic'>F</mi>
1583		<mi mathvariant='italic'>i</mi>
1584		</msub>
1585		</mrow>
1586		<mrow><mo stretchy="false">∂</mo>
1587		<msub><mi mathvariant='italic'>x</mi>
1588		<mo stretchy="false">ℓ</mo>
1589		</msub>
1590		<mo stretchy="false">∂</mo>
1591		<msub><mi mathvariant='italic'>x</mi>
1592		<mo stretchy="false">ℓ</mo>
1593		</msub>
1594		</mrow>
1595		</mfrac>
1596		<mo stretchy="false">(</mo>
1597		<msup><mi mathvariant='italic'>x</mi>
1598		<mrow><mo stretchy="false">(</mo>
1599		<mn>0</mn>
1600		<mo stretchy="false">)</mo>
1601		</mrow>
1602		</msup>
1603		<mo stretchy="false">)</mo>
1604		</mrow><mo stretchy="true">]</mo></mrow>
1605		</mtd></mtr><mtr><mtd columnalign="right" >
1606		<mfrac><mrow><msup><mo stretchy="false">∂</mo>
1607		<mn>2</mn>
1608		</msup>
1609		<msub><mi mathvariant='italic'>F</mi>
1610		<mi mathvariant='italic'>i</mi>
1611		</msub>
1612		</mrow>
1613		<mrow><mo stretchy="false">∂</mo>
1614		<msub><mi mathvariant='italic'>x</mi>
1615		<mo stretchy="false">ℓ</mo>
1616		</msub>
1617		<mo stretchy="false">∂</mo>
1618		<msub><mi mathvariant='italic'>x</mi>
1619		<mi mathvariant='italic'>j</mi>
1620		</msub>
1621		</mrow>
1622		</mfrac>
1623		<mo stretchy="false">(</mo>
1624		<msup><mi mathvariant='italic'>x</mi>
1625		<mrow><mo stretchy="false">(</mo>
1626		<mn>0</mn>
1627		<mo stretchy="false">)</mo>
1628		</mrow>
1629		</msup>
1630		<mo stretchy="false">)</mo>
1631		</mtd><mtd columnalign="center" >
1632		<mo stretchy="false">=</mo>
1633		</mtd><mtd columnalign="left" >
1634		<msubsup><mi mathvariant='italic'>y</mi>
1635		<mi mathvariant='italic'>i</mi>
1636		<mrow><mo stretchy="false">(</mo>
1637		<mn>2</mn>
1638		<mo stretchy="false">)</mo>
1639		</mrow>
1640		</msubsup>
1641		<mo stretchy="false">-</mo>
1642		<mfrac><mrow><mn>1</mn>
1643		</mrow>
1644		<mrow><mn>2</mn>
1645		</mrow>
1646		</mfrac>
1647		<mfrac><mrow><msup><mo stretchy="false">∂</mo>
1648		<mn>2</mn>
1649		</msup>
1650		<msub><mi mathvariant='italic'>F</mi>
1651		<mi mathvariant='italic'>i</mi>
1652		</msub>
1653		</mrow>
1654		<mrow><mo stretchy="false">∂</mo>
1655		<msub><mi mathvariant='italic'>x</mi>
1656		<mi mathvariant='italic'>j</mi>
1657		</msub>
1658		<mo stretchy="false">∂</mo>
1659		<msub><mi mathvariant='italic'>x</mi>
1660		<mi mathvariant='italic'>j</mi>
1661		</msub>
1662		</mrow>
1663		</mfrac>
1664		<mo stretchy="false">(</mo>
1665		<msup><mi mathvariant='italic'>x</mi>
1666		<mrow><mo stretchy="false">(</mo>
1667		<mn>0</mn>
1668		<mo stretchy="false">)</mo>
1669		</mrow>
1670		</msup>
1671		<mo stretchy="false">)</mo>
1672		<mo stretchy="false">-</mo>
1673		<mfrac><mrow><mn>1</mn>
1674		</mrow>
1675		<mrow><mn>2</mn>
1676		</mrow>
1677		</mfrac>
1678		<mfrac><mrow><msup><mo stretchy="false">∂</mo>
1679		<mn>2</mn>
1680		</msup>
1681		<msub><mi mathvariant='italic'>F</mi>
1682		<mi mathvariant='italic'>i</mi>
1683		</msub>
1684		</mrow>
1685		<mrow><mo stretchy="false">∂</mo>
1686		<msub><mi mathvariant='italic'>x</mi>
1687		<mo stretchy="false">ℓ</mo>
1688		</msub>
1689		<mo stretchy="false">∂</mo>
1690		<msub><mi mathvariant='italic'>x</mi>
1691		<mo stretchy="false">ℓ</mo>
1692		</msub>
1693		</mrow>
1694		</mfrac>
1695		<mo stretchy="false">(</mo>
1696		<msup><mi mathvariant='italic'>x</mi>
1697		<mrow><mo stretchy="false">(</mo>
1698		<mn>0</mn>
1699		<mo stretchy="false">)</mo>
1700		</mrow>
1701		</msup>
1702		<mo stretchy="false">)</mo>
1703		</mtd></mtr></mtable>
1704		</mrow></math>
1705
1706		<br/>
1707		<b><big><a name="Example" id="Example">Example</a></big></b>
1708		<br/>
1709		The file
1710		<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
1711		( <a href="forward_mul.cpp.xml" target="_top"><span style='white-space: nowrap'>forward_mul.cpp</span></a>
1712		)
1713		contains an example and test using one order (multiple orders).
1714		They return true if they succeed and false otherwise.
1715
1716
1717		<hr/>Input File: omh/forward.omh
1718
1719		</body>
1720		</html>

-329

~~doc/forwardone.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>First Order Forward Mode: Derivative Values</title>
6		<meta name="description" id="description" content="First Order Forward Mode: Derivative Values"/>
7		<meta name="keywords" id="keywords" content=" Forward order one "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_forwardone_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td><a href="forwardzero.xml" target="_top">Prev</a>
24		</td><td><a href="forwardany.xml" target="_top">Next</a>
25		</td><td>
26		<select onchange='choose_across0(this)'>
27		<option>Index-></option>
28		<option>contents</option>
29		<option>reference</option>
30		<option>index</option>
31		<option>search</option>
32		<option>external</option>
33		</select>
34		</td>
35		<td>
36		<select onchange='choose_up0(this)'>
37		<option>Up-></option>
38		<option>CppAD</option>
39		<option>ADFun</option>
40		<option>FunEval</option>
41		<option>Forward</option>
42		<option>ForwardOne</option>
43		</select>
44		</td>
45		<td>
46		<select onchange='choose_down3(this)'>
47		<option>ADFun-></option>
48		<option>Independent</option>
49		<option>FunConstruct</option>
50		<option>Dependent</option>
51		<option>abort_recording</option>
52		<option>seq_property</option>
53		<option>FunEval</option>
54		<option>Drivers</option>
55		<option>FunCheck</option>
56		<option>optimize</option>
57		<option>check_for_nan</option>
58		</select>
59		</td>
60		<td>
61		<select onchange='choose_down2(this)'>
62		<option>FunEval-></option>
63		<option>Forward</option>
64		<option>Reverse</option>
65		<option>Sparse</option>
66		</select>
67		</td>
68		<td>
69		<select onchange='choose_down1(this)'>
70		<option>Forward-></option>
71		<option>ForwardZero</option>
72		<option>ForwardOne</option>
73		<option>ForwardAny</option>
74		<option>size_taylor</option>
75		<option>CompareChange</option>
76		<option>capacity_taylor</option>
77		<option>number_skip</option>
78		<option>forward.cpp</option>
79		<option>forward_mul.cpp</option>
80		</select>
81		</td>
82		<td>ForwardOne</td>
83		<td>
84		<select onchange='choose_current0(this)'>
85		<option>Headings-></option>
86		<option>Syntax</option>
87		<option>Purpose</option>
88		<option>f</option>
89		<option>x</option>
90		<option>dx</option>
91		<option>s</option>
92		<option>dy</option>
93		<option>Vector</option>
94		<option>Example</option>
95		</select>
96		</td>
97		</tr></table><br/>
98
99
100
101		<center><b><big><big>First Order Forward Mode: Derivative Values</big></big></b></center>
102		<br/>
103		<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
104
105		<br/>
106
107		<code><i><font color="black"><span style='white-space: nowrap'>dy</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(1, </span></font><i><font color="black"><span style='white-space: nowrap'>dx</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
108		</span></font></code>
109
110		<code><i><font color="black"><span style='white-space: nowrap'>dy</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(1, </span></font><i><font color="black"><span style='white-space: nowrap'>dx</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
111		</span></font></code>
112		<br/>
113		<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
114		<br/>
115		We use
116		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
117		<mi mathvariant='italic'>F</mi>
118		<mo stretchy="false">:</mo>
119		<msup><mi mathvariant='italic'>B</mi>
120		<mi mathvariant='italic'>n</mi>
121		</msup>
122		<mo stretchy="false">→</mo>
123		<msup><mi mathvariant='italic'>B</mi>
124		<mi mathvariant='italic'>m</mi>
125		</msup>
126		</mrow></math>
127
128		to denote the
129		<a href="glossary.xml#AD Function" target="_top"><span style='white-space: nowrap'>AD function</span></a>
130		corresponding to
131		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
132		.
133		The result of the syntax above is
134
135		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
136		<mi mathvariant='italic'>dy</mi>
137		<mo stretchy="false">=</mo>
138		<msup><mi mathvariant='italic'>F</mi>
139		<mrow><mo stretchy="false">(</mo>
140		<mn>1</mn>
141		<mo stretchy="false">)</mo>
142		</mrow>
143		</msup>
144		<mo stretchy="false">(</mo>
145		<mi mathvariant='italic'>x</mi>
146		<mo stretchy="false">)</mo>
147		<mo stretchy="false">*</mo>
148		<mi mathvariant='italic'>dx</mi>
149		</mrow></math>
150
151		where
152		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
153		<msup><mi mathvariant='italic'>F</mi>
154		<mrow><mo stretchy="false">(</mo>
155		<mn>1</mn>
156		<mo stretchy="false">)</mo>
157		</mrow>
158		</msup>
159		<mo stretchy="false">(</mo>
160		<mi mathvariant='italic'>x</mi>
161		<mo stretchy="false">)</mo>
162		</mrow></math>
163
164		is the Jacobian of
165		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
166		<mi mathvariant='italic'>F</mi>
167		</mrow></math>
168
169
170		evaluated at
171		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
172		<mi mathvariant='italic'>x</mi>
173		</mrow></math>
174
175		.
176
177		<br/>
178		<br/>
179		<b><big><a name="f" id="f">f</a></big></b>
180		<br/>
181		The object
182		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
183		has prototype
184
185		<code><font color="blue"><span style='white-space: nowrap'><br/>
186		ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
187		</span></font></code>
188		Note that the <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
189		object
190		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
191		is not <code><font color="blue">const</font></code>.
192		Before this call to <code><font color="blue">Forward</font></code>, the value returned by
193
194		<code><font color="blue"><span style='white-space: nowrap'><br/>
195		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()<br/>
196		</span></font></code>
197		must be greater than or equal one.
198		After this call it will be will be two (see <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
199		).
200
201		<br/>
202		<br/>
203		<b><big><a name="x" id="x">x</a></big></b>
204		<br/>
205		The vector
206		<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
207		in expression for
208		<code><i><font color="black"><span style='white-space: nowrap'>dy</span></font></i></code>
209		above
210		corresponds to the previous call to <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>ForwardZero</span></a>
211
212		using this ADFun object
213		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
214		; i.e.,
215
216		<code><font color="blue"><span style='white-space: nowrap'><br/>
217		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(0, </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
218		</span></font></code>
219		If there is no previous call with the first argument zero,
220		the value of the <a href="independent.xml" target="_top"><span style='white-space: nowrap'>independent</span></a>
221		variables
222		during the recording of the AD sequence of operations is used
223		for
224		<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
225		.
226
227		<br/>
228		<br/>
229		<b><big><a name="dx" id="dx">dx</a></big></b>
230		<br/>
231		The argument
232		<code><i><font color="black"><span style='white-space: nowrap'>dx</span></font></i></code>
233		has prototype
234
235		<code><font color="blue"><span style='white-space: nowrap'><br/>
236		const </span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'>& </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
237		</span></font></code>
238		(see <a href="forwardone.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
239		below)
240		and its size
241		must be equal to
242		<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
243		, the dimension of the
244		<a href="seq_property.xml#Domain" target="_top"><span style='white-space: nowrap'>domain</span></a>
245		space for
246		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
247		.
248
249		<br/>
250		<br/>
251		<b><big><a name="s" id="s">s</a></big></b>
252		<br/>
253		The argument
254		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
255		, if present, is not used during this operation.
256
257		<br/>
258		<br/>
259		<b><big><a name="dy" id="dy">dy</a></big></b>
260		<br/>
261		The result
262		<code><i><font color="black"><span style='white-space: nowrap'>dy</span></font></i></code>
263		has prototype
264
265		<code><font color="blue"><span style='white-space: nowrap'><br/>
266		</span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>dy</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
267		</span></font></code>
268		(see <a href="forwardone.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
269		below)
270		and its value is
271		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
272		<msup><mi mathvariant='italic'>F</mi>
273		<mrow><mo stretchy="false">(</mo>
274		<mn>1</mn>
275		<mo stretchy="false">)</mo>
276		</mrow>
277		</msup>
278		<mo stretchy="false">(</mo>
279		<mi mathvariant='italic'>x</mi>
280		<mo stretchy="false">)</mo>
281		<mo stretchy="false">*</mo>
282		<mi mathvariant='italic'>dx</mi>
283		</mrow></math>
284
285		.
286		The size of
287		<code><i><font color="black"><span style='white-space: nowrap'>dy</span></font></i></code>
288
289		is equal to
290		<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
291		, the dimension of the
292		<a href="seq_property.xml#Range" target="_top"><span style='white-space: nowrap'>range</span></a>
293		space for
294		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
295		.
296
297		<br/>
298		<br/>
299		<b><big><a name="Vector" id="Vector">Vector</a></big></b>
300		<br/>
301		The type
302		<code><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i></code>
303		must be a <a href="simplevector.xml" target="_top"><span style='white-space: nowrap'>SimpleVector</span></a>
304		class with
305		<a href="simplevector.xml#Elements of Specified Type" target="_top"><span style='white-space: nowrap'>elements of type</span></a>
306
307
308		<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
309		.
310		The routine <a href="checksimplevector.xml" target="_top"><span style='white-space: nowrap'>CheckSimpleVector</span></a>
311		will generate an error message
312		if this is not the case.
313
314		<br/>
315		<br/>
316		<b><big><a name="Example" id="Example">Example</a></big></b>
317		<br/>
318		The file
319		<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
320
321		contains an example and test of this operation.
322		It returns true if it succeeds and false otherwise.
323
324
325		<hr/>Input File: omh/forward.omh
326
327		</body>
328		</html>

-6

doc/forwardtheory.xml less more

3	3	>
4	4	<head>
5	5	<title>The Theory of Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The Theory of Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" the theory of forward mode taylor notation binary operators addition subtraction multiplication division standard math functions differential equation coefficients recursion formula cases that apply above special "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

91	92	<option>AsinForward</option>
92	93	<option>AcosForward</option>
93	94	<option>tan_forward</option>
	95	<option>erf_forward</option>
94	96	</select>
95	97	</td>
96	98	<td>

141	143	, and
142	144	<code><i><font color="black"><span style='white-space: nowrap'>Z(t)</span></font></i></code>
143	145	are scalar valued functions
144		and the corresponding <i>p</i>-th order Taylor coefficients row vectors are
	146	and the corresponding <code><i>p</i></code>-th order Taylor coefficients row vectors are
145	147
146	148	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
147	149	<mi mathvariant='italic'>x</mi>

917	919	</mrow></math>
918	920
919	921	to denote the
920		<i>p</i>-th order Taylor coefficient row vectors for
	922	<code><i>p</i></code>-th order Taylor coefficient row vectors for
921	923
922	924	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
923	925	<mi mathvariant='italic'>A</mi>

959	961	</mrow></math>
960	962
961	963	,
962		the <i>p</i>-th order Taylor coefficients for
	964	the <code><i>p</i></code>-th order Taylor coefficients for
963	965	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
964	966	<mi mathvariant='italic'>X</mi>
965	967	<mo stretchy="false">(</mo>

979	981	</mrow></math>
980	982
981	983	,
982		the <i>p</i>-th order Taylor coefficient row vector for
	984	the <code><i>p</i></code>-th order Taylor coefficient row vector for
983	985	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
984	986	<mi mathvariant='italic'>Z</mi>
985	987	<mo stretchy="false">(</mo>

1666	1668	</td></tr>
1667	1669	</table>
1668	1670
1669		<hr/>Input File: omh/forward_theory.omh
	1671	<hr/>Input File: omh/theory/forward_theory.omh
1670	1672
1671	1673	</body>
1672	1674	</html>

-282

~~doc/forwardzero.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>Zero Order Forward Mode: Function Values</title>
6		<meta name="description" id="description" content="Zero Order Forward Mode: Function Values"/>
7		<meta name="keywords" id="keywords" content=" Forward order zero "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_forwardzero_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td><a href="forward.xml" target="_top">Prev</a>
24		</td><td><a href="forwardone.xml" target="_top">Next</a>
25		</td><td>
26		<select onchange='choose_across0(this)'>
27		<option>Index-></option>
28		<option>contents</option>
29		<option>reference</option>
30		<option>index</option>
31		<option>search</option>
32		<option>external</option>
33		</select>
34		</td>
35		<td>
36		<select onchange='choose_up0(this)'>
37		<option>Up-></option>
38		<option>CppAD</option>
39		<option>ADFun</option>
40		<option>FunEval</option>
41		<option>Forward</option>
42		<option>ForwardZero</option>
43		</select>
44		</td>
45		<td>
46		<select onchange='choose_down3(this)'>
47		<option>ADFun-></option>
48		<option>Independent</option>
49		<option>FunConstruct</option>
50		<option>Dependent</option>
51		<option>abort_recording</option>
52		<option>seq_property</option>
53		<option>FunEval</option>
54		<option>Drivers</option>
55		<option>FunCheck</option>
56		<option>optimize</option>
57		<option>check_for_nan</option>
58		</select>
59		</td>
60		<td>
61		<select onchange='choose_down2(this)'>
62		<option>FunEval-></option>
63		<option>Forward</option>
64		<option>Reverse</option>
65		<option>Sparse</option>
66		</select>
67		</td>
68		<td>
69		<select onchange='choose_down1(this)'>
70		<option>Forward-></option>
71		<option>ForwardZero</option>
72		<option>ForwardOne</option>
73		<option>ForwardAny</option>
74		<option>size_taylor</option>
75		<option>CompareChange</option>
76		<option>capacity_taylor</option>
77		<option>number_skip</option>
78		<option>forward.cpp</option>
79		<option>forward_mul.cpp</option>
80		</select>
81		</td>
82		<td>ForwardZero</td>
83		<td>
84		<select onchange='choose_current0(this)'>
85		<option>Headings-></option>
86		<option>Syntax</option>
87		<option>Purpose</option>
88		<option>f</option>
89		<option>x</option>
90		<option>s</option>
91		<option>y</option>
92		<option>Vector</option>
93		<option>Example</option>
94		</select>
95		</td>
96		</tr></table><br/>
97		<center><b><big><big>Zero Order Forward Mode: Function Values</big></big></b></center>
98		<br/>
99		<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
100
101		<br/>
102
103		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(0, </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
104		</span></font></code>
105
106		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(x, </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
107
108
109		<br/>
110		<br/>
111		<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
112		<br/>
113		We use
114		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
115		<mi mathvariant='italic'>F</mi>
116		<mo stretchy="false">:</mo>
117		<msup><mi mathvariant='italic'>B</mi>
118		<mi mathvariant='italic'>n</mi>
119		</msup>
120		<mo stretchy="false">→</mo>
121		<msup><mi mathvariant='italic'>B</mi>
122		<mi mathvariant='italic'>m</mi>
123		</msup>
124		</mrow></math>
125
126		to denote the
127		<a href="glossary.xml#AD Function" target="_top"><span style='white-space: nowrap'>AD function</span></a>
128		corresponding to
129		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
130		.
131		The result of the syntax above is
132
133		<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
134		<mi mathvariant='italic'>y</mi>
135		<mo stretchy="false">=</mo>
136		<mi mathvariant='italic'>F</mi>
137		<mo stretchy="false">(</mo>
138		<mi mathvariant='italic'>x</mi>
139		<mo stretchy="false">)</mo>
140		</mrow></math>
141
142		(See the <a href="funcheck.xml#Discussion" target="_top"><span style='white-space: nowrap'>FunCheck discussion</span></a>
143		for
144		possible differences between
145		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
146		<mi mathvariant='italic'>F</mi>
147		<mo stretchy="false">(</mo>
148		<mi mathvariant='italic'>x</mi>
149		<mo stretchy="false">)</mo>
150		</mrow></math>
151
152		and the algorithm that defined
153		the operation sequence.)
154
155		<br/>
156		<br/>
157		<b><big><a name="f" id="f">f</a></big></b>
158		<br/>
159		The object
160		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
161		has prototype
162
163		<code><font color="blue"><span style='white-space: nowrap'><br/>
164		ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
165		</span></font></code>
166		Note that the <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
167		object
168		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
169		is not <code><font color="blue">const</font></code>.
170		After this call to <code><font color="blue">Forward</font></code>, the value returned by
171
172		<code><font color="blue"><span style='white-space: nowrap'><br/>
173		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()<br/>
174		</span></font></code>
175		will be equal to one (see <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
176		).
177
178		<br/>
179		<br/>
180		<b><big><a name="x" id="x">x</a></big></b>
181		<br/>
182		The argument
183		<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
184		has prototype
185
186		<code><font color="blue"><span style='white-space: nowrap'><br/>
187		const </span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'>& </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
188		</span></font></code>
189		(see <a href="forwardzero.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
190		below)
191		and its size
192		must be equal to
193		<code><i><font color="black"><span style='white-space: nowrap'>n</span></font></i></code>
194		, the dimension of the
195		<a href="seq_property.xml#Domain" target="_top"><span style='white-space: nowrap'>domain</span></a>
196		space for
197		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
198		.
199
200		<br/>
201		<br/>
202		<b><big><a name="s" id="s">s</a></big></b>
203		<br/>
204		If the argument
205		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
206		is not present, <code><font color="blue">std::cout</font></code>
207		is used in its place.
208		Otherwise, this argument has prototype
209
210		<code><font color="blue"><span style='white-space: nowrap'><br/>
211		std::ostream& </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
212		</span></font></code>
213		It specifies where the output corresponding to <a href="printfor.xml" target="_top"><span style='white-space: nowrap'>PrintFor</span></a>
214		,
215		and this zero order forward mode call, will be written.
216
217		<br/>
218		<br/>
219		<b><big><a name="y" id="y">y</a></big></b>
220		<br/>
221		The result
222		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
223		has prototype
224
225		<code><font color="blue"><span style='white-space: nowrap'><br/>
226		</span></font><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
227		</span></font></code>
228		(see <a href="forwardzero.xml#Vector" target="_top"><span style='white-space: nowrap'>Vector</span></a>
229		below)
230		and its value is
231		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
232		<mi mathvariant='italic'>F</mi>
233		<mo stretchy="false">(</mo>
234		<mi mathvariant='italic'>x</mi>
235		<mo stretchy="false">)</mo>
236		</mrow></math>
237
238		.
239		The size of
240		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
241
242		is equal to
243		<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
244		, the dimension of the
245		<a href="seq_property.xml#Range" target="_top"><span style='white-space: nowrap'>range</span></a>
246		space for
247		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
248		.
249
250		<br/>
251		<br/>
252		<b><big><a name="Vector" id="Vector">Vector</a></big></b>
253		<br/>
254		The type
255		<code><i><font color="black"><span style='white-space: nowrap'>Vector</span></font></i></code>
256		must be a <a href="simplevector.xml" target="_top"><span style='white-space: nowrap'>SimpleVector</span></a>
257		class with
258		<a href="simplevector.xml#Elements of Specified Type" target="_top"><span style='white-space: nowrap'>elements of type</span></a>
259
260
261		<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>
262		.
263		The routine <a href="checksimplevector.xml" target="_top"><span style='white-space: nowrap'>CheckSimpleVector</span></a>
264		will generate an error message
265		if this is not the case.
266
267		<br/>
268		<br/>
269		<b><big><a name="Example" id="Example">Example</a></big></b>
270		<br/>
271		The file
272		<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
273
274		contains an example and test of this operation.
275		It returns true if it succeeds and false otherwise.
276
277
278		<hr/>Input File: omh/forward.omh
279
280		</body>
281		</html>

-2

doc/fun_assign.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ADFun Assignment: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ADFun Assignment: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Adfun assignment example "/>
	8	<meta name="keywords" id="keywords" content=" adfun assignment: example and test Adfun assignment "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

130	131	g = f;
131	132
132	133	// check values that should be equal
133		ok &= ( g.size_taylor() == f.size_taylor() );
	134	ok &= ( g.size_order() == f.size_order() );
134	135	ok &= ( g.size_forward_bool() == f.size_forward_bool() );
135	136	ok &= ( g.size_forward_set() == f.size_forward_set() );
136	137

-3

doc/fun_check.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ADFun Check and Re-Tape: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ADFun Check and Re-Tape: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Funcheck example test Adfun Dependent "/>
	8	<meta name="keywords" id="keywords" content=" adfun check and re-tape: example test Funcheck Adfun Dependent "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

141	142
142	143	// stop tape and store operation sequence in f : X -> Y
143	144	f.Dependent(X, Y);
144		ok &= (f.size_taylor() == 0); // no implicit forward operation
	145	ok &= (f.size_order() == 0); // no implicit forward operation
145	146
146	147	// create function object to use with double
147	148	Fun<double, Vector> g(n);

170	171
171	172	// stop tape and store operation sequence in f : X -> Y
172	173	f.Dependent(X, Y);
173		ok &= (f.size_taylor() == 0); // no implicit forward with this x
	174	ok &= (f.size_order() == 0); // no implicit forward with this x
174	175
175	176	// function values should agree now
176	177	ok &= FunCheck(f, g, x, a, r);

-1

doc/funcheck.xml less more

3	3	>
4	4	<head>
5	5	<title>Check an ADFun Sequence of Operations</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Check an ADFun Sequence of Operations"/>
7		<meta name="keywords" id="keywords" content=" Funcheck check Adfun "/>
	8	<meta name="keywords" id="keywords" content=" Funcheck check Adfun an adfun sequence of operations syntax purpose f g x y r a ok vector funcheck uses forward discussion example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+11

-10

doc/funconstruct.xml less more

3	3	>
4	4	<head>
5	5	<title>Construct an ADFun Object and Stop Recording</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Construct an ADFun Object and Stop Recording"/>
7		<meta name="keywords" id="keywords" content=" Adfun construct tape stop recording default constructor sequence copy assignment operator parallel "/>
	8	<meta name="keywords" id="keywords" content=" construct an adfun object and stop recording Adfun tape syntax purpose x y vectorad default constructor sequence copy assignment operator taylor coefficients sparsity patterns parallel mode example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

181	182	<code><font color="blue"><span style='white-space: nowrap'><br/>
182	183	ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>(</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
183	184	</span></font></code>
184		.
185
186		<br/>
187	185	<br/>
188	186	<b><big><a name="y" id="y">y</a></big></b>
189	187	<br/>

250	248
251	249
252	250	<br/>
253		The default constructor
254	251	The sequence constructor
255	252
256	253	<code><font color="blue"><span style='white-space: nowrap'><br/>

272	269	and stores the corresponding operation sequence in the object
273	270	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
274	271	.
275		It then stores the first order taylor_ coefficients
	272	It then stores the zero order Taylor coefficients
276	273	(corresponding to the value of
277	274	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
278	275	) in

298	295	).
299	296	</li><li>
300	297
301		Calculating the first order taylor_ coefficients for all
	298	Calculate the zero order Taylor coefficients for all
302	299	the variables in the operation sequence using
303	300
304	301	<code><font color="blue"><span style='white-space: nowrap'><br/>

355	352	<code><font color="blue"><span style='white-space: nowrap'><br/>
356	353	</span></font><i><font color="black"><span style='white-space: nowrap'>g</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
357	354	</span></font></code>
358		.
359	355	makes a copy of the operation sequence currently stored in
360	356	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
361	357

366	362	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
367	363	is not affected by this operation and
368	364	can be <code><font color="blue">const</font></code>.
369		Any operation sequence or other information in
	365	All of information (state) stored in
	366	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	367	is copied to
	368	<code><i><font color="black"><span style='white-space: nowrap'>g</span></font></i></code>
	369
	370	and any information originally in
370	371	<code><i><font color="black"><span style='white-space: nowrap'>g</span></font></i></code>
371	372	is lost.
372	373

385	386	Hence, directly after this operation
386	387
387	388	<code><font color="blue"><span style='white-space: nowrap'><br/>
388		</span></font><i><font color="black"><span style='white-space: nowrap'>g</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor() == </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()<br/>
	389	</span></font><i><font color="black"><span style='white-space: nowrap'>g</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order() == </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()<br/>
389	390	</span></font></code>
390	391	<br/>
391	392	<b><a name="Assignment Operator.Sparsity Patterns" id="Assignment Operator.Sparsity Patterns">Sparsity Patterns</a></b>

+65

-6

doc/fundeprecated.xml less more

3	3	>
4	4	<head>
5	5	<title>ADFun Object Deprecated Member Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ADFun Object Deprecated Member Functions"/>
7		<meta name="keywords" id="keywords" content=" Adfun Dependent Order Memory Size taylor_size use_vecad "/>
	8	<meta name="keywords" id="keywords" content=" adfun object deprecated member functions syntax purpose dependent Adfun Dependent order Order memory Memory size Size taylor_size use_vecad size_taylor capacity_taylor "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

105	106	<option>---..Deprecated</option>
106	107	<option>use_VecAD</option>
107	108	<option>---..Deprecated</option>
	109	<option>size_taylor</option>
	110	<option>---..Deprecated</option>
	111	<option>capacity_taylor</option>
	112	<option>---..Deprecated</option>
108	113	</select>
109	114	</td>
110	115	</tr></table><br/>

130	135	</span></font></code>
131	136
132	137	<code><i><font color="black"><span style='white-space: nowrap'>u</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.use_VecAD()<br/>
	138	</span></font></code>
	139
	140	<code><i><font color="black"><span style='white-space: nowrap'>v</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()<br/>
	141	</span></font></code>
	142
	143	<code><i><font color="black"><span style='white-space: nowrap'>w</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity_taylor()<br/>
133	144	</span></font></code>
134	145	<br/>
135	146	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>

214	225	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
215	226	uses less memory.
216	227	In this case, the return value of <code><font color="blue">Order</font></code> would not make sense.
217		Use <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	228	Use <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
218	229	to obtain
219	230	the number of Taylor coefficients currently stored
220	231	in the ADFun object

302	313	<code><font color="blue"><span style='white-space: nowrap'><br/>
303	314	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>t</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
304	315	</span></font></code>
305		and is the number of Taylor coefficients,
306		per variable in the AD operation sequence,
	316	and is the number of Taylor coefficient orders
307	317	currently calculated and stored in the ADFun object
308	318	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
309	319	.

312	322	<br/>
313	323	<b><a name="taylor_size.Deprecated" id="taylor_size.Deprecated">Deprecated</a></b>
314	324	<br/>
315		For the purpose of uniform naming,
316		this function has been replaced by <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	325	This function has been replaced by <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
317	326	.
318	327
319	328	<br/>

353	362	<code><font color="blue"><span style='white-space: nowrap'><br/>
354	363	</span></font><i><font color="black"><span style='white-space: nowrap'>u</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_VecAD() > 0<br/>
355	364	</span></font></code>
	365	<br/>
	366	<b><big><a name="size_taylor" id="size_taylor">size_taylor</a></big></b>
	367
	368
	369	<br/>
	370	The result
	371	<code><i><font color="black"><span style='white-space: nowrap'>v</span></font></i></code>
	372	has prototype
	373
	374	<code><font color="blue"><span style='white-space: nowrap'><br/>
	375	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>v</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	376	</span></font></code>
	377	and is the number of Taylor coefficient orders
	378	currently calculated and stored in the ADFun object
	379	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	380	.
	381
	382	<br/>
	383	<br/>
	384	<b><a name="size_taylor.Deprecated" id="size_taylor.Deprecated">Deprecated</a></b>
	385	<br/>
	386	This function has been replaced by <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
	387	.
	388
	389	<br/>
	390	<br/>
	391	<b><big><a name="capacity_taylor" id="capacity_taylor">capacity_taylor</a></big></b>
	392
	393
	394	<br/>
	395	The result
	396	<code><i><font color="black"><span style='white-space: nowrap'>w</span></font></i></code>
	397	has prototype
	398
	399	<code><font color="blue"><span style='white-space: nowrap'><br/>
	400	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>w</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	401	</span></font></code>
	402	and is the number of Taylor coefficient orders currently allocated
	403	in the ADFun object
	404	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	405	.
	406
	407	<br/>
	408	<br/>
	409	<b><a name="capacity_taylor.Deprecated" id="capacity_taylor.Deprecated">Deprecated</a></b>
	410	<br/>
	411	This function has been replaced by <a href="capacity_order.xml" target="_top"><span style='white-space: nowrap'>capacity_order</span></a>
	412	.
	413
	414
356	415
357	416	<hr/>Input File: omh/deprecated/fun_deprecated.omh
358	417

-1

doc/funeval.xml less more

3	3	>
4	4	<head>
5	5	<title>Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Evaluate ADFun Functions, Derivatives, and Sparsity Patterns"/>
7		<meta name="keywords" id="keywords" content=" evaluate Adfun "/>
	8	<meta name="keywords" id="keywords" content=" evaluate Adfun adfun functions derivatives and sparsity patterns "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/general.xml less more

3	3	>
4	4	<head>
5	5	<title>General Examples</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="General Examples"/>
7		<meta name="keywords" id="keywords" content=" example general realistic "/>
	8	<meta name="keywords" id="keywords" content=" example general realistic examples description "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-10

doc/get_adolc.sh.xml less more

3	3	>
4	4	<head>
5	5	<title>Download and Install Adolc in Build Directory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Download and Install Adolc in Build Directory"/>
7		<meta name="keywords" id="keywords" content=" adolc download and install "/>
	8	<meta name="keywords" id="keywords" content=" download and install adolc in build directory syntax purpose requirements distribution external prefix reuse "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="adolc_prefix.xml" target="_top">Prev</a>
24		</td><td><a href="get_colpack.sh.xml" target="_top">Next</a>
	25	</td><td><a href="colpack_prefix.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

47	48	<option>Install-></option>
48	49	<option>download</option>
49	50	<option>cmake</option>
50		<option>cppad_test</option>
	51	<option>cmake_check</option>
51	52	<option>pkgconfig</option>
52	53	<option>InstallUnix</option>
53	54	</select>

56	57	<select onchange='choose_down2(this)'>
57	58	<option>cmake-></option>
58	59	<option>adolc_prefix</option>
	60	<option>colpack_prefix</option>
59	61	<option>eigen_prefix</option>
60	62	<option>fadbad_prefix</option>
61	63	<option>ipopt_prefix</option>

69	71	<option>get_adolc.sh</option>
70	72	</select>
71	73	</td>
72		<td>
73		<select onchange='choose_down0(this)'>
74		<option>get_adolc.sh-></option>
75		<option>get_colpack.sh</option>
76		</select>
77		</td>
	74	<td>get_adolc.sh</td>
78	75	<td>
79	76	<select onchange='choose_current0(this)'>
80	77	<option>Headings-></option>

106	103	<a href="https://projects.coin-or.org/ADOL-C" target="_top"><span style='white-space: nowrap'>ADOL-C</span></a>
107	104	in the
108	105	CppAD <code><font color="blue">build</font></code> directory.
109
110	106
111	107	<br/>
112	108	<br/>

+17

-11

doc/get_colpack.sh.xml less more

3	3	>
4	4	<head>
5	5	<title>Download and Install ColPack in Build Directory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Download and Install ColPack in Build Directory"/>
7		<meta name="keywords" id="keywords" content=" colpack download and install "/>
	8	<meta name="keywords" id="keywords" content=" download and install colpack in build directory syntax purpose distribution external prefix reuse "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="get_adolc.sh.xml" target="_top">Prev</a>
	24	<td><a href="colpack.cpp.xml" target="_top">Prev</a>
24	25	</td><td><a href="eigen_prefix.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

38	39	<option>CppAD</option>
39	40	<option>Install</option>
40	41	<option>cmake</option>
41		<option>adolc_prefix</option>
42		<option>get_adolc.sh</option>
	42	<option>colpack_prefix</option>
43	43	<option>get_colpack.sh</option>
44	44	</select>
45	45	</td>
46	46	<td>
47	47	<select onchange='choose_down3(this)'>
	48	<option>Install-></option>
	49	<option>download</option>
	50	<option>cmake</option>
	51	<option>cmake_check</option>
	52	<option>pkgconfig</option>
	53	<option>InstallUnix</option>
	54	</select>
	55	</td>
	56	<td>
	57	<select onchange='choose_down2(this)'>
48	58	<option>cmake-></option>
49	59	<option>adolc_prefix</option>
	60	<option>colpack_prefix</option>
50	61	<option>eigen_prefix</option>
51	62	<option>fadbad_prefix</option>
52	63	<option>ipopt_prefix</option>

55	66	</select>
56	67	</td>
57	68	<td>
58		<select onchange='choose_down2(this)'>
59		<option>adolc_prefix-></option>
60		<option>get_adolc.sh</option>
61		</select>
62		</td>
63		<td>
64	69	<select onchange='choose_down1(this)'>
65		<option>get_adolc.sh-></option>
	70	<option>colpack_prefix-></option>
	71	<option>colpack.cpp</option>
66	72	<option>get_colpack.sh</option>
67	73	</select>
68	74	</td>

-2

doc/get_eigen.sh.xml less more

3	3	>
4	4	<head>
5	5	<title>Download and Install Eigen in Build Directory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Download and Install Eigen in Build Directory"/>
7		<meta name="keywords" id="keywords" content=" eigen download and install "/>
	8	<meta name="keywords" id="keywords" content=" download and install eigen in build directory syntax purpose distribution external prefix reuse "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

47	48	<option>Install-></option>
48	49	<option>download</option>
49	50	<option>cmake</option>
50		<option>cppad_test</option>
	51	<option>cmake_check</option>
51	52	<option>pkgconfig</option>
52	53	<option>InstallUnix</option>
53	54	</select>

56	57	<select onchange='choose_down2(this)'>
57	58	<option>cmake-></option>
58	59	<option>adolc_prefix</option>
	60	<option>colpack_prefix</option>
59	61	<option>eigen_prefix</option>
60	62	<option>fadbad_prefix</option>
61	63	<option>ipopt_prefix</option>

-2

doc/get_fadbad.sh.xml less more

3	3	>
4	4	<head>
5	5	<title>Download and Install Fadbad in Build Directory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Download and Install Fadbad in Build Directory"/>
7		<meta name="keywords" id="keywords" content=" fadbad download and install "/>
	8	<meta name="keywords" id="keywords" content=" download and install fadbad in build directory syntax purpose distribution external prefix "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

47	48	<option>Install-></option>
48	49	<option>download</option>
49	50	<option>cmake</option>
50		<option>cppad_test</option>
	51	<option>cmake_check</option>
51	52	<option>pkgconfig</option>
52	53	<option>InstallUnix</option>
53	54	</select>

56	57	<select onchange='choose_down2(this)'>
57	58	<option>cmake-></option>
58	59	<option>adolc_prefix</option>
	60	<option>colpack_prefix</option>
59	61	<option>eigen_prefix</option>
60	62	<option>fadbad_prefix</option>
61	63	<option>ipopt_prefix</option>

-2

doc/get_ipopt.sh.xml less more

3	3	>
4	4	<head>
5	5	<title>Download and Install Ipopt in Build Directory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Download and Install Ipopt in Build Directory"/>
7		<meta name="keywords" id="keywords" content=" ipopt download and install "/>
	8	<meta name="keywords" id="keywords" content=" download and install ipopt in build directory syntax purpose distribution external prefix reuse "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

47	48	<option>Install-></option>
48	49	<option>download</option>
49	50	<option>cmake</option>
50		<option>cppad_test</option>
	51	<option>cmake_check</option>
51	52	<option>pkgconfig</option>
52	53	<option>InstallUnix</option>
53	54	</select>

56	57	<select onchange='choose_down2(this)'>
57	58	<option>cmake-></option>
58	59	<option>adolc_prefix</option>
	60	<option>colpack_prefix</option>
59	61	<option>eigen_prefix</option>
60	62	<option>fadbad_prefix</option>
61	63	<option>ipopt_prefix</option>

-2

doc/get_sacado.sh.xml less more

3	3	>
4	4	<head>
5	5	<title>Download and Install Sacado in Build Directory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Download and Install Sacado in Build Directory"/>
7		<meta name="keywords" id="keywords" content=" sacado download and install "/>
	8	<meta name="keywords" id="keywords" content=" download and install sacado in build directory syntax purpose distribution external prefix reuse "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

47	48	<option>Install-></option>
48	49	<option>download</option>
49	50	<option>cmake</option>
50		<option>cppad_test</option>
	51	<option>cmake_check</option>
51	52	<option>pkgconfig</option>
52	53	<option>InstallUnix</option>
53	54	</select>

56	57	<select onchange='choose_down2(this)'>
57	58	<option>cmake-></option>
58	59	<option>adolc_prefix</option>
	60	<option>colpack_prefix</option>
59	61	<option>eigen_prefix</option>
60	62	<option>fadbad_prefix</option>
61	63	<option>ipopt_prefix</option>

-2

doc/get_started.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Getting Started Using CppAD to Compute Derivatives</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Getting Started Using CppAD to Compute Derivatives"/>
7		<meta name="keywords" id="keywords" content=" getting started simple example start using Cppad "/>
	8	<meta name="keywords" id="keywords" content=" getting started using cppad to compute derivatives simple example start Cppad purpose function derivative value poly exercises program output running "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

463	464	<br/>
464	465	<b><big><a name="Running" id="Running">Running</a></big></b>
465	466	<br/>
466		To build and run this program see <a href="cppad_test.xml" target="_top"><span style='white-space: nowrap'>cppad_test</span></a>
	467	To build and run this program see <a href="cmake_check.xml" target="_top"><span style='white-space: nowrap'>cmake_check</span></a>
467	468	.
468	469
469	470

-2

doc/glossary.xml less more

3	3	>
4	4	<head>
5	5	<title>Glossary</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Glossary"/>
7	8	<meta name="keywords" id="keywords" content=" ad function of base levels above level Ad type elementary vector operation atomic sequence dependent independent parameter sparsity pattern efficient boolean sets tape active inactive variable variables taylor coefficient "/>
8	9	<style type='text/css'>

252	253	<br/>
253	254	<b><big><a name="Elementary Vector" id="Elementary Vector">Elementary Vector</a></big></b>
254	255	<br/>
255		The <i>j</i>-th elementary vector
	256	The <code><i>j</i></code>-th elementary vector
256	257	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
257	258	<msup><mi mathvariant='italic'>e</mi>
258	259	<mi mathvariant='italic'>j</mi>

831	832	</msup>
832	833	</mrow></math>
833	834
834		for the <i>k</i>-th order
	835	for the <code><i>k</i></code>-th order
835	836	Taylor coefficient corresponding to
836	837	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
837	838	<mi mathvariant='italic'>X</mi>

-1

doc/harmonic.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Multi-Threaded Implementation of Summation of 1/i</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Multi-Threaded Implementation of Summation of 1/i"/>
7		<meta name="keywords" id="keywords" content=" harmonic multi_thread thread multi "/>
	8	<meta name="keywords" id="keywords" content=" harmonic multi_thread thread multi multi-threaded implementation of summation 1/i syntax ok sum num_sum num_threads source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/harmonic_time.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Timing Test of Multi-Threaded Summation of 1/i</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Timing Test of Multi-Threaded Summation of 1/i"/>
7		<meta name="keywords" id="keywords" content=" harmonic_time summation multi_thread speed time "/>
	8	<meta name="keywords" id="keywords" content=" harmonic_time summation multi_thread speed time timing test of multi-threaded 1/i syntax purpose ok time_out test_time num_threads mega_sum source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/harmonic_work.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Multi-threading Sum of 1/i Utility Routines</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Multi-threading Sum of 1/i Utility Routines"/>
7		<meta name="keywords" id="keywords" content=" harmonic_work harmonic_setup harmonic_worker harmonic_combine setup harmonic worker combine "/>
	8	<meta name="keywords" id="keywords" content=" harmonic_work multi-threading sum of 1/i utility routines harmonic_setup harmonic_worker harmonic_combine setup harmonic worker combine syntax purpose num_sum num_threads source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/hes_lagrangian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Hessian of Lagrangian and ADFun Default Constructor: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Hessian of Lagrangian and ADFun Default Constructor: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Heslagrangian example Hessian of Lagrangian test Adfun default constructor "/>
	8	<meta name="keywords" id="keywords" content=" hessian of lagrangian and adfun default constructor: example test Heslagrangian Hessian Lagrangian Adfun constructor "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/hes_lu_det.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Gradient of Determinant Using LU Factorization: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Gradient of Determinant Using LU Factorization: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" gradient Lu example test "/>
	8	<meta name="keywords" id="keywords" content=" gradient of determinant using lu factorization: example and test Lu "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/hes_minor_det.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Gradient of Determinant Using Expansion by Minors: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Gradient of Determinant Using Expansion by Minors: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" gradient minors expansion example test "/>
	8	<meta name="keywords" id="keywords" content=" gradient of determinant using expansion by minors: example and test minors "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/hes_times_dir.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Hessian Times Direction: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Hessian Times Direction: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Hessian times direction "/>
	8	<meta name="keywords" id="keywords" content=" hessian times direction: example and test Hessian direction "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/hessian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Hessian: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Hessian: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Hessian example test "/>
	8	<meta name="keywords" id="keywords" content=" hessian: example and test Hessian "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/hessian.xml less more

3	3	>
4	4	<head>
5	5	<title>Hessian: Easy Driver</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Hessian: Easy Driver"/>
7		<meta name="keywords" id="keywords" content=" Hessian driver second derivative "/>
	8	<meta name="keywords" id="keywords" content=" Hessian driver second derivative hessian: easy syntax purpose f x l w hes vector hessian uses forward example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/include_deprecated.xml less more

3	3	>
4	4	<head>
5	5	<title>Deprecated Include Files</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Deprecated Include Files"/>
7		<meta name="keywords" id="keywords" content=" deprecated include file "/>
	8	<meta name="keywords" id="keywords" content=" deprecated include files file purpose linking new to commands "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/independent.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Independent and ADFun Constructor: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Independent and ADFun Constructor: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Independent example test "/>
	8	<meta name="keywords" id="keywords" content=" independent and adfun constructor: example test Independent "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/independent.xml less more

3	3	>
4	4	<head>
5	5	<title>Declare Independent Variables and Start Recording</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Declare Independent Variables and Start Recording"/>
7		<meta name="keywords" id="keywords" content=" Independent start recording variable independent parallel "/>
	8	<meta name="keywords" id="keywords" content=" Independent start recording variable independent declare variables and syntax purpose stop x vectorad parallel mode example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-276

~~doc/index.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>cppad-20140000.3: A Package for Differentiation of C++ Algorithms</title>
6		<meta name="description" id="description" content="cppad-20140000.3: A Package for Differentiation of C++ Algorithms"/>
7		<meta name="keywords" id="keywords" content=" Ad algorithmic differentiation automatic C++ algorithm derivative Cppad version introduction include cppad.hpp symbol preprocessor namespace "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_cppad_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td>Prev</td><td><a href="_contents_xml.htm" target="_top">Next</a>
24		</td><td>
25		<select onchange='choose_across0(this)'>
26		<option>Index-></option>
27		<option>contents</option>
28		<option>reference</option>
29		<option>index</option>
30		<option>search</option>
31		<option>external</option>
32		</select>
33		</td>
34		<td>
35		<select onchange='choose_up0(this)'>
36		<option>Up-></option>
37		<option>CppAD</option>
38		</select>
39		</td>
40		<td>
41		<select onchange='choose_down0(this)'>
42		<option>CppAD-></option>
43		<option>Install</option>
44		<option>Introduction</option>
45		<option>AD</option>
46		<option>ADFun</option>
47		<option>preprocessor</option>
48		<option>multi_thread</option>
49		<option>library</option>
50		<option>ipopt_solve</option>
51		<option>Example</option>
52		<option>speed</option>
53		<option>Appendix</option>
54		</select>
55		</td>
56		<td>
57		<select onchange='choose_current0(this)'>
58		<option>Headings-></option>
59		<option>Syntax</option>
60		<option>Introduction</option>
61		<option>Example</option>
62		<option>Include File</option>
63		<option>Preprocessor Symbols</option>
64		<option>Namespace</option>
65		<option>Contents</option>
66		</select>
67		</td>
68		</tr></table><br/>
69		,
70
71
72
73
74
75
76
77		<center><b><big><big>cppad-20140000.3: A Package for Differentiation of C++ Algorithms</big></big></b></center>
78		<br/>
79		<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
80
81		<code><font color="blue"><br/>
82		# include <cppad/cppad.hpp></font></code>
83
84		<br/>
85		<br/>
86		<b><big><a name="Introduction" id="Introduction">Introduction</a></big></b>
87
88		<br/>
89		We refer to the
90		step by step conversion from an algorithm that computes function values
91		to an algorithm that computes derivative values
92		as <i>Algorithmic Differentiation</i>
93		(often referred to as <i>Automatic Differentiation</i>.)
94		Given a C++ algorithm that computes function values,
95		CppAD generates an algorithm that computes its derivative values.
96		A brief introduction to Algorithmic Differentiation can be found in
97		<a href="http://en.wikipedia.org/wiki/Automatic_differentiation" target="_top"><span style='white-space: nowrap'>wikipedia</span></a>
98		.
99		The web site
100		<a href="http://www.autodiff.org" target="_top"><span style='white-space: nowrap'>autodiff.org</span></a>
101
102		is dedicated to research about, and promoting the use of, AD.
103
104		<ol type="1"><li>
105		<a href="http://www.coin-or.org/CppAD/" target="_top"><span style='white-space: nowrap'>CppAD</span></a>
106
107		uses operator overloading to compute derivatives of algorithms defined in C++.
108		It is distributed by the
109		<a href="http://www.coin-or.org/foundation.html" target="_top"><span style='white-space: nowrap'>COIN-OR Foundation</span></a>
110
111		with the Eclipse Public License
112		<a href="http://www.opensource.org/licenses/EPL-1.0" target="_top"><span style='white-space: nowrap'>EPL-1.0</span></a>
113
114		or the GNU General Public License
115		<a href="http://www.opensource.org/licenses/AGPL-3.0" target="_top"><span style='white-space: nowrap'>GPL-3.0</span></a>
116		.
117		Testing and installation is supported for Unix, Microsoft, and Apple
118		operating systems.
119		Extensive user and developer documentation is included.
120
121		</li><li>
122
123		An AD of <i>Base</i>
124		<a href="glossary.xml#Operation.Sequence" target="_top"><span style='white-space: nowrap'>operation sequence</span></a>
125
126		is stored as an
127		<a href="adfun.xml" target="_top"><span style='white-space: nowrap'>AD function object</span></a>
128
129		which can evaluate function values and derivatives.
130		Arbitrary order
131		<a href="forward.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
132		and <a href="reverse.xml" target="_top"><span style='white-space: nowrap'>reverse</span></a>
133
134		mode derivative calculations
135		can be preformed on the operation sequence.
136		Logical comparisons can be included in an operation sequence
137		using AD <a href="condexp.xml" target="_top"><span style='white-space: nowrap'>conditional expressions</span></a>
138		.
139		Evaluation of user defined unary
140		<a href="discrete.xml" target="_top"><span style='white-space: nowrap'>discrete functions</span></a>
141		can also be included
142		in the sequence of operations; i.e.,
143		functions that depend on the
144		<a href="glossary.xml#Tape.Independent Variable" target="_top"><span style='white-space: nowrap'>independent variables</span></a>
145
146		but which have identically zero derivatives
147		(e.g., a step function).
148
149		</li><li>
150
151		Derivatives of functions that are defined in terms of other derivatives
152		can be computed using multiple levels of AD;
153		see <a href="mul_level.cpp.xml" target="_top"><span style='white-space: nowrap'>mul_level.cpp</span></a>
154		for a simple example
155		and <a href="mul_level_ode.cpp.xml" target="_top"><span style='white-space: nowrap'>mul_level_ode.cpp</span></a>
156		for a more realistic example.
157		To this end, CppAD can also be used with other AD types; for example see
158		<a href="mul_level_adolc_ode.cpp.xml" target="_top"><span style='white-space: nowrap'>mul_level_adolc_ode.cpp</span></a>
159		.
160
161		</li><li>
162
163		A set of programs for doing <a href="speed.xml" target="_top"><span style='white-space: nowrap'>speed</span></a>
164		comparisons between
165		<a href="https://projects.coin-or.org/ADOL-C" target="_top"><span style='white-space: nowrap'>Adolc</span></a>
166		,
167		CppAD,
168		<a href="http://www.imm.dtu.dk/fadbad.html/" target="_top"><span style='white-space: nowrap'>Fadbad</span></a>
169		,
170		and
171		<a href="http://trilinos.sandia.gov/packages/sacado/" target="_top"><span style='white-space: nowrap'>Sacado</span></a>
172
173		are included.
174
175
176		</li><li>
177
178		Includes a C++ <a href="library.xml" target="_top"><span style='white-space: nowrap'>library</span></a>
179		that is useful
180		for general operator overloaded numerical method.
181		Allows for replacement of the
182		<a href="testvector.xml" target="_top"><span style='white-space: nowrap'>testvector</span></a>
183
184		template vector class which is used for extensive testing;
185		for example, you can do your testing with the
186		<a href="http://www.boost.org/libs/numeric/ublas/doc/index.htm" target="_top"><span style='white-space: nowrap'>uBlas</span></a>
187
188		template vector class.
189
190		</li><li>
191
192		See <a href="whats_new.xml" target="_top"><span style='white-space: nowrap'>whats_new</span></a>
193		for a list of recent extensions and bug fixes.
194
195		</li></ol>
196
197
198		You can find out about other algorithmic differentiation tools
199		and about algorithmic differentiation in general at the following web sites:
200		<a href="http://en.wikipedia.org/wiki/Automatic_differentiation" target="_top"><span style='white-space: nowrap'>wikipedia</span></a>
201		,
202		<a href="http://www.autodiff.org" target="_top"><span style='white-space: nowrap'>autodiff.org</span></a>
203		.
204
205		<br/>
206		<br/>
207		<b><big><a name="Example" id="Example">Example</a></big></b>
208		<br/>
209		The file
210		<a href="get_started.cpp.xml" target="_top"><span style='white-space: nowrap'>get_started.cpp</span></a>
211
212		contains an example and test of using CppAD to compute
213		the derivative of a polynomial.
214		There are many other
215		<a href="example.xml" target="_top"><span style='white-space: nowrap'>examples</span></a>
216		.
217
218		<br/>
219		<br/>
220		<b><big><a name="Include File" id="Include File">Include File</a></big></b>
221
222
223		<br/>
224		The following include directive
225		<code><font color="blue"><span style='white-space: nowrap'><br/>
226		# include <cppad/cppad.hpp><br/>
227		</span></font></code>includes the CppAD package for the rest of the current compilation unit.
228
229		<br/>
230		<br/>
231		<b><big><a name="Preprocessor Symbols" id="Preprocessor Symbols">Preprocessor Symbols</a></big></b>
232
233
234
235		<br/>
236		All the <a href="preprocessor.xml" target="_top"><span style='white-space: nowrap'>preprocessor</span></a>
237		symbols used by CppAD begin with eight
238		<code><font color="blue">CppAD</font></code> or <code><font color="blue">CPPAD_</font></code>.
239
240		<br/>
241		<br/>
242		<b><big><a name="Namespace" id="Namespace">Namespace</a></big></b>
243
244
245		<br/>
246		All of the functions and objects defined by CppAD are in the
247		<code><font color="blue">CppAD</font></code> namespace; for example, you can access the <a href="ad.xml" target="_top"><span style='white-space: nowrap'>AD</span></a>
248		types as
249		<code><font color="blue"><span style='white-space: nowrap'><br/>
250		size_t n = 2;<br/>
251		CppAD::vector< CppAD::AD<</span></font></code><i><span style='white-space: nowrap'>Base</span></i><code><font color="blue"><span style='white-space: nowrap'>> > </span></font></code><i><span style='white-space: nowrap'>x</span></i><code><font color="blue"><span style='white-space: nowrap'>(</span></font></code><i><span style='white-space: nowrap'>n</span></i><code><font color="blue"><span style='white-space: nowrap'>)<br/>
252		</span></font></code>You can abbreviate access to one object or function a <code><font color="blue">using</font></code>
253		command of the form
254		<code><font color="blue"><span style='white-space: nowrap'><br/>
255		using CppAD::AD<br/>
256		CppAD::vector< AD<</span></font></code><i><span style='white-space: nowrap'>Base</span></i><code><font color="blue"><span style='white-space: nowrap'>> > </span></font></code><i><span style='white-space: nowrap'>x</span></i><code><font color="blue"><span style='white-space: nowrap'>(</span></font></code><i><span style='white-space: nowrap'>n</span></i><code><font color="blue"><span style='white-space: nowrap'>)<br/>
257		</span></font></code>You can abbreviate access to all CppAD objects and functions
258		with a command of the form
259		<code><font color="blue"><span style='white-space: nowrap'><br/>
260		using namespace CppAD<br/>
261		vector< AD<</span></font></code><i><span style='white-space: nowrap'>Base</span></i><code><font color="blue"><span style='white-space: nowrap'>> > </span></font></code><i><span style='white-space: nowrap'>x</span></i><code><font color="blue"><span style='white-space: nowrap'>(</span></font></code><i><span style='white-space: nowrap'>n</span></i><code><font color="blue"><span style='white-space: nowrap'>)<br/>
262		</span></font></code>If you include other namespaces in a similar manner,
263		this can cause naming conflicts.
264
265
266		<br/>
267		<br/>
268		<b><big><a name="Contents" id="Contents">Contents</a></big></b>
269		<br/>
270		<table>
271		<tr><td><a href="_contents_xml.htm" target="_top">_contents</a></td><td>Table of Contents</td></tr><tr><td><a href="install.xml" target="_top">Install</a></td><td>CppAD Download, Test, and Install Instructions</td></tr><tr><td><a href="introduction.xml" target="_top">Introduction</a></td><td>An Introduction by Example to Algorithmic Differentiation</td></tr><tr><td><a href="ad.xml" target="_top">AD</a></td><td>AD Objects</td></tr><tr><td><a href="adfun.xml" target="_top">ADFun</a></td><td>ADFun Objects</td></tr><tr><td><a href="preprocessor.xml" target="_top">preprocessor</a></td><td>CppAD API Preprocessor Symbols</td></tr><tr><td><a href="multi_thread.xml" target="_top">multi_thread</a></td><td>Using CppAD in a Multi-Threading Environment</td></tr><tr><td><a href="library.xml" target="_top">library</a></td><td>The CppAD General Purpose Library</td></tr><tr><td><a href="ipopt_solve.xml" target="_top">ipopt_solve</a></td><td>Use Ipopt to Solve a Nonlinear Programming Problem</td></tr><tr><td><a href="example.xml" target="_top">Example</a></td><td>Examples</td></tr><tr><td><a href="speed.xml" target="_top">speed</a></td><td>AD Speed Test Routines</td></tr><tr><td><a href="appendix.xml" target="_top">Appendix</a></td><td>Appendix</td></tr><tr><td><a href="_reference.xml" target="_top">_reference</a></td><td>Alphabetic Listing of Cross Reference Tags</td></tr><tr><td><a href="_index.xml" target="_top">_index</a></td><td>Keyword Index</td></tr><tr><td><a href="_search_xml.htm" target="_top">_search</a></td><td>Search This Web Site</td></tr><tr><td><a href="_external.xml" target="_top">_external</a></td><td>External Internet References</td></tr></table>
272		<hr/>Input File: doc.omh
273
274		</body>
275		</html>

-1

doc/index_sort.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Index Sort: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Index Sort: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" index_sort example sort index test "/>
	8	<meta name="keywords" id="keywords" content=" index sort: example and test index_sort sort "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/index_sort.xml less more

3	3	>
4	4	<head>
5	5	<title>Returns Indices that Sort a Vector</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Returns Indices that Sort a Vector"/>
7		<meta name="keywords" id="keywords" content=" index_sort sort index "/>
	8	<meta name="keywords" id="keywords" content=" returns indices that sort a vector index_sort index syntax keys ind example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+15

-13

doc/install.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Download, Test, and Install Instructions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Download, Test, and Install Instructions"/>
7		<meta name="keywords" id="keywords" content=" install test "/>
	8	<meta name="keywords" id="keywords" content=" install test cppad download and instructions step 1: 2: cmake 3: check 4: "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

60	61	<option>Install-></option>
61	62	<option>download</option>
62	63	<option>cmake</option>
63		<option>cppad_test</option>
	64	<option>cmake_check</option>
64	65	<option>pkgconfig</option>
65	66	<option>InstallUnix</option>
66	67	</select>

69	70	<select onchange='choose_current0(this)'>
70	71	<option>Headings-></option>
71	72	<option>Instructions</option>
72		<option>---..Download</option>
73		<option>---..Cmake</option>
74		<option>---..Test</option>
75		<option>---..Install</option>
	73	<option>---..Step 1: Download</option>
	74	<option>---..Step 2: Cmake</option>
	75	<option>---..Step 3: Check</option>
	76	<option>---..Step 4: Install</option>
76	77	<option>Contents</option>
77	78	</select>
78	79	</td>

84	85
85	86	<br/>
86	87	<br/>
87		<b><a name="Instructions.Download" id="Instructions.Download">Download</a></b>
	88	<b><a name="Instructions.Step 1: Download" id="Instructions.Step 1: Download">Step 1: Download</a></b>
88	89	<br/>
89	90	Use the <a href="download.xml" target="_top"><span style='white-space: nowrap'>download</span></a>
90	91	instructions to obtain a copy or CppAD.
91	92
92	93	<br/>
93	94	<br/>
94		<b><a name="Instructions.Cmake" id="Instructions.Cmake">Cmake</a></b>
	95	<b><a name="Instructions.Step 2: Cmake" id="Instructions.Step 2: Cmake">Step 2: Cmake</a></b>
95	96	<br/>
96	97	Use the <a href="cmake.xml" target="_top"><span style='white-space: nowrap'>cmake</span></a>
97	98	instructions to configure CppAD.
98	99
99	100	<br/>
100	101	<br/>
101		<b><a name="Instructions.Test" id="Instructions.Test">Test</a></b>
	102	<b><a name="Instructions.Step 3: Check" id="Instructions.Step 3: Check">Step 3: Check</a></b>
102	103	<br/>
103		Use the <a href="cppad_test.xml" target="_top"><span style='white-space: nowrap'>cppad_test</span></a>
104		instructions to test CppAD.
	104	Use the <a href="cmake_check.xml" target="_top"><span style='white-space: nowrap'>cmake_check</span></a>
	105	instructions to check the
	106	CppAD examples and tests.
105	107
106	108	<br/>
107	109	<br/>
108		<b><a name="Instructions.Install" id="Instructions.Install">Install</a></b>
	110	<b><a name="Instructions.Step 4: Install" id="Instructions.Step 4: Install">Step 4: Install</a></b>
109	111	<br/>
110	112	Use the command
111	113	<code><font color='blue'><pre style='display:inline'>

129	131	<b><big><a name="Contents" id="Contents">Contents</a></big></b>
130	132	<br/>
131	133	<table>
132		<tr><td><a href="download.xml" target="_top">download</a></td><td>Download The CppAD Source Code</td></tr><tr><td><a href="cmake.xml" target="_top">cmake</a></td><td>Using CMake to Configure CppAD</td></tr><tr><td><a href="cppad_test.xml" target="_top">cppad_test</a></td><td>Running the CppAD Examples and Tests</td></tr><tr><td><a href="pkgconfig.xml" target="_top">pkgconfig</a></td><td>CppAD pkg-config Files</td></tr><tr><td><a href="installunix.xml" target="_top">InstallUnix</a></td><td>Unix Test and Installation</td></tr></table>
	134	<tr><td><a href="download.xml" target="_top">download</a></td><td>Download The CppAD Source Code</td></tr><tr><td><a href="cmake.xml" target="_top">cmake</a></td><td>Using CMake to Configure CppAD</td></tr><tr><td><a href="cmake_check.xml" target="_top">cmake_check</a></td><td>Checking the CppAD Examples and Tests</td></tr><tr><td><a href="pkgconfig.xml" target="_top">pkgconfig</a></td><td>CppAD pkg-config Files</td></tr><tr><td><a href="installunix.xml" target="_top">InstallUnix</a></td><td>Deprecated Unix Test and Installation</td></tr></table>
133	135	<hr/>Input File: omh/install/install.omh
134	136
135	137	</body>

+10

-6

doc/installunix.xml less more

2	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
3	3	>
4	4	<head>
5		<title>Unix Test and Installation</title>
6		<meta name="description" id="description" content="Unix Test and Installation"/>
7		<meta name="keywords" id="keywords" content=" Cppad unix install free configure speed profile cppad prefix directory documentation std test vector boost eigen sparse internal sets ctor implicit or explicit compile flags Openmp postfix Adolc Eigen Fadbad Ipopt Sacado memory usage tape "/>
	5	<title>Deprecated Unix Test and Installation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Deprecated Unix Test and Installation"/>
	8	<meta name="keywords" id="keywords" content=" Cppad unix install free deprecated test and installation distribution directory work configure make examples tests profiling cppad speed profile prefix_dir prefix --with-documentation documentation --with-testvector std vector boost eigen --with-sparse_option sparse internal sets --with-implicit_ctor ctor implicit or explicit max_num_threads cxx_flags compile flags openmp_flags Openmp postfix_dir postfix adolc_dir Adolc linux cygwin boost_dir eigen_dir Eigen fadbad_dir Fadbad ipopt_dir Ipopt sacado_dir Sacado tape_addr_type memory usage tape tape_id_type "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

61	62	<option>Install-></option>
62	63	<option>download</option>
63	64	<option>cmake</option>
64		<option>cppad_test</option>
	65	<option>cmake_check</option>
65	66	<option>pkgconfig</option>
66	67	<option>InstallUnix</option>
67	68	</select>

100	101	</select>
101	102	</td>
102	103	</tr></table><br/>
103		<center><b><big><big>Unix Test and Installation</big></big></b></center>
	104	<center><b><big><big>Deprecated Unix Test and Installation</big></big></b></center>
104	105	<br/>
105	106	<b><big><a name="Deprecated" id="Deprecated">Deprecated</a></big></b>
106	107	<br/>
107		These install instructions have been deprecated.
	108	These install instructions have been deprecated and no improvements
	109	have been added since 2012.
	110	For example, this install procedure will not detect any of the
	111	<code><font color="blue">c++11</font></code> extensions.
108	112	You should use the <a href="cmake.xml" target="_top"><span style='white-space: nowrap'>cmake</span></a>
109	113	instructions to install CppAD.
110	114

-1

doc/integer.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Convert From AD to Integer: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Convert From AD to Integer: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Integer example test "/>
	8	<meta name="keywords" id="keywords" content=" convert from ad to integer: example and test Integer "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/integer.xml less more

3	3	>
4	4	<head>
5	5	<title>Convert From AD to Integer</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Convert From AD to Integer"/>
7		<meta name="keywords" id="keywords" content=" Integer Ad convert to integer "/>
	8	<meta name="keywords" id="keywords" content=" Integer Ad convert to integer from ad syntax purpose i x real types complex operation sequence example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/interface2c.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Interfacing to C: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Interfacing to C: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" C interface to difference central "/>
	8	<meta name="keywords" id="keywords" content=" interfacing to c: example and test C interface difference central "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/interp_onetape.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Interpolation With Out Retaping: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Interpolation With Out Retaping: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" interpolate example test tape retape "/>
	8	<meta name="keywords" id="keywords" content=" interpolation with out retaping: example and test interpolate tape retape see also "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/interp_retape.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Interpolation With Retaping: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Interpolation With Retaping: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" interpolate example test tape retape "/>
	8	<meta name="keywords" id="keywords" content=" interpolation with retaping: example and test interpolate tape retape see also "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/introduction.xml less more

3	3	>
4	4	<head>
5	5	<title>An Introduction by Example to Algorithmic Differentiation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="An Introduction by Example to Algorithmic Differentiation"/>
7		<meta name="keywords" id="keywords" content=" introduction Ad Algorithmic Differentiation Automatic "/>
	8	<meta name="keywords" id="keywords" content=" introduction Ad Algorithmic Differentiation Automatic an by example to algorithmic differentiation purpose preface forward mode reverse operation count efficiency outline reference "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_nlp_get_started.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Nonlinear Programming Using CppAD and Ipopt: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Nonlinear Programming Using CppAD and Ipopt: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" example nonlinear programming ipopt Ad "/>
	8	<meta name="keywords" id="keywords" content=" example nonlinear programming ipopt Ad using cppad and ipopt: test purpose configuration requirement "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_nlp_ode.xml less more

3	3	>
4	4	<head>
5	5	<title>Example Simultaneous Solution of Forward and Inverse Problem</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Example Simultaneous Solution of Forward and Inverse Problem"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" example simultaneous solution of forward and inverse problem "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_nlp_ode_check.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Correctness Check for Both Simple and Fast Representations</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Correctness Check for Both Simple and Fast Representations"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" correctness check for both simple and fast representations "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_nlp_ode_fast.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ODE Fitting Using Fast Representation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ODE Fitting Using Fast Representation"/>
7		<meta name="keywords" id="keywords" content=" cppad_ipopt_nlp ode example source "/>
	8	<meta name="keywords" id="keywords" content=" ode fitting using fast representation cppad_ipopt_nlp example source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_nlp_ode_fast.xml less more

3	3	>
4	4	<head>
5	5	<title>ODE Fitting Using Fast Representation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ODE Fitting Using Fast Representation"/>
7		<meta name="keywords" id="keywords" content=" representation cppad_ipopt_nlp ode "/>
	8	<meta name="keywords" id="keywords" content=" ode fitting using fast representation cppad_ipopt_nlp purpose objective function range indices i(k0) domain j(k0) initial condition trapezoidal approximation source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_nlp_ode_problem.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ODE Inverse Problem Definitions: Source Code</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ODE Inverse Problem Definitions: Source Code"/>
7		<meta name="keywords" id="keywords" content=" ode inverse example "/>
	8	<meta name="keywords" id="keywords" content=" ode inverse problem definitions: source code example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-5

doc/ipopt_nlp_ode_problem.xml less more

3	3	>
4	4	<head>
5	5	<title>An ODE Inverse Problem Example</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="An ODE Inverse Problem Example"/>
7		<meta name="keywords" id="keywords" content=" ode inverse example "/>
	8	<meta name="keywords" id="keywords" content=" an ode inverse problem example notation forward measurements simulation analytic solution parameter values simulated measurement trapezoidal approximation time grid black box method two levels of iteration derivatives simultaneous source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

162	163
163	164	</td><td align='left' valign='top'>
164	165
165		number of grid points between <i>i-1</i>-th and <i>i</i>-th measurement
	166	number of grid points between <code><i>i-1</i></code>-th and <code><i>i</i></code>-th measurement
166	167	</td></tr><tr><td align='left' valign='top'>
167	168
168	169

175	176
176	177	</td><td align='left' valign='top'>
177	178
178		number of grid points up to an including the <i>i</i>-th measurement
	179	number of grid points up to an including the <code><i>i</i></code>-th measurement
179	180	</td></tr>
180	181	</table>
181	182	<br/>

442	443	</mstyle></mrow>
443	444	</mrow></math>
444	445
445		is the time for the <i>i</i>-th measurement,
	446	is the time for the <code><i>i</i></code>-th measurement,
446	447
447	448	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
448	449	<msub><mi mathvariant='italic'>e</mi>

673	674
674	675	<code><span style='white-space: nowrap'> </span></code> </td><td align='left' valign='top'>
675	676
676		time corresponding to the <i>i</i>-th measurement,
	677	time corresponding to the <code><i>i</i></code>-th measurement,
677	678
678	679	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
679	680	<mi mathvariant='italic'>i</mi>

-1

doc/ipopt_nlp_ode_run.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Driver for Running the Ipopt ODE Example</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Driver for Running the Ipopt ODE Example"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" driver for running the ipopt ode example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_nlp_ode_simple.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ODE Fitting Using Simple Representation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ODE Fitting Using Simple Representation"/>
7		<meta name="keywords" id="keywords" content=" cppad_ipopt_nlp ode example source "/>
	8	<meta name="keywords" id="keywords" content=" ode fitting using simple representation cppad_ipopt_nlp example source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_nlp_ode_simple.xml less more

3	3	>
4	4	<head>
5	5	<title>ODE Fitting Using Simple Representation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ODE Fitting Using Simple Representation"/>
7		<meta name="keywords" id="keywords" content=" cppad_ipopt_nlp ode simple representation "/>
	8	<meta name="keywords" id="keywords" content=" ode fitting using simple representation cppad_ipopt_nlp purpose argument vector objective function initial condition constraint trapezoidal approximation source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_ode_speed.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Test for Both Simple and Fast Representations</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Test for Both Simple and Fast Representations"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" speed test for both simple and fast representations "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/ipopt_prefix.xml less more

3	3	>
4	4	<head>
5	5	<title>Including the cppad_ipopt Library and Tests</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Including the cppad_ipopt Library and Tests"/>
7		<meta name="keywords" id="keywords" content=" ipopt cppad library cppad_ipopt prefix example get "/>
	8	<meta name="keywords" id="keywords" content=" including the cppad_ipopt library and tests ipopt cppad purpose ipopt_prefix prefix examples example get_ipopt get "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

62	63	<option>Install-></option>
63	64	<option>download</option>
64	65	<option>cmake</option>
65		<option>cppad_test</option>
	66	<option>cmake_check</option>
66	67	<option>pkgconfig</option>
67	68	<option>InstallUnix</option>
68	69	</select>

71	72	<select onchange='choose_down1(this)'>
72	73	<option>cmake-></option>
73	74	<option>adolc_prefix</option>
	75	<option>colpack_prefix</option>
74	76	<option>eigen_prefix</option>
75	77	<option>fadbad_prefix</option>
76	78	<option>ipopt_prefix</option>

-1

doc/ipopt_solve.xml less more

3	3	>
4	4	<head>
5	5	<title>Use Ipopt to Solve a Nonlinear Programming Problem</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Use Ipopt to Solve a Nonlinear Programming Problem"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" use ipopt to solve a nonlinear programming problem syntax purpose include file bvector dvector options retape sparse string numeric integer xi xl xu gl gu fg_eval advector x fg solution status zl zu g lambda obj_value example get_started ode_inverse "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ipopt_solve_get_started.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Nonlinear Programming Using CppAD and Ipopt: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Nonlinear Programming Using CppAD and Ipopt: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" example nonlinear programming ipopt Ad "/>
	8	<meta name="keywords" id="keywords" content=" example nonlinear programming ipopt Ad using cppad and ipopt: test purpose configuration requirement "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/ipopt_solve_ode_inverse.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ODE Inverse Problem Definitions: Source Code</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ODE Inverse Problem Definitions: Source Code"/>
7		<meta name="keywords" id="keywords" content=" ode inverse example "/>
	8	<meta name="keywords" id="keywords" content=" ode inverse problem definitions: source code example purpose forward measurements simulation analytic solution parameter values simulated measurement trapezoidal approximation method "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

526	527
527	528	<code><span style='white-space: nowrap'> </span></code> </td><td align='left' valign='top'>
528	529
529		time corresponding to the <i>i</i>-th measurement,
	530	time corresponding to the <code><i>i</i></code>-th measurement,
530	531
531	532	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
532	533	<mi mathvariant='italic'>i</mi>

-1

doc/ipopt_solve_retape.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Nonlinear Programming Retaping: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Nonlinear Programming Retaping: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" retape ipopt_solve "/>
	8	<meta name="keywords" id="keywords" content=" retape ipopt_solve nonlinear programming retaping: example and test purpose "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/jac_lu_det.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Gradient of Determinant Using Lu Factorization: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Gradient of Determinant Using Lu Factorization: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" gradient Lu example test "/>
	8	<meta name="keywords" id="keywords" content=" gradient of determinant using lu factorization: example and test Lu "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/jac_minor_det.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Gradient of Determinant Using Expansion by Minors: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Gradient of Determinant Using Expansion by Minors: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" gradient minors expansion example test "/>
	8	<meta name="keywords" id="keywords" content=" gradient of determinant using expansion by minors: example and test minors "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/jacobian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Jacobian: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Jacobian: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Jacobian example test "/>
	8	<meta name="keywords" id="keywords" content=" jacobian: example and test Jacobian "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/jacobian.xml less more

3	3	>
4	4	<head>
5	5	<title>Jacobian: Driver Routine</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Jacobian: Driver Routine"/>
7		<meta name="keywords" id="keywords" content=" Jacobian driver first derivative "/>
	8	<meta name="keywords" id="keywords" content=" Jacobian driver first derivative jacobian: routine syntax purpose f x jac vector forward or reverse example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/library.xml less more

3	3	>
4	4	<head>
5	5	<title>The CppAD General Purpose Library</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The CppAD General Purpose Library"/>
7		<meta name="keywords" id="keywords" content=" numerical C++ template library concept "/>
	8	<meta name="keywords" id="keywords" content=" numerical C++ template library the cppad general purpose error handler testing utilities c++ concepts concept ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/license.xml less more

3	3	>
4	4	<head>
5	5	<title>Your License for the CppAD Software</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Your License for the CppAD Software"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" your license for the cppad software "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/limits.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Numeric Limits: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Numeric Limits: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" limits example test "/>
	8	<meta name="keywords" id="keywords" content=" numeric limits: example and test limits "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/limits.xml less more

3	3	>
4	4	<head>
5	5	<title>Numeric Limits For an AD and Base Types</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Numeric Limits For an AD and Base Types"/>
7		<meta name="keywords" id="keywords" content=" limits Ad epsilon limit max min "/>
	8	<meta name="keywords" id="keywords" content=" limits Ad epsilon limit max min numeric for an ad and base types syntax purpose float eps example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/link_det_lu.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Testing Gradient of Determinant Using Lu Factorization</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Testing Gradient of Determinant Using Lu Factorization"/>
7		<meta name="keywords" id="keywords" content=" link_det_lu det_lu speed test "/>
	8	<meta name="keywords" id="keywords" content=" link_det_lu det_lu speed test testing gradient of determinant using lu factorization prototype purpose method return value size repeat matrix double "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/link_det_minor.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Testing Gradient of Determinant by Minor Expansion</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Testing Gradient of Determinant by Minor Expansion"/>
7		<meta name="keywords" id="keywords" content=" link_det_minor det_minor speed test "/>
	8	<meta name="keywords" id="keywords" content=" link_det_minor det_minor speed test testing gradient of determinant by minor expansion prototype purpose method return value size repeat matrix double "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/link_mat_mul.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Testing Derivative of Matrix Multiply</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Testing Derivative of Matrix Multiply"/>
7		<meta name="keywords" id="keywords" content=" link_mat_mul matrix multiply speed test multiple "/>
	8	<meta name="keywords" id="keywords" content=" link_mat_mul matrix multiply speed test multiple testing derivative of prototype purpose return value n repeat x z dz "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/link_ode.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Testing the Jacobian of Ode Solution</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Testing the Jacobian of Ode Solution"/>
7		<meta name="keywords" id="keywords" content=" link_ode ode speed test "/>
	8	<meta name="keywords" id="keywords" content=" link_ode ode speed test testing the jacobian of solution prototype purpose method f return value size repeat x double "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/link_poly.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Testing Second Derivative of a Polynomial</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Testing Second Derivative of a Polynomial"/>
7		<meta name="keywords" id="keywords" content=" link_poly polynomial speed test "/>
	8	<meta name="keywords" id="keywords" content=" link_poly polynomial speed test testing second derivative of a prototype purpose method return value size repeat z ddp double "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

180	181	The input value of its elements does not matter.
181	182	The output value of its elements is the coefficients of the
182	183	polynomial that is differentiated
183		(<i>i</i>-th element is coefficient of order
	184	(<code><i>i</i></code>-th element is coefficient of order
184	185	<code><i><font color="black"><span style='white-space: nowrap'>i</span></font></i></code>
185	186	).
186	187

-3

doc/link_sparse_hessian.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Testing Sparse Hessian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Testing Sparse Hessian"/>
7		<meta name="keywords" id="keywords" content=" link_sparse_hessian sparse speed test "/>
	8	<meta name="keywords" id="keywords" content=" link_sparse_hessian sparse speed test testing hessian prototype method size repeat x row col double "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

318	319	has prototype
319	320
320	321	<code><font color="blue"><span style='white-space: nowrap'><br/>
321		CppAD::vector<double> &</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	322	CppAD::vector<double>& </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
322	323	</span></font></code>
323	324	and its size is
324	325	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

475	476	has prototype
476	477
477	478	<code><font color="blue"><span style='white-space: nowrap'><br/>
478		CppAD::vector<double>  &hessian<br/>
	479	CppAD::vector<double>&  hessian<br/>
479	480	</span></font></code>
480	481	and its size is
481	482	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

+63

-49

doc/link_sparse_jacobian.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Testing Sparse Jacobian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Testing Sparse Jacobian"/>
7		<meta name="keywords" id="keywords" content=" link_sparse_jacobian sparse speed test "/>
	8	<meta name="keywords" id="keywords" content=" link_sparse_jacobian sparse speed test testing jacobian prototype method size repeat m row col x n_sweep double "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

91	92	<option>size</option>
92	93	<option>repeat</option>
93	94	<option>m</option>
94		<option>x</option>
95	95	<option>row</option>
96	96	<option>col</option>
	97	<option>x</option>
97	98	<option>jacobian</option>
	99	<option>n_sweep</option>
98	100	<option>---..double</option>
99	101	</select>
100	102	</td>

114	116	<br/>
115	117
116	118	<code><font color="blue"><span style='white-space: nowrap'>extern bool link_sparse_jacobian(<br/>
117		size_t                 </span></font><i><font color="black"><span style='white-space: nowrap'>size</span></font></i><font color="blue"><span style='white-space: nowrap'>      ,<br/>
118		size_t                 </span></font><i><font color="black"><span style='white-space: nowrap'>repeat</span></font></i><font color="blue"><span style='white-space: nowrap'>    ,<br/>
119		size_t                 </span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'>         ,<br/>
120		CppAD::vector<double> &</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>         ,<br/>
121		CppAD::vector<size_t> &</span></font><i><font color="black"><span style='white-space: nowrap'>row</span></font></i><font color="blue"><span style='white-space: nowrap'>       ,<br/>
122		CppAD::vector<size_t> &</span></font><i><font color="black"><span style='white-space: nowrap'>col</span></font></i><font color="blue"><span style='white-space: nowrap'>       , <br/>
123		CppAD::vector<double> &</span></font><i><font color="black"><span style='white-space: nowrap'>jacobian</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	119	size_t                       </span></font><i><font color="black"><span style='white-space: nowrap'>size</span></font></i><font color="blue"><span style='white-space: nowrap'>      ,<br/>
	120	size_t                       </span></font><i><font color="black"><span style='white-space: nowrap'>repeat</span></font></i><font color="blue"><span style='white-space: nowrap'>    ,<br/>
	121	size_t                       </span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'>         ,<br/>
	122	const CppAD::vector<size_t>& </span></font><i><font color="black"><span style='white-space: nowrap'>row</span></font></i><font color="blue"><span style='white-space: nowrap'>       ,<br/>
	123	const CppAD::vector<size_t>& </span></font><i><font color="black"><span style='white-space: nowrap'>col</span></font></i><font color="blue"><span style='white-space: nowrap'>       , <br/>
	124	CppAD::vector<double>& </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>         ,<br/>
	125	CppAD::vector<double>& </span></font><i><font color="black"><span style='white-space: nowrap'>jacobian</span></font></i><font color="blue"><span style='white-space: nowrap'>  ,<br/>
	126	size_t&                </span></font><i><font color="black"><span style='white-space: nowrap'>n_sweep</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
124	127	);<br/>
125	128	</span></font></code>
126	129	<br/>

280	283
281	284	<br/>
282	285	<br/>
283		<b><big><a name="x" id="x">x</a></big></b>
284		<br/>
285		The argument
286		<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
287		has prototype
288
289		<code><font color="blue"><span style='white-space: nowrap'><br/>
290		CppAD::vector<double> &</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
291		</span></font></code>
292		and its size is
293		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
294		<mi mathvariant='italic'>n</mi>
295		</mrow></math>
296
297		; i.e.,
298		<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>size</span></font></i></code>
299		.
300		The input value of the elements of
301		<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
302		does not matter.
303		On output, it has been set to the
304		argument value for which the function,
305		or its derivative, is being evaluated.
306		The value of this vector need not change with each repetition.
307
308		<br/>
309		<br/>
310	286	<b><big><a name="row" id="row">row</a></big></b>
311	287	<br/>
312	288	The size of the vector

317	293	</mrow></math>
318	294
319	295	.
320		The input value of the elements of
321		<code><i><font color="black"><span style='white-space: nowrap'>row</span></font></i></code>
322		does not matter.
323		On output, it has been set the row index vector
324		for the last repetition.
325	296	All the elements of
326	297	<code><i><font color="black"><span style='white-space: nowrap'>row</span></font></i></code>
327		must are between zero and
	298	are between zero and
328	299	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
329	300	<mi mathvariant='italic'>m</mi>
330	301	<mn>-1</mn>

349	320	for the last repetition.
350	321	All the elements of
351	322	<code><i><font color="black"><span style='white-space: nowrap'>col</span></font></i></code>
352		must are between zero and
	323	are between zero and
353	324	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
354	325	<mi mathvariant='italic'>n</mi>
355	326	<mn>-1</mn>

366	337	</span></font><i><font color="black"><span style='white-space: nowrap'>row</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>j</span></font></i><font color="blue"><span style='white-space: nowrap'>] != </span></font><i><font color="black"><span style='white-space: nowrap'>row</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'>] \|\| </span></font><i><font color="black"><span style='white-space: nowrap'>col</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>j</span></font></i><font color="blue"><span style='white-space: nowrap'>] != </span></font><i><font color="black"><span style='white-space: nowrap'>col</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>k</span></font></i><font color="blue"><span style='white-space: nowrap'>]<br/>
367	338	</span></font></code>
368	339	<br/>
	340	<b><big><a name="x" id="x">x</a></big></b>
	341	<br/>
	342	The argument
	343	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
	344	has prototype
	345
	346	<code><font color="blue"><span style='white-space: nowrap'><br/>
	347	CppAD::vector<double>& </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	348	</span></font></code>
	349	and its size is
	350	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	351	<mi mathvariant='italic'>n</mi>
	352	</mrow></math>
	353
	354	; i.e.,
	355	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>size</span></font></i></code>
	356	.
	357	The input value of the elements of
	358	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
	359	does not matter.
	360	On output, it has been set to the
	361	argument value for which the function,
	362	or its derivative, is being evaluated and placed in
	363	<code><i><font color="black"><span style='white-space: nowrap'>jacobian</span></font></i></code>
	364	.
	365	The value of this vector need not change with each repetition.
	366
	367	<br/>
	368	<br/>
369	369	<b><big><a name="jacobian" id="jacobian">jacobian</a></big></b>
370	370	<br/>
371	371	The argument

390	390
391	391
392	392	that corresponds to output values of
393
394		<code><i><font color="black"><span style='white-space: nowrap'>row</span></font></i></code>
395		,
396		<code><i><font color="black"><span style='white-space: nowrap'>col</span></font></i></code>
397		, and
398	393	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
399	394	.
400	395	To be more specific, for

455	450	</mrow></math>
456	451
457	452	<br/>
458		<b><a name="jacobian.double" id="jacobian.double">double</a></b>
	453	<b><big><a name="n_sweep" id="n_sweep">n_sweep</a></big></b>
	454	<br/>
	455	The input value of
	456	<code><i><font color="black"><span style='white-space: nowrap'>n_sweep</span></font></i></code>
	457	does not matter. On output,
	458	it is the value <a href="sparse_jacobian.xml#n_sweep" target="_top"><span style='white-space: nowrap'>n_sweep</span></a>
	459	corresponding
	460	to the evaluation of
	461	<code><i><font color="black"><span style='white-space: nowrap'>jacobian</span></font></i></code>
	462	.
	463	This is also the number of colors corresponding to the
	464	<a href="sparse_jacobian.xml#work.color_method" target="_top"><span style='white-space: nowrap'>coloring method</span></a>
	465
	466	which can be set to <a href="speed_main.xml#Sparsity Options.colpack" target="_top"><span style='white-space: nowrap'>colpack</span></a>
	467
	468	and is otherwise <code><font color="blue">cppad</font></code>.
	469
	470	<br/>
	471	<br/>
	472	<b><a name="n_sweep.double" id="n_sweep.double">double</a></b>
459	473	<br/>
460	474	In the case where
461	475	<code><i><font color="black"><span style='white-space: nowrap'>package</span></font></i></code>

+12

-3

doc/listallexamples.xml less more

3	3	>
4	4	<head>
5	5	<title>List of All the CppAD Examples</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="List of All the CppAD Examples"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" list of all the cppad examples "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

160	161	AD Boolean Functions: Example and Test</td></tr>
161	162	<tr><td>
162	163
163		<a href="capacity_taylor.cpp.xml" target="_top">capacity_taylor.cpp</a></td><td>
	164	<a href="capacity_order.cpp.xml" target="_top">capacity_order.cpp</a></td><td>
164	165	Controlling Taylor Coefficient Memory Allocation: Example and Test</td></tr>
165	166	<tr><td>
166	167

184	185	Simple Checkpointing: Example and Test</td></tr>
185	186	<tr><td>
186	187
	188	<a href="colpack.cpp.xml" target="_top">colpack.cpp</a></td><td>
	189	Using ColPack: Example and Test</td></tr>
	190	<tr><td>
	191
187	192	<a href="compare_change.cpp.xml" target="_top">compare_change.cpp</a></td><td>
188	193	CompareChange and Re-Tape: Example and Test</td></tr>
189	194	<tr><td>

280	285	Forward Mode: Example and Test</td></tr>
281	286	<tr><td>
282	287
283		<a href="forward_mul.cpp.xml" target="_top">forward_mul.cpp</a></td><td>
	288	<a href="forward_dir.cpp.xml" target="_top">forward_dir.cpp</a></td><td>
	289	Forward Mode: Example and Test of Multiple Directions</td></tr>
	290	<tr><td>
	291
	292	<a href="forward_order.cpp.xml" target="_top">forward_order.cpp</a></td><td>
284	293	Forward Mode: Example and Test of Multiple Orders</td></tr>
285	294	<tr><td>
286	295

-1

doc/log.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD log Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD log Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" log Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad log function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/log10.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD log10 Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD log10 Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" log10 Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad log10 function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/logforward.xml less more

3	3	>
4	4	<head>
5	5	<title>Logarithm Function Forward Taylor Polynomial Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Logarithm Function Forward Taylor Polynomial Theory"/>
7		<meta name="keywords" id="keywords" content=" log forward theory "/>
	8	<meta name="keywords" id="keywords" content=" log forward theory logarithm function taylor polynomial "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinForward</option>
77	78	<option>AcosForward</option>
78	79	<option>tan_forward</option>
	80	<option>erf_forward</option>
79	81	</select>
80	82	</td>
81	83	<td>LogForward</td>

469	471	</mrow></math>
470	472
471	473
472		<hr/>Input File: omh/log_forward.omh
	474	<hr/>Input File: omh/theory/log_forward.omh
473	475
474	476	</body>
475	477	</html>

-2

doc/logreverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Logarithm Function Reverse Mode Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Logarithm Function Reverse Mode Theory"/>
7		<meta name="keywords" id="keywords" content=" log reverse theory "/>
	8	<meta name="keywords" id="keywords" content=" log reverse theory logarithm function mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinReverse</option>
77	78	<option>AcosReverse</option>
78	79	<option>tan_reverse</option>
	80	<option>erf_reverse</option>
79	81	</select>
80	82	</td>
81	83	<td>LogReverse</td>

611	613	</mrow></math>
612	614
613	615
614		<hr/>Input File: omh/log_reverse.omh
	616	<hr/>Input File: omh/theory/log_reverse.omh
615	617
616	618	</body>
617	619	</html>

-1

doc/lu_factor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>LuFactor: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="LuFactor: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" example Lufactor test "/>
	8	<meta name="keywords" id="keywords" content=" lufactor: example and test Lufactor "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/lu_factor.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: LuFactor</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: LuFactor"/>
7		<meta name="keywords" id="keywords" content=" Lufactor source "/>
	8	<meta name="keywords" id="keywords" content=" source: lufactor Lufactor source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/lu_invert.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>LuInvert: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="LuInvert: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" example Luinvert test "/>
	8	<meta name="keywords" id="keywords" content=" luinvert: example and test Luinvert "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/lu_invert.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: LuInvert</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: LuInvert"/>
7		<meta name="keywords" id="keywords" content=" Luinvert source "/>
	8	<meta name="keywords" id="keywords" content=" source: luinvert Luinvert source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/lu_ratio.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>LuRatio: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="LuRatio: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" example Luratio test "/>
	8	<meta name="keywords" id="keywords" content=" luratio: example and test Luratio "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/lu_solve.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>LuSolve With Complex Arguments: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="LuSolve With Complex Arguments: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" complex Lusolve example test "/>
	8	<meta name="keywords" id="keywords" content=" lusolve with complex arguments: example and test Lusolve "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/lu_solve.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: LuSolve</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: LuSolve"/>
7		<meta name="keywords" id="keywords" content=" Lusolve source "/>
	8	<meta name="keywords" id="keywords" content=" source: lusolve Lusolve source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/lu_vec_ad.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Lu Factor and Solve with Recorded Pivoting</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Lu Factor and Solve with Recorded Pivoting"/>
7		<meta name="keywords" id="keywords" content=" Luvecad Lu linear equation determinant solve "/>
	8	<meta name="keywords" id="keywords" content=" Luvecad Lu linear equation determinant solve lu factor and with recorded pivoting syntax purpose storage convention n m matrix rhs result logdet example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/lu_vec_ad_ok.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Lu Factor and Solve With Recorded Pivoting: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Lu Factor and Solve With Recorded Pivoting: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Lu record pivot example test "/>
	8	<meta name="keywords" id="keywords" content=" lu factor and solve with recorded pivoting: example test Lu record pivot "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ludetandsolve.xml less more

3	3	>
4	4	<head>
5	5	<title>Compute Determinants and Solve Equations by LU Factorization</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Compute Determinants and Solve Equations by LU Factorization"/>
7		<meta name="keywords" id="keywords" content=" matrix factor determinant linear equation "/>
	8	<meta name="keywords" id="keywords" content=" matrix factor determinant linear equation compute determinants and solve equations by lu factorization "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/lufactor.xml less more

3	3	>
4	4	<head>
5	5	<title>LU Factorization of A Square Matrix</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="LU Factorization of A Square Matrix"/>
7		<meta name="keywords" id="keywords" content=" Lufactor linear Lu factor equation determinant solve "/>
	8	<meta name="keywords" id="keywords" content=" Lufactor linear Lu factor equation determinant solve lu factorization of a square matrix syntax description include storage sign ip jp p l u sizevector floatvector float absgeq example source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/luinvert.xml less more

3	3	>
4	4	<head>
5	5	<title>Invert an LU Factored Equation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Invert an LU Factored Equation"/>
7		<meta name="keywords" id="keywords" content=" Luinvert linear invert Lu equation "/>
	8	<meta name="keywords" id="keywords" content=" Luinvert linear invert Lu equation an lu factored syntax description include matrix storage ip jp l u p a x example source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/luratio.xml less more

3	3	>
4	4	<head>
5	5	<title>LU Factorization of A Square Matrix and Stability Calculation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="LU Factorization of A Square Matrix and Stability Calculation"/>
7		<meta name="keywords" id="keywords" content=" Luratio linear Lu factor equation determinant solve "/>
	8	<meta name="keywords" id="keywords" content=" Luratio linear Lu factor equation determinant solve lu factorization of a square matrix and stability calculation syntax description include storage sign ip jp p l u ratio purpose sizevector advector example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

531	532	</mrow></math>
532	533
533	534	,
534		the <i>p</i>-th pivot element is the element of maximum absolute value of a
	535	the <code><i>p</i></code>-th pivot element is the element of maximum absolute value of a
535	536
536	537	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
537	538	<mo stretchy="false">(</mo>

-1

doc/lusolve.xml less more

3	3	>
4	4	<head>
5	5	<title>Compute Determinant and Solve Linear Equations</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Compute Determinant and Solve Linear Equations"/>
7		<meta name="keywords" id="keywords" content=" Lusolve linear equation determinant Lu solve "/>
	8	<meta name="keywords" id="keywords" content=" Lusolve linear equation determinant Lu solve compute and equations syntax description include factor invert matrix storage signdet n m a b x logdet float floatvector leqzero absgeq example source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/main_compare_c.xml less more

3	3	>
4	4	<head>
5	5	<title>Main Program For Comparing C and C++ Speed</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Main Program For Comparing C and C++ Speed"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" main program for comparing c and c++ speed source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/mat_sum_sq.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sum of the Elements of the Square of a Matrix: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sum of the Elements of the Square of a Matrix: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" mat_sum_sq example test "/>
	8	<meta name="keywords" id="keywords" content=" sum of the elements square a matrix: example and test mat_sum_sq "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/mat_sum_sq.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: mat_sum_sq</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: mat_sum_sq"/>
7		<meta name="keywords" id="keywords" content=" mat_sum_sq source "/>
	8	<meta name="keywords" id="keywords" content=" source: mat_sum_sq source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/mat_sum_sq.xml less more

3	3	>
4	4	<head>
5	5	<title>Sum Elements of a Matrix Times Itself</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sum Elements of a Matrix Times Itself"/>
7		<meta name="keywords" id="keywords" content=" mat_sum_sq matrix multiply speed test "/>
	8	<meta name="keywords" id="keywords" content=" sum elements of a matrix times itself mat_sum_sq multiply speed test syntax purpose inclusion n x y z vector example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/mathother.xml less more

3	3	>
4	4	<head>
5	5	<title>Other AD Math Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Other AD Math Functions"/>
7		<meta name="keywords" id="keywords" content=" other Ad math "/>
	8	<meta name="keywords" id="keywords" content=" other Ad math ad functions "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/memory_leak.xml less more

3	3	>
4	4	<head>
5	5	<title>Memory Leak Detection</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Memory Leak Detection"/>
7		<meta name="keywords" id="keywords" content=" memory_leak leak memory check static deprecated "/>
	8	<meta name="keywords" id="keywords" content=" memory leak detection memory_leak check static deprecated syntax purpose thread add_static flag inuse available track_count error message "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/microsoft_timer.xml less more

3	3	>
4	4	<head>
5	5	<title>Microsoft Version of Elapsed Number of Seconds</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Microsoft Version of Elapsed Number of Seconds"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" microsoft version of elapsed number seconds syntax purpose s linking "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/mul.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Binary Multiplication: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Binary Multiplication: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" * Ad example multiply times test "/>
	8	<meta name="keywords" id="keywords" content=" ad binary multiplication: example and test * Ad multiply times "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/mul_eq.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Computed Assignment Multiplication: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Computed Assignment Multiplication: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" *= Ad example computed assignment multiply test assign plus add "/>
	8	<meta name="keywords" id="keywords" content=" ad computed assignment multiplication: example and test *= Ad multiply assign plus add "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/mul_level.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Multiple Tapes: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Multiple Tapes: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" multiple Ad level "/>
	8	<meta name="keywords" id="keywords" content=" multiple tapes: example and test Ad level purpose "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/mul_level.xml less more

3	3	>
4	4	<head>
5	5	<title>Using Multiple Levels of AD</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using Multiple Levels of AD"/>
7		<meta name="keywords" id="keywords" content=" multiple Ad level "/>
	8	<meta name="keywords" id="keywords" content=" multiple Ad level using levels of ad background motivation general solution procedure start adbasetape addbasetape inner function calculations derivative outer example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/mul_level_adolc.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Using Adolc with Multiple Levels of Taping: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using Adolc with Multiple Levels of Taping: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" multiple Adolc level "/>
	8	<meta name="keywords" id="keywords" content=" using adolc with multiple levels of taping: example and test Adolc level purpose memory management configuration requirement "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-3

doc/mul_level_adolc_ode.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Using Adolc with Taylor's Ode Solver: An Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using Adolc with Taylor's Ode Solver: An Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Ode Taylor Adolc "/>
	8	<meta name="keywords" id="keywords" content=" using adolc with taylor's ode solver: an example and test Ode Taylor Adolc purpose solution derivative of method ad base_adolc.hpp memory management configuration requirement "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

513	514	<br/>
514	515	<b><big><a name="Taylor's Method Using AD" id="Taylor's Method Using AD">Taylor's Method Using AD</a></big></b>
515	516	<br/>
516		An <i>m</i>-th order Taylor method for
	517	An <code><i>m</i></code>-th order Taylor method for
517	518	approximating the solution of an
518	519	ordinary differential equations is
519	520

790	791	</mrow></math>
791	792
792	793	is the
793		<i>k</i>-th order Taylor coefficient
	794	<code><i>k</i></code>-th order Taylor coefficient
794	795	for
795	796	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
796	797	<mi mathvariant='italic'>z</mi>

-3

doc/mul_level_ode.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Taylor's Ode Solver: An Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Taylor's Ode Solver: An Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Ode Taylor example test "/>
	8	<meta name="keywords" id="keywords" content=" taylor's ode solver: an example and test Ode Taylor purpose solution derivative of method using ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

510	511	<br/>
511	512	<b><big><a name="Taylor's Method Using AD" id="Taylor's Method Using AD">Taylor's Method Using AD</a></big></b>
512	513	<br/>
513		An <i>m</i>-th order Taylor method for
	514	An <code><i>m</i></code>-th order Taylor method for
514	515	approximating the solution of an
515	516	ordinary differential equations is
516	517

787	788	</mrow></math>
788	789
789	790	is the
790		<i>k</i>-th order Taylor coefficient
	791	<code><i>k</i></code>-th order Taylor coefficient
791	792	for
792	793	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
793	794	<mi mathvariant='italic'>z</mi>

-3

doc/multi_newton.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>A Multi-Threaded Newton's Method</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Multi-Threaded Newton's Method"/>
7		<meta name="keywords" id="keywords" content=" multi_newton threading thread newton multi-threading "/>
	8	<meta name="keywords" id="keywords" content=" multi_newton threading thread newton multi-threading a multi-threaded newton's method syntax purpose ok xout fun num_sub xlow xup epsilon max_itr num_threads source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

179	180	</mrow></math>
180	181
181	182	,
182		we define the <i>i</i>-th grid point
	183	we define the <code><i>i</i></code>-th grid point
183	184	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
184	185	<msub><mi mathvariant='italic'>g</mi>
185	186	<mi mathvariant='italic'>i</mi>

223	224	</mrow></math>
224	225
225	226	,
226		we define the <i>i</i>-th sub-interval of
	227	we define the <code><i>i</i></code>-th sub-interval of
227	228	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
228	229	<mo stretchy="false">[</mo>
229	230	<mi mathvariant='italic'>a</mi>

-1

doc/multi_newton_time.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Timing Test of Multi-Threaded Newton Method</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Timing Test of Multi-Threaded Newton Method"/>
7		<meta name="keywords" id="keywords" content=" multi_newton_time multi_thread Newton Ad speed thread multi_newton newton "/>
	8	<meta name="keywords" id="keywords" content=" multi_newton_time multi_thread Newton Ad speed thread multi_newton newton timing test of multi-threaded method syntax purpose ok time_out test_time num_threads num_zero num_sub num_sum use_ad source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/multi_newton_work.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Multi-threading Newton Method Utility Routines</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Multi-threading Newton Method Utility Routines"/>
7		<meta name="keywords" id="keywords" content=" multi_newton_work multi_newton_setup multi_newton_worker multi_newton_combine setup multi_newton worker combine "/>
	8	<meta name="keywords" id="keywords" content=" multi_newton_work multi-threading newton method utility routines multi_newton_setup multi_newton_worker multi_newton_combine setup multi_newton worker combine syntax purpose fun num_sub xlow xup epsilon max_itr num_threads xout source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/multi_thread.xml less more

3	3	>
4	4	<head>
5	5	<title>Using CppAD in a Multi-Threading Environment</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using CppAD in a Multi-Threading Environment"/>
7		<meta name="keywords" id="keywords" content=" parallel mode execution multi-threading maximum number of threads Cppad_max_num_threads "/>
	8	<meta name="keywords" id="keywords" content=" using cppad in a multi-threading environment parallel mode execution purpose cppad_max_num_threads maximum number of threads Cppad_max_num_threads parallel_setup hold_memory ad initialization same thread prohibited "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/nan.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>nan: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="nan: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" nan example test "/>
	8	<meta name="keywords" id="keywords" content=" nan: example and test nan "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/nan.xml less more

3	3	>
4	4	<head>
5	5	<title>Obtain Nan or Determine if a Value is Nan</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Obtain Nan or Determine if a Value is Nan"/>
7		<meta name="keywords" id="keywords" content=" isnan hasnan nan macro "/>
	8	<meta name="keywords" id="keywords" content=" obtain nan or determine if a value is isnan hasnan syntax purpose include macros macro z s b v scalar vector example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/near_equal.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>NearEqual Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="NearEqual Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Nearequal example test "/>
	8	<meta name="keywords" id="keywords" content=" nearequal function: example and test Nearequal file name "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/near_equal_ext.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Compare AD with Base Objects: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Compare AD with Base Objects: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Nearequalext example test "/>
	8	<meta name="keywords" id="keywords" content=" compare ad with base objects: example and test Nearequalext "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/nearequal.xml less more

3	3	>
4	4	<head>
5	5	<title>Determine if Two Values Are Nearly Equal</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determine if Two Values Are Nearly Equal"/>
7		<meta name="keywords" id="keywords" content=" Nearequal equal near absolute difference relative exercise "/>
	8	<meta name="keywords" id="keywords" content=" determine if two values are nearly equal Nearequal near absolute difference relative syntax purpose x y r a b type include files example exercise "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/nearequalext.xml less more

3	3	>
4	4	<head>
5	5	<title>Compare AD and Base Objects for Nearly Equal</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Compare AD and Base Objects for Nearly Equal"/>
7		<meta name="keywords" id="keywords" content=" Nearequal Ad with Base "/>
	8	<meta name="keywords" id="keywords" content=" compare ad and base objects for nearly equal Nearequal Ad with Base syntax purpose x y r a b type operation sequence example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/not_complex_ad.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Not Complex Differentiable: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Not Complex Differentiable: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" complex polynomial imag() real() example not differentiable test "/>
	8	<meta name="keywords" id="keywords" content=" not complex differentiable: example and test polynomial imag() real() differentiable see also poly "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+10

-9

doc/number_skip.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Number of Variables That Can be Skipped: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Number of Variables That Can be Skipped: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" number_skip example optimize conditional expression condition "/>
	8	<meta name="keywords" id="keywords" content=" number of variables that can be skipped: example and test number_skip optimize conditional expression condition "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="number_skip.xml" target="_top">Prev</a>
24		</td><td><a href="forward.cpp.xml" target="_top">Next</a>
	25	</td><td><a href="reverse.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

54	55	<td>
55	56	<select onchange='choose_down2(this)'>
56	57	<option>Forward-></option>
57		<option>ForwardZero</option>
58		<option>ForwardOne</option>
59		<option>ForwardAny</option>
60		<option>size_taylor</option>
	58	<option>forward_zero</option>
	59	<option>forward_one</option>
	60	<option>forward_two</option>
	61	<option>forward_order</option>
	62	<option>forward_dir</option>
	63	<option>size_order</option>
61	64	<option>CompareChange</option>
62		<option>capacity_taylor</option>
	65	<option>capacity_order</option>
63	66	<option>number_skip</option>
64		<option>forward.cpp</option>
65		<option>forward_mul.cpp</option>
66	67	</select>
67	68	</td>
68	69	<td>

+10

-9

doc/number_skip.xml less more

3	3	>
4	4	<head>
5	5	<title>Number of Variables that Can be Skipped</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Number of Variables that Can be Skipped"/>
7		<meta name="keywords" id="keywords" content=" number_skip number skip variables "/>
	8	<meta name="keywords" id="keywords" content=" number_skip number skip variables of that can be skipped syntax see also purpose n f example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="capacity_taylor.cpp.xml" target="_top">Prev</a>
	24	<td><a href="capacity_order.cpp.xml" target="_top">Prev</a>
24	25	</td><td><a href="number_skip.cpp.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

68	69	<td>
69	70	<select onchange='choose_down1(this)'>
70	71	<option>Forward-></option>
71		<option>ForwardZero</option>
72		<option>ForwardOne</option>
73		<option>ForwardAny</option>
74		<option>size_taylor</option>
	72	<option>forward_zero</option>
	73	<option>forward_one</option>
	74	<option>forward_two</option>
	75	<option>forward_order</option>
	76	<option>forward_dir</option>
	77	<option>size_order</option>
75	78	<option>CompareChange</option>
76		<option>capacity_taylor</option>
	79	<option>capacity_order</option>
77	80	<option>number_skip</option>
78		<option>forward.cpp</option>
79		<option>forward_mul.cpp</option>
80	81	</select>
81	82	</td>
82	83	<td>

-1

doc/numeric_type.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The NumericType: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The NumericType: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Numerictype example test "/>
	8	<meta name="keywords" id="keywords" content=" the numerictype: example and test Numerictype "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/numerictype.xml less more

3	3	>
4	4	<head>
5	5	<title>Definition of a Numeric Type</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Definition of a Numeric Type"/>
7		<meta name="keywords" id="keywords" content=" numeric type default constructor int copy exercise "/>
	8	<meta name="keywords" id="keywords" content=" numeric type definition of a requirements default constructor from integer int copy assignment operators example exercise "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ode_err_control.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>OdeErrControl: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="OdeErrControl: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Odeerrcontrol example test "/>
	8	<meta name="keywords" id="keywords" content=" odeerrcontrol: example and test Odeerrcontrol nan "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ode_err_maxabs.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>OdeErrControl: Example and Test Using Maxabs Argument</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="OdeErrControl: Example and Test Using Maxabs Argument"/>
7		<meta name="keywords" id="keywords" content=" Odeerrcontrol example maxabs test "/>
	8	<meta name="keywords" id="keywords" content=" odeerrcontrol: example and test using maxabs argument Odeerrcontrol "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ode_evaluate.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ode_evaluate: Example and test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ode_evaluate: Example and test"/>
7		<meta name="keywords" id="keywords" content=" ode_evaluate example test "/>
	8	<meta name="keywords" id="keywords" content=" ode_evaluate example test ode_evaluate: and "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ode_evaluate.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: ode_evaluate</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: ode_evaluate"/>
7		<meta name="keywords" id="keywords" content=" ode_evaluate source "/>
	8	<meta name="keywords" id="keywords" content=" source: ode_evaluate source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ode_evaluate.xml less more

3	3	>
4	4	<head>
5	5	<title>Evaluate a Function Defined in Terms of an ODE</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Evaluate a Function Defined in Terms of an ODE"/>
7		<meta name="keywords" id="keywords" content=" ode_evaluate function "/>
	8	<meta name="keywords" id="keywords" content=" evaluate a function defined in terms of an ode ode_evaluate syntax purpose inclusion float operation sequence fabs x p == 0 = 1 fp gradient example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ode_gear.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>OdeGear: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="OdeGear: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Odegear example test "/>
	8	<meta name="keywords" id="keywords" content=" odegear: example and test Odegear "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ode_gear_control.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>OdeGearControl: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="OdeGearControl: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Odegearcontrol example test "/>
	8	<meta name="keywords" id="keywords" content=" odegearcontrol: example and test Odegearcontrol "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ode_stiff.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>A Stiff Ode: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Stiff Ode: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" stiff ode example test "/>
	8	<meta name="keywords" id="keywords" content=" a stiff ode: example and test ode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-3

doc/ode_taylor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Taylor's Ode Solver: An Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Taylor's Ode Solver: An Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Ode Taylor example test "/>
	8	<meta name="keywords" id="keywords" content=" taylor's ode solver: an example and test Ode Taylor purpose solution forward mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

429	430	</msup>
430	431	</mrow></math>
431	432
432		is the <i>k</i>-th order Taylor coefficient for
	433	is the <code><i>k</i></code>-th order Taylor coefficient for
433	434
434	435	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
435	436	<mi mathvariant='italic'>H</mi>

442	443	</mrow></math>
443	444
444	445	.
445		Taking <i>K</i>-th order derivatives of both sides we obtain
	446	Taking <code><i>K</i></code>-th order derivatives of both sides we obtain
446	447
447	448	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
448	449	<mtable rowalign="center" ><mtr><mtd columnalign="right" >

-1

doc/odeerrcontrol.xml less more

3	3	>
4	4	<head>
5	5	<title>An Error Controller for ODE Solvers</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="An Error Controller for ODE Solvers"/>
7		<meta name="keywords" id="keywords" content=" Odeerrcontrol Ode control error differential equation "/>
	8	<meta name="keywords" id="keywords" content=" Odeerrcontrol Ode control error differential equation an controller for ode solvers syntax description include notation xf method step nan order ti tf xi smin smax scur eabs erel ef maxabs nstep criteria discussion scalar vector example theory source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/odegear.xml less more

3	3	>
4	4	<head>
5	5	<title>An Arbitrary Order Gear Method</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="An Arbitrary Order Gear Method"/>
7		<meta name="keywords" id="keywords" content=" Odegear Ode Gear stiff differential equation "/>
	8	<meta name="keywords" id="keywords" content=" Odegear Ode Gear stiff differential equation an arbitrary order gear method syntax purpose include fun t x f f_x warning m n e scalar vector example source code theory gear's "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

421	422
422	423	in the multi-step method.
423	424	Upon return from <code><font color="blue">OdeGear</font></code>,
424		the <i>i</i>-th component of the polynomial is defined by
	425	the <code><i>i</i></code>-th component of the polynomial is defined by
425	426
426	427	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
427	428	<msub><mi mathvariant='italic'>p</mi>

-1

doc/odegearcontrol.xml less more

3	3	>
4	4	<head>
5	5	<title>An Error Controller for Gear's Ode Solvers</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="An Error Controller for Gear's Ode Solvers"/>
7		<meta name="keywords" id="keywords" content=" Odegearcontrol control Ode Gear error differential equation "/>
	8	<meta name="keywords" id="keywords" content=" Odegearcontrol control Ode Gear error differential equation an controller for gear's ode solvers syntax purpose include notation xf fun t x f f_x warning m ti tf xi smin smax sini eabs erel ef maxabs nstep criteria discussion scalar vector example theory source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/old_atomic.xml less more

3	3	>
4	4	<head>
5	5	<title>User Defined Atomic AD Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="User Defined Atomic AD Functions"/>
7		<meta name="keywords" id="keywords" content=" Cppad_user_atomic atomic user function operation parallel old_atomic "/>
	8	<meta name="keywords" id="keywords" content=" user defined atomic ad functions Cppad_user_atomic function operation syntax define use callback routines free static memory purpose partial implementation cppad_user_atomic tvector base ok id k n m tx ty forward reverse afun ax ay parallel mode old_atomic usage vx vy py px for_jac_sparse q r s rev_jac_sparse rev_hes_sparse t u v clear restriction example simple tangent matrix multiplication "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

1382	1383
1383	1384	<code><i><font color="black"><span style='white-space: nowrap'>k</span></font></i></code>
1384	1385	equal to the order of the derivative begin computed,
1385		by calls to <a href="forwardany.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
	1386	by calls to <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
1386	1387	.
1387	1388
1388	1389	<br/>

-1

doc/old_mat_mul.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Matrix Multiply as a User Atomic Operation: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Matrix Multiply as a User Atomic Operation: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" old_atomic example test matrix atomic old_mat_mul "/>
	8	<meta name="keywords" id="keywords" content=" matrix multiply as a user atomic operation: example and test old_atomic old_mat_mul deprecated include file "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-4

doc/old_mat_mul.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Define Matrix Multiply as a User Atomic Operation</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Define Matrix Multiply as a User Atomic Operation"/>
7		<meta name="keywords" id="keywords" content=" old_mat_mul define matrix multiply old_atomic test example "/>
	8	<meta name="keywords" id="keywords" content=" define matrix multiply as a user atomic operation old_mat_mul old_atomic test example syntax begin source extra call information indexing one reverse partials order set union cppad callback functions declare mat_mul function "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

378	379	size_t id ,
379	380	size_t n ,
380	381	size_t m ,
381		size_t q ,
	382	size_t p ,
382	383	const vector< std::set<size_t> >& r ,
383	384	vector< std::set<size_t> >& s )
384	385	{ size_t i, j, k, im_left, middle, mj_right, ij_result;

409	410	size_t id ,
410	411	size_t n ,
411	412	size_t m ,
412		size_t q ,
	413	size_t p ,
413	414	vector< std::set<size_t> >& r ,
414	415	const vector< std::set<size_t> >& s )
415	416	{ size_t i, j, k, im_left, middle, mj_right, ij_result;

442	443	size_t id ,
443	444	size_t n ,
444	445	size_t m ,
445		size_t q ,
	446	size_t p ,
446	447	const vector< std::set<size_t> >& r ,
447	448	const vector<bool>& s ,
448	449	vector<bool>& t ,

-1

doc/old_max_num_threads.xml less more

3	3	>
4	4	<head>
5	5	<title>Set Maximum Number of Threads for omp_alloc Allocator</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Set Maximum Number of Threads for omp_alloc Allocator"/>
7		<meta name="keywords" id="keywords" content=" max_num_threads omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" set maximum number of threads for omp_alloc allocator removed max_num_threads syntax purpose restrictions "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+33

-32

doc/old_reciprocal.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Old Atomic Operation Reciprocal: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Old Atomic Operation Reciprocal: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" user old atomic reciprocal "/>
	8	<meta name="keywords" id="keywords" content=" old atomic operation reciprocal: example and test user reciprocal deprecated theory "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

192	193	double f, fp, fpp;
193	194
194	195	// Must always define the case k = 0.
195		// Do not need case k if not using f.<a href="forward.xml" target="_top">Forward</a>(p, xp) for p >= k.
	196	// Do not need case k if not using f.<a href="forward.xml" target="_top">Forward</a>(q, xp) for q >= k.
196	197	switch(k)
197	198	{ case 0:
198	199	// this case must be implemented

298	299	size_t id ,
299	300	size_t n ,
300	301	size_t m ,
301		size_t q ,
	302	size_t p ,
302	303	const vector< std::set<size_t> >& r ,
303	304	vector< std::set<size_t> >& s )
304	305	{ // Can just return false if not using f.ForSparseJac

317	318	size_t id ,
318	319	size_t n ,
319	320	size_t m ,
320		size_t q ,
	321	size_t p ,
321	322	vector< std::set<size_t> >& r ,
322	323	const vector< std::set<size_t> >& s )
323	324	{ // Can just return false if not using RevSparseJac.

326	327	assert( m == 1 );
327	328
328	329	// sparsity for R(x) = S * f'(x) is same as sparsity for S
329		for(size_t p = 0; p < q; p++)
330		r[p] = s[p];
	330	for(size_t q = 0; q < p; q++)
	331	r[q] = s[q];
331	332
332	333	return true;
333	334	}

337	338	size_t id ,
338	339	size_t n ,
339	340	size_t m ,
340		size_t q ,
	341	size_t p ,
341	342	const vector< std::set<size_t> >& r ,
342	343	const vector<bool>& s ,
343	344	vector<bool>& t ,

423	424	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
424	425
425	426	// check zero order forward mode
426		size_t p;
427		vector<double> x_p(n), y_p(m);
428		p = 0;
429		x_p[0] = x0;
430		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
431		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	427	size_t q;
	428	vector<double> x_q(n), y_q(m);
	429	q = 0;
	430	x_q[0] = x0;
	431	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	432	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
432	433
433	434	// check first order forward mode
434		p = 1;
435		x_p[0] = 1;
436		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
	435	q = 1;
	436	x_q[0] = 1;
	437	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
437	438	check = 1.;
438		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	439	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
439	440
440	441	// check second order forward mode
441		p = 2;
442		x_p[0] = 0;
443		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
	442	q = 2;
	443	x_q[0] = 0;
	444	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
444	445	check = 0.;
445		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	446	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
446	447
447	448	// --------------------------------------------------------------------
448	449	// Check reverse mode results
449	450	//
450	451	// third order reverse mode
451		p = 3;
452		vector<double> w(m), dw(n * p);
	452	q = 3;
	453	vector<double> w(m), dw(n * q);
453	454	w[0] = 1.;
454		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(p, w);
	455	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(q, w);
455	456	check = 1.;
456	457	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0] , check, eps, eps);
457	458	check = 0.;

460	461
461	462	// --------------------------------------------------------------------
462	463	// forward mode sparstiy pattern
463		size_t q = n;
464		CppAD::vectorBool r1(n * q), s1(m * q);
	464	size_t p = n;
	465	CppAD::vectorBool r1(n * p), s1(m * p);
465	466	r1[0] = true; // compute sparsity pattern for x[0]
466		s1 = f.ForSparseJac(q, r1);
	467	s1 = f.ForSparseJac(p, r1);
467	468	ok &= s1[0] == true; // f[0] depends on x[0]
468	469
469	470	// --------------------------------------------------------------------
470	471	// reverse mode sparstiy pattern
471		p = m;
472		CppAD::vectorBool s2(p * m), r2(p * n);
	472	q = m;
	473	CppAD::vectorBool s2(q * m), r2(q * n);
473	474	s2[0] = true; // compute sparsity pattern for f[0]
474		r2 = f.RevSparseJac(p, s2);
	475	r2 = f.RevSparseJac(q, s2);
475	476	ok &= r2[0] == true; // f[0] depends on x[0]
476	477
477	478	// --------------------------------------------------------------------
478	479	// Hessian sparsity (using previous ForSparseJac call)
479		CppAD::vectorBool s3(m), h(q * n);
	480	CppAD::vectorBool s3(m), h(p * n);
480	481	s3[0] = true; // compute sparsity pattern for f[0]
481		h = f.RevSparseHes(q, s3);
	482	h = f.RevSparseHes(p, s3);
482	483	ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
483	484
484	485	// -----------------------------------------------------------------

+17

-16

doc/old_tan.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Tan and Tanh as User Atomic Operations: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Tan and Tanh as User Atomic Operations: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" tan old_atomic user atomic test example "/>
	8	<meta name="keywords" id="keywords" content=" tan and tanh as user atomic operations: example test old_atomic deprecated theory "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

265	266	size_t id ,
266	267	size_t n ,
267	268	size_t m ,
268		size_t q ,
	269	size_t p ,
269	270	const vector< std::set<size_t> >& r ,
270	271	vector< std::set<size_t> >& s )
271	272	{

287	288	size_t id ,
288	289	size_t n ,
289	290	size_t m ,
290		size_t q ,
	291	size_t p ,
291	292	vector< std::set<size_t> >& r ,
292	293	const vector< std::set<size_t> >& s )
293	294	{

308	309	size_t id ,
309	310	size_t n ,
310	311	size_t m ,
311		size_t q ,
	312	size_t p ,
312	313	const vector< std::set<size_t> >& r ,
313	314	const vector<bool>& s ,
314	315	vector<bool>& t ,

450	451	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ddw[1], w[0]tanpp + w[1]tanhpp, eps, eps);
451	452
452	453	// Forward mode computation of sparsity pattern for F.
453		size_t q = n;
	454	size_t p = n;
454	455	// user vectorBool because m and n are small
455		CppAD::vectorBool r1(q), s1(m * q);
	456	CppAD::vectorBool r1(p), s1(m * p);
456	457	r1[0] = true; // propagate sparsity for x[0]
457		s1 = F.ForSparseJac(q, r1);
	458	s1 = F.ForSparseJac(p, r1);
458	459	ok &= (s1[0] == true); // f[0] depends on x[0]
459	460	ok &= (s1[1] == true); // f[1] depends on x[0]
460	461	ok &= (s1[2] == false); // f[2] does not depend on x[0]
461	462
462	463	// Reverse mode computation of sparsity pattern for F.
463		size_t p = m;
464		CppAD::vectorBool s2(p * m), r2(p * n);
	464	size_t q = m;
	465	CppAD::vectorBool s2(q * m), r2(q * n);
465	466	// Sparsity pattern for identity matrix
466	467	size_t i, j;
467		for(i = 0; i < p; i++)
	468	for(i = 0; i < q; i++)
468	469	{ for(j = 0; j < m; j++)
469		s2[i * p + j] = (i == j);
470		}
471		r2 = F.RevSparseJac(p, s2);
	470	s2[i * q + j] = (i == j);
	471	}
	472	r2 = F.RevSparseJac(q, s2);
472	473	ok &= (r2[0] == true); // f[0] depends on x[0]
473	474	ok &= (r2[1] == true); // f[1] depends on x[0]
474	475	ok &= (r2[2] == false); // f[2] does not depend on x[0]
475	476
476	477	// Hessian sparsity for f[0]
477		CppAD::vectorBool s3(m), h(q * n);
	478	CppAD::vectorBool s3(m), h(p * n);
478	479	s3[0] = true;
479	480	s3[1] = false;
480	481	s3[2] = false;
481		h = F.RevSparseHes(q, s3);
	482	h = F.RevSparseHes(p, s3);
482	483	ok &= (h[0] == true); // Hessian is non-zero
483	484
484	485	// Hessian sparsity for f[2]
485	486	s3[0] = false;
486	487	s3[2] = true;
487		h = F.RevSparseHes(q, s3);
	488	h = F.RevSparseHes(p, s3);
488	489	ok &= (h[0] == false); // Hessian is zero
489	490
490	491	// check tanh results for a large value of x

+70

-69

doc/old_usead_1.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Using AD to Compute Atomic Function Derivatives</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using AD to Compute Atomic Function Derivatives"/>
7		<meta name="keywords" id="keywords" content=" Ad inside atomic user checkpoint "/>
	8	<meta name="keywords" id="keywords" content=" using ad to compute atomic function derivatives Ad inside user checkpoint deprecated purpose simple case "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

168	169	assert( m == 1 );
169	170	assert( k == 0 \|\| vx.size() == 0 );
170	171	bool ok = true;
171		vector<double> x_p(1), y_p(1);
	172	vector<double> x_q(1), y_q(1);
172	173
173	174	// check for special case
174	175	if( vx.size() > 0 )

176	177
177	178	// make sure r_ has proper lower order Taylor coefficients stored
178	179	// then compute ty[k]
179		for(size_t p = 0; p <= k; p++)
180		{ x_p[0] = tx[p];
181		y_p = r_ptr_->Forward(p, x_p);
182		if( p == k )
183		ty[k] = y_p[0];
184		assert( p == k \|\| ty[p] == y_p[0] );
	180	for(size_t q = 0; q <= k; q++)
	181	{ x_q[0] = tx[q];
	182	y_q = r_ptr_->Forward(q, x_q);
	183	if( q == k )
	184	ty[k] = y_q[0];
	185	assert( q == k \|\| ty[q] == y_q[0] );
185	186	}
186	187	return ok;
187	188	}

201	202	assert( n == 1 );
202	203	assert( m == 1 );
203	204	bool ok = true;
204		vector<double> x_p(1), w(k+1), dw(k+1);
	205	vector<double> x_q(1), w(k+1), dw(k+1);
205	206
206	207	// make sure r_ has proper forward mode coefficients
207		size_t p;
208		for(p = 0; p <= k; p++)
209		{ x_p[0] = tx[p];
	208	size_t q;
	209	for(q = 0; q <= k; q++)
	210	{ x_q[0] = tx[q];
210	211	# ifdef NDEBUG
211		r_ptr_->Forward(p, x_p);
	212	r_ptr_->Forward(q, x_q);
212	213	# else
213		vector<double> y_p(1);
214		y_p = r_ptr_->Forward(p, x_p);
215		assert( ty[p] == y_p[0] );
	214	vector<double> y_q(1);
	215	y_q = r_ptr_->Forward(q, x_q);
	216	assert( ty[q] == y_q[0] );
216	217	# endif
217	218	}
218		for(p = 0; p <=k; p++)
219		w[p] = py[p];
	219	for(q = 0; q <=k; q++)
	220	w[q] = py[q];
220	221	dw = r_ptr_->Reverse(k+1, w);
221		for(p = 0; p <=k; p++)
222		px[p] = dw[p];
	222	for(q = 0; q <=k; q++)
	223	px[q] = dw[q];
223	224
224	225	return ok;
225	226	}

229	230	size_t id ,
230	231	size_t n ,
231	232	size_t m ,
232		size_t q ,
	233	size_t p ,
233	234	const vector< std::set<size_t> >& r ,
234	235	vector< std::set<size_t> >& s )
235	236	{ assert( id == 0 );

239	240
240	241	vector< std::set<size_t> > R(1), S(1);
241	242	R[0] = r[0];
242		S = r_ptr_->ForSparseJac(q, R);
	243	S = r_ptr_->ForSparseJac(p, R);
243	244	s[0] = S[0];
244	245
245	246	return ok;

250	251	size_t id ,
251	252	size_t n ,
252	253	size_t m ,
253		size_t q ,
	254	size_t p ,
254	255	vector< std::set<size_t> >& r ,
255	256	const vector< std::set<size_t> >& s )
256	257	{

259	260	assert( m == 1 );
260	261	bool ok = true;
261	262
262		vector< std::set<size_t> > R(q), S(q);
263		size_t p;
264		for(p = 0; p < q; p++)
265		S[p] = s[p];
266		R = r_ptr_->RevSparseJac(q, S);
267		for(p = 0; p < q; p++)
268		r[p] = R[p];
	263	vector< std::set<size_t> > R(p), S(p);
	264	size_t q;
	265	for(q = 0; q < p; q++)
	266	S[q] = s[q];
	267	R = r_ptr_->RevSparseJac(p, S);
	268	for(q = 0; q < p; q++)
	269	r[q] = R[q];
269	270
270	271	return ok;
271	272	}

275	276	size_t id ,
276	277	size_t n ,
277	278	size_t m ,
278		size_t q ,
	279	size_t p ,
279	280	const vector< std::set<size_t> >& r ,
280	281	const vector<bool>& s ,
281	282	vector<bool>& t ,

294	295	t[0] = T[0];
295	296
296	297	// compute sparsity pattern for A(x) = U(x)^T * f'(x)
297		vector<bool> Ut(q), A(q);
298		size_t p;
299		for(p = 0; p < q; p++)
300		Ut[p] = false;
	298	vector<bool> Ut(p), A(p);
	299	size_t q;
	300	for(q = 0; q < p; q++)
	301	Ut[q] = false;
301	302	std::set<size_t>::iterator itr;
302	303	for(itr = u[0].begin(); itr != u[0].end(); itr++)
303	304	Ut[*itr] = true;
304		A = r_ptr_-> RevSparseJac(q, Ut);
	305	A = r_ptr_-> RevSparseJac(p, Ut);
305	306
306	307	// compute sparsity pattern for H(x) = R^T * (S * F)''(x)
307		vector<bool> H(q), R(n);
308		for(p = 0; p < q; p++)
309		R[p] = false;
	308	vector<bool> H(p), R(n);
	309	for(q = 0; q < p; q++)
	310	R[q] = false;
310	311	for(itr = r[0].begin(); itr != r[0].end(); itr++)
311	312	R[*itr] = true;
312		r_ptr_->ForSparseJac(q, R);
313		H = r_ptr_->RevSparseHes(q, S);
	313	r_ptr_->ForSparseJac(p, R);
	314	H = r_ptr_->RevSparseHes(p, S);
314	315
315	316	// compute sparsity pattern for V(x) = A(x)^T + H(x)^T
316	317	v[0].clear();
317		for(p = 0; p < q; p++)
318		if( A[p] \| H[p] )
319		v[0].insert(p);
	318	for(q = 0; q < p; q++)
	319	if( A[q] \| H[q] )
	320	v[0].insert(q);
320	321
321	322	return ok;
322	323	}

379	380	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
380	381
381	382	// check zero order forward mode
382		size_t p;
383		vector<double> x_p(n), y_p(m);
384		p = 0;
385		x_p[0] = x0;
386		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
387		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	383	size_t q;
	384	vector<double> x_q(n), y_q(m);
	385	q = 0;
	386	x_q[0] = x0;
	387	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	388	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
388	389
389	390	// check first order forward mode
390		p = 1;
391		x_p[0] = 1;
392		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
	391	q = 1;
	392	x_q[0] = 1;
	393	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
393	394	check = 1.;
394		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	395	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
395	396
396	397	// check second order forward mode
397		p = 2;
398		x_p[0] = 0;
399		y_p = f.<a href="forward.xml" target="_top">Forward</a>(p, x_p);
	398	q = 2;
	399	x_q[0] = 0;
	400	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
400	401	check = 0.;
401		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_p[0] , check, eps, eps);
	402	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
402	403
403	404	// --------------------------------------------------------------------
404	405	// Check reverse mode results
405	406	//
406	407	// third order reverse mode
407		p = 3;
408		vector<double> w(m), dw(n * p);
	408	q = 3;
	409	vector<double> w(m), dw(n * q);
409	410	w[0] = 1.;
410		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(p, w);
	411	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(q, w);
411	412	check = 1.;
412	413	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0] , check, eps, eps);
413	414	check = 0.;

416	417
417	418	// --------------------------------------------------------------------
418	419	// forward mode sparstiy pattern
419		size_t q = n;
420		CppAD::vectorBool r1(n * q), s1(m * q);
	420	size_t p = n;
	421	CppAD::vectorBool r1(n * p), s1(m * p);
421	422	r1[0] = true; // compute sparsity pattern for x[0]
422		s1 = f.ForSparseJac(q, r1);
	423	s1 = f.ForSparseJac(p, r1);
423	424	ok &= s1[0] == true; // f[0] depends on x[0]
424	425
425	426	// --------------------------------------------------------------------
426	427	// reverse mode sparstiy pattern
427		p = m;
428		CppAD::vectorBool s2(p * m), r2(p * n);
	428	q = m;
	429	CppAD::vectorBool s2(q * m), r2(q * n);
429	430	s2[0] = true; // compute sparsity pattern for f[0]
430		r2 = f.RevSparseJac(p, s2);
	431	r2 = f.RevSparseJac(q, s2);
431	432	ok &= r2[0] == true; // f[0] depends on x[0]
432	433
433	434	// --------------------------------------------------------------------
434	435	// Hessian sparsity (using previous ForSparseJac call)
435		CppAD::vectorBool s3(m), h(q * n);
	436	CppAD::vectorBool s3(m), h(p * n);
436	437	s3[0] = true; // compute sparsity pattern for f[0]
437		h = f.RevSparseJac(q, s3);
	438	h = f.RevSparseJac(p, s3);
438	439	ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
439	440
440	441	// -----------------------------------------------------------------

+66

-65

doc/old_usead_2.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Using AD to Compute Atomic Function Derivatives</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using AD to Compute Atomic Function Derivatives"/>
7		<meta name="keywords" id="keywords" content=" Ad inside atomic user checkpoint "/>
	8	<meta name="keywords" id="keywords" content=" using ad to compute atomic function derivatives Ad inside user checkpoint deprecated purpose "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

204	205	}
205	206	// make sure r_ has proper lower order Taylor coefficients stored
206	207	// then compute ty[k]
207		for(size_t p = 0; p <= k; p++)
	208	for(size_t q = 0; q <= k; q++)
208	209	{ for(j = 0; j < n; j++)
209		xp[j] = tx[j * (k+1) + p];
210		yp = r_ptr_->Forward(p, xp);
211		if( p == k )
	210	xp[j] = tx[j * (k+1) + q];
	211	yp = r_ptr_->Forward(q, xp);
	212	if( q == k )
212	213	{ for(i = 0; i < m; i++)
213		ty[i * (k+1) + p] = yp[i];
	214	ty[i * (k+1) + q] = yp[i];
214	215	}
215	216	# ifndef NDEBUG
216	217	else
217	218	{ for(i = 0; i < m; i++)
218		assert( ty[i * (k+1) + p] == yp[i] );
	219	assert( ty[i * (k+1) + q] == yp[i] );
219	220	}
220	221	# endif
221	222	}
222	223	// no longer need the Taylor coefficients in r_ptr_
223	224	// (have to reconstruct them every time)
224		r_ptr_->capacity_taylor(0);
	225	r_ptr_->capacity_order(0);
225	226	return ok;
226	227	}
227	228	// ----------------------------------------------------------------------

243	244	vector<double> xp(n), w( (k+1) * m ), dw( (k+1) * n );
244	245
245	246	// make sure r_ has proper forward mode coefficients
246		size_t i, j, p;
247		for(p = 0; p <= k; p++)
	247	size_t i, j, q;
	248	for(q = 0; q <= k; q++)
248	249	{ for(j = 0; j < n; j++)
249		xp[j] = tx[j * (k+1) + p];
	250	xp[j] = tx[j * (k+1) + q];
250	251	# ifdef NDEBUG
251		r_ptr_->Forward(p, xp);
	252	r_ptr_->Forward(q, xp);
252	253	# else
253	254	vector<double> yp(m);
254		yp = r_ptr_->Forward(p, xp);
	255	yp = r_ptr_->Forward(q, xp);
255	256	for(i = 0; i < m; i++)
256		assert( ty[i * (k+1) + p] == yp[i] );
	257	assert( ty[i * (k+1) + q] == yp[i] );
257	258	# endif
258	259	}
259	260	for(i = 0; i < m; i++)
260		{ for(p = 0; p <=k; p++)
261		w[ i * (k+1) + p] = py[ i * (k+1) + p];
	261	{ for(q = 0; q <=k; q++)
	262	w[ i * (k+1) + q] = py[ i * (k+1) + q];
262	263	}
263	264	dw = r_ptr_->Reverse(k+1, w);
264	265	for(j = 0; j < n; j++)
265		{ for(p = 0; p <=k; p++)
266		px[ j * (k+1) + p] = dw[ j * (k+1) + p];
	266	{ for(q = 0; q <=k; q++)
	267	px[ j * (k+1) + q] = dw[ j * (k+1) + q];
267	268	}
268	269	// no longer need the Taylor coefficients in r_ptr_
269	270	// (have to reconstruct them every time)
270		r_ptr_->capacity_taylor(0);
	271	r_ptr_->capacity_order(0);
271	272
272	273	return ok;
273	274	}

277	278	size_t id ,
278	279	size_t n ,
279	280	size_t m ,
280		size_t q ,
	281	size_t p ,
281	282	const vector< std::set<size_t> >& r ,
282	283	vector< std::set<size_t> >& s )
283	284	{ assert( id == 0 );

288	289	vector< std::set<size_t> > R(n), S(m);
289	290	for(size_t j = 0; j < n; j++)
290	291	R[j] = r[j];
291		S = r_ptr_->ForSparseJac(q, R);
	292	S = r_ptr_->ForSparseJac(p, R);
292	293	for(size_t i = 0; i < m; i++)
293	294	s[i] = S[i];
294	295

304	305	size_t id ,
305	306	size_t n ,
306	307	size_t m ,
307		size_t q ,
	308	size_t p ,
308	309	vector< std::set<size_t> >& r ,
309	310	const vector< std::set<size_t> >& s )
310	311	{

313	314	assert( m == 2 );
314	315	bool ok = true;
315	316
316		vector< std::set<size_t> > R(q), S(q);
	317	vector< std::set<size_t> > R(p), S(p);
317	318	std::set<size_t>::const_iterator itr;
318	319	size_t i;
319	320	// untranspose s

321	322	{ for(itr = s[i].begin(); itr != s[i].end(); itr++)
322	323	S[*itr].insert(i);
323	324	}
324		R = r_ptr_->RevSparseJac(q, S);
	325	R = r_ptr_->RevSparseJac(p, S);
325	326	// transpose r
326	327	for(i = 0; i < m; i++)
327	328	r[i].clear();
328		for(i = 0; i < q; i++)
	329	for(i = 0; i < p; i++)
329	330	{ for(itr = R[i].begin(); itr != R[i].end(); itr++)
330	331	r[*itr].insert(i);
331	332	}

337	338	size_t id ,
338	339	size_t n ,
339	340	size_t m ,
340		size_t q ,
	341	size_t p ,
341	342	const vector< std::set<size_t> >& r ,
342	343	const vector<bool>& s ,
343	344	vector<bool>& t ,

360	361	t = r_ptr_->RevSparseJac(1, s);
361	362
362	363	// compute sparsity pattern for A(x)^T = U(x)^T * f'(x)
363		vector< std::set<size_t> > Ut(q), At(q);
	364	vector< std::set<size_t> > Ut(p), At(p);
364	365	for(i = 0; i < m; i++)
365	366	{ for(itr = u[i].begin(); itr != u[i].end(); itr++)
366	367	Ut[*itr].insert(i);
367	368	}
368		At = r_ptr_->RevSparseJac(q, Ut);
	369	At = r_ptr_->RevSparseJac(p, Ut);
369	370
370	371	// compute sparsity pattern for H(x)^T = R^T * (S * F)''(x)
371		vector< std::set<size_t> > R(n), Ht(q);
	372	vector< std::set<size_t> > R(n), Ht(p);
372	373	for(j = 0; j < n; j++)
373	374	R[j] = r[j];
374		r_ptr_->ForSparseJac(q, R);
375		Ht = r_ptr_->RevSparseHes(q, S);
	375	r_ptr_->ForSparseJac(p, R);
	376	Ht = r_ptr_->RevSparseHes(p, S);
376	377
377	378	// compute sparsity pattern for V(x) = A(x) + H(x)^T
378	379	for(j = 0; j < n; j++)
379	380	v[j].clear();
380		for(i = 0; i < q; i++)
	381	for(i = 0; i < p; i++)
381	382	{ for(itr = At[i].begin(); itr != At[i].end(); itr++)
382	383	v[*itr].insert(i);
383	384	for(itr = Ht[i].begin(); itr != Ht[i].end(); itr++)

445	446	//
446	447	// zero order forward
447	448	vector<double> up(n), yp(m);
448		size_t p = 0;
	449	size_t q = 0;
449	450	double u0 = 0.5;
450	451	double u1 = 0.25;
451	452	double u2 = 0.75;

453	454	up[0] = u0;
454	455	up[1] = u1;
455	456	up[2] = u2;
456		yp = f.<a href="forward.xml" target="_top">Forward</a>(p, up);
	457	yp = f.<a href="forward.xml" target="_top">Forward</a>(q, up);
457	458	check = u0 + u2;
458	459	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( yp[0], check, eps, eps);
459	460	check = u1 + u0 * u2 + u2 * u2 / 2.0;
460	461	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( yp[1], check, eps, eps);
461	462	//
462	463	// forward mode first derivative w.r.t t
463		p = 1;
	464	q = 1;
464	465	up[0] = 0.0;
465	466	up[1] = 0.0;
466	467	up[2] = 1.0;
467		yp = f.<a href="forward.xml" target="_top">Forward</a>(p, up);
	468	yp = f.<a href="forward.xml" target="_top">Forward</a>(q, up);
468	469	check = 1.0;
469	470	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( yp[0], check, eps, eps);
470	471	check = u0 + u2;
471	472	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( yp[1], check, eps, eps);
472	473	//
473	474	// forward mode second order Taylor coefficient w.r.t t
474		p = 2;
	475	q = 2;
475	476	up[0] = 0.0;
476	477	up[1] = 0.0;
477	478	up[2] = 0.0;
478		yp = f.<a href="forward.xml" target="_top">Forward</a>(p, up);
	479	yp = f.<a href="forward.xml" target="_top">Forward</a>(q, up);
479	480	check = 0.0;
480	481	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( yp[0], check, eps, eps);
481	482	check = 1.0 / 2.0;
482	483	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( yp[1], check, eps, eps);
483	484	// --------------------------------------------------------------------
484	485	// reverse mode derivatives of \partial_t y_1 (t)
485		vector<double> w(m * p), dw(n * p);
486		w[0 * p + 0] = 0.0;
487		w[1 * p + 0] = 0.0;
488		w[0 * p + 1] = 0.0;
489		w[1 * p + 1] = 1.0;
490		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(p, w);
	486	vector<double> w(m * q), dw(n * q);
	487	w[0 * q + 0] = 0.0;
	488	w[1 * q + 0] = 0.0;
	489	w[0 * q + 1] = 0.0;
	490	w[1 * q + 1] = 1.0;
	491	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(q, w);
491	492	// derivative of y_1(u) = u_1 + u_0 * u_2 + u_2^2 / 2, w.r.t. u
492	493	// is equal deritative of \partial_u2 y_1(u) w.r.t \partial_u2 u
493	494	check = u2;
494		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[0 * p + 1], check, eps, eps);
	495	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[0 * q + 1], check, eps, eps);
495	496	check = 1.0;
496		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[1 * p + 1], check, eps, eps);
	497	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[1 * q + 1], check, eps, eps);
497	498	check = u0 + u2;
498		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[2 * p + 1], check, eps, eps);
	499	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[2 * q + 1], check, eps, eps);
499	500	// derivative of \partial_t y_1 w.r.t u = u_0 + t, w.r.t u
500	501	check = 1.0;
501		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[0 * p + 0], check, eps, eps);
	502	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[0 * q + 0], check, eps, eps);
502	503	check = 0.0;
503		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[1 * p + 0], check, eps, eps);
	504	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[1 * q + 0], check, eps, eps);
504	505	check = 1.0;
505		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[2 * p + 0], check, eps, eps);
	506	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( dw[2 * q + 0], check, eps, eps);
506	507	// --------------------------------------------------------------------
507	508	// forward mode sparsity pattern for the Jacobian
508	509	// f_u = [ 1, 0, 1 ]
509	510	// [ u_2, 1, u_2 ]
510		size_t i, j, q = n;
511		CppAD::vectorBool r(n * q), s(m * q);
	511	size_t i, j, p = n;
	512	CppAD::vectorBool r(n * p), s(m * p);
512	513	// r = identity sparsity pattern
513	514	for(i = 0; i < n; i++)
514		for(j = 0; j < q; j++)
	515	for(j = 0; j < p; j++)
515	516	r[i*n +j] = (i == j);
516		s = f.ForSparseJac(q, r);
517		ok &= s[ 0 * q + 0] == true;
518		ok &= s[ 0 * q + 1] == false;
519		ok &= s[ 0 * q + 2] == true;
520		ok &= s[ 1 * q + 0] == true;
521		ok &= s[ 1 * q + 1] == true;
522		ok &= s[ 1 * q + 2] == true;
	517	s = f.ForSparseJac(p, r);
	518	ok &= s[ 0 * p + 0] == true;
	519	ok &= s[ 0 * p + 1] == false;
	520	ok &= s[ 0 * p + 2] == true;
	521	ok &= s[ 1 * p + 0] == true;
	522	ok &= s[ 1 * p + 1] == true;
	523	ok &= s[ 1 * p + 2] == true;
523	524	// --------------------------------------------------------------------
524	525	// reverse mode sparsity pattern for the Jacobian
525		p = m;
526		s.resize(p * m);
527		r.resize(p * n);
	526	q = m;
	527	s.resize(q * m);
	528	r.resize(q * n);
528	529	// s = identity sparsity pattern
529		for(i = 0; i < p; i++)
	530	for(i = 0; i < q; i++)
530	531	for(j = 0; j < m; j++)
531	532	s[i*m +j] = (i == j);
532		r = f.RevSparseJac(p, s);
	533	r = f.RevSparseJac(q, s);
533	534	ok &= r[ 0 * n + 0] == true;
534	535	ok &= r[ 0 * n + 1] == false;
535	536	ok &= r[ 0 * n + 2] == true;

-1

doc/omp_alloc.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>OpenMP Memory Allocator: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="OpenMP Memory Allocator: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" openmp memory allocation multi-thread example test "/>
	8	<meta name="keywords" id="keywords" content=" openmp memory allocator: example and test allocation multi-thread deprecated "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_alloc.xml less more

3	3	>
4	4	<head>
5	5	<title>A Quick OpenMP Memory Allocator Used by CppAD</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Quick OpenMP Memory Allocator Used by CppAD"/>
7		<meta name="keywords" id="keywords" content=" multi-threading memory allocation openmp "/>
	8	<meta name="keywords" id="keywords" content=" a quick openmp memory allocator used by cppad multi-threading allocation syntax purpose include "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_available.xml less more

3	3	>
4	4	<head>
5	5	<title>Amount of Memory Available for Quick Use by a Thread</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Amount of Memory Available for Quick Use by a Thread"/>
7		<meta name="keywords" id="keywords" content=" available omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" amount of memory available for quick use by a thread deprecated omp_alloc syntax purpose num_bytes example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_create_array.xml less more

3	3	>
4	4	<head>
5	5	<title>Allocate Memory and Create A Raw Array</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Allocate Memory and Create A Raw Array"/>
7		<meta name="keywords" id="keywords" content=" create_array omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" allocate memory and create a raw array deprecated create_array omp_alloc syntax purpose type size_min size_out delta example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_delete_array.xml less more

3	3	>
4	4	<head>
5	5	<title>Return A Raw Array to The Available Memory for a Thread</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Return A Raw Array to The Available Memory for a Thread"/>
7		<meta name="keywords" id="keywords" content=" delete_array omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" return a raw array to the available memory for thread deprecated delete_array omp_alloc syntax purpose type delta example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_efficient.xml less more

3	3	>
4	4	<head>
5	5	<title>Check If A Memory Allocation is Efficient for Another Use</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Check If A Memory Allocation is Efficient for Another Use"/>
7		<meta name="keywords" id="keywords" content=" efficient omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" check if a memory allocation is efficient for another use removed omp_alloc syntax purpose v_ptr num_bytes flag thread ndebug "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_free_available.xml less more

3	3	>
4	4	<head>
5	5	<title>Free Memory Currently Available for Quick Use by a Thread</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Free Memory Currently Available for Quick Use by a Thread"/>
7		<meta name="keywords" id="keywords" content=" free_available omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" free memory currently available for quick use by a thread deprecated free_available omp_alloc syntax purpose example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_get_memory.xml less more

3	3	>
4	4	<head>
5	5	<title>Get At Least A Specified Amount of Memory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Get At Least A Specified Amount of Memory"/>
7		<meta name="keywords" id="keywords" content=" get_thread_num omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" get at least a specified amount of memory deprecated get_thread_num omp_alloc syntax purpose min_bytes cap_bytes v_ptr allocation speed example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_get_thread_num.xml less more

3	3	>
4	4	<head>
5	5	<title>Get the Current OpenMP Thread Number</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Get the Current OpenMP Thread Number"/>
7		<meta name="keywords" id="keywords" content=" get_thread_num omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" get the current openmp thread number deprecated get_thread_num omp_alloc syntax purpose example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_in_parallel.xml less more

3	3	>
4	4	<head>
5	5	<title>Is The Current Execution in OpenMP Parallel Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Is The Current Execution in OpenMP Parallel Mode"/>
7		<meta name="keywords" id="keywords" content=" in_parallel omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" is the current execution in openmp parallel mode deprecated in_parallel omp_alloc syntax purpose flag example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_inuse.xml less more

3	3	>
4	4	<head>
5	5	<title>Amount of Memory a Thread is Currently Using</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Amount of Memory a Thread is Currently Using"/>
7		<meta name="keywords" id="keywords" content=" inuse omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" amount of memory a thread is currently using deprecated inuse omp_alloc syntax purpose num_bytes example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_max_num_threads.xml less more

3	3	>
4	4	<head>
5	5	<title>Set and Get Maximum Number of Threads for omp_alloc Allocator</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Set and Get Maximum Number of Threads for omp_alloc Allocator"/>
7		<meta name="keywords" id="keywords" content=" set_max_num_threads omp_alloc get_max_num_threads "/>
	8	<meta name="keywords" id="keywords" content=" set and get maximum number of threads for omp_alloc allocator deprecated set_max_num_threads get_max_num_threads syntax purpose restrictions "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/omp_max_thread.xml less more

3	3	>
4	4	<head>
5	5	<title>OpenMP Parallel Setup</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="OpenMP Parallel Setup"/>
7		<meta name="keywords" id="keywords" content=" depreciated omp_max_thread "/>
	8	<meta name="keywords" id="keywords" content=" openmp parallel setup deprecated depreciated omp_max_thread syntax purpose number independent restriction "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

100	101	</select>
101	102	</td>
102	103	</tr></table><br/>
	104
	105
	106
103	107	<center><b><big><big>OpenMP Parallel Setup</big></big></b></center>
104	108	<br/>
105	109	<b><big><a name="Deprecated" id="Deprecated">Deprecated</a></big></b>

-1

doc/omp_return_memory.xml less more

3	3	>
4	4	<head>
5	5	<title>Return Memory to omp_alloc</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Return Memory to omp_alloc"/>
7		<meta name="keywords" id="keywords" content=" return_memory omp_alloc "/>
	8	<meta name="keywords" id="keywords" content=" return memory to omp_alloc deprecated return_memory syntax purpose v_ptr thread ndebug example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/opt_val_hes.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>opt_val_hes: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="opt_val_hes: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" opt_val_hes example test "/>
	8	<meta name="keywords" id="keywords" content=" opt_val_hes: example and test opt_val_hes "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/opt_val_hes.xml less more

3	3	>
4	4	<head>
5	5	<title>Jacobian and Hessian of Optimal Values</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Jacobian and Hessian of Optimal Values"/>
7		<meta name="keywords" id="keywords" content=" Jacobian Hessian optimal value opt_val_hes "/>
	8	<meta name="keywords" id="keywords" content=" Jacobian Hessian optimal value opt_val_hes jacobian and hessian of values syntax see also reference purpose basevector x y fun fun::ad_vector fun.ell fun.s fun.sy jac hes signdet example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/optimize.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ADFun Operation Sequence Optimization: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ADFun Operation Sequence Optimization: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" optimize operation sequence test example "/>
	8	<meta name="keywords" id="keywords" content=" adfun operation sequence optimization: example and test optimize "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-5

doc/optimize.xml less more

3	3	>
4	4	<head>
5	5	<title>Optimize an ADFun Object Tape</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Optimize an ADFun Object Tape"/>
7		<meta name="keywords" id="keywords" content=" optimize tape sequence operations speed memory Ndebug "/>
	8	<meta name="keywords" id="keywords" content=" optimize an adfun object tape sequence operations speed memory syntax purpose f improvements testing efficiency comparison operators atomic functions rev_sparse_jac nan checking optimization Ndebug example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

152	153	You can run the CppAD <a href="speed_main.xml" target="_top"><span style='white-space: nowrap'>speed</span></a>
153	154	tests and see
154	155	the corresponding changes in number of variables and execution time;
155		see <a href="cppad_test.xml" target="_top"><span style='white-space: nowrap'>cppad_test</span></a>
	156	see <a href="cmake_check.xml" target="_top"><span style='white-space: nowrap'>cmake_check</span></a>
156	157	.
157	158
158	159	<br/>

163	164	may greatly reduce the number of variables
164	165	in the operation sequence; see <a href="seq_property.xml#size_var" target="_top"><span style='white-space: nowrap'>size_var</span></a>
165	166	.
166		If a <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>zero order forward</span></a>
	167	If a <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>zero order forward</span></a>
167	168	calculation is done during
168	169	the construction of
169	170	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>

255	256	<br/>
256	257	If <a href="faq.xml#Speed.NDEBUG" target="_top"><span style='white-space: nowrap'>NDEBUG</span></a>
257	258	is not defined,
258		and <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>f.size_taylor()</span></a>
	259	and <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>f.size_order()</span></a>
259	260	is greater than zero,
260		a <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>ForwardZero</span></a>
	261	a <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
261	262	calculation is done using the optimized version
262	263	of
263	264	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>

-1

doc/par_var.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Parameter and Variable Functions: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Parameter and Variable Functions: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Parameter example Variable test "/>
	8	<meta name="keywords" id="keywords" content=" ad parameter and variable functions: example test Parameter Variable "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/parallel_ad.xml less more

3	3	>
4	4	<head>
5	5	<title>Enable AD Calculations During Parallel Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Enable AD Calculations During Parallel Mode"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" enable ad calculations during parallel mode syntax purpose discussion checksimplevector example restriction "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/parvar.xml less more

3	3	>
4	4	<head>
5	5	<title>Is an AD Object a Parameter or Variable</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Is an AD Object a Parameter or Variable"/>
7		<meta name="keywords" id="keywords" content=" Parameter Variable "/>
	8	<meta name="keywords" id="keywords" content=" Parameter Variable is an ad object a parameter or variable syntax purpose x b operation sequence example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-4

doc/pkgconfig.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD pkg-config Files</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD pkg-config Files"/>
7		<meta name="keywords" id="keywords" content=" pkg-config files pc "/>
	8	<meta name="keywords" id="keywords" content=" cppad pkg-config files pc purpose usage defined fields configuration "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="cppad_test.xml" target="_top">Prev</a>
	24	<td><a href="cmake_check.xml" target="_top">Prev</a>
24	25	</td><td><a href="installunix.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

61	62	<option>Install-></option>
62	63	<option>download</option>
63	64	<option>cmake</option>
64		<option>cppad_test</option>
	65	<option>cmake_check</option>
65	66	<option>pkgconfig</option>
66	67	<option>InstallUnix</option>
67	68	</select>

210	211	<code><i><font color="black"><span style='white-space: nowrap'>prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>/</span></font><i><font color="black"><span style='white-space: nowrap'>datadir</span></font></i><font color="blue"><span style='white-space: nowrap'>/pkgconfig/cppad.pc</span></font></code>
211	212	</td><td align='left' valign='top'>
212	213
213		for use after <a href="install.xml#Instructions.Install" target="_top"><span style='white-space: nowrap'>make install</span></a>
	214	for use after <a href="install.xml#Instructions.Step 4: Install" target="_top"><span style='white-space: nowrap'>make install</span></a>
214	215
215	216	</td></tr><tr><td align='left' valign='top'>
216	217

-1

doc/poly.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Polynomial Evaluation: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Polynomial Evaluation: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" polynomial example test "/>
	8	<meta name="keywords" id="keywords" content=" polynomial evaluation: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/poly.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: Poly</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: Poly"/>
7		<meta name="keywords" id="keywords" content=" Poly source "/>
	8	<meta name="keywords" id="keywords" content=" source: poly Poly source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-3

doc/poly.xml less more

3	3	>
4	4	<head>
5	5	<title>Evaluate a Polynomial or its Derivative</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Evaluate a Polynomial or its Derivative"/>
7		<meta name="keywords" id="keywords" content=" Poly polynomial derivative template "/>
	8	<meta name="keywords" id="keywords" content=" Poly polynomial derivative template evaluate a or its syntax description include k z p type operations vector operation sequence example source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

137	138	<br/>
138	139	<b><big><a name="Description" id="Description">Description</a></big></b>
139	140	<br/>
140		Computes the <i>k</i>-th derivative of the polynomial
	141	Computes the <code><i>k</i></code>-th derivative of the polynomial
141	142
142	143	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
143	144	<mi mathvariant='italic'>P</mi>

253	254	</span></font></code>
254	255	(see <a href="poly.xml#Type" target="_top"><span style='white-space: nowrap'>Type</span></a>
255	256	below)
256		and it is equal to the <i>k</i>-th derivative of
	257	and it is equal to the <code><i>k</i></code>-th derivative of
257	258	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
258	259	<mi mathvariant='italic'>P</mi>
259	260	<mo stretchy="false">(</mo>

-1

doc/pow.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD Power Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD Power Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" pow Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad power function: example and test pow Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/pow.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD Power Function</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD Power Function"/>
7		<meta name="keywords" id="keywords" content=" pow Ad exponent function "/>
	8	<meta name="keywords" id="keywords" content=" pow Ad exponent function the ad power syntax see also purpose x y z operation sequence example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/pow_int.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The Pow Integer Exponent: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The Pow Integer Exponent: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" pow int example test "/>
	8	<meta name="keywords" id="keywords" content=" the pow integer exponent: example and test int "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/pow_int.xml less more

3	3	>
4	4	<head>
5	5	<title>The Integer Power Function</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The Integer Power Function"/>
7		<meta name="keywords" id="keywords" content=" pow integer exponent "/>
	8	<meta name="keywords" id="keywords" content=" pow integer exponent the power function syntax see also purpose include x y z type operation sequence example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/preprocessor.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD API Preprocessor Symbols</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD API Preprocessor Symbols"/>
7		<meta name="keywords" id="keywords" content=" preprocessor Cppad_ symbol Null pointer Cppad_null "/>
	8	<meta name="keywords" id="keywords" content=" cppad api preprocessor symbols Cppad_ symbol purpose documented here cppad_null Null pointer Cppad_null cppad_package_string elsewhere deprecated "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/print_for_cout.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Printing During Forward Mode: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Printing During Forward Mode: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" forward mode print example "/>
	8	<meta name="keywords" id="keywords" content=" printing during forward mode: example and test mode print running source code output "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

89	90	<br/>
90	91	<b><big><a name="Running" id="Running">Running</a></big></b>
91	92	<br/>
92		To build this program and run its correctness test see <a href="cppad_test.xml" target="_top"><span style='white-space: nowrap'>cppad_test</span></a>
	93	To build this program and run its correctness test see <a href="cmake_check.xml" target="_top"><span style='white-space: nowrap'>cmake_check</span></a>
93	94	.
94	95
95	96	<br/>

-1

doc/print_for_string.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Print During Zero Order Forward Mode: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Print During Zero Order Forward Mode: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" print zero order forward "/>
	8	<meta name="keywords" id="keywords" content=" print during zero order forward mode: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/printfor.xml less more

3	3	>
4	4	<head>
5	5	<title>Printing AD Values During Forward Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Printing AD Values During Forward Mode"/>
7		<meta name="keywords" id="keywords" content=" print forward mode text output debug "/>
	8	<meta name="keywords" id="keywords" content=" print forward mode text output debug printing ad values during syntax purpose f.forward(0 x) pos before var after discussion alternative example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

130	131	<br/>
131	132	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
132	133	<br/>
133		The <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>zero order forward</span></a>
	134	The <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>zero order forward</span></a>
134	135	mode command
135	136
136	137	<code><font color="blue"><span style='white-space: nowrap'><br/>

-1

doc/repeat_det_by_minor_c.xml less more

3	3	>
4	4	<head>
5	5	<title>Repeat det_by_minor Routine A Specified Number of Times</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Repeat det_by_minor Routine A Specified Number of Times"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" repeat det_by_minor routine a specified number of times syntax size source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/rev_one.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>First Order Derivative Driver: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="First Order Derivative Driver: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" derivative example test "/>
	8	<meta name="keywords" id="keywords" content=" first order derivative driver: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/rev_sparse_hes.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Reverse Mode Hessian Sparsity: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Reverse Mode Hessian Sparsity: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Revsparsehes example sparsity Hessian test "/>
	8	<meta name="keywords" id="keywords" content=" reverse mode hessian sparsity: example and test Revsparsehes sparsity Hessian "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/rev_sparse_jac.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Reverse Mode Jacobian Sparsity: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Reverse Mode Jacobian Sparsity: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Revsparsejac example sparsity reverse test "/>
	8	<meta name="keywords" id="keywords" content=" reverse mode jacobian sparsity: example and test Revsparsejac sparsity "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/rev_two.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Second Partials Reverse Driver: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Second Partials Reverse Driver: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" second partial example test "/>
	8	<meta name="keywords" id="keywords" content=" second partials reverse driver: example and test partial "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+20

-3

doc/reverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" reverse mode multiple directions "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="forward_mul.cpp.xml" target="_top">Prev</a>
	24	<td><a href="number_skip.cpp.xml" target="_top">Prev</a>
24	25	</td><td><a href="reverse_one.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

91	92	<td>
92	93	<select onchange='choose_current0(this)'>
93	94	<option>Headings-></option>
	95	<option>Multiple Directions</option>
94	96	<option>Contents</option>
95	97	</select>
96	98	</td>

100	102
101	103	<center><b><big><big>Reverse Mode</big></big></b></center>
102	104	<br/>
	105	<b><big><a name="Multiple Directions" id="Multiple Directions">Multiple Directions</a></big></b>
	106	<br/>
	107	Reverse mode after <a href="forward_dir.xml" target="_top"><span style='white-space: nowrap'>Forward(q, r, xq)</span></a>
	108
	109	with number of directions
	110	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'> != 1</span></font></code>
	111	is not yet supported.
	112	There is one exception, <a href="reverse_one.xml" target="_top"><span style='white-space: nowrap'>reverse_one</span></a>
	113	is allowed
	114	because there is only one zero order forward direction.
	115	After such an operation, only the zero order forward
	116	results are retained (the higher order forward results are lost).
	117
	118	<br/>
	119	<br/>
103	120	<b><big><a name="Contents" id="Contents">Contents</a></big></b>
104	121	<br/>
105	122	<table>
106	123	<tr><td><a href="reverse_one.xml" target="_top">reverse_one</a></td><td>First Order Reverse Mode</td></tr><tr><td><a href="reverse_two.xml" target="_top">reverse_two</a></td><td>Second Order Reverse Mode</td></tr><tr><td><a href="reverse_any.xml" target="_top">reverse_any</a></td><td>Any Order Reverse Mode</td></tr></table>
107		<hr/>Input File: cppad/local/reverse.hpp
	124	<hr/>Input File: omh/reverse/reverse.omh
108	125
109	126	</body>
110	127	</html>

-2

doc/reverse_any.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Reverse Mode General Case: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Reverse Mode General Case: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" reverse example test "/>
	8	<meta name="keywords" id="keywords" content=" reverse mode general case: example and test purpose processing steps "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

1050	1051	f = empty;
1051	1052	else
1052	1053	{ // free all the Taylor coefficients stored in f
1053		f.capacity_taylor(0);
	1054	f.capacity_order(0);
1054	1055	}
1055	1056
1056	1057	// record the function G(x)

+41

-40

doc/reverse_any.xml less more

3	3	>
4	4	<head>
5	5	<title>Any Order Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Any Order Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" reverse any order mode derivative "/>
	8	<meta name="keywords" id="keywords" content=" any order reverse mode derivative syntax purpose notation u^(k) x(t u) y(t w^(k) w(u) f q w dw first second vector example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

86	87	<option>Syntax</option>
87	88	<option>Purpose</option>
88	89	<option>Notation</option>
89		<option>---..x^(k)</option>
	90	<option>---..u^(k)</option>
90	91	<option>---..X(t, u)</option>
91	92	<option>---..Y(t, u)</option>
92	93	<option>---..w^(k)</option>
93	94	<option>---..W(u)</option>
94	95	<option>f</option>
95		<option>p</option>
	96	<option>q</option>
96	97	<option>w</option>
97	98	<option>dw</option>
98	99	<option>First Order</option>

111	112
112	113	<br/>
113	114
114		<code><i><font color="black"><span style='white-space: nowrap'>dw</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Reverse(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>w</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
	115	<code><i><font color="black"><span style='white-space: nowrap'>dw</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Reverse(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>w</span></font></i><font color="blue"><span style='white-space: nowrap'>)</span></font></code>
115	116
116	117
117	118

178	179
179	180	<br/>
180	181	<br/>
181		<b><a name="Notation.x^(k)" id="Notation.x^(k)">x^(k)</a></b>
	182	<b><a name="Notation.u^(k)" id="Notation.u^(k)">u^(k)</a></b>
182	183	<br/>
183	184	For
184	185	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

188	189	<mo stretchy="false">,</mo>
189	190	<mo stretchy="false">…</mo>
190	191	<mo stretchy="false">,</mo>
191		<mi mathvariant='italic'>p</mi>
	192	<mi mathvariant='italic'>q</mi>
192	193	<mn>-1</mn>
193	194	</mrow></math>
194	195
195	196	,
196	197	the vector
197	198	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
198		<msup><mi mathvariant='italic'>x</mi>
	199	<msup><mi mathvariant='italic'>u</mi>
199	200	<mrow><mo stretchy="false">(</mo>
200	201	<mi mathvariant='italic'>k</mi>
201	202	<mo stretchy="false">)</mo>

225	226	,
226	227
227	228	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
228		<msup><mi mathvariant='italic'>x</mi>
	229	<msup><mi mathvariant='italic'>u</mi>
229	230	<mrow><mo stretchy="false">(</mo>
230	231	<mn>0</mn>
231	232	<mo stretchy="false">)</mo>

256	257	<msup><mi mathvariant='italic'>B</mi>
257	258	<mrow><mi mathvariant='italic'>n</mi>
258	259	<mo stretchy="false">×</mo>
259		<mi mathvariant='italic'>p</mi>
	260	<mi mathvariant='italic'>q</mi>
260	261	</mrow>
261	262	</msup>
262	263	<mo stretchy="false">→</mo>

295	296	<mo stretchy="false">+</mo>
296	297	<msup><mi mathvariant='italic'>u</mi>
297	298	<mrow><mo stretchy="false">(</mo>
298		<mi mathvariant='italic'>p</mi>
	299	<mi mathvariant='italic'>q</mi>
299	300	<mn>-1</mn>
300	301	<mo stretchy="false">)</mo>
301	302	</mrow>
302	303	</msup>
303	304	<mo stretchy="false">*</mo>
304	305	<msup><mi mathvariant='italic'>t</mi>
305		<mrow><mi mathvariant='italic'>p</mi>
	306	<mrow><mi mathvariant='italic'>q</mi>
306	307	<mn>-1</mn>
307	308	</mrow>
308	309	</msup>

316	317	<mo stretchy="false">,</mo>
317	318	<mo stretchy="false">…</mo>
318	319	<mo stretchy="false">,</mo>
319		<mi mathvariant='italic'>p</mi>
	320	<mi mathvariant='italic'>q</mi>
320	321	<mn>-1</mn>
321	322	</mrow></math>
322	323

331	332	</msup>
332	333	</mrow></math>
333	334
334		is related to the <i>k</i>-th partial of
	335	is related to the <code><i>k</i></code>-th partial of
335	336	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
336	337	<mi mathvariant='italic'>X</mi>
337	338	<mo stretchy="false">(</mo>

397	398	<msup><mi mathvariant='italic'>B</mi>
398	399	<mrow><mi mathvariant='italic'>n</mi>
399	400	<mo stretchy="false">×</mo>
400		<mi mathvariant='italic'>p</mi>
	401	<mi mathvariant='italic'>q</mi>
401	402	</mrow>
402	403	</msup>
403	404	<mo stretchy="false">→</mo>

433	434	If the argument
434	435	<code><i><font color="black"><span style='white-space: nowrap'>w</span></font></i></code>
435	436	has size
436		<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
	437	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
437	438	,
438	439	for
439	440	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

443	444	<mo stretchy="false">,</mo>
444	445	<mo stretchy="false">…</mo>
445	446	<mo stretchy="false">,</mo>
446		<mi mathvariant='italic'>p</mi>
	447	<mi mathvariant='italic'>q</mi>
447	448	<mn>-1</mn>
448	449	</mrow></math>
449	450

474	475	<mo stretchy="false">[</mo>
475	476	<mi mathvariant='italic'>i</mi>
476	477	<mo stretchy="false">*</mo>
477		<mi mathvariant='italic'>p</mi>
	478	<mi mathvariant='italic'>q</mi>
478	479	<mo stretchy="false">+</mo>
479	480	<mi mathvariant='italic'>k</mi>
480	481	<mo stretchy="false">]</mo>

493	494	<mo stretchy="false">,</mo>
494	495	<mo stretchy="false">…</mo>
495	496	<mo stretchy="false">,</mo>
496		<mi mathvariant='italic'>p</mi>
	497	<mi mathvariant='italic'>q</mi>
497	498	<mn>-1</mn>
498	499	</mrow></math>
499	500

531	532	<mspace width='.3em'/>
532	533	<mi mathvariant='italic'>k</mi>
533	534	<mo stretchy="false">=</mo>
534		<mi mathvariant='italic'>p</mi>
	535	<mi mathvariant='italic'>q</mi>
535	536	<mn>-1</mn>
536	537	</mtd></mtr><mtr><mtd columnalign="left" >
537	538	<mn>0</mn>

552	553	<msup><mi mathvariant='italic'>B</mi>
553	554	<mrow><mi mathvariant='italic'>n</mi>
554	555	<mo stretchy="false">×</mo>
555		<mi mathvariant='italic'>p</mi>
	556	<mi mathvariant='italic'>q</mi>
556	557	</mrow>
557	558	</msup>
558	559	<mo stretchy="false">→</mo>

572	573	<mo stretchy="false">=</mo>
573	574	<mn>0</mn>
574	575	</mrow>
575		<mrow><mi mathvariant='italic'>p</mi>
	576	<mrow><mi mathvariant='italic'>q</mi>
576	577	<mn>-1</mn>
577	578	</mrow>
578	579	</munderover>

627	628	Before this call to <code><font color="blue">Reverse</font></code>, the value returned by
628	629
629	630	<code><font color="blue"><span style='white-space: nowrap'><br/>
630		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()<br/>
	631	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()<br/>
631	632	</span></font></code>
632	633	must be greater than or equal
633		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
634
635		(see <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	634	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
	635
	636	(see <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
636	637	).
637	638
638	639	<br/>
639	640	<br/>
640		<b><big><a name="p" id="p">p</a></big></b>
	641	<b><big><a name="q" id="q">q</a></big></b>
641	642	<br/>
642	643	The argument
643		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
	644	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
644	645	has prototype
645	646
646	647	<code><font color="blue"><span style='white-space: nowrap'><br/>
647		size_t </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	648	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
648	649	</span></font></code>
649		and specifies the number of Taylor coefficients to be differentiated
	650	and specifies the number of Taylor coefficient orders to be differentiated
650	651	(for each variable).
651	652
652	653

667	668	must be equal to
668	669	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
669	670	or
670		<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
	671	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
671	672	,
672	673	It specifies the weighting vector
673	674	<code><i><font color="black"><span style='white-space: nowrap'>w</span></font></i></code>

694	695	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
695	696	<mi mathvariant='italic'>n</mi>
696	697	<mo stretchy="false">×</mo>
697		<mi mathvariant='italic'>p</mi>
	698	<mi mathvariant='italic'>q</mi>
698	699	</mrow></math>
699	700
700	701	.

718	719	<mo stretchy="false">,</mo>
719	720	<mo stretchy="false">…</mo>
720	721	<mo stretchy="false">,</mo>
721		<mi mathvariant='italic'>p</mi>
	722	<mi mathvariant='italic'>q</mi>
722	723	<mn>-1</mn>
723	724	</mrow></math>
724	725

726	727	If the argument
727	728	<code><i><font color="black"><span style='white-space: nowrap'>w</span></font></i></code>
728	729	has size
729		<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
	730	<code><i><font color="black"><span style='white-space: nowrap'>m</span></font></i><font color="blue"><span style='white-space: nowrap'> * </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
730	731	,
731	732
732	733	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>

734	735	<mo stretchy="false">[</mo>
735	736	<mi mathvariant='italic'>j</mi>
736	737	<mo stretchy="false">*</mo>
737		<mi mathvariant='italic'>p</mi>
	738	<mi mathvariant='italic'>q</mi>
738	739	<mo stretchy="false">+</mo>
739	740	<mi mathvariant='italic'>k</mi>
740	741	<mo stretchy="false">]</mo>

777	778	<mo stretchy="false">[</mo>
778	779	<mi mathvariant='italic'>j</mi>
779	780	<mo stretchy="false">*</mo>
780		<mi mathvariant='italic'>p</mi>
781		<mo stretchy="false">+</mo>
782		<mi mathvariant='italic'>p</mi>
	781	<mi mathvariant='italic'>q</mi>
	782	<mo stretchy="false">+</mo>
	783	<mi mathvariant='italic'>q</mi>
783	784	<mo stretchy="false">-</mo>
784	785	<mi mathvariant='italic'>k</mi>
785	786	<mo stretchy="false">-</mo>

821	822	<br/>
822	823	We consider the case where
823	824
824		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> = 1</span></font></code>
	825	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> = 1</span></font></code>
825	826	and
826	827	<code><i><font color="black"><span style='white-space: nowrap'>w</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
827	828	.

965	966	<br/>
966	967	We consider the case where
967	968
968		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> = 2</span></font></code>
	969	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'> = 2</span></font></code>
969	970	and
970	971	<code><i><font color="black"><span style='white-space: nowrap'>w</span></font></i><font color="blue"><span style='white-space: nowrap'>.size() == </span></font><i><font color="black"><span style='white-space: nowrap'>m</span></font></i></code>
971	972	.

1326	1327
1327	1328
1328	1329
1329		<hr/>Input File: omh/reverse.omh
	1330	<hr/>Input File: omh/reverse/reverse_any.omh
1330	1331
1331	1332	</body>
1332	1333	</html>

-6

doc/reverse_identity.xml less more

3	3	>
4	4	<head>
5	5	<title>An Important Reverse Mode Identity</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="An Important Reverse Mode Identity"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" an important reverse mode identity notation sweep theorem proof "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="tan_reverse.xml" target="_top">Prev</a>
	24	<td><a href="erf_reverse.xml" target="_top">Prev</a>
24	25	</td><td><a href="glossary.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

400	401	</msup>
401	402	</mrow></math>
402	403
403		is the <i>j</i>-th column of
	404	is the <code><i>j</i></code>-th column of
404	405	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
405	406	<mi mathvariant='italic'>x</mi>
406	407	<mo stretchy="false">∈</mo>

722	723	</msup>
723	724	</mrow></math>
724	725
725		denotes the <i>j</i>-th column of
	726	denotes the <code><i>j</i></code>-th column of
726	727
727	728	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
728	729	<mi mathvariant='italic'>x</mi>

989	990	<mi mathvariant='italic'>i</mi>
990	991	</mrow></math>
991	992
992		, the <i>k</i>-th
	993	, the <code><i>k</i></code>-th
993	994	partial of
994	995	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
995	996	<msup><mi mathvariant='italic'>t</mi>

1421	1422	which completes the proof
1422	1423
1423	1424
1424		<hr/>Input File: omh/reverse_identity.omh
	1425	<hr/>Input File: omh/theory/reverse_identity.omh
1425	1426
1426	1427	</body>
1427	1428	</html>

-1

doc/reverse_one.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>First Order Reverse Mode: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="First Order Reverse Mode: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" reverse first order example test "/>
	8	<meta name="keywords" id="keywords" content=" first order reverse mode: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-7

doc/reverse_one.xml less more

3	3	>
4	4	<head>
5	5	<title>First Order Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="First Order Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" reverse first order mode derivative "/>
	8	<meta name="keywords" id="keywords" content=" first order reverse mode derivative syntax purpose f x w dw vector example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

236	237	<mi mathvariant='italic'>w</mi>
237	238	</mrow></math>
238	239
239		is the <i>i</i>-th
	240	is the <code><i>i</i></code>-th
240	241	<a href="glossary.xml#Elementary Vector" target="_top"><span style='white-space: nowrap'>elementary vector</span></a>
241	242	,
242	243

271	272	Before this call to <code><font color="blue">Reverse</font></code>, the value returned by
272	273
273	274	<code><font color="blue"><span style='white-space: nowrap'><br/>
274		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()<br/>
275		</span></font></code>
276		must be greater than or equal one (see <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	275	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()<br/>
	276	</span></font></code>
	277	must be greater than or equal one (see <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
277	278	).
278	279
279	280	<br/>

285	286	in expression for
286	287	<code><i><font color="black"><span style='white-space: nowrap'>dw</span></font></i></code>
287	288	above
288		corresponds to the previous call to <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>ForwardZero</span></a>
	289	corresponds to the previous call to <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
289	290
290	291	using this ADFun object
291	292	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>

391	392	It returns true if it succeeds and false otherwise.
392	393
393	394
394		<hr/>Input File: omh/reverse.omh
	395	<hr/>Input File: omh/reverse/reverse_one.omh
395	396
396	397	</body>
397	398	</html>

-1

doc/reverse_three.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Third Order Reverse Mode: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Third Order Reverse Mode: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" reverse third order example test "/>
	8	<meta name="keywords" id="keywords" content=" third order reverse mode: example and test taylor coefficients "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/reverse_two.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Second Order Reverse ModeExample and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Second Order Reverse ModeExample and Test"/>
7		<meta name="keywords" id="keywords" content=" reverse second order example test "/>
	8	<meta name="keywords" id="keywords" content=" second order reverse modeexample and test example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-7

doc/reverse_two.xml less more

3	3	>
4	4	<head>
5	5	<title>Second Order Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Second Order Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" reverse second order mode derivative "/>
	8	<meta name="keywords" id="keywords" content=" second order reverse mode derivative syntax purpose x^(k) w f dw first partials vector hessian times direction example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

493	494	Before this call to <code><font color="blue">Reverse</font></code>, the value returned by
494	495
495	496	<code><font color="blue"><span style='white-space: nowrap'><br/>
496		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()<br/>
	497	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()<br/>
497	498	</span></font></code>
498		must be greater than or equal two (see <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	499	must be greater than or equal two (see <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
499	500	).
500	501
501	502	<br/>

846	847	<mi mathvariant='italic'>w</mi>
847	848	</mrow></math>
848	849
849		is the <i>i</i>-th elementary vector.
	850	is the <code><i>i</i></code>-th elementary vector.
850	851	It follows that for
851	852	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
852	853	<mi mathvariant='italic'>j</mi>

967	968	<mo stretchy="false">[</mo>
968	969	<mi mathvariant='italic'>n</mi>
969	970	<mo stretchy="false">*</mo>
970		<mi mathvariant='italic'>p</mi>
	971	<mi mathvariant='italic'>q</mi>
971	972	<mo stretchy="false">-</mo>
972	973	<mn>1</mn>
973	974	<mo stretchy="false">]</mo>

1008	1009	</msup>
1009	1010	</mrow></math>
1010	1011
1011		is the <i>l</i>-th
	1012	is the <code><i>l</i></code>-th
1012	1013	<a href="glossary.xml#Elementary Vector" target="_top"><span style='white-space: nowrap'>elementary vector</span></a>
1013	1014	,
1014	1015

1062	1063	They return true if they succeed and false otherwise.
1063	1064
1064	1065
1065		<hr/>Input File: omh/reverse.omh
	1066	<hr/>Input File: omh/reverse/reverse_two.omh
1066	1067
1067	1068	</body>
1068	1069	</html>

+10

-8

doc/reversetheory.xml less more

3	3	>
4	4	<head>
5	5	<title>The Theory of Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The Theory of Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" the theory of reverse mode taylor notation binary operators addition subtraction multiplication division standard math functions "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="tan_forward.xml" target="_top">Prev</a>
	24	<td><a href="erf_forward.xml" target="_top">Prev</a>
24	25	</td><td><a href="expreverse.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

91	92	<option>AsinReverse</option>
92	93	<option>AcosReverse</option>
93	94	<option>tan_reverse</option>
	95	<option>erf_reverse</option>
94	96	</select>
95	97	</td>
96	98	<td>

138	140	, and
139	141	<code><i><font color="black"><span style='white-space: nowrap'>Z(t)</span></font></i></code>
140	142	are scalar valued functions
141		and the corresponding <i>p</i>-th order Taylor coefficients row vectors are
	143	and the corresponding <code><i>p</i></code>-th order Taylor coefficients row vectors are
142	144
143	145	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
144	146	<mi mathvariant='italic'>x</mi>

299	301	</mrow></math>
300	302
301	303	For the purposes of this discussion,
302		we are given the <i>p</i>-th order Taylor coefficient row vectors
	304	we are given the <code><i>p</i></code>-th order Taylor coefficient row vectors
303	305
304	306	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
305	307	<mi mathvariant='italic'>x</mi>

413	415	</mrow></math>
414	416
415	417	is expressed as a function of the
416		<i>j-1</i>-th order Taylor coefficient row
	418	<code><i>j-1</i></code>-th order Taylor coefficient row
417	419	vector for
418	420	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
419	421	<mi mathvariant='italic'>Z</mi>

1451	1453	</mrow></math>
1452	1454
1453	1455	is expressed as a function of the
1454		<i>j-1</i>-th order Taylor coefficient row
	1456	<code><i>j-1</i></code>-th order Taylor coefficient row
1455	1457	vector for
1456	1458	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
1457	1459	<mi mathvariant='italic'>Z</mi>

1508	1510	<b><big><a name="Contents" id="Contents">Contents</a></big></b>
1509	1511	<br/>
1510	1512	<table>
1511		<tr><td><a href="expreverse.xml" target="_top">ExpReverse</a></td><td>Exponential Function Reverse Mode Theory</td></tr><tr><td><a href="logreverse.xml" target="_top">LogReverse</a></td><td>Logarithm Function Reverse Mode Theory</td></tr><tr><td><a href="sqrtreverse.xml" target="_top">SqrtReverse</a></td><td>Square Root Function Reverse Mode Theory</td></tr><tr><td><a href="sincosreverse.xml" target="_top">SinCosReverse</a></td><td>Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</td></tr><tr><td><a href="atanreverse.xml" target="_top">AtanReverse</a></td><td>Arctangent Function Reverse Mode Theory</td></tr><tr><td><a href="asinreverse.xml" target="_top">AsinReverse</a></td><td>Arcsine Function Reverse Mode Theory</td></tr><tr><td><a href="acosreverse.xml" target="_top">AcosReverse</a></td><td>Arccosine Function Reverse Mode Theory</td></tr><tr><td><a href="tan_reverse.xml" target="_top">tan_reverse</a></td><td>Tangent and Hyperbolic Tangent Reverse Mode Theory</td></tr></table>
1512		<hr/>Input File: omh/reverse_theory.omh
	1513	<tr><td><a href="expreverse.xml" target="_top">ExpReverse</a></td><td>Exponential Function Reverse Mode Theory</td></tr><tr><td><a href="logreverse.xml" target="_top">LogReverse</a></td><td>Logarithm Function Reverse Mode Theory</td></tr><tr><td><a href="sqrtreverse.xml" target="_top">SqrtReverse</a></td><td>Square Root Function Reverse Mode Theory</td></tr><tr><td><a href="sincosreverse.xml" target="_top">SinCosReverse</a></td><td>Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</td></tr><tr><td><a href="atanreverse.xml" target="_top">AtanReverse</a></td><td>Arctangent Function Reverse Mode Theory</td></tr><tr><td><a href="asinreverse.xml" target="_top">AsinReverse</a></td><td>Arcsine Function Reverse Mode Theory</td></tr><tr><td><a href="acosreverse.xml" target="_top">AcosReverse</a></td><td>Arccosine Function Reverse Mode Theory</td></tr><tr><td><a href="tan_reverse.xml" target="_top">tan_reverse</a></td><td>Tangent and Hyperbolic Tangent Reverse Mode Theory</td></tr><tr><td><a href="erf_reverse.xml" target="_top">erf_reverse</a></td><td>Error Function Reverse Mode Theory</td></tr></table>
	1514	<hr/>Input File: omh/theory/reverse_theory.omh
1513	1515
1514	1516	</body>
1515	1517	</html>

-1

doc/revone.xml less more

3	3	>
4	4	<head>
5	5	<title>First Order Derivative: Driver Routine</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="First Order Derivative: Driver Routine"/>
7		<meta name="keywords" id="keywords" content=" derivative first order driver easy "/>
	8	<meta name="keywords" id="keywords" content=" derivative first order driver easy derivative: routine syntax purpose f x i dw vector revone uses forward example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/revsparsehes.xml less more

3	3	>
4	4	<head>
5	5	<title>Hessian Sparsity Pattern: Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Hessian Sparsity Pattern: Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" Revsparsehes reverse sparse Hessian pattern "/>
	8	<meta name="keywords" id="keywords" content=" hessian sparsity pattern: reverse mode Revsparsehes sparse Hessian pattern syntax purpose f x q transpose r s h false true vectorset entire example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

606	607	<mi mathvariant='italic'>S</mi>
607	608	</mrow></math>
608	609
609		is the <i>k</i>-th
	610	is the <code><i>k</i></code>-th
610	611	<a href="glossary.xml#Elementary Vector" target="_top"><span style='white-space: nowrap'>elementary vector</span></a>
611	612	; i.e.
612	613

-1

doc/revsparsejac.xml less more

3	3	>
4	4	<head>
5	5	<title>Jacobian Sparsity Pattern: Reverse Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Jacobian Sparsity Pattern: Reverse Mode"/>
7		<meta name="keywords" id="keywords" content=" Revsparsejac reverse sparse Jacobian pattern "/>
	8	<meta name="keywords" id="keywords" content=" jacobian sparsity pattern: reverse mode Revsparsejac sparse Jacobian pattern syntax purpose f x q transpose nz_compare r false true s vectorset entire example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/revtwo.xml less more

3	3	>
4	4	<head>
5	5	<title>Reverse Mode Second Partial Derivative Driver</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Reverse Mode Second Partial Derivative Driver"/>
7		<meta name="keywords" id="keywords" content=" partial second order driver easy "/>
	8	<meta name="keywords" id="keywords" content=" partial second order driver easy reverse mode derivative syntax purpose f x i j ddw vectorbase vectorsize_t revtwo uses forward examples "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/romberg_one.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>One Dimensional Romberg Integration: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="One Dimensional Romberg Integration: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Romberg example test "/>
	8	<meta name="keywords" id="keywords" content=" one dimensional romberg integration: example and test Romberg "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/rombergmul.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>One Dimensional Romberg Integration: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="One Dimensional Romberg Integration: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Romberg example test "/>
	8	<meta name="keywords" id="keywords" content=" one dimensional romberg integration: example and test Romberg "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/rombergmul.xml less more

3	3	>
4	4	<head>
5	5	<title>Multi-dimensional Romberg Integration</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Multi-dimensional Romberg Integration"/>
7		<meta name="keywords" id="keywords" content=" integrate multi-dimensional Romberg multi dimensional integration dimension "/>
	8	<meta name="keywords" id="keywords" content=" multi-dimensional romberg integration integrate Romberg multi dimensional dimension syntax description include m r f a b n p e float floatvector example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/rombergone.xml less more

3	3	>
4	4	<head>
5	5	<title>One DimensionalRomberg Integration</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="One DimensionalRomberg Integration"/>
7		<meta name="keywords" id="keywords" content=" integrate Romberg Integrate "/>
	8	<meta name="keywords" id="keywords" content=" one dimensionalromberg integration integrate Romberg Integrate syntax description include r f a b n p e float example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/rosen34.xml less more

3	3	>
4	4	<head>
5	5	<title>A 3rd and 4th Order Rosenbrock ODE Solver</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A 3rd and 4th Order Rosenbrock ODE Solver"/>
7		<meta name="keywords" id="keywords" content=" Rosen34 Ode Rosenbrock solve stiff differential equation parallel "/>
	8	<meta name="keywords" id="keywords" content=" Rosen34 Ode Rosenbrock solve stiff differential equation a 3rd and 4th order rosenbrock ode solver syntax description include xf fun t x f f_t f_x nan warning optimization m ti tf xi e scalar vector parallel mode example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

438	439	and the input values of the elements of
439	440	<code><i><font color="black"><span style='white-space: nowrap'>f_t</span></font></i></code>
440	441	do not matter.
441		On output, the <i>i</i>-th element of
	442	On output, the <code><i>i</i></code>-th element of
442	443
443	444	<code><i><font color="black"><span style='white-space: nowrap'>f_t</span></font></i></code>
444	445	is set equal to

-1

doc/rosen_34.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Rosen34: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Rosen34: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Rosen34 example test "/>
	8	<meta name="keywords" id="keywords" content=" rosen34: example and test Rosen34 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/runge45.xml less more

3	3	>
4	4	<head>
5	5	<title>An Embedded 4th and 5th Order Runge-Kutta ODE Solver</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="An Embedded 4th and 5th Order Runge-Kutta ODE Solver"/>
7		<meta name="keywords" id="keywords" content=" Runge45 Ode Runge-kutta Runge Kutta solve differential equation parallel "/>
	8	<meta name="keywords" id="keywords" content=" Runge45 Ode Runge-kutta Runge Kutta solve differential equation an embedded 4th and 5th order runge-kutta ode solver syntax purpose operation sequence include xf fun t x f warning m ti tf xi e scalar fabs vector parallel mode example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/runge45_1.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Runge45: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Runge45: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Runge45 example test "/>
	8	<meta name="keywords" id="keywords" content=" runge45: example and test Runge45 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/runge45_2.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Runge45: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Runge45: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Runge45 example test "/>
	8	<meta name="keywords" id="keywords" content=" runge45: example and test Runge45 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-5

doc/sacado_det_lu.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sacado Speed: Gradient of Determinant Using Lu Factorization</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sacado Speed: Gradient of Determinant Using Lu Factorization"/>
7		<meta name="keywords" id="keywords" content=" link_det_lu sacado speed lu matrix factor "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: gradient of determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

110	111	# include <cppad/speed/uniform_01.hpp>
111	112	# include <cppad/vector.hpp>
112	113
	114	// list of possible options
	115	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	116
113	117	bool link_det_lu(
114	118	size_t size ,
115	119	size_t repeat ,

117	121	CppAD::vector<double> &gradient )
118	122	{
119	123	// speed test global option values
120		extern bool global_retape, global_atomic, global_optimize;
121		if( ! global_retape \|\| global_optimize \|\| global_atomic )
	124	if( global_onetape \|\| global_atomic )
122	125	return false;
123
	126	if( global_memory \|\| global_optimize )
	127	return false;
124	128	// -----------------------------------------------------
125	129	// setup
126
	130	//
127	131	// object for computing determinant
128	132	typedef Sacado::Rad::ADvar<double> ADScalar;
129	133	typedef CppAD::vector<ADScalar> ADVector;

+10

-5

doc/sacado_det_minor.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sacado Speed: Gradient of Determinant by Minor Expansion</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sacado Speed: Gradient of Determinant by Minor Expansion"/>
7		<meta name="keywords" id="keywords" content=" link_det_minor sacado speed minor determinant "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: gradient of determinant by minor expansion link_det_minor speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

107	108	# include <cppad/speed/det_by_minor.hpp>
108	109	# include <cppad/speed/uniform_01.hpp>
109	110	# include <cppad/vector.hpp>
	111
	112	// list of possible options
	113	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	114
110	115	bool link_det_minor(
111	116	size_t size ,
112	117	size_t repeat ,

114	119	CppAD::vector<double> &gradient )
115	120	{
116	121	// speed test global option values
117		extern bool global_retape, global_atomic, global_optimize;
118		if( ! global_retape \|\| global_optimize \|\| global_atomic )
119		return false;
120
	122	if( global_atomic )
	123	return false;
	124	if( global_memory \|\| global_onetape \|\| global_optimize )
	125	return false;
121	126	// -----------------------------------------------------
122	127	// setup
123	128

-4

doc/sacado_mat_mul.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sacado Speed: Matrix Multiplication</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sacado Speed: Matrix Multiplication"/>
7		<meta name="keywords" id="keywords" content=" link_mat_mul sacado speed matrix multiply "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: matrix multiplication link_mat_mul speed multiply specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

110	111	# include <cppad/vector.hpp>
111	112	# include <cppad/speed/mat_sum_sq.hpp>
112	113	# include <cppad/speed/uniform_01.hpp>
	114
	115	// list of possible options
	116	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	117
113	118	bool link_mat_mul(
114	119	size_t size ,
115	120	size_t repeat ,

118	123	CppAD::vector<double>& dz )
119	124	{
120	125	// speed test global option values
121		extern bool global_retape, global_atomic, global_optimize;
122		if( ! global_retape \|\| global_atomic \|\| global_optimize )
	126	if( global_memory \|\| global_onetape \|\| global_atomic \|\| global_optimize )
123	127	return false;
124
125	128	// -----------------------------------------------------
126	129	// setup
127	130

+12

-8

doc/sacado_ode.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sacado Speed: Gradient of Ode Solution</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sacado Speed: Gradient of Ode Solution"/>
7		<meta name="keywords" id="keywords" content=" link_ode sacado speed ode "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: gradient of ode solution link_ode speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

113	114	# include <cppad/speed/uniform_01.hpp>
114	115	# include <cppad/speed/ode_evaluate.hpp>
115	116
	117	// list of possible options
	118	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	119
116	120	bool link_ode(
117	121	size_t size ,
118	122	size_t repeat ,

120	124	CppAD::vector<double> &jacobian
121	125	)
122	126	{
	127	// speed test global option values
	128	if( global_atomic )
	129	return false;
	130	if( global_memory \|\| global_onetape \|\| global_optimize )
	131	return false;
	132	// -------------------------------------------------------------
	133	// setup
123	134	assert( x.size() == size );
124	135	assert( jacobian.size() == size * size );
125	136
126		// speed test global option values
127		extern bool global_retape, global_atomic, global_optimize;
128		if( ! global_retape \|\| global_atomic \|\| global_optimize )
129		return false;
130
131		// -------------------------------------------------------------
132		// setup
133	137	typedef Sacado::Fad::DFad<double> ADScalar;
134	138	typedef CppAD::vector<ADScalar> ADVector;
135	139

-5

doc/sacado_poly.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sacado Speed: Second Derivative of a Polynomial</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sacado Speed: Second Derivative of a Polynomial"/>
7		<meta name="keywords" id="keywords" content=" link_poly sacado speed polynomial "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: second derivative of a polynomial link_poly speed specifications implementation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

112	113	# include <cppad/speed/uniform_01.hpp>
113	114	# include <Sacado.hpp>
114	115
	116	// list of possible options
	117	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	118
115	119	bool link_poly(
116	120	size_t size ,
117	121	size_t repeat ,

119	123	CppAD::vector<double> &z , // polynomial argument value
120	124	CppAD::vector<double> &ddp ) // second derivative w.r.t z
121	125	{
122		// speed test global option values
123		extern bool global_retape, global_atomic, global_optimize;
124		if( ! global_retape \|\| global_atomic \|\| global_optimize )
	126	if( global_atomic )
125	127	return false;
126
	128	if( global_memory \|\| global_onetape \|\| global_optimize )
	129	return false;
127	130	// -----------------------------------------------------
128	131	// setup
129	132	typedef Sacado::Tay::Taylor<double> ADScalar;

-2

doc/sacado_prefix.xml less more

3	3	>
4	4	<head>
5	5	<title>Including the Sacado Speed Tests</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Including the Sacado Speed Tests"/>
7		<meta name="keywords" id="keywords" content=" sacado speed prefix get "/>
	8	<meta name="keywords" id="keywords" content=" including the sacado speed tests purpose sacado_prefix prefix get_sacado get "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

62	63	<option>Install-></option>
63	64	<option>download</option>
64	65	<option>cmake</option>
65		<option>cppad_test</option>
	66	<option>cmake_check</option>
66	67	<option>pkgconfig</option>
67	68	<option>InstallUnix</option>
68	69	</select>

71	72	<select onchange='choose_down1(this)'>
72	73	<option>cmake-></option>
73	74	<option>adolc_prefix</option>
	75	<option>colpack_prefix</option>
74	76	<option>eigen_prefix</option>
75	77	<option>fadbad_prefix</option>
76	78	<option>ipopt_prefix</option>

-6

doc/sacado_sparse_hessian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sacado Speed: Sparse Hessian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sacado Speed: Sparse Hessian"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: sparse hessian "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

88	89
89	90
90	91	<center><b><big><big>Sacado Speed: Sparse Hessian</big></big></b></center>
91		<code><font color='blue'><pre style='display:inline'> // The sacado version of this test is not yet available
	92	<code><font color='blue'><pre style='display:inline'> // A sacado version of this test is not yet implemented
92	93	extern bool link_sparse_hessian(
93	94	size_t size ,
94	95	size_t repeat ,
95		CppAD::vector<double> &x ,
96		const CppAD::vector<size_t> &row ,
97		const CppAD::vector<size_t> &col ,
98		CppAD::vector<double> &hessian
	96	const CppAD::vector<size_t>& row ,
	97	const CppAD::vector<size_t>& col ,
	98	CppAD::vector<double>& x ,
	99	CppAD::vector<double>& hessian
99	100	)
100	101	{
101	102	return false;

+11

-9

doc/sacado_sparse_jacobian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>sacado Speed: sparse_jacobian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="sacado Speed: sparse_jacobian"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: sparse_jacobian "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

88	89
89	90
90	91	<center><b><big><big>sacado Speed: sparse_jacobian</big></big></b></center>
91		<code><font color='blue'><pre style='display:inline'> // The sacado version of this test is not yet available
	92	<code><font color='blue'><pre style='display:inline'> // A sacado version of this test is not yet available
92	93	bool link_sparse_jacobian(
93		size_t size ,
94		size_t repeat ,
95		size_t m ,
96		CppAD::vector<double> &x ,
97		CppAD::vector<size_t> &i ,
98		CppAD::vector<size_t> &j ,
99		CppAD::vector<double> &jacobian )
	94	size_t size ,
	95	size_t repeat ,
	96	size_t m ,
	97	const CppAD::vector<size_t>& row ,
	98	const CppAD::vector<size_t>& col ,
	99	CppAD::vector<double>& x ,
	100	CppAD::vector<double>& jacobian ,
	101	size_t& n_sweep )
100	102	{
101	103	return false;
102	104	}

-1

doc/seq_property.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>ADFun Sequence Properties: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ADFun Sequence Properties: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Domain Adfun Range Parameter size_var size_par size_op size_op_arg size_vecad example test "/>
	8	<meta name="keywords" id="keywords" content=" adfun sequence properties: example and test Domain Adfun Range Parameter size_var size_par size_op size_op_arg size_vecad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-7

doc/seq_property.xml less more

3	3	>
4	4	<head>
5	5	<title>ADFun Sequence Properties</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="ADFun Sequence Properties"/>
7		<meta name="keywords" id="keywords" content=" Adfun Domain Range Parameter size_var size_par size_vecad "/>
	8	<meta name="keywords" id="keywords" content=" adfun sequence properties syntax see also purpose f domain Adfun Domain range Range parameter Parameter size_var size_par size_op size_op_arg size_text size_vecad size_op_seq example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

140	141	<b><a name="Syntax.See Also" id="Syntax.See Also">See Also</a></b>
141	142
142	143	<br/>
143		<a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
144		, <a href="capacity_taylor.xml" target="_top"><span style='white-space: nowrap'>capacity_taylor</span></a>
	144	<a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
	145	, <a href="capacity_order.xml" target="_top"><span style='white-space: nowrap'>capacity_order</span></a>
145	146	.
146	147
147	148	<br/>

274	275	<code><font color="blue"><span style='white-space: nowrap'><br/>
275	276	bool </span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
276	277	</span></font></code>
277		It is true if the <i>i</i>-th component of range space for
	278	It is true if the <code><i>i</i></code>-th component of range space for
278	279	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
279	280	<mi mathvariant='italic'>F</mi>
280	281	</mrow></math>

284	285	<a href="glossary.xml#Parameter" target="_top"><span style='white-space: nowrap'>parameter</span></a>
285	286	in the operation sequence.
286	287	In this case,
287		the <i>i</i>-th component of
	288	the <code><i>i</i></code>-th component of
288	289	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
289	290	<mi mathvariant='italic'>F</mi>
290	291	</mrow></math>

355	356	is roughly proportional to
356	357	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
357	358	.
358		(The function call <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>f.size_taylor()</span></a>
	359	(The function call <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>f.size_order()</span></a>
359	360
360		returns the number of Taylor coefficients, per variable,
	361	returns the number of Taylor coefficient orders, per variable,direction,
361	362	currently stored in
362	363	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
363	364	.)

-1

doc/sign.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sign Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sign Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" sign example test "/>
	8	<meta name="keywords" id="keywords" content=" sign function: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sign.xml less more

3	3	>
4	4	<head>
5	5	<title>Sign Function</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sign Function"/>
7		<meta name="keywords" id="keywords" content=" sign Ad "/>
	8	<meta name="keywords" id="keywords" content=" sign Ad function syntax purpose x y operation sequence complex types derivative example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/simple_ad_bthread.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>A Simple Boost Threading AD: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Simple Boost Threading AD: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" boost simple thread Ad "/>
	8	<meta name="keywords" id="keywords" content=" a simple boost threading ad: example and test thread Ad purpose source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/simple_ad_openmp.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>A Simple OpenMP AD: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Simple OpenMP AD: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" openmp simple Ad "/>
	8	<meta name="keywords" id="keywords" content=" a simple openmp ad: example and test Ad purpose source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/simple_ad_pthread.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>A Simple pthread AD: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Simple pthread AD: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" pthread simple Ad "/>
	8	<meta name="keywords" id="keywords" content=" a simple pthread ad: example and test Ad purpose source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/simple_vector.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Simple Vector Template Class: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Simple Vector Template Class: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" vector simple example test "/>
	8	<meta name="keywords" id="keywords" content=" simple vector template class: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/simplevector.xml less more

3	3	>
4	4	<head>
5	5	<title>Definition of a Simple Vector</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Definition of a Simple Vector"/>
7		<meta name="keywords" id="keywords" content=" vector simple class template default constructor size copy element destructor assignment resize value_type [] exercise Ndebug "/>
	8	<meta name="keywords" id="keywords" content=" vector simple class template definition of a requirements elements specified type default constructor sizing size copy element and destructor assignment resize value value_type access [] using example exercise Ndebug "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

451	452	<code><font color="blue"><span style='white-space: nowrap'><br/>
452	453	</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'>] = </span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
453	454	</span></font></code>
454		assigns the <i>i</i>-th element of
	455	assigns the <code><i>i</i></code>-th element of
455	456	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
456	457	to have value
457	458	<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>

-1

doc/sin.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD sin Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD sin Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" sin Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad sin function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/sincosforward.xml less more

3	3	>
4	4	<head>
5	5	<title>Trigonometric and Hyperbolic Sine and Cosine Forward Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Trigonometric and Hyperbolic Sine and Cosine Forward Theory"/>
7		<meta name="keywords" id="keywords" content=" sin forward sinh cos cosh theory "/>
	8	<meta name="keywords" id="keywords" content=" sin forward sinh cos cosh theory trigonometric and hyperbolic sine cosine differential equation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinForward</option>
77	78	<option>AcosForward</option>
78	79	<option>tan_forward</option>
	80	<option>erf_forward</option>
79	81	</select>
80	82	</td>
81	83	<td>SinCosForward</td>

658	660	.
659	661
660	662
661		<hr/>Input File: omh/sin_cos_forward.omh
	663	<hr/>Input File: omh/theory/sin_cos_forward.omh
662	664
663	665	</body>
664	666	</html>

-2

doc/sincosreverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Trigonometric and Hyperbolic Sine and Cosine Reverse Theory"/>
7		<meta name="keywords" id="keywords" content=" sin reverse sinh cos cosh theory "/>
	8	<meta name="keywords" id="keywords" content=" sin reverse sinh cos cosh theory trigonometric and hyperbolic sine cosine "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinReverse</option>
77	78	<option>AcosReverse</option>
78	79	<option>tan_reverse</option>
	80	<option>erf_reverse</option>
79	81	</select>
80	82	</td>
81	83	<td>SinCosReverse</td>

738	740	</mrow></math>
739	741
740	742
741		<hr/>Input File: omh/sin_cos_reverse.omh
	743	<hr/>Input File: omh/theory/sin_cos_reverse.omh
742	744
743	745	</body>
744	746	</html>

-1

doc/sinh.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD sinh Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD sinh Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" sinh Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad sinh function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+273

-0

doc/size_order.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>Number Taylor Coefficient Orders Currently Stored</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Number Taylor Coefficient Orders Currently Stored"/>
	8	<meta name="keywords" id="keywords" content=" number taylor coefficient orders currently stored syntax see also purpose f s constructor forward capacity_order example "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_size_order_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="forward_dir.cpp.xml" target="_top">Prev</a>
	25	</td><td><a href="comparechange.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>ADFun</option>
	41	<option>FunEval</option>
	42	<option>Forward</option>
	43	<option>size_order</option>
	44	</select>
	45	</td>
	46	<td>
	47	<select onchange='choose_down3(this)'>
	48	<option>ADFun-></option>
	49	<option>Independent</option>
	50	<option>FunConstruct</option>
	51	<option>Dependent</option>
	52	<option>abort_recording</option>
	53	<option>seq_property</option>
	54	<option>FunEval</option>
	55	<option>Drivers</option>
	56	<option>FunCheck</option>
	57	<option>optimize</option>
	58	<option>check_for_nan</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>FunEval-></option>
	64	<option>Forward</option>
	65	<option>Reverse</option>
	66	<option>Sparse</option>
	67	</select>
	68	</td>
	69	<td>
	70	<select onchange='choose_down1(this)'>
	71	<option>Forward-></option>
	72	<option>forward_zero</option>
	73	<option>forward_one</option>
	74	<option>forward_two</option>
	75	<option>forward_order</option>
	76	<option>forward_dir</option>
	77	<option>size_order</option>
	78	<option>CompareChange</option>
	79	<option>capacity_order</option>
	80	<option>number_skip</option>
	81	</select>
	82	</td>
	83	<td>size_order</td>
	84	<td>
	85	<select onchange='choose_current0(this)'>
	86	<option>Headings-></option>
	87	<option>Syntax</option>
	88	<option>---..See Also</option>
	89	<option>Purpose</option>
	90	<option>f</option>
	91	<option>s</option>
	92	<option>Constructor</option>
	93	<option>Forward</option>
	94	<option>capacity_order</option>
	95	<option>Example</option>
	96	</select>
	97	</td>
	98	</tr></table><br/>
	99
	100
	101
	102	<center><b><big><big>Number Taylor Coefficient Orders Currently Stored</big></big></b></center>
	103	<br/>
	104	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
	105
	106	<br/>
	107
	108	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_order()</span></font></code>
	109
	110
	111	<br/>
	112	<br/>
	113	<b><a name="Syntax.See Also" id="Syntax.See Also">See Also</a></b>
	114
	115	<br/>
	116	<a href="seq_property.xml" target="_top"><span style='white-space: nowrap'>seq_property</span></a>
	117
	118
	119	<br/>
	120	<br/>
	121	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
	122	<br/>
	123	Determine the number of Taylor coefficient orders, per variable,direction,
	124	currently calculated and stored in the ADFun object
	125	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	126	.
	127	See the discussion under
	128	<a href="size_order.xml#Constructor" target="_top"><span style='white-space: nowrap'>Constructor</span></a>
	129	,
	130	<a href="size_order.xml#Forward" target="_top"><span style='white-space: nowrap'>Forward</span></a>
	131	, and
	132	<a href="size_order.xml#capacity_order" target="_top"><span style='white-space: nowrap'>capacity_order</span></a>
	133
	134	for a description of when this value can change.
	135
	136
	137	<br/>
	138	<br/>
	139	<b><big><a name="f" id="f">f</a></big></b>
	140	<br/>
	141	The object
	142	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	143	has prototype
	144
	145	<code><font color="blue"><span style='white-space: nowrap'><br/>
	146	const ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	147	</span></font></code>
	148	<br/>
	149	<b><big><a name="s" id="s">s</a></big></b>
	150	<br/>
	151	The result
	152	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
	153	has prototype
	154
	155	<code><font color="blue"><span style='white-space: nowrap'><br/>
	156	size_t </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	157	</span></font></code>
	158	and is the number of Taylor coefficient orders,
	159	per variable,direction in the AD operation sequence,
	160	currently calculated and stored in the ADFun object
	161	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	162	.
	163
	164	<br/>
	165	<br/>
	166	<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
	167	<br/>
	168	Directly after the <a href="funconstruct.xml" target="_top"><span style='white-space: nowrap'>FunConstruct</span></a>
	169	syntax
	170
	171	<code><font color="blue"><span style='white-space: nowrap'><br/>
	172	ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>(</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	173	</span></font></code>
	174	the value of
	175	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
	176	returned by <code><font color="blue">size_order</font></code> is one.
	177	This is because
	178	there is an implicit call to <code><font color="blue">Forward</font></code> that computes
	179	the zero order Taylor coefficients during this constructor.
	180
	181	<br/>
	182	<br/>
	183	<b><big><a name="Forward" id="Forward">Forward</a></big></b>
	184	<br/>
	185	After a call to <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>Forward</span></a>
	186	with the syntax
	187
	188	<code><font color="blue"><span style='white-space: nowrap'><br/>
	189	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>x_q</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	190	</span></font></code>
	191	the value of
	192	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
	193	returned by <code><font color="blue">size_order</font></code>
	194	would be
	195	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	196	<mi mathvariant='italic'>q</mi>
	197	<mo stretchy="false">+</mo>
	198	<mn>1</mn>
	199	</mrow></math>
	200
	201	.
	202	The call to <code><font color="blue">Forward</font></code> above
	203	uses the lower order Taylor coefficients to compute and store
	204	the <code><i>q</i></code>-th order Taylor coefficients for all
	205	the variables in the operation sequence corresponding to
	206	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	207	.
	208	Thus there are
	209	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	210	<mi mathvariant='italic'>q</mi>
	211	<mo stretchy="false">+</mo>
	212	<mn>1</mn>
	213	</mrow></math>
	214
	215	(order zero through
	216	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
	217	)
	218	Taylor coefficients per variable,direction.
	219	(You can determine the number of variables in the operation sequence
	220	using the <a href="seq_property.xml#size_var" target="_top"><span style='white-space: nowrap'>size_var</span></a>
	221	function.)
	222
	223	<br/>
	224	<br/>
	225	<b><big><a name="capacity_order" id="capacity_order">capacity_order</a></big></b>
	226	<br/>
	227	If the number of Taylor coefficient orders
	228	currently stored in
	229	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	230	is less than or equal
	231	<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
	232	,
	233	a call to <a href="capacity_order.xml" target="_top"><span style='white-space: nowrap'>capacity_order</span></a>
	234	with the syntax
	235
	236	<code><font color="blue"><span style='white-space: nowrap'><br/>
	237	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity_order(</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	238	</span></font></code>
	239	does not affect the value
	240	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
	241	returned by <code><font color="blue">size_order</font></code>.
	242	Otherwise,
	243	the value
	244	<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
	245	returned by <code><font color="blue">size_order</font></code>
	246	is equal to
	247	<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
	248
	249	(only Taylor coefficients of order zero through
	250	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	251	<mi mathvariant='italic'>c</mi>
	252	<mn>-1</mn>
	253	</mrow></math>
	254
	255
	256	have been retained).
	257
	258	<br/>
	259	<br/>
	260	<b><big><a name="Example" id="Example">Example</a></big></b>
	261	<br/>
	262	The file
	263	<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
	264
	265	contains an example and test of this operation.
	266	It returns true if it succeeds and false otherwise.
	267
	268
	269	<hr/>Input File: omh/forward/size_order.omh
	270
	271	</body>
	272	</html>

-272

~~doc/size_taylor.xml~~ less more

0		<?xml version='1.0'?>
1		<html xmlns='http://www.w3.org/1999/xhtml'
2		xmlns:math='http://www.w3.org/1998/Math/MathML'
3		>
4		<head>
5		<title>Number Taylor Coefficients, Per Variable, Currently Stored</title>
6		<meta name="description" id="description" content="Number Taylor Coefficients, Per Variable, Currently Stored"/>
7		<meta name="keywords" id="keywords" content=" "/>
8		<style type='text/css'>
9		body { color : black }
10		body { background-color : white }
11		A:link { color : blue }
12		A:visited { color : purple }
13		A:active { color : purple }
14		</style>
15		<script type='text/javascript' language='JavaScript' src='_size_taylor_xml.js'>
16		</script>
17		</head>
18		<body>
19		<table><tr>
20		<td>
21		<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22		</td>
23		<td><a href="forwardany.xml" target="_top">Prev</a>
24		</td><td><a href="comparechange.xml" target="_top">Next</a>
25		</td><td>
26		<select onchange='choose_across0(this)'>
27		<option>Index-></option>
28		<option>contents</option>
29		<option>reference</option>
30		<option>index</option>
31		<option>search</option>
32		<option>external</option>
33		</select>
34		</td>
35		<td>
36		<select onchange='choose_up0(this)'>
37		<option>Up-></option>
38		<option>CppAD</option>
39		<option>ADFun</option>
40		<option>FunEval</option>
41		<option>Forward</option>
42		<option>size_taylor</option>
43		</select>
44		</td>
45		<td>
46		<select onchange='choose_down3(this)'>
47		<option>ADFun-></option>
48		<option>Independent</option>
49		<option>FunConstruct</option>
50		<option>Dependent</option>
51		<option>abort_recording</option>
52		<option>seq_property</option>
53		<option>FunEval</option>
54		<option>Drivers</option>
55		<option>FunCheck</option>
56		<option>optimize</option>
57		<option>check_for_nan</option>
58		</select>
59		</td>
60		<td>
61		<select onchange='choose_down2(this)'>
62		<option>FunEval-></option>
63		<option>Forward</option>
64		<option>Reverse</option>
65		<option>Sparse</option>
66		</select>
67		</td>
68		<td>
69		<select onchange='choose_down1(this)'>
70		<option>Forward-></option>
71		<option>ForwardZero</option>
72		<option>ForwardOne</option>
73		<option>ForwardAny</option>
74		<option>size_taylor</option>
75		<option>CompareChange</option>
76		<option>capacity_taylor</option>
77		<option>number_skip</option>
78		<option>forward.cpp</option>
79		<option>forward_mul.cpp</option>
80		</select>
81		</td>
82		<td>size_taylor</td>
83		<td>
84		<select onchange='choose_current0(this)'>
85		<option>Headings-></option>
86		<option>Syntax</option>
87		<option>---..See Also</option>
88		<option>Purpose</option>
89		<option>f</option>
90		<option>s</option>
91		<option>Constructor</option>
92		<option>Forward</option>
93		<option>capacity_taylor</option>
94		<option>Example</option>
95		</select>
96		</td>
97		</tr></table><br/>
98
99
100
101		<center><b><big><big>Number Taylor Coefficients, Per Variable, Currently Stored</big></big></b></center>
102		<br/>
103		<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
104
105		<br/>
106
107		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.size_taylor()</span></font></code>
108
109
110		<br/>
111		<br/>
112		<b><a name="Syntax.See Also" id="Syntax.See Also">See Also</a></b>
113
114		<br/>
115		<a href="seq_property.xml" target="_top"><span style='white-space: nowrap'>seq_property</span></a>
116
117
118		<br/>
119		<br/>
120		<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
121		<br/>
122		Determine the number of Taylor coefficients, per variable,
123		currently calculated and stored in the ADFun object
124		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
125		.
126		See the discussion under
127		<a href="size_taylor.xml#Constructor" target="_top"><span style='white-space: nowrap'>Constructor</span></a>
128		,
129		<a href="size_taylor.xml#Forward" target="_top"><span style='white-space: nowrap'>Forward</span></a>
130		, and
131		<a href="size_taylor.xml#capacity_taylor" target="_top"><span style='white-space: nowrap'>capacity_taylor</span></a>
132
133		for a description of when this value can change.
134
135
136		<br/>
137		<br/>
138		<b><big><a name="f" id="f">f</a></big></b>
139		<br/>
140		The object
141		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
142		has prototype
143
144		<code><font color="blue"><span style='white-space: nowrap'><br/>
145		const ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
146		</span></font></code>
147		<br/>
148		<b><big><a name="s" id="s">s</a></big></b>
149		<br/>
150		The result
151		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
152		has prototype
153
154		<code><font color="blue"><span style='white-space: nowrap'><br/>
155		size_t </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
156		</span></font></code>
157		and is the number of Taylor coefficients,
158		per variable in the AD operation sequence,
159		currently calculated and stored in the ADFun object
160		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
161		.
162
163		<br/>
164		<br/>
165		<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
166		<br/>
167		Directly after the <a href="funconstruct.xml" target="_top"><span style='white-space: nowrap'>FunConstruct</span></a>
168		syntax
169
170		<code><font color="blue"><span style='white-space: nowrap'><br/>
171		ADFun<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>> </span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>(</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
172		</span></font></code>
173		the value of
174		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
175		returned by <code><font color="blue">size_taylor</font></code> is one.
176		This is because
177		there is an implicit call to <code><font color="blue">Forward</font></code> that computes
178		the zero order Taylor coefficients during this constructor.
179
180		<br/>
181		<br/>
182		<b><big><a name="Forward" id="Forward">Forward</a></big></b>
183		<br/>
184		After a call to <a href="forwardany.xml" target="_top"><span style='white-space: nowrap'>Forward</span></a>
185		with the syntax
186
187		<code><font color="blue"><span style='white-space: nowrap'><br/>
188		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(</span></font><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>x_p</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
189		</span></font></code>
190		the value of
191		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
192		returned by <code><font color="blue">size_taylor</font></code>
193		would be
194		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
195		<mi mathvariant='italic'>p</mi>
196		<mo stretchy="false">+</mo>
197		<mn>1</mn>
198		</mrow></math>
199
200		.
201		The call to <code><font color="blue">Forward</font></code> above
202		uses the lower order Taylor coefficients to compute and store
203		the <i>p</i>-th order Taylor coefficients for all
204		the variables in the operation sequence corresponding to
205		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
206		.
207		Thus there are
208		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
209		<mi mathvariant='italic'>p</mi>
210		<mo stretchy="false">+</mo>
211		<mn>1</mn>
212		</mrow></math>
213
214		(order zero through
215		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
216		)
217		Taylor coefficients per variable.
218		(You can determine the number of variables in the operation sequence
219		using the <a href="seq_property.xml#size_var" target="_top"><span style='white-space: nowrap'>size_var</span></a>
220		function.)
221
222		<br/>
223		<br/>
224		<b><big><a name="capacity_taylor" id="capacity_taylor">capacity_taylor</a></big></b>
225		<br/>
226		If the number of Taylor coefficients
227		currently stored in
228		<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
229		is less than or equal
230		<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
231		,
232		a call to <a href="capacity_taylor.xml" target="_top"><span style='white-space: nowrap'>capacity_taylor</span></a>
233		with the syntax
234
235		<code><font color="blue"><span style='white-space: nowrap'><br/>
236		</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.capacity_taylor(</span></font><i><font color="black"><span style='white-space: nowrap'>c</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
237		</span></font></code>
238		does not affect the value
239		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
240		returned by <code><font color="blue">size_taylor</font></code>.
241		Otherwise,
242		the value
243		<code><i><font color="black"><span style='white-space: nowrap'>s</span></font></i></code>
244		returned by <code><font color="blue">size_taylor</font></code>
245		is equal to
246		<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
247
248		(only Taylor coefficients of order zero through
249		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
250		<mi mathvariant='italic'>c</mi>
251		<mn>-1</mn>
252		</mrow></math>
253
254
255		have been retained).
256
257		<br/>
258		<br/>
259		<b><big><a name="Example" id="Example">Example</a></big></b>
260		<br/>
261		The file
262		<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
263
264		contains an example and test of this operation.
265		It returns true if it succeeds and false otherwise.
266
267
268		<hr/>Input File: omh/forward.omh
269
270		</body>
271		</html>

-1

doc/sparse.xml less more

3	3	>
4	4	<head>
5	5	<title>Calculating Sparsity Patterns</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Calculating Sparsity Patterns"/>
7		<meta name="keywords" id="keywords" content=" sparsity pattern "/>
	8	<meta name="keywords" id="keywords" content=" sparsity pattern calculating patterns "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sparse_hes_fun.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>sparse_hes_fun: Example and test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="sparse_hes_fun: Example and test"/>
7		<meta name="keywords" id="keywords" content=" sparse_hes_fun example test "/>
	8	<meta name="keywords" id="keywords" content=" sparse_hes_fun example test sparse_hes_fun: and "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sparse_hes_fun.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: sparse_hes_fun</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: sparse_hes_fun"/>
7		<meta name="keywords" id="keywords" content=" sparse_hes_fun source "/>
	8	<meta name="keywords" id="keywords" content=" source: sparse_hes_fun source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sparse_hes_fun.xml less more

3	3	>
4	4	<head>
5	5	<title>Evaluate a Function That Has a Sparse Hessian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Evaluate a Function That Has a Sparse Hessian"/>
7		<meta name="keywords" id="keywords" content=" sparse_hes_fun function "/>
	8	<meta name="keywords" id="keywords" content=" evaluate a function that has sparse hessian sparse_hes_fun syntax purpose inclusion float floatvector n x row col p fp gradient example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sparse_hessian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sparse Hessian: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sparse Hessian: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Hessian sparse example test spare "/>
	8	<meta name="keywords" id="keywords" content=" sparse hessian: example and test Hessian spare "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sparse_hessian.xml less more

3	3	>
4	4	<head>
5	5	<title>Sparse Hessian: Easy Driver</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sparse Hessian: Easy Driver"/>
7		<meta name="keywords" id="keywords" content=" Sparsehessian hessian sparse "/>
	8	<meta name="keywords" id="keywords" content=" sparse hessian: easy driver Sparsehessian hessian syntax purpose f x w p row col hes work n_sweep vectorbase vectorset restrictions vectorsize uses forward example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sparse_jac_fun.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>sparse_jac_fun: Example and test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="sparse_jac_fun: Example and test"/>
7		<meta name="keywords" id="keywords" content=" sparse_jac_fun example test "/>
	8	<meta name="keywords" id="keywords" content=" sparse_jac_fun example test sparse_jac_fun: and "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sparse_jac_fun.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: sparse_jac_fun</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: sparse_jac_fun"/>
7		<meta name="keywords" id="keywords" content=" sparse_jac_fun source "/>
	8	<meta name="keywords" id="keywords" content=" source: sparse_jac_fun source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sparse_jac_fun.xml less more

3	3	>
4	4	<head>
5	5	<title>Evaluate a Function That Has a Sparse Jacobian</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Evaluate a Function That Has a Sparse Jacobian"/>
7		<meta name="keywords" id="keywords" content=" sparse_jac_fun function "/>
	8	<meta name="keywords" id="keywords" content=" evaluate a function that has sparse jacobian sparse_jac_fun syntax purpose inclusion float floatvector n m x row col p fp example source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sparse_jacobian.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Sparse Jacobian: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sparse Jacobian: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Jacobian sparse example test spare "/>
	8	<meta name="keywords" id="keywords" content=" sparse jacobian: example and test Jacobian spare "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+49

-22

doc/sparse_jacobian.xml less more

3	3	>
4	4	<head>
5	5	<title>Sparse Jacobian: Easy Driver</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Sparse Jacobian: Easy Driver"/>
7		<meta name="keywords" id="keywords" content=" Sparsejacobian jacobian sparse "/>
	8	<meta name="keywords" id="keywords" content=" sparse jacobian: easy driver Sparsejacobian jacobian syntax purpose f x p row col jac work color_method n_sweep vectorbase vectorset restrictions vectorsize uses forward example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

102	103	<option>row, col</option>
103	104	<option>jac</option>
104	105	<option>work</option>
	106	<option>---..color_method</option>
105	107	<option>n_sweep</option>
106	108	<option>VectorBase</option>
107	109	<option>VectorSet</option>

351	353	</mrow></math>
352	354
353	355	are
354		returned and in what order.
	356	computes and in what order.
	357	Not all the non-zero entries in
	358	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	359	<msup><mi mathvariant='italic'>F</mi>
	360	<mrow><mo stretchy="false">(</mo>
	361	<mn>1</mn>
	362	<mo stretchy="false">)</mo>
	363	</mrow>
	364	</msup>
	365	<mo stretchy="false">(</mo>
	366	<mi mathvariant='italic'>x</mi>
	367	<mo stretchy="false">)</mo>
	368	</mrow></math>
	369
	370	need be computed,
	371	but all the entries specified by
	372	<code><i><font color="black"><span style='white-space: nowrap'>row</span></font></i></code>
	373	and
	374	<code><i><font color="black"><span style='white-space: nowrap'>col</span></font></i></code>
	375
	376	must be possibly non-zero in the sparsity pattern.
355	377	We use
356	378	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
357	379	<mi mathvariant='italic'>K</mi>

399	421	<mi mathvariant='italic'>n</mi>
400	422	</mrow></math>
401	423
402		.
403		In addition,
404		all of the
405		<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
406		<mo stretchy="false">(</mo>
407		<mi mathvariant='italic'>row</mi>
408		<mo stretchy="false">[</mo>
409		<mi mathvariant='italic'>k</mi>
410		<mo stretchy="false">]</mo>
411		<mo stretchy="false">,</mo>
412		<mi mathvariant='italic'>col</mi>
413		<mo stretchy="false">[</mo>
414		<mi mathvariant='italic'>k</mi>
415		<mo stretchy="false">]</mo>
416		<mo stretchy="false">)</mo>
417		</mrow></math>
418
419		pairs must correspond to a true value
420		in the sparsity pattern
421		<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
422	424	.
423	425
424	426	<br/>

609	611
610	612	<br/>
611	613	<br/>
	614	<b><a name="work.color_method" id="work.color_method">color_method</a></b>
	615	<br/>
	616	The coloring algorithm determines which columns (forward mode)
	617	or rows (reverse mode) can be computed during the same sweep.
	618	This field has prototype
	619	<code><font color='blue'><pre style='display:inline'>
	620	std::string %work%.color_method
	621	</pre></font></code>
	622
	623	and its default value (after a constructor or <code><font color="blue">clear()</font></code>)
	624	is <code><font color="blue">"cppad"</font></code>.
	625	If <a href="colpack_prefix.xml" target="_top"><span style='white-space: nowrap'>colpack_prefix</span></a>
	626	is specified on the
	627	<a href="cmake.xml#CMake Command" target="_top"><span style='white-space: nowrap'>cmake command</span></a>
	628	line,
	629	you can set this method to <code><font color="blue">"colpack"</font></code>.
	630	This value only matters on the first call to <code><font color="blue">sparse_jacobian</font></code>
	631	after the
	632	<code><i><font color="black"><span style='white-space: nowrap'>work</span></font></i></code>
	633	constructor or a call to <code><font color="blue">clear</font></code>.
	634
	635	<br/>
	636	<br/>
612	637	<b><big><a name="n_sweep" id="n_sweep">n_sweep</a></big></b>
613	638	<br/>
614	639	The return value

623	648	<code><i><font color="black"><span style='white-space: nowrap'>n_sweep</span></font></i></code>
624	649	is the number of first order forward (reverse) sweeps
625	650	used to compute the requested Jacobian values.
	651	(This is also the number of colors determined by the coloring method
	652	mentioned above).
626	653	This is proportional to the total work that <code><font color="blue">SparseJacobian</font></code> does,
627	654	not counting the zero order forward sweep,
628	655	or the work to combine multiple columns (rows) into a single sweep.

+10

-33

doc/speed.xml less more

2	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
3	3	>
4	4	<head>
5		<title>AD Speed Test Routines</title>
6		<meta name="description" id="description" content="AD Speed Test Routines"/>
7		<meta name="keywords" id="keywords" content=" speed test windows "/>
	5	<title>Speed Test an Operator Overloading AD Package</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Speed Test an Operator Overloading AD Package"/>
	8	<meta name="keywords" id="keywords" content=" speed test an operator overloading ad package purpose "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

71	72	<select onchange='choose_current0(this)'>
72	73	<option>Headings-></option>
73	74	<option>Purpose</option>
74		<option>Windows</option>
75	75	<option>Contents</option>
76	76	</select>
77	77	</td>

82	82
83	83
84	84
85		<center><b><big><big>AD Speed Test Routines</big></big></b></center>
	85	<center><b><big><big>Speed Test an Operator Overloading AD Package</big></big></b></center>
86	86	<br/>
87	87	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>
88	88	<br/>
89	89	CppAD has a set of speed tests that are used to determine if
90		certain changes improve its execution speed
91		and to compare the C++ AD packages
	90	certain changes improve its execution speed.
	91	These tests can also be used to compare the AD packages
92	92	<a href="https://projects.coin-or.org/ADOL-C" target="_top"><span style='white-space: nowrap'>Adolc</span></a>
93	93	,
94	94	<a href="http://www.coin-or.org/CppAD/" target="_top"><span style='white-space: nowrap'>CppAD</span></a>

97	97	and
98	98	<a href="http://trilinos.sandia.gov/packages/sacado/" target="_top"><span style='white-space: nowrap'>Sacado</span></a>
99	99	.
100		This section explains how you can run these tests on your computer.
101
102		<br/>
103		<br/>
104		<b><big><a name="Windows" id="Windows">Windows</a></big></b>
105
106
107
108		<br/>
109		The speed test routines have not yet been compiled or tested using
110		the MS Windows C++ compiler.
111		Under Windows, you can use
112		<a href="http://www.cygwin.com" target="_top"><span style='white-space: nowrap'>Cygwin</span></a>
113
114		or,
115		<a href="http://www.mingw.org" target="_top"><span style='white-space: nowrap'>MinGW with MSYS</span></a>
116
117		to run these speed tests.
	100	The sections below explain how you can run these tests on your computer.
118	101
119	102	<br/>
120	103	<br/>
121	104	<b><big><a name="Contents" id="Contents">Contents</a></big></b>
122	105	<br/>
123		<div><a href="speed_main.xml" target="_top">Speed Testing Main Program</a><br/>
124		<a href="speed_utility.xml" target="_top">Speed Testing Utilities</a><br/>
125		<a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
126		<a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
127		<a href="speed_cppad.xml" target="_top">Speed Test Derivatives Using CppAD</a><br/>
128		<a href="speed_fadbad.xml" target="_top">Speed Test Derivatives Using Fadbad</a><br/>
129		<a href="speed_sacado.xml" target="_top">Speed Test Derivatives Using Sacado</a><br/>
130		</div>
	106	<table>
	107	<tr><td><a href="speed_main.xml" target="_top">speed_main</a></td><td>Running the Speed Test Program</td></tr><tr><td><a href="speed_utility.xml" target="_top">speed_utility</a></td><td>Speed Testing Utilities</td></tr><tr><td><a href="speed_double.xml" target="_top">speed_double</a></td><td>Speed Test of Functions in Double</td></tr><tr><td><a href="speed_adolc.xml" target="_top">speed_adolc</a></td><td>Speed Test of Derivatives Using Adolc</td></tr><tr><td><a href="speed_cppad.xml" target="_top">speed_cppad</a></td><td>Speed Test Derivatives Using CppAD</td></tr><tr><td><a href="speed_fadbad.xml" target="_top">speed_fadbad</a></td><td>Speed Test Derivatives Using Fadbad</td></tr><tr><td><a href="speed_sacado.xml" target="_top">speed_sacado</a></td><td>Speed Test Derivatives Using Sacado</td></tr></table>
131	108	<hr/>Input File: omh/speed/speed.omh
132	109
133	110	</body>

+12

-28

doc/speed_adolc.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Test of Derivatives Using Adolc</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Test of Derivatives Using Adolc"/>
7		<meta name="keywords" id="keywords" content=" speed test adolc "/>
	8	<meta name="keywords" id="keywords" content=" speed test adolc of derivatives using purpose adolc_prefix running tests "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

85	86	<select onchange='choose_current0(this)'>
86	87	<option>Headings-></option>
87	88	<option>Purpose</option>
88		<option>adolc_dir</option>
	89	<option>adolc_prefix</option>
89	90	<option>Running Tests</option>
90		<option>C++ Compiler Flags</option>
91	91	<option>Contents</option>
92	92	</select>
93	93	</td>

110	110
111	111	<br/>
112	112	<br/>
113		<b><big><a name="adolc_dir" id="adolc_dir">adolc_dir</a></big></b>
	113	<b><big><a name="adolc_prefix" id="adolc_prefix">adolc_prefix</a></big></b>
114	114	<br/>
115		To run these tests, you must include the <code><font color="blue">configure</font></code> command line option
	115	To run these tests,
	116	you must include the <a href="adolc_prefix.xml" target="_top"><span style='white-space: nowrap'>adolc_prefix</span></a>
	117
	118	in you <a href="cmake.xml#CMake Command" target="_top"><span style='white-space: nowrap'>cmake command</span></a>
	119	.
116	120
117		<code><font color="blue"><span style='white-space: nowrap'><br/>
118		ADOLC_DIR=</span></font><i><font color="black"><span style='white-space: nowrap'>adolc_dir</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
119		</span></font></code>
120		during <a href="installunix.xml#adolc_dir" target="_top"><span style='white-space: nowrap'>installation</span></a>
121		.
122	121
123	122	<br/>
124	123	<br/>

126	125	<br/>
127	126	To build these speed tests, and run their correctness tests,
128	127	execute the following commands starting in the
129		<a href="installunix.xml#Work Directory" target="_top"><span style='white-space: nowrap'>work directory</span></a>
	128	<a href="cmake.xml#CMake Command.Build Directory" target="_top"><span style='white-space: nowrap'>build directory</span></a>
130	129	:
131	130
132	131	<code><font color="blue"><span style='white-space: nowrap'><br/>
133	132	cd speed/adolc<br/>
134		make test<br/>
	133	make check_speed_adolc VERBOSE=1<br/>
135	134	</span></font></code>
136	135	You can then run the corresponding speed tests
137	136	with the following command
138	137
139	138	<code><font color="blue"><span style='white-space: nowrap'><br/>
140		./adolc speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	139	./speed_adolc speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
141	140	</span></font></code>
142	141	where
143	142	<code><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i></code>
144	143	is a positive integer.
145	144	See <a href="speed_main.xml" target="_top"><span style='white-space: nowrap'>speed_main</span></a>
146	145	for more options.
147
148		<br/>
149		<br/>
150		<b><big><a name="C++ Compiler Flags" id="C++ Compiler Flags">C++ Compiler Flags</a></big></b>
151		<br/>
152		The C++ compiler flags used to build the Adolc speed tests are
153		<code><font color="blue">
154		<pre style='display:inline'>
155		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_ADOLC $(CXX_FLAGS)
156		</pre>
157
158		</font></code>
159		where <code><font color="blue">CXX_FLAGS</font></code> is specified by the
160		<a href="installunix.xml#Configure" target="_top"><span style='white-space: nowrap'>configure</span></a>
161		command.
162	146
163	147	<br/>
164	148	<br/>

-22

doc/speed_cppad.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Test Derivatives Using CppAD</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Test Derivatives Using CppAD"/>
7		<meta name="keywords" id="keywords" content=" speed test cppad "/>
	8	<meta name="keywords" id="keywords" content=" speed test cppad derivatives using purpose running tests "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

78	79	<option>cppad_poly.cpp</option>
79	80	<option>cppad_sparse_hessian.cpp</option>
80	81	<option>cppad_sparse_jacobian.cpp</option>
81		<option>cppad_print_optimize</option>
82	82	</select>
83	83	</td>
84	84	<td>

86	86	<option>Headings-></option>
87	87	<option>Purpose</option>
88	88	<option>Running Tests</option>
89		<option>C++ Compiler Flags</option>
90	89	<option>Contents</option>
91	90	</select>
92	91	</td>

108	107	This section links to the source code the CppAD speed tests
109	108	(any suggestions to make the CppAD results faster are welcome).
110	109
	110
111	111	<br/>
112	112	<br/>
113	113	<b><big><a name="Running Tests" id="Running Tests">Running Tests</a></big></b>
114	114	<br/>
115	115	To build these speed tests, and run their correctness tests,
116	116	execute the following commands starting in the
117		<a href="installunix.xml#Work Directory" target="_top"><span style='white-space: nowrap'>work directory</span></a>
	117	<a href="cmake.xml#CMake Command.Build Directory" target="_top"><span style='white-space: nowrap'>build directory</span></a>
118	118	:
119	119
120	120	<code><font color="blue"><span style='white-space: nowrap'><br/>
121	121	cd speed/cppad<br/>
122		make test<br/>
	122	make check_speed_cppad VERBOSE=1<br/>
123	123	</span></font></code>
124	124	You can then run the corresponding speed tests
125	125	with the following command
126	126
127	127	<code><font color="blue"><span style='white-space: nowrap'><br/>
128		./cppad speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	128	./speed_cppad speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
129	129	</span></font></code>
130	130	where
131	131	<code><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i></code>
132	132	is a positive integer.
133	133	See <a href="speed_main.xml" target="_top"><span style='white-space: nowrap'>speed_main</span></a>
134	134	for more options.
135
136		<br/>
137		<br/>
138		<b><big><a name="C++ Compiler Flags" id="C++ Compiler Flags">C++ Compiler Flags</a></big></b>
139		<br/>
140		The C++ compiler flags used to build the CppAD speed tests are
141		<code><font color="blue">
142		<pre style='display:inline'>
143		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_CPPAD $(CXX_FLAGS)
144		</pre>
145
146		</font></code>
147		where <code><font color="blue">CXX_FLAGS</font></code> is specified by the
148		<a href="installunix.xml#Configure" target="_top"><span style='white-space: nowrap'>configure</span></a>
149		command.
150	135
151	136	<br/>
152	137	<br/>

159	144	<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
160	145	<a href="cppad_sparse_hessian.cpp.xml" target="_top">CppAD Speed: Sparse Hessian</a><br/>
161	146	<a href="cppad_sparse_jacobian.cpp.xml" target="_top">CppAD Speed: Sparse Jacobian</a><br/>
162		<a href="cppad_print_optimize.xml" target="_top">Speed Test Utility: Optimize Operation Sequences and Print Results</a><br/>
163	147	</div>
164	148	<hr/>Input File: omh/speed/speed_cppad.omh
165	149

-20

doc/speed_double.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Test of Functions in Double</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Test of Functions in Double"/>
7		<meta name="keywords" id="keywords" content=" speed test double "/>
	8	<meta name="keywords" id="keywords" content=" speed test double of functions in purpose running tests "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

85	86	<option>Headings-></option>
86	87	<option>Purpose</option>
87	88	<option>Running Tests</option>
88		<option>C++ Compiler Flags</option>
89	89	<option>Contents</option>
90	90	</select>
91	91	</td>

111	111	<br/>
112	112	To build these speed tests, and run their correctness tests,
113	113	execute the following commands starting in the
114		<a href="installunix.xml#Work Directory" target="_top"><span style='white-space: nowrap'>work directory</span></a>
	114	<a href="cmake.xml#CMake Command.Build Directory" target="_top"><span style='white-space: nowrap'>build directory</span></a>
115	115	:
116	116
117	117	<code><font color="blue"><span style='white-space: nowrap'><br/>
118	118	cd speed/double<br/>
119		make test<br/>
	119	make check_speed_double VERBOSE=1<br/>
120	120	</span></font></code>
121	121	You can then run the corresponding speed tests
122	122	with the following command
123	123
124	124	<code><font color="blue"><span style='white-space: nowrap'><br/>
125		./double speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	125	./speed_double speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
126	126	</span></font></code>
127	127	where
128	128	<code><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i></code>
129	129	is a positive integer.
130	130	See <a href="speed_main.xml" target="_top"><span style='white-space: nowrap'>speed_main</span></a>
131	131	for more options.
132
133		<br/>
134		<br/>
135		<b><big><a name="C++ Compiler Flags" id="C++ Compiler Flags">C++ Compiler Flags</a></big></b>
136		<br/>
137		The C++ compiler flags used to build the <code><font color="blue">double</font></code> program are
138		<code><font color="blue">
139		<pre style='display:inline'>
140		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_DOUBLE $(CXX_FLAGS)
141		</pre>
142
143		</font></code>
144		where <code><font color="blue">CXX_FLAGS</font></code> is specified by the
145		<a href="installunix.xml#Configure" target="_top"><span style='white-space: nowrap'>configure</span></a>
146		command.
147	132
148	133	<br/>
149	134	<br/>

-2

doc/speed_example.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Run the Speed Examples</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Run the Speed Examples"/>
7		<meta name="keywords" id="keywords" content=" speed example program "/>
	8	<meta name="keywords" id="keywords" content=" speed example program run the examples running tests "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

94	95	<br/>
95	96	<b><big><a name="Running Tests" id="Running Tests">Running Tests</a></big></b>
96	97	<br/>
97		To build this program and run its correctness tests see <a href="cppad_test.xml" target="_top"><span style='white-space: nowrap'>cppad_test</span></a>
	98	To build this program and run its correctness tests see <a href="cmake_check.xml" target="_top"><span style='white-space: nowrap'>cmake_check</span></a>
98	99	.
99	100
100	101

+14

-28

doc/speed_fadbad.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Test Derivatives Using Fadbad</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Test Derivatives Using Fadbad"/>
7		<meta name="keywords" id="keywords" content=" speed test fadbad "/>
	8	<meta name="keywords" id="keywords" content=" speed test fadbad derivatives using purpose fadbad_prefix running tests "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="cppad_print_optimize.xml" target="_top">Prev</a>
	24	<td><a href="cppad_sparse_jacobian.cpp.xml" target="_top">Prev</a>
24	25	</td><td><a href="fadbad_det_minor.cpp.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

84	85	<select onchange='choose_current0(this)'>
85	86	<option>Headings-></option>
86	87	<option>Purpose</option>
87		<option>fadbad_dir</option>
	88	<option>fadbad_prefix</option>
88	89	<option>Running Tests</option>
89		<option>C++ Compiler Flags</option>
90	90	<option>Contents</option>
91	91	</select>
92	92	</td>

109	109
110	110	<br/>
111	111	<br/>
112		<b><big><a name="fadbad_dir" id="fadbad_dir">fadbad_dir</a></big></b>
	112	<b><big><a name="fadbad_prefix" id="fadbad_prefix">fadbad_prefix</a></big></b>
113	113	<br/>
114		To run these tests, you must include the <code><font color="blue">configure</font></code> command line option
	114	To run these tests,
	115	you must include the <a href="fadbad_prefix.xml" target="_top"><span style='white-space: nowrap'>fadbad_prefix</span></a>
	116
	117	in you <a href="cmake.xml#CMake Command" target="_top"><span style='white-space: nowrap'>cmake command</span></a>
	118	.
115	119
116		<code><font color="blue"><span style='white-space: nowrap'><br/>
117		FADBAD_DIR=</span></font><i><font color="black"><span style='white-space: nowrap'>fadbad_dir</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
118		</span></font></code>
119		during <a href="installunix.xml#fadbad_dir" target="_top"><span style='white-space: nowrap'>installation</span></a>
120		.
121	120
122	121	<br/>
123	122	<br/>

125	124	<br/>
126	125	To build these speed tests, and run their correctness tests,
127	126	execute the following commands starting in the
128		<a href="installunix.xml#Work Directory" target="_top"><span style='white-space: nowrap'>work directory</span></a>
	127	<a href="cmake.xml#CMake Command.Build Directory" target="_top"><span style='white-space: nowrap'>build directory</span></a>
129	128	:
130	129
131	130	<code><font color="blue"><span style='white-space: nowrap'><br/>
132		cd speed/double<br/>
133		make test<br/>
	131	cd speed/fadbad<br/>
	132	make check_speed_fadbad VERBOSE=1<br/>
134	133	</span></font></code>
135	134	You can then run the corresponding speed tests
136	135	with the following command
137	136
138	137	<code><font color="blue"><span style='white-space: nowrap'><br/>
139		./double speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	138	./speed_fadbad speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
140	139	</span></font></code>
141	140	where
142	141	<code><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i></code>
143	142	is a positive integer.
144	143	See <a href="speed_main.xml" target="_top"><span style='white-space: nowrap'>speed_main</span></a>
145	144	for more options.
146
147		<br/>
148		<br/>
149		<b><big><a name="C++ Compiler Flags" id="C++ Compiler Flags">C++ Compiler Flags</a></big></b>
150		<br/>
151		The C++ compiler flags used to build the Fadbad speed tests are
152		<code><font color="blue">
153		<pre style='display:inline'>
154		# Use special version of CXX_FLAGS with -Wshadow removed (if present).
155		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_FADBAD $(CXX_FLAGS_FADBAD)
156		</pre>
157
158		</font></code>
159	145
160	146	<br/>
161	147	<br/>

+125

-41

doc/speed_main.xml less more

2	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
3	3	>
4	4	<head>
5		<title>Speed Testing Main Program</title>
6		<meta name="description" id="description" content="Speed Testing Main Program"/>
7		<meta name="keywords" id="keywords" content=" cppad speed test uniform_01 "/>
	5	<title>Running the Speed Test Program</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="Running the Speed Test Program"/>
	8	<meta name="keywords" id="keywords" content=" cppad speed test running the program syntax purpose package ad double profile correct seed uniform_01 option_list onetape optimize atomic memory sparsity options boolsparsity colpack correctness results sparse_jacobian link functions "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

95	96	<option>---..speed</option>
96	97	<option>seed</option>
97	98	<option>option_list</option>
98		<option>---..retape</option>
	99	<option>---..onetape</option>
99	100	<option>---..optimize</option>
100	101	<option>---..atomic</option>
101	102	<option>---..memory</option>
	103	<option>Sparsity Options</option>
	104	<option>---..boolsparsity</option>
	105	<option>---..colpack</option>
102	106	<option>Correctness Results</option>
103	107	<option>Speed Results</option>
	108	<option>---..sparse_jacobian</option>
104	109	<option>Link Functions</option>
105	110	</select>
106	111	</td>
107	112	</tr></table><br/>
108		<center><b><big><big>Speed Testing Main Program</big></big></b></center>
	113	<center><b><big><big>Running the Speed Test Program</big></big></b></center>
109	114	<br/>
110	115	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
111	116
112	117	<br/>
113	118
114		<code><font color="blue"><span style='white-space: nowrap'>speed/</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>/</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>test</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>option_list</span></font></i></code>
	119	<code><font color="blue"><span style='white-space: nowrap'>speed/</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>/speed_</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>test</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>option_list</span></font></i></code>
115	120
116	121
117	122	<br/>

135	140	The command line argument
136	141
137	142	<code><i><font color="black"><span style='white-space: nowrap'>package</span></font></i></code>
138		specifies one of the following AD packages:
	143	specifies one of the AD package.
	144	The CppAD distribution comes with support for the following packages:
139	145	<a href="speed_adolc.xml" target="_top"><span style='white-space: nowrap'>adolc</span></a>
140	146	,
141	147	<a href="speed_cppad.xml" target="_top"><span style='white-space: nowrap'>cppad</span></a>

144	150	,
145	151	<a href="speed_sacado.xml" target="_top"><span style='white-space: nowrap'>sacado</span></a>
146	152	.
	153	You can extend this program to include other package.
	154	Such an extension need not include all the tests.
	155	For example,
	156	<a href="link_sparse_hessian.xml" target="_top"><span style='white-space: nowrap'>link_sparse_hessian</span></a>
	157	just returns <code><font color="blue">false</font></code> for the
	158	<a href="fadbad_sparse_hessian.cpp.xml" target="_top"><span style='white-space: nowrap'>fadbad</span></a>
	159	and
	160	<a href="sacado_sparse_hessian.cpp.xml" target="_top"><span style='white-space: nowrap'>sacado</span></a>
	161	packages.
	162
147	163
148	164	<br/>
149	165	<br/>

196	212	,
197	213	<a href="link_sparse_jacobian.xml" target="_top"><span style='white-space: nowrap'>sparse_jacobian</span></a>
198	214	.
	215	You can experiment with changing the implementation of a
	216	particular test for a particular package.
199	217
200	218	<br/>
201	219	<br/>

242	260	The order of the options does not matter and the list can be empty.
243	261	Each option in the list, must be separate
244	262	command line argument to the main program.
245
246		<br/>
247		<br/>
248		<b><a name="option_list.retape" id="option_list.retape">retape</a></b>
249		<br/>
250		If the option <code><font color="blue">retape</font></code> is present, the symbol
	263	The documentation below specifics how CppAD uses these options,
	264	see the examples in <a href="speed_adolc.xml" target="_top"><span style='white-space: nowrap'>speed_adolc</span></a>
	265	for how another package might
	266	uses these options.
	267
	268	<br/>
	269	<br/>
	270	<b><a name="option_list.onetape" id="option_list.onetape">onetape</a></b>
	271	<br/>
	272	If the option <code><font color="blue">onetape</font></code> is present, the symbol
251	273	<code><font color='blue'><pre style='display:inline'>
252		extern bool global_retape
	274	extern bool global_onetape
253	275	</pre></font></code>
254	276
255	277	is true and otherwise it is false.
256	278	If this external symbol is true,
257		every test must retape the
	279	CppAD will use one taping of the operation
	280	sequence for all the repetitions of that speed test.
	281	Otherwise, the
258	282	<a href="glossary.xml#Operation.Sequence" target="_top"><span style='white-space: nowrap'>operation sequence</span></a>
259	283
260		for each test repetition.
261		If it is false,
262		the AD package is allowed to use one taping of the operation
263		sequence for all the repetitions of that speed test.
	284	will be retaped for each test repetition.
264	285	<code><span style='white-space: nowrap'><br/>
265	286	<br/>
266	287	</span></code>All of the tests, except <a href="link_det_lu.xml" target="_top"><span style='white-space: nowrap'>det_lu</span></a>

269	290	The operation sequence for <code><font color="blue">det_lu</font></code>
270	291	may be different for each repetition of the test because it
271	292	depends on the matrix for which the determinant is being calculated.
272		For this reason,
	293	For this reason, the CppAD test
273	294	<a href="cppad_det_lu.cpp.xml" target="_top"><span style='white-space: nowrap'>cppad_det_lu.cpp</span></a>
274	295	returns false
275		(for test not implemented)
276		when <code><font color="blue">global_retape</font></code> is false.
	296	(indicating that the test not implemented)
	297	when <code><font color="blue">global_onetape</font></code> is true.
277	298
278	299	<br/>
279	300	<br/>

286	307
287	308	is true and otherwise it is false.
288	309	If this external symbol is true,
289		and the AD package has an optional way to spend time optimizing
290		the operation sequence,
291		this optimization should be done before doing computations.
292		If it is false,
293		this optimization should not be done.
	310	CppAD will optimize the operation sequence before doing computations.
	311	If it is false, this optimization will not be done.
294	312
295	313	<br/>
296	314	<br/>

302	320	</pre></font></code>
303	321
304	322	is true and otherwise it is false.
305		If this external symbol is true,
306		and the AD package has a way to speed up the processing
307		by adding <a href="old_atomic.xml" target="_top"><span style='white-space: nowrap'>old_atomic</span></a>
308		operations,
309		this should be included in computations.
310		If it is false, user defined atomic operations should not be done.
	323	If this external symbol is true, CppAD will use its user defined
	324	<a href="atomic_base.xml" target="_top"><span style='white-space: nowrap'>atomic</span></a>
	325	operation is used for the test.
	326	If no such atomic operation exists,
	327	and atomic is chosen, CppAD returns false for the test.
311	328
312	329	<br/>
313	330	<br/>

324	341	routine will be called by
325	342	the main program before any of the tests are executed.
326	343	This should make the CppAD <code><font color="blue">thread_alloc</font></code> allocator faster.
327		If it is false, standard memory allocation should be done by.
328		Otherwise the test can use special memory allocation to try
329		and improve speed.
	344	If it is false, CppAD will used standard memory allocation.
	345
	346	<br/>
	347	<br/>
	348	<b><big><a name="Sparsity Options" id="Sparsity Options">Sparsity Options</a></big></b>
	349	<br/>
	350	The following options only apply to the
	351	<a href="link_sparse_jacobian.xml" target="_top"><span style='white-space: nowrap'>sparse_jacobian</span></a>
	352	and
	353	<a href="link_sparse_hessian.xml" target="_top"><span style='white-space: nowrap'>sparse_hessian</span></a>
	354	tests.
	355	The other tests will ignore these options:
	356
	357	<br/>
	358	<br/>
	359	<b><a name="Sparsity Options.boolsparsity" id="Sparsity Options.boolsparsity">boolsparsity</a></b>
	360	<br/>
	361	If the option <code><font color="blue">boolsparsity</font></code> is present, the symbol
	362	<code><font color='blue'><pre style='display:inline'>
	363	extern bool global_boolsparsity
	364	</pre></font></code>
	365
	366	is true and otherwise it is false.
	367	If it is true, CppAD will use a
	368	<a href="glossary.xml#Sparsity Pattern.Vector of Boolean" target="_top"><span style='white-space: nowrap'>vector of bool</span></a>
	369
	370	for its sparsity patterns.
	371	Otherwise it will use a
	372	<a href="glossary.xml#Sparsity Pattern.Vector of Sets" target="_top"><span style='white-space: nowrap'>vector of sets</span></a>
	373	.
	374
	375	<br/>
	376	<br/>
	377	<b><a name="Sparsity Options.colpack" id="Sparsity Options.colpack">colpack</a></b>
	378	<br/>
	379	If the option <code><font color="blue">colpack</font></code> is present, the symbol
	380	<code><font color='blue'><pre style='display:inline'>
	381	extern bool global_colpack
	382	</pre></font></code>
	383
	384	is true and otherwise it is false.
	385	If this external symbol is true,
	386	CppAD will use <a href="colpack_prefix.xml" target="_top"><span style='white-space: nowrap'>colpack</span></a>
	387	to do the coloring
	388	for its
	389	Otherwise, it will use it's own coloring algorithm.
330	390
331	391	<br/>
332	392	<br/>
333	393	<b><big><a name="Correctness Results" id="Correctness Results">Correctness Results</a></big></b>
334	394	<br/>
335		An output line of the following form:
	395	One, but not both, of the following two output lines
336	396
337	397	<code><font color="blue"><span style='white-space: nowrap'><br/>
	398	</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>test</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>optionlist</span></font></i><font color="blue"><span style='white-space: nowrap'>_available = false<br/>
338	399	</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>test</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>optionlist</span></font></i><font color="blue"><span style='white-space: nowrap'>_ok = </span></font><i><font color="black"><span style='white-space: nowrap'>flag</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
339	400	</span></font></code>
340	401	is generated for each correctness test where

365	426
366	427	<code><font color="blue"><span style='white-space: nowrap'><br/>
367	428	</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>test</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>optionlist</span></font></i><font color="blue"><span style='white-space: nowrap'>_ok   = </span></font><i><font color="black"><span style='white-space: nowrap'>flag</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
368		</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>test</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>optionlist</span></font></i><font color="blue"><span style='white-space: nowrap'>_size = [ </span></font><i><font color="black"><span style='white-space: nowrap'>size_1</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>...</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>size_n</span></font></i><font color="blue"><span style='white-space: nowrap'> ]<br/>
369		</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>test</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>optionlist</span></font></i><font color="blue"><span style='white-space: nowrap'>_rate = [ </span></font><i><font color="black"><span style='white-space: nowrap'>rate_1</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>...</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>rate_n</span></font></i><font color="blue"><span style='white-space: nowrap'> ]<br/>
	429	</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>test</span></font></i><font color="blue"><span style='white-space: nowrap'>_size = [ </span></font><i><font color="black"><span style='white-space: nowrap'>size_1</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>...</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>size_n</span></font></i><font color="blue"><span style='white-space: nowrap'> ]<br/>
	430	</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>_</span></font><i><font color="black"><span style='white-space: nowrap'>test</span></font></i><font color="blue"><span style='white-space: nowrap'>_rate = [ </span></font><i><font color="black"><span style='white-space: nowrap'>rate_1</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>...</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>rate_n</span></font></i><font color="blue"><span style='white-space: nowrap'> ]<br/>
370	431	</span></font></code>
371	432	The values
372	433	<code><i><font color="black"><span style='white-space: nowrap'>package</span></font></i></code>

391	452	are the number of times
392	453	per second that the corresponding size problem executed.
393	454
	455	<br/>
	456	<br/>
	457	<b><a name="Speed Results.sparse_jacobian" id="Speed Results.sparse_jacobian">sparse_jacobian</a></b>
	458	<br/>
	459	The <a href="link_sparse_jacobian.xml" target="_top"><span style='white-space: nowrap'>sparse_jacobian</span></a>
	460	test has an extra output
	461	line with the following form
	462
	463	<code><font color="blue"><span style='white-space: nowrap'><br/>
	464	</span></font><i><font color="black"><span style='white-space: nowrap'>package</span></font></i><font color="blue"><span style='white-space: nowrap'>_sparse_jacobian_n_sweep = [ </span></font><i><font color="black"><span style='white-space: nowrap'>n_sweep_1</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>...</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>n_sweep_n</span></font></i><font color="blue"><span style='white-space: nowrap'> ]<br/>
	465	</span></font></code>
	466	The values
	467	<code><i><font color="black"><span style='white-space: nowrap'>n_sweep_1</span></font></i></code>
	468	, ...,
	469	<code><i><font color="black"><span style='white-space: nowrap'>n_sweep_n</span></font></i></code>
	470	are the number of
	471	sweeps (colors) used for each sparse Jacobian calculation; see
	472	<a href="sparse_jacobian.xml#n_sweep" target="_top"><span style='white-space: nowrap'>n_sweep</span></a>
	473	.
	474
	475
394	476
395	477
396	478	<br/>
397	479	<br/>
398	480	<b><big><a name="Link Functions" id="Link Functions">Link Functions</a></big></b>
399	481	<br/>
400		Each speed test defines it's own version of one of the following
401		functions that link the speed test to the main program described above:
	482	Each <a href="speed_main.xml#package" target="_top"><span style='white-space: nowrap'>package</span></a>
	483
	484	defines it's own version of one of the link functions listed below.
	485	Each of these functions links this main program to the corresponding test:
402	486	<table><tr><td align='left' valign='top'>
403	487
404	488	<a href="link_det_lu.xml" target="_top">link_det_lu</a></td><td>

-1

doc/speed_program.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Example Use of SpeedTest</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Example Use of SpeedTest"/>
7		<meta name="keywords" id="keywords" content=" Speedtest example test speed "/>
	8	<meta name="keywords" id="keywords" content=" Speedtest example test speed use of speedtest running this program output "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+11

-29

doc/speed_sacado.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Test Derivatives Using Sacado</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Test Derivatives Using Sacado"/>
7		<meta name="keywords" id="keywords" content=" speed test sacado "/>
	8	<meta name="keywords" id="keywords" content=" speed test sacado derivatives using purpose sacado_prefix running tests "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

84	85	<select onchange='choose_current0(this)'>
85	86	<option>Headings-></option>
86	87	<option>Purpose</option>
87		<option>sacado_dir</option>
	88	<option>sacado_prefix</option>
88	89	<option>Running Tests</option>
89		<option>C++ Compiler Flags</option>
90	90	<option>Contents</option>
91	91	</select>
92	92	</td>

109	109
110	110	<br/>
111	111	<br/>
112		<b><big><a name="sacado_dir" id="sacado_dir">sacado_dir</a></big></b>
	112	<b><big><a name="sacado_prefix" id="sacado_prefix">sacado_prefix</a></big></b>
113	113	<br/>
114		To run these tests, you must include the <code><font color="blue">configure</font></code> command line option
115
116		<code><font color="blue"><span style='white-space: nowrap'><br/>
117		SACADO_DIR=</span></font><i><font color="black"><span style='white-space: nowrap'>sacado_dir</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
118		</span></font></code>
119		during <a href="installunix.xml#sacado_dir" target="_top"><span style='white-space: nowrap'>installation</span></a>
	114	To run these tests,
	115	you must include the <a href="sacado_prefix.xml" target="_top"><span style='white-space: nowrap'>sacado_prefix</span></a>
	116
	117	in you <a href="cmake.xml#CMake Command" target="_top"><span style='white-space: nowrap'>cmake command</span></a>
120	118	.
121	119
122	120

126	124	<br/>
127	125	To build these speed tests, and run their correctness tests,
128	126	execute the following commands starting in the
129		<a href="installunix.xml#Work Directory" target="_top"><span style='white-space: nowrap'>work directory</span></a>
	127	<a href="cmake.xml#CMake Command.Build Directory" target="_top"><span style='white-space: nowrap'>build directory</span></a>
130	128	:
131	129
132	130	<code><font color="blue"><span style='white-space: nowrap'><br/>
133	131	cd speed/sacado<br/>
134		make test<br/>
	132	make check_speed_sacado VERBOSE=1<br/>
135	133	</span></font></code>
136	134	You can then run the corresponding speed tests
137	135	with the following command
138	136
139	137	<code><font color="blue"><span style='white-space: nowrap'><br/>
140		./sacado speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	138	./speed_sacado speed </span></font><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
141	139	</span></font></code>
142	140	where
143	141	<code><i><font color="black"><span style='white-space: nowrap'>seed</span></font></i></code>
144	142	is a positive integer.
145	143	See <a href="speed_main.xml" target="_top"><span style='white-space: nowrap'>speed_main</span></a>
146	144	for more options.
147
148		<br/>
149		<br/>
150		<b><big><a name="C++ Compiler Flags" id="C++ Compiler Flags">C++ Compiler Flags</a></big></b>
151		<br/>
152		The C++ compiler flags used to build the Sacado speed tests are
153		<code><font color="blue">
154		<pre style='display:inline'>
155		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_SACADO \
156		-DRAD_EQ_ALIAS -DRAD_AUTO_AD_Const $(CXX_FLAGS)
157		</pre>
158
159		</font></code>
160		where <code><font color="blue">CXX_FLAGS</font></code> is specified by the
161		<a href="installunix.xml#Configure" target="_top"><span style='white-space: nowrap'>configure</span></a>
162		command.
163	145
164	146	<br/>
165	147	<br/>

+11

-8

doc/speed_test.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>speed_test: Example and test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="speed_test: Example and test"/>
7		<meta name="keywords" id="keywords" content=" speed_test example test speed "/>
	8	<meta name="keywords" id="keywords" content=" speed_test example test speed speed_test: and "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

126	127	{ i = size;;
127	128	while(i)
128	129	{ --i;
129		c[i] = a[i] + b[i];
	130	c[i] = a[i] * b[i];
130	131	}
131	132	}
132	133	// teardown

141	142
142	143	// size of the test cases
143	144	std::vector<size_t> size_vec(2);
144		size_vec[0] = 10;
145		size_vec[1] = 20;
	145	size_vec[0] = 40;
	146	size_vec[1] = 80;
146	147
147		// use a small amout of time (we do not need accurate results)
148		double time_min = .2;
	148	// minimum amount of time to run test
	149	double time_min = 0.5;
149	150
150	151	// run the test cases
151	152	std::vector<size_t> rate_vec(2);

157	158
158	159	// for this case, time should be linear w.r.t size
159	160	double check = double(size_vec[1]) * time_0 / double(size_vec[0]);
160		double rel_diff = std::abs(check - time_1) / time_1;
161		ok &= (rel_diff <= .1);
	161	double rel_diff = (check - time_1) / time_1;
	162	ok &= (std::fabs(rel_diff) <= .1);
	163	if( ! ok )
	164	std::cout << std::endl << "rel_diff = " << rel_diff << std::endl;
162	165
163	166	return ok;
164	167	}

-1

doc/speed_test.xml less more

3	3	>
4	4	<head>
5	5	<title>Run One Speed Test and Return Results</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Run One Speed Test and Return Results"/>
7		<meta name="keywords" id="keywords" content=" speed_test test speed "/>
	8	<meta name="keywords" id="keywords" content=" speed_test test speed run one and return results syntax purpose motivation include vector size repeat size_vec time_min rate_vec timing example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/speed_utility.xml less more

3	3	>
4	4	<head>
5	5	<title>Speed Testing Utilities</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Speed Testing Utilities"/>
7		<meta name="keywords" id="keywords" content=" speed utility "/>
	8	<meta name="keywords" id="keywords" content=" speed testing utilities utility main program routines library source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

102	103	<table><tr><td align='left' valign='top'>
103	104
104	105	<a href="speed_main.xml" target="_top">speed_main</a></td><td>
105		Speed Testing Main Program</td></tr>
	106	Running the Speed Test Program</td></tr>
106	107	<tr><td>
107	108
108	109	</td></tr>

136	137	Sum Elements of a Matrix Times Itself</td></tr>
137	138	<tr><td>
138	139
	140	<a href="ode_evaluate.xml" target="_top">ode_evaluate</a></td><td>
	141	Evaluate a Function Defined in Terms of an ODE</td></tr>
	142	<tr><td>
	143
139	144	<a href="sparse_jac_fun.xml" target="_top">sparse_jac_fun</a></td><td>
140	145	Evaluate a Function That Has a Sparse Jacobian</td></tr>
141	146	<tr><td>

-1

doc/speedtest.xml less more

3	3	>
4	4	<head>
5	5	<title>Run One Speed Test and Print Results</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Run One Speed Test and Print Results"/>
7		<meta name="keywords" id="keywords" content=" Speedtest test speed "/>
	8	<meta name="keywords" id="keywords" content=" Speedtest test speed run one and print results syntax purpose motivation include size repeat name first last inc rate errors example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sqrt.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD sqrt Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD sqrt Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" sqrt Ad example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad sqrt function: example and test Ad "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/sqrtforward.xml less more

3	3	>
4	4	<head>
5	5	<title>Square Root Function Forward Taylor Polynomial Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Square Root Function Forward Taylor Polynomial Theory"/>
7		<meta name="keywords" id="keywords" content=" sqrt forward theory "/>
	8	<meta name="keywords" id="keywords" content=" sqrt forward theory square root function taylor polynomial "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinForward</option>
77	78	<option>AcosForward</option>
78	79	<option>tan_forward</option>
	80	<option>erf_forward</option>
79	81	</select>
80	82	</td>
81	83	<td>SqrtForward</td>

481	483	</mrow></math>
482	484
483	485
484		<hr/>Input File: omh/sqrt_forward.omh
	486	<hr/>Input File: omh/theory/sqrt_forward.omh
485	487
486	488	</body>
487	489	</html>

-2

doc/sqrtreverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Square Root Function Reverse Mode Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Square Root Function Reverse Mode Theory"/>
7		<meta name="keywords" id="keywords" content=" sqrt reverse theory "/>
	8	<meta name="keywords" id="keywords" content=" sqrt reverse theory square root function mode "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

76	77	<option>AsinReverse</option>
77	78	<option>AcosReverse</option>
78	79	<option>tan_reverse</option>
	80	<option>erf_reverse</option>
79	81	</select>
80	82	</td>
81	83	<td>SqrtReverse</td>

642	644	</mrow></math>
643	645
644	646
645		<hr/>Input File: omh/sqrt_reverse.omh
	647	<hr/>Input File: omh/theory/sqrt_reverse.omh
646	648
647	649	</body>
648	650	</html>

-1

doc/stack_machine.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Example Differentiating a Stack Machine Interpreter</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Example Differentiating a Stack Machine Interpreter"/>
7		<meta name="keywords" id="keywords" content=" interpreter example test "/>
	8	<meta name="keywords" id="keywords" content=" example differentiating a stack machine interpreter test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/std_math_ad.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Standard Math Unary Functions</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Standard Math Unary Functions"/>
7		<meta name="keywords" id="keywords" content=" standard Ad math unary acos asin atan cos cosh exp fabs log log10 sin sinh sqrt tan tanh "/>
	8	<meta name="keywords" id="keywords" content=" standard Ad math unary acos asin atan cos cosh exp fabs log log10 sin sinh sqrt tan tanh ad functions syntax purpose x y operation sequence fun examples derivatives "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sub.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Binary Subtraction: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Binary Subtraction: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" - Ad example subtract minus test "/>
	8	<meta name="keywords" id="keywords" content=" ad binary subtraction: example and test - Ad subtract minus "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/sub_eq.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Computed Assignment Subtraction: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Computed Assignment Subtraction: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" -= Ad example computed assignment subtract test assign plus add "/>
	8	<meta name="keywords" id="keywords" content=" ad computed assignment subtraction: example and test -= Ad subtract assign plus add "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ta_available.xml less more

3	3	>
4	4	<head>
5	5	<title>Amount of Memory Available for Quick Use by a Thread</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Amount of Memory Available for Quick Use by a Thread"/>
7		<meta name="keywords" id="keywords" content=" available thread_alloc memory thread "/>
	8	<meta name="keywords" id="keywords" content=" amount of memory available for quick use by a thread thread_alloc syntax purpose num_bytes example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+14

-1

doc/ta_create_array.xml less more

3	3	>
4	4	<head>
5	5	<title>Allocate An Array and Call Default Constructor for its Elements</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Allocate An Array and Call Default Constructor for its Elements"/>
7		<meta name="keywords" id="keywords" content=" create_array thread_alloc array allocate "/>
	8	<meta name="keywords" id="keywords" content=" allocate an array and call default constructor for its elements create_array thread_alloc syntax purpose type size_min size_out delta alignment example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

118	119	<option>size_out</option>
119	120	<option>array</option>
120	121	<option>Delta</option>
	122	<option>Alignment</option>
121	123	<option>Example</option>
122	124	</select>
123	125	</td>

232	234
233	235	<br/>
234	236	<br/>
	237	<b><big><a name="Alignment" id="Alignment">Alignment</a></big></b>
	238	<br/>
	239	We call a memory allocation aligned if the address is a multiple
	240	of the number of bytes in a <code><font color="blue">size_t</font></code> value.
	241	If the system <code><font color="blue">new</font></code> allocator is aligned, then
	242	<code><i><font color="black"><span style='white-space: nowrap'>array</span></font></i></code>
	243
	244	pointer is also aligned.
	245
	246	<br/>
	247	<br/>
235	248	<b><big><a name="Example" id="Example">Example</a></big></b>
236	249
237	250	<br/>

-1

doc/ta_delete_array.xml less more

3	3	>
4	4	<head>
5	5	<title>Deallocate An Array and Call Destructor for its Elements</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Deallocate An Array and Call Destructor for its Elements"/>
7		<meta name="keywords" id="keywords" content=" delete_array thread_alloc array allocate "/>
	8	<meta name="keywords" id="keywords" content=" deallocate an array and call destructor for its elements delete_array thread_alloc allocate syntax purpose type thread delta example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ta_free_all.xml less more

3	3	>
4	4	<head>
5	5	<title>Free All Memory That Was Allocated for Use by thread_alloc</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Free All Memory That Was Allocated for Use by thread_alloc"/>
7		<meta name="keywords" id="keywords" content=" free all thread_alloc "/>
	8	<meta name="keywords" id="keywords" content=" free all memory that was allocated for use by thread_alloc syntax purpose ok restrictions example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ta_free_available.xml less more

3	3	>
4	4	<head>
5	5	<title>Free Memory Currently Available for Quick Use by a Thread</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Free Memory Currently Available for Quick Use by a Thread"/>
7		<meta name="keywords" id="keywords" content=" free_available thread_alloc free available thread memory "/>
	8	<meta name="keywords" id="keywords" content=" free memory currently available for quick use by a thread free_available thread_alloc syntax purpose extra example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+14

-1

doc/ta_get_memory.xml less more

3	3	>
4	4	<head>
5	5	<title>Get At Least A Specified Amount of Memory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Get At Least A Specified Amount of Memory"/>
7		<meta name="keywords" id="keywords" content=" thread_num thread_alloc memory allocate "/>
	8	<meta name="keywords" id="keywords" content=" get at least a specified amount of memory thread_num thread_alloc allocate syntax purpose min_bytes cap_bytes v_ptr allocation speed alignment example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

117	118	<option>cap_bytes</option>
118	119	<option>v_ptr</option>
119	120	<option>Allocation Speed</option>
	121	<option>Alignment</option>
120	122	<option>Example</option>
121	123	</select>
122	124	</td>

212	214
213	215	<br/>
214	216	<br/>
	217	<b><big><a name="Alignment" id="Alignment">Alignment</a></big></b>
	218	<br/>
	219	We call a memory allocation aligned if the address is a multiple
	220	of the number of bytes in a <code><font color="blue">size_t</font></code> value.
	221	If the system <code><font color="blue">new</font></code> allocator is aligned, then
	222	<code><i><font color="black"><span style='white-space: nowrap'>v_ptr</span></font></i></code>
	223
	224	pointer is also aligned.
	225
	226	<br/>
	227	<br/>
215	228	<b><big><a name="Example" id="Example">Example</a></big></b>
216	229
217	230	<br/>

-1

doc/ta_hold_memory.xml less more

3	3	>
4	4	<head>
5	5	<title>Control When Thread Alloc Retains Memory For Future Use</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Control When Thread Alloc Retains Memory For Future Use"/>
7		<meta name="keywords" id="keywords" content=" thread_alloc hold memory "/>
	8	<meta name="keywords" id="keywords" content=" control when thread alloc retains memory for future use thread_alloc hold syntax purpose value free_available "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ta_in_parallel.xml less more

3	3	>
4	4	<head>
5	5	<title>Is The Current Execution in Parallel Mode</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Is The Current Execution in Parallel Mode"/>
7		<meta name="keywords" id="keywords" content=" in_parallel thread_alloc parallel execution sequential "/>
	8	<meta name="keywords" id="keywords" content=" is the current execution in parallel mode in_parallel thread_alloc sequential syntax purpose flag example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ta_inuse.xml less more

3	3	>
4	4	<head>
5	5	<title>Amount of Memory a Thread is Currently Using</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Amount of Memory a Thread is Currently Using"/>
7		<meta name="keywords" id="keywords" content=" inuse thread_alloc use memory thread "/>
	8	<meta name="keywords" id="keywords" content=" amount of memory a thread is currently using inuse thread_alloc use syntax purpose num_bytes example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ta_num_threads.xml less more

3	3	>
4	4	<head>
5	5	<title>Get Number of Threads</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Get Number of Threads"/>
7		<meta name="keywords" id="keywords" content=" num_threads thread_alloc threads number of "/>
	8	<meta name="keywords" id="keywords" content=" get number of threads num_threads thread_alloc syntax purpose example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ta_parallel_setup.xml less more

3	3	>
4	4	<head>
5	5	<title>Setup thread_alloc For Use in Multi-Threading Environment</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Setup thread_alloc For Use in Multi-Threading Environment"/>
7		<meta name="keywords" id="keywords" content=" setup thread_alloc parallel num_threads in_parallel thread_num multi-threading initialize "/>
	8	<meta name="keywords" id="keywords" content=" setup thread_alloc for use in multi-threading environment parallel num_threads in_parallel thread_num initialize syntax purpose speed restrictions example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ta_return_memory.xml less more

3	3	>
4	4	<head>
5	5	<title>Return Memory to thread_alloc</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Return Memory to thread_alloc"/>
7		<meta name="keywords" id="keywords" content=" return_memory thread_alloc memory available thread "/>
	8	<meta name="keywords" id="keywords" content=" return memory to thread_alloc return_memory available thread syntax purpose v_ptr ndebug example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/ta_thread_num.xml less more

3	3	>
4	4	<head>
5	5	<title>Get the Current Thread Number</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Get the Current Thread Number"/>
7		<meta name="keywords" id="keywords" content=" thread_num thread_alloc thread current "/>
	8	<meta name="keywords" id="keywords" content=" get the current thread number thread_num thread_alloc syntax purpose example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/tan.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD tan Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD tan Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" tan example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad tan function: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-7

doc/tan_forward.xml less more

3	3	>
4	4	<head>
5	5	<title>Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory"/>
7		<meta name="keywords" id="keywords" content=" tan forward theory "/>
	8	<meta name="keywords" id="keywords" content=" tan forward theory tangent and hyperbolic taylor polynomial derivatives coefficients recursion "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="acosforward.xml" target="_top">Prev</a>
24		</td><td><a href="reversetheory.xml" target="_top">Next</a>
	25	</td><td><a href="erf_forward.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

76	77	<option>AsinForward</option>
77	78	<option>AcosForward</option>
78	79	<option>tan_forward</option>
	80	<option>erf_forward</option>
79	81	</select>
80	82	</td>
81	83	<td>tan_forward</td>

610	612	<msup><mi mathvariant='italic'>z</mi>
611	613	<mrow><mo stretchy="false">(</mo>
612	614	<mi mathvariant='italic'>j</mi>
613		<mo stretchy="false">+</mo>
614		<mn>1</mn>
615	615	<mo stretchy="false">)</mo>
616	616	</mrow>
617	617	</msup>

623	623	<msup><mi mathvariant='italic'>y</mi>
624	624	<mrow><mo stretchy="false">(</mo>
625	625	<mi mathvariant='italic'>j</mi>
626		<mo stretchy="false">+</mo>
627		<mn>1</mn>
628	626	<mo stretchy="false">)</mo>
629	627	</mrow>
630	628	</msup>

664	662	</mrow></math>
665	663
666	664
667		<hr/>Input File: omh/tan_forward.omh
	665	<hr/>Input File: omh/theory/tan_forward.omh
668	666
669	667	</body>
670	668	</html>

-15

doc/tan_reverse.xml less more

3	3	>
4	4	<head>
5	5	<title>Tangent and Hyperbolic Tangent Reverse Mode Theory</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Tangent and Hyperbolic Tangent Reverse Mode Theory"/>
7		<meta name="keywords" id="keywords" content=" tan reverse theory "/>
	8	<meta name="keywords" id="keywords" content=" tan reverse theory tangent and hyperbolic mode notation eliminating y(t) positive orders z(t) order zero "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="acosreverse.xml" target="_top">Prev</a>
24		</td><td><a href="reverse_identity.xml" target="_top">Next</a>
	25	</td><td><a href="erf_reverse.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

76	77	<option>AsinReverse</option>
77	78	<option>AcosReverse</option>
78	79	<option>tan_reverse</option>
	80	<option>erf_reverse</option>
79	81	</select>
80	82	</td>
81	83	<td>tan_reverse</td>

568	570	<mi mathvariant='italic'>k</mi>
569	571	<mo stretchy="false">)</mo>
570	572	<mo stretchy="false">±</mo>
571		<mfrac><mrow><mo stretchy="false">∂</mo>
572		<mi mathvariant='italic'>G</mi>
573		</mrow>
574		<mrow><mo stretchy="false">∂</mo>
575		<msup><mi mathvariant='italic'>z</mi>
576		<mrow><mo stretchy="false">(</mo>
577		<mi mathvariant='italic'>j</mi>
578		<mo stretchy="false">)</mo>
579		</mrow>
580		</msup>
581		</mrow>
582		</mfrac>
583	573	<mfrac><mrow><mi mathvariant='italic'>k</mi>
584	574	</mrow>
585	575	<mrow><mi mathvariant='italic'>j</mi>

930	920	</mrow></math>
931	921
932	922
933		<hr/>Input File: omh/tan_reverse.omh
	923	<hr/>Input File: omh/theory/tan_reverse.omh
934	924
935	925	</body>
936	926	</html>

-1

doc/tanh.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>The AD tanh Function: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The AD tanh Function: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" tanh example test "/>
	8	<meta name="keywords" id="keywords" content=" the ad tanh function: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/tape_index.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Taping Array Index Operation: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Taping Array Index Operation: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" array tape index operation "/>
	8	<meta name="keywords" id="keywords" content=" taping array index operation: example and test tape operation "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/team_bthread.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Boost Thread Implementation of a Team of AD Threads</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Boost Thread Implementation of a Team of AD Threads"/>
7		<meta name="keywords" id="keywords" content=" bthread Ad team "/>
	8	<meta name="keywords" id="keywords" content=" bthread Ad team boost thread implementation of a ad threads "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/team_example.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Using a Team of AD Threads: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using a Team of AD Threads: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" thread team example Ad "/>
	8	<meta name="keywords" id="keywords" content=" using a team of ad threads: example and test thread Ad purpose thread_team source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/team_openmp.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>OpenMP Implementation of a Team of AD Threads</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="OpenMP Implementation of a Team of AD Threads"/>
7		<meta name="keywords" id="keywords" content=" openmp Ad team "/>
	8	<meta name="keywords" id="keywords" content=" openmp Ad team implementation of a ad threads "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/team_pthread.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Pthread Implementation of a Team of AD Threads</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Pthread Implementation of a Team of AD Threads"/>
7		<meta name="keywords" id="keywords" content=" pthread Ad team bug cygwin pthread_exit in "/>
	8	<meta name="keywords" id="keywords" content=" pthread Ad team implementation of a ad threads bug in cygwin pthread_exit "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/team_thread.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Specifications for A Team of AD Threads</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Specifications for A Team of AD Threads"/>
7		<meta name="keywords" id="keywords" content=" thread Ad team threads "/>
	8	<meta name="keywords" id="keywords" content=" specifications for a team of ad threads thread Ad syntax purpose restrictions team_create team_work team_destroy team_name ok example use implementation speed test source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/test_vector.xml less more

3	3	>
4	4	<head>
5	5	<title>Choosing The Vector Testing Template Class</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Choosing The Vector Testing Template Class"/>
7		<meta name="keywords" id="keywords" content=" Cppad_test_vector vector test deprecated "/>
	8	<meta name="keywords" id="keywords" content=" Cppad_test_vector vector test choosing the testing template class deprecated syntax introduction ms windows cppad::vector std::vector boost::numeric::ublas::vector cppadvector "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/testvector.xml less more

3	3	>
4	4	<head>
5	5	<title>Using The CppAD Test Vector Template Class</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Using The CppAD Test Vector Template Class"/>
7		<meta name="keywords" id="keywords" content=" Cppad_testvector vector test "/>
	8	<meta name="keywords" id="keywords" content=" Cppad_testvector vector test using the cppad template class syntax introduction cppad::vector std::vector boost::numeric::ublas::vector eigen vectors "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-2

doc/theory.xml less more

3	3	>
4	4	<head>
5	5	<title>The Theory of Derivative Calculations</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The Theory of Derivative Calculations"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" the theory of derivative calculations "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

96	97	<a href="reversetheory.xml" target="_top">The Theory of Reverse Mode</a><br/>
97	98	<a href="reverse_identity.xml" target="_top">An Important Reverse Mode Identity</a><br/>
98	99	</div>
99		<hr/>Input File: omh/theory.omh
	100	<hr/>Input File: omh/theory/theory.omh
100	101
101	102	</body>
102	103	</html>

+54

-2

doc/thread_alloc.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Fast Multi-Threading Memory Allocator: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Fast Multi-Threading Memory Allocator: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" openmp memory allocation pthread boost multi-thread example test "/>
	8	<meta name="keywords" id="keywords" content=" fast multi-threading memory allocator: example and test openmp allocation pthread boost multi-thread "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

115	116	# include <cppad/thread_alloc.hpp>
116	117	# include <cppad/memory_leak.hpp>
117	118	# include <vector>
	119	# include <limits>
118	120
119	121
120	122	namespace { // Begin empty namespace
	123
	124
121	125
122	126	bool raw_allocate(void)
123	127	{ bool ok = true;

243	247
244	248	} // End empty namespace
245	249
	250	bool check_alignment(void)
	251	{ bool ok = true;
	252	using CppAD::thread_alloc;
	253
	254	// number of binary digits in a size_t value
	255	size_t n_digit = std::numeric_limits<size_t>::digits;
	256
	257	// must be a multiple of 8
	258	ok &= (n_digit % 8) == 0;
	259
	260	// number of bytes in a size_t value
	261	size_t n_byte = n_digit / 8;
	262
	263	// check raw allocation -------------------------------------------------
	264	size_t min_bytes = 1;
	265	size_t cap_bytes;
	266	void* v_ptr = thread_alloc::get_memory(min_bytes, cap_bytes);
	267
	268	// convert to a size_t value
	269	size_t v_size_t = reinterpret_cast<size_t>(v_ptr);
	270
	271	// check that it is aligned
	272	ok &= (v_size_t % n_byte) == 0;
	273
	274	// return memory to available pool
	275	thread_alloc::return_memory(v_ptr);
	276
	277	// check array allocation ----------------------------------------------
	278	size_t size_min = 1;
	279	size_t size_out;
	280	my_char *array_ptr =
	281	thread_alloc::create_array<my_char>(size_min, size_out);
	282
	283	// convert to a size_t value
	284	size_t array_size_t = reinterpret_cast<size_t>(array_ptr);
	285
	286	// check that it is aligned
	287	ok &= (array_size_t % n_byte) == 0;
	288
	289	// return memory to avialable pool
	290	thread_alloc::delete_array(array_ptr);
	291
	292	return ok;
	293	}
	294
246	295
247	296	bool thread_alloc(void)
248	297	{ bool ok = true;

264	313
265	314	// run typed allocation tests
266	315	ok &= type_allocate();
267
	316
	317	// check alignment
	318	ok &= check_alignment();
	319
268	320	// return allocator to its default mode
269	321	thread_alloc::hold_memory(false);
270	322	return ok;

-1

doc/thread_alloc.xml less more

3	3	>
4	4	<head>
5	5	<title>A Fast Multi-Threading Memory Allocator</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="A Fast Multi-Threading Memory Allocator"/>
7		<meta name="keywords" id="keywords" content=" multi-threading memory allocation "/>
	8	<meta name="keywords" id="keywords" content=" a fast multi-threading memory allocator allocation syntax purpose include "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-6

doc/thread_test.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Run Multi-Threading Examples and Speed Tests</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Run Multi-Threading Examples and Speed Tests"/>
7		<meta name="keywords" id="keywords" content=" thread_test example speed thread multi openmp run tests pthread bthread "/>
	8	<meta name="keywords" id="keywords" content=" thread_test example speed thread multi run multi-threading examples and tests syntax running threading openmp pthread bthread purpose a11c simple_ad team_example harmonic test_time max_threads mega_sum multi_newton num_zero num_sub num_sum use_ad team implementations source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

120	121
121	122	<br/>
122	123
123		<code><font color="blue"><span style='white-space: nowrap'>./</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'>_test a11c<br/>
124		./</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'>_test simple_ad<br/>
125		./</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'>_test team_example<br/>
126		./</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'>_test harmonic </span></font><i><font color="black"><span style='white-space: nowrap'>test_time</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>max_threads</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>mega_sum</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
127		./</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'>_test multi_newton </span></font><i><font color="black"><span style='white-space: nowrap'>test_time</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>max_threads</span></font></i><font color="blue"><span style='white-space: nowrap'> \<br/>
	124	<code><font color="blue"><span style='white-space: nowrap'>./multi_thread_</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'> a11c<br/>
	125	./multi_thread_</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'> simple_ad<br/>
	126	./multi_thread_</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'> team_example<br/>
	127	./multi_thread_</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'> harmonic </span></font><i><font color="black"><span style='white-space: nowrap'>test_time</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>max_threads</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>mega_sum</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	128	./multi_thread_</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'> multi_newton </span></font><i><font color="black"><span style='white-space: nowrap'>test_time</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>max_threads</span></font></i><font color="blue"><span style='white-space: nowrap'> \<br/>
128	129	</span></font><i><font color="black"><span style='white-space: nowrap'>num_zero</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>num_sub</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>num_sum</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>use_ad</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
129	130	</span></font></code>
130	131	<br/>

-1

doc/time_det_by_minor_c.xml less more

3	3	>
4	4	<head>
5	5	<title>Determine Amount of Time to Execute det_by_minor</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determine Amount of Time to Execute det_by_minor"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" determine amount of time to execute det_by_minor syntax purpose time_min source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+10

-7

doc/time_test.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>time_test: Example and test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="time_test: Example and test"/>
7		<meta name="keywords" id="keywords" content=" time_test example test time "/>
	8	<meta name="keywords" id="keywords" content=" time_test example test time time_test: and "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

131	132	{ i = size_;
132	133	while(i)
133	134	{ --i;
134		c[i] = a[i] + b[i];
	135	c[i] = a[i] * b[i];
135	136	}
136	137	}
137	138	// teardown

144	145	bool time_test(void)
145	146	{ bool ok = true;
146	147
147		// use a small amount of time (we do not need accurate results)
148		double time_min = .2;
	148	// minimum amount of time to run test
	149	double time_min = 0.5;
149	150
150	151	// size of first test case
151		size_ = 10;
	152	size_ = 20;
152	153
153	154	// run the first test case
154	155	double time_first = CppAD::time_test(test, time_min);

160	161	double time_second = CppAD::time_test(test, time_min);
161	162
162	163	// for this case, time should be linear w.r.t size
163		double rel_diff = std::abs(1. - 2. * time_first / time_second );
164		ok &= (rel_diff <= .1);
	164	double rel_diff = 1. - 2. * time_first / time_second;
	165	ok &= (std::fabs(rel_diff) <= .1);
	166	if( ! ok )
	167	std::cout << std::endl << "rel_diff = " << rel_diff << std::endl;
165	168
166	169	return ok;
167	170	}

-1

doc/time_test.xml less more

3	3	>
4	4	<head>
5	5	<title>Determine Amount of Time to Execute a Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Determine Amount of Time to Execute a Test"/>
7		<meta name="keywords" id="keywords" content=" time_test test speed time "/>
	8	<meta name="keywords" id="keywords" content=" time_test test speed time determine amount of to execute a syntax purpose motivation include size repeat time_min test_size timing example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/tracknewdel.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Tracking Use of New and Delete: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Tracking Use of New and Delete: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" new example test delete "/>
	8	<meta name="keywords" id="keywords" content=" tracking use of new and delete: example test delete "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/tracknewdel.xml less more

3	3	>
4	4	<head>
5	5	<title>Routines That Track Use of New and Delete</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Routines That Track Use of New and Delete"/>
7		<meta name="keywords" id="keywords" content=" new track delete and memory deprecated Tracknewvec Ndebug Cppad_track_new_vec Cppadtracknewvec Trackdelvec Cppad_track_del_vec Cppadtrackdelvec Trackextend Cppad_track_extend Cppadtrackextend Trackcount Cppad_track_count multi-threading thread multi "/>
	8	<meta name="keywords" id="keywords" content=" routines that track use of new and delete memory deprecated syntax purpose include file line oldptr newlen head newptr ncopy tracknewvec Tracknewvec Ndebug macro Cppad_track_new_vec previously Cppadtracknewvec trackdelvec Trackdelvec Cppad_track_del_vec Cppadtrackdelvec trackextend Trackextend Cppad_track_extend Cppadtrackextend trackcount Trackcount Cppad_track_count multi-threading thread multi example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/unary_minus.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Unary Minus Operator: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Unary Minus Operator: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" unary minus example test "/>
	8	<meta name="keywords" id="keywords" content=" ad unary minus operator: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/unary_plus.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Unary Plus Operator: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Unary Plus Operator: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" unary plus example test "/>
	8	<meta name="keywords" id="keywords" content=" ad unary plus operator: example and test "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/unaryminus.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Unary Minus Operator</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Unary Minus Operator"/>
7		<meta name="keywords" id="keywords" content=" unary Ad minus operator - "/>
	8	<meta name="keywords" id="keywords" content=" unary Ad minus operator - ad syntax purpose base x y operation sequence derivative example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/unaryplus.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Unary Plus Operator</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Unary Plus Operator"/>
7		<meta name="keywords" id="keywords" content=" unary Ad plus operator + "/>
	8	<meta name="keywords" id="keywords" content=" unary Ad plus operator + ad syntax purpose x y operation sequence derivative example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/uniform_01.hpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Source: uniform_01</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Source: uniform_01"/>
7		<meta name="keywords" id="keywords" content=" uniform_01 source "/>
	8	<meta name="keywords" id="keywords" content=" source: uniform_01 source "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/uniform_01.xml less more

3	3	>
4	4	<head>
5	5	<title>Simulate a [0,1] Uniform Random Variate</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Simulate a [0,1] Uniform Random Variate"/>
7		<meta name="keywords" id="keywords" content=" uniform_01 random uniform vector "/>
	8	<meta name="keywords" id="keywords" content=" simulate a [01] uniform random variate uniform_01 vector syntax purpose inclusion seed n x source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/uniform_01_c.xml less more

3	3	>
4	4	<head>
5	5	<title>Simulate a [0,1] Uniform Random Variate</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Simulate a [0,1] Uniform Random Variate"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" simulate a [01] uniform random variate syntax purpose seed n source code "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/value.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Convert From AD to its Base Type: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Convert From AD to its Base Type: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Value example test record "/>
	8	<meta name="keywords" id="keywords" content=" convert from ad to its base type: example and test Value record "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/value.xml less more

3	3	>
4	4	<head>
5	5	<title>Convert From an AD Type to its Base Type</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Convert From an AD Type to its Base Type"/>
7		<meta name="keywords" id="keywords" content=" Value Base from Ad convert to "/>
	8	<meta name="keywords" id="keywords" content=" Value Base from Ad convert to an ad type its base syntax purpose x b operation sequence restriction example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/var2par.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>Convert an AD Variable to a Parameter: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Convert an AD Variable to a Parameter: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Var2par example test Value during taping "/>
	8	<meta name="keywords" id="keywords" content=" convert an ad variable to a parameter: example and test Var2par Value during taping "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/var2par.xml less more

3	3	>
4	4	<head>
5	5	<title>Convert an AD Variable to a Parameter</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Convert an AD Variable to a Parameter"/>
7		<meta name="keywords" id="keywords" content=" Var2par variable convert to parameter from value_ obtain during taping "/>
	8	<meta name="keywords" id="keywords" content=" Var2par variable convert to parameter from value_ obtain during taping an ad a syntax purpose x y example "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-1

doc/vec_ad.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Vectors that Record Index Operations: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Vectors that Record Index Operations: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" Vecad example test vec_ad.cpp "/>
	8	<meta name="keywords" id="keywords" content=" ad vectors that record index operations: example and test Vecad vec_ad.cpp "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

+27

-21

doc/vecad.xml less more

3	3	>
4	4	<head>
5	5	<title>AD Vectors that Record Index Operations</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="AD Vectors that Record Index Operations"/>
7		<meta name="keywords" id="keywords" content=" Vecad vector Ad index record tape Vecad<base>::reference reference Vecad<base> "/>
	8	<meta name="keywords" id="keywords" content=" Vecad vector Ad index record tape ad vectors that operations syntax purpose alternatives vecad<base>::reference Vecad<base>::reference reference Vecad<base> exceptions constructor v n size size_t indexing i b x r example speed and memory "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

127	128	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>v</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>]</span></font></code>
128	129
129	130
130
131	131	<br/>
132	132	<br/>
133	133	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>

142	142	the indexing operation
143	143
144	144	<code><font color="blue"><span style='white-space: nowrap'><br/>
145		</span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>v</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>]<br/>
	145	</span></font><i><font color="black"><span style='white-space: nowrap'>r</span></font></i><font color="blue"><span style='white-space: nowrap'> = </span></font><i><font color="black"><span style='white-space: nowrap'>v</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>]<br/>
146	146	</span></font></code>
147	147	is recorded in the corresponding
148	148	AD of

201	201
202	202	<br/>
203	203	The result
204		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
	204	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i></code>
205	205	has type
206	206
207	207	<code><font color="blue"><span style='white-space: nowrap'><br/>

218	218
219	219	<ol type="1"><li>
220	220	The object
221		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
	221	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i></code>
222	222	cannot be used with the
223	223	<a href="value.xml" target="_top"><span style='white-space: nowrap'>Value</span></a>
224	224	function to compute the corresponding

226	226	value.
227	227	If
228	228	<code><i><font color="black"><span style='white-space: nowrap'>v</span></font></i></code>
229		is not a <a href="glossary.xml#Variable" target="_top"><span style='white-space: nowrap'>variable</span></a>
230
231
232		<code><font color="blue"><span style='white-space: nowrap'><br/>
233		v[</span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'>]<br/>
	229	and
	230	<code><i><font color="black"><span style='white-space: nowrap'>i</span></font></i></code>
	231	are not <a href="glossary.xml#Variable" target="_top"><span style='white-space: nowrap'>variables</span></a>
	232
	233
	234	<code><font color="blue"><span style='white-space: nowrap'><br/>
	235	</span></font><i><font color="black"><span style='white-space: nowrap'>b</span></font></i><font color="blue"><span style='white-space: nowrap'> = v[</span></font><i><font color="black"><span style='white-space: nowrap'>i</span></font></i><font color="blue"><span style='white-space: nowrap'>]<br/>
234	236	</span></font></code>
235	237	can be used to compute the corresponding
236	238	<code><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i></code>

239	241	</li><li>
240	242
241	243	The object
242		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
	244	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i></code>
243	245	cannot be used
244	246	with the <a href="arithmetic.xml" target="_top"><span style='white-space: nowrap'>computed assignments operators</span></a>
245	247

259	261	</li><li>
260	262
261	263	Assignment to
262		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
	264	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i></code>
263	265	returns a <code><font color="blue">void</font></code>.
264	266	For example, the following syntax is not valid:
265	267

282	284	For example, the following syntax is not valid:
283	285
284	286	<code><font color="blue"><span style='white-space: nowrap'><br/>
285		CondExpGt(</span></font><i><font color="black"><span style='white-space: nowrap'>y</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>z</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>u</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>v</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
	287	CondExpGt(</span></font><i><font color="black"><span style='white-space: nowrap'>v</span></font></i><font color="blue"><span style='white-space: nowrap'>[</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>], </span></font><i><font color="black"><span style='white-space: nowrap'>z</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>u</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>v</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
286	288	</span></font></code>
287	289	no matter what the types of
288	290	<code><i><font color="black"><span style='white-space: nowrap'>z</span></font></i></code>

298	300	functions cannot be used with
299	301
300	302	<code><font color="blue"><span style='white-space: nowrap'>VecAD<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>>::reference</span></font></code>
301		arguments
302		(use the entire
	303	arguments like
	304	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i></code>
	305	,
	306	use the entire
303	307	<code><font color="blue"><span style='white-space: nowrap'>VecAD<</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'>></span></font></code>
304		vector instead).
	308	vector instead; i.e.
	309	<code><i><font color="black"><span style='white-space: nowrap'>v</span></font></i></code>
	310	.
305	311
306	312	</li><li>
307	313

428	434	<code><font color="blue"><span style='white-space: nowrap'><br/>
429	435	</span></font><i><font color="black"><span style='white-space: nowrap'>Base</span></font></i><font color="blue"><span style='white-space: nowrap'> </span></font><i><font color="black"><span style='white-space: nowrap'>b</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
430	436	</span></font></code>
431		and is a reference to the <i>i</i>-th element in the vector
	437	and is a reference to the <code><i>i</i></code>-th element in the vector
432	438	<code><i><font color="black"><span style='white-space: nowrap'>v</span></font></i></code>
433	439	.
434	440	It can be used to change the element value;

489	495	<b><a name="AD Indexing.r" id="AD Indexing.r">r</a></b>
490	496	<br/>
491	497	The result
492		<code><i><font color="black"><span style='white-space: nowrap'>y</span></font></i></code>
	498	<code><i><font color="black"><span style='white-space: nowrap'>r</span></font></i></code>
493	499	has prototype
494	500
495	501	<code><font color="blue"><span style='white-space: nowrap'><br/>

583	589	The effect of this can be seen by executing the following steps:
584	590
585	591	<ol type="1"><li>
586		In the file <code><font color="blue">cppad/local/forward_sweep.h</font></code>,
587		change the definition of <code><font color="blue">CPPAD_FORWARD_SWEEP_TRACE</font></code> to
	592	In the file <code><font color="blue">cppad/local/forward1sweep.h</font></code>,
	593	change the definition of <code><font color="blue">CPPAD_FORWARD1SWEEP_TRACE</font></code> to
588	594	<code><font color='blue'><pre style='display:inline'>
589		# define CPPAD_FORWARD_SWEEP_TRACE 1
	595	# define CPPAD_FORWARD1SWEEP_TRACE 1
590	596	</pre></font></code>
591	597
592	598	</li><li>

-1

doc/vector_bool.cpp.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD::vectorBool Class: Example and Test</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD::vectorBool Class: Example and Test"/>
7		<meta name="keywords" id="keywords" content=" bool Cppad::vector vectorbool Cppad Cppad::vectorbool example test "/>
	8	<meta name="keywords" id="keywords" content=" cppad::vectorbool class: example and test bool Cppad::vector vectorbool Cppad Cppad::vectorbool "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

-3

doc/whats_new.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad introduction this year previous years "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23	24	<td><a href="wishlist.xml" target="_top">Prev</a>
24		</td><td><a href="whats_new_13.xml" target="_top">Next</a>
	25	</td><td><a href="whats_new_14.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>
27	28	<option>Index-></option>

74	75	<td>
75	76	<select onchange='choose_down0(this)'>
76	77	<option>whats_new-></option>
	78	<option>whats_new_14</option>
77	79	<option>whats_new_13</option>
78	80	<option>whats_new_12</option>
79	81	<option>whats_new_11</option>

115	117	<b><big><a name="This Year" id="This Year">This Year</a></big></b>
116	118
117	119	<br/>
118		<a href="whats_new_13.xml" target="_top"><span style='white-space: nowrap'>whats_new_13</span></a>
	120	<a href="whats_new_14.xml" target="_top"><span style='white-space: nowrap'>whats_new_14</span></a>
119	121
120	122
121	123	<br/>

123	125	<b><big><a name="Previous Years" id="Previous Years">Previous Years</a></big></b>
124	126
125	127	<br/>
	128	<a href="whats_new_13.xml" target="_top"><span style='white-space: nowrap'>whats_new_13</span></a>
	129
126	130	<a href="whats_new_12.xml" target="_top"><span style='white-space: nowrap'>whats_new_12</span></a>
127	131
128	132	<a href="whats_new_11.xml" target="_top"><span style='white-space: nowrap'>whats_new_11</span></a>

-1

doc/whats_new_03.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD During 2003</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2003"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2003 introduction 12-24 12-22 12-14 12-13 12-12 12-10 12-05 12-01 11-21 11-20 11-16 11-15 11-14 11-12 11-11 11-06 11-04 11-02 10-21 10-16 10-14 10-10 10-06 10-05 09-30 09-20 09-19 09-18 09-15 09-14 09-13 09-06 09-05 09-04 09-03 08-23 08-22 08-19 08-17 08-16 08-11 08-10 08-07 08-06 08-05 08-04 08-03 08-01 07-30 07-29 07-26 07-22 07-20 07-18 07-16 07-14 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

-2

doc/whats_new_04.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD During 2004</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2004"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2004 introduction 12-11 12-09 12-03 11-17 11-16 11-15 11-14 11-13 11-12 11-10 11-04 11-02 11-01 10-29 10-28 10-27 10-21 10-19 10-16 10-06 09-29 09-26 09-23 09-21 09-13 09-10 09-09 09-07 09-04 09-02 08-27 08-25 08-24 08-12 07-31 07-08 07-07 07-03 07-02 06-29 06-25 06-12 06-04 06-03 06-01 05-30 05-29 05-26 05-25 05-14 05-12 05-09 05-07 05-04 05-03 04-29 04-28 04-25 04-24 04-22 04-21 04-20 04-19 04-09 04-08 04-07 04-03 04-02 04-01 03-30 03-28 03-25 03-18 03-17 03-15 03-12 03-11 03-09 03-07 03-06 03-05 03-04 03-03 03-01 02-29 02-28 02-21 02-20 02-17 02-16 02-15 02-12 02-01 01-29 01-28 01-22 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

301	303
302	304	<a href="compare.xml" target="_top"><span style='white-space: nowrap'>comparison</span></a>
303	305	operations are checked during
304		<a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>zero order</span></a>
	306	<a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>zero order</span></a>
305	307	forward mode calculations.
306	308	The
307	309	<a href="comparechange.xml" target="_top"><span style='white-space: nowrap'>CompareChange</span></a>

-1

doc/whats_new_05.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD During 2005</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2005"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2005 12-24 12-23 12-22 12-20 12-19 12-16 12-15 12-14 12-11 12-08 12-07 12-06 12-05 12-03 12-02 12-01 11-23 11-22 11-20 11-19 11-15 11-12 11-09 11-07 11-06 11-01 10-20 10-18 10-14 10-12 10-06 09-29 09-27 09-24 09-20 09-14 09-09 09-07 08-30 08-24 08-20 08-19 08-15 08-14 08-13 08-07 07-21 07-19 07-15 07-11 07-08 07-05 07-04 07-03 07-02 07-01 06-25 06-24 06-18 06-14 06-13 06-06 05-19 05-18 05-16 05-12 05-06 05-01 04-21 04-20 04-19 03-26 03-23 03-22 03-09 03-04 03-01 02-24 01-08 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

-7

doc/whats_new_06.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD During 2006</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2006"/>
7		<meta name="keywords" id="keywords" content=" aclocal "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2006 introduction 12-24 12-23 12-22 12-21 12-19 12-18 12-17 12-15 12-13 12-12 12-11 12-10 12-09 12-07 12-05 12-03 12-02 12-01 11-30 11-29 11-28 11-23 11-18 11-12 11-08 11-06 11-05 11-04 11-02 11-01 10-31 10-29 10-28 10-27 10-26 10-25 10-18 10-16 10-10 09-30 08-17 07-14 07-12 06-29 06-22 06-19 06-17 06-18 06-15 06-09 06-07 06-05 06-02 05-31 05-29 05-27 05-03 04-29 04-28 04-26 04-25 04-19 04-18 04-17 04-15 04-14 04-13 04-08 04-06 04-05 04-04 04-03 04-02 04-01 03-31 03-30 03-29 03-28 03-27 03-26 03-24 03-23 03-22 03-18 03-17 03-16 03-15 03-11 03-10 03-09 03-07 03-05 02-28 02-25 02-24 02-23 02-21 02-15 02-14 02-13 02-11 02-10 02-04 01-20 01-18 01-08 aclocal 01-07 01-02 01-05 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

985	987	<br/>
986	988	<b><a name="06-19.06-17" id="06-19.06-17">06-17</a></b>
987	989	<br/>
988		Added <a href="capacity_taylor.xml" target="_top"><span style='white-space: nowrap'>capacity_taylor</span></a>
	990	Added <a href="capacity_order.xml" target="_top"><span style='white-space: nowrap'>capacity_order</span></a>
989	991	which can be used to control
990	992	the amount of memory used to store <a href="forward.xml" target="_top"><span style='white-space: nowrap'>Forward</span></a>
991	993	results.
992	994	Also <a href="fundeprecated.xml" target="_top"><span style='white-space: nowrap'>deprecated</span></a>
993	995	<code><font color="blue">taylor_size</font></code>, and defined
994		<a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	996	<a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
995	997	in its place.
996	998
997	999	<br/>

1325	1327	independent variable values.
1326	1328	In this case, the sparsity pattern can be (and has been)
1327	1329	made more efficient; i.e., fewer true values
1328		(because it only applies to the current <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>ForwardZero</span></a>
	1330	(because it only applies to the current <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
1329	1331	).
1330	1332	<code><span style='white-space: nowrap'><br/>
1331	1333	<br/>

1406	1408	<b><big><a name="04-03" id="04-03">04-03</a></big></b>
1407	1409	<br/>
1408	1410	Create separate sections for the
1409		<a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>zero</span></a>
1410		and <a href="forwardone.xml" target="_top"><span style='white-space: nowrap'>ForwardOne</span></a>
	1411	<a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>zero</span></a>
	1412	and <a href="forward_one.xml" target="_top"><span style='white-space: nowrap'>forward_one</span></a>
1411	1413	first order case
1412	1414	of <a href="forward.xml" target="_top"><span style='white-space: nowrap'>Forward</span></a>
1413	1415	mode.

1415	1417	<br/>
1416	1418	</span></code>The ADFun <a href="fundeprecated.xml#Size" target="_top"><span style='white-space: nowrap'>Size</span></a>
1417	1419	member function
1418		has been deprecated (use <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	1420	has been deprecated (use <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
1419	1421	instead).
1420	1422	<code><span style='white-space: nowrap'><br/>
1421	1423	<br/>

-5

doc/whats_new_07.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD During 2007</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2007"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2007 introduction 12-29 12-25 12-21 12-08 12-05 12-04 12-03 12-02 11-29 11-23 11-18 11-06 11-05 11-04 11-03 11-02 11-01 10-30 10-27 10-23 10-22 10-16 10-13 10-05 10-02 09-06 08-09 08-07 07-30 07-29 07-28 07-26 07-25 07-23 07-22 07-21 07-20 07-19 07-18 07-14 07-13 06-22 06-20 06-14 05-26 05-25 05-24 05-22 05-08 05-05 04-19 04-17 04-14 04-11 04-10 04-07 04-06 04-05 03-31 03-30 03-29 03-20 03-15 03-14 03-13 03-09 03-28 02-27 02-22 02-17 02-16 02-15 02-06 02-04 02-03 02-02 02-01 01-29 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

338	340	<a href="speed_sacado.xml" target="_top"><span style='white-space: nowrap'>Sacado speed tests</span></a>
339	341	.
340	342	In addition, compiler flag documentation was included for
341		<a href="speed_sacado.xml#C++ Compiler Flags" target="_top"><span style='white-space: nowrap'>Sacado</span></a>
342		and
343		all the other speed tests.
	343	Sacado and all the other speed tests.
344	344
345	345	<br/>
346	346	<br/>

1127	1127	<code><span style='white-space: nowrap'><br/>
1128	1128	<br/>
1129	1129	</span></code>There was a typo in the
1130		<a href="forwardany.xml#Second Order" target="_top"><span style='white-space: nowrap'>second order</span></a>
	1130	<a href="forward_order.xml#Second Order" target="_top"><span style='white-space: nowrap'>second order</span></a>
1131	1131	discussion
1132	1132	(found by Kipp Martin).
1133	1133	It has been fixed.

-3

doc/whats_new_08.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD During 2008</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2008"/>
7		<meta name="keywords" id="keywords" content=" erf ipopt_cppad_nlp "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2008 introduction 12-19 12-14 12-04 11-22 11-21 11-20 erf 10-27 10-17 10-16 09-30 09-26 09-18 09-17 09-16 09-12 09-10 09-09 09-07 09-06 09-05 09-04 09-03 09-01 08-29 ipopt_cppad_nlp 08-19 08-08 07-02 06-18 06-15 06-11 06-10 05-08 05-03 04-20 04-18 04-10 04-06 04-04 03-27 02-05 02-03 01-26 01-24 01-21 01-20 01-11 01-08 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

273	275	<br/>
274	276	Add or modify some wish list entries; see
275	277	<code><font color="blue">cppad_ipopt_nlp</font></code> (since removed),
276		<a href="wishlist.xml#Multiple Argument Forward" target="_top"><span style='white-space: nowrap'>multiple arguments</span></a>
277		,
	278	multiple argument forward (completed with <a href="forward_dir.xml" target="_top"><span style='white-space: nowrap'>forward_dir</span></a>
	279	),
278	280	and sparsity patterns
279	281	(<a href="glossary.xml#Sparsity Pattern" target="_top"><span style='white-space: nowrap'>sparsity patterns</span></a>
280	282	has been fulfilled).

-5

doc/whats_new_09.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD During 2009</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2009"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2009 introduction 12-23 12-22 12-18 12-12 12-04 12-02 11-28 11-27 11-26 10-30 10-29 10-28 10-27 10-24 10-23 10-21 10-16 10-14 10-03 09-30 09-29 09-28 09-26 09-20 09-19 09-18 08-25 08-14 08_13 08-13 08-11 08-10 08-09 08-06 08-02 08-01 07-31 07-26 07-25 07-24 07-23 07-06 07-04 07-03 07-02 07-01 06-30 06-29 06-28 06-25 06-22 06-21 06-20 06-06 05-20 03-24 02-20 02-15 02-01 01-31 01-18 01-06 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

184	186	Taylor coefficients and sparsity pattern information.
185	187	(This assignment operator was added on <a href="whats_new_09.xml#10-24" target="_top"><span style='white-space: nowrap'>10-24</span></a>
186	188	.)
187		You can use <a href="capacity_taylor.xml" target="_top"><span style='white-space: nowrap'>capacity_taylor</span></a>
	189	You can use <a href="capacity_order.xml" target="_top"><span style='white-space: nowrap'>capacity_order</span></a>
188	190	to delete the Taylor coefficients
189	191	before copying them.
190	192	Two new functions were added so that you can query and delete the

544	546	<br/>
545	547	<b><a name="08_13.08-13" id="08_13.08-13">08-13</a></b>
546	548	<br/>
547		An automatic check of the <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>ForwardZero</span></a>
	549	An automatic check of the <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
548	550	results was added
549	551	after each call to <a href="optimize.xml" target="_top"><span style='white-space: nowrap'>f.optimize()</span></a>
550	552

568	570	This will make it possible to add options in the future with out
569	571	having to change all the existing tests because the options are now
570	572	global variables instead of arguments to the speed test routines; for example,
571		see <a href="speed_main.xml#option_list.retape" target="_top"><span style='white-space: nowrap'>retape</span></a>
572		.
	573	see <code><font color="blue">retape</font></code> speed test option.
573	574
574	575	<br/>
575	576	<br/>

-1

doc/whats_new_10.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD During 2010</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2010"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2010 introduction 12-31 11-27 09-26 09-22 08-21 07-14 07-11 06-01 04-28 04-26 04-24 04-01 03-11 03-10 03-09 03-03 02-11 02-08 02-06 02-05 02-03 01-26 01-24 01-23 01-20 01-18 01-04 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

-2

doc/whats_new_11.xml less more

3	3	>
4	4	<head>
5	5	<title>Changes and Additions to CppAD During 2011</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2011"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2011 introduction 12-30 12-28 12-21 12-20 11-29 11-27 11-24 11-21 11-20 11-18 11-17 11-09 11-07 11-06 11-04 11-01 10-30 10-29 10-14 10-12 09-06 09-05 09-02 09-01 08-31 08-30 08-25 08-23 08-21 08-11 08-10 08-09 08-08 08-07 08-06 08-04 08-03 08-02 07-31 07-29 07-28 07-27 07-25 07-18 07-17 07-14 07-13 07-11 openmp/run.sh 07-10 07-09 07-07 06-23 06-21 06-18 05-29 05-28 05-26 05-22 05-11 05-03 04-29 04-20 04-19 03-19 03-11 03-05 02-22 02-19 02-17 02-15 02-09 02-06 02-02 02-01 01-19 01-16 01-09 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

808	810	<code><font color="blue"><span style='white-space: nowrap'><br/>
809	811	</span></font><i><font color="black"><span style='white-space: nowrap'>f</span></font></i><font color="blue"><span style='white-space: nowrap'>.Forward(0, </span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>, </span></font><i><font color="black"><span style='white-space: nowrap'>s</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>
810	812	</span></font></code>
811		See <a href="forwardzero.xml" target="_top"><span style='white-space: nowrap'>zero order forward mode</span></a>
	813	See <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>zero order forward mode</span></a>
812	814	and <a href="printfor.xml" target="_top"><span style='white-space: nowrap'>PrintFor</span></a>
813	815	.
814	816	</li><li>

-11

doc/whats_new_12.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Changes and Additions During 2012</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Changes and Additions During 2012"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" cppad changes and additions during 2012 introduction 12-30 12-29 12-28 12-27 12-26 12-23 12-22 12-20 12-19 12-17 12-15 12-14 12-13 11-28 11-21 11-20 11-17 11-16 11-14 11-09 11-06 11-04 10-31 10-30 10-25 10-24 10-12 10-04 10-03 10-02 09-24 09-11 08-05 07-30 07-08 07-07 07-05 07-04 07-03 07-02 07-01 06-17 06-16 06-15 06-12 06-10 06-09 06-08 06-07 06-05 06-04 06-03 06-02 06-01 05-31 05-30 05-29 05-27 05-24 04-19 04-18 04-17 04-10 04-06 04-05 04-01 03-27 03-26 03-23 03-21 03-17 03-11 03-03 03-02 02-11 02-10 02-09 01-30 01-27 01-24 01-23 01-20 01-19 01-16 01-15 01-12 01-07 01-02 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

296	298
297	299	Include the <a href="introduction.xml" target="_top"><span style='white-space: nowrap'>Introduction</span></a>
298	300	programs in the
299		<a href="cppad_test.xml" target="_top"><span style='white-space: nowrap'>cppad_test</span></a>
	301	<a href="cmake_check.xml" target="_top"><span style='white-space: nowrap'>cmake_check</span></a>
300	302	built using <a href="cmake.xml" target="_top"><span style='white-space: nowrap'>cmake</span></a>
301	303	.
302	304	</li><li>

1140	1142	</li><li>
1141	1143
1142	1144	Use same argument for taping and derivative evaluation when
1143		<a href="speed_main.xml#option_list.retape" target="_top"><span style='white-space: nowrap'>retape</span></a>
1144		is true.
	1145	<code><font color="blue">retape</font></code> speed test option is true.
1145	1146	</li><li>
1146	1147
1147	1148	Implement the

1190	1191	interface to <a href="sparse_hessian.xml" target="_top"><span style='white-space: nowrap'>sparse_hessian</span></a>
1191	1192	.
1192	1193	In addition, implement the speed test
1193		<a href="speed_main.xml#option_list.retape" target="_top"><span style='white-space: nowrap'>retape</span></a>
1194		option for these tests.
	1194	<code><font color="blue">retape</font></code> speed test option for these tests.
1195	1195
1196	1196	<br/>
1197	1197	<br/>
1198	1198	<b><big><a name="05-31" id="05-31">05-31</a></big></b>
1199	1199	<br/>
1200		Add the <a href="cppad_print_optimize.xml" target="_top"><span style='white-space: nowrap'>cppad_print_optimize</span></a>
1201		routine to so that the corresponding
	1200	Add the <code><font color="blue">cppad_print_optimize</font></code> routine to so that the corresponding
1202	1201	code does not need to be reproduced for all the
1203	1202	<a href="speed_cppad.xml" target="_top"><span style='white-space: nowrap'>speed_cppad</span></a>
1204	1203	tests.

1214	1213	so that the row and column indices are
1215	1214	inputs (instead of being chosen randomly by the test for each repetition).
1216	1215	This enables use of the
1217		<a href="speed_main.xml#option_list.retape" target="_top"><span style='white-space: nowrap'>retape</span></a>
1218		option
	1216	<code><font color="blue">retape</font></code> speed test option
1219	1217	during sparse Hessian speed tests.
1220	1218
1221	1219	<br/>

1429	1427	<br/>
1430	1428	Calling <code><font color="blue">taylor_capacity</font></code>, with to with capacity equal to zero,
1431	1429	was not
1432		<a href="capacity_taylor.xml#c.Freeing Memory" target="_top"><span style='white-space: nowrap'>freeing memory</span></a>
	1430	<a href="capacity_order.xml#c.Freeing Memory" target="_top"><span style='white-space: nowrap'>freeing memory</span></a>
1433	1431	.
1434	1432	This has been fixed.
1435	1433

-4

doc/whats_new_13.xml less more

3	3	>
4	4	<head>
5	5	<title>CppAD Changes and Additions During 2013</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="CppAD Changes and Additions During 2013"/>
7		<meta name="keywords" id="keywords" content=" "/>
	8	<meta name="keywords" id="keywords" content=" cppad changes and additions during 2013 introduction 12-29 12-27 12-26 12-24 11-27 11-13 11-12 10-29 10-23 10-22 10-16 10-15 10-14 10-13 10-12 09-20 09-19 09-18 09-07 08-12 08-11 08-06 07-26 05-28 05-21 05-17 05-15 05-14 05-12 05-11 05-04 04-28 04-27 04-26 "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

20	21	<td>
21	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
22	23	</td>
23		<td><a href="whats_new.xml" target="_top">Prev</a>
	24	<td><a href="whats_new_14.xml" target="_top">Prev</a>
24	25	</td><td><a href="whats_new_12.xml" target="_top">Next</a>
25	26	</td><td>
26	27	<select onchange='choose_across0(this)'>

75	76	<td>
76	77	<select onchange='choose_down1(this)'>
77	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
78	80	<option>whats_new_13</option>
79	81	<option>whats_new_12</option>
80	82	<option>whats_new_11</option>

536	538	mode results when
537	539	<a href="check_for_nan.xml" target="_top"><span style='white-space: nowrap'>check_for_nan</span></a>
538	540	is true.
539		(It used to be the case that only <a href="forwardany.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
	541	(It used to be the case that only <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
540	542	results
541	543	were checked for <code><font color="blue">nan</font></code>.)
542	544	</li></ol>

690	692	<b><big><a name="05-04" id="05-04">05-04</a></big></b>
691	693	<br/>
692	694	The option to compute
693		<a href="forwardany.xml#x_p.Multiple Orders" target="_top"><span style='white-space: nowrap'>multiple orders</span></a>
	695	<a href="forward_order.xml#xq.Multiple Orders" target="_top"><span style='white-space: nowrap'>multiple orders</span></a>
694	696	was added.
695	697	The <a href="old_usead_2.cpp.xml" target="_top"><span style='white-space: nowrap'>old_usead_2.cpp</span></a>
696	698	example shows the need for this.

+817

-0

doc/whats_new_14.xml less more

	0	<?xml version='1.0'?>
	1	<html xmlns='http://www.w3.org/1999/xhtml'
	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
	3	>
	4	<head>
	5	<title>CppAD Changes and Additions During 2014</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
	7	<meta name="description" id="description" content="CppAD Changes and Additions During 2014"/>
	8	<meta name="keywords" id="keywords" content=" cppad changes and additions during 2014 introduction 12-27 12-26 12-25 12-23 12-22 12-17 12-16 12-15 11-28 11-27 09-28 09-27 09-25 09-21 05-28 05-27 05-23 05-22 05-20 05-19 05-16 05-14 03-18 03-17 03-09 03-05 03-02 03-01 02-28 02-27 02-26 02-23 02-22 02-17 02-15 01-26 01-21 01-10 "/>
	9	<style type='text/css'>
	10	body { color : black }
	11	body { background-color : white }
	12	A:link { color : blue }
	13	A:visited { color : purple }
	14	A:active { color : purple }
	15	</style>
	16	<script type='text/javascript' language='JavaScript' src='_whats_new_14_xml.js'>
	17	</script>
	18	</head>
	19	<body>
	20	<table><tr>
	21	<td>
	22	<a href="http://www.coin-or.org/CppAD/" target="_top"><img border="0" src="_image.gif"/></a>
	23	</td>
	24	<td><a href="whats_new.xml" target="_top">Prev</a>
	25	</td><td><a href="whats_new_13.xml" target="_top">Next</a>
	26	</td><td>
	27	<select onchange='choose_across0(this)'>
	28	<option>Index-></option>
	29	<option>contents</option>
	30	<option>reference</option>
	31	<option>index</option>
	32	<option>search</option>
	33	<option>external</option>
	34	</select>
	35	</td>
	36	<td>
	37	<select onchange='choose_up0(this)'>
	38	<option>Up-></option>
	39	<option>CppAD</option>
	40	<option>Appendix</option>
	41	<option>whats_new</option>
	42	<option>whats_new_14</option>
	43	</select>
	44	</td>
	45	<td>
	46	<select onchange='choose_down3(this)'>
	47	<option>CppAD-></option>
	48	<option>Install</option>
	49	<option>Introduction</option>
	50	<option>AD</option>
	51	<option>ADFun</option>
	52	<option>preprocessor</option>
	53	<option>multi_thread</option>
	54	<option>library</option>
	55	<option>ipopt_solve</option>
	56	<option>Example</option>
	57	<option>speed</option>
	58	<option>Appendix</option>
	59	</select>
	60	</td>
	61	<td>
	62	<select onchange='choose_down2(this)'>
	63	<option>Appendix-></option>
	64	<option>Faq</option>
	65	<option>Theory</option>
	66	<option>glossary</option>
	67	<option>Bib</option>
	68	<option>Bugs</option>
	69	<option>WishList</option>
	70	<option>whats_new</option>
	71	<option>deprecated</option>
	72	<option>compare_c</option>
	73	<option>License</option>
	74	</select>
	75	</td>
	76	<td>
	77	<select onchange='choose_down1(this)'>
	78	<option>whats_new-></option>
	79	<option>whats_new_14</option>
	80	<option>whats_new_13</option>
	81	<option>whats_new_12</option>
	82	<option>whats_new_11</option>
	83	<option>whats_new_10</option>
	84	<option>whats_new_09</option>
	85	<option>whats_new_08</option>
	86	<option>whats_new_07</option>
	87	<option>whats_new_06</option>
	88	<option>whats_new_05</option>
	89	<option>whats_new_04</option>
	90	<option>whats_new_03</option>
	91	</select>
	92	</td>
	93	<td>whats_new_14</td>
	94	<td>
	95	<select onchange='choose_current0(this)'>
	96	<option>Headings-></option>
	97	<option>Introduction</option>
	98	<option>12-27</option>
	99	<option>12-26</option>
	100	<option>12-25</option>
	101	<option>12-23</option>
	102	<option>12-22</option>
	103	<option>12-17</option>
	104	<option>12-16</option>
	105	<option>12-15</option>
	106	<option>11-28</option>
	107	<option>11-27</option>
	108	<option>09-28</option>
	109	<option>09-27</option>
	110	<option>09-25</option>
	111	<option>09-21</option>
	112	<option>05-28</option>
	113	<option>05-27</option>
	114	<option>05-23</option>
	115	<option>05-22</option>
	116	<option>05-20</option>
	117	<option>05-19</option>
	118	<option>05-16</option>
	119	<option>05-14</option>
	120	<option>03-18</option>
	121	<option>03-17</option>
	122	<option>03-09</option>
	123	<option>03-05</option>
	124	<option>03-02</option>
	125	<option>03-01</option>
	126	<option>02-28</option>
	127	<option>02-27</option>
	128	<option>02-26</option>
	129	<option>02-23</option>
	130	<option>02-22</option>
	131	<option>02-17</option>
	132	<option>02-15</option>
	133	<option>01-26</option>
	134	<option>01-21</option>
	135	<option>01-10</option>
	136	</select>
	137	</td>
	138	</tr></table><br/>
	139
	140
	141
	142
	143	<center><b><big><big>CppAD Changes and Additions During 2014</big></big></b></center>
	144	<br/>
	145	<b><big><a name="Introduction" id="Introduction">Introduction</a></big></b>
	146	<br/>
	147	This section contains a list of the changes to CppAD during 2014
	148	(in reverse order by date).
	149	The purpose of this section is to
	150	assist you in learning about changes between various versions of CppAD.
	151
	152	<br/>
	153	<br/>
	154	<b><big><a name="12-27" id="12-27">12-27</a></big></b>
	155	<br/>
	156	More work on the bug in
	157	<a href="condexp.xml#Optimize" target="_top"><span style='white-space: nowrap'>optimizing</span></a>
	158
	159	conditional expressions.
	160
	161	<br/>
	162	<br/>
	163	<b><big><a name="12-26" id="12-26">12-26</a></big></b>
	164	<br/>
	165	A minimal example for computing cross terms in atomic operation
	166	Hessian sparsity patterns <a href="atomic_hes_sparse.cpp.xml" target="_top"><span style='white-space: nowrap'>atomic_hes_sparse.cpp</span></a>
	167	was added.
	168
	169	<br/>
	170	<br/>
	171	<b><big><a name="12-25" id="12-25">12-25</a></big></b>
	172	<br/>
	173	More work on the bug in
	174	<a href="condexp.xml#Optimize" target="_top"><span style='white-space: nowrap'>optimizing</span></a>
	175
	176	conditional expressions.
	177
	178	<br/>
	179	<br/>
	180	<b><big><a name="12-23" id="12-23">12-23</a></big></b>
	181	<br/>
	182	The c++11 standard includes the error function <a href="erf.xml" target="_top"><span style='white-space: nowrap'>erf</span></a>
	183	in
	184	<code><font color="blue">cmath</font></code>.
	185	If the c++ compiler has the error function defined in <code><font color="blue">cmath</font></code>,
	186	the complier version of the error function is used and it corresponds to an
	187	atomic operation.
	188	<code><span style='white-space: nowrap'><br/>
	189	<br/>
	190	</span></code>Fix typo in tangent reverse mode theory for
	191	<a href="tan_reverse.xml#Positive Orders Z(t)" target="_top"><span style='white-space: nowrap'>Positive Orders</span></a>
	192	.
	193
	194	<br/>
	195	<br/>
	196	<b><big><a name="12-22" id="12-22">12-22</a></big></b>
	197	<br/>
	198	There was a bug related to
	199	<a href="condexp.xml#Optimize" target="_top"><span style='white-space: nowrap'>optimizing</span></a>
	200
	201	conditional expressions.
	202	This has been fixed.
	203
	204	<br/>
	205	<br/>
	206	<b><big><a name="12-17" id="12-17">12-17</a></big></b>
	207	<br/>
	208	Fix some compiler warnings and <a href="speed.xml" target="_top"><span style='white-space: nowrap'>speed</span></a>
	209	program names
	210	when using the deprecated <a href="installunix.xml" target="_top"><span style='white-space: nowrap'>auto-tools</span></a>
	211	install procedure.
	212
	213	<br/>
	214	<br/>
	215	<b><big><a name="12-16" id="12-16">12-16</a></big></b>
	216	<br/>
	217	If the <code><font color="blue">c++11</font></code> include file <code><font color="blue"><cstdint></font></code>
	218	defines all the standard types, they can be used by to specify
	219	<a href="cmake.xml#cppad_tape_addr_type.cstdint" target="_top"><span style='white-space: nowrap'>cppad_tape_addr_type</span></a>
	220	and
	221	<a href="cmake.xml#cppad_tape_id_type.cstdint" target="_top"><span style='white-space: nowrap'>cppad_tape_id_type</span></a>
	222	.
	223
	224	<br/>
	225	<br/>
	226	<b><big><a name="12-15" id="12-15">12-15</a></big></b>
	227	<br/>
	228	Correct the title and <a href="_index.xml" target="_top"><span style='white-space: nowrap'>_index</span></a>
	229	entries for <a href="forward_two.xml" target="_top"><span style='white-space: nowrap'>forward_two</span></a>
	230
	231	from first to second order.
	232
	233	<br/>
	234	<br/>
	235	<b><big><a name="11-28" id="11-28">11-28</a></big></b>
	236	<br/>
	237	Improve the <a href="_index.xml" target="_top"><span style='white-space: nowrap'>index</span></a>
	238	and <code><font color="blue">search</font></code> using
	239	a new version of the <code><font color="blue">omhelp</font></code> documentation tool.
	240
	241	<br/>
	242	<br/>
	243	<b><big><a name="11-27" id="11-27">11-27</a></big></b>
	244
	245	<ol type="1"><li>
	246	Add alignment to the
	247	<a href="ta_get_memory.xml#Alignment" target="_top"><span style='white-space: nowrap'>get_memory</span></a>
	248	and
	249	<a href="ta_create_array.xml#Alignment" target="_top"><span style='white-space: nowrap'>create_array</span></a>
	250	specifications
	251	and
	252	<a href="thread_alloc.cpp.xml" target="_top"><span style='white-space: nowrap'>thread_alloc example</span></a>
	253	.
	254	</li><li>
	255
	256	Advance the deprecated <a href="installunix.xml" target="_top"><span style='white-space: nowrap'>unix install</span></a>
	257	utilities to
	258	autoconf-2.69 and automake-1.13.4.
	259	</li></ol>
	260
	261
	262	<br/>
	263	<br/>
	264	<b><big><a name="09-28" id="09-28">09-28</a></big></b>
	265	<br/>
	266	Fix more bugs related to optimizing condition conditional expressions.
	267	<ol type="1"><li>
	268	Using old instead of new operator indices.
	269	</li><li>
	270
	271	Not properly following dependence back through atomic operations.
	272	</li><li>
	273
	274	Aborting during forward order zero, when skipping computation for a variable
	275	that was already completed (the skip is still useful for higher orders
	276	and for reverse mode).
	277	</li><li>
	278
	279	Reverse mode not properly handling the variable number of arguments in the
	280	conditional skip operation.
	281	</li><li>
	282
	283	Reverse mode tracing not properly handling the variable number
	284	of argument operations; i.e., conditional skip and cumulative summation.
	285	</li></ol>
	286
	287
	288	<br/>
	289	<br/>
	290	<b><big><a name="09-27" id="09-27">09-27</a></big></b>
	291	<br/>
	292	Fix a bug that occurred when
	293	<a href="optimize.xml" target="_top"><span style='white-space: nowrap'>f.optimize</span></a>
	294	was used with a function
	295	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	296
	297	that contained calls to user defined <a href="atomic.xml" target="_top"><span style='white-space: nowrap'>atomic</span></a>
	298	operations
	299	and <a href="condexp.xml" target="_top"><span style='white-space: nowrap'>conditional expressions</span></a>
	300	.
	301
	302	<br/>
	303	<br/>
	304	<b><big><a name="09-25" id="09-25">09-25</a></big></b>
	305	<br/>
	306	Fix a bug that occurred when
	307	<a href="optimize.xml" target="_top"><span style='white-space: nowrap'>f.optimize</span></a>
	308	was used with a function
	309	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
	310
	311	that contained <a href="discrete.xml" target="_top"><span style='white-space: nowrap'>discrete</span></a>
	312	functions.
	313
	314	<br/>
	315	<br/>
	316	<b><big><a name="09-21" id="09-21">09-21</a></big></b>
	317	<br/>
	318	Fix a typo in documentation for
	319	<a href="reverse_any.xml" target="_top"><span style='white-space: nowrap'>any order reverse</span></a>
	320	.
	321	To be specific,
	322	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	323	<msup><mi mathvariant='italic'>x</mi>
	324	<mrow><mo stretchy="false">(</mo>
	325	<mi mathvariant='italic'>k</mi>
	326	<mo stretchy="false">)</mo>
	327	</mrow>
	328	</msup>
	329	</mrow></math>
	330
	331	was changed to be
	332	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
	333	<msup><mi mathvariant='italic'>u</mi>
	334	<mrow><mo stretchy="false">(</mo>
	335	<mi mathvariant='italic'>k</mi>
	336	<mo stretchy="false">)</mo>
	337	</mrow>
	338	</msup>
	339	</mrow></math>
	340
	341	.
	342
	343	<br/>
	344	<br/>
	345	<b><big><a name="05-28" id="05-28">05-28</a></big></b>
	346
	347	<ol type="1"><li>
	348	Change the <a href="speed_main.xml#Sparsity Options.boolsparsity" target="_top"><span style='white-space: nowrap'>boolsparsity</span></a>
	349
	350	so that it only affects the sparsity speed tests
	351	<a href="link_sparse_jacobian.xml" target="_top"><span style='white-space: nowrap'>sparse_jacobian</span></a>
	352	and
	353	<a href="link_sparse_hessian.xml" target="_top"><span style='white-space: nowrap'>sparse_hessian</span></a>
	354	;
	355	i.e., it is now ignored by the other tests.
	356	</li><li>
	357
	358	Improve the <a href="speed.xml" target="_top"><span style='white-space: nowrap'>speed</span></a>
	359	documentation page.
	360	</li></ol>
	361
	362
	363	<br/>
	364	<br/>
	365	<b><big><a name="05-27" id="05-27">05-27</a></big></b>
	366
	367	<ol type="1"><li>
	368	The <a href="colpack_prefix.xml#cppad_colpack.cpp" target="_top"><span style='white-space: nowrap'>cppad_colpack.cpp</span></a>
	369
	370	file was not being copied to the specified directory.
	371	In addition, the specified directory was changed from an include
	372	directory to data directory
	373	(<code><font color="blue">cppad_colpack.cpp</font></code> is not an include file).
	374	</li><li>
	375
	376	If <a href="colpack_prefix.xml" target="_top"><span style='white-space: nowrap'>colpack_prefix</span></a>
	377	was specified, the CppAD
	378	<a href="pkgconfig.xml" target="_top"><span style='white-space: nowrap'>pkgconfig</span></a>
	379	file was missing some information.
	380	This has been fixed.
	381	</li></ol>
	382
	383
	384	<br/>
	385	<br/>
	386	<b><big><a name="05-23" id="05-23">05-23</a></big></b>
	387	<br/>
	388	The <a href="speed.xml" target="_top"><span style='white-space: nowrap'>speed</span></a>
	389	test instructions were converted from using
	390	the old auto-tools <a href="installunix.xml" target="_top"><span style='white-space: nowrap'>unix install</span></a>
	391	instructions
	392	to use the <a href="cmake.xml" target="_top"><span style='white-space: nowrap'>cmake</span></a>
	393	install instructions.
	394	These instructions should work on any system, not just unix.
	395
	396	<br/>
	397	<br/>
	398	<b><big><a name="05-22" id="05-22">05-22</a></big></b>
	399
	400	<ol type="1"><li>
	401	Add multiple direction for mode
	402	<a href="forward_dir.xml" target="_top"><span style='white-space: nowrap'>forward_dir</span></a>
	403	and use it to speed up the forward
	404	version of <a href="sparse_jacobian.xml" target="_top"><span style='white-space: nowrap'>sparse_jacobian</span></a>
	405	.
	406	Below is an example run of <a href="cppad_sparse_jacobian.cpp.xml" target="_top"><span style='white-space: nowrap'>cppad_sparse_jacobian.cpp</span></a>
	407	results
	408	before this change:
	409	<code><font color='blue'><pre style='display:inline'>
	410	cppad_sparse_jacobian_size = [ 100, 400, 900, 1600, 2500 ]
	411	cppad_sparse_jacobian_rate = [ 2973, 431.94, 142.25, 78.64, 26.87 ]
	412	</pre></font></code>
	413
	414	and after this change:
	415	<code><font color='blue'><pre style='display:inline'>
	416	cppad_sparse_jacobian_size = [ 100, 400, 900, 1600, 2500 ]
	417	cppad_sparse_jacobian_rate = [ 6389, 954.26, 314.04, 180.06, 56.95 ]
	418	</pre></font></code>
	419
	420	Due to the success of this change, other
	421	<a href="wishlist.xml#Multiple Directions" target="_top"><span style='white-space: nowrap'>multiple direction</span></a>
	422	items
	423	were added to the wish list.
	424	</li><li>
	425
	426	Improve the forward mode tracing of arguments to,
	427	and results from, user defined <a href="atomic.xml" target="_top"><span style='white-space: nowrap'>atomic</span></a>
	428	operations.
	429	</li></ol>
	430
	431
	432	<br/>
	433	<br/>
	434	<b><big><a name="05-20" id="05-20">05-20</a></big></b>
	435
	436	<ol type="1"><li>
	437	Move <code><font color="blue">speed/adolc/alloc_mat.hpp</font></code> to
	438	<code><font color="blue">speed/adolc/adolc_alloc_mat.hpp</font></code> so it has the
	439	same name is its <code><font color="blue"># ifndef</font></code> command.
	440	</li><li>
	441
	442	Fix <code><font color="blue"># ifndef</font></code> command in
	443	<code><font color="blue">cppad/ipopt/solve_callback.hpp</font></code>.
	444	</li><li>
	445
	446	Add <code><font color="blue"># ifndef</font></code> command to <code><font color="blue">test_more/extern_value.hpp</font></code>.
	447	</li></ol>
	448
	449
	450
	451	<br/>
	452	<br/>
	453	<b><big><a name="05-19" id="05-19">05-19</a></big></b>
	454	<br/>
	455	In the files
	456	<code><font color="blue">cppad/local/asin_op.hpp</font></code> and <code><font color="blue">cppad/local/acos_op.hpp</font></code>
	457	there were assignments of the form <code><font color="blue">uj = 0.</font></code> where <code><font color="blue">u_j</font></code>
	458	has type <a href="glossary.xml#Base Type" target="_top"><span style='white-space: nowrap'>Base</span></a>
	459	.
	460	These may have not be defined operations in certain cases and
	461	have been converted to <code><font color="blue">uj = Base(0)</font></code>.
	462
	463
	464	<br/>
	465	<br/>
	466	<b><big><a name="05-16" id="05-16">05-16</a></big></b>
	467	<br/>
	468	There was a mistake in printing the arguments for
	469	<code><font color="blue">CSumOp</font></code> and <code><font color="blue">CSkipOp</font></code> when using the undocumented
	470	<code><font color="blue">TRACE</font></code> option during forward mode (available in files of the form
	471
	472	<code><font color="blue"><span style='white-space: nowrap'>cppad/local/</span></font><i><font color="black"><span style='white-space: nowrap'>*</span></font></i><font color="blue"><span style='white-space: nowrap'>sweep.hpp/</span></font></code>
	473	).
	474	This has been fixed.
	475
	476	<br/>
	477	<br/>
	478	<b><big><a name="05-14" id="05-14">05-14</a></big></b>
	479
	480	<ol type="1"><li>
	481	There were some global variables in the file
	482	<code><font color="blue">cppad/local/op_code.hpp</font></code> that might have caused multiple definitions
	483	during link time for CppAD applications.
	484	These variables have been changed to be local so that this cannot happen.
	485	</li><li>
	486
	487	There was a mistaken assert that the number of arguments for the
	488	<code><font color="blue">BeginOp</font></code> was zero that caused an abort when using the undocumented
	489	<code><font color="blue">TRACE</font></code> option available in files of the form
	490
	491	<code><font color="blue"><span style='white-space: nowrap'>cppad/local/</span></font><i><font color="black"><span style='white-space: nowrap'>*</span></font></i><font color="blue"><span style='white-space: nowrap'>sweep.hpp/</span></font></code>
	492	.
	493	This has been fixed.
	494	</li></ol>
	495
	496
	497	<br/>
	498	<br/>
	499	<b><big><a name="03-18" id="03-18">03-18</a></big></b>
	500
	501	<ol type="1"><li>
	502	The
	503	<a href="fundeprecated.xml#size_taylor" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	504
	505	and
	506	<a href="fundeprecated.xml#capacity_taylor" target="_top"><span style='white-space: nowrap'>capacity_taylor</span></a>
	507
	508	functions were deprecated;
	509	use <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
	510	and <a href="capacity_order.xml" target="_top"><span style='white-space: nowrap'>capacity_order</span></a>
	511	instead.
	512	</li><li>
	513
	514	The documentation for <a href="forward.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
	515	and the examples
	516	<a href="forward.cpp.xml" target="_top"><span style='white-space: nowrap'>forward.cpp</span></a>
	517	, <a href="forward_order.cpp.xml" target="_top"><span style='white-space: nowrap'>forward_order.cpp</span></a>
	518	, have been improved.
	519	To be more specific, <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward_order</span></a>
	520	now references the special
	521	cases <a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
	522	, <a href="forward_one.xml" target="_top"><span style='white-space: nowrap'>forward_one</span></a>
	523	and the new case
	524	<a href="forward_two.xml" target="_top"><span style='white-space: nowrap'>forward_two</span></a>
	525	.
	526	</li></ol>
	527
	528
	529	<br/>
	530	<br/>
	531	<b><big><a name="03-17" id="03-17">03-17</a></big></b>
	532	<br/>
	533	The
	534	<a href="cppad_vector.xml#Assignment.Move Semantics" target="_top"><span style='white-space: nowrap'>move semantics</span></a>
	535
	536	version of the <code><font color="blue">CppAD::vector</font></code> assignment statement
	537	was not checking vector sizes.
	538	This has been fixed so that things work the same with compilers
	539	that do not have move semantics.
	540	(Note that with move semantics, no extra memory allocation is done
	541	even if the target vector has a different size.)
	542
	543	<br/>
	544	<br/>
	545	<b><big><a name="03-09" id="03-09">03-09</a></big></b>
	546	<br/>
	547	The documentation links
	548	<code><font color="blue">forwardzero</font></code>, <code><font color="blue">forwardone</font></code>, and <code><font color="blue">forwardany</font></code>
	549	have been changed to
	550	<a href="forward_zero.xml" target="_top"><span style='white-space: nowrap'>forward_zero</span></a>
	551	, <a href="forward_one.xml" target="_top"><span style='white-space: nowrap'>forward_one</span></a>
	552	,
	553	and <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward_order</span></a>
	554	respectively.
	555	This may affect links from other web pages to the CppAD documentation.
	556
	557	<br/>
	558	<br/>
	559	<b><big><a name="03-05" id="03-05">03-05</a></big></b>
	560	<br/>
	561	The names
	562	<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i></code>
	563	and
	564	<code><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
	565	in the
	566	<a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward</span></a>
	567	,
	568	<a href="reverse_any.xml" target="_top"><span style='white-space: nowrap'>reverse</span></a>
	569	,
	570	<a href="atomic_forward.xml" target="_top"><span style='white-space: nowrap'>atomic_forward</span></a>
	571	, and
	572	<a href="atomic_reverse.xml" target="_top"><span style='white-space: nowrap'>atomic_reverse</span></a>
	573	functions
	574	were reverse so that
	575	<code><i><font color="black"><span style='white-space: nowrap'>p</span></font></i><font color="blue"><span style='white-space: nowrap'> <= </span></font><i><font color="black"><span style='white-space: nowrap'>q</span></font></i></code>
	576	.
	577	This is only a notational change to make the arguments easier to remember.
	578
	579	<br/>
	580	<br/>
	581	<b><big><a name="03-02" id="03-02">03-02</a></big></b>
	582
	583	<ol type="1"><li>
	584	In the output for the speed
	585	<a href="speed_main.xml#test.correct" target="_top"><span style='white-space: nowrap'>correct</span></a>
	586	test,
	587	mention which tests are not available.
	588	Note that the set of available tests can depend on the
	589	<a href="speed_main.xml#option_list" target="_top"><span style='white-space: nowrap'>list of options</span></a>
	590	.
	591	</li><li>
	592
	593	In the documentation for
	594	<a href="sparse_jacobian.xml#n_sweep" target="_top"><span style='white-space: nowrap'>n_sweep</span></a>
	595	,
	596	mention that it is equal to the number of colors determined by the
	597	<a href="sparse_jacobian.xml#work.color_method" target="_top"><span style='white-space: nowrap'>color_method</span></a>
	598	.
	599	</li><li>
	600
	601	The <a href="speed_cppad.xml" target="_top"><span style='white-space: nowrap'>speed_cppad</span></a>
	602	tests were simplified by removing the printing
	603	of auxillary information related to the
	604	<a href="speed_main.xml#option_list.optimize" target="_top"><span style='white-space: nowrap'>optimize</span></a>
	605	option.
	606	Future auxillary information will be passed back in a manner similar to
	607	<a href="link_sparse_jacobian.xml#n_sweep" target="_top"><span style='white-space: nowrap'>n_sweep</span></a>
	608	for the sparse jacobian test.
	609	</li><li>
	610
	611	<a href="cppad_vector.xml#Assignment.Move Semantics" target="_top"><span style='white-space: nowrap'>Move semantics</span></a>
	612
	613	were added to the <code><font color="blue">CppAD::vector</font></code> assignment operator.
	614	</li></ol>
	615
	616
	617	<br/>
	618	<br/>
	619	<b><big><a name="03-01" id="03-01">03-01</a></big></b>
	620
	621	<ol type="1"><li>
	622	Change the prototype for
	623	<code><i><font color="black"><span style='white-space: nowrap'>row</span></font></i></code>
	624	and
	625	<code><i><font color="black"><span style='white-space: nowrap'>col</span></font></i></code>
	626	in the
	627	<a href="link_sparse_jacobian.xml" target="_top"><span style='white-space: nowrap'>link_sparse_jacobian</span></a>
	628	speed test to be <code><font color="blue">const</font></code>; i.e.,
	629	they are not changed.
	630	</li><li>
	631
	632	Move
	633	<code><i><font color="black"><span style='white-space: nowrap'>x</span></font></i></code>
	634	near end of <a href="link_sparse_hessian.xml" target="_top"><span style='white-space: nowrap'>link_sparse_hessian</span></a>
	635	speed test
	636	parameter list,
	637	(as is the case for <a href="link_sparse_jacobian.xml" target="_top"><span style='white-space: nowrap'>link_sparse_jacobian</span></a>
	638	).
	639	</li></ol>
	640
	641
	642	<br/>
	643	<br/>
	644	<b><big><a name="02-28" id="02-28">02-28</a></big></b>
	645	<br/>
	646	The <a href="cppad_vector.xml#data" target="_top"><span style='white-space: nowrap'>data</span></a>
	647	function was added to the
	648	<code><font color="blue">CppAD::vector</font></code> template class.
	649
	650	<br/>
	651	<br/>
	652	<b><big><a name="02-27" id="02-27">02-27</a></big></b>
	653	<br/>
	654	The CppAD developer documentation for the subdirectory
	655	<code><font color="blue">cppad/ipopt</font></code> was not being built by the command
	656	<code><font color="blue">bin/run_doxygen.sh</font></code>.
	657	This has been fixed.
	658
	659	<br/>
	660	<br/>
	661	<b><big><a name="02-26" id="02-26">02-26</a></big></b>
	662
	663	<ol type="1"><li>
	664	The
	665	<a href="speed_adolc.xml" target="_top"><span style='white-space: nowrap'>adolc</span></a>
	666	and
	667	<a href="speed_cppad.xml" target="_top"><span style='white-space: nowrap'>cppad</span></a>
	668	sparse jacobian speed tests now print out
	669	<a href="sparse_jacobian.xml#n_sweep" target="_top"><span style='white-space: nowrap'>n_sweep</span></a>
	670	.
	671	</li><li>
	672
	673	The size of some of the <a href="speed.xml" target="_top"><span style='white-space: nowrap'>speed</span></a>
	674	test cases has been increased
	675	to test behavior for larger problems.
	676	</li><li>
	677
	678	A link to <a href="ode_evaluate.xml" target="_top"><span style='white-space: nowrap'>ode_evaluate</span></a>
	679	was missing in the
	680	<a href="speed_utility.xml#Speed Utility Routines" target="_top"><span style='white-space: nowrap'>Speed Utility Routines</span></a>
	681	table.
	682	This has been fixed.
	683	</li></ol>
	684
	685
	686
	687	<br/>
	688	<br/>
	689	<b><big><a name="02-23" id="02-23">02-23</a></big></b>
	690	<br/>
	691	The <a href="sparse_jacobian.xml#work.color_method" target="_top"><span style='white-space: nowrap'>color_method</span></a>
	692
	693	option was added to the sparse Jacobian calculations.
	694	This enables one to use <a href="colpack_prefix.xml" target="_top"><span style='white-space: nowrap'>ColPack</span></a>
	695
	696	do color the rows or columns.
	697	The speed test <a href="speed_main.xml#Sparsity Options.colpack" target="_top"><span style='white-space: nowrap'>colpack</span></a>
	698	option
	699	was also added (but not yet implemented for
	700	<a href="link_sparse_hessian.xml" target="_top"><span style='white-space: nowrap'>sparse_hessian</span></a>
	701	speed tests).
	702
	703
	704	<br/>
	705	<br/>
	706	<b><big><a name="02-22" id="02-22">02-22</a></big></b>
	707	<br/>
	708	The program names in
	709	<a href="thread_test.cpp.xml" target="_top"><span style='white-space: nowrap'>thread_test.cpp</span></a>
	710	where changes from
	711
	712	<code><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i><font color="blue"><span style='white-space: nowrap'>_test</span></font></code>
	713	to
	714	<code><font color="blue"><span style='white-space: nowrap'>multi_thread_</span></font><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i></code>
	715
	716	where
	717	<code><i><font color="black"><span style='white-space: nowrap'>threading</span></font></i></code>
	718	is <code><font color="blue">openmp</font></code>, <code><font color="blue">pthread</font></code> or <code><font color="blue">bthread</font></code>.
	719
	720	<br/>
	721	<br/>
	722	<b><big><a name="02-17" id="02-17">02-17</a></big></b>
	723	<br/>
	724	Fix ambiguous call to <a href="nan.xml#isnan" target="_top"><span style='white-space: nowrap'>isnan</span></a>
	725
	726	during MS Visual Studio 2012 compilation.
	727
	728	<br/>
	729	<br/>
	730	<b><big><a name="02-15" id="02-15">02-15</a></big></b>
	731
	732	<ol type="1"><li>
	733	The <a href="speed_main.xml#Sparsity Options.boolsparsity" target="_top"><span style='white-space: nowrap'>boolsparsity</span></a>
	734	option
	735	was added to the <a href="speed_main.xml" target="_top"><span style='white-space: nowrap'>speed_main</span></a>
	736	program.
	737	</li><li>
	738
	739	The <code><font color="blue">retape</font></code> option what changed to
	740	<a href="speed_main.xml#option_list.onetape" target="_top"><span style='white-space: nowrap'>onetape</span></a>
	741	so that the default
	742	is to retape (option not present).
	743	This was done because
	744	<a href="fadbad_prefix.xml" target="_top"><span style='white-space: nowrap'>fadbad</span></a>
	745	and
	746	<a href="sacado_prefix.xml" target="_top"><span style='white-space: nowrap'>sacado</span></a>
	747	always retape.
	748	</li><li>
	749
	750	The documentation, and example source code, for all the speed
	751	<a href="speed_main.xml#option_list" target="_top"><span style='white-space: nowrap'>options</span></a>
	752	was improved
	753	(made clearer).
	754	</li><li>
	755
	756	Improve the success rate for
	757	<a href="speed_test.cpp.xml" target="_top"><span style='white-space: nowrap'>speed_test.cpp</span></a>
	758	and <a href="time_test.cpp.xml" target="_top"><span style='white-space: nowrap'>time_test.cpp</span></a>
	759	.
	760	</li></ol>
	761
	762
	763	<br/>
	764	<br/>
	765	<b><big><a name="01-26" id="01-26">01-26</a></big></b>
	766	<br/>
	767	The destination directory for the
	768	<a href="cmake.xml#cmake_install_docdir" target="_top"><span style='white-space: nowrap'>cppad documentation</span></a>
	769
	770	is now set separately from the data directory
	771	using the <code><font color="blue">cmake</font></code> option
	772
	773	<code><font color="blue"><span style='white-space: nowrap'><br/>
	774	-D cmake_install_docdir=</span></font><i><font color="black"><span style='white-space: nowrap'>cmake_install_docdir</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	775	</span></font></code>
	776	This has increased the flexibility of the documentation installation
	777	and removed the need for the option
	778
	779	<code><font color="blue"><span style='white-space: nowrap'><br/>
	780	-D cppad_documentation=</span></font><i><font color="black"><span style='white-space: nowrap'>yes_or_no</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	781	</span></font></code>
	782	which has been removed.
	783
	784	<br/>
	785	<br/>
	786	<b><big><a name="01-21" id="01-21">01-21</a></big></b>
	787	<br/>
	788	The destination directory for the
	789	cppad documentation
	790	used to be one of the following:
	791
	792	<code><font color="blue"><span style='white-space: nowrap'><br/>
	793	</span></font><i><font color="black"><span style='white-space: nowrap'>prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>/</span></font><i><font color="black"><span style='white-space: nowrap'>datadir</span></font></i><font color="blue"><span style='white-space: nowrap'>/doc/cppad-</span></font><i><font color="black"><span style='white-space: nowrap'>version</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	794	</span></font><i><font color="black"><span style='white-space: nowrap'>prefix</span></font></i><font color="blue"><span style='white-space: nowrap'>/</span></font><i><font color="black"><span style='white-space: nowrap'>datadir</span></font></i><font color="blue"><span style='white-space: nowrap'>/doc/</span></font><i><font color="black"><span style='white-space: nowrap'>postfix</span></font></i><font color="blue"><span style='white-space: nowrap'>cppad-</span></font><i><font color="black"><span style='white-space: nowrap'>version</span></font></i><font color="blue"><span style='white-space: nowrap'><br/>
	795	</span></font></code>
	796	This has been changed by dropping the
	797	<code><i><font color="black"><span style='white-space: nowrap'>version</span></font></i></code>
	798	number
	799	at the end of the directory name.
	800
	801	<br/>
	802	<br/>
	803	<b><big><a name="01-10" id="01-10">01-10</a></big></b>
	804	<br/>
	805	The change on <a href="whats_new_13.xml#12-27" target="_top"><span style='white-space: nowrap'>2013-12-27</span></a>
	806
	807	caused a conversion error in <a href="atan2.xml" target="_top"><span style='white-space: nowrap'>atan2</span></a>
	808	when it was used with
	809	<code><font color="blue">AD< AD<double> ></font></code> arguments (and other similar cases).
	810	This has been fixed.
	811
	812
	813	<hr/>Input File: omh/whats_new/whats_new_14.omh
	814
	815	</body>
	816	</html>

+27

-13

doc/wishlist.xml less more

3	3	>
4	4	<head>
5	5	<title>The CppAD Wish List</title>
	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
6	7	<meta name="description" id="description" content="The CppAD Wish List"/>
7		<meta name="keywords" id="keywords" content=" wish list new features adolc atan2 checkpoint forward iterator compile speed Ad<double> testing machine epsilon sequence operation optimize tape preprocessor tracing "/>
	8	<meta name="keywords" id="keywords" content=" the cppad wish list new features adolc atan2 benderquad checkpointing checkpoint conditional expressions nesting sparsity forward mode recomputation iterator interface library compile speed Ad<double> multiple directions numeric limits testing machine epsilon operation sequence optimization optimize tape expression hashing variable pairs preprocessor symbols software guidelines boost tracing "/>
8	9	<style type='text/css'>
9	10	body { color : black }
10	11	body { background-color : white }

85	86	<option>Forward Mode Recomputation</option>
86	87	<option>Iterator Interface</option>
87	88	<option>Library</option>
88		<option>Multiple Argument Forward</option>
	89	<option>Multiple Directions</option>
89	90	<option>Numeric Limits</option>
90	91	<option>Operation Sequence</option>
91	92	<option>Optimization</option>

223	224	<b><big><a name="Forward Mode Recomputation" id="Forward Mode Recomputation">Forward Mode Recomputation</a></big></b>
224	225
225	226	<br/>
226		If the results of <a href="forwardany.xml" target="_top"><span style='white-space: nowrap'>ForwardAny</span></a>
	227	If the results of <a href="forward_order.xml" target="_top"><span style='white-space: nowrap'>forward_order</span></a>
227	228	have already been computed and are still
228	229	stored in the <a href="adfun.xml" target="_top"><span style='white-space: nowrap'>ADFun</span></a>
229		object (see <a href="size_taylor.xml" target="_top"><span style='white-space: nowrap'>size_taylor</span></a>
	230	object (see <a href="size_order.xml" target="_top"><span style='white-space: nowrap'>size_order</span></a>
230	231	),
231	232	then they do not need to be recomputed and the results can just be returned.
232	233

263	264
264	265	<br/>
265	266	<br/>
266		<b><big><a name="Multiple Argument Forward" id="Multiple Argument Forward">Multiple Argument Forward</a></big></b>
267
268
269		<br/>
270		It has been suggested that computing and storing forward mode
271		results for multiple argument values
272		is faster for Adolc.
273		Perhaps CppAD should allow for forward mode at
274		multiple argument values.
	267	<b><big><a name="Multiple Directions" id="Multiple Directions">Multiple Directions</a></big></b>
	268
	269
	270
	271	<ol type="1"><li>
	272	Extend the <a href="forward_dir.xml" target="_top"><span style='white-space: nowrap'>forward_dir</span></a>
	273	routine so they can do multiple orders
	274	as well as multiple directions at the same time.
	275	</li><li>
	276
	277	Extend the <a href="atomic.xml" target="_top"><span style='white-space: nowrap'>atomic</span></a>
	278	functions so they can use multiple directions
	279	and multiple orders at the same time
	280	(currently they compute one direction and one order at a time).
	281	</li><li>
	282
	283	Extend the <a href="reverse.xml" target="_top"><span style='white-space: nowrap'>Reverse</span></a>
	284	routines so they can handle one reverse direction
	285	for multiple forward directions, or multiple reverse directions for
	286	one forward direction.
	287	</li></ol>
	288
275	289
276	290	<br/>
277	291	<br/>

+48

-44

doc.omh less more

0		$Id: doc.omh 3099 2014-02-18 03:29:44Z bradbell $
	0	$Id: doc.omh 3509 2014-12-27 20:38:37Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

20	20	Down_up_1%_up_1%
21	21	Down_up_0%_up_0%
22	22	Current%Headings
	23	%$$
	24	$comment -------------------------------------------------------------
	25	default automatic indexing command for all CppAD documentaiton
	26	$$
	27	$aindex section head subhead$$
	28	$comment -------------------------------------------------------------
	29	Latex used throughout the CppAD documentation
	30	$$
	31	$latex
	32	\newcommand{\W}[1]{ \; #1 \; }
	33	\newcommand{\R}[1]{ {\rm #1} }
	34	\newcommand{\B}[1]{ {\bf #1} }
	35	\newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} }
	36	\newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} }
	37	\newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} }
	38	\newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }
	39	$$
	40	$comment -------------------------------------------------------------
	41	hilite commands used throughout the CppAD documentation
	42	$$
	43	$hilitecmd%
	44	verbatim%
	45	codep
	46	%$$
	47	$hiliteseq%
	48
	49	CppAD::%AD%<% AD
	50	% %AD%<% AD
	51
	52	%CppAD::%ADFun%<% FunConstruct
	53	% %ADFun%<% FunConstruct
	54
	55	% %CPPAD_TESTVECTOR%(% testvector
	56
	57	%.%Forward%(% Forward
	58
	59	%CppAD::%Independent%(% Independent
	60	% %Independent%(% Independent
	61
	62	%.%Jacobian%(% Jacobian
	63
	64	%CppAD::%NearEqual%(% NearEqual
	65	% %NearEqual%(% NearEqual
	66
	67	%.%Reverse%(% Reverse
23	68	%$$
24	69	$spell
25	70	cppad.hpp

49	94
50	95	$comment bin/version assumes that : follows cppad version number here$$
51	96	$section
52		cppad-20140000.3: A Package for Differentiation of C++ Algorithms
	97	cppad-20150000.0: A Package for Differentiation of C++ Algorithms
53	98	$$
54	99
55	100	$comment This comment is used to remove the table below$$

225	270	omh/appendix.omh
226	271	%$$
227	272
228		$latex
229		% --------------------------------------------------------------------
230		% Latex macros defined here and used throughout the CppAD documentation
231		\newcommand{\W}[1]{ \; #1 \; }
232		\newcommand{\R}[1]{ {\rm #1} }
233		\newcommand{\B}[1]{ {\bf #1} }
234		\newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} }
235		\newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} }
236		\newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} }
237		\newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }
238		$$
239		$comment -------------------------------------------------------------
240		hilite commands used throughout the CppAD documentation
241		$$
242		$hilitecmd%
243		verbatim%
244		codep
245		%$$
246		$hiliteseq%
247
248		CppAD::%AD%<% AD
249		% %AD%<% AD
250
251		%CppAD::%ADFun%<% FunConstruct
252		% %ADFun%<% FunConstruct
253
254		% %CPPAD_TESTVECTOR%(% testvector
255
256		%.%Forward%(% Forward
257
258		%CppAD::%Independent%(% Independent
259		% %Independent%(% Independent
260
261		%.%Jacobian%(% Jacobian
262
263		%CppAD::%NearEqual%(% NearEqual
264		% %NearEqual%(% NearEqual
265
266		%.%Reverse%(% Reverse
267		%$$
268
269	273	$end

+27

-30

example/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2991 2013-10-22 16:25:15Z bradbell $
	0	# $Id: CMakeLists.txt 3301 2014-05-24 05:20:21Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

15	15	# empty, Debug, Release, RelWithDebInfo and MinSizeRel
16	16	SET(CMAKE_BUILD_TYPE DEBUG)
17	17
	18	# initialize check_depends
	19	SET(check_depends example)
	20
18	21	# atomic examples
19	22	ADD_SUBDIRECTORY(atomic)
	23	add_to_list(check_depends check_example_atomic)
20	24
21	25	# adolc_prefix
22		IF ( adolc_prefix )
23		# Extra source files if we are including adolc
24		SET(adolc_sources
25		mul_level_adolc.cpp mul_level_adolc_ode.cpp
26		)
27		# Adds -D define flags to the compilation of source files.
28		ADD_DEFINITIONS("-DCPPAD_ADOLC_EXAMPLES")
29		# add adolc to list of libraries
30		SET(example_adolc adolc)
31		ELSE ( adolc_prefix )
32		SET(adolc_sources "")
33		SET(example_adolc "")
34		ENDIF ( adolc_prefix )
	26	SET(sources mul_level_adolc.cpp mul_level_adolc_ode.cpp)
	27	sources_libs_define(adolc "${sources}" adolc ADOLC_EXAMPLES)
	28
	29	# colpack_prefix
	30	SET(sources colpack.cpp ../cppad/local/cppad_colpack.cpp)
	31	sources_libs_define(colpack "${sources}" ColPack COLPACK_EXAMPLES)
35	32
36	33	# eigen_prefix
37	34	IF ( eigen_prefix )
38	35	# compile eigen library separately so can use different compiler flags
39		ADD_LIBRARY(example_eigen
	36	ADD_LIBRARY(example_eigen_lib EXCLUDE_FROM_ALL
40	37	eigen_det.cpp
41	38	eigen_array.cpp
42	39	)
43	40	# Adds -D define flags to the compilation of source files.
44	41	ADD_DEFINITIONS("-DCPPAD_EIGEN_EXAMPLES")
45		add_cppad_cxx_flags(example_eigen)
	42	add_cppad_cxx_flags(example_eigen_lib)
46	43	#
47	44	# Add eigen to list of libraries
48		SET(example_eigen example_eigen)
	45	SET(eigen_libs example_eigen_lib)
49	46	ELSE ( eigen_prefix )
50		SET(example_eigen "")
	47	SET(eigen_libs "")
51	48	ENDIF ( eigen_prefix )
52	49
53	50	# ipopt_prefix
54	51	IF( ipopt_prefix )
55	52	ADD_SUBDIRECTORY(ipopt_solve)
56		SET(example_ipopt check_example_ipopt_solve)
57		ELSE( ipopt_prefix )
58		SET(example_ipopt "")
	53	add_to_list(check_depends check_example_ipopt_solve)
59	54	ENDIF( ipopt_prefix )
60	55
61	56

72	67	# )
73	68	ADD_EXECUTABLE(example EXCLUDE_FROM_ALL example.cpp
74	69	${adolc_sources}
	70	${colpack_sources}
75	71	abort_recording.cpp
76	72	abs.cpp
77	73	acos.cpp

90	86	base_require.cpp
91	87	bender_quad.cpp
92	88	bool_fun.cpp
93		capacity_taylor.cpp
	89	capacity_order.cpp
94	90	change_const.cpp
95	91	check_for_nan.cpp
96	92	check_numeric_type.cpp

112	108	for_one.cpp
113	109	for_two.cpp
114	110	forward.cpp
115		forward_mul.cpp
	111	forward_dir.cpp
	112	forward_order.cpp
116	113	for_sparse_jac.cpp
117	114	fun_assign.cpp
118	115	fun_check.cpp

204	201	add_cppad_cxx_flags(example)
205	202
206	203	# List of libraries to be linked into the specified target
207		TARGET_LINK_LIBRARIES(example ${example_adolc} ${example_eigen})
	204	TARGET_LINK_LIBRARIES(example
	205	${adolc_libs}
	206	${colpack_libs}
	207	${eigen_libs}
	208	)
208	209
209	210	# Add the check_example target
210		ADD_CUSTOM_TARGET(check_example example DEPENDS
211		example
212		check_example_atomic
213		${example_ipopt}
214		)
	211	ADD_CUSTOM_TARGET(check_example example DEPENDS ${check_depends})

-1

example/atomic/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3012 2013-11-27 22:00:48Z bradbell $
	0	# $Id: CMakeLists.txt 3505 2014-12-26 15:06:54Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3	#

19	19	atomic.cpp
20	20	checkpoint.cpp
21	21	get_started.cpp
	22	hes_sparse.cpp
22	23	mat_mul.cpp
23	24	norm_sq.cpp
24	25	reciprocal.cpp

-1

example/atomic/atomic.cpp less more

0		/* $Id: atomic.cpp 3012 2013-11-27 22:00:48Z bradbell $ */
	0	/* $Id: atomic.cpp 3505 2014-12-26 15:06:54Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3

21	21	// external complied tests
22	22	extern bool checkpoint(void);
23	23	extern bool get_started(void);
	24	extern bool hes_sparse(void);
24	25	extern bool mat_mul(void);
25	26	extern bool norm_sq(void);
26	27	extern bool reciprocal(void);

59	60	// external compiled tests
60	61	ok &= Run( checkpoint, "checkpoint" );
61	62	ok &= Run( get_started, "get_started" );
	63	ok &= Run( hes_sparse, "hes_sparse" );
62	64	ok &= Run( mat_mul, "mat_mul" );
63	65	ok &= Run( norm_sq, "norm_sq" );
64	66	ok &= Run( reciprocal, "reciprocal" );

+17

-17

example/atomic/checkpoint.cpp less more

0		/* $Id: checkpoint.cpp 2905 2013-09-20 14:39:39Z bradbell $ */
	0	/* $Id: checkpoint.cpp 3160 2014-03-05 17:04:14Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

112	112	ok &= check_yes.size_var() < check_not.size_var();
113	113
114	114	// compare forward mode results for orders 0, 1, 2
115		size_t p = 2;
116		CPPAD_TESTVECTOR(double) x_p(n(p+1)), z_not(m(p+1)), z_yes(m*(p+1));
	115	size_t q = 2;
	116	CPPAD_TESTVECTOR(double) x_q(n(q+1)), z_not(m(q+1)), z_yes(m*(q+1));
117	117	for(j = 0; j < n; j++)
118		{ for(k = 0; k <= p; k++)
119		x_p[ j * (p+1) + k ] = 1.0 / (p + 1 - k);
	118	{ for(k = 0; k <= q; k++)
	119	x_q[ j * (q+1) + k ] = 1.0 / (q + 1 - k);
120	120	}
121		z_not = check_not.Forward(p, x_p);
122		z_yes = check_yes.Forward(p, x_p);
	121	z_not = check_not.Forward(q, x_q);
	122	z_yes = check_yes.Forward(q, x_q);
123	123	for(i = 0; i < m; i++)
124		{ for(k = 0; k <= p; k++)
125		{ double zik_not = z_not[ i * (p+1) + k];
126		double zik_yes = z_yes[ i * (p+1) + k];
	124	{ for(k = 0; k <= q; k++)
	125	{ double zik_not = z_not[ i * (q+1) + k];
	126	double zik_yes = z_yes[ i * (q+1) + k];
127	127	ok &= NearEqual(zik_not, zik_yes, eps, eps);
128	128	}
129	129	}
130	130
131	131	// compare reverse mode results
132		CPPAD_TESTVECTOR(double) w(m(p+1)), dw_not(n(p+1)), dw_yes(n*(p+1));
133		dw_not = check_not.Reverse(p+1, w);
134		dw_yes = check_yes.Reverse(p+1, w);
	132	CPPAD_TESTVECTOR(double) w(m(q+1)), dw_not(n(q+1)), dw_yes(n*(q+1));
	133	dw_not = check_not.Reverse(q+1, w);
	134	dw_yes = check_yes.Reverse(q+1, w);
135	135	for(j = 0; j < n; j++)
136		{ for(k = 0; k <= p; k++)
137		{ double dwjk_not = dw_not[ j * (p+1) + k];
138		double dwjk_yes = dw_yes[ j * (p+1) + k];
	136	{ for(k = 0; k <= q; k++)
	137	{ double dwjk_not = dw_not[ j * (q+1) + k];
	138	double dwjk_yes = dw_yes[ j * (q+1) + k];
139	139	ok &= NearEqual(dwjk_not, dwjk_yes, eps, eps);
140	140	}
141	141	}

+13

-13

example/atomic/get_started.cpp less more

0		// $Id: get_started.cpp 2905 2013-09-20 14:39:39Z bradbell $
	0	// $Id: get_started.cpp 3160 2014-03-05 17:04:14Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

44	44	$codep */
45	45	// forward mode routine called by CppAD
46	46	virtual bool forward(
	47	size_t p ,
47	48	size_t q ,
48		size_t p ,
49	49	const vector<bool>& vx ,
50	50	vector<bool>& vy ,
51	51	const vector<double>& tx ,
52	52	vector<double>& ty
53	53	)
54		{ size_t n = tx.size() / (p + 1);
55		size_t m = ty.size() / (p + 1);
	54	{ size_t n = tx.size() / (q + 1);
	55	size_t m = ty.size() / (q + 1);
56	56	assert( n == 1 );
57	57	assert( m == 1 );
58	58
59	59	// return flag
60		bool ok = p == 0;
	60	bool ok = q == 0;
61	61	if( ! ok )
62	62	return ok;
63	63

70	70	// This case must always be implemented
71	71	// y^0 = f( x^0 ) = 1 / x^0
72	72	double f = 1. / tx[0];
73		if( q <= 0 )
	73	if( p <= 0 )
74	74	ty[0] = f;
75	75	return ok;
76	76	}

129	129	ok &= NearEqual( Value(ay[0]) , check, eps, eps);
130	130
131	131	// check zero order forward mode
132		size_t p;
133		vector<double> x_p(n), y_p(m);
134		p = 0;
135		x_p[0] = x0;
136		y_p = f.Forward(p, x_p);
137		ok &= NearEqual(y_p[0] , check, eps, eps);
	132	size_t q;
	133	vector<double> x_q(n), y_q(m);
	134	q = 0;
	135	x_q[0] = x0;
	136	y_q = f.Forward(q, x_q);
	137	ok &= NearEqual(y_q[0] , check, eps, eps);
138	138
139	139	return ok;
140	140	}

+271

-0

example/atomic/hes_sparse.cpp less more

	0	// $Id$
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	/*
	12	$begin atomic_hes_sparse.cpp$$
	13
	14	$section Atomic Operation Hessian Sparsity: Example and Test$$
	15	$index hessian, atomic operation sparsity$$
	16	$index atomic, hessian sparsity $$
	17	$index operation, atomic hessian sparsity$$
	18	$index sparsity, atomic hessian$$
	19
	20	$head Purpose$$
	21	This example demonstrates calculation of the Hessian sparsity pattern
	22	for an atomic operation.
	23
	24	$nospell
	25
	26	$head Start Class Definition$$
	27	$codep */
	28	# include <cppad/cppad.hpp>
	29	namespace { // isolate items below to this file
	30	using CppAD::vector; // abbreviate as vector
	31	//
	32	// a utility to compute the union of two sets.
	33	void my_union(
	34	std::set<size_t>& result ,
	35	const std::set<size_t>& left ,
	36	const std::set<size_t>& right )
	37	{ std::set<size_t> temp;
	38	std::set_union(
	39	left.begin() ,
	40	left.end() ,
	41	right.begin() ,
	42	right.end() ,
	43	std::inserter(temp, temp.begin())
	44	);
	45	result.swap(temp);
	46	}
	47	//
	48	class atomic_hes_sparse : public CppAD::atomic_base<double> {
	49	/* $$
	50	$head Constructor $$
	51	$codep */
	52	public:
	53	// constructor (could use const char* for name)
	54	atomic_hes_sparse(const std::string& name) :
	55	CppAD::atomic_base<double>(name)
	56	{ }
	57	private:
	58	/* $$
	59	$head forward$$
	60	$codep */
	61	// forward mode routine called by CppAD
	62	virtual bool forward(
	63	size_t p ,
	64	size_t q ,
	65	const vector<bool>& vx ,
	66	vector<bool>& vy ,
	67	const vector<double>& tx ,
	68	vector<double>& ty
	69	)
	70	{ size_t n = tx.size() / (q + 1);
	71	size_t m = ty.size() / (q + 1);
	72	assert( n == 2 );
	73	assert( m == 2 );
	74
	75	// return flag
	76	bool ok = q == 0;
	77	if( ! ok )
	78	return ok;
	79
	80	// check for defining variable information
	81	// This case must always be implemented
	82	if( vx.size() > 0 )
	83	{ vy[0] = vx[0];
	84	vy[1] = vx[0] \|\| vy[0];
	85	}
	86
	87	// Order zero forward mode.
	88	// This case must always be implemented
	89	// y^0 = f( x^0 ) = [ x0_0 * x0_0 , x0_0 * x0_1 ]^T
	90	assert( p <= 0 );
	91	if( p <= 0 )
	92	{ ty[0] = tx[0] * tx[0];
	93	ty[1] = tx[0] * tx[1];
	94	}
	95	return ok;
	96	}
	97	/* $$
	98	$head for_sparse_jac$$
	99	$codep */
	100	// forward Jacobian set sparsity routine called by CppAD
	101	virtual bool for_sparse_jac(
	102	size_t p ,
	103	const vector< std::set<size_t> >& r ,
	104	vector< std::set<size_t> >& s )
	105	{ // This function needed if using f.ForSparseJac
	106	// with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
	107	size_t n = r.size();
	108	size_t m = s.size();
	109	assert( n == 2 );
	110	assert( m == 2 );
	111
	112	// sparsity for S(x) = f'(x) * R is union of rows of R
	113	s[0] = r[0];
	114	my_union(s[1], r[0], r[1]);
	115
	116	return true;
	117	}
	118	/* $$
	119	$head rev_sparse_hes$$
	120	$codep */
	121	// reverse Hessian set sparsity routine called by CppAD
	122	virtual bool rev_sparse_hes(
	123	const vector<bool>& vx,
	124	const vector<bool>& s ,
	125	vector<bool>& t ,
	126	size_t p ,
	127	const vector< std::set<size_t> >& r ,
	128	const vector< std::set<size_t> >& u ,
	129	vector< std::set<size_t> >& v )
	130	{ // This function needed if using RevSparseHes
	131	// with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
	132	size_t n = vx.size();
	133	size_t m = s.size();
	134	assert( t.size() == n );
	135	assert( r.size() == n );
	136	assert( u.size() == m );
	137	assert( v.size() == n );
	138	assert( n == 2 );
	139	assert( m == 2 );
	140
	141	// There are no cross term second derivatives for this case,
	142	// so it is not necessary to vx.
	143
	144	// sparsity for T(x) = S(x) * f'(x)
	145	t[0] = s[0];
	146	t[1] = s[0] \|\| s[1];
	147
	148	// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
	149	// U(x) = g''(y) * f'(x) * R
	150	// S(x) = g'(y)
	151
	152	// back propagate the sparsity for U,
	153	// note both components of f'(x) may be non-zero;
	154	v[0] = u[0];
	155	my_union(v[1], u[0], u[1]);
	156
	157	// include forward Jacobian sparsity in Hessian sparsity
	158	// f_0''(x) * R
	159	if( s[0] )
	160	my_union(v[0], v[0], r[0] );
	161	// f_1''(x) * R
	162	if( s[1] )
	163	{ my_union(v[1], v[1], r[0] );
	164	my_union(v[0], v[0], r[1] );
	165	}
	166	return true;
	167	}
	168	}; // End of atomic_hes_sparse class
	169
	170	/* $$
	171	$head Use Atomic Function$$
	172	$codep */
	173	bool use_atomic_hes_sparse(bool x_1_variable)
	174	{ bool ok = true;
	175	using CppAD::AD;
	176	using CppAD::NearEqual;
	177	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	178	//
	179	// Create the atomic hes_sparse object
	180	atomic_hes_sparse afun("atomic_hes_sparse");
	181	//
	182	// Create the function f(u)
	183	//
	184	// domain space vector
	185	size_t n = 2;
	186	double x0_0 = 0.75, x0_1 = 2.00;
	187	vector< AD<double> > au(n);
	188	au[0] = x0_0;
	189	au[1] = x0_1;
	190
	191	// declare independent variables and start tape recording
	192	CppAD::Independent(au);
	193
	194	// range space vector
	195	size_t m = 2;
	196	vector< AD<double> > ay(m);
	197
	198	// call user function
	199	vector< AD<double> > ax(n);
	200	ax[0] = au[0];
	201	if( x_1_variable )
	202	ax[1] = au[1];
	203	else
	204	ax[1] = x0_1;
	205	afun(ax, ay); // y = [ x[0] * x[0] , x[0] * x[1] ] ^T
	206
	207	// create f: u -> y and stop tape recording
	208	CppAD::ADFun<double> f;
	209	f.Dependent (au, ay); // f(u) = y
	210	//
	211	// check function value
	212	double check_y0_0 = x0_0 * x0_0;
	213	double check_y0_1 = x0_0 * x0_1;
	214	ok &= NearEqual( Value(ay[0]) , check_y0_0, eps, eps);
	215	ok &= NearEqual( Value(ay[1]) , check_y0_1, eps, eps);
	216
	217	// check zero order forward mode
	218	size_t q;
	219	vector<double> uq(n), yq(m);
	220	q = 0;
	221	uq[0] = x0_0;
	222	uq[1] = x0_1;
	223	yq = f.Forward(q, uq);
	224	ok &= NearEqual(yq[0] , check_y0_0, eps, eps);
	225	ok &= NearEqual(yq[1] , check_y0_1, eps, eps);
	226
	227	// forward sparse jacobian
	228	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
	229	vector< std::set<size_t> > r(2), jac_s(2), check_s(2);
	230	r[0].insert(0);
	231	r[1].insert(1);
	232	jac_s = f.ForSparseJac(n, r);
	233	check_s[0].insert(0);
	234	ok &= jac_s[0] == check_s[0];
	235	check_s[1].insert(0);
	236	if( x_1_variable )
	237	check_s[1].insert(1);
	238	ok &= jac_s[1] == check_s[1];
	239
	240	// reverse sparse Hessian
	241	vector< std::set<size_t> > h(2), check_h(2), hes_s(1);
	242	hes_s[0].insert(0);
	243	hes_s[0].insert(1);
	244	h = f.RevSparseHes(n, hes_s);
	245	check_h[0].insert(0);
	246	if( x_1_variable )
	247	check_h[0].insert(1);
	248	ok &= h[0] == check_h[0];
	249	if( x_1_variable )
	250	check_h[1].insert(0);
	251	ok &= h[1] == check_h[1];
	252
	253	return ok;
	254	}
	255	} // End empty namespace
	256	/* $$
	257	$head Test with x_1 Both a Variable and a Parameter$$
	258	$codep */
	259	bool hes_sparse(void)
	260	{ bool ok = true;
	261	// test with x_1 a variable
	262	ok &= use_atomic_hes_sparse(true);
	263	// test with x_1 a parameter
	264	ok &= use_atomic_hes_sparse(false);
	265	return ok;
	266	}
	267	/* $$
	268	$$ $comment end nospell$$
	269	$end
	270	*/

-1

example/atomic/makefile.am less more

0		# $Id: makefile.am 3015 2013-11-30 13:16:23Z bradbell $
	0	# $Id: makefile.am 3505 2014-12-26 15:06:54Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3	#

26	26	atomic.cpp \
27	27	checkpoint.cpp \
28	28	get_started.cpp \
	29	hes_sparse.cpp \
29	30	mat_mul.cpp \
30	31	norm_sq.cpp \
31	32	reciprocal.cpp \

+154

-79

example/atomic/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = atomic$(EXEEXT)
51	80	subdir = example/atomic
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

58	88	CONFIG_CLEAN_FILES =
59	89	CONFIG_CLEAN_VPATH_FILES =
60	90	am_atomic_OBJECTS = atomic.$(OBJEXT) checkpoint.$(OBJEXT) \
61		get_started.$(OBJEXT) mat_mul.$(OBJEXT) norm_sq.$(OBJEXT) \
62		reciprocal.$(OBJEXT) tangent.$(OBJEXT) old_mat_mul.$(OBJEXT) \
63		old_reciprocal.$(OBJEXT) old_tan.$(OBJEXT) \
64		old_usead_1.$(OBJEXT) old_usead_2.$(OBJEXT)
	91	get_started.$(OBJEXT) hes_sparse.$(OBJEXT) mat_mul.$(OBJEXT) \
	92	norm_sq.$(OBJEXT) reciprocal.$(OBJEXT) tangent.$(OBJEXT) \
	93	old_mat_mul.$(OBJEXT) old_reciprocal.$(OBJEXT) \
	94	old_tan.$(OBJEXT) old_usead_1.$(OBJEXT) old_usead_2.$(OBJEXT)
65	95	atomic_OBJECTS = $(am_atomic_OBJECTS)
66	96	atomic_LDADD = $(LDADD)
	97	AM_V_P = $(am__v_P_@AM_V@)
	98	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	99	am__v_P_0 = false
	100	am__v_P_1 = :
	101	AM_V_GEN = $(am__v_GEN_@AM_V@)
	102	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	103	am__v_GEN_0 = @echo " GEN " $@;
	104	am__v_GEN_1 =
	105	AM_V_at = $(am__v_at_@AM_V@)
	106	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	107	am__v_at_0 = @
	108	am__v_at_1 =
67	109	DEFAULT_INCLUDES =
68	110	depcomp = $(SHELL) $(top_srcdir)/depcomp
69	111	am__depfiles_maybe = depfiles

72	114	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
73	115	AM_V_CXX = $(am__v_CXX_@AM_V@)
74	116	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
75		am__v_CXX_0 = @echo " CXX " $@;
76		AM_V_at = $(am__v_at_@AM_V@)
77		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
78		am__v_at_0 = @
	117	am__v_CXX_0 = @echo " CXX " $@;
	118	am__v_CXX_1 =
79	119	CXXLD = $(CXX)
80	120	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
81	121	-o $@
82	122	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
83	123	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
84		am__v_CXXLD_0 = @echo " CXXLD " $@;
	124	am__v_CXXLD_0 = @echo " CXXLD " $@;
	125	am__v_CXXLD_1 =
85	126	COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
86	127	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
87	128	AM_V_CC = $(am__v_CC_@AM_V@)
88	129	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
89		am__v_CC_0 = @echo " CC " $@;
	130	am__v_CC_0 = @echo " CC " $@;
	131	am__v_CC_1 =
90	132	CCLD = $(CC)
91	133	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
92	134	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
93	135	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
94		am__v_CCLD_0 = @echo " CCLD " $@;
95		AM_V_GEN = $(am__v_GEN_@AM_V@)
96		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
97		am__v_GEN_0 = @echo " GEN " $@;
	136	am__v_CCLD_0 = @echo " CCLD " $@;
	137	am__v_CCLD_1 =
98	138	SOURCES = $(atomic_SOURCES)
99	139	DIST_SOURCES = $(atomic_SOURCES)
100	140	am__can_run_installinfo = \

102	142	n\|no\|NO) false;; \
103	143	*) (install-info --version) >/dev/null 2>&1;; \
104	144	esac
	145	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	146	# Read a list of newline-separated strings from the standard input,
	147	# and print each of them once, without duplicates. Input order is
	148	# not preserved.
	149	am__uniquify_input = $(AWK) '\
	150	BEGIN { nonempty = 0; } \
	151	{ items[$$0] = 1; nonempty = 1; } \
	152	END { if (nonempty) { for (i in items) print i; }; } \
	153	'
	154	# Make sure the list of sources is unique. This is necessary because,
	155	# e.g., the same source file might be shared among _SOURCES variables
	156	# for different programs/libraries.
	157	am__define_uniq_tagged_files = \
	158	list='$(am__tagged_files)'; \
	159	unique=`for i in $$list; do \
	160	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	161	done \| $(am__uniquify_input)`
105	162	ETAGS = etags
106	163	CTAGS = ctags
107	164	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

111	168	ADOLC_DIR = @ADOLC_DIR@
112	169	AMTAR = @AMTAR@
113	170	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	171	AR = @AR@
114	172	AUTOCONF = @AUTOCONF@
115	173	AUTOHEADER = @AUTOHEADER@
116	174	AUTOMAKE = @AUTOMAKE@

133	191	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
134	192	CYGPATH_W = @CYGPATH_W@
135	193
136		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	194	# $Id: makefile.in 3506 2014-12-26 15:06:59Z bradbell $
137	195	# -----------------------------------------------------------------------------
138	196	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
139	197	#

200	258	abs_srcdir = @abs_srcdir@
201	259	abs_top_builddir = @abs_top_builddir@
202	260	abs_top_srcdir = @abs_top_srcdir@
	261	ac_ct_AR = @ac_ct_AR@
203	262	ac_ct_CC = @ac_ct_CC@
204	263	ac_ct_CXX = @ac_ct_CXX@
205	264	ac_ct_FC = @ac_ct_FC@

210	269	am__tar = @am__tar@
211	270	am__untar = @am__untar@
212	271	bindir = @bindir@
	272	build = @build@
213	273	build_alias = @build_alias@
	274	build_cpu = @build_cpu@
	275	build_os = @build_os@
	276	build_vendor = @build_vendor@
214	277	builddir = @builddir@
215	278	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
216	279	cppad_boostvector = @cppad_boostvector@
217	280	cppad_cflags = @cppad_cflags@
	281	cppad_compiler_has_erf = @cppad_compiler_has_erf@
218	282	cppad_cppadvector = @cppad_cppadvector@
219	283	cppad_description = @cppad_description@
220	284	cppad_eigenvector = @cppad_eigenvector@
	285	cppad_has_colpack = @cppad_has_colpack@
	286	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
221	287	cppad_has_gettimeofday = @cppad_has_gettimeofday@
222	288	cppad_has_nullptr = @cppad_has_nullptr@
	289	cppad_has_rvalue = @cppad_has_rvalue@
223	290	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
224	291	cppad_internal_sparse_set = @cppad_internal_sparse_set@
225	292	cppad_libs = @cppad_libs@
226	293	cppad_max_num_threads = @cppad_max_num_threads@
227	294	cppad_requires = @cppad_requires@
228		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	295	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
229	296	cppad_stdvector = @cppad_stdvector@
230	297	cppad_tape_addr_type = @cppad_tape_addr_type@
231	298	cppad_tape_id_type = @cppad_tape_id_type@

237	304	dvidir = @dvidir@
238	305	eigen_prefix = @eigen_prefix@
239	306	exec_prefix = @exec_prefix@
240		have_ar = @have_ar@
241	307	have_pkg_config = @have_pkg_config@
	308	host = @host@
242	309	host_alias = @host_alias@
	310	host_cpu = @host_cpu@
	311	host_os = @host_os@
	312	host_vendor = @host_vendor@
243	313	htmldir = @htmldir@
244	314	includedir = @includedir@
245	315	infodir = @infodir@

277	347	atomic.cpp \
278	348	checkpoint.cpp \
279	349	get_started.cpp \
	350	hes_sparse.cpp \
280	351	mat_mul.cpp \
281	352	norm_sq.cpp \
282	353	reciprocal.cpp \

325	396
326	397	clean-checkPROGRAMS:
327	398	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	399
328	400	atomic$(EXEEXT): $(atomic_OBJECTS) $(atomic_DEPENDENCIES) $(EXTRA_atomic_DEPENDENCIES)
329	401	@rm -f atomic$(EXEEXT)
330	402	$(AM_V_CXXLD)$(CXXLINK) $(atomic_OBJECTS) $(atomic_LDADD) $(LIBS)

338	410	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/atomic.Po@am__quote@
339	411	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/checkpoint.Po@am__quote@
340	412	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get_started.Po@am__quote@
	413	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hes_sparse.Po@am__quote@
341	414	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mat_mul.Po@am__quote@
342	415	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/norm_sq.Po@am__quote@
343	416	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/old_mat_mul.Po@am__quote@

349	422	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tangent.Po@am__quote@
350	423
351	424	.cpp.o:
352		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
353		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	425	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	426	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	427	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
354	428	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
355	429	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
356	430	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
357	431
358	432	.cpp.obj:
359		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
360		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	433	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	434	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	435	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
361	436	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
362	437	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
363	438	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
364	439
365		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
366		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
367		unique=`for i in $$list; do \
368		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
369		done \| \
370		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
371		END { if (nonempty) { for (i in files) print i; }; }'`; \
372		mkid -fID $$unique
373		tags: TAGS
374
375		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
376		$(TAGS_FILES) $(LISP)
	440	ID: $(am__tagged_files)
	441	$(am__define_uniq_tagged_files); mkid -fID $$unique
	442	tags: tags-am
	443	TAGS: tags
	444
	445	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
377	446	set x; \
378	447	here=`pwd`; \
379		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
380		unique=`for i in $$list; do \
381		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
382		done \| \
383		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
384		END { if (nonempty) { for (i in files) print i; }; }'`; \
	448	$(am__define_uniq_tagged_files); \
385	449	shift; \
386	450	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
387	451	test -n "$$unique" \|\| unique=$$empty_fix; \

393	457	$$unique; \
394	458	fi; \
395	459	fi
396		ctags: CTAGS
397		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
398		$(TAGS_FILES) $(LISP)
399		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
400		unique=`for i in $$list; do \
401		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
402		done \| \
403		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
404		END { if (nonempty) { for (i in files) print i; }; }'`; \
	460	ctags: ctags-am
	461
	462	CTAGS: ctags
	463	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	464	$(am__define_uniq_tagged_files); \
405	465	test -z "$(CTAGS_ARGS)$$unique" \
406	466	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
407	467	$$unique

410	470	here=`$(am__cd) $(top_builddir) && pwd` \
411	471	&& $(am__cd) $(top_srcdir) \
412	472	&& gtags -i $(GTAGS_ARGS) "$$here"
	473	cscopelist: cscopelist-am
	474
	475	cscopelist-am: $(am__tagged_files)
	476	list='$(am__tagged_files)'; \
	477	case "$(srcdir)" in \
	478	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	479	*) sdir=$(subdir)/$(srcdir) ;; \
	480	esac; \
	481	for i in $$list; do \
	482	if test -f "$$i"; then \
	483	echo "$(subdir)/$$i"; \
	484	else \
	485	echo "$$sdir/$$i"; \
	486	fi; \
	487	done >> $(top_builddir)/cscope.files
413	488
414	489	distclean-tags:
415	490	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

550	625
551	626	.MAKE: check-am install-am install-strip
552	627
553		.PHONY: CTAGS GTAGS all all-am check check-am clean \
554		clean-checkPROGRAMS clean-generic ctags distclean \
555		distclean-compile distclean-generic distclean-tags distdir dvi \
556		dvi-am html html-am info info-am install install-am \
557		install-data install-data-am install-dvi install-dvi-am \
558		install-exec install-exec-am install-html install-html-am \
559		install-info install-info-am install-man install-pdf \
560		install-pdf-am install-ps install-ps-am install-strip \
561		installcheck installcheck-am installdirs maintainer-clean \
562		maintainer-clean-generic mostlyclean mostlyclean-compile \
563		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
564		uninstall-am
	628	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	629	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	630	distclean distclean-compile distclean-generic distclean-tags \
	631	distdir dvi dvi-am html html-am info info-am install \
	632	install-am install-data install-data-am install-dvi \
	633	install-dvi-am install-exec install-exec-am install-html \
	634	install-html-am install-info install-info-am install-man \
	635	install-pdf install-pdf-am install-ps install-ps-am \
	636	install-strip installcheck installcheck-am installdirs \
	637	maintainer-clean maintainer-clean-generic mostlyclean \
	638	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	639	tags tags-am uninstall uninstall-am
565	640
566	641
567	642	test: check

+75

-75

example/atomic/norm_sq.cpp less more

0		// $Id: norm_sq.cpp 3013 2013-11-29 10:31:32Z bradbell $
	0	// $Id: norm_sq.cpp 3160 2014-03-05 17:04:14Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

69	69	$codep */
70	70	// forward mode routine called by CppAD
71	71	virtual bool forward(
	72	size_t p ,
72	73	size_t q ,
73		size_t p ,
74	74	const vector<bool>& vx ,
75	75	vector<bool>& vy ,
76	76	const vector<double>& tx ,
77	77	vector<double>& ty
78	78	)
79		{ size_t n = tx.size() / (p+1);
80		size_t m = ty.size() / (p+1);
81		assert( n == 2 );
82		assert( m == 1 );
83		assert( q <= p );
	79	{ size_t n = tx.size() / (q+1);
	80	size_t m = ty.size() / (q+1);
	81	assert( n == 2 );
	82	assert( m == 1 );
	83	assert( p <= q );
84	84
85	85	// return flag
86		bool ok = p <= 1;
	86	bool ok = q <= 1;
87	87
88	88	// Variable information must always be implemented.
89	89	// y_0 is a variable if and only if x_0 or x_1 is a variable.

92	92
93	93	// Order zero forward mode must always be implemented.
94	94	// y^0 = f( x^0 )
95		double x_00 = tx[ 0*(p+1) + 0]; // x_0^0
96		double x_10 = tx[ 1*(p+1) + 0]; // x_10
	95	double x_00 = tx[ 0*(q+1) + 0]; // x_0^0
	96	double x_10 = tx[ 1*(q+1) + 0]; // x_10
97	97	double f = x_00 * x_00 + x_10 * x_10; // f( x^0 )
	98	if( p <= 0 )
	99	ty[0] = f; // y_0^0
98	100	if( q <= 0 )
99		ty[0] = f; // y_0^0
100		if( p <= 0 )
101	101	return ok;
102	102	assert( vx.size() == 0 );
103	103
104	104	// Order one forward mode.
105	105	// This case needed if first order forward mode is used.
106	106	// y^1 = f'( x^0 ) x^1
107		double x_01 = tx[ 0*(p+1) + 1]; // x_0^1
108		double x_11 = tx[ 1*(p+1) + 1]; // x_1^1
	107	double x_01 = tx[ 0*(q+1) + 1]; // x_0^1
	108	double x_11 = tx[ 1*(q+1) + 1]; // x_1^1
109	109	double fp_0 = 2.0 * x_00; // partial f w.r.t x_0^0
110	110	double fp_1 = 2.0 * x_10; // partial f w.r.t x_1^0
	111	if( p <= 1 )
	112	ty[1] = fp_0 * x_01 + fp_1 * x_11; // f'( x^0 ) * x^1
111	113	if( q <= 1 )
112		ty[1] = fp_0 * x_01 + fp_1 * x_11; // f'( x^0 ) * x^1
113		if( p <= 1 )
114	114	return ok;
115	115
116	116	// Assume we are not using forward mode with order > 1

122	122	$codep */
123	123	// reverse mode routine called by CppAD
124	124	virtual bool reverse(
125		size_t p ,
	125	size_t q ,
126	126	const vector<double>& tx ,
127	127	const vector<double>& ty ,
128	128	vector<double>& px ,
129	129	const vector<double>& py
130	130	)
131		{ size_t n = tx.size() / (p+1);
132		size_t m = ty.size() / (p+1);
133		assert( px.size() == n * (p+1) );
134		assert( py.size() == m * (p+1) );
135		assert( n == 2 );
136		assert( m == 1 );
137		bool ok = p <= 1;
	131	{ size_t n = tx.size() / (q+1);
	132	size_t m = ty.size() / (q+1);
	133	assert( px.size() == n * (q+1) );
	134	assert( py.size() == m * (q+1) );
	135	assert( n == 2 );
	136	assert( m == 1 );
	137	bool ok = q <= 1;
138	138
139	139	double fp_0, fp_1;
140		switch(p)
	140	switch(q)
141	141	{ case 0:
142	142	// This case needed if first order reverse mode is used
143	143	// F ( {x} ) = f( x^0 ) = y^0

149	149	break;
150	150
151	151	default:
152		// Assume we are not using reverse with order > 1 (p > 0)
	152	// Assume we are not using reverse with order > 1 (q > 0)
153	153	assert(!ok);
154	154	}
155	155	return ok;

159	159	$codep */
160	160	// forward Jacobian bool sparsity routine called by CppAD
161	161	virtual bool for_sparse_jac(
162		size_t q ,
	162	size_t p ,
163	163	const vector<bool>& r ,
164	164	vector<bool>& s )
165	165	{ // This function needed if using f.ForSparseJac
166	166	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
167		size_t n = r.size() / q;
168		size_t m = s.size() / q;
	167	size_t n = r.size() / p;
	168	size_t m = s.size() / p;
169	169	assert( n == 2 );
170	170	assert( m == 1 );
171	171
172	172	// sparsity for S(x) = f'(x) * R
173	173	// where f'(x) = 2 * [ x_0, x_1 ]
174		for(size_t j = 0; j < q; j++)
	174	for(size_t j = 0; j < p; j++)
175	175	{ s[j] = false;
176	176	for(size_t i = 0; i < n; i++)
177		s[j] \|= r[i * q + j];
	177	s[j] \|= r[i * p + j];
178	178	}
179	179	return true;
180	180	}
181	181	// forward Jacobian set sparsity routine called by CppAD
182	182	virtual bool for_sparse_jac(
183		size_t q ,
	183	size_t p ,
184	184	const vector< std::set<size_t> >& r ,
185	185	vector< std::set<size_t> >& s )
186	186	{ // This function needed if using f.ForSparseJac

201	201	$codep */
202	202	// reverse Jacobian bool sparsity routine called by CppAD
203	203	virtual bool rev_sparse_jac(
204		size_t q ,
	204	size_t p ,
205	205	const vector<bool>& rt ,
206	206	vector<bool>& st )
207	207	{ // This function needed if using RevSparseJac or optimize
208	208	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
209		size_t n = st.size() / q;
210		size_t m = rt.size() / q;
	209	size_t n = st.size() / p;
	210	size_t m = rt.size() / p;
211	211	assert( n == 2 );
212	212	assert( m == 1 );
213	213
214	214	// sparsity for S(x)^T = f'(x)^T * R^T
215	215	// where f'(x)^T = 2 * [ x_0, x_1]^T
216		for(size_t j = 0; j < q; j++)
	216	for(size_t j = 0; j < p; j++)
217	217	for(size_t i = 0; i < n; i++)
218		st[i * q + j] = rt[j];
	218	st[i * p + j] = rt[j];
219	219
220	220	return true;
221	221	}
222	222	// reverse Jacobian set sparsity routine called by CppAD
223	223	virtual bool rev_sparse_jac(
224		size_t q ,
	224	size_t p ,
225	225	const vector< std::set<size_t> >& rt ,
226	226	vector< std::set<size_t> >& st )
227	227	{ // This function needed if using RevSparseJac or optimize

246	246	const vector<bool>& vx,
247	247	const vector<bool>& s ,
248	248	vector<bool>& t ,
249		size_t q ,
	249	size_t p ,
250	250	const vector<bool>& r ,
251	251	const vector<bool>& u ,
252	252	vector<bool>& v )

254	254	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
255	255	size_t m = s.size();
256	256	size_t n = t.size();
257		assert( r.size() == n * q );
258		assert( u.size() == m * q );
259		assert( v.size() == n * q );
	257	assert( r.size() == n * p );
	258	assert( u.size() == m * p );
	259	assert( v.size() == n * p );
260	260	assert( n == 2 );
261	261	assert( m == 1 );
262	262

273	273
274	274	// back propagate the sparsity for U
275	275	size_t j;
276		for(j = 0; j < q; j++)
	276	for(j = 0; j < p; j++)
277	277	for(size_t i = 0; i < n; i++)
278		v[ i * q + j] = u[j];
	278	v[ i * p + j] = u[j];
279	279
280	280	// include forward Jacobian sparsity in Hessian sparsity
281	281	// sparsity for g'(y) * f''(x) * R (Note f''(x) has same sparsity
282	282	// as the identity matrix)
283	283	if( s[0] )
284		{ for(j = 0; j < q; j++)
	284	{ for(j = 0; j < p; j++)
285	285	for(size_t i = 0; i < n; i++)
286		v[ i * q + j] \|= r[ i * q + j];
	286	v[ i * p + j] \|= r[ i * p + j];
287	287	}
288	288
289	289	return true;

293	293	const vector<bool>& vx,
294	294	const vector<bool>& s ,
295	295	vector<bool>& t ,
296		size_t q ,
	296	size_t p ,
297	297	const vector< std::set<size_t> >& r ,
298	298	const vector< std::set<size_t> >& u ,
299	299	vector< std::set<size_t> >& v )

390	390	ok &= NearEqual( Value(ay[0]) , check, eps, eps);
391	391
392	392	// check zero order forward mode
393		size_t p;
394		vector<double> x_p(n), y_p(m);
395		p = 0;
396		x_p[0] = x0;
397		x_p[1] = x1;
398		y_p = f.Forward(p, x_p);
399		ok &= NearEqual(y_p[0] , check, eps, eps);
	393	size_t q;
	394	vector<double> x_q(n), y_q(m);
	395	q = 0;
	396	x_q[0] = x0;
	397	x_q[1] = x1;
	398	y_q = f.Forward(q, x_q);
	399	ok &= NearEqual(y_q[0] , check, eps, eps);
400	400
401	401	// check first order forward mode
402		p = 1;
403		x_p[0] = 0.3;
404		x_p[1] = 0.7;
405		y_p = f.Forward(p, x_p);
406		check = 2.0 * x0 * x_p[0] + 2.0 * x1 * x_p[1];
407		ok &= NearEqual(y_p[0] , check, eps, eps);
	402	q = 1;
	403	x_q[0] = 0.3;
	404	x_q[1] = 0.7;
	405	y_q = f.Forward(q, x_q);
	406	check = 2.0 * x0 * x_q[0] + 2.0 * x1 * x_q[1];
	407	ok &= NearEqual(y_q[0] , check, eps, eps);
408	408
409	409	/* $$
410	410	$subhead reverse$$
411	411	$codep */
412	412	// first order reverse mode
413		p = 1;
414		vector<double> w(m), dw(n * p);
	413	q = 1;
	414	vector<double> w(m), dw(n * q);
415	415	w[0] = 1.;
416		dw = f.Reverse(p, w);
	416	dw = f.Reverse(q, w);
417	417	check = 2.0 * x0;
418	418	ok &= NearEqual(dw[0] , check, eps, eps);
419	419	check = 2.0 * x1;

422	422	$subhead for_sparse_jac$$
423	423	$codep */
424	424	// forward mode sparstiy pattern
425		size_t q = n;
426		CppAD::vectorBool r1(n * q), s1(m * q);
	425	size_t p = n;
	426	CppAD::vectorBool r1(n * p), s1(m * p);
427	427	r1[0] = true; r1[1] = false; // sparsity pattern identity
428	428	r1[2] = false; r1[3] = true;
429	429	//
430	430	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
431		s1 = f.ForSparseJac(q, r1);
	431	s1 = f.ForSparseJac(p, r1);
432	432	ok &= s1[0] == true; // f[0] depends on x[0]
433	433	ok &= s1[1] == true; // f[0] depends on x[1]
434	434	//
435	435	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
436		s1 = f.ForSparseJac(q, r1);
	436	s1 = f.ForSparseJac(p, r1);
437	437	ok &= s1[0] == true; // f[0] depends on x[0]
438	438	ok &= s1[1] == true; // f[0] depends on x[1]
439	439	/* $$
440	440	$subhead rev_sparse_jac$$
441	441	$codep */
442	442	// reverse mode sparstiy pattern
443		p = m;
444		CppAD::vectorBool s2(p * m), r2(p * n);
	443	q = m;
	444	CppAD::vectorBool s2(q * m), r2(q * n);
445	445	s2[0] = true; // compute sparsity pattern for f[0]
446	446	//
447	447	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
448		r2 = f.RevSparseJac(p, s2);
	448	r2 = f.RevSparseJac(q, s2);
449	449	ok &= r2[0] == true; // f[0] depends on x[0]
450	450	ok &= r2[1] == true; // f[0] depends on x[1]
451	451	//
452	452	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
453		r2 = f.RevSparseJac(p, s2);
	453	r2 = f.RevSparseJac(q, s2);
454	454	ok &= r2[0] == true; // f[0] depends on x[0]
455	455	ok &= r2[1] == true; // f[0] depends on x[1]
456	456	/* $$
457	457	$subhead rev_sparse_hes$$
458	458	$codep */
459	459	// Hessian sparsity (using previous ForSparseJac call)
460		CppAD::vectorBool s3(m), h(q * n);
	460	CppAD::vectorBool s3(m), h(p * n);
461	461	s3[0] = true; // compute sparsity pattern for f[0]
462	462	//
463	463	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
464		h = f.RevSparseHes(q, s3);
	464	h = f.RevSparseHes(p, s3);
465	465	ok &= h[0] == true; // partial of f[0] w.r.t. x[0],x[0] is non-zero
466	466	ok &= h[1] == false; // partial of f[0] w.r.t. x[0],x[1] is zero
467	467	ok &= h[2] == false; // partial of f[0] w.r.t. x[1],x[0] is zero
468	468	ok &= h[3] == true; // partial of f[0] w.r.t. x[1],x[1] is non-zero
469	469	//
470	470	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
471		h = f.RevSparseHes(q, s3);
	471	h = f.RevSparseHes(p, s3);
472	472	ok &= h[0] == true; // partial of f[0] w.r.t. x[0],x[0] is non-zero
473	473	ok &= h[1] == false; // partial of f[0] w.r.t. x[0],x[1] is zero
474	474	ok &= h[2] == false; // partial of f[0] w.r.t. x[1],x[0] is zero

-5

example/atomic/old_mat_mul.hpp less more

0		// $Id: old_mat_mul.hpp 2850 2013-05-24 17:49:50Z bradbell $
	0	// $Id: old_mat_mul.hpp 3160 2014-03-05 17:04:14Z bradbell $
1	1	# ifndef CPPAD_OLD_MAT_MUL_INCLUDED
2	2	# define CPPAD_OLD_MAT_MUL_INCLUDED
3	3
4	4	/* --------------------------------------------------------------------------
5		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	5	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6	6
7	7	CppAD is distributed under multiple licenses. This distribution is under
8	8	the terms of the

303	303	size_t id ,
304	304	size_t n ,
305	305	size_t m ,
306		size_t q ,
	306	size_t p ,
307	307	const vector< std::set<size_t> >& r ,
308	308	vector< std::set<size_t> >& s )
309	309	{ size_t i, j, k, im_left, middle, mj_right, ij_result;

334	334	size_t id ,
335	335	size_t n ,
336	336	size_t m ,
337		size_t q ,
	337	size_t p ,
338	338	vector< std::set<size_t> >& r ,
339	339	const vector< std::set<size_t> >& s )
340	340	{ size_t i, j, k, im_left, middle, mj_right, ij_result;

367	367	size_t id ,
368	368	size_t n ,
369	369	size_t m ,
370		size_t q ,
	370	size_t p ,
371	371	const vector< std::set<size_t> >& r ,
372	372	const vector<bool>& s ,
373	373	vector<bool>& t ,

+33

-33

example/atomic/old_reciprocal.cpp less more

0		// $Id: old_reciprocal.cpp 2899 2013-09-18 13:50:37Z bradbell $
	0	// $Id: old_reciprocal.cpp 3160 2014-03-05 17:04:14Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

73	73	double f, fp, fpp;
74	74
75	75	// Must always define the case k = 0.
76		// Do not need case k if not using f.Forward(p, xp) for p >= k.
	76	// Do not need case k if not using f.Forward(q, xp) for q >= k.
77	77	switch(k)
78	78	{ case 0:
79	79	// this case must be implemented

179	179	size_t id ,
180	180	size_t n ,
181	181	size_t m ,
182		size_t q ,
	182	size_t p ,
183	183	const vector< std::set<size_t> >& r ,
184	184	vector< std::set<size_t> >& s )
185	185	{ // Can just return false if not using f.ForSparseJac

198	198	size_t id ,
199	199	size_t n ,
200	200	size_t m ,
201		size_t q ,
	201	size_t p ,
202	202	vector< std::set<size_t> >& r ,
203	203	const vector< std::set<size_t> >& s )
204	204	{ // Can just return false if not using RevSparseJac.

207	207	assert( m == 1 );
208	208
209	209	// sparsity for R(x) = S * f'(x) is same as sparsity for S
210		for(size_t p = 0; p < q; p++)
211		r[p] = s[p];
	210	for(size_t q = 0; q < p; q++)
	211	r[q] = s[q];
212	212
213	213	return true;
214	214	}

218	218	size_t id ,
219	219	size_t n ,
220	220	size_t m ,
221		size_t q ,
	221	size_t p ,
222	222	const vector< std::set<size_t> >& r ,
223	223	const vector<bool>& s ,
224	224	vector<bool>& t ,

304	304	ok &= NearEqual( Value(ay[0]) , check, eps, eps);
305	305
306	306	// check zero order forward mode
307		size_t p;
308		vector<double> x_p(n), y_p(m);
309		p = 0;
310		x_p[0] = x0;
311		y_p = f.Forward(p, x_p);
312		ok &= NearEqual(y_p[0] , check, eps, eps);
	307	size_t q;
	308	vector<double> x_q(n), y_q(m);
	309	q = 0;
	310	x_q[0] = x0;
	311	y_q = f.Forward(q, x_q);
	312	ok &= NearEqual(y_q[0] , check, eps, eps);
313	313
314	314	// check first order forward mode
315		p = 1;
316		x_p[0] = 1;
317		y_p = f.Forward(p, x_p);
	315	q = 1;
	316	x_q[0] = 1;
	317	y_q = f.Forward(q, x_q);
318	318	check = 1.;
319		ok &= NearEqual(y_p[0] , check, eps, eps);
	319	ok &= NearEqual(y_q[0] , check, eps, eps);
320	320
321	321	// check second order forward mode
322		p = 2;
323		x_p[0] = 0;
324		y_p = f.Forward(p, x_p);
	322	q = 2;
	323	x_q[0] = 0;
	324	y_q = f.Forward(q, x_q);
325	325	check = 0.;
326		ok &= NearEqual(y_p[0] , check, eps, eps);
	326	ok &= NearEqual(y_q[0] , check, eps, eps);
327	327
328	328	// --------------------------------------------------------------------
329	329	// Check reverse mode results
330	330	//
331	331	// third order reverse mode
332		p = 3;
333		vector<double> w(m), dw(n * p);
	332	q = 3;
	333	vector<double> w(m), dw(n * q);
334	334	w[0] = 1.;
335		dw = f.Reverse(p, w);
	335	dw = f.Reverse(q, w);
336	336	check = 1.;
337	337	ok &= NearEqual(dw[0] , check, eps, eps);
338	338	check = 0.;

341	341
342	342	// --------------------------------------------------------------------
343	343	// forward mode sparstiy pattern
344		size_t q = n;
345		CppAD::vectorBool r1(n * q), s1(m * q);
	344	size_t p = n;
	345	CppAD::vectorBool r1(n * p), s1(m * p);
346	346	r1[0] = true; // compute sparsity pattern for x[0]
347		s1 = f.ForSparseJac(q, r1);
	347	s1 = f.ForSparseJac(p, r1);
348	348	ok &= s1[0] == true; // f[0] depends on x[0]
349	349
350	350	// --------------------------------------------------------------------
351	351	// reverse mode sparstiy pattern
352		p = m;
353		CppAD::vectorBool s2(p * m), r2(p * n);
	352	q = m;
	353	CppAD::vectorBool s2(q * m), r2(q * n);
354	354	s2[0] = true; // compute sparsity pattern for f[0]
355		r2 = f.RevSparseJac(p, s2);
	355	r2 = f.RevSparseJac(q, s2);
356	356	ok &= r2[0] == true; // f[0] depends on x[0]
357	357
358	358	// --------------------------------------------------------------------
359	359	// Hessian sparsity (using previous ForSparseJac call)
360		CppAD::vectorBool s3(m), h(q * n);
	360	CppAD::vectorBool s3(m), h(p * n);
361	361	s3[0] = true; // compute sparsity pattern for f[0]
362		h = f.RevSparseHes(q, s3);
	362	h = f.RevSparseHes(p, s3);
363	363	ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
364	364
365	365	// -----------------------------------------------------------------

+17

-17

example/atomic/old_tan.cpp less more

0		// $Id: old_tan.cpp 2843 2013-05-23 05:25:06Z bradbell $
	0	// $Id: old_tan.cpp 3160 2014-03-05 17:04:14Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

187	187	size_t id ,
188	188	size_t n ,
189	189	size_t m ,
190		size_t q ,
	190	size_t p ,
191	191	const vector< std::set<size_t> >& r ,
192	192	vector< std::set<size_t> >& s )
193	193	{

209	209	size_t id ,
210	210	size_t n ,
211	211	size_t m ,
212		size_t q ,
	212	size_t p ,
213	213	vector< std::set<size_t> >& r ,
214	214	const vector< std::set<size_t> >& s )
215	215	{

230	230	size_t id ,
231	231	size_t n ,
232	232	size_t m ,
233		size_t q ,
	233	size_t p ,
234	234	const vector< std::set<size_t> >& r ,
235	235	const vector<bool>& s ,
236	236	vector<bool>& t ,

372	372	ok &= NearEqual(ddw[1], w[0]tanpp + w[1]tanhpp, eps, eps);
373	373
374	374	// Forward mode computation of sparsity pattern for F.
375		size_t q = n;
	375	size_t p = n;
376	376	// user vectorBool because m and n are small
377		CppAD::vectorBool r1(q), s1(m * q);
	377	CppAD::vectorBool r1(p), s1(m * p);
378	378	r1[0] = true; // propagate sparsity for x[0]
379		s1 = F.ForSparseJac(q, r1);
	379	s1 = F.ForSparseJac(p, r1);
380	380	ok &= (s1[0] == true); // f[0] depends on x[0]
381	381	ok &= (s1[1] == true); // f[1] depends on x[0]
382	382	ok &= (s1[2] == false); // f[2] does not depend on x[0]
383	383
384	384	// Reverse mode computation of sparsity pattern for F.
385		size_t p = m;
386		CppAD::vectorBool s2(p * m), r2(p * n);
	385	size_t q = m;
	386	CppAD::vectorBool s2(q * m), r2(q * n);
387	387	// Sparsity pattern for identity matrix
388	388	size_t i, j;
389		for(i = 0; i < p; i++)
	389	for(i = 0; i < q; i++)
390	390	{ for(j = 0; j < m; j++)
391		s2[i * p + j] = (i == j);
392		}
393		r2 = F.RevSparseJac(p, s2);
	391	s2[i * q + j] = (i == j);
	392	}
	393	r2 = F.RevSparseJac(q, s2);
394	394	ok &= (r2[0] == true); // f[0] depends on x[0]
395	395	ok &= (r2[1] == true); // f[1] depends on x[0]
396	396	ok &= (r2[2] == false); // f[2] does not depend on x[0]
397	397
398	398	// Hessian sparsity for f[0]
399		CppAD::vectorBool s3(m), h(q * n);
	399	CppAD::vectorBool s3(m), h(p * n);
400	400	s3[0] = true;
401	401	s3[1] = false;
402	402	s3[2] = false;
403		h = F.RevSparseHes(q, s3);
	403	h = F.RevSparseHes(p, s3);
404	404	ok &= (h[0] == true); // Hessian is non-zero
405	405
406	406	// Hessian sparsity for f[2]
407	407	s3[0] = false;
408	408	s3[2] = true;
409		h = F.RevSparseHes(q, s3);
	409	h = F.RevSparseHes(p, s3);
410	410	ok &= (h[0] == false); // Hessian is zero
411	411
412	412	// check tanh results for a large value of x

+70

-70

example/atomic/old_usead_1.cpp less more

0		// $Id: old_usead_1.cpp 2838 2013-05-21 13:22:16Z bradbell $
	0	// $Id: old_usead_1.cpp 3160 2014-03-05 17:04:14Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

87	87	assert( m == 1 );
88	88	assert( k == 0 \|\| vx.size() == 0 );
89	89	bool ok = true;
90		vector<double> x_p(1), y_p(1);
	90	vector<double> x_q(1), y_q(1);
91	91
92	92	// check for special case
93	93	if( vx.size() > 0 )

95	95
96	96	// make sure r_ has proper lower order Taylor coefficients stored
97	97	// then compute ty[k]
98		for(size_t p = 0; p <= k; p++)
99		{ x_p[0] = tx[p];
100		y_p = r_ptr_->Forward(p, x_p);
101		if( p == k )
102		ty[k] = y_p[0];
103		assert( p == k \|\| ty[p] == y_p[0] );
	98	for(size_t q = 0; q <= k; q++)
	99	{ x_q[0] = tx[q];
	100	y_q = r_ptr_->Forward(q, x_q);
	101	if( q == k )
	102	ty[k] = y_q[0];
	103	assert( q == k \|\| ty[q] == y_q[0] );
104	104	}
105	105	return ok;
106	106	}

120	120	assert( n == 1 );
121	121	assert( m == 1 );
122	122	bool ok = true;
123		vector<double> x_p(1), w(k+1), dw(k+1);
	123	vector<double> x_q(1), w(k+1), dw(k+1);
124	124
125	125	// make sure r_ has proper forward mode coefficients
126		size_t p;
127		for(p = 0; p <= k; p++)
128		{ x_p[0] = tx[p];
	126	size_t q;
	127	for(q = 0; q <= k; q++)
	128	{ x_q[0] = tx[q];
129	129	# ifdef NDEBUG
130		r_ptr_->Forward(p, x_p);
	130	r_ptr_->Forward(q, x_q);
131	131	# else
132		vector<double> y_p(1);
133		y_p = r_ptr_->Forward(p, x_p);
134		assert( ty[p] == y_p[0] );
	132	vector<double> y_q(1);
	133	y_q = r_ptr_->Forward(q, x_q);
	134	assert( ty[q] == y_q[0] );
135	135	# endif
136	136	}
137		for(p = 0; p <=k; p++)
138		w[p] = py[p];
	137	for(q = 0; q <=k; q++)
	138	w[q] = py[q];
139	139	dw = r_ptr_->Reverse(k+1, w);
140		for(p = 0; p <=k; p++)
141		px[p] = dw[p];
	140	for(q = 0; q <=k; q++)
	141	px[q] = dw[q];
142	142
143	143	return ok;
144	144	}

148	148	size_t id ,
149	149	size_t n ,
150	150	size_t m ,
151		size_t q ,
	151	size_t p ,
152	152	const vector< std::set<size_t> >& r ,
153	153	vector< std::set<size_t> >& s )
154	154	{ assert( id == 0 );

158	158
159	159	vector< std::set<size_t> > R(1), S(1);
160	160	R[0] = r[0];
161		S = r_ptr_->ForSparseJac(q, R);
	161	S = r_ptr_->ForSparseJac(p, R);
162	162	s[0] = S[0];
163	163
164	164	return ok;

169	169	size_t id ,
170	170	size_t n ,
171	171	size_t m ,
172		size_t q ,
	172	size_t p ,
173	173	vector< std::set<size_t> >& r ,
174	174	const vector< std::set<size_t> >& s )
175	175	{

178	178	assert( m == 1 );
179	179	bool ok = true;
180	180
181		vector< std::set<size_t> > R(q), S(q);
182		size_t p;
183		for(p = 0; p < q; p++)
184		S[p] = s[p];
185		R = r_ptr_->RevSparseJac(q, S);
186		for(p = 0; p < q; p++)
187		r[p] = R[p];
	181	vector< std::set<size_t> > R(p), S(p);
	182	size_t q;
	183	for(q = 0; q < p; q++)
	184	S[q] = s[q];
	185	R = r_ptr_->RevSparseJac(p, S);
	186	for(q = 0; q < p; q++)
	187	r[q] = R[q];
188	188
189	189	return ok;
190	190	}

194	194	size_t id ,
195	195	size_t n ,
196	196	size_t m ,
197		size_t q ,
	197	size_t p ,
198	198	const vector< std::set<size_t> >& r ,
199	199	const vector<bool>& s ,
200	200	vector<bool>& t ,

213	213	t[0] = T[0];
214	214
215	215	// compute sparsity pattern for A(x) = U(x)^T * f'(x)
216		vector<bool> Ut(q), A(q);
217		size_t p;
218		for(p = 0; p < q; p++)
219		Ut[p] = false;
	216	vector<bool> Ut(p), A(p);
	217	size_t q;
	218	for(q = 0; q < p; q++)
	219	Ut[q] = false;
220	220	std::set<size_t>::iterator itr;
221	221	for(itr = u[0].begin(); itr != u[0].end(); itr++)
222	222	Ut[*itr] = true;
223		A = r_ptr_-> RevSparseJac(q, Ut);
	223	A = r_ptr_-> RevSparseJac(p, Ut);
224	224
225	225	// compute sparsity pattern for H(x) = R^T * (S * F)''(x)
226		vector<bool> H(q), R(n);
227		for(p = 0; p < q; p++)
228		R[p] = false;
	226	vector<bool> H(p), R(n);
	227	for(q = 0; q < p; q++)
	228	R[q] = false;
229	229	for(itr = r[0].begin(); itr != r[0].end(); itr++)
230	230	R[*itr] = true;
231		r_ptr_->ForSparseJac(q, R);
232		H = r_ptr_->RevSparseHes(q, S);
	231	r_ptr_->ForSparseJac(p, R);
	232	H = r_ptr_->RevSparseHes(p, S);
233	233
234	234	// compute sparsity pattern for V(x) = A(x)^T + H(x)^T
235	235	v[0].clear();
236		for(p = 0; p < q; p++)
237		if( A[p] \| H[p] )
238		v[0].insert(p);
	236	for(q = 0; q < p; q++)
	237	if( A[q] \| H[q] )
	238	v[0].insert(q);
239	239
240	240	return ok;
241	241	}

298	298	ok &= NearEqual( Value(ay[0]) , check, eps, eps);
299	299
300	300	// check zero order forward mode
301		size_t p;
302		vector<double> x_p(n), y_p(m);
303		p = 0;
304		x_p[0] = x0;
305		y_p = f.Forward(p, x_p);
306		ok &= NearEqual(y_p[0] , check, eps, eps);
	301	size_t q;
	302	vector<double> x_q(n), y_q(m);
	303	q = 0;
	304	x_q[0] = x0;
	305	y_q = f.Forward(q, x_q);
	306	ok &= NearEqual(y_q[0] , check, eps, eps);
307	307
308	308	// check first order forward mode
309		p = 1;
310		x_p[0] = 1;
311		y_p = f.Forward(p, x_p);
	309	q = 1;
	310	x_q[0] = 1;
	311	y_q = f.Forward(q, x_q);
312	312	check = 1.;
313		ok &= NearEqual(y_p[0] , check, eps, eps);
	313	ok &= NearEqual(y_q[0] , check, eps, eps);
314	314
315	315	// check second order forward mode
316		p = 2;
317		x_p[0] = 0;
318		y_p = f.Forward(p, x_p);
	316	q = 2;
	317	x_q[0] = 0;
	318	y_q = f.Forward(q, x_q);
319	319	check = 0.;
320		ok &= NearEqual(y_p[0] , check, eps, eps);
	320	ok &= NearEqual(y_q[0] , check, eps, eps);
321	321
322	322	// --------------------------------------------------------------------
323	323	// Check reverse mode results
324	324	//
325	325	// third order reverse mode
326		p = 3;
327		vector<double> w(m), dw(n * p);
	326	q = 3;
	327	vector<double> w(m), dw(n * q);
328	328	w[0] = 1.;
329		dw = f.Reverse(p, w);
	329	dw = f.Reverse(q, w);
330	330	check = 1.;
331	331	ok &= NearEqual(dw[0] , check, eps, eps);
332	332	check = 0.;

335	335
336	336	// --------------------------------------------------------------------
337	337	// forward mode sparstiy pattern
338		size_t q = n;
339		CppAD::vectorBool r1(n * q), s1(m * q);
	338	size_t p = n;
	339	CppAD::vectorBool r1(n * p), s1(m * p);
340	340	r1[0] = true; // compute sparsity pattern for x[0]
341		s1 = f.ForSparseJac(q, r1);
	341	s1 = f.ForSparseJac(p, r1);
342	342	ok &= s1[0] == true; // f[0] depends on x[0]
343	343
344	344	// --------------------------------------------------------------------
345	345	// reverse mode sparstiy pattern
346		p = m;
347		CppAD::vectorBool s2(p * m), r2(p * n);
	346	q = m;
	347	CppAD::vectorBool s2(q * m), r2(q * n);
348	348	s2[0] = true; // compute sparsity pattern for f[0]
349		r2 = f.RevSparseJac(p, s2);
	349	r2 = f.RevSparseJac(q, s2);
350	350	ok &= r2[0] == true; // f[0] depends on x[0]
351	351
352	352	// --------------------------------------------------------------------
353	353	// Hessian sparsity (using previous ForSparseJac call)
354		CppAD::vectorBool s3(m), h(q * n);
	354	CppAD::vectorBool s3(m), h(p * n);
355	355	s3[0] = true; // compute sparsity pattern for f[0]
356		h = f.RevSparseJac(q, s3);
	356	h = f.RevSparseJac(p, s3);
357	357	ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
358	358
359	359	// -----------------------------------------------------------------

+66

-66

example/atomic/old_usead_2.cpp less more

0		// $Id: old_usead_2.cpp 2838 2013-05-21 13:22:16Z bradbell $
	0	// $Id: old_usead_2.cpp 3214 2014-03-18 20:50:38Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

130	130	}
131	131	// make sure r_ has proper lower order Taylor coefficients stored
132	132	// then compute ty[k]
133		for(size_t p = 0; p <= k; p++)
	133	for(size_t q = 0; q <= k; q++)
134	134	{ for(j = 0; j < n; j++)
135		xp[j] = tx[j * (k+1) + p];
136		yp = r_ptr_->Forward(p, xp);
137		if( p == k )
	135	xp[j] = tx[j * (k+1) + q];
	136	yp = r_ptr_->Forward(q, xp);
	137	if( q == k )
138	138	{ for(i = 0; i < m; i++)
139		ty[i * (k+1) + p] = yp[i];
	139	ty[i * (k+1) + q] = yp[i];
140	140	}
141	141	# ifndef NDEBUG
142	142	else
143	143	{ for(i = 0; i < m; i++)
144		assert( ty[i * (k+1) + p] == yp[i] );
	144	assert( ty[i * (k+1) + q] == yp[i] );
145	145	}
146	146	# endif
147	147	}
148	148	// no longer need the Taylor coefficients in r_ptr_
149	149	// (have to reconstruct them every time)
150		r_ptr_->capacity_taylor(0);
	150	r_ptr_->capacity_order(0);
151	151	return ok;
152	152	}
153	153	// ----------------------------------------------------------------------

169	169	vector<double> xp(n), w( (k+1) * m ), dw( (k+1) * n );
170	170
171	171	// make sure r_ has proper forward mode coefficients
172		size_t i, j, p;
173		for(p = 0; p <= k; p++)
	172	size_t i, j, q;
	173	for(q = 0; q <= k; q++)
174	174	{ for(j = 0; j < n; j++)
175		xp[j] = tx[j * (k+1) + p];
	175	xp[j] = tx[j * (k+1) + q];
176	176	# ifdef NDEBUG
177		r_ptr_->Forward(p, xp);
	177	r_ptr_->Forward(q, xp);
178	178	# else
179	179	vector<double> yp(m);
180		yp = r_ptr_->Forward(p, xp);
	180	yp = r_ptr_->Forward(q, xp);
181	181	for(i = 0; i < m; i++)
182		assert( ty[i * (k+1) + p] == yp[i] );
	182	assert( ty[i * (k+1) + q] == yp[i] );
183	183	# endif
184	184	}
185	185	for(i = 0; i < m; i++)
186		{ for(p = 0; p <=k; p++)
187		w[ i * (k+1) + p] = py[ i * (k+1) + p];
	186	{ for(q = 0; q <=k; q++)
	187	w[ i * (k+1) + q] = py[ i * (k+1) + q];
188	188	}
189	189	dw = r_ptr_->Reverse(k+1, w);
190	190	for(j = 0; j < n; j++)
191		{ for(p = 0; p <=k; p++)
192		px[ j * (k+1) + p] = dw[ j * (k+1) + p];
	191	{ for(q = 0; q <=k; q++)
	192	px[ j * (k+1) + q] = dw[ j * (k+1) + q];
193	193	}
194	194	// no longer need the Taylor coefficients in r_ptr_
195	195	// (have to reconstruct them every time)
196		r_ptr_->capacity_taylor(0);
	196	r_ptr_->capacity_order(0);
197	197
198	198	return ok;
199	199	}

203	203	size_t id ,
204	204	size_t n ,
205	205	size_t m ,
206		size_t q ,
	206	size_t p ,
207	207	const vector< std::set<size_t> >& r ,
208	208	vector< std::set<size_t> >& s )
209	209	{ assert( id == 0 );

214	214	vector< std::set<size_t> > R(n), S(m);
215	215	for(size_t j = 0; j < n; j++)
216	216	R[j] = r[j];
217		S = r_ptr_->ForSparseJac(q, R);
	217	S = r_ptr_->ForSparseJac(p, R);
218	218	for(size_t i = 0; i < m; i++)
219	219	s[i] = S[i];
220	220

230	230	size_t id ,
231	231	size_t n ,
232	232	size_t m ,
233		size_t q ,
	233	size_t p ,
234	234	vector< std::set<size_t> >& r ,
235	235	const vector< std::set<size_t> >& s )
236	236	{

239	239	assert( m == 2 );
240	240	bool ok = true;
241	241
242		vector< std::set<size_t> > R(q), S(q);
	242	vector< std::set<size_t> > R(p), S(p);
243	243	std::set<size_t>::const_iterator itr;
244	244	size_t i;
245	245	// untranspose s

247	247	{ for(itr = s[i].begin(); itr != s[i].end(); itr++)
248	248	S[*itr].insert(i);
249	249	}
250		R = r_ptr_->RevSparseJac(q, S);
	250	R = r_ptr_->RevSparseJac(p, S);
251	251	// transpose r
252	252	for(i = 0; i < m; i++)
253	253	r[i].clear();
254		for(i = 0; i < q; i++)
	254	for(i = 0; i < p; i++)
255	255	{ for(itr = R[i].begin(); itr != R[i].end(); itr++)
256	256	r[*itr].insert(i);
257	257	}

263	263	size_t id ,
264	264	size_t n ,
265	265	size_t m ,
266		size_t q ,
	266	size_t p ,
267	267	const vector< std::set<size_t> >& r ,
268	268	const vector<bool>& s ,
269	269	vector<bool>& t ,

286	286	t = r_ptr_->RevSparseJac(1, s);
287	287
288	288	// compute sparsity pattern for A(x)^T = U(x)^T * f'(x)
289		vector< std::set<size_t> > Ut(q), At(q);
	289	vector< std::set<size_t> > Ut(p), At(p);
290	290	for(i = 0; i < m; i++)
291	291	{ for(itr = u[i].begin(); itr != u[i].end(); itr++)
292	292	Ut[*itr].insert(i);
293	293	}
294		At = r_ptr_->RevSparseJac(q, Ut);
	294	At = r_ptr_->RevSparseJac(p, Ut);
295	295
296	296	// compute sparsity pattern for H(x)^T = R^T * (S * F)''(x)
297		vector< std::set<size_t> > R(n), Ht(q);
	297	vector< std::set<size_t> > R(n), Ht(p);
298	298	for(j = 0; j < n; j++)
299	299	R[j] = r[j];
300		r_ptr_->ForSparseJac(q, R);
301		Ht = r_ptr_->RevSparseHes(q, S);
	300	r_ptr_->ForSparseJac(p, R);
	301	Ht = r_ptr_->RevSparseHes(p, S);
302	302
303	303	// compute sparsity pattern for V(x) = A(x) + H(x)^T
304	304	for(j = 0; j < n; j++)
305	305	v[j].clear();
306		for(i = 0; i < q; i++)
	306	for(i = 0; i < p; i++)
307	307	{ for(itr = At[i].begin(); itr != At[i].end(); itr++)
308	308	v[*itr].insert(i);
309	309	for(itr = Ht[i].begin(); itr != Ht[i].end(); itr++)

371	371	//
372	372	// zero order forward
373	373	vector<double> up(n), yp(m);
374		size_t p = 0;
	374	size_t q = 0;
375	375	double u0 = 0.5;
376	376	double u1 = 0.25;
377	377	double u2 = 0.75;

379	379	up[0] = u0;
380	380	up[1] = u1;
381	381	up[2] = u2;
382		yp = f.Forward(p, up);
	382	yp = f.Forward(q, up);
383	383	check = u0 + u2;
384	384	ok &= NearEqual( yp[0], check, eps, eps);
385	385	check = u1 + u0 * u2 + u2 * u2 / 2.0;
386	386	ok &= NearEqual( yp[1], check, eps, eps);
387	387	//
388	388	// forward mode first derivative w.r.t t
389		p = 1;
	389	q = 1;
390	390	up[0] = 0.0;
391	391	up[1] = 0.0;
392	392	up[2] = 1.0;
393		yp = f.Forward(p, up);
	393	yp = f.Forward(q, up);
394	394	check = 1.0;
395	395	ok &= NearEqual( yp[0], check, eps, eps);
396	396	check = u0 + u2;
397	397	ok &= NearEqual( yp[1], check, eps, eps);
398	398	//
399	399	// forward mode second order Taylor coefficient w.r.t t
400		p = 2;
	400	q = 2;
401	401	up[0] = 0.0;
402	402	up[1] = 0.0;
403	403	up[2] = 0.0;
404		yp = f.Forward(p, up);
	404	yp = f.Forward(q, up);
405	405	check = 0.0;
406	406	ok &= NearEqual( yp[0], check, eps, eps);
407	407	check = 1.0 / 2.0;
408	408	ok &= NearEqual( yp[1], check, eps, eps);
409	409	// --------------------------------------------------------------------
410	410	// reverse mode derivatives of \partial_t y_1 (t)
411		vector<double> w(m * p), dw(n * p);
412		w[0 * p + 0] = 0.0;
413		w[1 * p + 0] = 0.0;
414		w[0 * p + 1] = 0.0;
415		w[1 * p + 1] = 1.0;
416		dw = f.Reverse(p, w);
	411	vector<double> w(m * q), dw(n * q);
	412	w[0 * q + 0] = 0.0;
	413	w[1 * q + 0] = 0.0;
	414	w[0 * q + 1] = 0.0;
	415	w[1 * q + 1] = 1.0;
	416	dw = f.Reverse(q, w);
417	417	// derivative of y_1(u) = u_1 + u_0 * u_2 + u_2^2 / 2, w.r.t. u
418	418	// is equal deritative of \partial_u2 y_1(u) w.r.t \partial_u2 u
419	419	check = u2;
420		ok &= NearEqual( dw[0 * p + 1], check, eps, eps);
	420	ok &= NearEqual( dw[0 * q + 1], check, eps, eps);
421	421	check = 1.0;
422		ok &= NearEqual( dw[1 * p + 1], check, eps, eps);
	422	ok &= NearEqual( dw[1 * q + 1], check, eps, eps);
423	423	check = u0 + u2;
424		ok &= NearEqual( dw[2 * p + 1], check, eps, eps);
	424	ok &= NearEqual( dw[2 * q + 1], check, eps, eps);
425	425	// derivative of \partial_t y_1 w.r.t u = u_0 + t, w.r.t u
426	426	check = 1.0;
427		ok &= NearEqual( dw[0 * p + 0], check, eps, eps);
	427	ok &= NearEqual( dw[0 * q + 0], check, eps, eps);
428	428	check = 0.0;
429		ok &= NearEqual( dw[1 * p + 0], check, eps, eps);
	429	ok &= NearEqual( dw[1 * q + 0], check, eps, eps);
430	430	check = 1.0;
431		ok &= NearEqual( dw[2 * p + 0], check, eps, eps);
	431	ok &= NearEqual( dw[2 * q + 0], check, eps, eps);
432	432	// --------------------------------------------------------------------
433	433	// forward mode sparsity pattern for the Jacobian
434	434	// f_u = [ 1, 0, 1 ]
435	435	// [ u_2, 1, u_2 ]
436		size_t i, j, q = n;
437		CppAD::vectorBool r(n * q), s(m * q);
	436	size_t i, j, p = n;
	437	CppAD::vectorBool r(n * p), s(m * p);
438	438	// r = identity sparsity pattern
439	439	for(i = 0; i < n; i++)
440		for(j = 0; j < q; j++)
	440	for(j = 0; j < p; j++)
441	441	r[i*n +j] = (i == j);
442		s = f.ForSparseJac(q, r);
443		ok &= s[ 0 * q + 0] == true;
444		ok &= s[ 0 * q + 1] == false;
445		ok &= s[ 0 * q + 2] == true;
446		ok &= s[ 1 * q + 0] == true;
447		ok &= s[ 1 * q + 1] == true;
448		ok &= s[ 1 * q + 2] == true;
	442	s = f.ForSparseJac(p, r);
	443	ok &= s[ 0 * p + 0] == true;
	444	ok &= s[ 0 * p + 1] == false;
	445	ok &= s[ 0 * p + 2] == true;
	446	ok &= s[ 1 * p + 0] == true;
	447	ok &= s[ 1 * p + 1] == true;
	448	ok &= s[ 1 * p + 2] == true;
449	449	// --------------------------------------------------------------------
450	450	// reverse mode sparsity pattern for the Jacobian
451		p = m;
452		s.resize(p * m);
453		r.resize(p * n);
	451	q = m;
	452	s.resize(q * m);
	453	r.resize(q * n);
454	454	// s = identity sparsity pattern
455		for(i = 0; i < p; i++)
	455	for(i = 0; i < q; i++)
456	456	for(j = 0; j < m; j++)
457	457	s[i*m +j] = (i == j);
458		r = f.RevSparseJac(p, s);
	458	r = f.RevSparseJac(q, s);
459	459	ok &= r[ 0 * n + 0] == true;
460	460	ok &= r[ 0 * n + 1] == false;
461	461	ok &= r[ 0 * n + 2] == true;

+68

-68

example/atomic/reciprocal.cpp less more

0		// $Id: reciprocal.cpp 3008 2013-11-13 14:59:21Z bradbell $
	0	// $Id: reciprocal.cpp 3160 2014-03-05 17:04:14Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

63	63	$codep */
64	64	// forward mode routine called by CppAD
65	65	virtual bool forward(
	66	size_t p ,
66	67	size_t q ,
67		size_t p ,
68	68	const vector<bool>& vx ,
69	69	vector<bool>& vy ,
70	70	const vector<double>& tx ,
71	71	vector<double>& ty
72	72	)
73		{ size_t n = tx.size() / (p + 1);
74		size_t m = ty.size() / (p + 1);
75		assert( n == 1 );
76		assert( m == 1 );
77		assert( q <= p );
	73	{ size_t n = tx.size() / (q + 1);
	74	size_t m = ty.size() / (q + 1);
	75	assert( n == 1 );
	76	assert( m == 1 );
	77	assert( p <= q );
78	78
79	79	// return flag
80		bool ok = p <= 2;
	80	bool ok = q <= 2;
81	81
82	82	// check for defining variable information
83	83	// This case must always be implemented

88	88	// This case must always be implemented
89	89	// y^0 = f( x^0 ) = 1 / x^0
90	90	double f = 1. / tx[0];
	91	if( p <= 0 )
	92	ty[0] = f;
91	93	if( q <= 0 )
92		ty[0] = f;
93		if( p <= 0 )
94	94	return ok;
95	95	assert( vx.size() == 0 );
96	96

98	98	// This case needed if first order forward mode is used.
99	99	// y^1 = f'( x^0 ) x^1
100	100	double fp = - f / tx[0];
	101	if( p <= 1 )
	102	ty[1] = fp * tx[1];
101	103	if( q <= 1 )
102		ty[1] = fp * tx[1];
103		if( p <= 1 )
104	104	return ok;
105	105
106	106	// Order two forward mode.

109	109	// 2 y^2 = x^1 * f''( x^0 ) x^1 + 2 f'( x^0 ) x^2
110	110	double fpp = - 2.0 * fp / tx[0];
111	111	ty[2] = tx[1] * fpp * tx[1] / 2.0 + fp * tx[2];
112		if( p <= 2 )
	112	if( q <= 2 )
113	113	return ok;
114	114
115	115	// Assume we are not using forward mode with order > 2

121	121	$codep */
122	122	// reverse mode routine called by CppAD
123	123	virtual bool reverse(
124		size_t p ,
	124	size_t q ,
125	125	const vector<double>& tx ,
126	126	const vector<double>& ty ,
127	127	vector<double>& px ,
128	128	const vector<double>& py
129	129	)
130		{ size_t n = tx.size() / (p + 1);
131		size_t m = ty.size() / (p + 1);
132		assert( px.size() == n * (p + 1) );
133		assert( py.size() == m * (p + 1) );
134		assert( n == 1 );
135		assert( m == 1 );
136		bool ok = p <= 2;
	130	{ size_t n = tx.size() / (q + 1);
	131	size_t m = ty.size() / (q + 1);
	132	assert( px.size() == n * (q + 1) );
	133	assert( py.size() == m * (q + 1) );
	134	assert( n == 1 );
	135	assert( m == 1 );
	136	bool ok = q <= 2;
137	137
138	138	double f, fp, fpp, fppp;
139		switch(p)
	139	switch(q)
140	140	{ case 0:
141	141	// This case needed if first order reverse mode is used
142	142	// reverse: F^0 ( tx ) = y^0 = f( x^0 )

188	188	$codep */
189	189	// forward Jacobian bool sparsity routine called by CppAD
190	190	virtual bool for_sparse_jac(
191		size_t q ,
	191	size_t p ,
192	192	const vector<bool>& r ,
193	193	vector<bool>& s )
194	194	{ // This function needed if using f.ForSparseJac
195	195	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
196		size_t n = r.size() / q;
197		size_t m = s.size() / q;
	196	size_t n = r.size() / p;
	197	size_t m = s.size() / p;
198	198	assert( n == 1 );
199	199	assert( m == 1 );
200	200
201	201	// sparsity for S(x) = f'(x) * R is same as sparsity for R
202		for(size_t j = 0; j < q; j++)
	202	for(size_t j = 0; j < p; j++)
203	203	s[j] = r[j];
204	204
205	205	return true;
206	206	}
207	207	// forward Jacobian set sparsity routine called by CppAD
208	208	virtual bool for_sparse_jac(
209		size_t q ,
	209	size_t p ,
210	210	const vector< std::set<size_t> >& r ,
211	211	vector< std::set<size_t> >& s )
212	212	{ // This function needed if using f.ForSparseJac

226	226	$codep */
227	227	// reverse Jacobian bool sparsity routine called by CppAD
228	228	virtual bool rev_sparse_jac(
229		size_t q ,
	229	size_t p ,
230	230	const vector<bool>& rt ,
231	231	vector<bool>& st )
232	232	{ // This function needed if using RevSparseJac or optimize
233	233	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
234		size_t n = st.size() / q;
235		size_t m = rt.size() / q;
	234	size_t n = st.size() / p;
	235	size_t m = rt.size() / p;
236	236	assert( n == 1 );
237	237	assert( m == 1 );
238	238
239	239	// sparsity for S(x)^T = f'(x)^T * R^T is same as sparsity for R^T
240		for(size_t i = 0; i < q; i++)
	240	for(size_t i = 0; i < p; i++)
241	241	st[i] = rt[i];
242	242
243	243	return true;
244	244	}
245	245	// reverse Jacobian set sparsity routine called by CppAD
246	246	virtual bool rev_sparse_jac(
247		size_t q ,
	247	size_t p ,
248	248	const vector< std::set<size_t> >& rt ,
249	249	vector< std::set<size_t> >& st )
250	250	{ // This function needed if using RevSparseJac or optimize

267	267	const vector<bool>& vx,
268	268	const vector<bool>& s ,
269	269	vector<bool>& t ,
270		size_t q ,
	270	size_t p ,
271	271	const vector<bool>& r ,
272	272	const vector<bool>& u ,
273	273	vector<bool>& v )

275	275	// with afun.option( CppAD::atomic_base<double>::bool_sparsity_enum )
276	276	size_t m = s.size();
277	277	size_t n = t.size();
278		assert( r.size() == n * q );
279		assert( u.size() == m * q );
280		assert( v.size() == n * q );
	278	assert( r.size() == n * p );
	279	assert( u.size() == m * p );
	280	assert( v.size() == n * p );
281	281	assert( n == 1 );
282	282	assert( m == 1 );
283	283

293	293
294	294	// back propagate the sparsity for U, note f'(x) may be non-zero;
295	295	size_t j;
296		for(j = 0; j < q; j++)
	296	for(j = 0; j < p; j++)
297	297	v[j] = u[j];
298	298
299	299	// include forward Jacobian sparsity in Hessian sparsity
300	300	// (note sparsty for f''(x) * R same as for R)
301	301	if( s[0] )
302		{ for(j = 0; j < q; j++)
	302	{ for(j = 0; j < p; j++)
303	303	v[j] \|= r[j];
304	304	}
305	305

310	310	const vector<bool>& vx,
311	311	const vector<bool>& s ,
312	312	vector<bool>& t ,
313		size_t q ,
	313	size_t p ,
314	314	const vector< std::set<size_t> >& r ,
315	315	const vector< std::set<size_t> >& u ,
316	316	vector< std::set<size_t> >& v )

401	401	ok &= NearEqual( Value(ay[0]) , check, eps, eps);
402	402
403	403	// check zero order forward mode
404		size_t p;
405		vector<double> x_p(n), y_p(m);
406		p = 0;
407		x_p[0] = x0;
408		y_p = f.Forward(p, x_p);
409		ok &= NearEqual(y_p[0] , check, eps, eps);
	404	size_t q;
	405	vector<double> x_q(n), y_q(m);
	406	q = 0;
	407	x_q[0] = x0;
	408	y_q = f.Forward(q, x_q);
	409	ok &= NearEqual(y_q[0] , check, eps, eps);
410	410
411	411	// check first order forward mode
412		p = 1;
413		x_p[0] = 1;
414		y_p = f.Forward(p, x_p);
	412	q = 1;
	413	x_q[0] = 1;
	414	y_q = f.Forward(q, x_q);
415	415	check = 1.;
416		ok &= NearEqual(y_p[0] , check, eps, eps);
	416	ok &= NearEqual(y_q[0] , check, eps, eps);
417	417
418	418	// check second order forward mode
419		p = 2;
420		x_p[0] = 0;
421		y_p = f.Forward(p, x_p);
	419	q = 2;
	420	x_q[0] = 0;
	421	y_q = f.Forward(q, x_q);
422	422	check = 0.;
423		ok &= NearEqual(y_p[0] , check, eps, eps);
	423	ok &= NearEqual(y_q[0] , check, eps, eps);
424	424	/* $$
425	425	$subhead reverse$$
426	426	$codep */
427	427	// third order reverse mode
428		p = 3;
429		vector<double> w(m), dw(n * p);
	428	q = 3;
	429	vector<double> w(m), dw(n * q);
430	430	w[0] = 1.;
431		dw = f.Reverse(p, w);
	431	dw = f.Reverse(q, w);
432	432	check = 1.;
433	433	ok &= NearEqual(dw[0] , check, eps, eps);
434	434	check = 0.;

438	438	$subhead for_sparse_jac$$
439	439	$codep */
440	440	// forward mode sparstiy pattern
441		size_t q = n;
442		CppAD::vectorBool r1(n * q), s1(m * q);
	441	size_t p = n;
	442	CppAD::vectorBool r1(n * p), s1(m * p);
443	443	r1[0] = true; // compute sparsity pattern for x[0]
444	444	//
445	445	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
446		s1 = f.ForSparseJac(q, r1);
	446	s1 = f.ForSparseJac(p, r1);
447	447	ok &= s1[0] == true; // f[0] depends on x[0]
448	448	//
449	449	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
450		s1 = f.ForSparseJac(q, r1);
	450	s1 = f.ForSparseJac(p, r1);
451	451	ok &= s1[0] == true; // f[0] depends on x[0]
452	452	/* $$
453	453	$subhead rev_sparse_jac$$
454	454	$codep */
455	455	// reverse mode sparstiy pattern
456		p = m;
457		CppAD::vectorBool s2(p * m), r2(p * n);
	456	q = m;
	457	CppAD::vectorBool s2(q * m), r2(q * n);
458	458	s2[0] = true; // compute sparsity pattern for f[0]
459	459	//
460	460	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
461		r2 = f.RevSparseJac(p, s2);
	461	r2 = f.RevSparseJac(q, s2);
462	462	ok &= r2[0] == true; // f[0] depends on x[0]
463	463	//
464	464	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
465		r2 = f.RevSparseJac(p, s2);
	465	r2 = f.RevSparseJac(q, s2);
466	466	ok &= r2[0] == true; // f[0] depends on x[0]
467	467	/* $$
468	468	$subhead rev_sparse_hes$$
469	469	$codep */
470	470	// Hessian sparsity (using previous ForSparseJac call)
471		CppAD::vectorBool s3(m), h(q * n);
	471	CppAD::vectorBool s3(m), h(p * n);
472	472	s3[0] = true; // compute sparsity pattern for f[0]
473	473	//
474	474	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
475		h = f.RevSparseHes(q, s3);
	475	h = f.RevSparseHes(p, s3);
476	476	ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
477	477	//
478	478	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
479		h = f.RevSparseHes(q, s3);
	479	h = f.RevSparseHes(p, s3);
480	480	ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
481	481
482	482	return ok;

+62

-62

example/atomic/tangent.cpp less more

0		// $Id: tangent.cpp 2905 2013-09-20 14:39:39Z bradbell $
	0	// $Id: tangent.cpp 3160 2014-03-05 17:04:14Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

67	67	$codep */
68	68	// forward mode routine called by CppAD
69	69	bool forward(
	70	size_t p ,
70	71	size_t q ,
71		size_t p ,
72	72	const vector<bool>& vx ,
73	73	vector<bool>& vzy ,
74	74	const vector<float>& tx ,
75	75	vector<float>& tzy
76	76	)
77		{ size_t p1 = p + 1;
78		size_t n = tx.size() / p1;
79		size_t m = tzy.size() / p1;
80		assert( n == 1 );
81		assert( m == 2 );
82		assert( q <= p );
	77	{ size_t q1 = q + 1;
	78	size_t n = tx.size() / q1;
	79	size_t m = tzy.size() / q1;
	80	assert( n == 1 );
	81	assert( m == 2 );
	82	assert( p <= q );
83	83	size_t j, k;
84	84
85	85	// check if this is during the call to old_tan(id, ax, ay)

89	89	vzy[1] = vx[0];
90	90	}
91	91
92		if( q == 0 )
	92	if( p == 0 )
93	93	{ // z^{(0)} = tan( x^{(0)} ) or tanh( x^{(0)} )
94	94	if( hyperbolic_ )
95	95	tzy[0] = tanh( tx[0] );
96	96	else tzy[0] = tan( tx[0] );
97	97
98	98	// y^{(0)} = z^{(0)} * z^{(0)}
99		tzy[p1 + 0] = tzy[0] * tzy[0];
	99	tzy[q1 + 0] = tzy[0] * tzy[0];
100	100
101		q++;
	101	p++;
102	102	}
103		for(j = q; j <= p; j++)
	103	for(j = p; j <= q; j++)
104	104	{ float j_inv = 1.f / float(j);
105	105	if( hyperbolic_ )
106	106	j_inv = - j_inv;

108	108	// z^{(j)} = x^{(j)} +- sum_{k=1}^j k x^{(k)} y^{(j-k)} / j
109	109	tzy[j] = tx[j];
110	110	for(k = 1; k <= j; k++)
111		tzy[j] += tx[k] * tzy[p1 + j-k] * k * j_inv;
	111	tzy[j] += tx[k] * tzy[q1 + j-k] * k * j_inv;
112	112
113	113	// y^{(j)} = sum_{k=0}^j z^{(k)} z^{(j-k)}
114		tzy[p1 + j] = 0.;
	114	tzy[q1 + j] = 0.;
115	115	for(k = 0; k <= j; k++)
116		tzy[p1 + j] += tzy[k] * tzy[j-k];
	116	tzy[q1 + j] += tzy[k] * tzy[j-k];
117	117	}
118	118
119	119	// All orders are implemented and there are no possible errors

124	124	$codep */
125	125	// reverse mode routine called by CppAD
126	126	virtual bool reverse(
127		size_t p ,
	127	size_t q ,
128	128	const vector<float>& tx ,
129	129	const vector<float>& tzy ,
130	130	vector<float>& px ,
131	131	const vector<float>& pzy
132	132	)
133		{ size_t p1 = p + 1;
134		size_t n = tx.size() / p1;
135		size_t m = tzy.size() / p1;
136		assert( px.size() == n * p1 );
137		assert( pzy.size() == m * p1 );
	133	{ size_t q1 = q + 1;
	134	size_t n = tx.size() / q1;
	135	size_t m = tzy.size() / q1;
	136	assert( px.size() == n * q1 );
	137	assert( pzy.size() == m * q1 );
138	138	assert( n == 1 );
139	139	assert( m == 2 );
140	140

144	144	vector<float> qzy = pzy;
145	145
146	146	// initialize accumultion of reverse mode partials
147		for(k = 0; k < p1; k++)
	147	for(k = 0; k < q1; k++)
148	148	px[k] = 0.;
149	149
150	150	// eliminate positive orders
151		for(j = p; j > 0; j--)
	151	for(j = q; j > 0; j--)
152	152	{ float j_inv = 1.f / float(j);
153	153	if( hyperbolic_ )
154	154	j_inv = - j_inv;

156	156	// H_{x^{(k)}} += delta(j-k) +- H_{z^{(j)} y^{(j-k)} * k / j
157	157	px[j] += qzy[j];
158	158	for(k = 1; k <= j; k++)
159		px[k] += qzy[j] * tzy[p1 + j-k] * k * j_inv;
	159	px[k] += qzy[j] * tzy[q1 + j-k] * k * j_inv;
160	160
161	161	// H_{y^{j-k)} += +- H_{z^{(j)} x^{(k)} * k / j
162	162	for(k = 1; k <= j; k++)
163		qzy[p1 + j-k] += qzy[j] * tx[k] * k * j_inv;
	163	qzy[q1 + j-k] += qzy[j] * tx[k] * k * j_inv;
164	164
165	165	// H_{z^{(k)}} += H_{y^{(j-1)}} * z^{(j-k-1)} * 2.
166	166	for(k = 0; k < j; k++)
167		qzy[k] += qzy[p1 + j-1] * tzy[j-k-1] * 2.f;
	167	qzy[k] += qzy[q1 + j-1] * tzy[j-k-1] * 2.f;
168	168	}
169	169
170	170	// eliminate order zero
171	171	if( hyperbolic_ )
172		px[0] += qzy[0] * (1.f - tzy[p1 + 0]);
	172	px[0] += qzy[0] * (1.f - tzy[q1 + 0]);
173	173	else
174		px[0] += qzy[0] * (1.f + tzy[p1 + 0]);
	174	px[0] += qzy[0] * (1.f + tzy[q1 + 0]);
175	175
176	176	return true;
177	177	}

180	180	$codep */
181	181	// forward Jacobian sparsity routine called by CppAD
182	182	virtual bool for_sparse_jac(
183		size_t q ,
	183	size_t p ,
184	184	const vector<bool>& r ,
185	185	vector<bool>& s )
186		{ size_t n = r.size() / q;
187		size_t m = s.size() / q;
	186	{ size_t n = r.size() / p;
	187	size_t m = s.size() / p;
188	188	assert( n == 1 );
189	189	assert( m == 2 );
190	190
191	191	// sparsity for S(x) = f'(x) * R
192		for(size_t j = 0; j < q; j++)
193		{ s[0 * q + j] = r[j];
194		s[1 * q + j] = r[j];
	192	for(size_t j = 0; j < p; j++)
	193	{ s[0 * p + j] = r[j];
	194	s[1 * p + j] = r[j];
195	195	}
196	196
197	197	return true;
198	198	}
199	199	// forward Jacobian sparsity routine called by CppAD
200	200	virtual bool for_sparse_jac(
201		size_t q ,
	201	size_t p ,
202	202	const vector< std::set<size_t> >& r ,
203	203	vector< std::set<size_t> >& s )
204	204	{ size_t n = r.size();

217	217	$codep */
218	218	// reverse Jacobian sparsity routine called by CppAD
219	219	virtual bool rev_sparse_jac(
220		size_t q ,
	220	size_t p ,
221	221	const vector<bool>& rt ,
222	222	vector<bool>& st )
223		{ size_t n = st.size() / q;
224		size_t m = rt.size() / q;
	223	{ size_t n = st.size() / p;
	224	size_t m = rt.size() / p;
225	225	assert( n == 1 );
226	226	assert( m == 2 );
227	227
228	228	// sparsity for S(x)^T = f'(x)^T * R^T
229		for(size_t j = 0; j < q; j++)
230		st[j] = rt[0 * q + j] \| rt[1 * q + j];
	229	for(size_t j = 0; j < p; j++)
	230	st[j] = rt[0 * p + j] \| rt[1 * p + j];
231	231
232	232	return true;
233	233	}
234	234	// reverse Jacobian sparsity routine called by CppAD
235	235	virtual bool rev_sparse_jac(
236		size_t q ,
	236	size_t p ,
237	237	const vector< std::set<size_t> >& rt ,
238	238	vector< std::set<size_t> >& st )
239	239	{ size_t n = st.size();

253	253	const vector<bool>& vx,
254	254	const vector<bool>& s ,
255	255	vector<bool>& t ,
256		size_t q ,
	256	size_t p ,
257	257	const vector<bool>& r ,
258	258	const vector<bool>& u ,
259	259	vector<bool>& v )
260	260	{
261	261	size_t m = s.size();
262	262	size_t n = t.size();
263		assert( r.size() == n * q );
264		assert( u.size() == m * q );
265		assert( v.size() == n * q );
	263	assert( r.size() == n * p );
	264	assert( u.size() == m * p );
	265	assert( v.size() == n * p );
266	266	assert( n == 1 );
267	267	assert( m == 2 );
268	268

279	279	// back propagate the sparsity for U, note both components
280	280	// of f'(x) may be non-zero;
281	281	size_t j;
282		for(j = 0; j < q; j++)
283		v[j] = u[ 0 * q + j ] \| u[ 1 * q + j ];
	282	for(j = 0; j < p; j++)
	283	v[j] = u[ 0 * p + j ] \| u[ 1 * p + j ];
284	284
285	285	// include forward Jacobian sparsity in Hessian sparsity
286	286	// (note sparsty for f''(x) * R same as for R)
287	287	if( s[0] \| s[1] )
288		{ for(j = 0; j < q; j++)
	288	{ for(j = 0; j < p; j++)
289	289	v[j] \|= r[j];
290	290	}
291	291

296	296	const vector<bool>& vx,
297	297	const vector<bool>& s ,
298	298	vector<bool>& t ,
299		size_t q ,
	299	size_t p ,
300	300	const vector< std::set<size_t> >& r ,
301	301	const vector< std::set<size_t> >& u ,
302	302	vector< std::set<size_t> >& v )

448	448	$subhead for_sparse_jac$$
449	449	$codep */
450	450	// Forward mode computation of sparsity pattern for F.
451		size_t q = n;
	451	size_t p = n;
452	452	// user vectorBool because m and n are small
453		CppAD::vectorBool r1(q), s1(m * q);
	453	CppAD::vectorBool r1(p), s1(m * p);
454	454	r1[0] = true; // propagate sparsity for x[0]
455		s1 = F.ForSparseJac(q, r1);
	455	s1 = F.ForSparseJac(p, r1);
456	456	ok &= (s1[0] == true); // f[0] depends on x[0]
457	457	ok &= (s1[1] == true); // f[1] depends on x[0]
458	458	ok &= (s1[2] == false); // f[2] does not depend on x[0]

460	460	$subhead rev_sparse_jac$$
461	461	$codep */
462	462	// Reverse mode computation of sparsity pattern for F.
463		size_t p = m;
464		CppAD::vectorBool s2(p * m), r2(p * n);
	463	size_t q = m;
	464	CppAD::vectorBool s2(q * m), r2(q * n);
465	465	// Sparsity pattern for identity matrix
466	466	size_t i, j;
467		for(i = 0; i < p; i++)
	467	for(i = 0; i < q; i++)
468	468	{ for(j = 0; j < m; j++)
469		s2[i * p + j] = (i == j);
470		}
471		r2 = F.RevSparseJac(p, s2);
	469	s2[i * q + j] = (i == j);
	470	}
	471	r2 = F.RevSparseJac(q, s2);
472	472	ok &= (r2[0] == true); // f[0] depends on x[0]
473	473	ok &= (r2[1] == true); // f[1] depends on x[0]
474	474	ok &= (r2[2] == false); // f[2] does not depend on x[0]

476	476	$subhead rev_sparse_hes$$
477	477	$codep */
478	478	// Hessian sparsity for f[0]
479		CppAD::vectorBool s3(m), h(q * n);
	479	CppAD::vectorBool s3(m), h(p * n);
480	480	s3[0] = true;
481	481	s3[1] = false;
482	482	s3[2] = false;
483		h = F.RevSparseHes(q, s3);
	483	h = F.RevSparseHes(p, s3);
484	484	ok &= (h[0] == true); // Hessian is non-zero
485	485
486	486	// Hessian sparsity for f[2]
487	487	s3[0] = false;
488	488	s3[2] = true;
489		h = F.RevSparseHes(q, s3);
	489	h = F.RevSparseHes(p, s3);
490	490	ok &= (h[0] == false); // Hessian is zero
491	491	/* $$
492	492	$subhead Large x Values$$

-2

example/atomic/test_one.sh less more

0	0	#! /bin/bash -e
1		# $Id: test_one.sh 2850 2013-05-24 17:49:50Z bradbell $
	1	# $Id: test_one.sh 3323 2014-09-12 12:10:54Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4	4	#

48	48	-o test_one.exe
49	49	$cxxflags
50	50	-g
51		-lboost_thread-mt
52	51	-std=c++11
53	52	-I../..
54	53	"

+13

-1

example/base_alloc.hpp less more

0		/* $Id: base_alloc.hpp 2936 2013-10-13 11:44:13Z bradbell $ */
	0	/* $Id: base_alloc.hpp 3495 2014-12-24 01:16:15Z bradbell $ */
1	1	# ifndef CPPAD_BASE_ALLOC_INCLUDED
2	2	# define CPPAD_BASE_ALLOC_INCLUDED
3	3	/* --------------------------------------------------------------------------

38	38	asin
39	39	std
40	40	fabs
	41	erf
	42	endif
41	43	$$
42	44	$section Example AD<Base> Where Base Constructor Allocates Memory$$
43	45

297	299	}
298	300	/* $$
299	301
	302	$head erf$$
	303	The following defines the $code CppAD::erf$$ function that
	304	is required th use $code AD<Base_alloc>$$:
	305	$codep */
	306	# if CPPAD_COMPILER_HAS_ERF
	307	inline base_alloc erf(const base_alloc& x)
	308	{ return std::erf(*x.ptrdbl_); }
	309	# endif
	310	/* $$
	311
300	312	$head sign$$
301	313	The following defines the $code CppAD::sign$$ function that
302	314	is required to use $code AD<base_alloc>$$:

+122

-0

example/capacity_order.cpp less more

	0	/* $Id: capacity_order.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	/*
	13	$begin capacity_order.cpp$$
	14	$spell
	15	Taylor
	16	$$
	17
	18	$section Controlling Taylor Coefficient Memory Allocation: Example and Test$$
	19
	20	$index capacity_order, example$$
	21	$index example, capacity_order$$
	22
	23	$code
	24	$verbatim%example/capacity_order.cpp%0%// BEGIN C++%// END C++%1%$$
	25	$$
	26
	27	$end
	28	*/
	29	// BEGIN C++
	30	# include <cppad/cppad.hpp>
	31
	32	namespace {
	33	bool test(void)
	34	{ bool ok = true;
	35	using CppAD::AD;
	36	using CppAD::NearEqual;
	37	using CppAD::thread_alloc;
	38
	39	// domain space vector
	40	size_t n(1), m(1);
	41	CPPAD_TESTVECTOR(AD<double>) ax(n), ay(n);
	42
	43	// declare independent variables and start tape recording
	44	ax[0] = 1.0;
	45	CppAD::Independent(ax);
	46
	47	// Set y = x^3, use enough variables so more that the minimal amount
	48	// of memory is allocated for Taylor coefficients
	49	ay[0] = 0.;
	50	for( size_t i = 0; i < 10; i++)
	51	ay[0] += ax[0] * ax[0] * ax[0];
	52	ay[0] = ay[0] / 10.;
	53
	54	// create f: x -> y and stop tape recording
	55	// (without running zero order forward mode).
	56	CppAD::ADFun<double> f;
	57	f.Dependent(ax, ay);
	58
	59	// check that this is master thread
	60	size_t thread = thread_alloc::thread_num();
	61	ok &= thread == 0; // this should be master thread
	62
	63	// The highest order forward mode calculation below is first order.
	64	// This corresponds to two Taylor coefficient per variable,direction
	65	// (orders zero and one). Preallocate memory for speed.
	66	size_t inuse = thread_alloc::inuse(thread);
	67	f.capacity_order(2);
	68	ok &= thread_alloc::inuse(thread) > inuse;
	69
	70	// zero order forward mode
	71	CPPAD_TESTVECTOR(double) x(n), y(m);
	72	x[0] = 0.5;
	73	y = f.Forward(0, x);
	74	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	75	ok &= NearEqual(y[0], x[0] * x[0] * x[0], eps, eps);
	76
	77	// forward computation of partials w.r.t. x
	78	CPPAD_TESTVECTOR(double) dx(n), dy(m);
	79	dx[0] = 1.;
	80	dy = f.Forward(1, dx);
	81	ok &= NearEqual(dy[0], 3. * x[0] * x[0], eps, eps);
	82
	83	// Suppose we no longer need the first order Taylor coefficients.
	84	inuse = thread_alloc::inuse(thread);
	85	f.capacity_order(1); // just keep zero order coefficients
	86	ok &= thread_alloc::inuse(thread) < inuse;
	87
	88	// Suppose we no longer need the zero order Taylor coefficients
	89	// (could have done this first and not used f.capacity_order(1)).
	90	inuse = thread_alloc::inuse(thread);
	91	f.capacity_order(0);
	92	ok &= thread_alloc::inuse(thread) < inuse;
	93
	94	// turn off memory holding
	95	thread_alloc::hold_memory(false);
	96
	97	return ok;
	98	}
	99	}
	100	bool capacity_order(void)
	101	{ bool ok = true;
	102	using CppAD::thread_alloc;
	103
	104	// original amount of memory inuse
	105	size_t thread = thread_alloc::thread_num();
	106	ok &= thread == 0; // this should be master thread
	107	size_t inuse = thread_alloc::inuse(thread);
	108
	109	// do test in separate routine so all objects are destroyed
	110	ok &= test();
	111
	112	// check that the amount of memroy inuse has not changed
	113	ok &= thread_alloc::inuse(thread) == inuse;
	114
	115	// Test above uses hold_memory, so return available memory
	116	thread_alloc::free_available(thread);
	117
	118	return ok;
	119	}
	120
	121	// END C++

-122

~~example/capacity_taylor.cpp~~ less more

0		/* $Id: capacity_taylor.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		/*
13		$begin capacity_taylor.cpp$$
14		$spell
15		Taylor
16		$$
17
18		$section Controlling Taylor Coefficient Memory Allocation: Example and Test$$
19
20		$index capacity_taylor, example$$
21		$index example, capacity_taylor$$
22
23		$code
24		$verbatim%example/capacity_taylor.cpp%0%// BEGIN C++%// END C++%1%$$
25		$$
26
27		$end
28		*/
29		// BEGIN C++
30		# include <cppad/cppad.hpp>
31
32		namespace {
33		bool test(void)
34		{ bool ok = true;
35		using CppAD::AD;
36		using CppAD::NearEqual;
37		using CppAD::thread_alloc;
38
39		// domain space vector
40		size_t n(1), m(1);
41		CPPAD_TESTVECTOR(AD<double>) ax(n), ay(n);
42
43		// declare independent variables and start tape recording
44		ax[0] = 1.0;
45		CppAD::Independent(ax);
46
47		// Set y = x^3, use enough variables so more that the minimal amount
48		// of memory is allocated for Taylor coefficients
49		ay[0] = 0.;
50		for( size_t i = 0; i < 10; i++)
51		ay[0] += ax[0] * ax[0] * ax[0];
52		ay[0] = ay[0] / 10.;
53
54		// create f: x -> y and stop tape recording
55		// (without running zero order forward mode).
56		CppAD::ADFun<double> f;
57		f.Dependent(ax, ay);
58
59		// check that this is master thread
60		size_t thread = thread_alloc::thread_num();
61		ok &= thread == 0; // this should be master thread
62
63		// The highest order forward mode calculation below is first order.
64		// This corresponds to two Taylor coefficient per variable
65		// (orders zero and one). Preallocate memory for speed.
66		size_t inuse = thread_alloc::inuse(thread);
67		f.capacity_taylor(2);
68		ok &= thread_alloc::inuse(thread) > inuse;
69
70		// zero order forward mode
71		CPPAD_TESTVECTOR(double) x(n), y(m);
72		x[0] = 0.5;
73		y = f.Forward(0, x);
74		double eps = 10. * CppAD::numeric_limits<double>::epsilon();
75		ok &= NearEqual(y[0], x[0] * x[0] * x[0], eps, eps);
76
77		// forward computation of partials w.r.t. x
78		CPPAD_TESTVECTOR(double) dx(n), dy(m);
79		dx[0] = 1.;
80		dy = f.Forward(1, dx);
81		ok &= NearEqual(dy[0], 3. * x[0] * x[0], eps, eps);
82
83		// Suppose we no longer need the first order Taylor coefficients.
84		inuse = thread_alloc::inuse(thread);
85		f.capacity_taylor(1); // just keep zero order coefficients
86		ok &= thread_alloc::inuse(thread) < inuse;
87
88		// Suppose we no longer need the zero order Taylor coefficients
89		// (could have done this first and not used f.capacity_taylor(1)).
90		inuse = thread_alloc::inuse(thread);
91		f.capacity_taylor(0);
92		ok &= thread_alloc::inuse(thread) < inuse;
93
94		// turn off memory holding
95		thread_alloc::hold_memory(false);
96
97		return ok;
98		}
99		}
100		bool capacity_taylor(void)
101		{ bool ok = true;
102		using CppAD::thread_alloc;
103
104		// original amount of memory inuse
105		size_t thread = thread_alloc::thread_num();
106		ok &= thread == 0; // this should be master thread
107		size_t inuse = thread_alloc::inuse(thread);
108
109		// do test in separate routine so all objects are destroyed
110		ok &= test();
111
112		// check that the amount of memroy inuse has not changed
113		ok &= thread_alloc::inuse(thread) == inuse;
114
115		// Test above uses hold_memory, so return available memory
116		thread_alloc::free_available(thread);
117
118		return ok;
119		}
120
121		// END C++

+123

-0

example/colpack.cpp less more

	0	/* $Id: colpack.cpp 3116 2014-02-24 21:44:26Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	/*
	13	$begin colpack.cpp$$
	14	$spell
	15	colpack
	16	$$
	17
	18	$section Using ColPack: Example and Test$$
	19
	20	$index example, colpack$$
	21	$index test, colpack$$
	22	$index spare, colpack$$
	23
	24	$code
	25	$verbatim%example/colpack.cpp%0%// BEGIN C++%// END C++%1%$$
	26	$$
	27
	28	$end
	29	*/
	30	// BEGIN C++
	31
	32	# include <cppad/cppad.hpp>
	33	bool colpack(void)
	34	{ bool ok = true;
	35	using CppAD::AD;
	36	using CppAD::NearEqual;
	37	typedef CPPAD_TESTVECTOR(AD<double>) a_vector;
	38	typedef CPPAD_TESTVECTOR(double) d_vector;
	39	typedef CppAD::vector<size_t> i_vector;
	40	size_t i, j, k, ell;
	41	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	42
	43	// domain space vector
	44	size_t n = 4;
	45	a_vector a_x(n);
	46	for(j = 0; j < n; j++)
	47	a_x[j] = AD<double> (0);
	48
	49	// declare independent variables and starting recording
	50	CppAD::Independent(a_x);
	51
	52	size_t m = 3;
	53	a_vector a_y(m);
	54	a_y[0] = a_x[0] + a_x[1];
	55	a_y[1] = a_x[2] + a_x[3];
	56	a_y[2] = a_x[0] + a_x[1] + a_x[2] + a_x[3] * a_x[3] / 2.;
	57
	58	// create f: x -> y and stop tape recording
	59	CppAD::ADFun<double> f(a_x, a_y);
	60
	61	// new value for the independent variable vector
	62	d_vector x(n);
	63	for(j = 0; j < n; j++)
	64	x[j] = double(j);
	65
	66	/*
	67	[ 1 1 0 0 ]
	68	jac = [ 0 0 1 1 ]
	69	[ 1 1 1 x_3]
	70	*/
	71	d_vector check(m * n);
	72	check[0] = 1.; check[1] = 1.; check[2] = 0.; check[3] = 0.;
	73	check[4] = 0.; check[5] = 0.; check[6] = 1.; check[7] = 1.;
	74	check[8] = 1.; check[9] = 1.; check[10] = 1.; check[11] = x[3];
	75
	76	// Normally one would use f.ForSparseJac or f.RevSparseJac to compute
	77	// sparsity pattern, but for this example we extract it from check.
	78	std::vector< std::set<size_t> > p(m);
	79
	80	// using row and column indices to compute non-zero in rows 1 and 2
	81	i_vector row, col;
	82	for(i = 0; i < m; i++)
	83	{ for(j = 0; j < n; j++)
	84	{ ell = i * n + j;
	85	if( check[ell] != 0. )
	86	{ row.push_back(i);
	87	col.push_back(j);
	88	p[i].insert(j);
	89	}
	90	}
	91	}
	92	size_t K = row.size();
	93	d_vector jac(K);
	94
	95	// empty work structure
	96	CppAD::sparse_jacobian_work work;
	97	ok &= work.color_method == "cppad";
	98
	99	// choose to use ColPack
	100	work.color_method = "colpack";
	101
	102	// forward mode
	103	size_t n_sweep = f.SparseJacobianForward(x, p, row, col, jac, work);
	104	for(k = 0; k < K; k++)
	105	{ ell = row[k] * n + col[k];
	106	ok &= NearEqual(check[ell], jac[k], eps, eps);
	107	}
	108	ok &= n_sweep == 4;
	109
	110	// reverse mode
	111	work.clear();
	112	work.color_method = "colpack";
	113	n_sweep = f.SparseJacobianReverse(x, p, row, col, jac, work);
	114	for(k = 0; k < K; k++)
	115	{ ell = row[k] * n + col[k];
	116	ok &= NearEqual(check[ell], jac[k], eps, eps);
	117	}
	118	ok &= n_sweep == 2;
	119
	120	return ok;
	121	}
	122	// END C++

+13

-4

example/cppad_vector.cpp less more

0		/* $Id: cppad_vector.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: cppad_vector.cpp 3127 2014-02-28 15:28:12Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

94	94	for(i = 0; i < N; i++)
95	95	ok &= ( x[i] == Type(i) );
96	96
	97	// test of data
	98	Type* data = x.data();
	99	for(i = 0; i < N; i++)
	100	{ ok &= data[i] == Type(i);
	101	data[i] = Type(N - i);
	102	ok &= x[i] == Type(N - i);
	103	}
	104
97	105	// test of push_vector
98	106	x.push_vector(x);
99	107	ok &= (x.size() == 2 * N);
100	108	for(i = 0; i < N; i++)
101		{ ok &= ( x[i] == Type(i) );
102		ok &= ( x[i+N] == Type(i) );
	109	{ ok &= x[i] == Type(N - i);
	110	ok &= x[i+N] == Type(N - i);
103	111	}
	112
104	113
105	114	return ok;
106	115	}

+22

-15

example/erf.cpp less more

0		/* $Id: erf.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: erf.cpp 3499 2014-12-24 15:31:55Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
3	3

44	44	// domain space vector
45	45	size_t n = 1;
46	46	double x0 = 0.5;
47		CPPAD_TESTVECTOR(AD<double>) x(n);
48		x[0] = x0;
	47	CPPAD_TESTVECTOR(AD<double>) ax(n);
	48	ax[0] = x0;
49	49
50	50	// declare independent variables and start tape recording
51		CppAD::Independent(x);
52
53		// a temporary value
	51	CppAD::Independent(ax);
54	52
55	53	// range space vector
56	54	size_t m = 1;
57		CPPAD_TESTVECTOR(AD<double>) y(m);
58		y[0] = CppAD::erf(x[0]);
	55	CPPAD_TESTVECTOR(AD<double>) ay(m);
	56	ay[0] = CppAD::erf(ax[0]);
59	57
60	58	// create f: x -> y and stop tape recording
61		CppAD::ADFun<double> f(x, y);
	59	CppAD::ADFun<double> f(ax, ay);
62	60
63	61	// check relative erorr
64		double erf_x0 = 0.5205;
65		ok &= NearEqual(y[0] , erf_x0, 4e-4 , 0.);
	62	double erf_x0 = 0.52050;
	63	ok &= NearEqual(ay[0] , erf_x0, 0., 4e-4);
	64	# if CPPAD_COMPILER_HAS_ERF
	65	ok &= NearEqual(ay[0] , erf_x0, 0., 1e-5);
	66	# endif
66	67
67	68	// value of derivative of erf at x0
68	69	double pi = 4. * std::atan(1.);

74	75	CPPAD_TESTVECTOR(double) dy(m);
75	76	dx[0] = 1.;
76	77	dy = f.Forward(1, dx);
77		ok &= NearEqual(dy[0], check, 4e-4, 0.);
	78	ok &= NearEqual(dy[0], check, 0., 1e-3);
	79	# if CPPAD_COMPILER_HAS_ERF
	80	ok &= NearEqual(dy[0], check, 0., eps);
	81	# endif
78	82
79	83	// reverse computation of derivative of y[0]
80	84	CPPAD_TESTVECTOR(double) w(m);
81	85	CPPAD_TESTVECTOR(double) dw(n);
82	86	w[0] = 1.;
83	87	dw = f.Reverse(1, w);
84		ok &= NearEqual(dw[0], check, 4e-4, 0.);
	88	ok &= NearEqual(dw[0], check, 0., 1e-1);
	89	# if CPPAD_COMPILER_HAS_ERF
	90	ok &= NearEqual(dw[0], check, 0., eps);
	91	# endif
85	92
86	93	// use a VecAD<Base>::reference object with erf
87	94	CppAD::VecAD<double> v(1);
88	95	AD<double> zero(0);
89	96	v[zero] = x0;
90	97	AD<double> result = CppAD::erf(v[zero]);
91		ok &= NearEqual(result, y[0], eps, eps);
	98	ok &= NearEqual(result, ay[0], eps, eps);
92	99
93	100	// use a double with erf
94		ok &= NearEqual(CppAD::erf(x0), y[0], eps, eps);
	101	ok &= NearEqual(CppAD::erf(x0), ay[0], eps, eps);
95	102
96	103	return ok;
97	104	}

+13

-7

example/example.cpp less more

0		/* $Id: example.cpp 2991 2013-10-22 16:25:15Z bradbell $ */
	0	/* $Id: example.cpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

20	20	$index test, CppAD$$
21	21
22	22	$head Running Tests$$
23		To build this program and run its correctness tests see $cref cppad_test$$.
	23	To build this program and run its correctness tests see $cref cmake_check$$.
24	24
25	25	$code
26	26	$verbatim%example/example.cpp%0%// BEGIN C++%// END C++%1%$$

60	60	extern bool base_require(void);
61	61	extern bool BenderQuad(void);
62	62	extern bool BoolFun(void);
63		extern bool capacity_taylor(void);
	63	extern bool capacity_order(void);
64	64	extern bool change_const(void);
65	65	extern bool check_for_nan(void);
66	66	extern bool CheckNumericType(void);
67	67	extern bool CheckSimpleVector(void);
	68	extern bool colpack(void);
68	69	extern bool Compare(void);
69	70	extern bool CompareChange(void);
70	71	extern bool complex_poly(void);

85	86	extern bool ForTwo(void);
86	87	extern bool ForSparseJac(void);
87	88	extern bool Forward(void);
88		extern bool forward_mul(void);
	89	extern bool forward_dir(void);
	90	extern bool forward_order(void);
89	91	extern bool fun_assign(void);
90	92	extern bool FunCheck(void);
91	93	extern bool HesLagrangian(void);

219	221	ok &= Run( Atan2, "Atan2" );
220	222	ok &= Run( BenderQuad, "BenderQuad" );
221	223	ok &= Run( BoolFun, "BoolFun" );
222		ok &= Run( capacity_taylor, "capacity_taylor" );
	224	ok &= Run( capacity_order, "capacity_order" );
223	225	ok &= Run( change_const, "change_const" );
224	226	ok &= Run( check_for_nan, "check_for_nan" );
225	227	ok &= Run( CheckNumericType, "CheckNumericType" );

241	243	ok &= Run( ForOne, "ForOne" );
242	244	ok &= Run( ForTwo, "ForTwo" );
243	245	ok &= Run( Forward, "Forward" );
244		ok &= Run( forward_mul, "forward_mul" );
	246	ok &= Run( forward_dir, "forward_dir" );
	247	ok &= Run( forward_order, "forward_order" );
245	248	ok &= Run( ForSparseJac, "ForSparseJac" );
246	249	ok &= Run( fun_assign, "fun_assign" );
247	250	ok &= Run( FunCheck, "FunCheck" );

328	331	ok &= Run( mul_level_adolc, "mul_level_adolc" );
329	332	ok &= Run( mul_level_adolc_ode, "mul_level_adolc_ode" );
330	333	# endif
	334	# ifdef CPPAD_COLPACK_EXAMPLES
	335	ok &= Run( colpack, "colpack" );
	336	# endif
331	337	# ifdef CPPAD_EIGEN_EXAMPLES
332	338	ok &= Run( eigen_array, "eigen_array" );
333	339	ok &= Run( eigen_det, "eigen_det" );

+39

-40

example/forward.cpp less more

0		/* $Id: forward.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: forward.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

27	27	$end
28	28	*/
29	29	// BEGIN C++
	30	# include <limits>
30	31	# include <cppad/cppad.hpp>
31	32	namespace { // --------------------------------------------------------
32	33	// define the template function ForwardCases<Vector> in empty namespace

35	36	{ bool ok = true;
36	37	using CppAD::AD;
37	38	using CppAD::NearEqual;
	39	double eps = 10. * std::numeric_limits<double>::epsilon();
38	40
39	41	// domain space vector
40	42	size_t n = 2;
41		CPPAD_TESTVECTOR(AD<double>) X(n);
42		X[0] = 0.;
43		X[1] = 1.;
	43	CPPAD_TESTVECTOR(AD<double>) ax(n);
	44	ax[0] = 0.;
	45	ax[1] = 1.;
44	46
45	47	// declare independent variables and starting recording
46		CppAD::Independent(X);
	48	CppAD::Independent(ax);
47	49
48	50	// range space vector
49	51	size_t m = 1;
50		CPPAD_TESTVECTOR(AD<double>) Y(m);
51		Y[0] = X[0] * X[0] * X[1];
	52	CPPAD_TESTVECTOR(AD<double>) ay(m);
	53	ay[0] = ax[0] * ax[0] * ax[1];
52	54
53		// create f: X -> Y and stop tape recording
54		CppAD::ADFun<double> f(X, Y);
	55	// create f: x -> y and stop tape recording
	56	CppAD::ADFun<double> f(ax, ay);
55	57
56	58	// initially, the variable values during taping are stored in f
57		ok &= f.size_taylor() == 1;
	59	ok &= f.size_order() == 1;
58	60
59		// zero order forward mode using notaiton in ForwardZero
	61	// zero order forward mode using notation in forward_zero
60	62	// use the template parameter Vector for the vector type
61		Vector x(n);
62		Vector y(m);
63		x[0] = 3.;
64		x[1] = 4.;
65		y = f.Forward(0, x);
66		ok &= NearEqual(y[0] , x[0]x[0]x[1], 1e-10, 1e-10);
67		ok &= f.size_taylor() == 1;
	63	Vector x0(n), y0(m);
	64	x0[0] = 3.;
	65	x0[1] = 4.;
	66	y0 = f.Forward(0, x0);
	67	ok &= NearEqual(y0[0] , x0[0]x0[0]x0[1], eps, eps);
	68	ok &= f.size_order() == 1;
68	69
69		// first order forward mode using notation in ForwardOne
70		// X(t) = x + dx * t
71		// Y(t) = F[X(t)] = y + dy * t + o(t)
72		Vector dx(n);
73		Vector dy(m);
74		dx[0] = 1.;
75		dx[1] = 0.;
76		dy = f.Forward(1, dx); // partial F w.r.t. x[0]
77		ok &= NearEqual(dy[0] , 2.x[0]x[1], 1e-10, 1e-10);
78		ok &= f.size_taylor() == 2;
	70	// first order forward mode using notation in forward_one
	71	// X(t) = x0 + x1 * t
	72	// Y(t) = F[X(t)] = y0 + y1 * t + o(t)
	73	Vector x1(n), y1(m);
	74	x1[0] = 1.;
	75	x1[1] = 0.;
	76	y1 = f.Forward(1, x1); // partial F w.r.t. x_0
	77	ok &= NearEqual(y1[0] , 2.x0[0]x0[1], eps, eps);
	78	ok &= f.size_order() == 2;
79	79
80		// second order forward mode using notaiton in ForwardAny
81		// X(t) = x + dx * t + x_2 * t^2
82		// Y(t) = F[X(t)] = y + dy * t + y_2 * t^2 + o(t^3)
83		Vector x_2(n);
84		Vector y_2(m);
85		x_2[0] = 0.;
86		x_2[1] = 0.;
87		y_2 = f.Forward(2, x_2);
88		double F_00 = 2. * y_2[0]; // second partial F w.r.t. x[0], x[0]
89		ok &= NearEqual(F_00, 2.*x[1], 1e-10, 1e-10);
90		ok &= f.size_taylor() == 3;
	80	// second order forward mode using notation in forward_order
	81	// X(t) = x0 + x1 * t + x2 * t^2
	82	// Y(t) = F[X(t)] = y0 + y1 * t + y2 * t^2 + o(t^3)
	83	Vector x2(n), y2(m);
	84	x2[0] = 0.;
	85	x2[1] = 0.;
	86	y2 = f.Forward(2, x2);
	87	double F_00 = 2. * y2[0]; // second partial F w.r.t. x_0, x_0
	88	ok &= NearEqual(F_00, 2.*x0[1], eps, eps);
	89	ok &= f.size_order() == 3;
91	90
92	91	return ok;
93	92	}

+112

-0

example/forward_dir.cpp less more

	0	/* $Id: forward_dir.cpp 3301 2014-05-24 05:20:21Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	/*
	13	$begin forward_dir.cpp$$
	14	$spell
	15	Cpp
	16	$$
	17
	18	$section Forward Mode: Example and Test of Multiple Directions$$
	19	$index forward, multiple orders$$
	20	$index multiple, forward orders$$
	21	$index order, multiple forward$$
	22
	23	$code
	24	$verbatim%example/forward_dir.cpp%0%// BEGIN C++%// END C++%1%$$
	25	$$
	26
	27	$end
	28	*/
	29	// BEGIN C++
	30	# include <limits>
	31	# include <cppad/cppad.hpp>
	32	bool forward_dir(void)
	33	{ bool ok = true;
	34	using CppAD::AD;
	35	using CppAD::NearEqual;
	36	double eps = 10. * std::numeric_limits<double>::epsilon();
	37	size_t j;
	38
	39	// domain space vector
	40	size_t n = 3;
	41	CPPAD_TESTVECTOR(AD<double>) ax(n);
	42	ax[0] = 0.;
	43	ax[1] = 1.;
	44	ax[2] = 2.;
	45
	46	// declare independent variables and starting recording
	47	CppAD::Independent(ax);
	48
	49	// range space vector
	50	size_t m = 1;
	51	CPPAD_TESTVECTOR(AD<double>) ay(m);
	52	ay[0] = ax[0] * ax[1] * ax[2];
	53
	54	// create f: x -> y and stop tape recording
	55	CppAD::ADFun<double> f(ax, ay);
	56
	57	// initially, the variable values during taping are stored in f
	58	ok &= f.size_order() == 1;
	59
	60	// zero order Taylor coefficients
	61	CPPAD_TESTVECTOR(double) x0(n), y0;
	62	for(j = 0; j < n; j++)
	63	x0[j] = double(j+1);
	64	y0 = f.Forward(0, x0);
	65	ok &= y0.size() == m;
	66	double y_0 = 1.2.3.;
	67	ok &= NearEqual(y0[0], y_0, eps, eps);
	68
	69	// first order Taylor coefficients
	70	size_t r = 2, ell;
	71	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	72	for(ell = 0; ell < r; ell++)
	73	{ for(j = 0; j < n; j++)
	74	x1[ r * j + ell ] = double(j + 1 + ell);
	75	}
	76	y1 = f.Forward(1, r, x1);
	77	ok &= y1.size() == r*m;
	78
	79	// secondorder Taylor coefficients
	80	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	81	for(ell = 0; ell < r; ell++)
	82	{ for(j = 0; j < n; j++)
	83	x2[ r * j + ell ] = 0.0;
	84	}
	85	y2 = f.Forward(2, r, x2);
	86	ok &= y2.size() == r*m;
	87	//
	88	// Y_0 (t) = F[X_0(t)]
	89	// = (1 + 1t)(2 + 2t)(3 + 3t)
	90	double y_1_0 = 1.2.3. + 2.1.3. + 3.1.2.;
	91	double y_2_0 = 1.2.3. + 2.1.3. + 3.1.2.;
	92	//
	93	// Y_1 (t) = F[X_1(t)]
	94	// = (1 + 2t)(2 + 3t)(3 + 4t)
	95	double y_1_1 = 2.2.3. + 3.1.3. + 4.1.2.;
	96	double y_2_1 = 1.3.4. + 2.2.4. + 3.2.3.;
	97	//
	98	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	99	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	100	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	101	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	102	//
	103	// check number of orders
	104	ok &= f.size_order() == 3;
	105	//
	106	// check number of directions
	107	ok &= f.size_direction() == 2;
	108	//
	109	return ok;
	110	}
	111	// END C++

-87

~~example/forward_mul.cpp~~ less more

0		/* $Id: forward_mul.cpp 2859 2013-05-28 06:03:21Z bradbell $ */
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		/*
13		$begin forward_mul.cpp$$
14		$spell
15		Cpp
16		$$
17
18		$section Forward Mode: Example and Test of Multiple Orders$$
19		$index forward, multiple orders$$
20		$index multiple, forward orders$$
21		$index order, multiple forward$$
22
23		$code
24		$verbatim%example/forward_mul.cpp%0%// BEGIN C++%// END C++%1%$$
25		$$
26
27		$end
28		*/
29		// BEGIN C++
30		# include <cppad/cppad.hpp>
31		bool forward_mul(void)
32		{ bool ok = true;
33		using CppAD::AD;
34		using CppAD::NearEqual;
35		double eps = 10. * std::numeric_limits<double>::epsilon();
36
37		// domain space vector
38		size_t n = 2;
39		CPPAD_TESTVECTOR(AD<double>) X(n);
40		X[0] = 0.;
41		X[1] = 1.;
42
43		// declare independent variables and starting recording
44		CppAD::Independent(X);
45
46		// range space vector
47		size_t m = 1;
48		CPPAD_TESTVECTOR(AD<double>) Y(m);
49		Y[0] = X[0] * X[0] * X[1];
50
51		// create f: X -> Y and stop tape recording
52		CppAD::ADFun<double> f(X, Y);
53
54		// initially, the variable values during taping are stored in f
55		ok &= f.size_taylor() == 1;
56
57		// Compute three forward orders at one
58		size_t p = 2, p1 = p+1;
59		CPPAD_TESTVECTOR(double) x_p(n * (p+1)), y_p(m * (p+1));
60		x_p[0 * p1 + 0] = 3.; x_p[1 * p1 + 0] = 4.; // order 0
61		x_p[0 * p1 + 1] = 1.; x_p[1 * p1 + 1] = 0.; // order 1
62		x_p[0 * p1 + 2] = 0.; x_p[1 * p1 + 2] = 0.; // order 2
63		// X(t) = x^0 + x^1 * t + x^2 * t^2
64		// = [ 3 + t, 4 ]
65		//
66		y_p = f.Forward(p, x_p);
67		// Y(t) = F[X(t)] = y^0 + y^1 * t + y^2 * t^2 + o(t^3)
68		//
69		// check order zero
70		CPPAD_TESTVECTOR(double) x(n);
71		x[0] = x_p[0 * p1 + 0];
72		x[1] = x_p[1 * p1 + 0];
73		ok &= NearEqual(y_p[0 * p1 + 0] , x[0]x[0]x[1], eps, eps);
74		//
75		// check order one
76		ok &= NearEqual(y_p[0 * p1 + 1] , 2.x[0]x[1], eps, eps);
77		// check order two
78		double F_00 = 2. * y_p[0 * p1 + 2]; // second partial F w.r.t. x[0], x[0]
79		ok &= NearEqual(F_00, 2.*x[1], eps, eps);
80
81		// check number of orders per variable
82		ok &= f.size_taylor() == 3;
83
84		return ok;
85		}
86		// END C++

+91

-0

example/forward_order.cpp less more

	0	/* $Id: forward_order.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	/*
	13	$begin forward_order.cpp$$
	14	$spell
	15	Cpp
	16	$$
	17
	18	$section Forward Mode: Example and Test of Multiple Orders$$
	19	$index forward, multiple orders$$
	20	$index multiple, forward orders$$
	21	$index order, multiple forward$$
	22
	23	$code
	24	$verbatim%example/forward_order.cpp%0%// BEGIN C++%// END C++%1%$$
	25	$$
	26
	27	$end
	28	*/
	29	// BEGIN C++
	30	# include <limits>
	31	# include <cppad/cppad.hpp>
	32	bool forward_order(void)
	33	{ bool ok = true;
	34	using CppAD::AD;
	35	using CppAD::NearEqual;
	36	double eps = 10. * std::numeric_limits<double>::epsilon();
	37
	38	// domain space vector
	39	size_t n = 2;
	40	CPPAD_TESTVECTOR(AD<double>) ax(n);
	41	ax[0] = 0.;
	42	ax[1] = 1.;
	43
	44	// declare independent variables and starting recording
	45	CppAD::Independent(ax);
	46
	47	// range space vector
	48	size_t m = 1;
	49	CPPAD_TESTVECTOR(AD<double>) ay(m);
	50	ay[0] = ax[0] * ax[0] * ax[1];
	51
	52	// create f: x -> y and stop tape recording
	53	CppAD::ADFun<double> f(ax, ay);
	54
	55	// initially, the variable values during taping are stored in f
	56	ok &= f.size_order() == 1;
	57
	58	// Compute three forward orders at one
	59	size_t q = 2, q1 = q+1;
	60	CPPAD_TESTVECTOR(double) xq(n*q1), yq;
	61	xq[q10 + 0] = 3.; xq[q11 + 0] = 4.; // x^0 (order zero)
	62	xq[q10 + 1] = 1.; xq[q11 + 1] = 0.; // x^1 (order one)
	63	xq[q10 + 2] = 0.; xq[q11 + 2] = 0.; // x^2 (order two)
	64	// X(t) = x^0 + x^1 * t + x^2 * t^2
	65	// = [ 3 + t, 4 ]
	66	yq = f.Forward(q, xq);
	67	ok &= yq.size() == m*q1;
	68	// Y(t) = F[X(t)]
	69	// = (3 + t) * (3 + t) * 4
	70	// = y^0 + y^1 * t + y^2 * t^2 + o(t^3)
	71	//
	72	// check y^0 (order zero)
	73	CPPAD_TESTVECTOR(double) x0(n);
	74	x0[0] = xq[q1*0 + 0];
	75	x0[1] = xq[q1*1 + 0];
	76	ok &= NearEqual(yq[q10 + 0] , x0[0]x0[0]*x0[1], eps, eps);
	77	//
	78	// check y^1 (order one)
	79	ok &= NearEqual(yq[q10 + 1] , 2.x0[0]*x0[1], eps, eps);
	80	//
	81	// check y^2 (order two)
	82	double F_00 = 2. * yq[q1*0 + 2]; // second partial F w.r.t. x_0, x_0
	83	ok &= NearEqual(F_00, 2.*x0[1], eps, eps);
	84
	85	// check number of orders per variable
	86	ok &= f.size_order() == 3;
	87
	88	return ok;
	89	}
	90	// END C++

-3

example/fun_assign.cpp less more

0		/* $Id: fun_assign.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: fun_assign.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

70	70	g = f;
71	71
72	72	// check values that should be equal
73		ok &= ( g.size_taylor() == f.size_taylor() );
	73	ok &= ( g.size_order() == f.size_order() );
74	74	ok &= ( g.size_forward_bool() == f.size_forward_bool() );
75	75	ok &= ( g.size_forward_set() == f.size_forward_set() );
76	76

-4

example/fun_check.cpp less more

0		/* $Id: fun_check.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: fun_check.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

92	92
93	93	// stop tape and store operation sequence in f : X -> Y
94	94	f.Dependent(X, Y);
95		ok &= (f.size_taylor() == 0); // no implicit forward operation
	95	ok &= (f.size_order() == 0); // no implicit forward operation
96	96
97	97	// create function object to use with double
98	98	Fun<double, Vector> g(n);

121	121
122	122	// stop tape and store operation sequence in f : X -> Y
123	123	f.Dependent(X, Y);
124		ok &= (f.size_taylor() == 0); // no implicit forward with this x
	124	ok &= (f.size_order() == 0); // no implicit forward with this x
125	125
126	126	// function values should agree now
127	127	ok &= FunCheck(f, g, x, a, r);

+15

-3

example/ipopt_solve/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2681 2012-12-30 17:23:09Z bradbell $
	0	# $Id: CMakeLists.txt 3116 2014-02-24 21:44:26Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

17	17	# Local link directories to search, as determined by pkg-config for ipopt
18	18	LINK_DIRECTORIES( ${ipopt_LIBRARY_DIRS} )
19	19
	20	# colpack_prefix
	21	IF ( colpack_prefix )
	22	# Extra source files if we are including colpack
	23	SET(colpack_sources ../../cppad/local/cppad_colpack.cpp)
	24	# add colpack to list of libraries
	25	SET(colpack_libs "ColPack")
	26	ELSE ( colpack_prefix )
	27	SET(colpack_sources "")
	28	SET(colpack_libs "")
	29	ENDIF ( colpack_prefix )
	30
20	31	#
21	32	ADD_EXECUTABLE(example_ipopt_solve EXCLUDE_FROM_ALL
22	33	solve.cpp
23	34	get_started.cpp
24	35	ode_inverse.cpp
25	36	retape.cpp
	37	${colpack_sources}
26	38	)
27	39
28	40	# Extra compiler flags

30	42
31	43	# libraries to be linked into the specified target,
32	44	# as determined by pkg-config for ipopt
33		TARGET_LINK_LIBRARIES(example_ipopt_solve ${ipopt_LIBRARIES})
	45	TARGET_LINK_LIBRARIES(example_ipopt_solve ${ipopt_LIBRARIES} ${colpack_libs})
34	46
35	47	# Add the check_example_ipopt_solve target
36	48	ADD_CUSTOM_TARGET(check_example_ipopt_solve

+144

-74

example/ipopt_solve/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = solve$(EXEEXT)
51	80	subdir = example/ipopt_solve
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in \
53		$(srcdir)/test.sh.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(srcdir)/test.sh.in $(top_srcdir)/depcomp
54	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
55	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
56	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

65	94	am__DEPENDENCIES_1 =
66	95	solve_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
67	96	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
	97	AM_V_P = $(am__v_P_@AM_V@)
	98	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	99	am__v_P_0 = false
	100	am__v_P_1 = :
	101	AM_V_GEN = $(am__v_GEN_@AM_V@)
	102	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	103	am__v_GEN_0 = @echo " GEN " $@;
	104	am__v_GEN_1 =
	105	AM_V_at = $(am__v_at_@AM_V@)
	106	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	107	am__v_at_0 = @
	108	am__v_at_1 =
68	109	DEFAULT_INCLUDES =
69	110	depcomp = $(SHELL) $(top_srcdir)/depcomp
70	111	am__depfiles_maybe = depfiles

73	114	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
74	115	AM_V_CXX = $(am__v_CXX_@AM_V@)
75	116	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
76		am__v_CXX_0 = @echo " CXX " $@;
77		AM_V_at = $(am__v_at_@AM_V@)
78		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
79		am__v_at_0 = @
	117	am__v_CXX_0 = @echo " CXX " $@;
	118	am__v_CXX_1 =
80	119	CXXLD = $(CXX)
81	120	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
82	121	-o $@
83	122	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
84	123	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
85		am__v_CXXLD_0 = @echo " CXXLD " $@;
86		AM_V_GEN = $(am__v_GEN_@AM_V@)
87		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
88		am__v_GEN_0 = @echo " GEN " $@;
	124	am__v_CXXLD_0 = @echo " CXXLD " $@;
	125	am__v_CXXLD_1 =
89	126	SOURCES = $(solve_SOURCES)
90	127	DIST_SOURCES = $(solve_SOURCES)
91	128	am__can_run_installinfo = \

93	130	n\|no\|NO) false;; \
94	131	*) (install-info --version) >/dev/null 2>&1;; \
95	132	esac
	133	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	134	# Read a list of newline-separated strings from the standard input,
	135	# and print each of them once, without duplicates. Input order is
	136	# not preserved.
	137	am__uniquify_input = $(AWK) '\
	138	BEGIN { nonempty = 0; } \
	139	{ items[$$0] = 1; nonempty = 1; } \
	140	END { if (nonempty) { for (i in items) print i; }; } \
	141	'
	142	# Make sure the list of sources is unique. This is necessary because,
	143	# e.g., the same source file might be shared among _SOURCES variables
	144	# for different programs/libraries.
	145	am__define_uniq_tagged_files = \
	146	list='$(am__tagged_files)'; \
	147	unique=`for i in $$list; do \
	148	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	149	done \| $(am__uniquify_input)`
96	150	ETAGS = etags
97	151	CTAGS = ctags
98	152	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

102	156	ADOLC_DIR = @ADOLC_DIR@
103	157	AMTAR = @AMTAR@
104	158	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	159	AR = @AR@
105	160	AUTOCONF = @AUTOCONF@
106	161	AUTOHEADER = @AUTOHEADER@
107	162	AUTOMAKE = @AUTOMAKE@

124	179	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
125	180	CYGPATH_W = @CYGPATH_W@
126	181
127		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	182	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
128	183	# -----------------------------------------------------------------------------
129	184	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
130	185	#

191	246	abs_srcdir = @abs_srcdir@
192	247	abs_top_builddir = @abs_top_builddir@
193	248	abs_top_srcdir = @abs_top_srcdir@
	249	ac_ct_AR = @ac_ct_AR@
194	250	ac_ct_CC = @ac_ct_CC@
195	251	ac_ct_CXX = @ac_ct_CXX@
196	252	ac_ct_FC = @ac_ct_FC@

201	257	am__tar = @am__tar@
202	258	am__untar = @am__untar@
203	259	bindir = @bindir@
	260	build = @build@
204	261	build_alias = @build_alias@
	262	build_cpu = @build_cpu@
	263	build_os = @build_os@
	264	build_vendor = @build_vendor@
205	265	builddir = @builddir@
206	266	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
207	267	cppad_boostvector = @cppad_boostvector@
208	268	cppad_cflags = @cppad_cflags@
	269	cppad_compiler_has_erf = @cppad_compiler_has_erf@
209	270	cppad_cppadvector = @cppad_cppadvector@
210	271	cppad_description = @cppad_description@
211	272	cppad_eigenvector = @cppad_eigenvector@
	273	cppad_has_colpack = @cppad_has_colpack@
	274	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
212	275	cppad_has_gettimeofday = @cppad_has_gettimeofday@
213	276	cppad_has_nullptr = @cppad_has_nullptr@
	277	cppad_has_rvalue = @cppad_has_rvalue@
214	278	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
215	279	cppad_internal_sparse_set = @cppad_internal_sparse_set@
216	280	cppad_libs = @cppad_libs@
217	281	cppad_max_num_threads = @cppad_max_num_threads@
218	282	cppad_requires = @cppad_requires@
219		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	283	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
220	284	cppad_stdvector = @cppad_stdvector@
221	285	cppad_tape_addr_type = @cppad_tape_addr_type@
222	286	cppad_tape_id_type = @cppad_tape_id_type@

228	292	dvidir = @dvidir@
229	293	eigen_prefix = @eigen_prefix@
230	294	exec_prefix = @exec_prefix@
231		have_ar = @have_ar@
232	295	have_pkg_config = @have_pkg_config@
	296	host = @host@
233	297	host_alias = @host_alias@
	298	host_cpu = @host_cpu@
	299	host_os = @host_os@
	300	host_vendor = @host_vendor@
234	301	htmldir = @htmldir@
235	302	includedir = @includedir@
236	303	infodir = @infodir@

317	384
318	385	clean-checkPROGRAMS:
319	386	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	387
320	388	solve$(EXEEXT): $(solve_OBJECTS) $(solve_DEPENDENCIES) $(EXTRA_solve_DEPENDENCIES)
321	389	@rm -f solve$(EXEEXT)
322	390	$(AM_V_CXXLD)$(CXXLINK) $(solve_OBJECTS) $(solve_LDADD) $(LIBS)

333	401	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/solve.Po@am__quote@
334	402
335	403	.cpp.o:
336		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
337		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	404	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	405	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	406	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
338	407	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
339	408	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
340	409	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
341	410
342	411	.cpp.obj:
343		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
344		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	412	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	413	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	414	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
345	415	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
346	416	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
347	417	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
348	418
349		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
350		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
351		unique=`for i in $$list; do \
352		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
353		done \| \
354		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
355		END { if (nonempty) { for (i in files) print i; }; }'`; \
356		mkid -fID $$unique
357		tags: TAGS
358
359		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
360		$(TAGS_FILES) $(LISP)
	419	ID: $(am__tagged_files)
	420	$(am__define_uniq_tagged_files); mkid -fID $$unique
	421	tags: tags-am
	422	TAGS: tags
	423
	424	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
361	425	set x; \
362	426	here=`pwd`; \
363		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
364		unique=`for i in $$list; do \
365		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
366		done \| \
367		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
368		END { if (nonempty) { for (i in files) print i; }; }'`; \
	427	$(am__define_uniq_tagged_files); \
369	428	shift; \
370	429	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
371	430	test -n "$$unique" \|\| unique=$$empty_fix; \

377	436	$$unique; \
378	437	fi; \
379	438	fi
380		ctags: CTAGS
381		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
382		$(TAGS_FILES) $(LISP)
383		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
384		unique=`for i in $$list; do \
385		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
386		done \| \
387		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
388		END { if (nonempty) { for (i in files) print i; }; }'`; \
	439	ctags: ctags-am
	440
	441	CTAGS: ctags
	442	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	443	$(am__define_uniq_tagged_files); \
389	444	test -z "$(CTAGS_ARGS)$$unique" \
390	445	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
391	446	$$unique

394	449	here=`$(am__cd) $(top_builddir) && pwd` \
395	450	&& $(am__cd) $(top_srcdir) \
396	451	&& gtags -i $(GTAGS_ARGS) "$$here"
	452	cscopelist: cscopelist-am
	453
	454	cscopelist-am: $(am__tagged_files)
	455	list='$(am__tagged_files)'; \
	456	case "$(srcdir)" in \
	457	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	458	*) sdir=$(subdir)/$(srcdir) ;; \
	459	esac; \
	460	for i in $$list; do \
	461	if test -f "$$i"; then \
	462	echo "$(subdir)/$$i"; \
	463	else \
	464	echo "$$sdir/$$i"; \
	465	fi; \
	466	done >> $(top_builddir)/cscope.files
397	467
398	468	distclean-tags:
399	469	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

534	604
535	605	.MAKE: check-am install-am install-strip
536	606
537		.PHONY: CTAGS GTAGS all all-am check check-am clean \
538		clean-checkPROGRAMS clean-generic ctags distclean \
539		distclean-compile distclean-generic distclean-tags distdir dvi \
540		dvi-am html html-am info info-am install install-am \
541		install-data install-data-am install-dvi install-dvi-am \
542		install-exec install-exec-am install-html install-html-am \
543		install-info install-info-am install-man install-pdf \
544		install-pdf-am install-ps install-ps-am install-strip \
545		installcheck installcheck-am installdirs maintainer-clean \
546		maintainer-clean-generic mostlyclean mostlyclean-compile \
547		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
548		uninstall-am
	607	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	608	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	609	distclean distclean-compile distclean-generic distclean-tags \
	610	distdir dvi dvi-am html html-am info info-am install \
	611	install-am install-data install-data-am install-dvi \
	612	install-dvi-am install-exec install-exec-am install-html \
	613	install-html-am install-info install-info-am install-man \
	614	install-pdf install-pdf-am install-ps install-ps-am \
	615	install-strip installcheck installcheck-am installdirs \
	616	maintainer-clean maintainer-clean-generic mostlyclean \
	617	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	618	tags tags-am uninstall uninstall-am
549	619
550	620
551	621	test: check

+20

-9

example/makefile.am less more

0		# $Id: makefile.am 2991 2013-10-22 16:25:15Z bradbell $
	0	# $Id: makefile.am 3486 2014-12-18 16:29:51Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

25	25	ADOLC_FLAGS =
26	26	endif
27	27	# -------------------------------------------------------------------------
	28	if CppAD_HAVE_AR
28	29	if CppAD_EIGEN_DIR
29	30	# make a special library so can have it's own compile flags (see configure.ac)
30	31	EIGEN_EXTRA_FILES =
31	32	noinst_LIBRARIES = libeigen.a
32	33	libeigen_a_SOURCES = eigen_det.cpp eigen_array.cpp
33	34	EIGEN_LIB = -L. -leigen
	35	EIGEN_FLAGS = -DCPPAD_EIGEN_EXAMPLES
34	36	libeigen_a_CXXFLAGS = \
35	37	-g $(CXX_FLAGS_EIGEN) \
36	38	-DCPPAD_EIGEN_EXAMPLES \

38	40	else
39	41	EIGEN_EXTRA_FILES = eigen_det.cpp eigen_array.cpp
40	42	EIGEN_LIB =
	43	EIGEN_FLAGS =
	44	endif
	45	else
	46	EIGEN_EXTRA_FILES = eigen_det.cpp eigen_array.cpp
	47	EIGEN_LIB =
	48	EIGEN_FLAGS =
41	49	endif
42	50	# -------------------------------------------------------------------------
43		# Microsoft project files an script to run a single test
	51	# auto-tools does not support use of colpack
44	52	EXTRA_DIST = \
45	53	test_one.sh.in \
	54	colpack.cpp \
46	55	$(ADOLC_EXTRA_FILES) \
47	56	$(EIGEN_EXTRA_FILES)
48	57	#
49	58	check_PROGRAMS = example
50	59	#
51	60	if CppAD_MS_COMPILER
52		AM_CXXFLAGS = -EHsc -g $(ADOLC_FLAGS) $(CXX_FLAGS)
53		else
54		AM_CXXFLAGS = -g $(ADOLC_FLAGS) $(CXX_FLAGS)
	61	AM_CXXFLAGS = -EHsc -g $(ADOLC_FLAGS) $(EIGEN_FLAGS) $(CXX_FLAGS)
	62	else
	63	AM_CXXFLAGS = -g $(ADOLC_FLAGS) $(EIGEN_FLAGS) $(CXX_FLAGS)
55	64	endif
56	65	#
57	66	AM_CPPFLAGS = \

59	68	-I$(top_srcdir) \
60	69	$(BOOST_INCLUDE) \
61	70	$(EIGEN_INCLUDE) \
62		$(ADOLC_FLAGS)
	71	$(ADOLC_FLAGS) \
	72	$(EIGEN_FLAGS)
63	73	#
64	74	LDADD = $(ADOLC_LIB) $(BTHREAD_LIB) $(EIGEN_LIB) $(PTHREAD_LIB)
65	75	#

85	95	base_require.cpp \
86	96	bender_quad.cpp \
87	97	bool_fun.cpp \
88		capacity_taylor.cpp \
	98	capacity_order.cpp \
89	99	change_const.cpp \
90	100	check_for_nan.cpp \
91	101	check_numeric_type.cpp \

107	117	for_one.cpp \
108	118	for_two.cpp \
109	119	forward.cpp \
110		forward_mul.cpp \
	120	forward_dir.cpp \
	121	forward_order.cpp \
111	122	for_sparse_jac.cpp \
112	123	fun_assign.cpp \
113	124	fun_check.cpp \

+206

-122

example/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

15	14	@SET_MAKE@
16	15
17	16	VPATH = @srcdir@
18		am__make_dryrun = \
19		{ \
20		am__dry=no; \
	17	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	18	am__make_running_with_option = \
	19	case $${target_option-} in \
	20	?) ;; \
	21	*) echo "am__make_running_with_option: internal error: invalid" \
	22	"target option '$${target_option-}' specified" >&2; \
	23	exit 1;; \
	24	esac; \
	25	has_opt=no; \
	26	sane_makeflags=$$MAKEFLAGS; \
	27	if $(am__is_gnu_make); then \
	28	sane_makeflags=$$MFLAGS; \
	29	else \
21	30	case $$MAKEFLAGS in \
22	31	\\[\ \ ]) \
23		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
24		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
25		*) \
26		for am__flg in $$MAKEFLAGS; do \
27		case $$am__flg in \
28		=\|--*) ;; \
29		n) am__dry=yes; break;; \
30		esac; \
31		done;; \
	32	bs=\\; \
	33	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	34	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
32	35	esac; \
33		test $$am__dry = yes; \
34		}
	36	fi; \
	37	skip_next=no; \
	38	strip_trailopt () \
	39	{ \
	40	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	41	}; \
	42	for flg in $$sane_makeflags; do \
	43	test $$skip_next = yes && { skip_next=no; continue; }; \
	44	case $$flg in \
	45	=\|--*) continue;; \
	46	-*I) strip_trailopt 'I'; skip_next=yes;; \
	47	-I?) strip_trailopt 'I';; \
	48	-*O) strip_trailopt 'O'; skip_next=yes;; \
	49	-O?) strip_trailopt 'O';; \
	50	-*l) strip_trailopt 'l'; skip_next=yes;; \
	51	-l?) strip_trailopt 'l';; \
	52	-[dEDm]) skip_next=yes;; \
	53	-[JT]) skip_next=yes;; \
	54	esac; \
	55	case $$flg in \
	56	$$target_option) has_opt=yes; break;; \
	57	esac; \
	58	done; \
	59	test $$has_opt = yes
	60	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	61	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
35	62	pkgdatadir = $(datadir)/@PACKAGE@
36	63	pkgincludedir = $(includedir)/@PACKAGE@
37	64	pkglibdir = $(libdir)/@PACKAGE@

48	75	NORMAL_UNINSTALL = :
49	76	PRE_UNINSTALL = :
50	77	POST_UNINSTALL = :
	78	build_triplet = @build@
	79	host_triplet = @host@
51	80	check_PROGRAMS = example$(EXEEXT)
52	81	subdir = example
53		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in \
54		$(srcdir)/test_one.sh.in
	82	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	83	$(srcdir)/test_one.sh.in $(top_srcdir)/depcomp
55	84	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
56	85	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
57	86	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

60	89	CONFIG_CLEAN_FILES = test_one.sh
61	90	CONFIG_CLEAN_VPATH_FILES =
62	91	LIBRARIES = $(noinst_LIBRARIES)
63		AR = ar
64	92	ARFLAGS = cru
65	93	AM_V_AR = $(am__v_AR_@AM_V@)
66	94	am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
67		am__v_AR_0 = @echo " AR " $@;
68		AM_V_at = $(am__v_at_@AM_V@)
69		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
70		am__v_at_0 = @
	95	am__v_AR_0 = @echo " AR " $@;
	96	am__v_AR_1 =
71	97	libeigen_a_AR = $(AR) $(ARFLAGS)
72	98	libeigen_a_LIBADD =
73	99	am__libeigen_a_SOURCES_DIST = eigen_det.cpp eigen_array.cpp
74		@CppAD_EIGEN_DIR_TRUE@am_libeigen_a_OBJECTS = \
75		@CppAD_EIGEN_DIR_TRUE@ libeigen_a-eigen_det.$(OBJEXT) \
76		@CppAD_EIGEN_DIR_TRUE@ libeigen_a-eigen_array.$(OBJEXT)
	100	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@am_libeigen_a_OBJECTS = libeigen_a-eigen_det.$(OBJEXT) \
	101	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@ libeigen_a-eigen_array.$(OBJEXT)
77	102	libeigen_a_OBJECTS = $(am_libeigen_a_OBJECTS)
78	103	am__example_SOURCES_DIST = mul_level_adolc.cpp mul_level_adolc_ode.cpp \
79	104	example.cpp abort_recording.cpp abs.cpp acos.cpp add.cpp \
80	105	add_eq.cpp ad_assign.cpp ad_ctor.cpp ad_fun.cpp ad_in_c.cpp \
81	106	ad_input.cpp ad_output.cpp asin.cpp atan.cpp atan2.cpp \
82	107	base_alloc.hpp base_require.cpp bender_quad.cpp bool_fun.cpp \
83		capacity_taylor.cpp change_const.cpp check_for_nan.cpp \
	108	capacity_order.cpp change_const.cpp check_for_nan.cpp \
84	109	check_numeric_type.cpp check_simple_vector.cpp compare.cpp \
85	110	compare_change.cpp complex_poly.cpp cond_exp.cpp conj_grad.cpp \
86	111	cos.cpp cosh.cpp cppad_vector.cpp div.cpp div_eq.cpp \
87	112	equal_op_seq.cpp erf.cpp error_handler.cpp exp.cpp for_one.cpp \
88		for_two.cpp forward.cpp forward_mul.cpp for_sparse_jac.cpp \
89		fun_assign.cpp fun_check.cpp hes_lagrangian.cpp hes_lu_det.cpp \
90		hes_minor_det.cpp hessian.cpp hes_times_dir.cpp \
91		independent.cpp index_sort.cpp integer.cpp interface2c.cpp \
92		interp_onetape.cpp interp_retape.cpp jac_lu_det.cpp \
93		jac_minor_det.cpp jacobian.cpp limits.cpp log.cpp log10.cpp \
94		lu_factor.cpp lu_invert.cpp lu_ratio.cpp lu_solve.cpp \
95		lu_vec_ad.cpp lu_vec_ad.hpp lu_vec_ad_ok.cpp mul.cpp \
96		mul_eq.cpp mul_level.cpp mul_level_ode.cpp nan.cpp \
97		near_equal.cpp near_equal_ext.cpp not_complex_ad.cpp \
98		number_skip.cpp numeric_type.cpp ode_err_control.cpp \
99		ode_err_maxabs.cpp ode_gear.cpp ode_gear_control.cpp \
100		ode_stiff.cpp ode_taylor.cpp omp_alloc.cpp opt_val_hes.cpp \
101		optimize.cpp par_var.cpp poly.cpp pow.cpp pow_int.cpp \
102		print_for.cpp reverse_any.cpp reverse_one.cpp \
103		reverse_three.cpp reverse_two.cpp rev_one.cpp \
	113	for_two.cpp forward.cpp forward_dir.cpp forward_order.cpp \
	114	for_sparse_jac.cpp fun_assign.cpp fun_check.cpp \
	115	hes_lagrangian.cpp hes_lu_det.cpp hes_minor_det.cpp \
	116	hessian.cpp hes_times_dir.cpp independent.cpp index_sort.cpp \
	117	integer.cpp interface2c.cpp interp_onetape.cpp \
	118	interp_retape.cpp jac_lu_det.cpp jac_minor_det.cpp \
	119	jacobian.cpp limits.cpp log.cpp log10.cpp lu_factor.cpp \
	120	lu_invert.cpp lu_ratio.cpp lu_solve.cpp lu_vec_ad.cpp \
	121	lu_vec_ad.hpp lu_vec_ad_ok.cpp mul.cpp mul_eq.cpp \
	122	mul_level.cpp mul_level_ode.cpp nan.cpp near_equal.cpp \
	123	near_equal_ext.cpp not_complex_ad.cpp number_skip.cpp \
	124	numeric_type.cpp ode_err_control.cpp ode_err_maxabs.cpp \
	125	ode_gear.cpp ode_gear_control.cpp ode_stiff.cpp ode_taylor.cpp \
	126	omp_alloc.cpp opt_val_hes.cpp optimize.cpp par_var.cpp \
	127	poly.cpp pow.cpp pow_int.cpp print_for.cpp reverse_any.cpp \
	128	reverse_one.cpp reverse_three.cpp reverse_two.cpp rev_one.cpp \
104	129	rev_sparse_hes.cpp rev_sparse_jac.cpp rev_two.cpp \
105	130	romberg_mul.cpp romberg_one.cpp rosen_34.cpp runge45_1.cpp \
106	131	runge45_2.cpp seq_property.cpp simple_vector.cpp sign.cpp \

117	142	ad_input.$(OBJEXT) ad_output.$(OBJEXT) asin.$(OBJEXT) \
118	143	atan.$(OBJEXT) atan2.$(OBJEXT) base_require.$(OBJEXT) \
119	144	bender_quad.$(OBJEXT) bool_fun.$(OBJEXT) \
120		capacity_taylor.$(OBJEXT) change_const.$(OBJEXT) \
	145	capacity_order.$(OBJEXT) change_const.$(OBJEXT) \
121	146	check_for_nan.$(OBJEXT) check_numeric_type.$(OBJEXT) \
122	147	check_simple_vector.$(OBJEXT) compare.$(OBJEXT) \
123	148	compare_change.$(OBJEXT) complex_poly.$(OBJEXT) \

125	150	cosh.$(OBJEXT) cppad_vector.$(OBJEXT) div.$(OBJEXT) \
126	151	div_eq.$(OBJEXT) equal_op_seq.$(OBJEXT) erf.$(OBJEXT) \
127	152	error_handler.$(OBJEXT) exp.$(OBJEXT) for_one.$(OBJEXT) \
128		for_two.$(OBJEXT) forward.$(OBJEXT) forward_mul.$(OBJEXT) \
129		for_sparse_jac.$(OBJEXT) fun_assign.$(OBJEXT) \
130		fun_check.$(OBJEXT) hes_lagrangian.$(OBJEXT) \
131		hes_lu_det.$(OBJEXT) hes_minor_det.$(OBJEXT) hessian.$(OBJEXT) \
	153	for_two.$(OBJEXT) forward.$(OBJEXT) forward_dir.$(OBJEXT) \
	154	forward_order.$(OBJEXT) for_sparse_jac.$(OBJEXT) \
	155	fun_assign.$(OBJEXT) fun_check.$(OBJEXT) \
	156	hes_lagrangian.$(OBJEXT) hes_lu_det.$(OBJEXT) \
	157	hes_minor_det.$(OBJEXT) hessian.$(OBJEXT) \
132	158	hes_times_dir.$(OBJEXT) independent.$(OBJEXT) \
133	159	index_sort.$(OBJEXT) integer.$(OBJEXT) interface2c.$(OBJEXT) \
134	160	interp_onetape.$(OBJEXT) interp_retape.$(OBJEXT) \

165	191	am__DEPENDENCIES_1 =
166	192	example_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
167	193	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
	194	AM_V_P = $(am__v_P_@AM_V@)
	195	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	196	am__v_P_0 = false
	197	am__v_P_1 = :
	198	AM_V_GEN = $(am__v_GEN_@AM_V@)
	199	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	200	am__v_GEN_0 = @echo " GEN " $@;
	201	am__v_GEN_1 =
	202	AM_V_at = $(am__v_at_@AM_V@)
	203	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	204	am__v_at_0 = @
	205	am__v_at_1 =
168	206	DEFAULT_INCLUDES =
169	207	depcomp = $(SHELL) $(top_srcdir)/depcomp
170	208	am__depfiles_maybe = depfiles

172	210	AM_V_lt = $(am__v_lt_@AM_V@)
173	211	am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
174	212	am__v_lt_0 = --silent
	213	am__v_lt_1 =
175	214	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
176	215	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
177	216	AM_V_CXX = $(am__v_CXX_@AM_V@)
178	217	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
179		am__v_CXX_0 = @echo " CXX " $@;
	218	am__v_CXX_0 = @echo " CXX " $@;
	219	am__v_CXX_1 =
180	220	CXXLD = $(CXX)
181	221	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
182	222	-o $@
183	223	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
184	224	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
185		am__v_CXXLD_0 = @echo " CXXLD " $@;
	225	am__v_CXXLD_0 = @echo " CXXLD " $@;
	226	am__v_CXXLD_1 =
186	227	COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
187	228	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
188	229	AM_V_CC = $(am__v_CC_@AM_V@)
189	230	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
190		am__v_CC_0 = @echo " CC " $@;
	231	am__v_CC_0 = @echo " CC " $@;
	232	am__v_CC_1 =
191	233	CCLD = $(CC)
192	234	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
193	235	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
194	236	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
195		am__v_CCLD_0 = @echo " CCLD " $@;
196		AM_V_GEN = $(am__v_GEN_@AM_V@)
197		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
198		am__v_GEN_0 = @echo " GEN " $@;
	237	am__v_CCLD_0 = @echo " CCLD " $@;
	238	am__v_CCLD_1 =
199	239	SOURCES = $(libeigen_a_SOURCES) $(example_SOURCES)
200	240	DIST_SOURCES = $(am__libeigen_a_SOURCES_DIST) \
201	241	$(am__example_SOURCES_DIST)

204	244	n\|no\|NO) false;; \
205	245	*) (install-info --version) >/dev/null 2>&1;; \
206	246	esac
	247	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	248	# Read a list of newline-separated strings from the standard input,
	249	# and print each of them once, without duplicates. Input order is
	250	# not preserved.
	251	am__uniquify_input = $(AWK) '\
	252	BEGIN { nonempty = 0; } \
	253	{ items[$$0] = 1; nonempty = 1; } \
	254	END { if (nonempty) { for (i in items) print i; }; } \
	255	'
	256	# Make sure the list of sources is unique. This is necessary because,
	257	# e.g., the same source file might be shared among _SOURCES variables
	258	# for different programs/libraries.
	259	am__define_uniq_tagged_files = \
	260	list='$(am__tagged_files)'; \
	261	unique=`for i in $$list; do \
	262	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	263	done \| $(am__uniquify_input)`
207	264	ETAGS = etags
208	265	CTAGS = ctags
209	266	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

213	270	ADOLC_DIR = @ADOLC_DIR@
214	271	AMTAR = @AMTAR@
215	272	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	273	AR = @AR@
216	274	AUTOCONF = @AUTOCONF@
217	275	AUTOHEADER = @AUTOHEADER@
218	276	AUTOMAKE = @AUTOMAKE@

235	293	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
236	294	CYGPATH_W = @CYGPATH_W@
237	295
238		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	296	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
239	297	# -----------------------------------------------------------------------------
240		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	298	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
241	299	#
242	300	# CppAD is distributed under multiple licenses. This distribution is under
243	301	# the terms of the

302	360	abs_srcdir = @abs_srcdir@
303	361	abs_top_builddir = @abs_top_builddir@
304	362	abs_top_srcdir = @abs_top_srcdir@
	363	ac_ct_AR = @ac_ct_AR@
305	364	ac_ct_CC = @ac_ct_CC@
306	365	ac_ct_CXX = @ac_ct_CXX@
307	366	ac_ct_FC = @ac_ct_FC@

312	371	am__tar = @am__tar@
313	372	am__untar = @am__untar@
314	373	bindir = @bindir@
	374	build = @build@
315	375	build_alias = @build_alias@
	376	build_cpu = @build_cpu@
	377	build_os = @build_os@
	378	build_vendor = @build_vendor@
316	379	builddir = @builddir@
317	380	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
318	381	cppad_boostvector = @cppad_boostvector@
319	382	cppad_cflags = @cppad_cflags@
	383	cppad_compiler_has_erf = @cppad_compiler_has_erf@
320	384	cppad_cppadvector = @cppad_cppadvector@
321	385	cppad_description = @cppad_description@
322	386	cppad_eigenvector = @cppad_eigenvector@
	387	cppad_has_colpack = @cppad_has_colpack@
	388	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
323	389	cppad_has_gettimeofday = @cppad_has_gettimeofday@
324	390	cppad_has_nullptr = @cppad_has_nullptr@
	391	cppad_has_rvalue = @cppad_has_rvalue@
325	392	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
326	393	cppad_internal_sparse_set = @cppad_internal_sparse_set@
327	394	cppad_libs = @cppad_libs@
328	395	cppad_max_num_threads = @cppad_max_num_threads@
329	396	cppad_requires = @cppad_requires@
330		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	397	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
331	398	cppad_stdvector = @cppad_stdvector@
332	399	cppad_tape_addr_type = @cppad_tape_addr_type@
333	400	cppad_tape_id_type = @cppad_tape_id_type@

339	406	dvidir = @dvidir@
340	407	eigen_prefix = @eigen_prefix@
341	408	exec_prefix = @exec_prefix@
342		have_ar = @have_ar@
343	409	have_pkg_config = @have_pkg_config@
	410	host = @host@
344	411	host_alias = @host_alias@
	412	host_cpu = @host_cpu@
	413	host_os = @host_os@
	414	host_vendor = @host_vendor@
345	415	htmldir = @htmldir@
346	416	includedir = @includedir@
347	417	infodir = @infodir@

375	445	@CppAD_ADOLC_TRUE@ADOLC_LIB = -ladolc -lColPack -L$(ADOLC_DIR)/lib -L$(ADOLC_DIR)/lib64
376	446	@CppAD_ADOLC_FALSE@ADOLC_FLAGS =
377	447	@CppAD_ADOLC_TRUE@ADOLC_FLAGS = -DCPPAD_ADOLC_EXAMPLES -I$(ADOLC_DIR)/include
378		@CppAD_EIGEN_DIR_FALSE@EIGEN_EXTRA_FILES = eigen_det.cpp eigen_array.cpp
	448	@CppAD_EIGEN_DIR_FALSE@@CppAD_HAVE_AR_TRUE@EIGEN_EXTRA_FILES = eigen_det.cpp eigen_array.cpp
379	449	# -------------------------------------------------------------------------
380	450	# make a special library so can have it's own compile flags (see configure.ac)
381		@CppAD_EIGEN_DIR_TRUE@EIGEN_EXTRA_FILES =
382		@CppAD_EIGEN_DIR_TRUE@noinst_LIBRARIES = libeigen.a
383		@CppAD_EIGEN_DIR_TRUE@libeigen_a_SOURCES = eigen_det.cpp eigen_array.cpp
384		@CppAD_EIGEN_DIR_FALSE@EIGEN_LIB =
385		@CppAD_EIGEN_DIR_TRUE@EIGEN_LIB = -L. -leigen
386		@CppAD_EIGEN_DIR_TRUE@libeigen_a_CXXFLAGS = \
387		@CppAD_EIGEN_DIR_TRUE@ -g $(CXX_FLAGS_EIGEN) \
388		@CppAD_EIGEN_DIR_TRUE@ -DCPPAD_EIGEN_EXAMPLES \
389		@CppAD_EIGEN_DIR_TRUE@ -I$(EIGEN_DIR)/include
	451	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@EIGEN_EXTRA_FILES =
	452	@CppAD_HAVE_AR_FALSE@EIGEN_EXTRA_FILES = eigen_det.cpp eigen_array.cpp
	453	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@noinst_LIBRARIES = libeigen.a
	454	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@libeigen_a_SOURCES = eigen_det.cpp eigen_array.cpp
	455	@CppAD_EIGEN_DIR_FALSE@@CppAD_HAVE_AR_TRUE@EIGEN_LIB =
	456	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@EIGEN_LIB = -L. -leigen
	457	@CppAD_HAVE_AR_FALSE@EIGEN_LIB =
	458	@CppAD_EIGEN_DIR_FALSE@@CppAD_HAVE_AR_TRUE@EIGEN_FLAGS =
	459	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@EIGEN_FLAGS = -DCPPAD_EIGEN_EXAMPLES
	460	@CppAD_HAVE_AR_FALSE@EIGEN_FLAGS =
	461	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@libeigen_a_CXXFLAGS = \
	462	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@ -g $(CXX_FLAGS_EIGEN) \
	463	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@ -DCPPAD_EIGEN_EXAMPLES \
	464	@CppAD_EIGEN_DIR_TRUE@@CppAD_HAVE_AR_TRUE@ -I$(EIGEN_DIR)/include
390	465
391	466	# -------------------------------------------------------------------------
392		# Microsoft project files an script to run a single test
	467	# auto-tools does not support use of colpack
393	468	EXTRA_DIST = \
394	469	test_one.sh.in \
	470	colpack.cpp \
395	471	$(ADOLC_EXTRA_FILES) \
396	472	$(EIGEN_EXTRA_FILES)
397	473
398		@CppAD_MS_COMPILER_FALSE@AM_CXXFLAGS = -g $(ADOLC_FLAGS) $(CXX_FLAGS)
	474	@CppAD_MS_COMPILER_FALSE@AM_CXXFLAGS = -g $(ADOLC_FLAGS) $(EIGEN_FLAGS) $(CXX_FLAGS)
399	475	#
400		@CppAD_MS_COMPILER_TRUE@AM_CXXFLAGS = -EHsc -g $(ADOLC_FLAGS) $(CXX_FLAGS)
	476	@CppAD_MS_COMPILER_TRUE@AM_CXXFLAGS = -EHsc -g $(ADOLC_FLAGS) $(EIGEN_FLAGS) $(CXX_FLAGS)
401	477	#
402	478	AM_CPPFLAGS = \
403	479	-I. \
404	480	-I$(top_srcdir) \
405	481	$(BOOST_INCLUDE) \
406	482	$(EIGEN_INCLUDE) \
407		$(ADOLC_FLAGS)
	483	$(ADOLC_FLAGS) \
	484	$(EIGEN_FLAGS)
408	485
409	486	#
410	487	LDADD = $(ADOLC_LIB) $(BTHREAD_LIB) $(EIGEN_LIB) $(PTHREAD_LIB)

431	508	base_require.cpp \
432	509	bender_quad.cpp \
433	510	bool_fun.cpp \
434		capacity_taylor.cpp \
	511	capacity_order.cpp \
435	512	change_const.cpp \
436	513	check_for_nan.cpp \
437	514	check_numeric_type.cpp \

453	530	for_one.cpp \
454	531	for_two.cpp \
455	532	forward.cpp \
456		forward_mul.cpp \
	533	forward_dir.cpp \
	534	forward_order.cpp \
457	535	for_sparse_jac.cpp \
458	536	fun_assign.cpp \
459	537	fun_check.cpp \

579	657
580	658	clean-noinstLIBRARIES:
581	659	-test -z "$(noinst_LIBRARIES)" \|\| rm -f $(noinst_LIBRARIES)
	660
582	661	libeigen.a: $(libeigen_a_OBJECTS) $(libeigen_a_DEPENDENCIES) $(EXTRA_libeigen_a_DEPENDENCIES)
583	662	$(AM_V_at)-rm -f libeigen.a
584	663	$(AM_V_AR)$(libeigen_a_AR) libeigen.a $(libeigen_a_OBJECTS) $(libeigen_a_LIBADD)

586	665
587	666	clean-checkPROGRAMS:
588	667	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	668
589	669	example$(EXEEXT): $(example_OBJECTS) $(example_DEPENDENCIES) $(EXTRA_example_DEPENDENCIES)
590	670	@rm -f example$(EXEEXT)
591	671	$(AM_V_CXXLD)$(CXXLINK) $(example_OBJECTS) $(example_LDADD) $(LIBS)

613	693	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/base_require.Po@am__quote@
614	694	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bender_quad.Po@am__quote@
615	695	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bool_fun.Po@am__quote@
616		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/capacity_taylor.Po@am__quote@
	696	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/capacity_order.Po@am__quote@
617	697	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/change_const.Po@am__quote@
618	698	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/check_for_nan.Po@am__quote@
619	699	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/check_numeric_type.Po@am__quote@

637	717	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_sparse_jac.Po@am__quote@
638	718	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_two.Po@am__quote@
639	719	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward.Po@am__quote@
640		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward_mul.Po@am__quote@
	720	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward_dir.Po@am__quote@
	721	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward_order.Po@am__quote@
641	722	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fun_assign.Po@am__quote@
642	723	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fun_check.Po@am__quote@
643	724	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hes_lagrangian.Po@am__quote@

727	808	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vector_bool.Po@am__quote@
728	809
729	810	.cpp.o:
730		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
731		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	811	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	812	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	813	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
732	814	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
733	815	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
734	816	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
735	817
736	818	.cpp.obj:
737		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
738		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	819	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	820	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	821	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
739	822	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
740	823	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
741	824	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`

768	851	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
769	852	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libeigen_a_CXXFLAGS) $(CXXFLAGS) -c -o libeigen_a-eigen_array.obj `if test -f 'eigen_array.cpp'; then $(CYGPATH_W) 'eigen_array.cpp'; else $(CYGPATH_W) '$(srcdir)/eigen_array.cpp'; fi`
770	853
771		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
772		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
773		unique=`for i in $$list; do \
774		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
775		done \| \
776		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
777		END { if (nonempty) { for (i in files) print i; }; }'`; \
778		mkid -fID $$unique
779		tags: TAGS
780
781		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
782		$(TAGS_FILES) $(LISP)
	854	ID: $(am__tagged_files)
	855	$(am__define_uniq_tagged_files); mkid -fID $$unique
	856	tags: tags-am
	857	TAGS: tags
	858
	859	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
783	860	set x; \
784	861	here=`pwd`; \
785		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
786		unique=`for i in $$list; do \
787		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
788		done \| \
789		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
790		END { if (nonempty) { for (i in files) print i; }; }'`; \
	862	$(am__define_uniq_tagged_files); \
791	863	shift; \
792	864	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
793	865	test -n "$$unique" \|\| unique=$$empty_fix; \

799	871	$$unique; \
800	872	fi; \
801	873	fi
802		ctags: CTAGS
803		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
804		$(TAGS_FILES) $(LISP)
805		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
806		unique=`for i in $$list; do \
807		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
808		done \| \
809		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
810		END { if (nonempty) { for (i in files) print i; }; }'`; \
	874	ctags: ctags-am
	875
	876	CTAGS: ctags
	877	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	878	$(am__define_uniq_tagged_files); \
811	879	test -z "$(CTAGS_ARGS)$$unique" \
812	880	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
813	881	$$unique

816	884	here=`$(am__cd) $(top_builddir) && pwd` \
817	885	&& $(am__cd) $(top_srcdir) \
818	886	&& gtags -i $(GTAGS_ARGS) "$$here"
	887	cscopelist: cscopelist-am
	888
	889	cscopelist-am: $(am__tagged_files)
	890	list='$(am__tagged_files)'; \
	891	case "$(srcdir)" in \
	892	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	893	*) sdir=$(subdir)/$(srcdir) ;; \
	894	esac; \
	895	for i in $$list; do \
	896	if test -f "$$i"; then \
	897	echo "$(subdir)/$$i"; \
	898	else \
	899	echo "$$sdir/$$i"; \
	900	fi; \
	901	done >> $(top_builddir)/cscope.files
819	902
820	903	distclean-tags:
821	904	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

957	1040
958	1041	.MAKE: check-am install-am install-strip
959	1042
960		.PHONY: CTAGS GTAGS all all-am check check-am clean \
961		clean-checkPROGRAMS clean-generic clean-noinstLIBRARIES ctags \
962		distclean distclean-compile distclean-generic distclean-tags \
963		distdir dvi dvi-am html html-am info info-am install \
964		install-am install-data install-data-am install-dvi \
965		install-dvi-am install-exec install-exec-am install-html \
966		install-html-am install-info install-info-am install-man \
967		install-pdf install-pdf-am install-ps install-ps-am \
968		install-strip installcheck installcheck-am installdirs \
969		maintainer-clean maintainer-clean-generic mostlyclean \
970		mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
971		tags uninstall uninstall-am
	1043	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	1044	clean-checkPROGRAMS clean-generic clean-noinstLIBRARIES \
	1045	cscopelist-am ctags ctags-am distclean distclean-compile \
	1046	distclean-generic distclean-tags distdir dvi dvi-am html \
	1047	html-am info info-am install install-am install-data \
	1048	install-data-am install-dvi install-dvi-am install-exec \
	1049	install-exec-am install-html install-html-am install-info \
	1050	install-info-am install-man install-pdf install-pdf-am \
	1051	install-ps install-ps-am install-strip installcheck \
	1052	installcheck-am installdirs maintainer-clean \
	1053	maintainer-clean-generic mostlyclean mostlyclean-compile \
	1054	mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \
	1055	uninstall-am
972	1056
973	1057
974	1058	test: check

-3

example/reverse_any.cpp less more

0		/* $Id: reverse_any.cpp 2859 2013-05-28 06:03:21Z bradbell $ */
	0	/* $Id: reverse_any.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

178	178	f = empty;
179	179	else
180	180	{ // free all the Taylor coefficients stored in f
181		f.capacity_taylor(0);
	181	f.capacity_order(0);
182	182	}
183	183
184	184	// record the function G(x)

+12

-3

example/test_one.sh.in less more

0	0	#! /bin/bash -e
1		# $Id: test_one.sh.in 3073 2014-01-01 11:48:13Z bradbell $
	1	# $Id: test_one.sh.in 3322 2014-09-12 10:29:34Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

49	49	$cxxflags
50	50	-g
51	51	-fopenmp
52		-lboost_thread-mt
	52	-lboost_thread
53	53	-lpthread
54	54	-std=c++11 -DCPPAD_ADOLC_EXAMPLES -DCPPAD_EIGEN_EXAMPLES
55	55	-I..

57	57	if [ -e @adolc_prefix@/include ]
58	58	then
59	59	cmd="$cmd -I@adolc_prefix@/include"
	60	fi
	61	if [ -e @colpack_prefix@/include ]
	62	then
	63	cmd="$cmd -I@colpack_prefix@/include"
60	64	fi
61	65	if [ -e @eigen_prefix@/include ]
62	66	then

69	73	cmd="$cmd -L@adolc_prefix@/$lib -ladolc -lColPack"
70	74	export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:@adolc_prefix@/$lib"
71	75	fi
	76	if [ -e @colpack_prefix@/$lib ]
	77	then
	78	cmd="$cmd -L@colpack_prefix@/$lib -lColPack"
	79	export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:@colpack_prefix@/$lib"
	80	fi
72	81	done
73	82	echo $cmd
74	83	$cmd

+53

-2

example/thread_alloc.cpp less more

0		/* $Id: thread_alloc.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: thread_alloc.cpp 3408 2014-11-27 15:17:20Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
3	3

35	35	# include <cppad/thread_alloc.hpp>
36	36	# include <cppad/memory_leak.hpp>
37	37	# include <vector>
	38	# include <limits>
38	39
39	40
40	41	namespace { // Begin empty namespace
	42
	43
41	44
42	45	bool raw_allocate(void)
43	46	{ bool ok = true;

163	166
164	167	} // End empty namespace
165	168
	169	bool check_alignment(void)
	170	{ bool ok = true;
	171	using CppAD::thread_alloc;
	172
	173	// number of binary digits in a size_t value
	174	size_t n_digit = std::numeric_limits<size_t>::digits;
	175
	176	// must be a multiple of 8
	177	ok &= (n_digit % 8) == 0;
	178
	179	// number of bytes in a size_t value
	180	size_t n_byte = n_digit / 8;
	181
	182	// check raw allocation -------------------------------------------------
	183	size_t min_bytes = 1;
	184	size_t cap_bytes;
	185	void* v_ptr = thread_alloc::get_memory(min_bytes, cap_bytes);
	186
	187	// convert to a size_t value
	188	size_t v_size_t = reinterpret_cast<size_t>(v_ptr);
	189
	190	// check that it is aligned
	191	ok &= (v_size_t % n_byte) == 0;
	192
	193	// return memory to available pool
	194	thread_alloc::return_memory(v_ptr);
	195
	196	// check array allocation ----------------------------------------------
	197	size_t size_min = 1;
	198	size_t size_out;
	199	my_char *array_ptr =
	200	thread_alloc::create_array<my_char>(size_min, size_out);
	201
	202	// convert to a size_t value
	203	size_t array_size_t = reinterpret_cast<size_t>(array_ptr);
	204
	205	// check that it is aligned
	206	ok &= (array_size_t % n_byte) == 0;
	207
	208	// return memory to avialable pool
	209	thread_alloc::delete_array(array_ptr);
	210
	211	return ok;
	212	}
	213
166	214
167	215	bool thread_alloc(void)
168	216	{ bool ok = true;

184	232
185	233	// run typed allocation tests
186	234	ok &= type_allocate();
187
	235
	236	// check alignment
	237	ok &= check_alignment();
	238
188	239	// return allocator to its default mode
189	240	thread_alloc::hold_memory(false);
190	241	return ok;

-7

install-sh less more

0	0	#!/bin/sh
1	1	# install - install a program, script, or datafile
2	2
3		scriptversion=2011-01-19.21; # UTC
	3	scriptversion=2011-11-20.07; # UTC
4	4
5	5	# This originates from X11R5 (mit/util/scripts/install.sh), which was
6	6	# later released in X11R6 (xc/config/util/install.sh) with the

34	34	# FSF changes to this file are in the public domain.
35	35	#
36	36	# Calling this script install-sh is preferred over install.sh, to prevent
37		# `make' implicit rules from creating a file called install from it
	37	# 'make' implicit rules from creating a file called install from it
38	38	# when there is no Makefile.
39	39	#
40	40	# This script is compatible with the BSD install script, but was written

155	155	-s) stripcmd=$stripprog;;
156	156
157	157	-t) dst_arg=$2
158		# Protect names problematic for `test' and other utilities.
	158	# Protect names problematic for 'test' and other utilities.
159	159	case $dst_arg in
160	160	-* \| [=!]) dst_arg=./$dst_arg;;
161	161	esac

189	189	fi
190	190	shift # arg
191	191	dst_arg=$arg
192		# Protect names problematic for `test' and other utilities.
	192	# Protect names problematic for 'test' and other utilities.
193	193	case $dst_arg in
194	194	-* \| [=!]) dst_arg=./$dst_arg;;
195	195	esac

201	201	echo "$0: no input file specified." >&2
202	202	exit 1
203	203	fi
204		# It's OK to call `install-sh -d' without argument.
	204	# It's OK to call 'install-sh -d' without argument.
205	205	# This can happen when creating conditional directories.
206	206	exit 0
207	207	fi

239	239
240	240	for src
241	241	do
242		# Protect names problematic for `test' and other utilities.
	242	# Protect names problematic for 'test' and other utilities.
243	243	case $src in
244	244	-* \| [=!]) src=./$src;;
245	245	esac

353	353	if test -z "$dir_arg" \|\| {
354	354	# Check for POSIX incompatibilities with -m.
355	355	# HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
356		# other-writeable bit of parent directory when it shouldn't.
	356	# other-writable bit of parent directory when it shouldn't.
357	357	# FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
358	358	ls_ld_tmpdir=`ls -ld "$tmpdir"`
359	359	case $ls_ld_tmpdir in

-3

introduction/exp_apx/main.cpp less more

0		/* $Id: main.cpp 2683 2012-12-30 18:17:03Z bradbell $ */
	0	/* $Id: main.cpp 3114 2014-02-22 16:20:39Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

24	24	$index test, exp_apx main$$
25	25
26	26	$head Running Tests$$
27		To build this program and run its correctness tests see $cref cppad_test$$.
	27	To build this program and run its correctness tests see $cref cmake_check$$.
28	28
29	29	$head main.cpp$$
30	30	$code

+148

-75

introduction/exp_apx/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = exp_apx$(EXEEXT)
51	80	subdir = introduction/exp_apx
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

66	96	exp_eps_rev2.$(OBJEXT)
67	97	exp_apx_OBJECTS = $(am_exp_apx_OBJECTS)
68	98	exp_apx_LDADD = $(LDADD)
	99	AM_V_P = $(am__v_P_@AM_V@)
	100	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	101	am__v_P_0 = false
	102	am__v_P_1 = :
	103	AM_V_GEN = $(am__v_GEN_@AM_V@)
	104	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	105	am__v_GEN_0 = @echo " GEN " $@;
	106	am__v_GEN_1 =
	107	AM_V_at = $(am__v_at_@AM_V@)
	108	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	109	am__v_at_0 = @
	110	am__v_at_1 =
69	111	DEFAULT_INCLUDES =
70	112	depcomp = $(SHELL) $(top_srcdir)/depcomp
71	113	am__depfiles_maybe = depfiles

74	116	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
75	117	AM_V_CXX = $(am__v_CXX_@AM_V@)
76	118	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
77		am__v_CXX_0 = @echo " CXX " $@;
78		AM_V_at = $(am__v_at_@AM_V@)
79		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
80		am__v_at_0 = @
	119	am__v_CXX_0 = @echo " CXX " $@;
	120	am__v_CXX_1 =
81	121	CXXLD = $(CXX)
82	122	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
83	123	-o $@
84	124	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
85	125	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
86		am__v_CXXLD_0 = @echo " CXXLD " $@;
	126	am__v_CXXLD_0 = @echo " CXXLD " $@;
	127	am__v_CXXLD_1 =
87	128	COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
88	129	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
89	130	AM_V_CC = $(am__v_CC_@AM_V@)
90	131	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
91		am__v_CC_0 = @echo " CC " $@;
	132	am__v_CC_0 = @echo " CC " $@;
	133	am__v_CC_1 =
92	134	CCLD = $(CC)
93	135	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
94	136	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
95	137	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
96		am__v_CCLD_0 = @echo " CCLD " $@;
97		AM_V_GEN = $(am__v_GEN_@AM_V@)
98		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
99		am__v_GEN_0 = @echo " GEN " $@;
	138	am__v_CCLD_0 = @echo " CCLD " $@;
	139	am__v_CCLD_1 =
100	140	SOURCES = $(exp_apx_SOURCES)
101	141	DIST_SOURCES = $(exp_apx_SOURCES)
102	142	am__can_run_installinfo = \

104	144	n\|no\|NO) false;; \
105	145	*) (install-info --version) >/dev/null 2>&1;; \
106	146	esac
	147	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	148	# Read a list of newline-separated strings from the standard input,
	149	# and print each of them once, without duplicates. Input order is
	150	# not preserved.
	151	am__uniquify_input = $(AWK) '\
	152	BEGIN { nonempty = 0; } \
	153	{ items[$$0] = 1; nonempty = 1; } \
	154	END { if (nonempty) { for (i in items) print i; }; } \
	155	'
	156	# Make sure the list of sources is unique. This is necessary because,
	157	# e.g., the same source file might be shared among _SOURCES variables
	158	# for different programs/libraries.
	159	am__define_uniq_tagged_files = \
	160	list='$(am__tagged_files)'; \
	161	unique=`for i in $$list; do \
	162	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	163	done \| $(am__uniquify_input)`
107	164	ETAGS = etags
108	165	CTAGS = ctags
109	166	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

113	170	ADOLC_DIR = @ADOLC_DIR@
114	171	AMTAR = @AMTAR@
115	172	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	173	AR = @AR@
116	174	AUTOCONF = @AUTOCONF@
117	175	AUTOHEADER = @AUTOHEADER@
118	176	AUTOMAKE = @AUTOMAKE@

135	193	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
136	194	CYGPATH_W = @CYGPATH_W@
137	195
138		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	196	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
139	197	# -----------------------------------------------------------------------------
140	198	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
141	199	#

202	260	abs_srcdir = @abs_srcdir@
203	261	abs_top_builddir = @abs_top_builddir@
204	262	abs_top_srcdir = @abs_top_srcdir@
	263	ac_ct_AR = @ac_ct_AR@
205	264	ac_ct_CC = @ac_ct_CC@
206	265	ac_ct_CXX = @ac_ct_CXX@
207	266	ac_ct_FC = @ac_ct_FC@

212	271	am__tar = @am__tar@
213	272	am__untar = @am__untar@
214	273	bindir = @bindir@
	274	build = @build@
215	275	build_alias = @build_alias@
	276	build_cpu = @build_cpu@
	277	build_os = @build_os@
	278	build_vendor = @build_vendor@
216	279	builddir = @builddir@
217	280	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
218	281	cppad_boostvector = @cppad_boostvector@
219	282	cppad_cflags = @cppad_cflags@
	283	cppad_compiler_has_erf = @cppad_compiler_has_erf@
220	284	cppad_cppadvector = @cppad_cppadvector@
221	285	cppad_description = @cppad_description@
222	286	cppad_eigenvector = @cppad_eigenvector@
	287	cppad_has_colpack = @cppad_has_colpack@
	288	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
223	289	cppad_has_gettimeofday = @cppad_has_gettimeofday@
224	290	cppad_has_nullptr = @cppad_has_nullptr@
	291	cppad_has_rvalue = @cppad_has_rvalue@
225	292	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
226	293	cppad_internal_sparse_set = @cppad_internal_sparse_set@
227	294	cppad_libs = @cppad_libs@
228	295	cppad_max_num_threads = @cppad_max_num_threads@
229	296	cppad_requires = @cppad_requires@
230		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	297	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
231	298	cppad_stdvector = @cppad_stdvector@
232	299	cppad_tape_addr_type = @cppad_tape_addr_type@
233	300	cppad_tape_id_type = @cppad_tape_id_type@

239	306	dvidir = @dvidir@
240	307	eigen_prefix = @eigen_prefix@
241	308	exec_prefix = @exec_prefix@
242		have_ar = @have_ar@
243	309	have_pkg_config = @have_pkg_config@
	310	host = @host@
244	311	host_alias = @host_alias@
	312	host_cpu = @host_cpu@
	313	host_os = @host_os@
	314	host_vendor = @host_vendor@
245	315	htmldir = @htmldir@
246	316	includedir = @includedir@
247	317	infodir = @infodir@

332	402
333	403	clean-checkPROGRAMS:
334	404	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	405
335	406	exp_apx$(EXEEXT): $(exp_apx_OBJECTS) $(exp_apx_DEPENDENCIES) $(EXTRA_exp_apx_DEPENDENCIES)
336	407	@rm -f exp_apx$(EXEEXT)
337	408	$(AM_V_CXXLD)$(CXXLINK) $(exp_apx_OBJECTS) $(exp_apx_LDADD) $(LIBS)

359	430	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@
360	431
361	432	.cpp.o:
362		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
363		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	433	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	434	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	435	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
364	436	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
365	437	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
366	438	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
367	439
368	440	.cpp.obj:
369		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
370		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	441	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	442	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	443	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
371	444	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
372	445	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
373	446	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
374	447
375		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
376		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
377		unique=`for i in $$list; do \
378		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
379		done \| \
380		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
381		END { if (nonempty) { for (i in files) print i; }; }'`; \
382		mkid -fID $$unique
383		tags: TAGS
384
385		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
386		$(TAGS_FILES) $(LISP)
	448	ID: $(am__tagged_files)
	449	$(am__define_uniq_tagged_files); mkid -fID $$unique
	450	tags: tags-am
	451	TAGS: tags
	452
	453	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
387	454	set x; \
388	455	here=`pwd`; \
389		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
390		unique=`for i in $$list; do \
391		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
392		done \| \
393		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
394		END { if (nonempty) { for (i in files) print i; }; }'`; \
	456	$(am__define_uniq_tagged_files); \
395	457	shift; \
396	458	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
397	459	test -n "$$unique" \|\| unique=$$empty_fix; \

403	465	$$unique; \
404	466	fi; \
405	467	fi
406		ctags: CTAGS
407		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
408		$(TAGS_FILES) $(LISP)
409		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
410		unique=`for i in $$list; do \
411		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
412		done \| \
413		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
414		END { if (nonempty) { for (i in files) print i; }; }'`; \
	468	ctags: ctags-am
	469
	470	CTAGS: ctags
	471	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	472	$(am__define_uniq_tagged_files); \
415	473	test -z "$(CTAGS_ARGS)$$unique" \
416	474	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
417	475	$$unique

420	478	here=`$(am__cd) $(top_builddir) && pwd` \
421	479	&& $(am__cd) $(top_srcdir) \
422	480	&& gtags -i $(GTAGS_ARGS) "$$here"
	481	cscopelist: cscopelist-am
	482
	483	cscopelist-am: $(am__tagged_files)
	484	list='$(am__tagged_files)'; \
	485	case "$(srcdir)" in \
	486	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	487	*) sdir=$(subdir)/$(srcdir) ;; \
	488	esac; \
	489	for i in $$list; do \
	490	if test -f "$$i"; then \
	491	echo "$(subdir)/$$i"; \
	492	else \
	493	echo "$$sdir/$$i"; \
	494	fi; \
	495	done >> $(top_builddir)/cscope.files
423	496
424	497	distclean-tags:
425	498	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

560	633
561	634	.MAKE: check-am install-am install-strip
562	635
563		.PHONY: CTAGS GTAGS all all-am check check-am clean \
564		clean-checkPROGRAMS clean-generic ctags distclean \
565		distclean-compile distclean-generic distclean-tags distdir dvi \
566		dvi-am html html-am info info-am install install-am \
567		install-data install-data-am install-dvi install-dvi-am \
568		install-exec install-exec-am install-html install-html-am \
569		install-info install-info-am install-man install-pdf \
570		install-pdf-am install-ps install-ps-am install-strip \
571		installcheck installcheck-am installdirs maintainer-clean \
572		maintainer-clean-generic mostlyclean mostlyclean-compile \
573		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
574		uninstall-am
	636	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	637	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	638	distclean distclean-compile distclean-generic distclean-tags \
	639	distdir dvi dvi-am html html-am info info-am install \
	640	install-am install-data install-data-am install-dvi \
	641	install-dvi-am install-exec install-exec-am install-html \
	642	install-html-am install-info install-info-am install-man \
	643	install-pdf install-pdf-am install-ps install-ps-am \
	644	install-strip installcheck installcheck-am installdirs \
	645	maintainer-clean maintainer-clean-generic mostlyclean \
	646	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	647	tags tags-am uninstall uninstall-am
575	648
576	649
577	650	test: check

-3

introduction/get_started/get_started.cpp less more

0		/* $Id: get_started.cpp 2683 2012-12-30 18:17:03Z bradbell $ */
	0	/* $Id: get_started.cpp 3114 2014-02-22 16:20:39Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

155	155	$$
156	156
157	157	$head Running$$
158		To build and run this program see $cref cppad_test$$.
	158	To build and run this program see $cref cmake_check$$.
159	159
160	160	$end
161	161	*/

+144

-73

introduction/get_started/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = get_started$(EXEEXT)
51	80	subdir = introduction/get_started
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

60	90	am_get_started_OBJECTS = get_started.$(OBJEXT)
61	91	get_started_OBJECTS = $(am_get_started_OBJECTS)
62	92	get_started_LDADD = $(LDADD)
	93	AM_V_P = $(am__v_P_@AM_V@)
	94	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	95	am__v_P_0 = false
	96	am__v_P_1 = :
	97	AM_V_GEN = $(am__v_GEN_@AM_V@)
	98	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	99	am__v_GEN_0 = @echo " GEN " $@;
	100	am__v_GEN_1 =
	101	AM_V_at = $(am__v_at_@AM_V@)
	102	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	103	am__v_at_0 = @
	104	am__v_at_1 =
63	105	DEFAULT_INCLUDES =
64	106	depcomp = $(SHELL) $(top_srcdir)/depcomp
65	107	am__depfiles_maybe = depfiles

68	110	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
69	111	AM_V_CXX = $(am__v_CXX_@AM_V@)
70	112	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
71		am__v_CXX_0 = @echo " CXX " $@;
72		AM_V_at = $(am__v_at_@AM_V@)
73		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
74		am__v_at_0 = @
	113	am__v_CXX_0 = @echo " CXX " $@;
	114	am__v_CXX_1 =
75	115	CXXLD = $(CXX)
76	116	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
77	117	-o $@
78	118	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
79	119	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
80		am__v_CXXLD_0 = @echo " CXXLD " $@;
81		AM_V_GEN = $(am__v_GEN_@AM_V@)
82		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
83		am__v_GEN_0 = @echo " GEN " $@;
	120	am__v_CXXLD_0 = @echo " CXXLD " $@;
	121	am__v_CXXLD_1 =
84	122	SOURCES = $(get_started_SOURCES)
85	123	DIST_SOURCES = $(get_started_SOURCES)
86	124	am__can_run_installinfo = \

88	126	n\|no\|NO) false;; \
89	127	*) (install-info --version) >/dev/null 2>&1;; \
90	128	esac
	129	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	130	# Read a list of newline-separated strings from the standard input,
	131	# and print each of them once, without duplicates. Input order is
	132	# not preserved.
	133	am__uniquify_input = $(AWK) '\
	134	BEGIN { nonempty = 0; } \
	135	{ items[$$0] = 1; nonempty = 1; } \
	136	END { if (nonempty) { for (i in items) print i; }; } \
	137	'
	138	# Make sure the list of sources is unique. This is necessary because,
	139	# e.g., the same source file might be shared among _SOURCES variables
	140	# for different programs/libraries.
	141	am__define_uniq_tagged_files = \
	142	list='$(am__tagged_files)'; \
	143	unique=`for i in $$list; do \
	144	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	145	done \| $(am__uniquify_input)`
91	146	ETAGS = etags
92	147	CTAGS = ctags
93	148	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

97	152	ADOLC_DIR = @ADOLC_DIR@
98	153	AMTAR = @AMTAR@
99	154	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	155	AR = @AR@
100	156	AUTOCONF = @AUTOCONF@
101	157	AUTOHEADER = @AUTOHEADER@
102	158	AUTOMAKE = @AUTOMAKE@

119	175	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
120	176	CYGPATH_W = @CYGPATH_W@
121	177
122		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	178	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
123	179	# -----------------------------------------------------------------------------
124	180	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
125	181	#

187	243	abs_srcdir = @abs_srcdir@
188	244	abs_top_builddir = @abs_top_builddir@
189	245	abs_top_srcdir = @abs_top_srcdir@
	246	ac_ct_AR = @ac_ct_AR@
190	247	ac_ct_CC = @ac_ct_CC@
191	248	ac_ct_CXX = @ac_ct_CXX@
192	249	ac_ct_FC = @ac_ct_FC@

197	254	am__tar = @am__tar@
198	255	am__untar = @am__untar@
199	256	bindir = @bindir@
	257	build = @build@
200	258	build_alias = @build_alias@
	259	build_cpu = @build_cpu@
	260	build_os = @build_os@
	261	build_vendor = @build_vendor@
201	262	builddir = @builddir@
202	263	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
203	264	cppad_boostvector = @cppad_boostvector@
204	265	cppad_cflags = @cppad_cflags@
	266	cppad_compiler_has_erf = @cppad_compiler_has_erf@
205	267	cppad_cppadvector = @cppad_cppadvector@
206	268	cppad_description = @cppad_description@
207	269	cppad_eigenvector = @cppad_eigenvector@
	270	cppad_has_colpack = @cppad_has_colpack@
	271	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
208	272	cppad_has_gettimeofday = @cppad_has_gettimeofday@
209	273	cppad_has_nullptr = @cppad_has_nullptr@
	274	cppad_has_rvalue = @cppad_has_rvalue@
210	275	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
211	276	cppad_internal_sparse_set = @cppad_internal_sparse_set@
212	277	cppad_libs = @cppad_libs@
213	278	cppad_max_num_threads = @cppad_max_num_threads@
214	279	cppad_requires = @cppad_requires@
215		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	280	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
216	281	cppad_stdvector = @cppad_stdvector@
217	282	cppad_tape_addr_type = @cppad_tape_addr_type@
218	283	cppad_tape_id_type = @cppad_tape_id_type@

224	289	dvidir = @dvidir@
225	290	eigen_prefix = @eigen_prefix@
226	291	exec_prefix = @exec_prefix@
227		have_ar = @have_ar@
228	292	have_pkg_config = @have_pkg_config@
	293	host = @host@
229	294	host_alias = @host_alias@
	295	host_cpu = @host_cpu@
	296	host_os = @host_os@
	297	host_vendor = @host_vendor@
230	298	htmldir = @htmldir@
231	299	includedir = @includedir@
232	300	infodir = @infodir@

293	361
294	362	clean-checkPROGRAMS:
295	363	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	364
296	365	get_started$(EXEEXT): $(get_started_OBJECTS) $(get_started_DEPENDENCIES) $(EXTRA_get_started_DEPENDENCIES)
297	366	@rm -f get_started$(EXEEXT)
298	367	$(AM_V_CXXLD)$(CXXLINK) $(get_started_OBJECTS) $(get_started_LDADD) $(LIBS)

306	375	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get_started.Po@am__quote@
307	376
308	377	.cpp.o:
309		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
310		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	378	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	379	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	380	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
311	381	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
312	382	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
313	383	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
314	384
315	385	.cpp.obj:
316		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
317		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	386	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	387	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	388	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
318	389	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
319	390	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
320	391	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
321	392
322		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
323		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
324		unique=`for i in $$list; do \
325		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
326		done \| \
327		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
328		END { if (nonempty) { for (i in files) print i; }; }'`; \
329		mkid -fID $$unique
330		tags: TAGS
331
332		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
333		$(TAGS_FILES) $(LISP)
	393	ID: $(am__tagged_files)
	394	$(am__define_uniq_tagged_files); mkid -fID $$unique
	395	tags: tags-am
	396	TAGS: tags
	397
	398	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
334	399	set x; \
335	400	here=`pwd`; \
336		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
337		unique=`for i in $$list; do \
338		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
339		done \| \
340		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
341		END { if (nonempty) { for (i in files) print i; }; }'`; \
	401	$(am__define_uniq_tagged_files); \
342	402	shift; \
343	403	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
344	404	test -n "$$unique" \|\| unique=$$empty_fix; \

350	410	$$unique; \
351	411	fi; \
352	412	fi
353		ctags: CTAGS
354		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
355		$(TAGS_FILES) $(LISP)
356		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
357		unique=`for i in $$list; do \
358		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
359		done \| \
360		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
361		END { if (nonempty) { for (i in files) print i; }; }'`; \
	413	ctags: ctags-am
	414
	415	CTAGS: ctags
	416	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	417	$(am__define_uniq_tagged_files); \
362	418	test -z "$(CTAGS_ARGS)$$unique" \
363	419	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
364	420	$$unique

367	423	here=`$(am__cd) $(top_builddir) && pwd` \
368	424	&& $(am__cd) $(top_srcdir) \
369	425	&& gtags -i $(GTAGS_ARGS) "$$here"
	426	cscopelist: cscopelist-am
	427
	428	cscopelist-am: $(am__tagged_files)
	429	list='$(am__tagged_files)'; \
	430	case "$(srcdir)" in \
	431	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	432	*) sdir=$(subdir)/$(srcdir) ;; \
	433	esac; \
	434	for i in $$list; do \
	435	if test -f "$$i"; then \
	436	echo "$(subdir)/$$i"; \
	437	else \
	438	echo "$$sdir/$$i"; \
	439	fi; \
	440	done >> $(top_builddir)/cscope.files
370	441
371	442	distclean-tags:
372	443	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

507	578
508	579	.MAKE: check-am install-am install-strip
509	580
510		.PHONY: CTAGS GTAGS all all-am check check-am clean \
511		clean-checkPROGRAMS clean-generic ctags distclean \
512		distclean-compile distclean-generic distclean-tags distdir dvi \
513		dvi-am html html-am info info-am install install-am \
514		install-data install-data-am install-dvi install-dvi-am \
515		install-exec install-exec-am install-html install-html-am \
516		install-info install-info-am install-man install-pdf \
517		install-pdf-am install-ps install-ps-am install-strip \
518		installcheck installcheck-am installdirs maintainer-clean \
519		maintainer-clean-generic mostlyclean mostlyclean-compile \
520		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
521		uninstall-am
	581	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	582	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	583	distclean distclean-compile distclean-generic distclean-tags \
	584	distdir dvi dvi-am html html-am info info-am install \
	585	install-am install-data install-data-am install-dvi \
	586	install-dvi-am install-exec install-exec-am install-html \
	587	install-html-am install-info install-info-am install-man \
	588	install-pdf install-pdf-am install-ps install-ps-am \
	589	install-strip installcheck installcheck-am installdirs \
	590	maintainer-clean maintainer-clean-generic mostlyclean \
	591	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	592	tags tags-am uninstall uninstall-am
522	593
523	594	#
524	595	test: check

-4

makefile.am less more

0		# $Id: makefile.am 2991 2013-10-22 16:25:15Z bradbell $
	0	# $Id: makefile.am 3495 2014-12-24 01:16:15Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

148	148	cppad/local/bender_quad.hpp \
149	149	cppad/local/bool_fun.hpp \
150	150	cppad/local/bool_valued.hpp \
151		cppad/local/cap_taylor.hpp \
	151	cppad/local/capacity_order.hpp \
152	152	cppad/local/checkpoint.hpp \
153	153	cppad/local/compare.hpp \
154	154	cppad/local/comp_op.hpp \

159	159	cppad/local/cosh_op.hpp \
160	160	cppad/local/cos_op.hpp \
161	161	cppad/local/cppad_assert.hpp \
	162	cppad/local/cppad_colpack.hpp \
162	163	cppad/local/cskip_op.hpp \
163	164	cppad/local/csum_op.hpp \
164	165	cppad/local/declare_ad.hpp \

173	174	cppad/local/epsilon.hpp \
174	175	cppad/local/equal_op_seq.hpp \
175	176	cppad/local/erf.hpp \
	177	cppad/local/erf_op.hpp \
176	178	cppad/local/exp_op.hpp \
177	179	cppad/local/for_jac_sweep.hpp \
178	180	cppad/local/for_one.hpp \
179	181	cppad/local/for_sparse_jac.hpp \
180	182	cppad/local/for_two.hpp \
181	183	cppad/local/forward0sweep.hpp \
	184	cppad/local/forward1sweep.hpp \
	185	cppad/local/forward2sweep.hpp \
182	186	cppad/local/forward.hpp \
183		cppad/local/forward_sweep.hpp \
184	187	cppad/local/fun_check.hpp \
185	188	cppad/local/fun_construct.hpp \
186	189	cppad/local/fun_eval.hpp \

232	235	cppad/local/sparse_binary_op.hpp \
233	236	cppad/local/sparse_hessian.hpp \
234	237	cppad/local/sparse.hpp \
	238	cppad/local/color_general.hpp \
235	239	cppad/local/sparse_jacobian.hpp \
236	240	cppad/local/sparse_list.hpp \
237	241	cppad/local/sparse_pack.hpp \

331	335	cppad_ipopt/test/CMakeLists.txt \
332	336	cppad_ipopt/CMakeLists.txt \
333	337	cppad_ipopt/speed/CMakeLists.txt \
	338	speed/main.cpp \
334	339	speed/cppad/CMakeLists.txt \
335	340	speed/adolc/CMakeLists.txt \
336	341	speed/fadbad/CMakeLists.txt \

+194

-151

makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

16	15
17	16
18	17	VPATH = @srcdir@
19		am__make_dryrun = \
20		{ \
21		am__dry=no; \
	18	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	19	am__make_running_with_option = \
	20	case $${target_option-} in \
	21	?) ;; \
	22	*) echo "am__make_running_with_option: internal error: invalid" \
	23	"target option '$${target_option-}' specified" >&2; \
	24	exit 1;; \
	25	esac; \
	26	has_opt=no; \
	27	sane_makeflags=$$MAKEFLAGS; \
	28	if $(am__is_gnu_make); then \
	29	sane_makeflags=$$MFLAGS; \
	30	else \
22	31	case $$MAKEFLAGS in \
23	32	\\[\ \ ]) \
24		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
25		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
26		*) \
27		for am__flg in $$MAKEFLAGS; do \
28		case $$am__flg in \
29		=\|--*) ;; \
30		n) am__dry=yes; break;; \
31		esac; \
32		done;; \
	33	bs=\\; \
	34	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	35	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
33	36	esac; \
34		test $$am__dry = yes; \
35		}
	37	fi; \
	38	skip_next=no; \
	39	strip_trailopt () \
	40	{ \
	41	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	42	}; \
	43	for flg in $$sane_makeflags; do \
	44	test $$skip_next = yes && { skip_next=no; continue; }; \
	45	case $$flg in \
	46	=\|--*) continue;; \
	47	-*I) strip_trailopt 'I'; skip_next=yes;; \
	48	-I?) strip_trailopt 'I';; \
	49	-*O) strip_trailopt 'O'; skip_next=yes;; \
	50	-O?) strip_trailopt 'O';; \
	51	-*l) strip_trailopt 'l'; skip_next=yes;; \
	52	-l?) strip_trailopt 'l';; \
	53	-[dEDm]) skip_next=yes;; \
	54	-[JT]) skip_next=yes;; \
	55	esac; \
	56	case $$flg in \
	57	$$target_option) has_opt=yes; break;; \
	58	esac; \
	59	done; \
	60	test $$has_opt = yes
	61	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	62	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
36	63	pkgdatadir = $(datadir)/@PACKAGE@
37	64	pkgincludedir = $(includedir)/@PACKAGE@
38	65	pkglibdir = $(libdir)/@PACKAGE@

49	76	NORMAL_UNINSTALL = :
50	77	PRE_UNINSTALL = :
51	78	POST_UNINSTALL = :
	79	build_triplet = @build@
	80	host_triplet = @host@
52	81	subdir = .
53		DIST_COMMON = README $(am__configure_deps) \
	82	DIST_COMMON = INSTALL NEWS README AUTHORS ChangeLog \
	83	$(srcdir)/makefile.in $(srcdir)/makefile.am \
	84	$(top_srcdir)/configure $(am__configure_deps) \
	85	$(top_srcdir)/cppad/configure.hpp.in \
	86	$(top_srcdir)/pkgconfig/cppad.pc.in \
	87	$(top_srcdir)/pkgconfig/cppad-uninstalled.pc.in \
54	88	$(am__myinclude_HEADERS_DIST) $(nobase_myinclude_HEADERS) \
55		$(srcdir)/makefile.am $(srcdir)/makefile.in \
56		$(top_srcdir)/configure $(top_srcdir)/cppad/configure.hpp.in \
57		$(top_srcdir)/pkgconfig/cppad-uninstalled.pc.in \
58		$(top_srcdir)/pkgconfig/cppad.pc.in AUTHORS COPYING ChangeLog \
59		INSTALL NEWS depcomp install-sh missing
	89	COPYING ar-lib config.guess config.sub depcomp install-sh \
	90	missing
60	91	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
61	92	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
62	93	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

67	98	CONFIG_CLEAN_FILES = cppad/configure.hpp pkgconfig/cppad.pc \
68	99	pkgconfig/cppad-uninstalled.pc
69	100	CONFIG_CLEAN_VPATH_FILES =
	101	AM_V_P = $(am__v_P_@AM_V@)
	102	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	103	am__v_P_0 = false
	104	am__v_P_1 = :
70	105	AM_V_GEN = $(am__v_GEN_@AM_V@)
71	106	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
72		am__v_GEN_0 = @echo " GEN " $@;
	107	am__v_GEN_0 = @echo " GEN " $@;
	108	am__v_GEN_1 =
73	109	AM_V_at = $(am__v_at_@AM_V@)
74	110	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
75	111	am__v_at_0 = @
	112	am__v_at_1 =
76	113	SOURCES =
77	114	DIST_SOURCES =
78		RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
79		html-recursive info-recursive install-data-recursive \
80		install-dvi-recursive install-exec-recursive \
81		install-html-recursive install-info-recursive \
82		install-pdf-recursive install-ps-recursive install-recursive \
83		installcheck-recursive installdirs-recursive pdf-recursive \
84		ps-recursive uninstall-recursive
	115	RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
	116	ctags-recursive dvi-recursive html-recursive info-recursive \
	117	install-data-recursive install-dvi-recursive \
	118	install-exec-recursive install-html-recursive \
	119	install-info-recursive install-pdf-recursive \
	120	install-ps-recursive install-recursive installcheck-recursive \
	121	installdirs-recursive pdf-recursive ps-recursive \
	122	tags-recursive uninstall-recursive
85	123	am__can_run_installinfo = \
86	124	case $$AM_UPDATE_INFO_DIR in \
87	125	n\|no\|NO) false;; \

121	159	HEADERS = $(myinclude_HEADERS) $(nobase_myinclude_HEADERS)
122	160	RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
123	161	distclean-recursive maintainer-clean-recursive
124		AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \
125		$(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \
126		distdir dist dist-all distcheck
	162	am__recursive_targets = \
	163	$(RECURSIVE_TARGETS) \
	164	$(RECURSIVE_CLEAN_TARGETS) \
	165	$(am__extra_recursive_targets)
	166	AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
	167	cscope distdir dist dist-all distcheck
	168	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	169	# Read a list of newline-separated strings from the standard input,
	170	# and print each of them once, without duplicates. Input order is
	171	# not preserved.
	172	am__uniquify_input = $(AWK) '\
	173	BEGIN { nonempty = 0; } \
	174	{ items[$$0] = 1; nonempty = 1; } \
	175	END { if (nonempty) { for (i in items) print i; }; } \
	176	'
	177	# Make sure the list of sources is unique. This is necessary because,
	178	# e.g., the same source file might be shared among _SOURCES variables
	179	# for different programs/libraries.
	180	am__define_uniq_tagged_files = \
	181	list='$(am__tagged_files)'; \
	182	unique=`for i in $$list; do \
	183	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	184	done \| $(am__uniquify_input)`
127	185	ETAGS = etags
128	186	CTAGS = ctags
	187	CSCOPE = cscope
129	188	DIST_SUBDIRS = cppad_ipopt/src example/ipopt_solve cppad_ipopt/example \
130	189	cppad_ipopt/speed cppad_ipopt/test speed/src speed/adolc \
131	190	speed/cppad speed/double speed/example speed/fadbad \

141	200	&& rm -rf "$(distdir)" \
142	201	\|\| { sleep 5 && rm -rf "$(distdir)"; }; \
143	202	else :; fi
	203	am__post_remove_distdir = $(am__remove_distdir)
144	204	am__relativize = \
145	205	dir0=`pwd`; \
146	206	sed_first='s,^$[^/]$/.$$,\1,'; \

168	228	reldir="$$dir2"
169	229	DIST_ARCHIVES = $(distdir).tar.gz
170	230	GZIP_ENV = --best
	231	DIST_TARGETS = dist-gzip
171	232	distuninstallcheck_listfiles = find . -type f -print
172	233	am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
173	234	\| sed 's\|^\./\|$(prefix)/\|' \| grep -v '$(infodir)/dir$$'

178	239	ADOLC_DIR = @ADOLC_DIR@
179	240	AMTAR = @AMTAR@
180	241	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	242	AR = @AR@
181	243	AUTOCONF = @AUTOCONF@
182	244	AUTOHEADER = @AUTOHEADER@
183	245	AUTOMAKE = @AUTOMAKE@

252	314	abs_srcdir = @abs_srcdir@
253	315	abs_top_builddir = @abs_top_builddir@
254	316	abs_top_srcdir = @abs_top_srcdir@
	317	ac_ct_AR = @ac_ct_AR@
255	318	ac_ct_CC = @ac_ct_CC@
256	319	ac_ct_CXX = @ac_ct_CXX@
257	320	ac_ct_FC = @ac_ct_FC@

262	325	am__tar = @am__tar@
263	326	am__untar = @am__untar@
264	327	bindir = @bindir@
	328	build = @build@
265	329	build_alias = @build_alias@
	330	build_cpu = @build_cpu@
	331	build_os = @build_os@
	332	build_vendor = @build_vendor@
266	333	builddir = @builddir@
267	334	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
268	335	cppad_boostvector = @cppad_boostvector@
269	336	cppad_cflags = @cppad_cflags@
	337	cppad_compiler_has_erf = @cppad_compiler_has_erf@
270	338	cppad_cppadvector = @cppad_cppadvector@
271	339	cppad_description = @cppad_description@
272	340	cppad_eigenvector = @cppad_eigenvector@
	341	cppad_has_colpack = @cppad_has_colpack@
	342	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
273	343	cppad_has_gettimeofday = @cppad_has_gettimeofday@
274	344	cppad_has_nullptr = @cppad_has_nullptr@
	345	cppad_has_rvalue = @cppad_has_rvalue@
275	346	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
276	347	cppad_internal_sparse_set = @cppad_internal_sparse_set@
277	348	cppad_libs = @cppad_libs@
278	349	cppad_max_num_threads = @cppad_max_num_threads@
279	350	cppad_requires = @cppad_requires@
280		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	351	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
281	352	cppad_stdvector = @cppad_stdvector@
282	353	cppad_tape_addr_type = @cppad_tape_addr_type@
283	354	cppad_tape_id_type = @cppad_tape_id_type@

289	360	dvidir = @dvidir@
290	361	eigen_prefix = @eigen_prefix@
291	362	exec_prefix = @exec_prefix@
292		have_ar = @have_ar@
293	363	have_pkg_config = @have_pkg_config@
	364	host = @host@
294	365	host_alias = @host_alias@
	366	host_cpu = @host_cpu@
	367	host_os = @host_os@
	368	host_vendor = @host_vendor@
295	369	htmldir = @htmldir@
296	370	includedir = @includedir@
297	371	infodir = @infodir@

317	391	top_builddir = @top_builddir@
318	392	top_srcdir = @top_srcdir@
319	393
320		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	394	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
321	395	# -----------------------------------------------------------------------------
322		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	396	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
323	397	#
324	398	# CppAD is distributed under multiple licenses. This distribution is under
325	399	# the terms of the

453	527	cppad/local/bender_quad.hpp \
454	528	cppad/local/bool_fun.hpp \
455	529	cppad/local/bool_valued.hpp \
456		cppad/local/cap_taylor.hpp \
	530	cppad/local/capacity_order.hpp \
457	531	cppad/local/checkpoint.hpp \
458	532	cppad/local/compare.hpp \
459	533	cppad/local/comp_op.hpp \

464	538	cppad/local/cosh_op.hpp \
465	539	cppad/local/cos_op.hpp \
466	540	cppad/local/cppad_assert.hpp \
	541	cppad/local/cppad_colpack.hpp \
467	542	cppad/local/cskip_op.hpp \
468	543	cppad/local/csum_op.hpp \
469	544	cppad/local/declare_ad.hpp \

478	553	cppad/local/epsilon.hpp \
479	554	cppad/local/equal_op_seq.hpp \
480	555	cppad/local/erf.hpp \
	556	cppad/local/erf_op.hpp \
481	557	cppad/local/exp_op.hpp \
482	558	cppad/local/for_jac_sweep.hpp \
483	559	cppad/local/for_one.hpp \
484	560	cppad/local/for_sparse_jac.hpp \
485	561	cppad/local/for_two.hpp \
486	562	cppad/local/forward0sweep.hpp \
	563	cppad/local/forward1sweep.hpp \
	564	cppad/local/forward2sweep.hpp \
487	565	cppad/local/forward.hpp \
488		cppad/local/forward_sweep.hpp \
489	566	cppad/local/fun_check.hpp \
490	567	cppad/local/fun_construct.hpp \
491	568	cppad/local/fun_eval.hpp \

537	614	cppad/local/sparse_binary_op.hpp \
538	615	cppad/local/sparse_hessian.hpp \
539	616	cppad/local/sparse.hpp \
	617	cppad/local/color_general.hpp \
540	618	cppad/local/sparse_jacobian.hpp \
541	619	cppad/local/sparse_list.hpp \
542	620	cppad/local/sparse_pack.hpp \

638	716	cppad_ipopt/test/CMakeLists.txt \
639	717	cppad_ipopt/CMakeLists.txt \
640	718	cppad_ipopt/speed/CMakeLists.txt \
	719	speed/main.cpp \
641	720	speed/cppad/CMakeLists.txt \
642	721	speed/adolc/CMakeLists.txt \
643	722	speed/fadbad/CMakeLists.txt \

784	863	dir='$(DESTDIR)$(myincludedir)'; $(am__uninstall_files_from_dir)
785	864
786	865	# This directory's subdirectories are mostly independent; you can cd
787		# into them and run `make' without going through this Makefile.
788		# To change the values of `make' variables: instead of editing Makefiles,
789		# (1) if the variable is set in `config.status', edit `config.status'
790		# (which will cause the Makefiles to be regenerated when you run `make');
791		# (2) otherwise, pass the desired values on the `make' command line.
792		$(RECURSIVE_TARGETS):
793		@fail= failcom='exit 1'; \
794		for f in x $$MAKEFLAGS; do \
795		case $$f in \
796		= \| --[!k]*);; \
797		k) failcom='fail=yes';; \
798		esac; \
799		done; \
	866	# into them and run 'make' without going through this Makefile.
	867	# To change the values of 'make' variables: instead of editing Makefiles,
	868	# (1) if the variable is set in 'config.status', edit 'config.status'
	869	# (which will cause the Makefiles to be regenerated when you run 'make');
	870	# (2) otherwise, pass the desired values on the 'make' command line.
	871	$(am__recursive_targets):
	872	@fail=; \
	873	if $(am__make_keepgoing); then \
	874	failcom='fail=yes'; \
	875	else \
	876	failcom='exit 1'; \
	877	fi; \
800	878	dot_seen=no; \
801	879	target=`echo $@ \| sed s/-recursive//`; \
802		list='$(SUBDIRS)'; for subdir in $$list; do \
	880	case "$@" in \
	881	distclean-* \| maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
	882	*) list='$(SUBDIRS)' ;; \
	883	esac; \
	884	for subdir in $$list; do \
803	885	echo "Making $$target in $$subdir"; \
804	886	if test "$$subdir" = "."; then \
805	887	dot_seen=yes; \

814	896	$(MAKE) $(AM_MAKEFLAGS) "$$target-am" \|\| exit 1; \
815	897	fi; test -z "$$fail"
816	898
817		$(RECURSIVE_CLEAN_TARGETS):
818		@fail= failcom='exit 1'; \
819		for f in x $$MAKEFLAGS; do \
820		case $$f in \
821		= \| --[!k]*);; \
822		k) failcom='fail=yes';; \
823		esac; \
824		done; \
825		dot_seen=no; \
826		case "$@" in \
827		distclean-* \| maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
828		*) list='$(SUBDIRS)' ;; \
829		esac; \
830		rev=''; for subdir in $$list; do \
831		if test "$$subdir" = "."; then :; else \
832		rev="$$subdir $$rev"; \
833		fi; \
834		done; \
835		rev="$$rev ."; \
836		target=`echo $@ \| sed s/-recursive//`; \
837		for subdir in $$rev; do \
838		echo "Making $$target in $$subdir"; \
839		if test "$$subdir" = "."; then \
840		local_target="$$target-am"; \
841		else \
842		local_target="$$target"; \
843		fi; \
844		($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
845		\|\| eval $$failcom; \
846		done && test -z "$$fail"
847		tags-recursive:
848		list='$(SUBDIRS)'; for subdir in $$list; do \
849		test "$$subdir" = . \|\| ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
850		done
851		ctags-recursive:
852		list='$(SUBDIRS)'; for subdir in $$list; do \
853		test "$$subdir" = . \|\| ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
854		done
855
856		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
857		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
858		unique=`for i in $$list; do \
859		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
860		done \| \
861		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
862		END { if (nonempty) { for (i in files) print i; }; }'`; \
863		mkid -fID $$unique
864		tags: TAGS
865
866		TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
867		$(TAGS_FILES) $(LISP)
	899	ID: $(am__tagged_files)
	900	$(am__define_uniq_tagged_files); mkid -fID $$unique
	901	tags: tags-recursive
	902	TAGS: tags
	903
	904	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
868	905	set x; \
869	906	here=`pwd`; \
870	907	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \

880	917	set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
881	918	fi; \
882	919	done; \
883		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
884		unique=`for i in $$list; do \
885		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
886		done \| \
887		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
888		END { if (nonempty) { for (i in files) print i; }; }'`; \
	920	$(am__define_uniq_tagged_files); \
889	921	shift; \
890	922	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
891	923	test -n "$$unique" \|\| unique=$$empty_fix; \

897	929	$$unique; \
898	930	fi; \
899	931	fi
900		ctags: CTAGS
901		CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
902		$(TAGS_FILES) $(LISP)
903		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
904		unique=`for i in $$list; do \
905		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
906		done \| \
907		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
908		END { if (nonempty) { for (i in files) print i; }; }'`; \
	932	ctags: ctags-recursive
	933
	934	CTAGS: ctags
	935	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	936	$(am__define_uniq_tagged_files); \
909	937	test -z "$(CTAGS_ARGS)$$unique" \
910	938	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
911	939	$$unique

914	942	here=`$(am__cd) $(top_builddir) && pwd` \
915	943	&& $(am__cd) $(top_srcdir) \
916	944	&& gtags -i $(GTAGS_ARGS) "$$here"
	945	cscope: cscope.files
	946	test ! -s cscope.files \
	947	\|\| $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
	948	clean-cscope:
	949	-rm -f cscope.files
	950	cscope.files: clean-cscope cscopelist
	951	cscopelist: cscopelist-recursive
	952
	953	cscopelist-am: $(am__tagged_files)
	954	list='$(am__tagged_files)'; \
	955	case "$(srcdir)" in \
	956	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	957	*) sdir=$(subdir)/$(srcdir) ;; \
	958	esac; \
	959	for i in $$list; do \
	960	if test -f "$$i"; then \
	961	echo "$(subdir)/$$i"; \
	962	else \
	963	echo "$$sdir/$$i"; \
	964	fi; \
	965	done >> $(top_builddir)/cscope.files
917	966
918	967	distclean-tags:
919	968	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
	969	-rm -f cscope.out cscope.in.out cscope.po.out cscope.files
920	970
921	971	distdir: $(DISTFILES)
922	972	$(am__remove_distdir)

987	1037	\|\| chmod -R a+r "$(distdir)"
988	1038	dist-gzip: distdir
989	1039	tardir=$(distdir) && $(am__tar) \| GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
990		$(am__remove_distdir)
	1040	$(am__post_remove_distdir)
991	1041
992	1042	dist-bzip2: distdir
993	1043	tardir=$(distdir) && $(am__tar) \| BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
994		$(am__remove_distdir)
	1044	$(am__post_remove_distdir)
995	1045
996	1046	dist-lzip: distdir
997	1047	tardir=$(distdir) && $(am__tar) \| lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
998		$(am__remove_distdir)
999
1000		dist-lzma: distdir
1001		tardir=$(distdir) && $(am__tar) \| lzma -9 -c >$(distdir).tar.lzma
1002		$(am__remove_distdir)
	1048	$(am__post_remove_distdir)
1003	1049
1004	1050	dist-xz: distdir
1005	1051	tardir=$(distdir) && $(am__tar) \| XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
1006		$(am__remove_distdir)
	1052	$(am__post_remove_distdir)
1007	1053
1008	1054	dist-tarZ: distdir
1009	1055	tardir=$(distdir) && $(am__tar) \| compress -c >$(distdir).tar.Z
1010		$(am__remove_distdir)
	1056	$(am__post_remove_distdir)
1011	1057
1012	1058	dist-shar: distdir
1013	1059	shar $(distdir) \| GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
1014		$(am__remove_distdir)
	1060	$(am__post_remove_distdir)
1015	1061
1016	1062	dist-zip: distdir
1017	1063	-rm -f $(distdir).zip
1018	1064	zip -rq $(distdir).zip $(distdir)
1019		$(am__remove_distdir)
1020
1021		dist dist-all: distdir
1022		tardir=$(distdir) && $(am__tar) \| GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
1023		$(am__remove_distdir)
	1065	$(am__post_remove_distdir)
	1066
	1067	dist dist-all:
	1068	$(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
	1069	$(am__post_remove_distdir)
1024	1070
1025	1071	# This target untars the dist file and tries a VPATH configuration. Then
1026	1072	# it guarantees that the distribution is self-contained by making another

1031	1077	GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz \| $(am__untar) ;;\
1032	1078	.tar.bz2) \
1033	1079	bzip2 -dc $(distdir).tar.bz2 \| $(am__untar) ;;\
1034		.tar.lzma) \
1035		lzma -dc $(distdir).tar.lzma \| $(am__untar) ;;\
1036	1080	.tar.lz) \
1037	1081	lzip -dc $(distdir).tar.lz \| $(am__untar) ;;\
1038	1082	.tar.xz) \

1044	1088	.zip) \
1045	1089	unzip $(distdir).zip ;;\
1046	1090	esac
1047		chmod -R a-w $(distdir); chmod u+w $(distdir)
1048		mkdir $(distdir)/_build
1049		mkdir $(distdir)/_inst
	1091	chmod -R a-w $(distdir)
	1092	chmod u+w $(distdir)
	1093	mkdir $(distdir)/_build $(distdir)/_inst
1050	1094	chmod a-w $(distdir)
1051	1095	test -d $(distdir)/_build \|\| exit 0; \
1052	1096	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd \| sed -e 's,^[^:\\/]:[\\/],/,'` \

1078	1122	&& $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
1079	1123	&& cd "$$am__cwd" \
1080	1124	\|\| exit 1
1081		$(am__remove_distdir)
	1125	$(am__post_remove_distdir)
1082	1126	@(echo "$(distdir) archives ready for distribution: "; \
1083	1127	list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) \| \
1084	1128	sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'

1222	1266	uninstall-am: uninstall-myincludeHEADERS \
1223	1267	uninstall-nobase_myincludeHEADERS uninstall-pkgconfigDATA
1224	1268
1225		.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) all check \
1226		ctags-recursive install install-am install-data-am \
1227		install-strip tags-recursive
1228
1229		.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \
1230		all all-am am--refresh check check-am clean clean-generic \
1231		ctags ctags-recursive dist dist-all dist-bzip2 dist-gzip \
1232		dist-hook dist-lzip dist-lzma dist-shar dist-tarZ dist-xz \
	1269	.MAKE: $(am__recursive_targets) all check install install-am \
	1270	install-data-am install-strip
	1271
	1272	.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
	1273	am--refresh check check-am clean clean-cscope clean-generic \
	1274	cscope cscopelist-am ctags ctags-am dist dist-all dist-bzip2 \
	1275	dist-gzip dist-hook dist-lzip dist-shar dist-tarZ dist-xz \
1233	1276	dist-zip distcheck distclean distclean-generic distclean-tags \
1234	1277	distcleancheck distdir distuninstallcheck dvi dvi-am html \
1235	1278	html-am info info-am install install-am install-data \

1241	1284	install-ps-am install-strip installcheck installcheck-am \
1242	1285	installdirs installdirs-am maintainer-clean \
1243	1286	maintainer-clean-generic mostlyclean mostlyclean-generic pdf \
1244		pdf-am ps ps-am tags tags-recursive uninstall uninstall-am \
	1287	pdf-am ps ps-am tags tags-am uninstall uninstall-am \
1245	1288	uninstall-myincludeHEADERS uninstall-nobase_myincludeHEADERS \
1246	1289	uninstall-pkgconfigDATA
1247	1290

+155

-271

missing less more

0	0	#! /bin/sh
1		# Common stub for a few missing GNU programs while installing.
2
3		scriptversion=2012-01-06.13; # UTC
4
5		# Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006,
6		# 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
7		# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
	1	# Common wrapper for a few potentially missing GNU programs.
	2
	3	scriptversion=2012-06-26.16; # UTC
	4
	5	# Copyright (C) 1996-2013 Free Software Foundation, Inc.
	6	# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
8	7
9	8	# This program is free software; you can redistribute it and/or modify
10	9	# it under the terms of the GNU General Public License as published by

25	24	# the same distribution terms that you use for the rest of that program.
26	25
27	26	if test $# -eq 0; then
28		echo 1>&2 "Try \`$0 --help' for more information"
	27	echo 1>&2 "Try '$0 --help' for more information"
29	28	exit 1
30	29	fi
31	30
32		run=:
33		sed_output='s/.* --output[ =]$[^ ]$./\1/p'
34		sed_minuso='s/.* -o $[^ ]$./\1/p'
35
36		# In the cases where this matters, `missing' is being run in the
37		# srcdir already.
38		if test -f configure.ac; then
39		configure_ac=configure.ac
40		else
41		configure_ac=configure.in
42		fi
43
44		msg="missing on your system"
45
46	31	case $1 in
47		--run)
48		# Try to run requested program, and just exit if it succeeds.
49		run=
50		shift
51		"$@" && exit 0
52		# Exit code 63 means version mismatch. This often happens
53		# when the user try to use an ancient version of a tool on
54		# a file that requires a minimum version. In this case we
55		# we should proceed has if the program had been absent, or
56		# if --run hadn't been passed.
57		if test $? = 63; then
58		run=:
59		msg="probably too old"
60		fi
61		;;
	32
	33	--is-lightweight)
	34	# Used by our autoconf macros to check whether the available missing
	35	# script is modern enough.
	36	exit 0
	37	;;
	38
	39	--run)
	40	# Back-compat with the calling convention used by older automake.
	41	shift
	42	;;
62	43
63	44	-h\|--h\|--he\|--hel\|--help)
64	45	echo "\
65	46	$0 [OPTION]... PROGRAM [ARGUMENT]...
66	47
67		Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
68		error status if there is no known handling for PROGRAM.
	48	Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
	49	to PROGRAM being missing or too old.
69	50
70	51	Options:
71	52	-h, --help display this help and exit
72	53	-v, --version output version information and exit
73		--run try to run the given command, and emulate it if it fails
74	54
75	55	Supported PROGRAM values:
76		aclocal touch file \`aclocal.m4'
77		autoconf touch file \`configure'
78		autoheader touch file \`config.h.in'
79		autom4te touch the output file, or create a stub one
80		automake touch all \`Makefile.in' files
81		bison create \`y.tab.[ch]', if possible, from existing .[ch]
82		flex create \`lex.yy.c', if possible, from existing .c
83		help2man touch the output file
84		lex create \`lex.yy.c', if possible, from existing .c
85		makeinfo touch the output file
86		yacc create \`y.tab.[ch]', if possible, from existing .[ch]
87
88		Version suffixes to PROGRAM as well as the prefixes \`gnu-', \`gnu', and
89		\`g' are ignored when checking the name.
	56	aclocal autoconf autoheader autom4te automake makeinfo
	57	bison yacc flex lex help2man
	58
	59	Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
	60	'g' are ignored when checking the name.
90	61
91	62	Send bug reports to <bug-automake@gnu.org>."
92	63	exit $?

98	69	;;
99	70
100	71	-*)
101		echo 1>&2 "$0: Unknown \`$1' option"
102		echo 1>&2 "Try \`$0 --help' for more information"
	72	echo 1>&2 "$0: unknown '$1' option"
	73	echo 1>&2 "Try '$0 --help' for more information"
103	74	exit 1
104	75	;;
105	76
106	77	esac
107	78
108		# normalize program name to check for.
109		program=`echo "$1" \| sed '
110		s/^gnu-//; t
111		s/^gnu//; t
112		s/^g//; t'`
113
114		# Now exit if we have it, but it failed. Also exit now if we
115		# don't have it and --version was passed (most likely to detect
116		# the program). This is about non-GNU programs, so use $1 not
117		# $program.
118		case $1 in
119		lex\|yacc)
120		# Not GNU programs, they don't have --version.
121		;;
122
123		*)
124		if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
125		# We have it, but it failed.
126		exit 1
127		elif test "x$2" = "x--version" \|\| test "x$2" = "x--help"; then
128		# Could not run --version or --help. This is probably someone
129		# running `$TOOL --version' or `$TOOL --help' to check whether
130		# $TOOL exists and not knowing $TOOL uses missing.
131		exit 1
132		fi
133		;;
134		esac
135
136		# If it does not exist, or fails to run (possibly an outdated version),
137		# try to emulate it.
138		case $program in
139		aclocal*)
140		echo 1>&2 "\
141		WARNING: \`$1' is $msg. You should only need it if
142		you modified \`acinclude.m4' or \`${configure_ac}'. You might want
143		to install the \`Automake' and \`Perl' packages. Grab them from
144		any GNU archive site."
145		touch aclocal.m4
146		;;
147
148		autoconf*)
149		echo 1>&2 "\
150		WARNING: \`$1' is $msg. You should only need it if
151		you modified \`${configure_ac}'. You might want to install the
152		\`Autoconf' and \`GNU m4' packages. Grab them from any GNU
153		archive site."
154		touch configure
155		;;
156
157		autoheader*)
158		echo 1>&2 "\
159		WARNING: \`$1' is $msg. You should only need it if
160		you modified \`acconfig.h' or \`${configure_ac}'. You might want
161		to install the \`Autoconf' and \`GNU m4' packages. Grab them
162		from any GNU archive site."
163		files=`sed -n 's/^[ ]A[CM]_CONFIG_HEADER($[^)]$).*/\1/p' ${configure_ac}`
164		test -z "$files" && files="config.h"
165		touch_files=
166		for f in $files; do
167		case $f in
168		:) touch_files="$touch_files "`echo "$f" \|
169		sed -e 's/^[^:]://' -e 's/:.//'`;;
170		*) touch_files="$touch_files $f.in";;
171		esac
172		done
173		touch $touch_files
174		;;
175
176		automake*)
177		echo 1>&2 "\
178		WARNING: \`$1' is $msg. You should only need it if
179		you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'.
180		You might want to install the \`Automake' and \`Perl' packages.
181		Grab them from any GNU archive site."
182		find . -type f -name Makefile.am -print \|
183		sed 's/\.am$/.in/' \|
184		while read f; do touch "$f"; done
185		;;
186
187		autom4te*)
188		echo 1>&2 "\
189		WARNING: \`$1' is needed, but is $msg.
190		You might have modified some files without having the
191		proper tools for further handling them.
192		You can get \`$1' as part of \`Autoconf' from any GNU
193		archive site."
194
195		file=`echo "$*" \| sed -n "$sed_output"`
196		test -z "$file" && file=`echo "$*" \| sed -n "$sed_minuso"`
197		if test -f "$file"; then
198		touch $file
199		else
200		test -z "$file" \|\| exec >$file
201		echo "#! /bin/sh"
202		echo "# Created by GNU Automake missing as a replacement of"
203		echo "# $ $@"
204		echo "exit 0"
205		chmod +x $file
206		exit 1
207		fi
208		;;
209
210		bison\|yacc)
211		echo 1>&2 "\
212		WARNING: \`$1' $msg. You should only need it if
213		you modified a \`.y' file. You may need the \`Bison' package
214		in order for those modifications to take effect. You can get
215		\`Bison' from any GNU archive site."
216		rm -f y.tab.c y.tab.h
217		if test $# -ne 1; then
218		eval LASTARG=\${$#}
219		case $LASTARG in
220		*.y)
221		SRCFILE=`echo "$LASTARG" \| sed 's/y$/c/'`
222		if test -f "$SRCFILE"; then
223		cp "$SRCFILE" y.tab.c
224		fi
225		SRCFILE=`echo "$LASTARG" \| sed 's/y$/h/'`
226		if test -f "$SRCFILE"; then
227		cp "$SRCFILE" y.tab.h
228		fi
229		;;
230		esac
231		fi
232		if test ! -f y.tab.h; then
233		echo >y.tab.h
234		fi
235		if test ! -f y.tab.c; then
236		echo 'main() { return 0; }' >y.tab.c
237		fi
238		;;
239
240		lex\|flex)
241		echo 1>&2 "\
242		WARNING: \`$1' is $msg. You should only need it if
243		you modified a \`.l' file. You may need the \`Flex' package
244		in order for those modifications to take effect. You can get
245		\`Flex' from any GNU archive site."
246		rm -f lex.yy.c
247		if test $# -ne 1; then
248		eval LASTARG=\${$#}
249		case $LASTARG in
250		*.l)
251		SRCFILE=`echo "$LASTARG" \| sed 's/l$/c/'`
252		if test -f "$SRCFILE"; then
253		cp "$SRCFILE" lex.yy.c
254		fi
255		;;
256		esac
257		fi
258		if test ! -f lex.yy.c; then
259		echo 'main() { return 0; }' >lex.yy.c
260		fi
261		;;
262
263		help2man*)
264		echo 1>&2 "\
265		WARNING: \`$1' is $msg. You should only need it if
266		you modified a dependency of a manual page. You may need the
267		\`Help2man' package in order for those modifications to take
268		effect. You can get \`Help2man' from any GNU archive site."
269
270		file=`echo "$*" \| sed -n "$sed_output"`
271		test -z "$file" && file=`echo "$*" \| sed -n "$sed_minuso"`
272		if test -f "$file"; then
273		touch $file
274		else
275		test -z "$file" \|\| exec >$file
276		echo ".ab help2man is required to generate this page"
277		exit $?
278		fi
279		;;
280
281		makeinfo*)
282		echo 1>&2 "\
283		WARNING: \`$1' is $msg. You should only need it if
284		you modified a \`.texi' or \`.texinfo' file, or any other file
285		indirectly affecting the aspect of the manual. The spurious
286		call might also be the consequence of using a buggy \`make' (AIX,
287		DU, IRIX). You might want to install the \`Texinfo' package or
288		the \`GNU make' package. Grab either from any GNU archive site."
289		# The file to touch is that specified with -o ...
290		file=`echo "$*" \| sed -n "$sed_output"`
291		test -z "$file" && file=`echo "$*" \| sed -n "$sed_minuso"`
292		if test -z "$file"; then
293		# ... or it is the one specified with @setfilename ...
294		infile=`echo "$" \| sed 's/. $[^ ]$ $/\1/'`
295		file=`sed -n '
296		/^@setfilename/{
297		s/.* $[^ ]$ $/\1/
298		p
299		q
300		}' $infile`
301		# ... or it is derived from the source name (dir/f.texi becomes f.info)
302		test -z "$file" && file=`echo "$infile" \| sed 's,./,,;s,.[^.]$,,'`.info
303		fi
304		# If the file does not exist, the user really needs makeinfo;
305		# let's fail without touching anything.
306		test -f $file \|\| exit 1
307		touch $file
308		;;
309
310		*)
311		echo 1>&2 "\
312		WARNING: \`$1' is needed, and is $msg.
313		You might have modified some files without having the
314		proper tools for further handling them. Check the \`README' file,
315		it often tells you about the needed prerequisites for installing
316		this package. You may also peek at any GNU archive site, in case
317		some other package would contain this missing \`$1' program."
318		exit 1
319		;;
320		esac
321
322		exit 0
	79	# Run the given program, remember its exit status.
	80	"$@"; st=$?
	81
	82	# If it succeeded, we are done.
	83	test $st -eq 0 && exit 0
	84
	85	# Also exit now if we it failed (or wasn't found), and '--version' was
	86	# passed; such an option is passed most likely to detect whether the
	87	# program is present and works.
	88	case $2 in --version\|--help) exit $st;; esac
	89
	90	# Exit code 63 means version mismatch. This often happens when the user
	91	# tries to use an ancient version of a tool on a file that requires a
	92	# minimum version.
	93	if test $st -eq 63; then
	94	msg="probably too old"
	95	elif test $st -eq 127; then
	96	# Program was missing.
	97	msg="missing on your system"
	98	else
	99	# Program was found and executed, but failed. Give up.
	100	exit $st
	101	fi
	102
	103	perl_URL=http://www.perl.org/
	104	flex_URL=http://flex.sourceforge.net/
	105	gnu_software_URL=http://www.gnu.org/software
	106
	107	program_details ()
	108	{
	109	case $1 in
	110	aclocal\|automake)
	111	echo "The '$1' program is part of the GNU Automake package:"
	112	echo "<$gnu_software_URL/automake>"
	113	echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
	114	echo "<$gnu_software_URL/autoconf>"
	115	echo "<$gnu_software_URL/m4/>"
	116	echo "<$perl_URL>"
	117	;;
	118	autoconf\|autom4te\|autoheader)
	119	echo "The '$1' program is part of the GNU Autoconf package:"
	120	echo "<$gnu_software_URL/autoconf/>"
	121	echo "It also requires GNU m4 and Perl in order to run:"
	122	echo "<$gnu_software_URL/m4/>"
	123	echo "<$perl_URL>"
	124	;;
	125	esac
	126	}
	127
	128	give_advice ()
	129	{
	130	# Normalize program name to check for.
	131	normalized_program=`echo "$1" \| sed '
	132	s/^gnu-//; t
	133	s/^gnu//; t
	134	s/^g//; t'`
	135
	136	printf '%s\n' "'$1' is $msg."
	137
	138	configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
	139	case $normalized_program in
	140	autoconf*)
	141	echo "You should only need it if you modified 'configure.ac',"
	142	echo "or m4 files included by it."
	143	program_details 'autoconf'
	144	;;
	145	autoheader*)
	146	echo "You should only need it if you modified 'acconfig.h' or"
	147	echo "$configure_deps."
	148	program_details 'autoheader'
	149	;;
	150	automake*)
	151	echo "You should only need it if you modified 'Makefile.am' or"
	152	echo "$configure_deps."
	153	program_details 'automake'
	154	;;
	155	aclocal*)
	156	echo "You should only need it if you modified 'acinclude.m4' or"
	157	echo "$configure_deps."
	158	program_details 'aclocal'
	159	;;
	160	autom4te*)
	161	echo "You might have modified some maintainer files that require"
	162	echo "the 'automa4te' program to be rebuilt."
	163	program_details 'autom4te'
	164	;;
	165	bison\|yacc)
	166	echo "You should only need it if you modified a '.y' file."
	167	echo "You may want to install the GNU Bison package:"
	168	echo "<$gnu_software_URL/bison/>"
	169	;;
	170	lex\|flex)
	171	echo "You should only need it if you modified a '.l' file."
	172	echo "You may want to install the Fast Lexical Analyzer package:"
	173	echo "<$flex_URL>"
	174	;;
	175	help2man*)
	176	echo "You should only need it if you modified a dependency" \
	177	"of a man page."
	178	echo "You may want to install the GNU Help2man package:"
	179	echo "<$gnu_software_URL/help2man/>"
	180	;;
	181	makeinfo*)
	182	echo "You should only need it if you modified a '.texi' file, or"
	183	echo "any other file indirectly affecting the aspect of the manual."
	184	echo "You might want to install the Texinfo package:"
	185	echo "<$gnu_software_URL/texinfo/>"
	186	echo "The spurious makeinfo call might also be the consequence of"
	187	echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
	188	echo "want to install GNU make:"
	189	echo "<$gnu_software_URL/make/>"
	190	;;
	191	*)
	192	echo "You might have modified some files without having the proper"
	193	echo "tools for further handling them. Check the 'README' file, it"
	194	echo "often tells you about the needed prerequisites for installing"
	195	echo "this package. You may also peek at any GNU archive site, in"
	196	echo "case some other package contains this missing '$1' program."
	197	;;
	198	esac
	199	}
	200
	201	give_advice "$1" \| sed -e '1s/^/WARNING: /' \
	202	-e '2,$s/^/ /' >&2
	203
	204	# Propagate the correct exit status (expected to be 127 for a program
	205	# not found, 63 for a program that failed due to version mismatch).
	206	exit $st
323	207
324	208	# Local variables:
325	209	# eval: (add-hook 'write-file-hooks 'time-stamp)

-7

multi_thread/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2595 2012-11-20 17:39:25Z bradbell $
	0	# $Id: CMakeLists.txt 3120 2014-02-25 14:04:02Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

12	12	# Inherit environment from ../CMakeList.txt
13	13
14	14	# initialize list as empty
15		SET(list_multi_thread "")
	15	SET(check_depends "")
16	16
17	17	# Define the operation
18	18	# CHECK_LIBRARY_EXISTS (LIBRARY FUNCTION LOCATION VARIABLE)

28	28	IF ( OPENMP_FOUND )
29	29	# OpenMP_CXX_FLAGS - flags to add to the CXX compiler for OpenMP support
30	30	ADD_SUBDIRECTORY(openmp)
31		add_to_list(list_multi_thread check_openmp)
	31	add_to_list(check_depends check_multi_thread_openmp)
32	32	ENDIF ( OPENMP_FOUND )
33	33
34	34	# If pthreads found, set pthread_lib and pthread_lib_path and process subdir

43	43	)
44	44	IF ( pthread_ok )
45	45	ADD_SUBDIRECTORY(pthread)
46		add_to_list(list_multi_thread check_pthread)
	46	add_to_list(check_depends check_multi_thread_pthread)
47	47	ENDIF ( pthread_ok )
48	48	ENDIF ( pthread_lib_path )
49	49

77	77	ENDIF ( NOT bthread_ok )
78	78	IF ( bthread_ok OR bthread_mt_ok )
79	79	ADD_SUBDIRECTORY(bthread)
80		add_to_list(list_multi_thread check_bthread)
	80	add_to_list(check_depends check_multi_thread_bthread)
81	81	ENDIF ( bthread_ok OR bthread_mt_ok )
82	82	ENDIF ( Boost_FOUND )
83	83
84	84	# check_multi_thread
85		ADD_CUSTOM_TARGET(check_multi_thread DEPENDS ${list_multi_thread})
	85	ADD_CUSTOM_TARGET(check_multi_thread DEPENDS ${check_depends})

-9

multi_thread/bthread/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2564 2012-11-12 21:55:25Z bradbell $
	0	# $Id: CMakeLists.txt 3114 2014-02-22 16:20:39Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

21	21	# add_executable(<name> [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL]
22	22	# source1 source2 ... sourceN
23	23	# )
24		ADD_EXECUTABLE(bthread_test EXCLUDE_FROM_ALL ../thread_test.cpp
	24	ADD_EXECUTABLE(multi_thread_bthread EXCLUDE_FROM_ALL ../thread_test.cpp
25	25	../multi_newton_time.cpp
26	26	../multi_newton.cpp
27	27	../multi_newton_work.cpp

35	35	)
36	36
37	37	# Compiler flags for cppad source
38		add_cppad_cxx_flags( bthread_test )
	38	add_cppad_cxx_flags( multi_thread_bthread )
39	39
40	40	# Paths in which the linker will search for libraries,
41	41	# only applies to targets created after it is called
42	42	LINK_DIRECTORIES( ${bthread_lib_path} )
43	43
44	44	# List of libraries to be linked into the specified target
45		TARGET_LINK_LIBRARIES(bthread_test ${bthread_lib})
	45	TARGET_LINK_LIBRARIES(multi_thread_bthread ${bthread_lib})
46	46
47		# Add the check_bthread target
48		ADD_CUSTOM_TARGET(check_bthread
49		bthread_test simple_ad
50		DEPENDS bthread_test
	47	# Add the check_multi_thread_bthread target
	48	ADD_CUSTOM_TARGET(check_multi_thread_bthread
	49	multi_thread_bthread simple_ad
	50	DEPENDS multi_thread_bthread
51	51	)

+215

-222

multi_thread/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

15	14	@SET_MAKE@
16	15
17	16	VPATH = @srcdir@
18		am__make_dryrun = \
19		{ \
20		am__dry=no; \
	17	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	18	am__make_running_with_option = \
	19	case $${target_option-} in \
	20	?) ;; \
	21	*) echo "am__make_running_with_option: internal error: invalid" \
	22	"target option '$${target_option-}' specified" >&2; \
	23	exit 1;; \
	24	esac; \
	25	has_opt=no; \
	26	sane_makeflags=$$MAKEFLAGS; \
	27	if $(am__is_gnu_make); then \
	28	sane_makeflags=$$MFLAGS; \
	29	else \
21	30	case $$MAKEFLAGS in \
22	31	\\[\ \ ]) \
23		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
24		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
25		*) \
26		for am__flg in $$MAKEFLAGS; do \
27		case $$am__flg in \
28		=\|--*) ;; \
29		n) am__dry=yes; break;; \
30		esac; \
31		done;; \
	32	bs=\\; \
	33	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	34	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
32	35	esac; \
33		test $$am__dry = yes; \
34		}
	36	fi; \
	37	skip_next=no; \
	38	strip_trailopt () \
	39	{ \
	40	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	41	}; \
	42	for flg in $$sane_makeflags; do \
	43	test $$skip_next = yes && { skip_next=no; continue; }; \
	44	case $$flg in \
	45	=\|--*) continue;; \
	46	-*I) strip_trailopt 'I'; skip_next=yes;; \
	47	-I?) strip_trailopt 'I';; \
	48	-*O) strip_trailopt 'O'; skip_next=yes;; \
	49	-O?) strip_trailopt 'O';; \
	50	-*l) strip_trailopt 'l'; skip_next=yes;; \
	51	-l?) strip_trailopt 'l';; \
	52	-[dEDm]) skip_next=yes;; \
	53	-[JT]) skip_next=yes;; \
	54	esac; \
	55	case $$flg in \
	56	$$target_option) has_opt=yes; break;; \
	57	esac; \
	58	done; \
	59	test $$has_opt = yes
	60	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	61	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
35	62	pkgdatadir = $(datadir)/@PACKAGE@
36	63	pkgincludedir = $(includedir)/@PACKAGE@
37	64	pkglibdir = $(libdir)/@PACKAGE@

48	75	NORMAL_UNINSTALL = :
49	76	PRE_UNINSTALL = :
50	77	POST_UNINSTALL = :
	78	build_triplet = @build@
	79	host_triplet = @host@
51	80	check_PROGRAMS = $(am__EXEEXT_1) $(am__EXEEXT_2) $(am__EXEEXT_3)
52	81	subdir = multi_thread
53		DIST_COMMON = $(dist_noinst_SCRIPTS) $(srcdir)/makefile.am \
54		$(srcdir)/makefile.in
	82	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	83	$(dist_noinst_SCRIPTS) $(top_srcdir)/depcomp
55	84	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
56	85	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
57	86	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

66	95	multi_newton.$(OBJEXT) multi_newton_work.$(OBJEXT) \
67	96	team_example.$(OBJEXT) harmonic_time.$(OBJEXT) \
68	97	harmonic.$(OBJEXT) harmonic_work.$(OBJEXT)
69		am_bthread_test_OBJECTS = $(am__objects_1) team_bthread.$(OBJEXT) \
70		a11c_bthread.$(OBJEXT) simple_ad_bthread.$(OBJEXT)
	98	am__dirstamp = $(am__leading_dot)dirstamp
	99	am_bthread_test_OBJECTS = $(am__objects_1) \
	100	bthread/team_bthread.$(OBJEXT) bthread/a11c_bthread.$(OBJEXT) \
	101	bthread/simple_ad_bthread.$(OBJEXT)
71	102	bthread_test_OBJECTS = $(am_bthread_test_OBJECTS)
72	103	bthread_test_LDADD = $(LDADD)
73	104	am__DEPENDENCIES_1 =
74	105	bthread_test_DEPENDENCIES = $(am__DEPENDENCIES_1) \
75	106	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
76		am_openmp_test_OBJECTS = $(am__objects_1) team_openmp.$(OBJEXT) \
77		a11c_openmp.$(OBJEXT) simple_ad_openmp.$(OBJEXT)
	107	am_openmp_test_OBJECTS = $(am__objects_1) openmp/team_openmp.$(OBJEXT) \
	108	openmp/a11c_openmp.$(OBJEXT) openmp/simple_ad_openmp.$(OBJEXT)
78	109	openmp_test_OBJECTS = $(am_openmp_test_OBJECTS)
79	110	openmp_test_LDADD = $(LDADD)
80	111	openmp_test_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
81	112	$(am__DEPENDENCIES_1)
82		am_pthread_test_OBJECTS = $(am__objects_1) team_pthread.$(OBJEXT) \
83		a11c_pthread.$(OBJEXT) simple_ad_pthread.$(OBJEXT)
	113	am_pthread_test_OBJECTS = $(am__objects_1) \
	114	pthread/team_pthread.$(OBJEXT) pthread/a11c_pthread.$(OBJEXT) \
	115	pthread/simple_ad_pthread.$(OBJEXT)
84	116	pthread_test_OBJECTS = $(am_pthread_test_OBJECTS)
85	117	pthread_test_LDADD = $(LDADD)
86	118	pthread_test_DEPENDENCIES = $(am__DEPENDENCIES_1) \
87	119	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
88	120	SCRIPTS = $(dist_noinst_SCRIPTS)
	121	AM_V_P = $(am__v_P_@AM_V@)
	122	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	123	am__v_P_0 = false
	124	am__v_P_1 = :
	125	AM_V_GEN = $(am__v_GEN_@AM_V@)
	126	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	127	am__v_GEN_0 = @echo " GEN " $@;
	128	am__v_GEN_1 =
	129	AM_V_at = $(am__v_at_@AM_V@)
	130	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	131	am__v_at_0 = @
	132	am__v_at_1 =
89	133	DEFAULT_INCLUDES =
90	134	depcomp = $(SHELL) $(top_srcdir)/depcomp
91	135	am__depfiles_maybe = depfiles
92	136	am__mv = mv -f
93		AM_V_lt = $(am__v_lt_@AM_V@)
94		am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
95		am__v_lt_0 = --silent
96	137	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
97	138	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
98	139	AM_V_CXX = $(am__v_CXX_@AM_V@)
99	140	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
100		am__v_CXX_0 = @echo " CXX " $@;
101		AM_V_at = $(am__v_at_@AM_V@)
102		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
103		am__v_at_0 = @
	141	am__v_CXX_0 = @echo " CXX " $@;
	142	am__v_CXX_1 =
104	143	CXXLD = $(CXX)
105	144	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
106	145	-o $@
107	146	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
108	147	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
109		am__v_CXXLD_0 = @echo " CXXLD " $@;
	148	am__v_CXXLD_0 = @echo " CXXLD " $@;
	149	am__v_CXXLD_1 =
110	150	COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
111	151	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
112	152	AM_V_CC = $(am__v_CC_@AM_V@)
113	153	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
114		am__v_CC_0 = @echo " CC " $@;
	154	am__v_CC_0 = @echo " CC " $@;
	155	am__v_CC_1 =
115	156	CCLD = $(CC)
116	157	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
117	158	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
118	159	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
119		am__v_CCLD_0 = @echo " CCLD " $@;
120		AM_V_GEN = $(am__v_GEN_@AM_V@)
121		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
122		am__v_GEN_0 = @echo " GEN " $@;
	160	am__v_CCLD_0 = @echo " CCLD " $@;
	161	am__v_CCLD_1 =
123	162	SOURCES = $(bthread_test_SOURCES) $(openmp_test_SOURCES) \
124	163	$(pthread_test_SOURCES)
125	164	DIST_SOURCES = $(bthread_test_SOURCES) $(openmp_test_SOURCES) \

129	168	n\|no\|NO) false;; \
130	169	*) (install-info --version) >/dev/null 2>&1;; \
131	170	esac
	171	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	172	# Read a list of newline-separated strings from the standard input,
	173	# and print each of them once, without duplicates. Input order is
	174	# not preserved.
	175	am__uniquify_input = $(AWK) '\
	176	BEGIN { nonempty = 0; } \
	177	{ items[$$0] = 1; nonempty = 1; } \
	178	END { if (nonempty) { for (i in items) print i; }; } \
	179	'
	180	# Make sure the list of sources is unique. This is necessary because,
	181	# e.g., the same source file might be shared among _SOURCES variables
	182	# for different programs/libraries.
	183	am__define_uniq_tagged_files = \
	184	list='$(am__tagged_files)'; \
	185	unique=`for i in $$list; do \
	186	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	187	done \| $(am__uniquify_input)`
132	188	ETAGS = etags
133	189	CTAGS = ctags
134	190	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

138	194	ADOLC_DIR = @ADOLC_DIR@
139	195	AMTAR = @AMTAR@
140	196	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	197	AR = @AR@
141	198	AUTOCONF = @AUTOCONF@
142	199	AUTOHEADER = @AUTOHEADER@
143	200	AUTOMAKE = @AUTOMAKE@

160	217	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
161	218	CYGPATH_W = @CYGPATH_W@
162	219
163		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	220	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
164	221	# -----------------------------------------------------------------------------
165	222	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
166	223	#

227	284	abs_srcdir = @abs_srcdir@
228	285	abs_top_builddir = @abs_top_builddir@
229	286	abs_top_srcdir = @abs_top_srcdir@
	287	ac_ct_AR = @ac_ct_AR@
230	288	ac_ct_CC = @ac_ct_CC@
231	289	ac_ct_CXX = @ac_ct_CXX@
232	290	ac_ct_FC = @ac_ct_FC@

237	295	am__tar = @am__tar@
238	296	am__untar = @am__untar@
239	297	bindir = @bindir@
	298	build = @build@
240	299	build_alias = @build_alias@
	300	build_cpu = @build_cpu@
	301	build_os = @build_os@
	302	build_vendor = @build_vendor@
241	303	builddir = @builddir@
242	304	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
243	305	cppad_boostvector = @cppad_boostvector@
244	306	cppad_cflags = @cppad_cflags@
	307	cppad_compiler_has_erf = @cppad_compiler_has_erf@
245	308	cppad_cppadvector = @cppad_cppadvector@
246	309	cppad_description = @cppad_description@
247	310	cppad_eigenvector = @cppad_eigenvector@
	311	cppad_has_colpack = @cppad_has_colpack@
	312	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
248	313	cppad_has_gettimeofday = @cppad_has_gettimeofday@
249	314	cppad_has_nullptr = @cppad_has_nullptr@
	315	cppad_has_rvalue = @cppad_has_rvalue@
250	316	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
251	317	cppad_internal_sparse_set = @cppad_internal_sparse_set@
252	318	cppad_libs = @cppad_libs@
253	319	cppad_max_num_threads = @cppad_max_num_threads@
254	320	cppad_requires = @cppad_requires@
255		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	321	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
256	322	cppad_stdvector = @cppad_stdvector@
257	323	cppad_tape_addr_type = @cppad_tape_addr_type@
258	324	cppad_tape_id_type = @cppad_tape_id_type@

264	330	dvidir = @dvidir@
265	331	eigen_prefix = @eigen_prefix@
266	332	exec_prefix = @exec_prefix@
267		have_ar = @have_ar@
268	333	have_pkg_config = @have_pkg_config@
	334	host = @host@
269	335	host_alias = @host_alias@
	336	host_cpu = @host_cpu@
	337	host_os = @host_os@
	338	host_vendor = @host_vendor@
270	339	htmldir = @htmldir@
271	340	includedir = @includedir@
272	341	infodir = @infodir@

393	462
394	463	clean-checkPROGRAMS:
395	464	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	465	bthread/$(am__dirstamp):
	466	@$(MKDIR_P) bthread
	467	@: > bthread/$(am__dirstamp)
	468	bthread/$(DEPDIR)/$(am__dirstamp):
	469	@$(MKDIR_P) bthread/$(DEPDIR)
	470	@: > bthread/$(DEPDIR)/$(am__dirstamp)
	471	bthread/team_bthread.$(OBJEXT): bthread/$(am__dirstamp) \
	472	bthread/$(DEPDIR)/$(am__dirstamp)
	473	bthread/a11c_bthread.$(OBJEXT): bthread/$(am__dirstamp) \
	474	bthread/$(DEPDIR)/$(am__dirstamp)
	475	bthread/simple_ad_bthread.$(OBJEXT): bthread/$(am__dirstamp) \
	476	bthread/$(DEPDIR)/$(am__dirstamp)
	477
396	478	bthread_test$(EXEEXT): $(bthread_test_OBJECTS) $(bthread_test_DEPENDENCIES) $(EXTRA_bthread_test_DEPENDENCIES)
397	479	@rm -f bthread_test$(EXEEXT)
398	480	$(AM_V_CXXLD)$(CXXLINK) $(bthread_test_OBJECTS) $(bthread_test_LDADD) $(LIBS)
	481	openmp/$(am__dirstamp):
	482	@$(MKDIR_P) openmp
	483	@: > openmp/$(am__dirstamp)
	484	openmp/$(DEPDIR)/$(am__dirstamp):
	485	@$(MKDIR_P) openmp/$(DEPDIR)
	486	@: > openmp/$(DEPDIR)/$(am__dirstamp)
	487	openmp/team_openmp.$(OBJEXT): openmp/$(am__dirstamp) \
	488	openmp/$(DEPDIR)/$(am__dirstamp)
	489	openmp/a11c_openmp.$(OBJEXT): openmp/$(am__dirstamp) \
	490	openmp/$(DEPDIR)/$(am__dirstamp)
	491	openmp/simple_ad_openmp.$(OBJEXT): openmp/$(am__dirstamp) \
	492	openmp/$(DEPDIR)/$(am__dirstamp)
	493
399	494	openmp_test$(EXEEXT): $(openmp_test_OBJECTS) $(openmp_test_DEPENDENCIES) $(EXTRA_openmp_test_DEPENDENCIES)
400	495	@rm -f openmp_test$(EXEEXT)
401	496	$(AM_V_CXXLD)$(CXXLINK) $(openmp_test_OBJECTS) $(openmp_test_LDADD) $(LIBS)
	497	pthread/$(am__dirstamp):
	498	@$(MKDIR_P) pthread
	499	@: > pthread/$(am__dirstamp)
	500	pthread/$(DEPDIR)/$(am__dirstamp):
	501	@$(MKDIR_P) pthread/$(DEPDIR)
	502	@: > pthread/$(DEPDIR)/$(am__dirstamp)
	503	pthread/team_pthread.$(OBJEXT): pthread/$(am__dirstamp) \
	504	pthread/$(DEPDIR)/$(am__dirstamp)
	505	pthread/a11c_pthread.$(OBJEXT): pthread/$(am__dirstamp) \
	506	pthread/$(DEPDIR)/$(am__dirstamp)
	507	pthread/simple_ad_pthread.$(OBJEXT): pthread/$(am__dirstamp) \
	508	pthread/$(DEPDIR)/$(am__dirstamp)
	509
402	510	pthread_test$(EXEEXT): $(pthread_test_OBJECTS) $(pthread_test_DEPENDENCIES) $(EXTRA_pthread_test_DEPENDENCIES)
403	511	@rm -f pthread_test$(EXEEXT)
404	512	$(AM_V_CXXLD)$(CXXLINK) $(pthread_test_OBJECTS) $(pthread_test_LDADD) $(LIBS)
405	513
406	514	mostlyclean-compile:
407	515	-rm -f *.$(OBJEXT)
	516	-rm -f bthread/*.$(OBJEXT)
	517	-rm -f openmp/*.$(OBJEXT)
	518	-rm -f pthread/*.$(OBJEXT)
408	519
409	520	distclean-compile:
410	521	-rm -f *.tab.c
411	522
412		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/a11c_bthread.Po@am__quote@
413		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/a11c_openmp.Po@am__quote@
414		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/a11c_pthread.Po@am__quote@
415	523	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/harmonic.Po@am__quote@
416	524	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/harmonic_time.Po@am__quote@
417	525	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/harmonic_work.Po@am__quote@
418	526	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/multi_newton.Po@am__quote@
419	527	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/multi_newton_time.Po@am__quote@
420	528	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/multi_newton_work.Po@am__quote@
421		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/simple_ad_bthread.Po@am__quote@
422		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/simple_ad_openmp.Po@am__quote@
423		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/simple_ad_pthread.Po@am__quote@
424		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/team_bthread.Po@am__quote@
425	529	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/team_example.Po@am__quote@
426		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/team_openmp.Po@am__quote@
427		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/team_pthread.Po@am__quote@
428	530	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/thread_test.Po@am__quote@
	531	@AMDEP_TRUE@@am__include@ @am__quote@bthread/$(DEPDIR)/a11c_bthread.Po@am__quote@
	532	@AMDEP_TRUE@@am__include@ @am__quote@bthread/$(DEPDIR)/simple_ad_bthread.Po@am__quote@
	533	@AMDEP_TRUE@@am__include@ @am__quote@bthread/$(DEPDIR)/team_bthread.Po@am__quote@
	534	@AMDEP_TRUE@@am__include@ @am__quote@openmp/$(DEPDIR)/a11c_openmp.Po@am__quote@
	535	@AMDEP_TRUE@@am__include@ @am__quote@openmp/$(DEPDIR)/simple_ad_openmp.Po@am__quote@
	536	@AMDEP_TRUE@@am__include@ @am__quote@openmp/$(DEPDIR)/team_openmp.Po@am__quote@
	537	@AMDEP_TRUE@@am__include@ @am__quote@pthread/$(DEPDIR)/a11c_pthread.Po@am__quote@
	538	@AMDEP_TRUE@@am__include@ @am__quote@pthread/$(DEPDIR)/simple_ad_pthread.Po@am__quote@
	539	@AMDEP_TRUE@@am__include@ @am__quote@pthread/$(DEPDIR)/team_pthread.Po@am__quote@
429	540
430	541	.cpp.o:
431		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
432		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	542	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	543	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	544	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
433	545	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
434	546	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
435	547	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
436	548
437	549	.cpp.obj:
438		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
439		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	550	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	551	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	552	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
440	553	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
441	554	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
442	555	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
443	556
444		team_bthread.o: bthread/team_bthread.cpp
445		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT team_bthread.o -MD -MP -MF $(DEPDIR)/team_bthread.Tpo -c -o team_bthread.o `test -f 'bthread/team_bthread.cpp' \|\| echo '$(srcdir)/'`bthread/team_bthread.cpp
446		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/team_bthread.Tpo $(DEPDIR)/team_bthread.Po
447		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='bthread/team_bthread.cpp' object='team_bthread.o' libtool=no @AMDEPBACKSLASH@
448		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
449		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o team_bthread.o `test -f 'bthread/team_bthread.cpp' \|\| echo '$(srcdir)/'`bthread/team_bthread.cpp
450
451		team_bthread.obj: bthread/team_bthread.cpp
452		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT team_bthread.obj -MD -MP -MF $(DEPDIR)/team_bthread.Tpo -c -o team_bthread.obj `if test -f 'bthread/team_bthread.cpp'; then $(CYGPATH_W) 'bthread/team_bthread.cpp'; else $(CYGPATH_W) '$(srcdir)/bthread/team_bthread.cpp'; fi`
453		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/team_bthread.Tpo $(DEPDIR)/team_bthread.Po
454		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='bthread/team_bthread.cpp' object='team_bthread.obj' libtool=no @AMDEPBACKSLASH@
455		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
456		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o team_bthread.obj `if test -f 'bthread/team_bthread.cpp'; then $(CYGPATH_W) 'bthread/team_bthread.cpp'; else $(CYGPATH_W) '$(srcdir)/bthread/team_bthread.cpp'; fi`
457
458		a11c_bthread.o: bthread/a11c_bthread.cpp
459		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT a11c_bthread.o -MD -MP -MF $(DEPDIR)/a11c_bthread.Tpo -c -o a11c_bthread.o `test -f 'bthread/a11c_bthread.cpp' \|\| echo '$(srcdir)/'`bthread/a11c_bthread.cpp
460		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/a11c_bthread.Tpo $(DEPDIR)/a11c_bthread.Po
461		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='bthread/a11c_bthread.cpp' object='a11c_bthread.o' libtool=no @AMDEPBACKSLASH@
462		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
463		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o a11c_bthread.o `test -f 'bthread/a11c_bthread.cpp' \|\| echo '$(srcdir)/'`bthread/a11c_bthread.cpp
464
465		a11c_bthread.obj: bthread/a11c_bthread.cpp
466		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT a11c_bthread.obj -MD -MP -MF $(DEPDIR)/a11c_bthread.Tpo -c -o a11c_bthread.obj `if test -f 'bthread/a11c_bthread.cpp'; then $(CYGPATH_W) 'bthread/a11c_bthread.cpp'; else $(CYGPATH_W) '$(srcdir)/bthread/a11c_bthread.cpp'; fi`
467		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/a11c_bthread.Tpo $(DEPDIR)/a11c_bthread.Po
468		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='bthread/a11c_bthread.cpp' object='a11c_bthread.obj' libtool=no @AMDEPBACKSLASH@
469		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
470		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o a11c_bthread.obj `if test -f 'bthread/a11c_bthread.cpp'; then $(CYGPATH_W) 'bthread/a11c_bthread.cpp'; else $(CYGPATH_W) '$(srcdir)/bthread/a11c_bthread.cpp'; fi`
471
472		simple_ad_bthread.o: bthread/simple_ad_bthread.cpp
473		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT simple_ad_bthread.o -MD -MP -MF $(DEPDIR)/simple_ad_bthread.Tpo -c -o simple_ad_bthread.o `test -f 'bthread/simple_ad_bthread.cpp' \|\| echo '$(srcdir)/'`bthread/simple_ad_bthread.cpp
474		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/simple_ad_bthread.Tpo $(DEPDIR)/simple_ad_bthread.Po
475		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='bthread/simple_ad_bthread.cpp' object='simple_ad_bthread.o' libtool=no @AMDEPBACKSLASH@
476		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
477		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o simple_ad_bthread.o `test -f 'bthread/simple_ad_bthread.cpp' \|\| echo '$(srcdir)/'`bthread/simple_ad_bthread.cpp
478
479		simple_ad_bthread.obj: bthread/simple_ad_bthread.cpp
480		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT simple_ad_bthread.obj -MD -MP -MF $(DEPDIR)/simple_ad_bthread.Tpo -c -o simple_ad_bthread.obj `if test -f 'bthread/simple_ad_bthread.cpp'; then $(CYGPATH_W) 'bthread/simple_ad_bthread.cpp'; else $(CYGPATH_W) '$(srcdir)/bthread/simple_ad_bthread.cpp'; fi`
481		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/simple_ad_bthread.Tpo $(DEPDIR)/simple_ad_bthread.Po
482		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='bthread/simple_ad_bthread.cpp' object='simple_ad_bthread.obj' libtool=no @AMDEPBACKSLASH@
483		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
484		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o simple_ad_bthread.obj `if test -f 'bthread/simple_ad_bthread.cpp'; then $(CYGPATH_W) 'bthread/simple_ad_bthread.cpp'; else $(CYGPATH_W) '$(srcdir)/bthread/simple_ad_bthread.cpp'; fi`
485
486		team_openmp.o: openmp/team_openmp.cpp
487		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT team_openmp.o -MD -MP -MF $(DEPDIR)/team_openmp.Tpo -c -o team_openmp.o `test -f 'openmp/team_openmp.cpp' \|\| echo '$(srcdir)/'`openmp/team_openmp.cpp
488		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/team_openmp.Tpo $(DEPDIR)/team_openmp.Po
489		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='openmp/team_openmp.cpp' object='team_openmp.o' libtool=no @AMDEPBACKSLASH@
490		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
491		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o team_openmp.o `test -f 'openmp/team_openmp.cpp' \|\| echo '$(srcdir)/'`openmp/team_openmp.cpp
492
493		team_openmp.obj: openmp/team_openmp.cpp
494		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT team_openmp.obj -MD -MP -MF $(DEPDIR)/team_openmp.Tpo -c -o team_openmp.obj `if test -f 'openmp/team_openmp.cpp'; then $(CYGPATH_W) 'openmp/team_openmp.cpp'; else $(CYGPATH_W) '$(srcdir)/openmp/team_openmp.cpp'; fi`
495		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/team_openmp.Tpo $(DEPDIR)/team_openmp.Po
496		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='openmp/team_openmp.cpp' object='team_openmp.obj' libtool=no @AMDEPBACKSLASH@
497		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
498		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o team_openmp.obj `if test -f 'openmp/team_openmp.cpp'; then $(CYGPATH_W) 'openmp/team_openmp.cpp'; else $(CYGPATH_W) '$(srcdir)/openmp/team_openmp.cpp'; fi`
499
500		a11c_openmp.o: openmp/a11c_openmp.cpp
501		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT a11c_openmp.o -MD -MP -MF $(DEPDIR)/a11c_openmp.Tpo -c -o a11c_openmp.o `test -f 'openmp/a11c_openmp.cpp' \|\| echo '$(srcdir)/'`openmp/a11c_openmp.cpp
502		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/a11c_openmp.Tpo $(DEPDIR)/a11c_openmp.Po
503		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='openmp/a11c_openmp.cpp' object='a11c_openmp.o' libtool=no @AMDEPBACKSLASH@
504		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
505		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o a11c_openmp.o `test -f 'openmp/a11c_openmp.cpp' \|\| echo '$(srcdir)/'`openmp/a11c_openmp.cpp
506
507		a11c_openmp.obj: openmp/a11c_openmp.cpp
508		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT a11c_openmp.obj -MD -MP -MF $(DEPDIR)/a11c_openmp.Tpo -c -o a11c_openmp.obj `if test -f 'openmp/a11c_openmp.cpp'; then $(CYGPATH_W) 'openmp/a11c_openmp.cpp'; else $(CYGPATH_W) '$(srcdir)/openmp/a11c_openmp.cpp'; fi`
509		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/a11c_openmp.Tpo $(DEPDIR)/a11c_openmp.Po
510		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='openmp/a11c_openmp.cpp' object='a11c_openmp.obj' libtool=no @AMDEPBACKSLASH@
511		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
512		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o a11c_openmp.obj `if test -f 'openmp/a11c_openmp.cpp'; then $(CYGPATH_W) 'openmp/a11c_openmp.cpp'; else $(CYGPATH_W) '$(srcdir)/openmp/a11c_openmp.cpp'; fi`
513
514		simple_ad_openmp.o: openmp/simple_ad_openmp.cpp
515		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT simple_ad_openmp.o -MD -MP -MF $(DEPDIR)/simple_ad_openmp.Tpo -c -o simple_ad_openmp.o `test -f 'openmp/simple_ad_openmp.cpp' \|\| echo '$(srcdir)/'`openmp/simple_ad_openmp.cpp
516		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/simple_ad_openmp.Tpo $(DEPDIR)/simple_ad_openmp.Po
517		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='openmp/simple_ad_openmp.cpp' object='simple_ad_openmp.o' libtool=no @AMDEPBACKSLASH@
518		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
519		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o simple_ad_openmp.o `test -f 'openmp/simple_ad_openmp.cpp' \|\| echo '$(srcdir)/'`openmp/simple_ad_openmp.cpp
520
521		simple_ad_openmp.obj: openmp/simple_ad_openmp.cpp
522		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT simple_ad_openmp.obj -MD -MP -MF $(DEPDIR)/simple_ad_openmp.Tpo -c -o simple_ad_openmp.obj `if test -f 'openmp/simple_ad_openmp.cpp'; then $(CYGPATH_W) 'openmp/simple_ad_openmp.cpp'; else $(CYGPATH_W) '$(srcdir)/openmp/simple_ad_openmp.cpp'; fi`
523		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/simple_ad_openmp.Tpo $(DEPDIR)/simple_ad_openmp.Po
524		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='openmp/simple_ad_openmp.cpp' object='simple_ad_openmp.obj' libtool=no @AMDEPBACKSLASH@
525		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
526		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o simple_ad_openmp.obj `if test -f 'openmp/simple_ad_openmp.cpp'; then $(CYGPATH_W) 'openmp/simple_ad_openmp.cpp'; else $(CYGPATH_W) '$(srcdir)/openmp/simple_ad_openmp.cpp'; fi`
527
528		team_pthread.o: pthread/team_pthread.cpp
529		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT team_pthread.o -MD -MP -MF $(DEPDIR)/team_pthread.Tpo -c -o team_pthread.o `test -f 'pthread/team_pthread.cpp' \|\| echo '$(srcdir)/'`pthread/team_pthread.cpp
530		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/team_pthread.Tpo $(DEPDIR)/team_pthread.Po
531		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='pthread/team_pthread.cpp' object='team_pthread.o' libtool=no @AMDEPBACKSLASH@
532		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
533		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o team_pthread.o `test -f 'pthread/team_pthread.cpp' \|\| echo '$(srcdir)/'`pthread/team_pthread.cpp
534
535		team_pthread.obj: pthread/team_pthread.cpp
536		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT team_pthread.obj -MD -MP -MF $(DEPDIR)/team_pthread.Tpo -c -o team_pthread.obj `if test -f 'pthread/team_pthread.cpp'; then $(CYGPATH_W) 'pthread/team_pthread.cpp'; else $(CYGPATH_W) '$(srcdir)/pthread/team_pthread.cpp'; fi`
537		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/team_pthread.Tpo $(DEPDIR)/team_pthread.Po
538		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='pthread/team_pthread.cpp' object='team_pthread.obj' libtool=no @AMDEPBACKSLASH@
539		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
540		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o team_pthread.obj `if test -f 'pthread/team_pthread.cpp'; then $(CYGPATH_W) 'pthread/team_pthread.cpp'; else $(CYGPATH_W) '$(srcdir)/pthread/team_pthread.cpp'; fi`
541
542		a11c_pthread.o: pthread/a11c_pthread.cpp
543		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT a11c_pthread.o -MD -MP -MF $(DEPDIR)/a11c_pthread.Tpo -c -o a11c_pthread.o `test -f 'pthread/a11c_pthread.cpp' \|\| echo '$(srcdir)/'`pthread/a11c_pthread.cpp
544		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/a11c_pthread.Tpo $(DEPDIR)/a11c_pthread.Po
545		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='pthread/a11c_pthread.cpp' object='a11c_pthread.o' libtool=no @AMDEPBACKSLASH@
546		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
547		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o a11c_pthread.o `test -f 'pthread/a11c_pthread.cpp' \|\| echo '$(srcdir)/'`pthread/a11c_pthread.cpp
548
549		a11c_pthread.obj: pthread/a11c_pthread.cpp
550		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT a11c_pthread.obj -MD -MP -MF $(DEPDIR)/a11c_pthread.Tpo -c -o a11c_pthread.obj `if test -f 'pthread/a11c_pthread.cpp'; then $(CYGPATH_W) 'pthread/a11c_pthread.cpp'; else $(CYGPATH_W) '$(srcdir)/pthread/a11c_pthread.cpp'; fi`
551		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/a11c_pthread.Tpo $(DEPDIR)/a11c_pthread.Po
552		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='pthread/a11c_pthread.cpp' object='a11c_pthread.obj' libtool=no @AMDEPBACKSLASH@
553		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
554		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o a11c_pthread.obj `if test -f 'pthread/a11c_pthread.cpp'; then $(CYGPATH_W) 'pthread/a11c_pthread.cpp'; else $(CYGPATH_W) '$(srcdir)/pthread/a11c_pthread.cpp'; fi`
555
556		simple_ad_pthread.o: pthread/simple_ad_pthread.cpp
557		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT simple_ad_pthread.o -MD -MP -MF $(DEPDIR)/simple_ad_pthread.Tpo -c -o simple_ad_pthread.o `test -f 'pthread/simple_ad_pthread.cpp' \|\| echo '$(srcdir)/'`pthread/simple_ad_pthread.cpp
558		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/simple_ad_pthread.Tpo $(DEPDIR)/simple_ad_pthread.Po
559		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='pthread/simple_ad_pthread.cpp' object='simple_ad_pthread.o' libtool=no @AMDEPBACKSLASH@
560		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
561		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o simple_ad_pthread.o `test -f 'pthread/simple_ad_pthread.cpp' \|\| echo '$(srcdir)/'`pthread/simple_ad_pthread.cpp
562
563		simple_ad_pthread.obj: pthread/simple_ad_pthread.cpp
564		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT simple_ad_pthread.obj -MD -MP -MF $(DEPDIR)/simple_ad_pthread.Tpo -c -o simple_ad_pthread.obj `if test -f 'pthread/simple_ad_pthread.cpp'; then $(CYGPATH_W) 'pthread/simple_ad_pthread.cpp'; else $(CYGPATH_W) '$(srcdir)/pthread/simple_ad_pthread.cpp'; fi`
565		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/simple_ad_pthread.Tpo $(DEPDIR)/simple_ad_pthread.Po
566		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='pthread/simple_ad_pthread.cpp' object='simple_ad_pthread.obj' libtool=no @AMDEPBACKSLASH@
567		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
568		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o simple_ad_pthread.obj `if test -f 'pthread/simple_ad_pthread.cpp'; then $(CYGPATH_W) 'pthread/simple_ad_pthread.cpp'; else $(CYGPATH_W) '$(srcdir)/pthread/simple_ad_pthread.cpp'; fi`
569
570		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
571		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
572		unique=`for i in $$list; do \
573		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
574		done \| \
575		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
576		END { if (nonempty) { for (i in files) print i; }; }'`; \
577		mkid -fID $$unique
578		tags: TAGS
579
580		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
581		$(TAGS_FILES) $(LISP)
	557	ID: $(am__tagged_files)
	558	$(am__define_uniq_tagged_files); mkid -fID $$unique
	559	tags: tags-am
	560	TAGS: tags
	561
	562	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
582	563	set x; \
583	564	here=`pwd`; \
584		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
585		unique=`for i in $$list; do \
586		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
587		done \| \
588		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
589		END { if (nonempty) { for (i in files) print i; }; }'`; \
	565	$(am__define_uniq_tagged_files); \
590	566	shift; \
591	567	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
592	568	test -n "$$unique" \|\| unique=$$empty_fix; \

598	574	$$unique; \
599	575	fi; \
600	576	fi
601		ctags: CTAGS
602		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
603		$(TAGS_FILES) $(LISP)
604		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
605		unique=`for i in $$list; do \
606		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
607		done \| \
608		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
609		END { if (nonempty) { for (i in files) print i; }; }'`; \
	577	ctags: ctags-am
	578
	579	CTAGS: ctags
	580	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	581	$(am__define_uniq_tagged_files); \
610	582	test -z "$(CTAGS_ARGS)$$unique" \
611	583	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
612	584	$$unique

615	587	here=`$(am__cd) $(top_builddir) && pwd` \
616	588	&& $(am__cd) $(top_srcdir) \
617	589	&& gtags -i $(GTAGS_ARGS) "$$here"
	590	cscopelist: cscopelist-am
	591
	592	cscopelist-am: $(am__tagged_files)
	593	list='$(am__tagged_files)'; \
	594	case "$(srcdir)" in \
	595	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	596	*) sdir=$(subdir)/$(srcdir) ;; \
	597	esac; \
	598	for i in $$list; do \
	599	if test -f "$$i"; then \
	600	echo "$(subdir)/$$i"; \
	601	else \
	602	echo "$$sdir/$$i"; \
	603	fi; \
	604	done >> $(top_builddir)/cscope.files
618	605
619	606	distclean-tags:
620	607	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

680	667	distclean-generic:
681	668	-test -z "$(CONFIG_CLEAN_FILES)" \|\| rm -f $(CONFIG_CLEAN_FILES)
682	669	-test . = "$(srcdir)" \|\| test -z "$(CONFIG_CLEAN_VPATH_FILES)" \|\| rm -f $(CONFIG_CLEAN_VPATH_FILES)
	670	-rm -f bthread/$(DEPDIR)/$(am__dirstamp)
	671	-rm -f bthread/$(am__dirstamp)
	672	-rm -f openmp/$(DEPDIR)/$(am__dirstamp)
	673	-rm -f openmp/$(am__dirstamp)
	674	-rm -f pthread/$(DEPDIR)/$(am__dirstamp)
	675	-rm -f pthread/$(am__dirstamp)
683	676
684	677	maintainer-clean-generic:
685	678	@echo "This command is intended for maintainers to use"

689	682	clean-am: clean-checkPROGRAMS clean-generic mostlyclean-am
690	683
691	684	distclean: distclean-am
692		-rm -rf ./$(DEPDIR)
	685	-rm -rf ./$(DEPDIR) bthread/$(DEPDIR) openmp/$(DEPDIR) pthread/$(DEPDIR)
693	686	-rm -f makefile
694	687	distclean-am: clean-am distclean-compile distclean-generic \
695	688	distclean-tags

735	728	installcheck-am:
736	729
737	730	maintainer-clean: maintainer-clean-am
738		-rm -rf ./$(DEPDIR)
	731	-rm -rf ./$(DEPDIR) bthread/$(DEPDIR) openmp/$(DEPDIR) pthread/$(DEPDIR)
739	732	-rm -f makefile
740	733	maintainer-clean-am: distclean-am maintainer-clean-generic
741	734

755	748
756	749	.MAKE: check-am install-am install-strip
757	750
758		.PHONY: CTAGS GTAGS all all-am check check-am clean \
759		clean-checkPROGRAMS clean-generic ctags distclean \
760		distclean-compile distclean-generic distclean-tags distdir dvi \
761		dvi-am html html-am info info-am install install-am \
762		install-data install-data-am install-dvi install-dvi-am \
763		install-exec install-exec-am install-html install-html-am \
764		install-info install-info-am install-man install-pdf \
765		install-pdf-am install-ps install-ps-am install-strip \
766		installcheck installcheck-am installdirs maintainer-clean \
767		maintainer-clean-generic mostlyclean mostlyclean-compile \
768		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
769		uninstall-am
	751	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	752	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	753	distclean distclean-compile distclean-generic distclean-tags \
	754	distdir dvi dvi-am html html-am info info-am install \
	755	install-am install-data install-data-am install-dvi \
	756	install-dvi-am install-exec install-exec-am install-html \
	757	install-html-am install-info install-info-am install-man \
	758	install-pdf install-pdf-am install-ps install-ps-am \
	759	install-strip installcheck installcheck-am installdirs \
	760	maintainer-clean maintainer-clean-generic mostlyclean \
	761	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	762	tags tags-am uninstall uninstall-am
770	763
771	764	#
772	765	test: check

-8

multi_thread/openmp/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2564 2012-11-12 21:55:25Z bradbell $
	0	# $Id: CMakeLists.txt 3114 2014-02-22 16:20:39Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

25	25	# add_executable(<name> [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL]
26	26	# source1 source2 ... sourceN
27	27	# )
28		ADD_EXECUTABLE(openmp_test EXCLUDE_FROM_ALL ../thread_test.cpp
	28	ADD_EXECUTABLE(multi_thread_openmp EXCLUDE_FROM_ALL ../thread_test.cpp
29	29	../multi_newton_time.cpp
30	30	../multi_newton.cpp
31	31	../multi_newton_work.cpp

39	39	)
40	40
41	41	# Compiler flags for cppad source
42		add_cppad_cxx_flags( openmp_test )
	42	add_cppad_cxx_flags( multi_thread_openmp )
43	43
44	44	# Extra flags used by linker for openmp support
45	45	SET(CMAKE_EXE_LINKER_FLAGS ${OpenMP_CXX_FLAGS} )
46	46
47		# Add the check_openmp target
48		ADD_CUSTOM_TARGET(check_openmp
49		openmp_test simple_ad
50		DEPENDS openmp_test
	47	# Add the check_multi_thread_openmp target
	48	ADD_CUSTOM_TARGET(check_multi_thread_openmp
	49	multi_thread_openmp simple_ad
	50	DEPENDS multi_thread_openmp
51	51	)

-9

multi_thread/pthread/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2564 2012-11-12 21:55:25Z bradbell $
	0	# $Id: CMakeLists.txt 3114 2014-02-22 16:20:39Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

21	21	# add_executable(<name> [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL]
22	22	# source1 source2 ... sourceN
23	23	# )
24		ADD_EXECUTABLE(pthread_test EXCLUDE_FROM_ALL ../thread_test.cpp
	24	ADD_EXECUTABLE(multi_thread_pthread EXCLUDE_FROM_ALL ../thread_test.cpp
25	25	../multi_newton_time.cpp
26	26	../multi_newton.cpp
27	27	../multi_newton_work.cpp

35	35	)
36	36
37	37	# Compiler flags for cppad source
38		add_cppad_cxx_flags( pthread_test )
	38	add_cppad_cxx_flags( multi_thread_pthread )
39	39
40	40	# Paths in which the linker will search for libraries,
41	41	# only applies to targets created after it is called
42	42	LINK_DIRECTORIES( ${pthread_lib_path} )
43	43
44	44	# List of libraries to be linked into the specified target
45		TARGET_LINK_LIBRARIES(pthread_test ${pthread_lib})
	45	TARGET_LINK_LIBRARIES(multi_thread_pthread ${pthread_lib})
46	46
47		# Add the check_pthread target
48		ADD_CUSTOM_TARGET(check_pthread
49		pthread_test simple_ad
50		DEPENDS pthread_test
	47	# Add the check_multi_thread_pthread target
	48	ADD_CUSTOM_TARGET(check_multi_thread_pthread
	49	multi_thread_pthread simple_ad
	50	DEPENDS multi_thread_pthread
51	51	)

+144

-73

multi_thread/test_multi/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = test_multi$(EXEEXT)
51	80	subdir = multi_thread/test_multi
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

60	90	am_test_multi_OBJECTS = test_multi.$(OBJEXT) user_atomic.$(OBJEXT)
61	91	test_multi_OBJECTS = $(am_test_multi_OBJECTS)
62	92	test_multi_LDADD = $(LDADD)
	93	AM_V_P = $(am__v_P_@AM_V@)
	94	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	95	am__v_P_0 = false
	96	am__v_P_1 = :
	97	AM_V_GEN = $(am__v_GEN_@AM_V@)
	98	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	99	am__v_GEN_0 = @echo " GEN " $@;
	100	am__v_GEN_1 =
	101	AM_V_at = $(am__v_at_@AM_V@)
	102	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	103	am__v_at_0 = @
	104	am__v_at_1 =
63	105	DEFAULT_INCLUDES =
64	106	depcomp = $(SHELL) $(top_srcdir)/depcomp
65	107	am__depfiles_maybe = depfiles

68	110	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
69	111	AM_V_CXX = $(am__v_CXX_@AM_V@)
70	112	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
71		am__v_CXX_0 = @echo " CXX " $@;
72		AM_V_at = $(am__v_at_@AM_V@)
73		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
74		am__v_at_0 = @
	113	am__v_CXX_0 = @echo " CXX " $@;
	114	am__v_CXX_1 =
75	115	CXXLD = $(CXX)
76	116	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
77	117	-o $@
78	118	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
79	119	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
80		am__v_CXXLD_0 = @echo " CXXLD " $@;
81		AM_V_GEN = $(am__v_GEN_@AM_V@)
82		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
83		am__v_GEN_0 = @echo " GEN " $@;
	120	am__v_CXXLD_0 = @echo " CXXLD " $@;
	121	am__v_CXXLD_1 =
84	122	SOURCES = $(test_multi_SOURCES)
85	123	DIST_SOURCES = $(test_multi_SOURCES)
86	124	am__can_run_installinfo = \

88	126	n\|no\|NO) false;; \
89	127	*) (install-info --version) >/dev/null 2>&1;; \
90	128	esac
	129	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	130	# Read a list of newline-separated strings from the standard input,
	131	# and print each of them once, without duplicates. Input order is
	132	# not preserved.
	133	am__uniquify_input = $(AWK) '\
	134	BEGIN { nonempty = 0; } \
	135	{ items[$$0] = 1; nonempty = 1; } \
	136	END { if (nonempty) { for (i in items) print i; }; } \
	137	'
	138	# Make sure the list of sources is unique. This is necessary because,
	139	# e.g., the same source file might be shared among _SOURCES variables
	140	# for different programs/libraries.
	141	am__define_uniq_tagged_files = \
	142	list='$(am__tagged_files)'; \
	143	unique=`for i in $$list; do \
	144	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	145	done \| $(am__uniquify_input)`
91	146	ETAGS = etags
92	147	CTAGS = ctags
93	148	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

97	152	ADOLC_DIR = @ADOLC_DIR@
98	153	AMTAR = @AMTAR@
99	154	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	155	AR = @AR@
100	156	AUTOCONF = @AUTOCONF@
101	157	AUTOHEADER = @AUTOHEADER@
102	158	AUTOMAKE = @AUTOMAKE@

119	175	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
120	176	CYGPATH_W = @CYGPATH_W@
121	177
122		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	178	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
123	179	# -----------------------------------------------------------------------------
124	180	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
125	181	#

186	242	abs_srcdir = @abs_srcdir@
187	243	abs_top_builddir = @abs_top_builddir@
188	244	abs_top_srcdir = @abs_top_srcdir@
	245	ac_ct_AR = @ac_ct_AR@
189	246	ac_ct_CC = @ac_ct_CC@
190	247	ac_ct_CXX = @ac_ct_CXX@
191	248	ac_ct_FC = @ac_ct_FC@

196	253	am__tar = @am__tar@
197	254	am__untar = @am__untar@
198	255	bindir = @bindir@
	256	build = @build@
199	257	build_alias = @build_alias@
	258	build_cpu = @build_cpu@
	259	build_os = @build_os@
	260	build_vendor = @build_vendor@
200	261	builddir = @builddir@
201	262	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
202	263	cppad_boostvector = @cppad_boostvector@
203	264	cppad_cflags = @cppad_cflags@
	265	cppad_compiler_has_erf = @cppad_compiler_has_erf@
204	266	cppad_cppadvector = @cppad_cppadvector@
205	267	cppad_description = @cppad_description@
206	268	cppad_eigenvector = @cppad_eigenvector@
	269	cppad_has_colpack = @cppad_has_colpack@
	270	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
207	271	cppad_has_gettimeofday = @cppad_has_gettimeofday@
208	272	cppad_has_nullptr = @cppad_has_nullptr@
	273	cppad_has_rvalue = @cppad_has_rvalue@
209	274	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
210	275	cppad_internal_sparse_set = @cppad_internal_sparse_set@
211	276	cppad_libs = @cppad_libs@
212	277	cppad_max_num_threads = @cppad_max_num_threads@
213	278	cppad_requires = @cppad_requires@
214		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	279	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
215	280	cppad_stdvector = @cppad_stdvector@
216	281	cppad_tape_addr_type = @cppad_tape_addr_type@
217	282	cppad_tape_id_type = @cppad_tape_id_type@

223	288	dvidir = @dvidir@
224	289	eigen_prefix = @eigen_prefix@
225	290	exec_prefix = @exec_prefix@
226		have_ar = @have_ar@
227	291	have_pkg_config = @have_pkg_config@
	292	host = @host@
228	293	host_alias = @host_alias@
	294	host_cpu = @host_cpu@
	295	host_os = @host_os@
	296	host_vendor = @host_vendor@
229	297	htmldir = @htmldir@
230	298	includedir = @includedir@
231	299	infodir = @infodir@

307	375
308	376	clean-checkPROGRAMS:
309	377	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	378
310	379	test_multi$(EXEEXT): $(test_multi_OBJECTS) $(test_multi_DEPENDENCIES) $(EXTRA_test_multi_DEPENDENCIES)
311	380	@rm -f test_multi$(EXEEXT)
312	381	$(AM_V_CXXLD)$(CXXLINK) $(test_multi_OBJECTS) $(test_multi_LDADD) $(LIBS)

321	390	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/user_atomic.Po@am__quote@
322	391
323	392	.cpp.o:
324		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
325		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	393	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	394	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	395	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
326	396	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
327	397	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
328	398	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
329	399
330	400	.cpp.obj:
331		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
332		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	401	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	402	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	403	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
333	404	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
334	405	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
335	406	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
336	407
337		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
338		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
339		unique=`for i in $$list; do \
340		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
341		done \| \
342		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
343		END { if (nonempty) { for (i in files) print i; }; }'`; \
344		mkid -fID $$unique
345		tags: TAGS
346
347		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
348		$(TAGS_FILES) $(LISP)
	408	ID: $(am__tagged_files)
	409	$(am__define_uniq_tagged_files); mkid -fID $$unique
	410	tags: tags-am
	411	TAGS: tags
	412
	413	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
349	414	set x; \
350	415	here=`pwd`; \
351		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
352		unique=`for i in $$list; do \
353		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
354		done \| \
355		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
356		END { if (nonempty) { for (i in files) print i; }; }'`; \
	416	$(am__define_uniq_tagged_files); \
357	417	shift; \
358	418	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
359	419	test -n "$$unique" \|\| unique=$$empty_fix; \

365	425	$$unique; \
366	426	fi; \
367	427	fi
368		ctags: CTAGS
369		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
370		$(TAGS_FILES) $(LISP)
371		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
372		unique=`for i in $$list; do \
373		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
374		done \| \
375		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
376		END { if (nonempty) { for (i in files) print i; }; }'`; \
	428	ctags: ctags-am
	429
	430	CTAGS: ctags
	431	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	432	$(am__define_uniq_tagged_files); \
377	433	test -z "$(CTAGS_ARGS)$$unique" \
378	434	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
379	435	$$unique

382	438	here=`$(am__cd) $(top_builddir) && pwd` \
383	439	&& $(am__cd) $(top_srcdir) \
384	440	&& gtags -i $(GTAGS_ARGS) "$$here"
	441	cscopelist: cscopelist-am
	442
	443	cscopelist-am: $(am__tagged_files)
	444	list='$(am__tagged_files)'; \
	445	case "$(srcdir)" in \
	446	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	447	*) sdir=$(subdir)/$(srcdir) ;; \
	448	esac; \
	449	for i in $$list; do \
	450	if test -f "$$i"; then \
	451	echo "$(subdir)/$$i"; \
	452	else \
	453	echo "$$sdir/$$i"; \
	454	fi; \
	455	done >> $(top_builddir)/cscope.files
385	456
386	457	distclean-tags:
387	458	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

522	593
523	594	.MAKE: check-am install-am install-strip
524	595
525		.PHONY: CTAGS GTAGS all all-am check check-am clean \
526		clean-checkPROGRAMS clean-generic ctags distclean \
527		distclean-compile distclean-generic distclean-tags distdir dvi \
528		dvi-am html html-am info info-am install install-am \
529		install-data install-data-am install-dvi install-dvi-am \
530		install-exec install-exec-am install-html install-html-am \
531		install-info install-info-am install-man install-pdf \
532		install-pdf-am install-ps install-ps-am install-strip \
533		installcheck installcheck-am installdirs maintainer-clean \
534		maintainer-clean-generic mostlyclean mostlyclean-compile \
535		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
536		uninstall-am
	596	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	597	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	598	distclean distclean-compile distclean-generic distclean-tags \
	599	distdir dvi dvi-am html html-am info info-am install \
	600	install-am install-data install-data-am install-dvi \
	601	install-dvi-am install-exec install-exec-am install-html \
	602	install-html-am install-info install-info-am install-man \
	603	install-pdf install-pdf-am install-ps install-ps-am \
	604	install-strip installcheck installcheck-am installdirs \
	605	maintainer-clean maintainer-clean-generic mostlyclean \
	606	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	607	tags tags-am uninstall uninstall-am
537	608
538	609
539	610	test: check

-7

multi_thread/thread_test.cpp less more

0		/* $Id: thread_test.cpp 2683 2012-12-30 18:17:03Z bradbell $ */
	0	/* $Id: thread_test.cpp 3114 2014-02-22 16:20:39Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

32	32	$section Run Multi-Threading Examples and Speed Tests$$
33	33
34	34	$head Syntax$$
35		$codei%./%threading%_test a11c
36		./%threading%_test simple_ad
37		./%threading%_test team_example
38		./%threading%_test harmonic %test_time% %max_threads% %mega_sum%
39		./%threading%_test multi_newton %test_time% %max_threads% \
	35	$codei%./multi_thread_%threading% a11c
	36	./multi_thread_%threading% simple_ad
	37	./multi_thread_%threading% team_example
	38	./multi_thread_%threading% harmonic %test_time% %max_threads% %mega_sum%
	39	./multi_thread_%threading% multi_newton %test_time% %max_threads% \
40	40	%num_zero% %num_sub% %num_sum% %use_ad%
41	41	%$$
42	42

-115

~~omh/acos_forward.omh~~ less more

0		$Id: acos_forward.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin AcosForward$$
15		$spell
16		acos
17		Arccosine
18		Taylor
19		$$
20
21		$index acos, forward theory$$
22		$index theory, acos forward$$
23		$index forward, acos theory$$
24
25		$section Arccosine Function Forward Taylor Polynomial Theory$$
26
27		If $latex F(x) = \arccos(x) $$ it follows that
28		$latex \[
29		\sqrt{ 1 - x * x } * F^{(1)} (x) - 0 * F (u) = -1
30		\] $$
31		and in the
32		$xref/
33		ForwardTheory/
34		Standard Math Functions/
35		Differential Equation/
36		standard math function differential equation/
37		1
38		/$$,
39		$latex A(x) = 0$$,
40		$latex B(x) = \sqrt{1 - x * x }$$,
41		and $latex D(x) = -1$$.
42		We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the
43		Taylor coefficients for
44		$latex A [ X (t) ] $$,
45		$latex B [ X (t) ]$$,
46		$latex D [ X (t) ] $$,
47		and $latex F [ X(t) ] $$ respectively.
48		$pre
49
50		$$
51		We define $latex Q(x) = 1 - x * x$$
52		and let $latex q$$ be the corresponding Taylor coefficients for
53		$latex Q[ X(t) ]$$.
54		It follows that
55		$latex \[
56		q^{(j)} = \left\{ \begin{array}{ll}
57		1 - x^{(0)} * x^{(0)} & {\rm if} \; j = 0 \\
58		- \sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
59		\end{array} \right.
60		\] $$
61		It follows that
62		$latex B[ X(t) ] = \sqrt{ Q[ X(t) ] }$$ and
63		from the equations for the
64		$cref/square root/SqrtForward/$$
65		that for $latex j = 0 , 1, \ldots$$,
66		$latex \[
67		\begin{array}{rcl}
68		b^{(0)} & = & \sqrt{ q^{(0)} }
69		\\
70		b^{(j+1)} & = &
71		\frac{1}{j+1} \frac{1}{ b^{(0)} }
72		\left(
73		\frac{j+1}{2} q^{(j+1) }
74		- \sum_{k=1}^j k b^{(k)} b^{(j+1-k)}
75		\right)
76		\end{array}
77		\] $$
78		It now follows from the general
79		$xref/
80		ForwardTheory/
81		Standard Math Functions/
82		Taylor Coefficients Recursion Formula/
83		Taylor coefficients recursion formula/
84		1
85		/$$
86		that for $latex j = 0 , 1, \ldots$$,
87		$latex \[
88		\begin{array}{rcl}
89		z^{(0)} & = & \arccos ( x^{(0)} )
90		\\
91		e^{(j)}
92		& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
93		\\
94		& = & \left\{ \begin{array}{ll}
95		-1 & {\rm if} \; j = 0 \\
96		0 & {\rm otherwise}
97		\end{array} \right.
98		\\
99		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
100		\left(
101		\sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
102		- \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
103		\right)
104		\\
105		z^{(j+1)} & = & - \frac{1}{j+1} \frac{1}{ b^{(0)} }
106		\left(
107		(j+1) x^{(j+1)}
108		+ \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
109		\right)
110		\end{array}
111		\] $$
112
113
114		$end

-164

~~omh/acos_reverse.omh~~ less more

0		$Id: acos_reverse.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin AcosReverse$$
15		$spell
16		acos
17		Taylor
18		Arccosine
19		$$
20
21		$index acos, reverse theory$$
22		$index theory, acos reverse$$
23		$index reverse, acos theory$$
24
25		$section Arccosine Function Reverse Mode Theory$$
26
27
28		We use the reverse theory
29		$xref%
30		ReverseTheory%
31		Standard Math Functions%
32		standard math function
33		%$$
34		definition for the functions $latex H$$ and $latex G$$.
35		In addition,
36
37		we use $latex q$$ and $latex b$$
38		for the $th p$$ order Taylor coefficient
39		row vectors corresponding to functions
40		$latex \[
41		\begin{array}{rcl}
42		Q(t) & = & 1 - X(t) * X(t) \\
43		B(t) & = & \sqrt{ Q(t) }
44		\end{array}
45		\] $$
46		and replace $latex z^{(j)}$$ by
47		$latex \[
48		( z^{(j)} , b^{(j)} )
49		\] $$
50		in the definition for $latex G$$ and $latex H$$.
51		The forward mode formulas for the
52		$cref/acos/AcosForward/$$
53		function are
54		$latex \[
55		\begin{array}{rcl}
56		q^{(0)} & = & 1 - x^{(0)} x^{(0)} \\
57		b^{(j)} & = & \sqrt{ q^{(0)} } \\
58		z^{(j)} & = & \arccos ( x^{(0)} )
59		\end{array}
60		\] $$
61
62		for the case $latex j = 0$$, and for $latex j > 0$$,
63
64		$latex \[
65		\begin{array}{rcl}
66		q^{(j)} & = &
67		- \sum_{k=0}^j x^{(k)} x^{(j-k)}
68		\\
69		b^{(j)} & = &
70		\frac{1}{j} \frac{1}{ b^{(0)} }
71		\left(
72		\frac{j}{2} q^{(j)}
73		- \sum_{k=1}^{j-1} k b^{(k)} b^{(j-k)}
74		\right)
75		\\
76		z^{(j)} & = & - \frac{1}{j} \frac{1}{ b^{(0)} }
77		\left(
78		j x^{(j)}
79		+ \sum_{k=1}^{j-1} k z^{(k)} b^{(j-k)}
80		\right)
81		\end{array}
82		\] $$
83
84		If $latex j = 0$$, we have the relation
85
86		$latex \[
87		\begin{array}{rcl}
88		\D{H}{ x^{(j)} } & = &
89		\D{G}{ x^{(0)} }
90		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
91		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(0)} } \D{ q^{(0)} }{ x^{(0)} }
92		\\
93		& = &
94		\D{G}{ x^{(j)} }
95		- \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
96		- \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
97		\end{array}
98		\] $$
99
100		If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
101
102		$latex \[
103		\begin{array}{rcl}
104		\D{H}{ b^{(0)} } & = &
105		\D{G}{ b^{(0)} }
106		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(0)} }
107		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(0)} }
108		\\
109		& = &
110		\D{G}{ b^{(0)} }
111		- \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} }
112		- \D{G}{ b^{(j)} } \frac{ b^{(j)} }{ b^{(0)} }
113		\\
114		\D{H}{ x^{(0)} } & = &
115		\D{G}{ x^{(0)} }
116		+
117		\D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(0)} }
118		\\
119		& = &
120		\D{G}{ x^{(0)} }
121		- \D{G}{ b^{(j)} } \frac{ x^{(j)} }{ b^{(0)} }
122		\\
123		\D{H}{ x^{(j)} } & = &
124		\D{G}{ x^{(j)} }
125		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
126		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(j)} }
127		\\
128		& = &
129		\D{G}{ x^{(j)} }
130		- \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
131		- \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
132		\\
133		\D{H}{ b^{(j - k)} } & = &
134		\D{G}{ b^{(j - k)} }
135		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(j - k)} }
136		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(j - k)} }
137		\\
138		& = &
139		\D{G}{ b^{(j - k)} }
140		- \D{G}{ z^{(j)} } \frac{k z^{(k)} }{j b^{(0)} }
141		- \D{G}{ b^{(j)} } \frac{ b^{(k)} }{ b^{(0)} }
142		\\
143		\D{H}{ x^{(k)} } & = &
144		\D{G}{ x^{(k)} }
145		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
146		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(k)} }
147		\\
148		& = &
149		\D{G}{ x^{(k)} }
150		- \D{G}{ b^{(j)} } \frac{ x^{(j-k)} }{ b^{(0)} }
151		\\
152		\D{H}{ z^{(k)} } & = &
153		\D{G}{ z^{(k)} }
154		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
155		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ z^{(k)} }
156		\\
157		& = &
158		\D{G}{ z^{(k)} }
159		- \D{G}{ z^{(j)} } \frac{k b^{(j-k)} }{ j b^{(0)} }
160		\end{array}
161		\] $$
162
163		$end

-3

omh/appendix.omh less more

0		$Id: appendix.omh 2683 2012-12-30 18:17:03Z bradbell $
	0	$Id: appendix.omh 3169 2014-03-09 13:37:59Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

17	17
18	18	$childtable%
19	19	omh/faq.omh%
20		omh/theory.omh%
	20	omh/theory/theory.omh%
21	21	omh/glossary.omh%
22	22	omh/bib.omh%
23	23	omh/bugs.omh%

-115

~~omh/asin_forward.omh~~ less more

0		$Id: asin_forward.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin AsinForward$$
15		$spell
16		asin
17		Arcsine
18		Taylor
19		$$
20
21		$index asin, forward theory$$
22		$index theory, asin forward$$
23		$index forward, asin theory$$
24
25		$section Arcsine Function Forward Taylor Polynomial Theory$$
26
27		If $latex F(x) = \arcsin(x) $$ it follows that
28		$latex \[
29		\sqrt{ 1 - x * x } * F^{(1)} (x) - 0 * F (u) = 1
30		\] $$
31		and in the
32		$xref/
33		ForwardTheory/
34		Standard Math Functions/
35		Differential Equation/
36		standard math function differential equation/
37		1
38		/$$,
39		$latex A(x) = 0$$,
40		$latex B(x) = \sqrt{1 - x * x }$$,
41		and $latex D(x) = 1$$.
42		We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the
43		Taylor coefficients for
44		$latex A [ X (t) ] $$,
45		$latex B [ X (t) ]$$,
46		$latex D [ X (t) ] $$,
47		and $latex F [ X(t) ] $$ respectively.
48		$pre
49
50		$$
51		We define $latex Q(x) = 1 - x * x$$
52		and let $latex q$$ be the corresponding Taylor coefficients for
53		$latex Q[ X(t) ]$$.
54		It follows that
55		$latex \[
56		q^{(j)} = \left\{ \begin{array}{ll}
57		1 - x^{(0)} * x^{(0)} & {\rm if} \; j = 0 \\
58		- \sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
59		\end{array} \right.
60		\] $$
61		It follows that
62		$latex B[ X(t) ] = \sqrt{ Q[ X(t) ] }$$ and
63		from the equations for the
64		$cref/square root/SqrtForward/$$
65		that for $latex j = 0 , 1, \ldots$$,
66		$latex \[
67		\begin{array}{rcl}
68		b^{(0)} & = & \sqrt{ q^{(0)} }
69		\\
70		b^{(j+1)} & = &
71		\frac{1}{j+1} \frac{1}{ b^{(0)} }
72		\left(
73		\frac{j+1}{2} q^{(j+1) }
74		- \sum_{k=1}^j k b^{(k)} b^{(j+1-k)}
75		\right)
76		\end{array}
77		\] $$
78		It now follows from the general
79		$xref/
80		ForwardTheory/
81		Standard Math Functions/
82		Taylor Coefficients Recursion Formula/
83		Taylor coefficients recursion formula/
84		1
85		/$$
86		that for $latex j = 0 , 1, \ldots$$,
87		$latex \[
88		\begin{array}{rcl}
89		z^{(0)} & = & \arcsin ( x^{(0)} )
90		\\
91		e^{(j)}
92		& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
93		\\
94		& = & \left\{ \begin{array}{ll}
95		1 & {\rm if} \; j = 0 \\
96		0 & {\rm otherwise}
97		\end{array} \right.
98		\\
99		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
100		\left(
101		\sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
102		- \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
103		\right)
104		\\
105		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
106		\left(
107		(j+1) x^{(j+1)}
108		- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
109		\right)
110		\end{array}
111		\] $$
112
113
114		$end

-164

~~omh/asin_reverse.omh~~ less more

0		$Id: asin_reverse.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin AsinReverse$$
15		$spell
16		asin
17		Taylor
18		Arcsine
19		$$
20
21		$index asin, reverse theory$$
22		$index theory, asin reverse$$
23		$index reverse, asin theory$$
24
25		$section Arcsine Function Reverse Mode Theory$$
26
27
28		We use the reverse theory
29		$xref%
30		ReverseTheory%
31		Standard Math Functions%
32		standard math function
33		%$$
34		definition for the functions $latex H$$ and $latex G$$.
35		In addition,
36
37		we use $latex q$$ and $latex b$$
38		for the $th p$$ order Taylor coefficient
39		row vectors corresponding to functions
40		$latex \[
41		\begin{array}{rcl}
42		Q(t) & = & 1 - X(t) * X(t) \\
43		B(t) & = & \sqrt{ Q(t) }
44		\end{array}
45		\] $$
46		and replace $latex z^{(j)}$$ by
47		$latex \[
48		( z^{(j)} , b^{(j)} )
49		\] $$
50		in the definition for $latex G$$ and $latex H$$.
51		The forward mode formulas for the
52		$cref/asin/AsinForward/$$
53		function are
54		$latex \[
55		\begin{array}{rcl}
56		q^{(0)} & = & 1 - x^{(0)} x^{(0)} \\
57		b^{(j)} & = & \sqrt{ q^{(0)} } \\
58		z^{(j)} & = & \arcsin ( x^{(0)} )
59		\end{array}
60		\] $$
61
62		for the case $latex j = 0$$, and for $latex j > 0$$,
63
64		$latex \[
65		\begin{array}{rcl}
66		q^{(j)} & = &
67		- \sum_{k=0}^j x^{(k)} x^{(j-k)}
68		\\
69		b^{(j)} & = &
70		\frac{1}{j} \frac{1}{ b^{(0)} }
71		\left(
72		\frac{j}{2} q^{(j)}
73		- \sum_{k=1}^{j-1} k b^{(k)} b^{(j-k)}
74		\right)
75		\\
76		z^{(j)} & = & \frac{1}{j} \frac{1}{ b^{(0)} }
77		\left(
78		j x^{(j)}
79		- \sum_{k=1}^{j-1} k z^{(k)} b^{(j-k)}
80		\right)
81		\end{array}
82		\] $$
83
84		If $latex j = 0$$, we have the relation
85
86		$latex \[
87		\begin{array}{rcl}
88		\D{H}{ x^{(j)} } & = &
89		\D{G}{ x^{(0)} }
90		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
91		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(0)} } \D{ q^{(0)} }{ x^{(0)} }
92		\\
93		& = &
94		\D{G}{ x^{(j)} }
95		+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
96		- \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
97		\end{array}
98		\] $$
99
100		If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
101
102		$latex \[
103		\begin{array}{rcl}
104		\D{H}{ b^{(0)} } & = &
105		\D{G}{ b^{(0)} }
106		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(0)} }
107		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(0)} }
108		\\
109		& = &
110		\D{G}{ b^{(0)} }
111		- \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} }
112		- \D{G}{ b^{(j)} } \frac{ b^{(j)} }{ b^{(0)} }
113		\\
114		\D{H}{ x^{(0)} } & = &
115		\D{G}{ x^{(0)} }
116		+
117		\D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(0)} }
118		\\
119		& = &
120		\D{G}{ x^{(0)} }
121		- \D{G}{ b^{(j)} } \frac{ x^{(j)} }{ b^{(0)} }
122		\\
123		\D{H}{ x^{(j)} } & = &
124		\D{G}{ x^{(j)} }
125		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
126		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(j)} }
127		\\
128		& = &
129		\D{G}{ x^{(j)} }
130		+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
131		- \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
132		\\
133		\D{H}{ b^{(j - k)} } & = &
134		\D{G}{ b^{(j - k)} }
135		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(j - k)} }
136		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(j - k)} }
137		\\
138		& = &
139		\D{G}{ b^{(j - k)} }
140		- \D{G}{ z^{(j)} } \frac{k z^{(k)} }{j b^{(0)} }
141		- \D{G}{ b^{(j)} } \frac{ b^{(k)} }{ b^{(0)} }
142		\\
143		\D{H}{ x^{(k)} } & = &
144		\D{G}{ x^{(k)} }
145		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
146		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(k)} }
147		\\
148		& = &
149		\D{G}{ x^{(k)} }
150		- \D{G}{ b^{(j)} } \frac{ x^{(j-k)} }{ b^{(0)} }
151		\\
152		\D{H}{ z^{(k)} } & = &
153		\D{G}{ z^{(k)} }
154		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
155		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ z^{(k)} }
156		\\
157		& = &
158		\D{G}{ z^{(k)} }
159		- \D{G}{ z^{(j)} } \frac{k b^{(j-k)} }{ j b^{(0)} }
160		\end{array}
161		\] $$
162
163		$end

-90

~~omh/atan_forward.omh~~ less more

0		$Id: atan_forward.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin AtanForward$$
15		$spell
16		atan
17		Arctangent
18		Taylor
19		$$
20
21		$index atan, forward theory$$
22		$index theory, atan forward$$
23		$index forward, atan theory$$
24
25		$section Arctangent Function Forward Taylor Polynomial Theory$$
26
27		If $latex F(x) = \arctan(x) $$
28		$latex \[
29		(1 + x * x ) * F^{(1)} (x) - 0 * F (x) = 1
30		\] $$
31		and in the
32		$xref/
33		ForwardTheory/
34		Standard Math Functions/
35		Differential Equation/
36		standard math function differential equation/
37		1
38		/$$,
39		$latex A(x) = 0$$,
40		$latex B(x) = 1 + x * x $$,
41		and $latex D(x) = 1$$.
42		We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the
43		Taylor coefficients for
44		$latex A [ X (t) ] $$,
45		$latex B [ X (t) ]$$,
46		$latex D [ X (t) ] $$,
47		and $latex F [ X(t) ] $$ respectively.
48		It now follows from the general
49		$xref/
50		ForwardTheory/
51		Standard Math Functions/
52		Taylor Coefficients Recursion Formula/
53		Taylor coefficients recursion formula/
54		1
55		/$$
56		that for $latex j = 0 , 1, \ldots$$,
57		$latex \[
58		\begin{array}{rcl}
59		z^{(0)} & = & \arctan ( x^{(0)} )
60		\\
61		b^{(j)}
62		& = & \left\{ \begin{array}{ll}
63		1 + x^{(0)} * x^{(0)} & {\rm if} \; j = 0 \\
64		\sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
65		\end{array} \right.
66		\\
67		e^{(j)}
68		& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
69		\\
70		& = & \left\{ \begin{array}{ll}
71		1 & {\rm if} \; j = 0 \\
72		0 & {\rm otherwise}
73		\end{array} \right.
74		\\
75		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
76		\left(
77		\sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
78		- \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
79		\right)
80		\\
81		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
82		\left(
83		(j+1) x^{(j+1)}
84		- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
85		\right)
86		\end{array}
87		\] $$
88
89		$end

-148

~~omh/atan_reverse.omh~~ less more

0		$Id: atan_reverse.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin AtanReverse$$
15		$spell
16		Arctangent
17		atan
18		Taylor
19		$$
20
21		$index atan, reverse theory$$
22		$index theory, atan reverse$$
23		$index reverse, atan theory$$
24
25		$section Arctangent Function Reverse Mode Theory$$
26
27
28		We use the reverse theory
29		$xref%
30		ReverseTheory%
31		Standard Math Functions%
32		standard math function
33		%$$
34		definition for the functions $latex H$$ and $latex G$$.
35		In addition,
36
37		we use $latex b$$
38		for the $th p$$ order Taylor coefficient
39		row vectors corresponding to
40		$latex 1 + X(t) * X(t)$$
41		and replace $latex z^{(j)}$$ by
42		$latex \[
43		( z^{(j)} , b^{(j)} )
44		\] $$
45		in the definition for $latex G$$ and $latex H$$.
46		The forward mode formulas for the
47		$cref/arctangent/AtanForward/$$
48		function are
49		$latex \[
50		\begin{array}{rcl}
51		z^{(j)} & = & \arctan ( x^{(0)} ) \\
52		b^{(j)} & = & 1 + x^{(0)} x^{(0)}
53		\end{array}
54		\] $$
55
56		for the case $latex j = 0$$, and for $latex j > 0$$,
57
58		$latex \[
59		\begin{array}{rcl}
60		b^{(j)} & = &
61		\sum_{k=0}^j x^{(k)} x^{(j-k)}
62		\\
63		z^{(j)} & = & \frac{1}{j} \frac{1}{ b^{(0)} }
64		\left(
65		j x^{(j)}
66		- \sum_{k=1}^{j-1} k z^{(k)} b^{(j-k)}
67		\right)
68		\end{array}
69		\] $$
70
71		If $latex j = 0$$, we have the relation
72
73		$latex \[
74		\begin{array}{rcl}
75		\D{H}{ x^{(j)} } & = &
76		\D{G}{ x^{(j)} }
77		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
78		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(0)} }
79		\\
80		& = &
81		\D{G}{ x^{(j)} }
82		+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
83		+ \D{G}{ b^{(j)} } 2 x^{(0)}
84		\end{array}
85		\] $$
86
87		If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
88
89		$latex \[
90		\begin{array}{rcl}
91		\D{H}{ b^{(0)} } & = &
92		\D{G}{ b^{(0)} }
93		- \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(0)} }
94		\\
95		& = &
96		\D{G}{ b^{(0)} }
97		- \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} }
98		\\
99		\D{H}{ x^{(j)} } & = &
100		\D{G}{ x^{(j)} }
101		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
102		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(j)} }
103		\\
104		& = &
105		\D{G}{ x^{(j)} }
106		+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
107		+ \D{G}{ b^{(j)} } 2 x^{(0)}
108		\\
109		\D{H}{ x^{(0)} } & = &
110		\D{G}{ x^{(0)} }
111		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
112		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(0)} }
113		\\
114		& = &
115		\D{G}{ x^{(0)} } +
116		\D{G}{ b^{(j)} } 2 x^{(j)}
117		\\
118		\D{H}{ x^{(k)} } & = &
119		\D{G}{ x^{(k)} }
120		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
121		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(k)} }
122		\\
123		& = &
124		\D{G}{ x^{(k)} }
125		+ \D{G}{ b^{(j)} } 2 x^{(j-k)}
126		\\
127		\D{H}{ z^{(k)} } & = &
128		\D{G}{ z^{(k)} }
129		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
130		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ z^{(k)} }
131		\\
132		& = &
133		\D{G}{ z^{(k)} }
134		- \D{G}{ z^{(j)} } \frac{k b^{(j-k)} }{ j b^{(0)} }
135		\\
136		\D{H}{ b^{(j-k)} } & = &
137		\D{G}{ b^{(j-k)} }
138		+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(j-k)} }
139		+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(j-k)} }
140		\\
141		& = &
142		\D{G}{ b^{(j-k)} }
143		- \D{G}{ z^{(j)} } \frac{k z^{(k)} }{ j b^{(0)} }
144		\end{array}
145		\] $$
146
147		$end

+11

-6

omh/atomic_base.omh less more

0		/* $Id: atomic_base.omh 3012 2013-11-27 22:00:48Z bradbell $ */
	0	/* $Id: atomic_base.omh 3505 2014-12-26 15:06:54Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

39	39	$codei%
40	40	%atomic_user% %afun%(%n%, %m%, %use_set%, %user_arg_list%)
41	41	%afun%(%ax%, %ay%)
42		%ok% = %afun%.forward(%q%, %p%, %vx%, %vy%, %tx%, %ty%)
43		%ok% = %afun%.reverse(%p%, %tx%, %ty%, %px%, %py%)
	42	%ok% = %afun%.forward(%p%, %q%, %vx%, %vy%, %tx%, %ty%)
	43	%ok% = %afun%.reverse(%q%, %tx%, %ty%, %px%, %py%)
44	44	%ok% = %afun%.for_sparse_jac(%q%, %r%, %s%)
45	45	%ok% = %afun%.rev_sparse_jac(%q%, %r%, %s%)
46	46	%ok% = %afun%.rev_sparse_hes(%vx%, %s%, %t%, %q%, %r%, %u%, %v%)

69	69	These virtual functions have a default implementation
70	70	that returns $icode%ok% == false%$$.
71	71	The $code forward$$ function,
72		for the case $icode%p% == 0%$$, must be implemented.
	72	for the case $icode%q% == 0%$$, must be implemented.
73	73	Otherwise, only those functions
74	74	required by the your calculations need to be implemented.
75	75	For example,
76		$icode forward$$ for the case $icode%p% == 2%$$ can just return
	76	$icode forward$$ for the case $icode%q% == 2%$$ can just return
77	77	$icode%ok% == false%$$ unless you require
78	78	forward mode calculation of second derivatives.
79	79

83	83	example/atomic/norm_sq.cpp%
84	84	example/atomic/reciprocal.cpp%
85	85	example/atomic/tangent.cpp%
	86	example/atomic/hes_sparse.cpp%
86	87	example/atomic/mat_mul.cpp
87	88	%$$
88	89

103	104	where the user provides the code for computing derivatives.
104	105	This example is more complex because the range has two components.
105	106
	107	$subhead Hessian Sparsity Patterns$$
	108	The file $cref atomic_hes_sparse.cpp$$ contains an minimal example
	109	where the user provides the code for computing Hessian sparsity patterns.
	110
106	111	$head General Case$$
107	112	The file $cref atomic_mat_mul.cpp$$ contains a more general example
108	113	where the user provides the code for computing derivatives.

-3

omh/check_for_nan.omh less more

0		$Id: check_for_nan.omh 2892 2013-08-13 17:30:55Z bradbell $
	0	$Id: check_for_nan.omh 3214 2014-03-18 20:50:38Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

28	28
29	29	$head Purpose$$
30	30	If $code NDEBUG$$ is not defined and
31		the result of a $cref/forward/ForwardAny/$$ or $cref/reverse/reverse_any/$$
	31	the result of a $cref/forward/forward_order/$$ or $cref/reverse/reverse_any/$$
32	32	calculation contains a $cref nan$$,
33	33	CppAD halts with an error message.
34	34	This can be suppressed using $code check_for_nan$$.

54	54	Future calls to $icode%f%.Forward%$$ will (will not) check for $code nan$$.
55	55	depending on if $icode b$$ is true (false).
56	56
	57	$head Default$$
	58	The value for this setting after construction of $icode f$$) is true.
	59	The value of this setting is not affected by calling
	60	$cref Dependent$$ for this function object.
	61
57	62	$head Example$$
58	63	$children%
59	64	example/check_for_nan.cpp

+35

-7

omh/deprecated/fun_deprecated.omh less more

0		$Id: fun_deprecated.omh 2652 2012-12-27 03:54:50Z bradbell $
	0	$Id: fun_deprecated.omh 3214 2014-03-18 20:50:38Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

33	33	$icode%t% = %f%.taylor_size()
34	34	%$$
35	35	$icode%u% = %f%.use_VecAD()
	36	%$$
	37	$icode%v% = %f%.size_taylor()
	38	%$$
	39	$icode%w% = %f%.capacity_taylor()
36	40	%$$
37	41
38	42

81	85	In the future, we would like to be able to erase the function
82	86	values so that $icode f$$ uses less memory.
83	87	In this case, the return value of $code Order$$ would not make sense.
84		Use $cref size_taylor$$ to obtain
	88	Use $cref size_order$$ to obtain
85	89	the number of Taylor coefficients currently stored
86	90	in the ADFun object $icode f$$
87	91	(which is equal to the order plus one).

135	139	$codei%
136	140	size_t %t%
137	141	%$$
138		and is the number of Taylor coefficients,
139		per variable in the AD operation sequence,
	142	and is the number of Taylor coefficient orders
140	143	currently calculated and stored in the ADFun object $icode f$$.
141	144
142	145	$subhead Deprecated$$
143		For the purpose of uniform naming,
144		this function has been replaced by $cref size_taylor$$.
	146	This function has been replaced by $cref size_order$$.
145	147
146	148	$head use_VecAD$$
147	149	$index ADFun, use_VecAD$$

163	165	%u% = %f%.size_VecAD() > 0
164	166	%$$
165	167
	168	$head size_taylor$$
	169	$index ADFun, size_taylor$$
	170	$index size_taylor, ADFun$$
	171	The result $icode v$$ has prototype
	172	$codei%
	173	size_t %v%
	174	%$$
	175	and is the number of Taylor coefficient orders
	176	currently calculated and stored in the ADFun object $icode f$$.
	177
	178	$subhead Deprecated$$
	179	This function has been replaced by $cref size_order$$.
	180
	181	$head capacity_taylor$$
	182	$index ADFun, capacity_taylor$$
	183	$index capacity_taylor, ADFun$$
	184	The result $icode w$$ has prototype
	185	$codei%
	186	size_t %w%
	187	%$$
	188	and is the number of Taylor coefficient orders currently allocated
	189	in the ADFun object $icode f$$.
	190
	191	$subhead Deprecated$$
	192	This function has been replaced by $cref capacity_order$$.
	193
166	194
167	195	$end

-4

omh/example_list.omh less more

0		$Id: example_list.omh 3012 2013-11-27 22:00:48Z bradbell $
	0	$Id: example_list.omh 3301 2014-05-24 05:20:21Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

105	105	$rref base_require.cpp$$
106	106	$rref bender_quad.cpp$$
107	107	$rref bool_fun.cpp$$
108		$rref capacity_taylor.cpp$$
	108	$rref capacity_order.cpp$$
109	109	$rref change_const.cpp$$
110	110	$rref check_for_nan.cpp$$
111	111	$rref check_numeric_type.cpp$$
112	112	$rref check_simple_vector.cpp$$
113	113	$rref checkpoint.cpp$$
	114	$rref colpack.cpp$$
114	115	$rref compare_change.cpp$$
115	116	$rref compare.cpp$$
116	117	$rref complex_poly.cpp$$

135	136	$rref for_sparse_jac.cpp$$
136	137	$rref for_two.cpp$$
137	138	$rref forward.cpp$$
138		$rref forward_mul.cpp$$
	139	$rref forward_dir.cpp$$
	140	$rref forward_order.cpp$$
139	141	$rref fun_assign.cpp$$
140	142	$rref fun_check.cpp$$
141	143	$rref get_started.cpp$$

-78

~~omh/exp_forward.omh~~ less more

0		$Id: exp_forward.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin ExpForward$$
15		$spell
16		exp
17		Taylor
18		$$
19
20		$index exp, forward theory$$
21		$index theory, exp forward$$
22		$index forward, exp theory$$
23
24		$section Exponential Function Forward Taylor Polynomial Theory$$
25
26		If $latex F(x) = \exp(x) $$
27		$latex \[
28		1 * F^{(1)} (x) - 1 * F (x) = 0
29		\] $$
30		and in the
31		$xref/
32		ForwardTheory/
33		Standard Math Functions/
34		Differential Equation/
35		standard math function differential equation/
36		1
37		/$$,
38		$latex A(x) = 1$$,
39		$latex B(x) = 1$$,
40		and $latex D(x) = 0$$.
41		We use $latex a$$, $latex b$$, $latex d$$,
42		and $latex z$$ to denote the
43		Taylor coefficients for
44		$latex A [ X (t) ] $$,
45		$latex B [ X (t) ]$$,
46		$latex D [ X (t) ] $$,
47		and $latex F [ X(t) ] $$ respectively.
48		It now follows from the general
49		$xref/
50		ForwardTheory/
51		Standard Math Functions/
52		Taylor Coefficients Recursion Formula/
53		Taylor coefficients recursion formula/
54		1
55		/$$
56		that for $latex j = 0 , 1, \ldots$$,
57		$latex \[
58		\begin{array}{rcl}
59		z^{(0)} & = & \exp ( x^{(0)} )
60		\\
61		e^{(j)}
62		& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
63		\\
64		& = & z^{(j)}
65		\\
66		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
67		\left(
68		\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
69		- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
70		\right)
71		\\
72		& = & \frac{1}{j+1}
73		\sum_{k=1}^{j+1} k x^{(k)} z^{(j+1-k)}
74		\end{array}
75		\] $$
76
77		$end

-68

~~omh/exp_reverse.omh~~ less more

0		$Id: exp_reverse.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin ExpReverse$$
15		$spell
16		Taylor
17		exp
18		$$
19
20		$index exp, reverse theory$$
21		$index theory, exp reverse$$
22		$index reverse, exp theory$$
23
24		$section Exponential Function Reverse Mode Theory$$
25
26		We use the reverse theory
27		$xref%
28		ReverseTheory%
29		Standard Math Functions%
30		standard math function
31		%$$
32		definition for the functions $latex H$$ and $latex G$$.
33
34		The forward mode formulas for the
35		$cref/exponential/ExpForward/$$
36		function are
37		$latex \[
38		z^{(j)} = \exp ( x^{(0)} )
39		\] $$
40		if $latex j = 0$$, and
41		$latex \[
42		z^{(j)} = \frac{1}{j}
43		\sum_{k=1}^{j} k x^{(k)} z^{(j-k)}
44		\] $$
45
46		for the case $latex j = 0$$, and for $latex j > 0$$,
47
48		$latex \[
49		\begin{array}{rcl}
50		\D{H}{ x^{(j)} } & = &
51		\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } z^{(j)}
52		\end{array}
53		\] $$
54
55		If $latex j > 0$$, then for $latex k = 1 , \ldots , j$$
56
57		$latex \[
58		\begin{array}{rcl}
59		\D{H}{ x^{(k)} } & = &
60		\D{G}{ x^{(k)} } + \D{G}{ z^{(j)} } \frac{1}{j} k z^{(j-k)}
61		\\
62		\D{H}{ z^{(j-k)} } & = &
63		\D{G}{ z^{(j-k)} } + \D{G}{ z^{(j)} } \frac{1}{j} k x^{(k)}
64		\end{array}
65		\] $$
66
67		$end

-3

omh/faq.omh less more

0		$Id: faq.omh 2506 2012-10-24 19:36:49Z bradbell $
	0	$Id: faq.omh 3170 2014-03-09 14:33:53Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

137	137	$pre
138	138
139	139	$$
140		Yes (see $cref ForwardZero$$).
	140	Yes (see $cref forward_zero$$).
141	141
142	142	$head Math Functions$$
143	143	$index math, functions$$

+99

-0

omh/forward/compare_change.omh less more

	0	/* $Id: compare_change.omh 3173 2014-03-09 17:09:49Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin CompareChange$$
	12	$spell
	13	const
	14	$$
	15
	16	$section Comparison Changes During Zero Order Forward Mode$$
	17
	18	$index ADFun, CompareChange$$
	19	$index CompareChange, ADFun$$
	20	$index zero, order forward$$
	21	$index forward, zero order$$
	22
	23	$head Syntax$$
	24	$icode%c% = %f%.CompareChange()%$$
	25	$pre
	26	$$
	27	$bold See Also$$
	28	$cref FunCheck$$
	29
	30
	31	$head Purpose$$
	32	We use $latex F : B^n \rightarrow B^m$$ to denote the
	33	$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
	34	This function may be not agree with the algorithm that was used
	35	to create the corresponding
	36	AD of $icode Base$$
	37	$cref/operation sequence/glossary/Operation/Sequence/$$
	38	because of changes in AD
	39	$cref/comparison/Compare/$$ results.
	40	The $code CompareChange$$ function can be used to detect these changes.
	41
	42	$head f$$
	43	The object $icode f$$ has prototype
	44	$codei%
	45	const ADFun<%Base%> %f%
	46	%$$
	47
	48	$head c$$
	49	The result $icode c$$ has prototype
	50	$codei%
	51	size_t %c%
	52	%$$
	53	It is the number of
	54	$codei%AD<%Base%>%$$ $cref/comparison/Compare/$$
	55	operations,
	56	corresponding to the previous call to $cref Forward$$
	57	$codei%
	58	%f%.Forward(0, %x%)
	59	%$$
	60	that have a different result from
	61	when $icode F$$ was created by taping an algorithm.
	62
	63	$head Discussion$$
	64	If $icode c$$ is not zero,
	65	the boolean values resulting from some of the
	66	$cref/comparison operations/Compare/$$ corresponding to $icode x$$
	67	are different from when the
	68	AD of $icode Base$$
	69	$cref/operation sequence/glossary/Operation/Sequence/$$ was created.
	70	In this case, you may want to re-tape the algorithm with the
	71	$cref/independent variables/glossary/Tape/Independent Variable/$$
	72	equal to the values in $icode x$$
	73	(so AD operation sequence properly represents the algorithm
	74	for this value of independent variables).
	75	On the other hand, re-taping the AD operation sequence usually takes
	76	significantly more time than evaluation using $cref forward_zero$$.
	77	If the functions values have not changed (see $cref FunCheck$$)
	78	it may not be worth re-taping a new AD operation sequence.
	79
	80	$head Restrictions$$
	81	$index NDEBUG, CompareChange$$
	82	Computation of this function requires extra operations in the tape.
	83	If $cref/NDEBUG/Faq/Speed/NDEBUG/$$ is defined,
	84	of if a tape $cref/optimization/optimize/$$ has been preformed,
	85	these operations are not included in the tape and
	86	the value of $icode c$$ is always zero (and does not correspond
	87	to the actual number of comparison changes).
	88
	89	$head Example$$
	90	$children%
	91	example/compare_change.cpp
	92	%$$
	93	The file
	94	$cref compare_change.cpp$$
	95	contains an example and test of this operation.
	96	They return true if they succeed and false otherwise.
	97
	98	$end

+28

-0

omh/forward/forward.omh less more

	0	/* $Id: forward.omh 3301 2014-05-24 05:20:21Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin Forward$$
	12
	13	$section Forward Mode$$
	14
	15	$childtable%
	16	omh/forward/forward_zero.omh%
	17	omh/forward/forward_one.omh%
	18	omh/forward/forward_two.omh%
	19	omh/forward/forward_order.omh%
	20	omh/forward/forward_dir.omh%
	21	omh/forward/size_order.omh%
	22	omh/forward/compare_change.omh%
	23	cppad/local/capacity_order.hpp%
	24	cppad/local/num_skip.hpp
	25	%$$
	26
	27	$end

+202

-0

omh/forward/forward_dir.omh less more

	0	/* $Id: forward_dir.omh 3301 2014-05-24 05:20:21Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin forward_dir$$
	12	$spell
	13	Taylor
	14	const
	15	dir
	16	cpp
	17	yq
	18	xq
	19	xk
	20	std::cout
	21	ostream
	22	$$
	23
	24	$section Multiple Directions Forward Mode$$
	25
	26	$index forward, mode$$
	27	$index mode, forward$$
	28	$index direction, multiple$$
	29	$index multiple, direction$$
	30
	31	$head Syntax$$
	32	$icode%yq% = %f%.Forward(%q%, %r%, %xq%)
	33	%$$
	34
	35	$head Purpose$$
	36	We use $latex F : B^n \rightarrow B^m$$ to denote the
	37	$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
	38	Given a function $latex X : B \rightarrow B^n$$,
	39	defined by its
	40	$cref/Taylor coefficients/glossary/Taylor Coefficient/$$,
	41	forward mode computes the Taylor coefficients for the function
	42	$latex \[
	43	Y (t) = F [ X(t) ]
	44	\]$$
	45
	46
	47	$head Notation$$
	48
	49	$subhead n$$
	50	We use $icode n$$ to denote the dimension of the
	51	$cref/domain/seq_property/Domain/$$ space for $icode f$$.
	52
	53	$subhead m$$
	54	We use $icode m$$ to denote the dimension of the
	55	$cref/range/seq_property/Range/$$ space for $icode f$$.
	56
	57	$head f$$
	58	The $cref ADFun$$ object $icode f$$ has prototype
	59	$codei%
	60	ADFun<%Base%> %f%
	61	%$$
	62	Note that the $cref ADFun$$ object $icode f$$ is not $code const$$.
	63	After this call we will have
	64	$codei%
	65	%f%.size_order() == %q% + 1
	66	%f%.size_direction() == %r%
	67	%$$
	68
	69	$head q$$
	70	This argument has prototype
	71	$codei%
	72	size_t %q%
	73	%$$
	74	It specifies the order of Taylor Coefficient that we are calculating
	75	and must be greater than zero.
	76	The zero order coefficients can only have one direction computed
	77	and stored in $icode f$$ so use $cref forward_zero$$
	78	to compute the zero order coefficients.
	79
	80	$head r$$
	81	This argument has prototype
	82	$codei%
	83	size_t %r%
	84	%$$
	85	It specifies the number of directions that are computed together.
	86	If ($icode%r% == 1%$$), you are only using one direction and
	87	$cref forward_order$$ is simpler, and should be faster,
	88	than this more general case.
	89
	90	$head xq$$
	91	The argument $icode xq$$ has prototype
	92	$codei%
	93	const %Vector%& %xq%
	94	%$$
	95	and its size must be $icode%n%*%r%$$
	96	(see $cref/Vector/forward_dir/Vector/$$ below).
	97	For $latex \ell = 0 , \ldots , r-1$$,
	98	$latex j = 0 , \ldots , n-1$$,
	99	the $th j$$ component of the $th q$$ order Taylor coefficient
	100	for $latex X_\ell (t)$$ is defined by
	101	$pre
	102	$$ $latex x_j^{(q),\ell} = $$ $icode%xq%[ %r% * %j% + %ell% ]%$$
	103
	104	$head Zero Order$$
	105	For $latex j = 0 , \ldots , n-1$$,
	106	the $th j$$ component of the zero order Taylor coefficient
	107	for $latex X_\ell (t)$$ is defined by
	108	$pre
	109	$$ $latex x_j^{(0)} = $$ $icode%xk%[ %j% ]%$$
	110	where $icode xk$$ corresponds to the previous call
	111	$codei%
	112	%f%.Forward(%k%, %xk%)
	113	%$$
	114	with $icode%k% = 0%$$.
	115
	116	$head Non-Zero Lower Orders$$
	117	For $latex \ell = 0 , \ldots , r-1$$,
	118	$latex j = 0 , \ldots , n-1$$,
	119	$latex k = 1, \ldots , q-1$$,
	120	the $th j$$ component of the $th k$$ order Taylor coefficient
	121	for $latex X_\ell (t)$$ is defined by
	122	$pre
	123	$$ $latex x_j^{(k),\ell} = $$ $icode%xk%[ %r% * %j% + %ell% ]%$$
	124	where $icode xk$$ corresponds to the previous call
	125	$codei%
	126	%f%.Forward(%k%, %r%, %xk%)
	127	%$$
	128	Note that $icode r$$ must have the same value in this previous call.
	129
	130	$head X(t)$$
	131	For $latex \ell = 0 , \ldots , r-1$$, the function
	132	$latex X_\ell : B \rightarrow B^n$$ is defined using
	133	the Taylor coefficients $latex x^{(k),\ell} \in B^n$$:
	134	$latex \[
	135	X_\ell (t) = x^{(0)} + x^{(1),\ell} * t^1 + \cdots + x^{(q),\ell} t^q
	136	\] $$
	137	Note that the $th k$$ derivative of $latex X_\ell (t)$$ is related to
	138	its Taylor coefficients by
	139	$latex \[
	140	\begin{array}{rcl}
	141	x^{(0)} & = & X_\ell (0)
	142	\\
	143	x^{(k), \ell} & = & \frac{1}{k !} X_\ell^{(k)} (0)
	144	\end{array}
	145	\] $$
	146	for $latex k = 1 , \ldots , q$$.
	147
	148	$head Y(t)$$
	149	For $latex \ell = 0 , \ldots , r-1$$, the function
	150	$latex Y_\ell : B \rightarrow B^m$$ is defined by
	151	$latex Y_\ell (t) = F[ X_\ell (t) ] $$.
	152	We use $latex y^{(0)}$$ for the zero order coefficient
	153	and $latex y^{(k),\ell} \in B^m$$ to denote the
	154	hight order coefficients; i.e.,
	155	$latex \[
	156	Y_\ell (t) = y^{(0)} + y^{(1),\ell} * t^1 + \cdots + y^{(q),\ell} * t^q
	157	+ o( t^q )
	158	\] $$
	159	where $latex o( t^q ) * t^{-q} \rightarrow 0$$ as $latex t \rightarrow 0$$.
	160	Note that the $th k$$ derivative of $latex Y_\ell (t)$$ is related to
	161	its Taylor coefficients by
	162	$latex \[
	163	\begin{array}{rcl}
	164	y^{(0)} & = & Y_\ell (0)
	165	\\
	166	y^{(k), \ell} & = & \frac{1}{k !} Y_\ell^{(k)} (0)
	167	\end{array}
	168	\] $$
	169	for $latex k = 1 , \ldots , q$$.
	170
	171	$head yq$$
	172	The argument $icode yq$$ has prototype
	173	$codei%
	174	%Vector% %yq%
	175	%$$
	176	and its size is $icode%m%*%r%$$
	177	(see $cref/Vector/forward_dir/Vector/$$ below).
	178	For $latex \ell = 0 , \ldots , r-1$$,
	179	$latex i = 0 , \ldots , m-1$$,
	180	the $th i$$ component of the $th q$$ order Taylor coefficient
	181	for $latex Y_\ell (t)$$ is given by
	182	$pre
	183	$$ $latex y_i^{(q),\ell} = $$ $icode%yq%[ %r% * %i% + %ell% ]%$$
	184
	185	$head Vector$$
	186	The type $icode Vector$$ must be a $cref SimpleVector$$ class with
	187	$cref/elements of type/SimpleVector/Elements of Specified Type/$$
	188	$icode Base$$.
	189	The routine $cref CheckSimpleVector$$ will generate an error message
	190	if this is not the case.
	191
	192	$children%
	193	example/forward_dir.cpp
	194	%$$
	195	$head Example$$
	196	The file
	197	$cref forward_dir.cpp$$
	198	contains an example and test using one order (multiple orders).
	199	They return true if they succeed and false otherwise.
	200
	201	$end

+116

-0

omh/forward/forward_one.omh less more

	0	/* $Id: forward_one.omh 3214 2014-03-18 20:50:38Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin forward_one$$
	12	$spell
	13	Jacobian
	14	Taylor
	15	const
	16	$$
	17
	18	$section First Order Forward Mode: Derivative Values$$
	19
	20	$index Forward, order one$$
	21	$index one, order Forward$$
	22	$index order, one Forward$$
	23
	24
	25	$head Syntax$$
	26	$icode%y1% = %f%.Forward(1, %x1%)%$$
	27
	28	$head Purpose$$
	29	We use $latex F : B^n \rightarrow B^m$$ to denote the
	30	$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
	31	The result of the syntax above is
	32	$latex \[
	33	y1 = F^{(1)} (x0) * x1
	34	\] $$
	35	where $latex F^{(1)} (x0)$$ is the Jacobian of $latex F$$
	36	evaluated at $icode x0$$.
	37
	38	$head f$$
	39	The object $icode f$$ has prototype
	40	$codei%
	41	ADFun<%Base%> %f%
	42	%$$
	43	Note that the $cref ADFun$$ object $icode f$$ is not $code const$$.
	44	Before this call to $code Forward$$, the value returned by
	45	$codei%
	46	%f%.size_order()
	47	%$$
	48	must be greater than or equal one.
	49	After this call it will be will be two (see $cref size_order$$).
	50
	51	$head x0$$
	52	The vector $icode x0$$ in the formula
	53	$latex \[
	54	y1 = F^{(1)} (x0) * x1
	55	\] $$
	56	corresponds to the previous call to $cref forward_zero$$
	57	using this ADFun object $icode f$$; i.e.,
	58	$codei%
	59	%f%.Forward(0, %x0%)
	60	%$$
	61	If there is no previous call with the first argument zero,
	62	the value of the $cref/independent/Independent/$$ variables
	63	during the recording of the AD sequence of operations is used
	64	for $icode x0$$.
	65
	66	$head x1$$
	67	The argument $icode x1$$ has prototype
	68	$codei%
	69	const %Vector%& %x1%
	70	%$$
	71	(see $cref/Vector/forward_one/Vector/$$ below)
	72	and its size must be equal to $icode n$$, the dimension of the
	73	$cref/domain/seq_property/Domain/$$ space for $icode f$$.
	74
	75	$head Vector$$
	76	The type $icode Vector$$ must be a $cref SimpleVector$$ class with
	77	$cref/elements of type/SimpleVector/Elements of Specified Type/$$
	78	$icode Base$$.
	79	The routine $cref CheckSimpleVector$$ will generate an error message
	80	if this is not the case.
	81
	82	$head Example$$
	83	The file
	84	$cref forward.cpp$$
	85	contains an example and test of this operation.
	86	It returns true if it succeeds and false otherwise.
	87
	88	$head Special Case$$
	89	This is special case of $cref forward_order$$ where
	90	$latex \[
	91	\begin{array}{rcl}
	92	Y(t) & = & F[ X(t) ]
	93	\\
	94	X(t) & = & x^{(0)} t^0 + x^{(1)} * t^1 + \cdots, + x^{(q)} * t^q + o( t^q )
	95	\\
	96	Y(t) & = & y^{(0)} t^0 + y^{(1)} * t^1 + \cdots, + y^{(q)} * t^q + o( t^q )
	97	\end{array}
	98	\] $$
	99	and $latex o( t^q ) * t^{-q} \rightarrow 0$$ as $latex t \rightarrow 0$$.
	100	For this special case, $latex q = 1$$,
	101	$latex x^{(0)}$$ $codei%= %x0%$$,
	102	$latex x^{(1)}$$ $codei%= %x1%$$,
	103	$latex X(t) = x^{(0)} + x^{(1)} t$$, and
	104	$latex \[
	105	y^{(0)} + y^{(1)} t = F [ x^{(0)} + x^{(1)} t ] + o(t)
	106	\] $$
	107	Taking the derivative with respect to $latex t$$, at $latex t = 0$$,
	108	we obtain
	109	$latex \[
	110	y^{(1)} = F^{(1)} [ x^{(0)} ] x^{(1)}
	111	\] $$
	112	which agrees with the specifications for
	113	$icode y1$$ in the $cref/purpose/forward_one/Purpose/$$ above.
	114
	115	$end

+248

-0

omh/forward/forward_order.omh less more

	0	/* $Id: forward_order.omh 3214 2014-03-18 20:50:38Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin forward_order$$
	12	$spell
	13	std::cout
	14	ostream
	15	xk
	16	xp
	17	yp
	18	Ind
	19	vp
	20	uj
	21	Taylor
	22	const
	23	xq
	24	yq
	25	$$
	26
	27	$section Multiple Order Forward Mode$$
	28
	29	$index forward, mode$$
	30	$index mode, forward$$
	31	$index order, any$$
	32	$index order, multiple$$
	33	$index multiple, order$$
	34
	35	$head Syntax$$
	36	$icode%yq% = %f%.Forward(%q%, %xq% )
	37	%$$
	38	$icode%yq% = %f%.Forward(%q%, %xq%, %s%)
	39	%$$
	40
	41
	42	$head Purpose$$
	43	We use $latex F : B^n \rightarrow B^m$$ to denote the
	44	$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
	45	Given a function $latex X : B \rightarrow B^n$$,
	46	defined by its
	47	$cref/Taylor coefficients/glossary/Taylor Coefficient/$$,
	48	forward mode computes the Taylor coefficients for the function
	49	$latex \[
	50	Y (t) = F [ X(t) ]
	51	\]$$
	52
	53	$subhead Function Values$$
	54	If you are using forward mode to compute values for $latex F(x)$$,
	55	$cref forward_zero$$ is simpler to understand
	56	than this explanation of the general case.
	57
	58	$subhead Derivative Values$$
	59	If you are using forward mode to compute values for $latex F^{(1)} (x) * dx$$,
	60	$cref forward_one$$ is simpler to understand
	61	than this explanation of the general case.
	62
	63	$head Notation$$
	64
	65	$subhead n$$
	66	We use $icode n$$ to denote the dimension of the
	67	$cref/domain/seq_property/Domain/$$ space for $icode f$$.
	68
	69	$subhead m$$
	70	We use $icode m$$ to denote the dimension of the
	71	$cref/range/seq_property/Range/$$ space for $icode f$$.
	72
	73
	74	$head f$$
	75	The $cref ADFun$$ object $icode f$$ has prototype
	76	$codei%
	77	ADFun<%Base%> %f%
	78	%$$
	79	Note that the $cref ADFun$$ object $icode f$$ is not $code const$$.
	80	After this call we will have
	81	$codei%
	82	%f%.size_order() == %q% + 1
	83	%f%.size_direction() == 1
	84	%$$
	85
	86	$head One Order$$
	87	If $icode%xq%.size() == %n%$$,
	88	then we are only computing one order.
	89	In this case, before this call we must have
	90	$codei%
	91	%f%.size_order() >= %q%
	92	%f%.size_direction() == 1
	93	%$$
	94
	95
	96	$head q$$
	97	The argument $icode q$$ has prototype
	98	$codei%
	99	size_t %q%
	100	%$$
	101	and specifies the highest order of the Taylor coefficients to be calculated.
	102
	103	$head xq$$
	104	The argument $icode xq$$ has prototype
	105	$codei%
	106	const %Vector%& %xq%
	107	%$$
	108	(see $cref/Vector/forward_order/Vector/$$ below).
	109	As above, we use $icode n$$ to denote the dimension of the
	110	$cref/domain/seq_property/Domain/$$ space for $icode f$$.
	111	The size of $icode xq$$ must be either $icode n$$ or
	112	$icode%n%*(%q%+1)%$$.
	113	After this call we will have
	114	$codei%
	115	%f%.size_order() == %q% + 1
	116	%$$
	117
	118	$subhead One Order$$
	119	If $icode%xq%.size() == %n%$$,
	120	the $th q$$ order Taylor coefficient for $latex X(t)$$
	121	is defined by
	122	$pre
	123	$$ $latex x^{(q)} = $$ $icode xq$$.
	124	For $latex k = 0 , \ldots , q-1$$,
	125	the Taylor coefficient $latex x^{(k)}$$
	126	is defined by $icode xk$$ in the previous call to
	127	$codei%
	128	%f%.Forward(%k%, %xk%)
	129	%$$
	130
	131	$subhead Multiple Orders$$
	132	If $icode%xq%.size() == %n%*(%q%+1)%$$,
	133	For $latex k = 0 , \ldots , q$$,
	134	$latex j = 0 , \ldots , n-1$$,
	135	the $th j$$ component of the $th k$$ order Taylor coefficient
	136	for $latex X(t)$$ is defined by
	137	$pre
	138	$$ $latex x_j^{(k)} = $$ $icode%%xq%[ (%q%+1) * %j% + %k% ]%$$
	139
	140	$subhead Restrictions$$
	141	Note if $icode f$$ uses $cref old_atomic$$ functions,
	142	the size of $icode xq$$ must be $icode n$$.
	143
	144	$head s$$
	145	If the argument $icode s$$ is not present, $code std::cout$$
	146	is used in its place.
	147	Otherwise, this argument has prototype
	148	$codei%
	149	std::ostream& %s%
	150	%$$
	151	If order zero is begin calculated,
	152	$icode s$$ specifies where the output corresponding to $cref PrintFor$$
	153	will be written.
	154	If order zero is not being calculated,
	155	$icode s$$ is not used
	156
	157	$head X(t)$$
	158	The function
	159	$latex X : B \rightarrow B^n$$ is defined using
	160	the Taylor coefficients $latex x^{(k)} \in B^n$$:
	161	$latex \[
	162	X(t) = x^{(0)} * t^0 + x^{(1)} * t^1 + \cdots + x^{(q)} * t^q
	163	\] $$
	164	Note that for $latex k = 0 , \ldots , q$$,
	165	the $th k$$ derivative of $latex X(t)$$ is related to the
	166	Taylor coefficients by the equation
	167	$latex \[
	168	x^{(k)} = \frac{1}{k !} X^{(k)} (0)
	169	\] $$
	170
	171	$head Y(t)$$
	172	The function
	173	$latex Y : B \rightarrow B^m$$ is defined by
	174	$latex Y(t) = F[ X(t) ] $$.
	175	We use $latex y^{(k)} \in B^m$$
	176	to denote the $th k$$ order Taylor coefficient of $latex Y(t)$$; i.e.,
	177	$latex \[
	178	Y(t) = y^{(0)} * t^0 + y^{(1)} * t^1 + \cdots + y^{(q)} * t^q + o( t^q )
	179	\] $$
	180	where $latex o( t^q ) * t^{-q} \rightarrow 0$$ as $latex t \rightarrow 0$$.
	181	Note that $latex y^{(k)}$$ is related to
	182	the $th k$$ derivative of $latex Y(t)$$ by the equation
	183	$latex \[
	184	y^{(k)} = \frac{1}{k !} Y^{(k)} (0)
	185	\] $$
	186
	187	$head yq$$
	188	The return value $icode yq$$ has prototype
	189	$codei%
	190	%Vector% %yq%
	191	%$$
	192	(see $cref/Vector/forward_order/Vector/$$ below).
	193
	194	$subhead One Order$$
	195	If $icode%xq%.size() == %n%$$,
	196	the vector $icode yq$$ has size $icode m$$.
	197	The $th q$$ order Taylor coefficient for $latex Y(t)$$
	198	is returned as
	199	$codei%
	200	%yq%$$ $latex = y^{(q)}$$.
	201
	202	$subhead Multiple Orders$$
	203	If $icode%xq%.size() == %n%*(%q%+1)%$$,
	204	the vector $icode yq$$ has size $icode%m%*(%q%+1)%$$.
	205	For $latex k = 0 , \ldots , q$$,
	206	for $latex i = 0 , \ldots , m-1$$,
	207	the $th i$$ component of the $th k$$ order Taylor coefficient
	208	for $latex Y(t)$$ is returned as
	209	$codei%
	210	%yq%[ (%q%+1) * %i% + %k% ]%$$ $latex = y_i^{(k)}$$
	211
	212	$head Vector$$
	213	The type $icode Vector$$ must be a $cref SimpleVector$$ class with
	214	$cref/elements of type/SimpleVector/Elements of Specified Type/$$
	215	$icode Base$$.
	216	The routine $cref CheckSimpleVector$$ will generate an error message
	217	if this is not the case.
	218
	219	$head Zero Order$$
	220	The case where
	221	$latex q = 0$$ and $icode%xq%.size() == %n%$$,
	222	corresponds to the zero order
	223	$cref/special case/forward_zero/Special Case/$$.
	224
	225	$head First Order$$
	226	The case where
	227	$latex q = 1$$ and $icode%xq%.size() == %n%$$,
	228	corresponds to the first order
	229	$cref/special case/forward_one/Special Case/$$.
	230
	231	$head Second Order$$
	232	The case where
	233	$latex q = 2$$ and $icode%xq%.size() == %n%$$,
	234	corresponds to the second order
	235	$cref/special case/forward_two/Special Case/$$.
	236
	237	$children%
	238	example/forward.cpp%
	239	example/forward_order.cpp
	240	%$$
	241	$head Example$$
	242	The file
	243	$cref forward.cpp$$ ( $cref forward_order.cpp$$ )
	244	contains an example and test using one order (multiple orders).
	245	They return true if they succeed and false otherwise.
	246
	247	$end

+152

-0

omh/forward/forward_two.omh less more

	0	/* $Id: forward_two.omh 3472 2014-12-15 13:29:52Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin forward_two$$
	12	$spell
	13	Jacobian
	14	Taylor
	15	const
	16	$$
	17
	18	$section Second Order Forward Mode: Derivative Values$$
	19
	20	$index Forward, order two$$
	21	$index two, order Forward$$
	22	$index order, two Forward$$
	23
	24
	25	$head Syntax$$
	26	$icode%y2% = %f%.Forward(1, %x2%)%$$
	27
	28	$head Purpose$$
	29	We use $latex F : B^n \rightarrow B^m$$ to denote the
	30	$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
	31	The result of the syntax above is that for
	32	$icode%i% = 0 , %...% , %m%-1%$$,
	33	$codei%
	34	%y2%[%i%]%$$
	35	$latex = F_i^{(1)} (x0) * x2 + \frac{1}{2} x1^T * F_i^{(2)} (x0) * x1$$
	36	$pre
	37	$$
	38	where
	39	$latex F^{(1)} (x0)$$ is the Jacobian of $latex F$$, and
	40	$latex F_i^{(2)} (x0)$$ is the Hessian of th $th i$$ component of $latex F$$,
	41	evaluated at $icode x0$$.
	42
	43	$head f$$
	44	The object $icode f$$ has prototype
	45	$codei%
	46	ADFun<%Base%> %f%
	47	%$$
	48	Note that the $cref ADFun$$ object $icode f$$ is not $code const$$.
	49	Before this call to $code Forward$$, the value returned by
	50	$codei%
	51	%f%.size_order()
	52	%$$
	53	must be greater than or equal two.
	54	After this call it will be will be three (see $cref size_order$$).
	55
	56	$head x0$$
	57	The vector $icode x0$$ in the formula for $icode%y2%[%i%]%$$
	58	corresponds to the previous call to $cref forward_zero$$
	59	using this ADFun object $icode f$$; i.e.,
	60	$codei%
	61	%f%.Forward(0, %x0%)
	62	%$$
	63	If there is no previous call with the first argument zero,
	64	the value of the $cref/independent/Independent/$$ variables
	65	during the recording of the AD sequence of operations is used
	66	for $icode x0$$.
	67
	68	$head x1$$
	69	The vector $icode x1$$ in the formula for $icode%y2%[%i%]%$$
	70	corresponds to the previous call to $cref forward_one$$
	71	using this ADFun object $icode f$$; i.e.,
	72	$codei%
	73	%f%.Forward(1, %x1%)
	74	%$$
	75
	76	$head x2$$
	77	The argument $icode x2$$ has prototype
	78	$codei%
	79	const %Vector%& %x2%
	80	%$$
	81	(see $cref/Vector/forward_two/Vector/$$ below)
	82	and its size must be equal to $icode n$$, the dimension of the
	83	$cref/domain/seq_property/Domain/$$ space for $icode f$$.
	84
	85	$head y2$$
	86	The result $icode y2$$ has prototype
	87	$codei%
	88	%Vector% %y2%
	89	%$$
	90	(see $cref/Vector/forward_two/Vector/$$ below)
	91	The size of $icode y1$$ is equal to $icode m$$, the dimension of the
	92	$cref/range/seq_property/Range/$$ space for $icode f$$.
	93	Its value is given element-wise by the formula in the
	94	$cref/purpose/forward_two/Purpose/$$ above.
	95
	96	$head Vector$$
	97	The type $icode Vector$$ must be a $cref SimpleVector$$ class with
	98	$cref/elements of type/SimpleVector/Elements of Specified Type/$$
	99	$icode Base$$.
	100	The routine $cref CheckSimpleVector$$ will generate an error message
	101	if this is not the case.
	102
	103	$head Example$$
	104	The file
	105	$cref forward.cpp$$
	106	contains an example and test of this operation.
	107	It returns true if it succeeds and false otherwise.
	108
	109	$head Special Case$$
	110	This is special case of $cref forward_order$$ where
	111	$latex \[
	112	\begin{array}{rcl}
	113	Y(t) & = F[ X(t) ]
	114	\\
	115	X(t) & = & x^{(0)} t^0 + x^{(1)} * t^1 + \cdots, + x^{(q)} * t^q + o( t^q )
	116	\\
	117	Y(t) & = & y^{(0)} t^0 + y^{(1)} * t^1 + \cdots, + y^{(q)} * t^q + o( t^q )
	118	\end{array}
	119	\] $$
	120	and $latex o( t^q ) * t^{-q} \rightarrow 0$$ as $latex t \rightarrow 0$$.
	121	For this special case, $latex q = 2$$,
	122	$latex x^{(0)}$$ $codei%= %x0%$$,
	123	$latex x^{(1)}$$ $codei%= %x1%$$,
	124	$latex X(t) = x^{(0)} + x^{(1)} t + x^{(2)} t^2$$, and
	125	$latex \[
	126	y^{(0)} + y^{(1)} t + y^{(2)} t^2
	127	=
	128	F [ x^{(0)} + x^{(1)} t + x^{(2)} t^2 ] + o(t^2)
	129	\] $$
	130	Restricting our attention to the $th i$$ component, and
	131	taking the derivative with respect to $latex t$$, we obtain
	132	$latex \[
	133	y_i^{(1)} + 2 y_i^{(2)} t
	134	=
	135	F_i^{(1)} [ x^{(0)} + x^{(1)} t + x^{(2)} t^2 ] [ x^{(1)} + 2 x^{(2)} t ]
	136	+
	137	o(t)
	138	\] $$
	139	Taking a second derivative with respect to $latex t$$,
	140	and evaluating at $latex t = 0$$, we obtain
	141	$latex \[
	142	2 y_i^{(2)}
	143	=
	144	[ x^{(1)} ]^T F_i^{(2)} [ x^{(0)} ] x^{(1)}
	145	+
	146	F_i^{(1)} [ x^{(0)} ] 2 x^{(2)}
	147	\] $$
	148	which agrees with the specification for $icode%y2%[%i%]%$$ in the
	149	$cref/purpose/forward_two/Purpose/$$ above.
	150
	151	$end

+120

-0

omh/forward/forward_zero.omh less more

	0	/* $Id: forward_zero.omh 3214 2014-03-18 20:50:38Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin forward_zero$$
	12	$spell
	13	std::cout
	14	ostream
	15	const
	16	Taylor
	17	dy
	18	Jacobian
	19	$$
	20	$index Forward, order zero$$
	21	$index zero, order Forward$$
	22	$index order, zero Forward$$
	23
	24	$section Zero Order Forward Mode: Function Values$$
	25
	26	$head Syntax$$
	27	$icode%y0% = %f%.Forward(0, %x0%)
	28	%$$
	29	$icode%y0% = %f%.Forward(0, %x0%, %s%)%$$
	30
	31	$head Purpose$$
	32	We use $latex F : B^n \rightarrow B^m$$ to denote the
	33	$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
	34	The result of the syntax above is
	35	$latex \[
	36	y0 = F(x0)
	37	\] $$
	38	See the $cref/FunCheck discussion/FunCheck/Discussion/$$ for
	39	possible differences between $latex F(x)$$ and the algorithm that defined
	40	the operation sequence.
	41
	42	$head f$$
	43	The object $icode f$$ has prototype
	44	$codei%
	45	ADFun<%Base%> %f%
	46	%$$
	47	Note that the $cref ADFun$$ object $icode f$$ is not $code const$$.
	48	After this call to $code Forward$$, the value returned by
	49	$codei%
	50	%f%.size_order()
	51	%$$
	52	will be equal to one (see $cref size_order$$).
	53
	54	$head x0$$
	55	The argument $icode x0$$ has prototype
	56	$codei%
	57	const %Vector%& %x0%
	58	%$$
	59	(see $cref/Vector/forward_zero/Vector/$$ below)
	60	and its size must be equal to $icode n$$, the dimension of the
	61	$cref/domain/seq_property/Domain/$$ space for $icode f$$.
	62
	63	$head s$$
	64	If the argument $icode s$$ is not present, $code std::cout$$
	65	is used in its place.
	66	Otherwise, this argument has prototype
	67	$codei%
	68	std::ostream& %s%
	69	%$$
	70	It specifies where the output corresponding to $cref PrintFor$$,
	71	and this zero order forward mode call, will be written.
	72
	73	$head y0$$
	74	The result $icode y0$$ has prototype
	75	$codei%
	76	%Vector% %y0%
	77	%$$
	78	(see $cref/Vector/forward_zero/Vector/$$ below)
	79	and its value is $latex F(x)$$ at $icode%x% = %x0%$$.
	80	The size of $icode y0$$ is equal to $icode m$$, the dimension of the
	81	$cref/range/seq_property/Range/$$ space for $icode f$$.
	82
	83	$head Vector$$
	84	The type $icode Vector$$ must be a $cref SimpleVector$$ class with
	85	$cref/elements of type/SimpleVector/Elements of Specified Type/$$
	86	$icode Base$$.
	87	The routine $cref CheckSimpleVector$$ will generate an error message
	88	if this is not the case.
	89
	90	$head Example$$
	91	The file
	92	$cref forward.cpp$$
	93	contains an example and test of this operation.
	94	It returns true if it succeeds and false otherwise.
	95
	96	$head Special Case$$
	97	This is special case of $cref forward_order$$ where
	98	$latex \[
	99	\begin{array}{rcl}
	100	Y(t) & = & F[ X(t) ]
	101	\\
	102	X(t) & = & x^{(0)} t^0 + x^{(1)} * t^1 + \cdots, + x^{(q)} * t^q + o( t^q )
	103	\\
	104	Y(t) & = & y^{(0)} t^0 + y^{(1)} * t^1 + \cdots, + y^{(q)} * t^q + o( t^q )
	105	\end{array}
	106	\] $$
	107	and $latex o( t^q ) * t^{-q} \rightarrow 0$$ as $latex t \rightarrow 0$$.
	108	For this special case, $latex q = 0$$,
	109	$latex x^{(0)}$$ $codei%= %x0%$$,
	110	$latex X(t) = x^{(0)}$$, and
	111	$latex \[
	112	y^{(0)} = Y(t) = F[ X(t) ] = F( x^{(0)} )
	113	\] $$
	114	which agrees with the specifications for
	115	$icode y0$$ in the $cref/purpose/forward_zero/Purpose/$$ above.
	116
	117
	118
	119	$end

+98

-0

omh/forward/size_order.omh less more

	0	/* $Id: size_order.omh 3214 2014-03-18 20:50:38Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin size_order$$
	12	$spell
	13	var
	14	Taylor
	15	const
	16	$$
	17
	18	$section Number Taylor Coefficient Orders Currently Stored$$
	19
	20	$head Syntax$$
	21	$icode%s% = %f%.size_order()%$$
	22
	23	$subhead See Also$$
	24	$cref seq_property$$
	25
	26	$head Purpose$$
	27	Determine the number of Taylor coefficient orders, per variable,direction,
	28	currently calculated and stored in the ADFun object $icode f$$.
	29	See the discussion under
	30	$cref/Constructor/size_order/Constructor/$$,
	31	$cref/Forward/size_order/Forward/$$, and
	32	$cref/capacity_order/size_order/capacity_order/$$
	33	for a description of when this value can change.
	34
	35
	36	$head f$$
	37	The object $icode f$$ has prototype
	38	$codei%
	39	const ADFun<%Base%> %f%
	40	%$$
	41
	42	$head s$$
	43	The result $icode s$$ has prototype
	44	$codei%
	45	size_t %s%
	46	%$$
	47	and is the number of Taylor coefficient orders,
	48	per variable,direction in the AD operation sequence,
	49	currently calculated and stored in the ADFun object $icode f$$.
	50
	51	$head Constructor$$
	52	Directly after the $cref FunConstruct$$ syntax
	53	$codei%
	54	ADFun<%Base%> %f%(%x%, %y%)
	55	%$$
	56	the value of $icode s$$ returned by $code size_order$$ is one.
	57	This is because
	58	there is an implicit call to $code Forward$$ that computes
	59	the zero order Taylor coefficients during this constructor.
	60
	61	$head Forward$$
	62	After a call to $cref/Forward/forward_order/$$ with the syntax
	63	$codei%
	64	%f%.Forward(%q%, %x_q%)
	65	%$$
	66	the value of $icode s$$ returned by $code size_order$$
	67	would be $latex q + 1$$.
	68	The call to $code Forward$$ above
	69	uses the lower order Taylor coefficients to compute and store
	70	the $th q$$ order Taylor coefficients for all
	71	the variables in the operation sequence corresponding to $icode f$$.
	72	Thus there are $latex q + 1$$ (order zero through $icode q$$)
	73	Taylor coefficients per variable,direction.
	74	(You can determine the number of variables in the operation sequence
	75	using the $cref/size_var/seq_property/size_var/$$ function.)
	76
	77	$head capacity_order$$
	78	If the number of Taylor coefficient orders
	79	currently stored in $icode f$$ is less than or equal $icode c$$,
	80	a call to $cref capacity_order$$ with the syntax
	81	$codei%
	82	%f%.capacity_order(%c%)
	83	%$$
	84	does not affect the value $icode s$$ returned by $code size_order$$.
	85	Otherwise,
	86	the value $icode s$$ returned by $code size_order$$
	87	is equal to $icode c$$
	88	(only Taylor coefficients of order zero through $latex c-1$$
	89	have been retained).
	90
	91	$head Example$$
	92	The file
	93	$cref forward.cpp$$
	94	contains an example and test of this operation.
	95	It returns true if it succeeds and false otherwise.
	96
	97	$end

-676

~~omh/forward.omh~~ less more

0		$Id: forward.omh 2859 2013-05-28 06:03:21Z bradbell $
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		$begin ForwardZero$$
13		$spell
14		std::cout
15		ostream
16		const
17		Taylor
18		dy
19		Jacobian
20		$$
21		$index Forward, order zero$$
22		$index zero, order Forward$$
23		$index order, zero Forward$$
24
25		$section Zero Order Forward Mode: Function Values$$
26
27		$head Syntax$$
28		$icode%y% = %f%.Forward(0, %x%)
29		%$$
30		$icode%y% = %f%.Forward(x, %x%, %s%)%$$
31
32		$head Purpose$$
33		We use $latex F : B^n \rightarrow B^m$$ to denote the
34		$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
35		The result of the syntax above is
36		$latex \[
37		y = F(x)
38		\] $$
39		(See the $cref/FunCheck discussion/FunCheck/Discussion/$$ for
40		possible differences between $latex F(x)$$ and the algorithm that defined
41		the operation sequence.)
42
43		$head f$$
44		The object $icode f$$ has prototype
45		$codei%
46		ADFun<%Base%> %f%
47		%$$
48		Note that the $cref ADFun$$ object $icode f$$ is not $code const$$.
49		After this call to $code Forward$$, the value returned by
50		$codei%
51		%f%.size_taylor()
52		%$$
53		will be equal to one (see $cref size_taylor$$).
54
55		$head x$$
56		The argument $icode x$$ has prototype
57		$codei%
58		const %Vector%& %x%
59		%$$
60		(see $cref/Vector/ForwardZero/Vector/$$ below)
61		and its size
62		must be equal to $icode n$$, the dimension of the
63		$cref/domain/seq_property/Domain/$$ space for $icode f$$.
64
65		$head s$$
66		If the argument $icode s$$ is not present, $code std::cout$$
67		is used in its place.
68		Otherwise, this argument has prototype
69		$codei%
70		std::ostream& %s%
71		%$$
72		It specifies where the output corresponding to $cref PrintFor$$,
73		and this zero order forward mode call, will be written.
74
75		$head y$$
76		The result $icode y$$ has prototype
77		$codei%
78		%Vector% %y%
79		%$$
80		(see $cref/Vector/ForwardZero/Vector/$$ below)
81		and its value is $latex F(x)$$.
82		The size of $icode y$$
83		is equal to $icode m$$, the dimension of the
84		$cref/range/seq_property/Range/$$ space for $icode f$$.
85
86		$head Vector$$
87		The type $icode Vector$$ must be a $cref SimpleVector$$ class with
88		$cref/elements of type/SimpleVector/Elements of Specified Type/$$
89		$icode Base$$.
90		The routine $cref CheckSimpleVector$$ will generate an error message
91		if this is not the case.
92
93		$head Example$$
94		The file
95		$cref forward.cpp$$
96		contains an example and test of this operation.
97		It returns true if it succeeds and false otherwise.
98
99		$end
100		---------------------------------------------------------------------------
101		$begin ForwardOne$$
102		$spell
103		dy
104		Jacobian
105		Taylor
106		const
107		$$
108
109		$section First Order Forward Mode: Derivative Values$$
110
111		$index Forward, order one$$
112		$index one, order Forward$$
113		$index order, one Forward$$
114
115
116		$head Syntax$$
117		$icode%dy% = %f%.Forward(1, %dx%)
118		%$$
119		$icode%dy% = %f%.Forward(1, %dx%, %s%)
120		%$$
121
122
123		$head Purpose$$
124		We use $latex F : B^n \rightarrow B^m$$ to denote the
125		$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
126		The result of the syntax above is
127		$latex \[
128		dy = F^{(1)} (x) * dx
129		\] $$
130		where $latex F^{(1)} (x)$$ is the Jacobian of $latex F$$
131		evaluated at $latex x$$.
132
133		$head f$$
134		The object $icode f$$ has prototype
135		$codei%
136		ADFun<%Base%> %f%
137		%$$
138		Note that the $cref ADFun$$ object $icode f$$ is not $code const$$.
139		Before this call to $code Forward$$, the value returned by
140		$codei%
141		%f%.size_taylor()
142		%$$
143		must be greater than or equal one.
144		After this call it will be will be two (see $cref size_taylor$$).
145
146		$head x$$
147		The vector $icode x$$ in expression for $icode dy$$ above
148		corresponds to the previous call to $cref ForwardZero$$
149		using this ADFun object $icode f$$; i.e.,
150		$codei%
151		%f%.Forward(0, %x%)
152		%$$
153		If there is no previous call with the first argument zero,
154		the value of the $cref/independent/Independent/$$ variables
155		during the recording of the AD sequence of operations is used
156		for $icode x$$.
157
158		$head dx$$
159		The argument $icode dx$$ has prototype
160		$codei%
161		const %Vector%& %x%
162		%$$
163		(see $cref/Vector/ForwardOne/Vector/$$ below)
164		and its size
165		must be equal to $icode n$$, the dimension of the
166		$cref/domain/seq_property/Domain/$$ space for $icode f$$.
167
168		$head s$$
169		The argument $icode s$$, if present, is not used during this operation.
170
171		$head dy$$
172		The result $icode dy$$ has prototype
173		$codei%
174		%Vector% %dy%
175		%$$
176		(see $cref/Vector/ForwardOne/Vector/$$ below)
177		and its value is $latex F^{(1)} (x) * dx$$.
178		The size of $icode dy$$
179		is equal to $icode m$$, the dimension of the
180		$cref/range/seq_property/Range/$$ space for $icode f$$.
181
182		$head Vector$$
183		The type $icode Vector$$ must be a $cref SimpleVector$$ class with
184		$cref/elements of type/SimpleVector/Elements of Specified Type/$$
185		$icode Base$$.
186		The routine $cref CheckSimpleVector$$ will generate an error message
187		if this is not the case.
188
189		$head Example$$
190		The file
191		$cref forward.cpp$$
192		contains an example and test of this operation.
193		It returns true if it succeeds and false otherwise.
194
195		$end
196		--------------------------------------------------------------------------
197		$begin ForwardAny$$
198		$spell
199		std::cout
200		ostream
201		xk
202		xp
203		yp
204		Ind
205		vp
206		uj
207		Taylor
208		const
209		dy
210		$$
211
212		$section Any Order Forward Mode$$
213
214		$index forward, mode$$
215		$index mode, forward$$
216		$index derivative, forward mode$$
217		$index calculate, forward mode$$
218
219		$head Syntax$$
220		$icode%y_p% = %f%.Forward(%p%, %x_p% )
221		%$$
222		$icode%y_p% = %f%.Forward(%p%, %x_p%, %s%)
223		%$$
224
225
226		$head Purpose$$
227		We use $latex F : B^n \rightarrow B^m$$ to denote the
228		$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
229		Given a function $latex X : B \rightarrow B^n$$,
230		defined by its
231		$cref/Taylor coefficients/glossary/Taylor Coefficient/$$,
232		forward mode computes the Taylor coefficients for the function
233		$latex \[
234		Y (t) = F [ X(t) ]
235		\]$$
236
237		$subhead Function Values$$
238		If you are using forward mode to compute values for $latex F(x)$$,
239		$cref ForwardZero$$ is simpler to understand
240		than this explanation of the general case.
241
242		$subhead Derivative Values$$
243		If you are using forward mode to compute values for $latex F^{(1)} (x) * dx$$,
244		$cref ForwardOne$$ is simpler to understand
245		than this explanation of the general case.
246
247		$head X(t)$$
248		The function
249		$latex X : B \rightarrow B^n$$ is defined using
250		a sequence of Taylor coefficients $latex x^{(k)} \in B^n$$:
251		$latex \[
252		X(t) = x^{(0)} + x^{(1)} * t + \cdots + x^{(p)} * t^p
253		\] $$
254		For $latex k = 0, \ldots , p$$,
255		the vector $latex x^{(k)}$$ above is defined as the value of
256		$icode x_k$$ in the previous call (counting this call) of the form
257		$codei%
258		%f%.Forward(%k%, %x_k%)
259		%$$
260		If there is no previous call with $latex k = 0$$,
261		$latex x^{(0)}$$ is the value of the independent variables when the
262		corresponding
263		AD of $icode Base$$
264		$cref/operation sequence/glossary/Operation/Sequence/$$ was recorded.
265		Note that
266		$latex x^{(k)}$$ is related to the $th k$$ derivative of $latex X(t)$$ by
267		$latex \[
268		x^{(k)} = \frac{1}{k !} X^{(k)} (0)
269		\] $$
270
271		$head Y(t)$$
272		The function
273		$latex Y : B \rightarrow B^m$$ is defined by
274		$latex Y(t) = F[ X(t) ] $$.
275		We use $latex y^{(k)} \in B^m$$
276		to denote the $th k$$ order Taylor coefficient of $latex Y(t)$$; i.e.,
277		$latex \[
278		Y(t) = y^{(0)} + y^{(1)} * t + \cdots, + y^{(p)} * t^p + o( t^p )
279		\] $$
280		where $latex o( t^p ) * t^{-p} \rightarrow 0$$
281		as $latex t \rightarrow 0$$.
282		Note that $latex y^{(k)}$$ is related to
283		the $th k$$ derivative of $latex Y(t)$$ by
284		$latex \[
285		y^{(k)} = \frac{1}{k !} Y^{(k)} (0)
286		\] $$
287
288
289		$head f$$
290		The $cref ADFun$$ object $icode f$$ has prototype
291		$codei%
292		ADFun<%Base%> %f%
293		%$$
294		Note that the $cref ADFun$$ object $icode f$$ is not $code const$$.
295		Before this call to $code Forward$$, the value returned by
296		$codei%
297		%f%.size_taylor()
298		%$$
299		must be greater than or equal $latex p$$.
300		After this call it will be will be $latex p+1$$ (see $cref size_taylor$$).
301
302		$head p$$
303		The argument $icode p$$ has prototype
304		$codei%
305		size_t %p%
306		%$$
307		and specifies the order of the Taylor coefficients to be calculated.
308
309		$head x_p$$
310		The argument $icode x_p$$ has prototype
311		$codei%
312		const %Vector%& %x_p%
313		%$$
314		(see $cref/Vector/ForwardAny/Vector/$$ below).
315		As above, we use $icode n$$ to denote the dimension of the
316		$cref/domain/seq_property/Domain/$$ space for $icode f$$.
317		The size of $icode x_p$$ must be either $icode n$$ or
318		$icode%n%*(%p%+1)%$$.
319
320		$subhead Restrictions$$
321		Note if $icode f$$ uses $cref old_atomic$$ functions,
322		the size of $icode x_p$$ must be $icode n$$.
323
324		$subhead One Order$$
325		If $icode%x_p%.size() == %n%$$,
326		The $th p$$ order Taylor coefficient for $latex X(t)$$
327		is defined by this value; i.e., $latex x^{(p)} = x\_p$$.
328		For $latex k = 0 , \ldots , p-1$$,
329		the $th k$$ order Taylor coefficient $latex x^{(k)}$$
330		is defined by $icode x_k$$ in the previous call to
331		$codei%
332		%f%.Forward(%k%, %x_k%)
333		%$$
334
335		$subhead Multiple Orders$$
336		If $icode%x_p%.size() == %n%*(%p%+1)%$$,
337		For $latex k = 0 , \ldots , p$$,
338		for $latex j = 0 , \ldots , n$$,
339		the $th j$$ component of the $th k$$ order Taylor coefficient
340		$latex x_j^{(k)}$$
341		is defined by $icode x_j^k$$ were
342		$codei%
343		%x_j^k% = %x_p%[ %j% * %p% + %k% ]
344		%$$
345
346		$head s$$
347		If the argument $icode s$$ is not present, $code std::cout$$
348		is used in its place.
349		Otherwise, this argument has prototype
350		$codei%
351		std::ostream& %s%
352		%$$
353		If $icode%p% == 0%$$,
354		$icode s$$ specifies where the output corresponding to $cref PrintFor$$
355		will be written.
356		If $icode%p% != 0%$$, $icode s$$ is not used.
357
358		$head y_p$$
359		The return value $icode y_p$$ has prototype
360		$codei%
361		%Vector% %y_p%
362		%$$
363		(see $cref/Vector/ForwardAny/Vector/$$ below).
364		As above, we use $icode m$$ to denote the dimension of the
365		$cref/range/seq_property/Range/$$ space for $icode f$$.
366
367		$subhead One Order$$
368		If $icode%x_p%.size() == %n%$$,
369		the vector $icode y_p$$ has size $icode m$$.
370		The $th p$$ order Taylor coefficient for $latex Y(t)$$
371		is defined by this value; i.e., $latex y^{(p)} = y\_p$$.
372
373		$subhead Multiple Orders$$
374		If $icode%x_p%.size() == %n%*(%p%+1)%$$,
375		the vector $icode y_p$$ has size $icode%m%*(%p%+1)%$$.
376		For $latex k = 0 , \ldots , p$$,
377		for $latex i = 0 , \ldots , m$$,
378		the $th i$$ component of the $th k$$ order Taylor coefficient
379		$latex y_i^{(k)}$$
380		is defined by $icode y_i^k$$ were
381		$codei%
382		%y_i^k% = %y_p%[ %i% * %p% + %k% ]
383		%$$
384
385		$head Vector$$
386		The type $icode Vector$$ must be a $cref SimpleVector$$ class with
387		$cref/elements of type/SimpleVector/Elements of Specified Type/$$
388		$icode Base$$.
389		The routine $cref CheckSimpleVector$$ will generate an error message
390		if this is not the case.
391
392		$head Zero Order$$
393		In the case where $latex p = 0$$ and $icode%x_p%.size() == %n%$$,
394		the result $icode y_p$$ is given by
395		$latex \[
396		\begin{array}{rcl}
397		y^{(0)} & = & (F \circ X) ( 0 ) \\
398		& = & F[ x^{(0)} ]
399		\end{array}
400		\] $$
401		The agrees with the simplification where
402		$latex p$$,
403		$latex x^{(0)}$$, and
404		$latex y^{(0)}$$ above are replaced by
405		$code 0$$,
406		$icode x$$, and
407		$icode y$$
408		in $cref ForwardZero$$.
409
410		$head First Order$$
411		In the case where $latex p = 1$$ and $icode%x_p%.size() == %n%$$,
412		the result $icode y_p$$ is given by
413		$latex \[
414		\begin{array}{rcl}
415		y^{(1)} & = & (F \circ X)^{(1)} ( 0 ) \\
416		& = & F^{(1)} [ X(0) ] * X^{(1)} (0) \\
417		& = & F^{(1)} ( x^{(0)} ) * x^{(1)}
418		\end{array}
419		\] $$
420		The agrees with the simplification where
421		$latex p$$,
422		$latex x^{(0)}$$,
423		$latex x^{(1)}$$, and
424		$latex y^{(1)}$$ above are replaced by
425		$code 1$$,
426		$icode x$$,
427		$icode dx$$, and
428		$icode dy$$
429		in $cref ForwardOne$$.
430		$pre
431
432		$$
433		Note that if $latex x^{(1)}$$ is the $th j$$
434		$cref/elementary vector/glossary/Elementary Vector/$$
435		$latex \[
436		y^{(1)} = \D{F}{x_j} ( x^{(0)} )
437		\] $$
438
439		$head Second Order$$
440		In the case where $latex p = 2$$ and $icode%x_p%.size() == %n%$$,
441		the $th i$$ element of
442		the result $icode y_p$$ is given by
443		$latex \[
444		\begin{array}{rcl}
445		y_i^{(2)}
446		& = & \frac{1}{2} (F_i \circ X)^{(2)} ( 0 )
447		\\
448		& = & \frac{1}{2} \left[ F_i^{(1)} [ X(0) ] * X^{(2)} (0)
449		+ X^{(1)} (0)^T * F_i^{(2)} [ X(0) ] * X^{(1)} (0) \right]
450		\\
451		& = & \frac{1}{2} \left[
452		2 * F_i^{(1)} ( x^{(0)} ) * x^{(2)}
453		+
454		( x^{(1)} )^T * F_i^{(2)} ( x^{(0)} ) * x^{(1)}
455		\right ]
456		\end{array}
457		\] $$
458		Note that if $latex x^{(1)}$$ is the $th j$$
459		$cref/elementary vector/glossary/Elementary Vector/$$
460		and $latex x^{(2)}$$ is zero,
461		$latex \[
462		\begin{array}{rcl}
463		\DD{F_i}{x_j}{x_j} ( x^{(0)} ) = 2 y_i^{(2)}
464		\end{array}
465		\] $$
466		If $latex x^{(1)}$$ is the sum of the $th j$$ and $th l$$
467		$cref/elementary vectors/glossary/Elementary Vector/$$
468		and $latex x^{(2)}$$ is zero,
469		$latex \[
470		\begin{array}{rcl}
471		y_i^{(2)}
472		& = & \frac{1}{2} \left[
473		\DD{F_i}{x_j}{x_j} ( x^{(0)} )
474		+
475		\DD{F_i}{x_j}{x_\ell} ( x^{(0)} )
476		+
477		\DD{F_i}{x_\ell}{x_j} ( x^{(0)} )
478		+
479		\DD{F_i}{x_\ell}{x_\ell} ( x^{(0)} )
480		\right]
481		\\
482		\DD{F_i}{x_\ell}{x_j} ( x^{(0)} )
483		& = &
484		y_i^{(2)}
485		-
486		\frac{1}{2} \DD{F_i}{x_j}{x_j} ( x^{(0)} )
487		-
488		\frac{1}{2} \DD{F_i}{x_\ell}{x_\ell} ( x^{(0)} )
489		\end{array}
490		\] $$
491
492		$head Example$$
493		The file
494		$cref forward.cpp$$ ( $cref forward_mul.cpp$$ )
495		contains an example and test using one order (multiple orders).
496		They return true if they succeed and false otherwise.
497
498		$end
499		-----------------------------------------------------------------------------
500		$begin size_taylor$$
501		$spell
502		var
503		Taylor
504		const
505		$$
506
507		$section Number Taylor Coefficients, Per Variable, Currently Stored$$
508
509		$head Syntax$$
510		$icode%s% = %f%.size_taylor()%$$
511
512		$subhead See Also$$
513		$cref seq_property$$
514
515		$head Purpose$$
516		Determine the number of Taylor coefficients, per variable,
517		currently calculated and stored in the ADFun object $icode f$$.
518		See the discussion under
519		$cref/Constructor/size_taylor/Constructor/$$,
520		$cref/Forward/size_taylor/Forward/$$, and
521		$cref/capacity_taylor/size_taylor/capacity_taylor/$$
522		for a description of when this value can change.
523
524
525		$head f$$
526		The object $icode f$$ has prototype
527		$codei%
528		const ADFun<%Base%> %f%
529		%$$
530
531		$head s$$
532		The result $icode s$$ has prototype
533		$codei%
534		size_t %s%
535		%$$
536		and is the number of Taylor coefficients,
537		per variable in the AD operation sequence,
538		currently calculated and stored in the ADFun object $icode f$$.
539
540		$head Constructor$$
541		Directly after the $cref FunConstruct$$ syntax
542		$codei%
543		ADFun<%Base%> %f%(%x%, %y%)
544		%$$
545		the value of $icode s$$ returned by $code size_taylor$$ is one.
546		This is because
547		there is an implicit call to $code Forward$$ that computes
548		the zero order Taylor coefficients during this constructor.
549
550		$head Forward$$
551		After a call to $cref/Forward/ForwardAny/$$ with the syntax
552		$codei%
553		%f%.Forward(%p%, %x_p%)
554		%$$
555		the value of $icode s$$ returned by $code size_taylor$$
556		would be $latex p + 1$$.
557		The call to $code Forward$$ above
558		uses the lower order Taylor coefficients to compute and store
559		the $th p$$ order Taylor coefficients for all
560		the variables in the operation sequence corresponding to $icode f$$.
561		Thus there are $latex p + 1$$ (order zero through $icode p$$)
562		Taylor coefficients per variable.
563		(You can determine the number of variables in the operation sequence
564		using the $cref/size_var/seq_property/size_var/$$ function.)
565
566		$head capacity_taylor$$
567		If the number of Taylor coefficients
568		currently stored in $icode f$$ is less than or equal $icode c$$,
569		a call to $cref capacity_taylor$$ with the syntax
570		$codei%
571		%f%.capacity_taylor(%c%)
572		%$$
573		does not affect the value $icode s$$ returned by $code size_taylor$$.
574		Otherwise,
575		the value $icode s$$ returned by $code size_taylor$$
576		is equal to $icode c$$
577		(only Taylor coefficients of order zero through $latex c-1$$
578		have been retained).
579
580		$head Example$$
581		The file
582		$cref forward.cpp$$
583		contains an example and test of this operation.
584		It returns true if it succeeds and false otherwise.
585
586		$end
587		-----------------------------------------------------------------------------
588		$begin CompareChange$$
589		$spell
590		const
591		$$
592
593		$section Comparison Changes During Zero Order Forward Mode$$
594
595		$index ADFun, CompareChange$$
596		$index CompareChange, ADFun$$
597		$index zero, order forward$$
598		$index forward, zero order$$
599
600		$head Syntax$$
601		$icode%c% = %f%.CompareChange()%$$
602		$pre
603		$$
604		$bold See Also$$
605		$cref FunCheck$$
606
607
608		$head Purpose$$
609		We use $latex F : B^n \rightarrow B^m$$ to denote the
610		$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
611		This function may be not agree with the algorithm that was used
612		to create the corresponding
613		AD of $icode Base$$
614		$cref/operation sequence/glossary/Operation/Sequence/$$
615		because of changes in AD
616		$cref/comparison/Compare/$$ results.
617		The $code CompareChange$$ function can be used to detect these changes.
618
619		$head f$$
620		The object $icode f$$ has prototype
621		$codei%
622		const ADFun<%Base%> %f%
623		%$$
624
625		$head c$$
626		The result $icode c$$ has prototype
627		$codei%
628		size_t %c%
629		%$$
630		It is the number of
631		$codei%AD<%Base%>%$$ $cref/comparison/Compare/$$
632		operations,
633		corresponding to the previous call to $cref Forward$$
634		$codei%
635		%f%.Forward(0, %x%)
636		%$$
637		that have a different result from
638		when $icode F$$ was created by taping an algorithm.
639
640		$head Discussion$$
641		If $icode c$$ is not zero,
642		the boolean values resulting from some of the
643		$cref/comparison operations/Compare/$$ corresponding to $icode x$$
644		are different from when the
645		AD of $icode Base$$
646		$cref/operation sequence/glossary/Operation/Sequence/$$ was created.
647		In this case, you may want to re-tape the algorithm with the
648		$cref/independent variables/glossary/Tape/Independent Variable/$$
649		equal to the values in $icode x$$
650		(so AD operation sequence properly represents the algorithm
651		for this value of independent variables).
652		On the other hand, re-taping the AD operation sequence usually takes
653		significantly more time than evaluation using $cref ForwardZero$$.
654		If the functions values have not changed (see $cref FunCheck$$)
655		it may not be worth re-taping a new AD operation sequence.
656
657		$head Restrictions$$
658		$index NDEBUG, CompareChange$$
659		Computation of this function requires extra operations in the tape.
660		If $cref/NDEBUG/Faq/Speed/NDEBUG/$$ is defined,
661		of if a tape $cref/optimization/optimize/$$ has been preformed,
662		these operations are not included in the tape and
663		the value of $icode c$$ is always zero (and does not correspond
664		to the actual number of comparison changes).
665
666		$head Example$$
667		$children%
668		example/compare_change.cpp
669		%$$
670		The file
671		$cref compare_change.cpp$$
672		contains an example and test of this operation.
673		They return true if they succeed and false otherwise.
674
675		$end

-221

~~omh/forward_theory.omh~~ less more

0		$Id: forward_theory.omh 2506 2012-10-24 19:36:49Z bradbell $
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		$begin ForwardTheory$$
13		$spell
14		Taylor
15		$$
16
17		$section The Theory of Forward Mode$$
18
19		$head Taylor Notation$$
20		In Taylor notation, each variable corresponds to
21		a function of a single argument which we denote by $icode t$$
22		(see Section 10.2 of
23		$cref/Evaluating Derivatives/Bib/Evaluating Derivatives/$$).
24		Here and below
25		$latex X(t)$$, $latex Y(t)$$, and $icode Z(t)$$ are scalar valued functions
26		and the corresponding $th p$$ order Taylor coefficients row vectors are
27		$latex x$$, $latex y$$ and $latex z$$; i.e.,
28		$latex \[
29		\begin{array}{lcr}
30		X(t) & = & x^{(0)} + x^{(1)} * t + \cdots + x^{(p)} * t^p + o( t^p ) \\
31		Y(t) & = & y^{(0)} + y^{(1)} * t + \cdots + y^{(p)} * t^p + o( t^p ) \\
32		Z(t) & = & z^{(0)} + z^{(1)} * t + \cdots + z^{(p)} * t^p + o( t^p )
33		\end{array}
34		\] $$
35		For the purposes of this section, we are given $latex x$$ and $latex y$$
36		and need to determine $latex z$$.
37
38		$head Binary Operators$$
39
40		$subhead Addition$$
41		$latex \[
42		\begin{array}{rcl}
43		Z(t)
44		& = & X(t) + Y(t)
45		\\
46		\sum_{j=0}^p z^{(j)} * t^j
47		& = & \sum_{j=0}^p x^{(j)} * t^j + \sum_{j=0}^p y^{(j)} * t^j + o( t^p )
48		\\
49		z^{(j)} & = & x^{(j)} + y^{(j)}
50		\end{array}
51		\] $$
52
53		$subhead Subtraction$$
54		$latex \[
55		\begin{array}{rcl}
56		Z(t)
57		& = & X(t) - Y(t)
58		\\
59		\sum_{j=0}^p z^{(j)} * t^j
60		& = & \sum_{j=0}^p x^{(j)} * t^j - \sum_{j=0}^p y^{(j)} * t^j + o( t^p )
61		\\
62		z^{(j)} & = & x^{(j)} - y^{(j)}
63		\end{array}
64		\] $$
65
66		$subhead Multiplication$$
67		$latex \[
68		\begin{array}{rcl}
69		Z(t)
70		& = & X(t) * Y(t)
71		\\
72		\sum_{j=0}^p z^{(j)} * t^j
73		& = & \left( \sum_{j=0}^p x^{(j)} * t^j \right)
74		*
75		\left( \sum_{j=0}^p y^{(j)} * t^j \right) + o( t^p )
76		\\
77		z^{(j)} & = & \sum_{k=0}^j x^{(j-k)} * y^{(k)}
78		\end{array}
79		\] $$
80
81		$subhead Division$$
82		$latex \[
83		\begin{array}{rcl}
84		Z(t)
85		& = & X(t) / Y(t)
86		\\
87		x
88		& = & z * y
89		\\
90		\sum_{j=0}^p x^{(j)} * t^j
91		& = &
92		\left( \sum_{j=0}^p z^{(j)} * t^j \right)
93		*
94		\left( \sum_{j=0}^p y^{(j)} * t^j \right)
95		+
96		o( t^p )
97		\\
98		x^{(j)} & = & \sum_{k=0}^j z^{(j-k)} y^{(k)}
99		\\
100		z^{(j)} & = & \frac{1}{y^{(0)}} \left( x^{(j)} - \sum_{k=1}^j z^{(j-k)} y^{(k)} \right)
101		\end{array}
102
103		\] $$
104
105		$head Standard Math Functions$$
106		Suppose that $latex F $$ is a standard math function and
107		$latex \[
108		Z(t) = F[ X(t) ]
109		\]$$
110
111		$subhead Differential Equation$$
112		All of the standard math functions
113		satisfy a differential equation of the form
114		$latex \[
115		B(u) * F^{(1)} (u) - A(u) * F (u) = D(u)
116		\] $$
117		We use $latex a$$, $latex b$$ and $latex d$$ to denote the
118		$th p$$ order Taylor coefficient row vectors for
119		$latex A [ X (t) ] $$, $latex B [ X (t) ]$$ and $latex D [ X (t) ] $$
120		respectively.
121		We assume that these coefficients are known functions of $latex x$$,
122		the $th p$$ order Taylor coefficients for $latex X(t)$$.
123
124		$subhead Taylor Coefficients Recursion Formula$$
125		Our problem here is to express $latex z$$,
126		the $th p$$ order Taylor coefficient row vector for $latex Z(t)$$,
127		in terms of these other known coefficients.
128		It follows from the formulas above that
129		$latex \[
130		\begin{array}{rcl}
131		Z^{(1)} (t)
132		& = & F^{(1)} [ X(t) ] * X^{(1)} (t)
133		\\
134		B[ X(t) ] * Z^{(1)} (t)
135		& = & \{ D[ X(t) ] + A[ X(t) ] * Z(t) \} * X^{(1)} (t)
136		\\
137		B[ X(t) ] * Z^{(1)} (t) & = & E(t) * X^{(1)} (t)
138		\end{array}
139		\] $$
140		where we define
141		$latex \[
142		E(t) = D[X(t)] + A[X(t)] * Z(t)
143		\] $$
144
145		We can compute the value of $latex z^{(0)}$$ using the formula
146		$latex \[
147		z^{(0)} = F ( x^{(0)} )
148		\]$$
149		Suppose by induction (on $latex j$$) that we are given the
150		Taylor coefficients of $latex E(t)$$ up to order $latex j-1$$; i.e.,
151		$latex e^{(k)}$$ for $latex k = 0 , \ldots , j-1$$
152		and the coefficients
153		$latex z^{(k)}$$ for $latex k = 0 , \ldots , j$$.
154		We can compute $latex e^{(j)}$$ using the formula
155		$latex \[
156		e^{(j)} = d^{(j)} + \sum_{k=0}^j a^{(j-k)} * z^{(k)}
157		\] $$
158		We need to complete the induction by finding formulas for $latex z^{(j+1)}$$.
159		It follows for the formula for the
160		$cref/multiplication/ForwardTheory/Binary Operators/Multiplication/$$
161		operator that
162		$latex \[
163		\begin{array}{rcl}
164		\left( \sum_{k=0}^j b^{(k)} t^k \right)
165		*
166		\left( \sum_{k=1}^{j+1} k z^{(k)} * t^{k-1} \right)
167		& = &
168		\left( \sum_{k=0}^j e^{(k)} * t^k \right)
169		*
170		\left( \sum_{k=1}^{j+1} k x^{(k)} * t^{k-1} \right)
171		+
172		o( t^p )
173		\\
174		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
175		\left(
176		\sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
177		- \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
178		\right)
179		\\
180		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
181		\left(
182		\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
183		- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
184		\right)
185		\end{array}
186		\] $$
187		This completes the induction that computes $latex e^{(j)}$$
188		and $latex z^{(j+1)}$$.
189
190
191
192
193		$children%
194		omh/exp_forward.omh%
195		omh/log_forward.omh%
196		omh/sqrt_forward.omh%
197		omh/sin_cos_forward.omh%
198		omh/atan_forward.omh%
199		omh/asin_forward.omh%
200		omh/acos_forward.omh%
201		omh/tan_forward.omh
202		%$$
203
204		$subhead Cases that Apply Recursion Above$$
205		$table
206		$rref ExpForward$$
207		$rref LogForward$$
208		$rref SqrtForward$$
209		$rref SinCosForward$$
210		$rref AtanForward$$
211		$rref AsinForward$$
212		$rref AcosForward$$
213		$tend
214
215		$subhead Special Cases$$
216		$table
217		$rref tan_forward$$
218		$tend
219
220		$end

+54

-37

omh/install/cmake.omh less more

0		$Id: cmake.omh 3064 2013-12-28 18:01:30Z bradbell $
	0	$Id: cmake.omh 3476 2014-12-16 17:15:01Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

12	12	$begin cmake$$
13	13	$escape $$
14	14	$spell
	15	cstdint
	16	uint
	17	pkgconfig
15	18	ctor
16	19	op
17	20	arg

42	45	fadbad
43	46	sacado
44	47	datadir
	48	docdir
45	49	includedirs
46	50	libdirs
47	51	cxx

71	75	$index cmake, command$$
72	76	$index configure, cppad$$
73	77	$index cppad, configure$$
74		The command below assume that $code cmake$$ is in your execution
	78	The command below assumes that $code cmake$$ is in your execution
75	79	path. If not, you can put the path to $code cmake$$ in font the command.
76	80	Only the $code cmake$$ command and the path to the distribution directory
77	81	($code ..$$ at the end of the command below) are required.
78	82	In other words, the first and last lines below are required
79	83	and all of the other lines are optional.
	84
	85	$subhead Build Directory$$
80	86	Create a $code build$$ subdirectory of the
81	87	$cref/distribution directory/download/Distribution Directory/$$,
82	88	change into the $code build$$ directory,

87	93	-D cmake_install_prefix=%cmake_install_prefix% \
88	94	-D cmake_install_includedirs=%cmake_install_includedirs% \
89	95	-D cmake_install_datadir=%cmake_install_datadir% \
	96	-D cmake_install_docdir=%cmake_install_docdir% \
90	97	-D cmake_install_libdirs=%cmake_install_libdirs% \
91	98	-D cmake_install_postfix=%cmake_install_postfix% \
92	99	\
93	100	-D adolc_prefix=%adolc_prefix% \
	101	-D colpack_prefix=%colpack_prefix% \
94	102	-D eigen_prefix=%eigen_prefix% \
95	103	-D fadbad_prefix=%fadbad_prefix% \
96	104	-D ipopt_prefix=%ipopt_prefix% \
97	105	-D sacado_prefix=%sacado_prefix% \
98	106	\
99	107	-D cppad_cxx_flags=%cppad_cxx_flags% \
100		-D cppad_documentation=%cppad_documentation% \
101	108	\
102	109	-D cppad_testvector=%cppad_testvector% \
103	110	-D cppad_max_num_threads=%cppad_max_num_threads% \

162	169	The default value for this directory is $code share$$.
163	170	For example, if
164	171	$icode cmake_install_prefix$$ and
	172	$icode cmake_install_postfix$$ are not specified,
	173	the $cref pkgconfig$$ file $code cppad.pc$$ will be installed in the location
	174	$codei%
	175	/usr/share/pkgconfig/cppad.pc
	176	%$$
	177
	178	$head cmake_install_docdir$$
	179	$index install, data directory$$
	180	$index data directory, install$$
	181	This is the directory is present, the documentation files are installed
	182	in this sub-directory below the $icode cmake_install_prefix$$.
	183	For example, if
	184	$icode cmake_install_prefix$$ and
165	185	$icode cmake_install_postfix$$ are not specified, and
166		$icode cppad_documentation$$ is $code YES$$,
167		the file $code doc/cppad.xml$$ will be installed in the location
168		$codei%
169		/usr/share/doc/cppad-%version%/cppad.xml
170		%$$
171		where $icode version$$ is version number for this copy of CppAD.
	186	$codei%
	187	-D cmake_install_docdir=share/doc
	188	%$$
	189	the file $code cppad.xml$$ will be installed in the location
	190	$codei%
	191	/usr/share/doc/cppad/cppad.xml
	192	%$$
172	193
173	194	$head cmake_install_libdirs$$
174	195	$index install, library directories$$

203	224	if $icode cmake_install_prefix$$ and
204	225	$icode cmake_install_postfix$$ are not specified, and
205	226	$codei%
206		-D cppad_documentation=YES
207	227	-D cmake_install_postfix=coin
208	228	%$$
209		the file $code cppad.xml$$ will be installed in the location
210		$codei%
211		/usr/share/coin/doc/cppad-%version%/cppad.xml
	229	the $cref pkgconfig$$ file $code cppad.pc$$ will be installed in the location
	230	$codei%
	231	/usr/share/coin/pkgconfig/cppad.pc
212	232	%$$
213	233
214	234	$head package_prefix$$

216	236	$index prefix, package$$
217	237	$table
218	238	$rref adolc_prefix$$
	239	$rref colpack_prefix$$
219	240	$rref eigen_prefix$$
220	241	$rref fadbad_prefix$$
221	242	$rref ipopt_prefix$$

242	263	Hence the $code -Wshadow$$ flag is automatically removed when
243	264	compiling examples and test that use these packages.
244	265
245		$head cppad_documentation$$
246		$index install, cppad documentation$$
247		$index cppad, install documentation$$
248		$index documentation, install$$
249		The default value for $icode cppad_documentation$$ is $code NO$$.
250		If $icode cppad_documentation$$ is $code YES$$,
251		and $cref/cmake_install_postfix/cmake/cmake_install_postfix/$$ is empty,
252		the CppAD XML documentation files will be installed in the directory
253		$codei%
254		%prefix%/%datadir%/doc/cppad-%version%
255		%$$
256		where $icode prefix$$ is
257		$cref/cmake_install_prefix/cmake/cmake_install_prefix/$$,
258		$icode datadir$$ is
259		$cref/cmake_install_datadir/cmake/cmake_install_datadir/$$,
260		and $icode version$$ is the version number for this copy of CppAD.
261		If $icode cmake_install_postfix$$ is non-empty,
262		the CppAD XML documentation files will be installed in the directory
263		$codei%
264		%prefix%/%datadir%/doc/%postfix%/cppad-%version%
265		%$$
266		where $icode postfix$$ is $icode cmake_install_postfix$$.
267
268	266	$head cppad_testvector$$
269	267	See $tref cppad_testvector$$.
270	268

303	301	The type $icode cppad_tape_id_type$$
304	302	is used for identifying different tapes.
305	303	The valid values for this type are
	304	$code unsigned char$$,
306	305	$code unsigned short int$$,
307	306	$code unsigned int$$, and
308	307	$code size_t$$.

314	313	%$$
315	314	must be larger than the maximum number of tapes used by one thread times
316	315	$cref/CPPAD_MAX_NUM_THREADS/multi_thread/CPPAD_MAX_NUM_THREADS/$$.
	316
	317	$subhead cstdint$$
	318	If all of the following $code cstdint$$ types are defined,
	319	they can also be used as the value of $icode cppad_tape_addr_type$$:
	320	$code uint8_t$$,
	321	$code uint16_t$$,
	322	$code uint32_t$$,
	323	$code uint64_t$$.
317	324
318	325	$head cppad_tape_addr_type$$
319	326	$index memory, usage$$

322	329	The type $icode cppad_tape_addr_type$$
323	330	is used for address in the AD recordings (tapes).
324	331	The valid values for this argument are
	332	$code unsigned char$$,
325	333	$code unsigned short int$$,
326	334	$code unsigned int$$,
327	335	$code size_t$$.

337	345	$cref/size_par/seq_property/size_text/$$,
338	346	$cref/size_par/seq_property/size_par/$$,
339	347	$cref/size_par/seq_property/size_VecAD/$$.
	348
	349	$subhead cstdint$$
	350	If all of the following $code cstdint$$ types are defined,
	351	they can also be used as the value of $icode cppad_tape_addr_type$$:
	352	$code uint8_t$$,
	353	$code uint16_t$$,
	354	$code uint32_t$$,
	355	$code uint64_t$$.
340	356
341	357	$head cppad_implicit_ctor_from_any_type$$
342	358	$index ctor, implicit or explicit$$

353	369
354	370	$children%
355	371	omh/install/adolc_prefix.omh%
	372	omh/install/colpack_prefix.omh%
356	373	omh/install/eigen_prefix.omh%
357	374	omh/install/fadbad_prefix.omh%
358	375	omh/install/ipopt_prefix.omh%

+79

-0

omh/install/cmake_check.omh less more

	0	/* $Id: cmake_check.omh 3114 2014-02-22 16:20:39Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin cmake_check$$
	12	$spell
	13	nlp
	14	cppad
	15	makefiles
	16	ipopt
	17	CppAD
	18	cmake
	19	nmake
	20	$$
	21
	22	$section Checking the CppAD Examples and Tests$$
	23
	24	$head Purpose$$
	25	After you configure your system with the
	26	$cref/cmake command/cmake/CMake Command/$$ you
	27	can run the CppAD example and tests to make sure that
	28	CppAD functions properly on your system.
	29
	30
	31	$head Check All$$
	32	In the $code build$$ subdirectory of the
	33	$cref/distribution directory/download/Distribution Directory/$$
	34	execute the command
	35	$codep
	36	make check
	37	$$
	38	This will build and run all of the tests that are support
	39	by your system and the $cref cmake$$ command options.
	40	If you created $code nmake$$ makefiles, you will have
	41	to use $code nmake$$ instead of $code make$$ in the command above; see
	42	the $cref/generator/cmake/generator/$$ option for the $code cmake$$ command.
	43
	44	$head Subsets$$
	45	It is possible to build and run the following subsets of the
	46	examples and tests:
	47	$table
	48	Command $cnext
	49	Description
	50	$rnext
	51	$code make check_compare_c$$ $cnext
	52	$tref compare_c$$
	53	$rnext
	54	$code make check_introduction$$ $cnext
	55	the programs in the $cref Introduction$$
	56	$rnext
	57	$code make check_example$$ $cnext
	58	most of the $cref Example$$ programs
	59	$rnext
	60	$code make check_print_for$$ $cnext
	61	the $cref PrintFor$$ command
	62	$rnext
	63	$code make check_test_more$$ $cnext
	64	correctness tests that are not examples
	65	$rnext
	66	$code make check_multi_thread$$ $cnext
	67	$cref multi_thread$$ tests (run correctness only)
	68	$rnext
	69	$code make check_speed$$ $cnext
	70	single threading $cref speed$$ tests (run correctness only)
	71	$rnext
	72	$code make check_cppad_ipopt$$ $cnext
	73	the $cref cppad_ipopt_nlp$$ speed and correctness tests
	74	$rnext
	75	$tend
	76
	77
	78	$end

+89

-0

omh/install/colpack_prefix.omh less more

	0	/* $Id: colpack_prefix.omh 3309 2014-05-28 00:08:58Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin colpack_prefix$$
	12	$dollar @$$
	13	$spell
	14	datadir
	15	cppad.hpp
	16	namespace
	17	std
	18	CppAD
	19	includedirs
	20	colpack
	21	cmake
	22	dir
	23	Jacobians
	24	$$
	25
	26	$section Including the ColPack Sparsity Calculations$$
	27	$index colpack, sparsity$$
	28	$index sparsity, colpack$$
	29
	30	$head Purpose$$
	31	If you specify a $icode colpack_prefix$$ on the
	32	$cref/cmake command/cmake/CMake Command/$$ line,
	33	the CppAD $cref sparse_jacobian$$ calculations use the
	34	$href%http://http://cscapes.cs.purdue.edu/coloringpage/%ColPack%$$ package.
	35
	36	$head colpack_prefix$$
	37	$index colpack, prefix$$
	38	$index prefix, colpack$$
	39	If ColPack is installed on your system, you can
	40	specify a value for its install $icode colpack_prefix$$ on the
	41	$cref cmake$$ command line.
	42	The value of $icode colpack_prefix$$ must be such that,
	43	for one of the directories $icode dir$$ in
	44	$cref/cmake_install_includedirs/cmake/cmake_install_includedirs/$$,
	45	$codei%
	46	%colpack_prefix%/%dir%/ColPack/ColPackHeaders.h
	47	%$$
	48	is a valid way to reference to the include file $code ColPackHeaders.h$$.
	49
	50	$head cppad_colpack.cpp$$
	51	$index cppad_colpack.cpp$$
	52	The ColPack header files has a
	53	$codei%
	54	using namespace std
	55	%$$
	56	at the global level.
	57	For this reason, CppAD does not include these files.
	58	It is therefore necessary to compile and link the short file
	59	$codei%
	60	%prefix%/%dir%/cppad/cppad_colpack.cpp
	61	%$$
	62	where $icode dir$$ is the
	63	$cref/cmake_install_datadir/cmake/cmake_install_datadir/$$ and
	64	where $icode prefix$$ is such that $code cppad.hpp$$ was installed in
	65	$codei%
	66	%prefix%/include/cppad/cppad.hpp
	67	%$$
	68	Hopefully, future versions of ColPack will not have this problem
	69	and it will no longer be necessary to do this.
	70
	71	$children%
	72	example/colpack.cpp%
	73	bin/get_colpack.sh
	74	%$$
	75	$head Example$$
	76	The file $cref colpack.cpp$$ contains an example and test of using
	77	ColPack to compute the coloring for sparse Jacobians.
	78	It returns true, if it succeeds and false otherwise.
	79
	80	$head get_colpack$$
	81	$index get, colpack$$
	82	$index colpack, get$$
	83	If you are using Unix, you can download and install
	84	a copy of ColPack using $cref get_colpack.sh$$.
	85	The corresponding $icode colpack_prefix$$ would be
	86	$code build/prefix$$.
	87
	88	$end

-78

~~omh/install/cppad_test.omh~~ less more

0		/* $Id: cppad_test.omh 2740 2013-01-12 16:56:53Z bradbell $ */
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11		$begin cppad_test$$
12		$spell
13		nlp
14		makefiles
15		ipopt
16		CppAD
17		cmake
18		nmake
19		$$
20
21		$section Running the CppAD Examples and Tests$$
22
23		$head Purpose$$
24		After you configure your system with the
25		$cref/cmake command/cmake/CMake Command/$$ you
26		can run the CppAD example and tests to make sure that
27		CppAD functions properly on your system.
28
29
30		$head Run All$$
31		In the $code build$$ subdirectory of the
32		$cref/distribution directory/download/Distribution Directory/$$
33		execute the command
34		$codep
35		make check
36		$$
37		This will build and run all of the tests that are support
38		by your system and the $cref cmake$$ command options.
39		If you created $code nmake$$ makefiles, you will have
40		to use $code nmake$$ instead of $code make$$ in the command above; see
41		the $cref/generator/cmake/generator/$$ option for the $code cmake$$ command.
42
43		$head Subsets$$
44		It is possible to build and run the following subsets of the
45		examples and tests:
46		$table
47		Command $cnext
48		Description
49		$rnext
50		$code make check_compare_c$$ $cnext
51		$tref compare_c$$
52		$rnext
53		$code make check_example$$ $cnext
54		most of the $cref Example$$ programs
55		$rnext
56		$code make check_introduction$$ $cnext
57		the programs in the $cref Introduction$$
58		$rnext
59		$code make check_print_for$$ $cnext
60		the print_for command
61		$rnext
62		$code make check_test_more$$ $cnext
63		correctness tests that are not examples
64		$rnext
65		$code make check_multi_thread$$ $cnext
66		$cref multi_thread$$ tests (run correctness only)
67		$rnext
68		$code make check_speed$$ $cnext
69		single threading $cref speed$$ tests (run correctness only)
70		$rnext
71		$code make check_ipopt_nlp$$ $cnext
72		the $cref cppad_ipopt_nlp$$ speed and correctness tests
73		$rnext
74		$tend
75
76
77		$end

-4

omh/install/download.omh less more

0		$Id: download.omh 3099 2014-02-18 03:29:44Z bradbell $
	0	$Id: download.omh 3509 2014-12-27 20:38:37Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

60	60	$subhead Current Version$$
61	61	The download files below are for the current version of CppAD.
62	62	$table
63		EPL License $pre $$ $cnext $href%cppad-20140000.3.epl.tgz%$$
	63	EPL License $pre $$ $cnext $href%
	64	http://www.coin-or.org/download/source/CppAD/cppad-20150000.0.epl.tgz%
	65	cppad-20150000.0.epl.tgz%$$
64	66	$rnext
65		GPL License $pre $$ $cnext $href%cppad-20140000.3.gpl.tgz%$$
	67	GPL License $pre $$ $cnext $href%
	68	http://www.coin-or.org/download/source/CppAD/cppad-20150000.0.gpl.tgz%
	69	cppad-20150000.0.gpl.tgz%$$
66	70	$tend
67	71	These tarballs only last for a few days.
68	72

-8

omh/install/install.omh less more

0		$Id: install.omh 2606 2012-12-15 14:08:30Z bradbell $
	0	$Id: install.omh 3114 2014-02-22 16:20:39Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

26	26
27	27	$head Instructions$$
28	28
29		$subhead Download$$
	29	$subhead Step 1: Download$$
30	30	Use the $cref download$$ instructions to obtain a copy or CppAD.
31	31
32		$subhead Cmake$$
	32	$subhead Step 2: Cmake$$
33	33	Use the $cref cmake$$ instructions to configure CppAD.
34	34
35		$subhead Test$$
36		Use the $cref cppad_test$$ instructions to test CppAD.
	35	$subhead Step 3: Check$$
	36	Use the $cref cmake_check$$ instructions to check the
	37	CppAD examples and tests.
37	38
38		$subhead Install$$
	39	$subhead Step 4: Install$$
39	40	Use the command
40	41	$codep
41	42	make install

53	54	$childtable%
54	55	omh/install/download.omh%
55	56	omh/install/cmake.omh%
56		omh/install/cppad_test.omh%
	57	omh/install/cmake_check.omh%
57	58	omh/install/pkgconfig.omh%
58	59	omh/install/unix.omh
59	60	%$$

-3

omh/install/pkgconfig.omh less more

0		// $Id: pkgconfig.omh 2606 2012-12-15 14:08:30Z bradbell $
	0	// $Id: pkgconfig.omh 3114 2014-02-22 16:20:39Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

94	94	$icode File$$ $cnext
95	95	$icode Description$$ $rnext
96	96	$icode%prefix%/%datadir%/pkgconfig/cppad.pc%$$ $cnext
97		for use after $cref/make install/install/Instructions/Install/$$
	97	for use after $cref/make install/install/Instructions/Step 4: Install/$$
98	98	$rnext
99	99	$icode%builddir%/pkgconfig/cppad-uninstalled.pc%$$ $cnext
100	100	for testing before $code make install$$

-4

omh/install/unix.omh less more

0		$Id: unix.omh 3067 2013-12-29 17:35:34Z bradbell $
	0	$Id: unix.omh 3496 2014-12-24 12:18:44Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

78	78	$index free, unix install$$
79	79	$index install, unix CppAD$$
80	80
81		$section Unix Test and Installation$$
	81	$section Deprecated Unix Test and Installation$$
82	82
83	83	$head Deprecated$$
84		These install instructions have been deprecated.
	84	These install instructions have been deprecated and no improvements
	85	have been added since 2012.
	86	For example, this install procedure will not detect any of the
	87	$code c++11$$ extensions.
85	88	You should use the $cref cmake$$ instructions to install CppAD.
86	89
87	90	$head Distribution Directory$$

-83

~~omh/log_forward.omh~~ less more

0		$Id: log_forward.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin LogForward$$
15		$spell
16		Taylor
17		$$
18
19		$index log, forward theory$$
20		$index theory, log forward$$
21		$index forward, log theory$$
22
23		$section Logarithm Function Forward Taylor Polynomial Theory$$
24
25		If $latex F(x) = \log(x) $$
26		$latex \[
27		x * F^{(1)} (x) - 0 * F (x) = 1
28		\] $$
29		and in the
30		$xref/
31		ForwardTheory/
32		Standard Math Functions/
33		Differential Equation/
34		standard math function differential equation/
35		1
36		/$$,
37		$latex A(x) = 0$$,
38		$latex B(x) = x$$,
39		and $latex D(x) = 1$$.
40		We use $latex a$$, $latex b$$, $latex d$$,
41		and $latex z$$ to denote the
42		Taylor coefficients for
43		$latex A [ X (t) ] $$,
44		$latex B [ X (t) ]$$,
45		$latex D [ X (t) ] $$,
46		and $latex F [ X(t) ] $$ respectively.
47		It now follows from the general
48		$xref/
49		ForwardTheory/
50		Standard Math Functions/
51		Taylor Coefficients Recursion Formula/
52		Taylor coefficients recursion formula/
53		1
54		/$$
55		that for $latex j = 0 , 1, \ldots$$,
56		$latex \[
57		\begin{array}{rcl}
58		z^{(0)} & = & \log ( x^{(0)} )
59		\\
60		e^{(j)}
61		& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
62		\\
63		& = & \left\{ \begin{array}{ll}
64		1 & {\rm if} \; j = 0 \\
65		0 & {\rm otherwise}
66		\end{array} \right.
67		\\
68		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
69		\left(
70		\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
71		- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
72		\right)
73		\\
74		& = & \frac{1}{j+1} \frac{1}{ x^{(0)} }
75		\left(
76		(j+1) x^{(j+1) }
77		- \sum_{k=1}^j k z^{(k)} x^{(j+1-k)}
78		\right)
79		\end{array}
80		\] $$
81
82		$end

-87

~~omh/log_reverse.omh~~ less more

0		$Id: log_reverse.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin LogReverse$$
15		$spell
16		Taylor
17		$$
18
19		$index log, reverse theory$$
20		$index theory, log reverse$$
21		$index reverse, log theory$$
22
23		$section Logarithm Function Reverse Mode Theory$$
24
25
26		We use the reverse theory
27		$xref%
28		ReverseTheory%
29		Standard Math Functions%
30		standard math function
31		%$$
32		definition for the functions $latex H$$ and $latex G$$.
33
34		The forward mode formulas for the
35		$cref/logarithm/LogForward/$$
36		function are
37		$latex \[
38		z^{(j)} = \log ( x^{(0)} )
39		\] $$
40
41		for the case $latex j = 0$$, and for $latex j > 0$$,
42
43		$latex \[
44		z^{(j)}
45		= \frac{1}{ x^{(0)} } \frac{1}{j}
46		\left(
47		j x^{(j)}
48		- \sum_{k=1}^{j-1} k z^{(k)} x^{(j-k)}
49		\right)
50		\] $$
51		otherwise.
52		If $latex j = 0$$, we have the relation
53		$latex \[
54		\D{H}{ x^{(j)} } =
55		\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{ x^{(0)} }
56		\] $$
57
58		If $latex j > 0$$, then for $latex k = 1 , \ldots , j-1$$
59
60		$latex \[
61		\begin{array}{rcl}
62		\D{H}{ x^{(0)} } & = &
63		\D{G}{ x^{(0)} } - \D{G}{ z^{(j)} } \frac{1}{ x^{(0)} }
64		\frac{1}{ x^{(0)} } \frac{1}{j}
65		\left(
66		j x^{(j)}
67		- \sum_{m=1}^{j-1} m z^{(m)} x^{(j-m)}
68		\right)
69		\\
70		& = &
71		\D{G}{ x^{(0)} } - \D{G}{ z^{(j)} } \frac{1}{ x^{(0)} } z^{(j)}
72		\\
73		\D{H}{ x^{(j)} } & = &
74		\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{ x^{(0)} }
75		\\
76		\D{H}{ x^{(j-k)} } & = &
77		\D{G}{ x^{(j-k)} } -
78		\D{G}{ z^{(j)} } \frac{1}{ x^{(0)} } \frac{1}{j} k z^{(k)}
79		\\
80		\D{H}{ z^{(k)} } & = &
81		\D{G}{ z^{(k)} } -
82		\D{G}{ z^{(j)} } \frac{1}{ x^{(0)} } \frac{1}{j} k x^{(j-k)}
83		\end{array}
84		\] $$
85
86		$end

+33

-0

omh/reverse/reverse.omh less more

	0	/* $Id: reverse.omh 3301 2014-05-24 05:20:21Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin Reverse$$
	12	$spell
	13	xq
	14	$$
	15
	16	$section Reverse Mode$$
	17
	18	$head Multiple Directions$$
	19	Reverse mode after $cref/Forward(q, r, xq)/forward_dir/$$
	20	with number of directions $icode%r% != 1%$$ is not yet supported.
	21	There is one exception, $cref reverse_one$$ is allowed
	22	because there is only one zero order forward direction.
	23	After such an operation, only the zero order forward
	24	results are retained (the higher order forward results are lost).
	25
	26	$childtable%
	27	omh/reverse/reverse_one.omh%
	28	omh/reverse/reverse_two.omh%
	29	omh/reverse/reverse_any.omh
	30	%$$
	31
	32	$end

+244

-0

omh/reverse/reverse_any.omh less more

	0	/* $Id: reverse_any.omh 3348 2014-09-21 09:24:45Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin reverse_any$$
	12	$spell
	13	checkpointing
	14	typename
	15	xk
	16	xp
	17	dw
	18	Ind
	19	uj
	20	std
	21	arg
	22	const
	23	Taylor
	24	$$
	25
	26	$section Any Order Reverse Mode$$
	27
	28
	29	$index reverse, any order mode$$
	30	$index any, order reverse mode$$
	31	$index mode, any order reverse$$
	32	$index derivative, reverse mode$$
	33
	34	$head Syntax$$
	35	$icode%dw% = %f%.Reverse(%q%, %w%)%$$
	36
	37
	38	$head Purpose$$
	39	We use $latex F : B^n \rightarrow B^m$$ to denote the
	40	$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
	41	Reverse mode computes the derivative of the $cref Forward$$ mode
	42	$cref/Taylor coefficients/glossary/Taylor Coefficient/$$
	43	with respect to the domain variable $latex x$$.
	44	To be specific, it computes the derivative
	45	$latex W^{(1)} (u)$$ at $latex u = x$$
	46	which is specified by the following notation:
	47
	48	$head Notation$$
	49
	50	$subhead u^(k)$$
	51	For $latex k = 0, \ldots , q-1$$,
	52	the vector $latex u^{(k)} \in B^n$$ is defined as the value of
	53	$icode x_k$$ in the previous calls of the form
	54	$codei%
	55	%f%.Forward(%k%, %x_k%)
	56	%$$
	57	If there is no previous call with $latex k = 0$$,
	58	$latex u^{(0)}$$ is the value of the independent variables when the
	59	corresponding
	60	AD of $icode Base$$
	61	$cref/operation sequence/glossary/Operation/Sequence/$$ was recorded.
	62
	63
	64	$subhead X(t, u)$$
	65	The function
	66	$latex X : B \times B^{n \times q} \rightarrow B^n$$ is defined by
	67	$latex \[
	68	X ( t , u ) = u^{(0)} + u^{(1)} * t + \cdots + u^{(q-1)} * t^{q-1}
	69	\] $$
	70	Note that for $latex k = 0 , \ldots , q-1$$,
	71	$latex u^{(k)}$$ is related to the $th k$$ partial of $latex X(t, u)$$
	72	with respect to $latex t$$ by
	73	$latex \[
	74	u^{(k)} = \frac{1}{k !} \Dpow{k}{t} X(0, u)
	75	\] $$
	76
	77	$subhead Y(t, u)$$
	78	The function
	79	$latex Y : B \times B^{n \times q} \rightarrow B^m$$ is defined by
	80	$latex \[
	81	Y(t, u) = F [ X(t,u) ]
	82	\]$$
	83
	84	$subhead w^(k)$$
	85	If the argument $icode w$$ has size $icode%m% * %q%$$,
	86	for $latex k = 0 , \ldots , q-1$$ and $latex i = 0, \ldots , m-1$$,
	87	$latex \[
	88	w_i^{(k)} = w [ i * q + k ]
	89	\] $$
	90	If the argument $icode w$$ has size $icode m$$,
	91	for $latex k = 0 , \ldots , q-1$$ and $latex i = 0, \ldots , m-1$$,
	92	$latex \[
	93	w_i^{(k)} = \left\{ \begin{array}{ll}
	94	w [ i ] & {\rm if} \; k = q-1
	95	\\
	96	0 & {\rm otherwise}
	97	\end{array} \right.
	98	\] $$
	99
	100
	101	$subhead W(u)$$
	102	The function $latex W : B^{n \times q} \rightarrow B$$ is defined by
	103	$latex \[
	104	W(u) = \sum_{k=0}^{q-1} ( w^{(k)} )^\R{T} \frac{1}{k !} \Dpow{k}{t} Y(0, u)
	105	\] $$
	106
	107
	108	$head f$$
	109	The object $icode f$$ has prototype
	110	$codei%
	111	const ADFun<%Base%> %f%
	112	%$$
	113	Before this call to $code Reverse$$, the value returned by
	114	$codei%
	115	%f%.size_order()
	116	%$$
	117	must be greater than or equal $icode q$$
	118	(see $cref size_order$$).
	119
	120	$head q$$
	121	The argument $icode q$$ has prototype
	122	$codei%
	123	size_t %q%
	124	%$$
	125	and specifies the number of Taylor coefficient orders to be differentiated
	126	(for each variable).
	127
	128
	129	$head w$$
	130	The argument $icode w$$ has prototype
	131	$codei%
	132	const %Vector% &%w%
	133	%$$
	134	(see $cref/Vector/reverse_any/Vector/$$ below)
	135	and its size
	136	must be equal to $icode m$$ or $icode%m% * %q%$$,
	137	It specifies the weighting vector $icode w$$
	138	in the definition of
	139	$cref/W(u)/reverse_any/Notation/W(u)/$$.
	140
	141
	142	$head dw$$
	143	The return value $icode dw$$ has prototype
	144	$codei%
	145	%Vector% %dw%
	146	%$$
	147	(see $cref/Vector/reverse_any/Vector/$$ below).
	148	It is a vector with size $latex n \times q$$.
	149	For $latex j = 0, \ldots, n-1$$ and $latex k = 0 , \ldots , q-1$$
	150	If the argument $icode w$$ has size $icode%m% * %q%$$,
	151	$latex \[
	152	dw[ j * q + k ] = W^{(1)} ( x )_{j,k}
	153	\] $$
	154	where $latex u = x$$ is value of the Taylor coefficients where the
	155	derivative is evaluated.
	156	$pre
	157
	158	$$
	159	If the argument $icode w$$ has size $icode m$$,
	160	$latex \[
	161	dw[ j * q + q - k - 1 ] = W^{(1)} ( x )_{j,k}
	162	\] $$
	163	where $latex u = x$$ is value of the Taylor coefficients where the
	164	derivative is evaluated.
	165	Note the reverse order in which the order indices are stored.
	166	This is an unfortunate consequence of keeping $code Reverse$$ backward
	167	compatible.
	168
	169	$head First Order$$
	170	We consider the case where
	171	$icode%q% = 1%$$ and $icode%w%.size() == %m%$$.
	172	In this case
	173	$latex \[
	174	\begin{array}{rcl}
	175	W(u) & = & w_0 Y_0 (0, u) + \cdots + w_m Y_m (0, u)
	176	\\
	177	W(u) & = & w_0 F_0 [ X(0, u) ] + \cdots + w_m F_m [ X(0, u) ]
	178	\\
	179	W^{(1)} (x) & = &
	180	w_0 F_0^{(1)} ( x^{(0)} ) + \cdots + w_m F_m^{(1)} ( x^{(0)} )
	181	\end{array}
	182	\] $$
	183	This is the same as the result documented in $cref reverse_one$$.
	184
	185
	186	$head Second Order$$
	187	We consider the case where
	188	$icode%q% = 2%$$ and $icode%w%.size() == %m%$$.
	189	In this case
	190	$latex \[
	191	\begin{array}{rcl}
	192	W(u) & = & w_0 \partial_t Y_0 (0, u) + \cdots + w_m \partial_t Y_m (0, u)
	193	\\
	194	W(u) & = &
	195	w_0 \partial_t \{ F_0 [ X(t, u) ] \}_{t = 0}
	196	+ \cdots +
	197	w_m \partial_t \{ F_m [ X(t, u) ] \}_{t = 0}
	198	\\
	199	W(u) & = &
	200	w_0 F_0^{(1)} ( u^{(0)} ) u^{(1)}
	201	+ \cdots +
	202	w_0 F_m^{(1)} ( u^{(0)} ) u^{(1)}
	203	\\
	204	\partial_{u(0)} W(x) & = &
	205	w_0 ( x^{(1)} )^\R{T} F_0^{(2)} ( x^{(0)} )
	206	+ \cdots +
	207	w_m ( x^{(1)} )^\R{T} F_m^{(2)} ( x^{(0)} )
	208	\\
	209	\partial_{u(1)} W(x) & = &
	210	w_0 F_0^{(1)} ( x^{(0)} )
	211	+ \cdots +
	212	w_m F_m^{(1)} ( x^{(0)} )
	213	\end{array}
	214	\] $$
	215	where $latex \partial{u(0)} $$
	216	denotes partial with respect to $latex u^{(0)}$$.
	217	These are the same as the result documented in $cref reverse_two$$.
	218
	219
	220	$head Vector$$
	221	The type $icode Vector$$ must be a $cref SimpleVector$$ class with
	222	$cref/elements of type/SimpleVector/Elements of Specified Type/$$
	223	$icode Base$$.
	224	The routine $cref CheckSimpleVector$$ will generate an error message
	225	if this is not the case.
	226
	227
	228	$head Example$$
	229	$children%
	230	example/reverse_three.cpp%
	231	example/reverse_any.cpp
	232	%$$
	233
	234	$list number$$
	235	The file $cref reverse_three.cpp$$
	236	contains an example and test of using reverse mode
	237	to compute third order derivatives.
	238	$lnext
	239	The file $cref reverse_any.cpp$$
	240	contains an example and test of the general reverse mode case.
	241	$lend
	242
	243	$end

+106

-0

omh/reverse/reverse_one.omh less more

	0	/* $Id: reverse_one.omh 3214 2014-03-18 20:50:38Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin reverse_one$$
	12
	13	$section First Order Reverse Mode$$
	14	$spell
	15	taylor
	16	const
	17	dw
	18	$$
	19
	20	$index reverse, first order mode$$
	21	$index first, order reverse mode$$
	22	$index mode, first order reverse$$
	23	$index derivative, reverse mode$$
	24
	25	$head Syntax$$
	26	$icode%dw% = %f%.Reverse(1, %w%)%$$
	27
	28
	29	$head Purpose$$
	30	We use $latex F : B^n \rightarrow B^m$$ to denote the
	31	$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
	32	The function $latex W : B^n \rightarrow B$$ is defined by
	33	$latex \[
	34	W(x) = w_0 * F_0 ( x ) + \cdots + w_{m-1} * F_{m-1} (x)
	35	\] $$
	36	The result of this operation is the derivative
	37	$latex dw = W^{(1)} (x)$$; i.e.,
	38	$latex \[
	39	dw = w_0 * F_0^{(1)} ( x ) + \cdots + w_{m-1} * F_{m-1}^{(1)} (x)
	40	\] $$
	41	Note that if $latex w$$ is the $th i$$
	42	$cref/elementary vector/glossary/Elementary Vector/$$,
	43	$latex dw = F_i^{(1)} (x)$$.
	44
	45	$head f$$
	46	The object $icode f$$ has prototype
	47	$codei%
	48	const ADFun<%Base%> %f%
	49	%$$
	50	Before this call to $code Reverse$$, the value returned by
	51	$codei%
	52	%f%.size_order()
	53	%$$
	54	must be greater than or equal one (see $cref size_order$$).
	55
	56	$head x$$
	57	The vector $icode x$$ in expression for $icode dw$$ above
	58	corresponds to the previous call to $cref forward_zero$$
	59	using this ADFun object $icode f$$; i.e.,
	60	$codei%
	61	%f%.Forward(0, %x%)
	62	%$$
	63	If there is no previous call with the first argument zero,
	64	the value of the $cref/independent/Independent/$$ variables
	65	during the recording of the AD sequence of operations is used
	66	for $icode x$$.
	67
	68	$head w$$
	69	The argument $icode w$$ has prototype
	70	$codei%
	71	const %Vector% &%w%
	72	%$$
	73	(see $cref/Vector/reverse_one/Vector/$$ below)
	74	and its size
	75	must be equal to $icode m$$, the dimension of the
	76	$cref/range/seq_property/Range/$$ space for $icode f$$.
	77
	78	$head dw$$
	79	The result $icode dw$$ has prototype
	80	$codei%
	81	%Vector% %dw%
	82	%$$
	83	(see $cref/Vector/reverse_one/Vector/$$ below)
	84	and its value is the derivative $latex W^{(1)} (x)$$.
	85	The size of $icode dw$$
	86	is equal to $icode n$$, the dimension of the
	87	$cref/domain/seq_property/Domain/$$ space for $icode f$$.
	88
	89	$head Vector$$
	90	The type $icode Vector$$ must be a $cref SimpleVector$$ class with
	91	$cref/elements of type/SimpleVector/Elements of Specified Type/$$
	92	$icode Base$$.
	93	The routine $cref CheckSimpleVector$$ will generate an error message
	94	if this is not the case.
	95
	96	$head Example$$
	97	$children%
	98	example/reverse_one.cpp
	99	%$$
	100	The file
	101	$cref reverse_one.cpp$$
	102	contains an example and test of this operation.
	103	It returns true if it succeeds and false otherwise.
	104
	105	$end

+185

-0

omh/reverse/reverse_two.omh less more

	0	/* $Id: reverse_two.omh 3214 2014-03-18 20:50:38Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	$begin reverse_two$$
	12
	13	$section Second Order Reverse Mode$$
	14	$spell
	15	taylor
	16	const
	17	dw
	18	$$
	19
	20	$index reverse, second order mode$$
	21	$index second, order reverse mode$$
	22	$index mode, second order reverse$$
	23	$index derivative, reverse mode$$
	24
	25	$head Syntax$$
	26	$icode%dw% = %f%.Reverse(2, %w%)%$$
	27
	28	$head Purpose$$
	29	We use $latex F : B^n \rightarrow B^m$$ to denote the
	30	$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
	31	Reverse mode computes the derivative of the $cref Forward$$ mode
	32	$cref/Taylor coefficients/glossary/Taylor Coefficient/$$
	33	with respect to the domain variable $latex x$$.
	34
	35	$head x^(k)$$
	36	For $latex k = 0, 1$$,
	37	the vector $latex x^{(k)} \in B^n$$ is defined as the value of
	38	$icode x_k$$ in the previous call (counting this call) of the form
	39	$codei%
	40	%f%.Forward(%k%, %x_k%)
	41	%$$
	42	If there is no previous call with $latex k = 0$$,
	43	$latex x^{(0)}$$ is the value of the independent variables when the
	44	corresponding
	45	AD of $icode Base$$
	46	$cref/operation sequence/glossary/Operation/Sequence/$$ was recorded.
	47
	48
	49	$head W$$
	50	The functions
	51	$latex W_0 : B^n \rightarrow B$$ and
	52	$latex W_1 : B^n \rightarrow B$$
	53	are defined by
	54	$latex \[
	55	\begin{array}{rcl}
	56	W_0 ( u ) & = & w_0 * F_0 ( u ) + \cdots + w_{m-1} * F_{m-1} (u)
	57	\\
	58	W_1 ( u ) & = &
	59	w_0 * F_0^{(1)} ( u ) * x^{(1)}
	60	+ \cdots + w_{m-1} * F_{m-1}^{(1)} (u) * x^{(1)}
	61	\end{array}
	62	\] $$
	63	This operation computes the derivatives
	64	$latex \[
	65	\begin{array}{rcl}
	66	W_0^{(1)} (u) & = &
	67	w_0 * F_0^{(1)} ( u ) + \cdots + w_{m-1} * F_{m-1}^{(1)} (u)
	68	\\
	69	W_1^{(1)} (u) & = &
	70	w_0 * \left( x^{(1)} \right)^\R{T} * F_0^{(2)} ( u )
	71	+ \cdots +
	72	w_{m-1} * \left( x^{(1)} \right)^\R{T} F_{m-1}^{(2)} (u)
	73	\end{array}
	74	\] $$
	75	at $latex u = x^{(0)}$$.
	76
	77	$head f$$
	78	The object $icode f$$ has prototype
	79	$codei%
	80	const ADFun<%Base%> %f%
	81	%$$
	82	Before this call to $code Reverse$$, the value returned by
	83	$codei%
	84	%f%.size_order()
	85	%$$
	86	must be greater than or equal two (see $cref size_order$$).
	87
	88	$head w$$
	89	The argument $icode w$$ has prototype
	90	$codei%
	91	const %Vector% &%w%
	92	%$$
	93	(see $cref/Vector/reverse_two/Vector/$$ below)
	94	and its size
	95	must be equal to $icode m$$, the dimension of the
	96	$cref/range/seq_property/Range/$$ space for $icode f$$.
	97
	98	$head dw$$
	99	The result $icode dw$$ has prototype
	100	$codei%
	101	%Vector% %dw%
	102	%$$
	103	(see $cref/Vector/reverse_two/Vector/$$ below).
	104	It contains both the derivative
	105	$latex W^{(1)} (x)$$ and the derivative $latex U^{(1)} (x)$$.
	106	The size of $icode dw$$
	107	is equal to $latex n \times 2$$,
	108	where $latex n$$ is the dimension of the
	109	$cref/domain/seq_property/Domain/$$ space for $icode f$$.
	110
	111	$subhead First Order Partials$$
	112	For $latex j = 0 , \ldots , n - 1$$,
	113	$latex \[
	114	dw [ j * 2 + 0 ]
	115	=
	116	\D{ W_0 }{ u_j } \left( x^{(0)} \right)
	117	=
	118	w_0 * \D{ F_0 }{ u_j } \left( x^{(0)} \right)
	119	+ \cdots +
	120	w_{m-1} * \D{ F_{m-1} }{ u_j } \left( x^{(0)} \right)
	121	\] $$
	122	This part of $icode dw$$ contains the same values as are returned
	123	by $cref reverse_one$$.
	124
	125	$subhead Second Order Partials$$
	126	For $latex j = 0 , \ldots , n - 1$$,
	127	$latex \[
	128	dw [ j * 2 + 1 ]
	129	=
	130	\D{ W_1 }{ u_j } \left( x^{(0)} \right)
	131	=
	132	\sum_{\ell=0}^{n-1} x_\ell^{(1)} \left[
	133	w_0 * \DD{ F_0 }{ u_\ell }{ u_j } \left( x^{(0)} \right)
	134	+ \cdots +
	135	w_{m-1} * \DD{ F_{m-1} }{ u_\ell }{ u_j } \left( x^{(0)} \right)
	136	\right]
	137	\] $$
	138
	139
	140	$head Vector$$
	141	The type $icode Vector$$ must be a $cref SimpleVector$$ class with
	142	$cref/elements of type/SimpleVector/Elements of Specified Type/$$
	143	$icode Base$$.
	144	The routine $cref CheckSimpleVector$$ will generate an error message
	145	if this is not the case.
	146
	147
	148	$head Hessian Times Direction$$
	149	Suppose that $latex w$$ is the $th i$$ elementary vector.
	150	It follows that for $latex j = 0, \ldots, n-1$$
	151	$latex \[
	152	\begin{array}{rcl}
	153	dw[ j * 2 + 1 ]
	154	& = &
	155	w_i \sum_{\ell=0}^{n-1}
	156	\DD{F_i}{ u_j }{ u_\ell } \left( x^{(0)} \right) x_\ell^{(1)}
	157	\\
	158	& = &
	159	\left[ F_i^{(2)} \left( x^{(0)} \right) * x^{(1)} \right]_j
	160	\end{array}
	161	\] $$
	162	Thus the vector $latex ( dw[1], dw[3], \ldots , dw[ n * q - 1 ] )$$
	163	is equal to the Hessian of $latex F_i (x)$$ times the direction
	164	$latex x^{(1)}$$.
	165	In the special case where
	166	$latex x^{(1)}$$ is the $th l$$
	167	$cref/elementary vector/glossary/Elementary Vector/$$,
	168	$latex \[
	169	dw[ j * 2 + 1 ] = \DD{ F_i }{ x_j }{ x_\ell } \left( x^{(0)} \right)
	170	\] $$
	171
	172	$head Example$$
	173	$children%
	174	example/reverse_two.cpp%
	175	example/hes_times_dir.cpp
	176	%$$
	177	The files
	178	$cref reverse_two.cpp$$
	179	and
	180	$cref hes_times_dir.cpp$$
	181	contain a examples and tests of reverse mode calculations.
	182	They return true if they succeed and false otherwise.
	183
	184	$end

-515

~~omh/reverse.omh~~ less more

0		$Id: reverse.omh 2859 2013-05-28 06:03:21Z bradbell $
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11		$begin reverse_one$$
12
13		$section First Order Reverse Mode$$
14		$spell
15		taylor
16		const
17		dw
18		$$
19
20		$index reverse, first order mode$$
21		$index first, order reverse mode$$
22		$index mode, first order reverse$$
23		$index derivative, reverse mode$$
24
25		$head Syntax$$
26		$icode%dw% = %f%.Reverse(1, %w%)%$$
27
28
29		$head Purpose$$
30		We use $latex F : B^n \rightarrow B^m$$ to denote the
31		$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
32		The function $latex W : B^n \rightarrow B$$ is defined by
33		$latex \[
34		W(x) = w_0 * F_0 ( x ) + \cdots + w_{m-1} * F_{m-1} (x)
35		\] $$
36		The result of this operation is the derivative
37		$latex dw = W^{(1)} (x)$$; i.e.,
38		$latex \[
39		dw = w_0 * F_0^{(1)} ( x ) + \cdots + w_{m-1} * F_{m-1}^{(1)} (x)
40		\] $$
41		Note that if $latex w$$ is the $th i$$
42		$cref/elementary vector/glossary/Elementary Vector/$$,
43		$latex dw = F_i^{(1)} (x)$$.
44
45		$head f$$
46		The object $icode f$$ has prototype
47		$codei%
48		const ADFun<%Base%> %f%
49		%$$
50		Before this call to $code Reverse$$, the value returned by
51		$codei%
52		%f%.size_taylor()
53		%$$
54		must be greater than or equal one (see $cref size_taylor$$).
55
56		$head x$$
57		The vector $icode x$$ in expression for $icode dw$$ above
58		corresponds to the previous call to $cref ForwardZero$$
59		using this ADFun object $icode f$$; i.e.,
60		$codei%
61		%f%.Forward(0, %x%)
62		%$$
63		If there is no previous call with the first argument zero,
64		the value of the $cref/independent/Independent/$$ variables
65		during the recording of the AD sequence of operations is used
66		for $icode x$$.
67
68		$head w$$
69		The argument $icode w$$ has prototype
70		$codei%
71		const %Vector% &%w%
72		%$$
73		(see $cref/Vector/reverse_one/Vector/$$ below)
74		and its size
75		must be equal to $icode m$$, the dimension of the
76		$cref/range/seq_property/Range/$$ space for $icode f$$.
77
78		$head dw$$
79		The result $icode dw$$ has prototype
80		$codei%
81		%Vector% %dw%
82		%$$
83		(see $cref/Vector/reverse_one/Vector/$$ below)
84		and its value is the derivative $latex W^{(1)} (x)$$.
85		The size of $icode dw$$
86		is equal to $icode n$$, the dimension of the
87		$cref/domain/seq_property/Domain/$$ space for $icode f$$.
88
89		$head Vector$$
90		The type $icode Vector$$ must be a $cref SimpleVector$$ class with
91		$cref/elements of type/SimpleVector/Elements of Specified Type/$$
92		$icode Base$$.
93		The routine $cref CheckSimpleVector$$ will generate an error message
94		if this is not the case.
95
96		$head Example$$
97		$children%
98		example/reverse_one.cpp
99		%$$
100		The file
101		$cref reverse_one.cpp$$
102		contains an example and test of this operation.
103		It returns true if it succeeds and false otherwise.
104
105		$end
106		-----------------------------------------------------------------------
107		$begin reverse_two$$
108
109		$section Second Order Reverse Mode$$
110		$spell
111		taylor
112		const
113		dw
114		$$
115
116		$index reverse, second order mode$$
117		$index second, order reverse mode$$
118		$index mode, second order reverse$$
119		$index derivative, reverse mode$$
120
121		$head Syntax$$
122		$icode%dw% = %f%.Reverse(2, %w%)%$$
123
124		$head Purpose$$
125		We use $latex F : B^n \rightarrow B^m$$ to denote the
126		$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
127		Reverse mode computes the derivative of the $cref Forward$$ mode
128		$cref/Taylor coefficients/glossary/Taylor Coefficient/$$
129		with respect to the domain variable $latex x$$.
130
131		$head x^(k)$$
132		For $latex k = 0, 1$$,
133		the vector $latex x^{(k)} \in B^n$$ is defined as the value of
134		$icode x_k$$ in the previous call (counting this call) of the form
135		$codei%
136		%f%.Forward(%k%, %x_k%)
137		%$$
138		If there is no previous call with $latex k = 0$$,
139		$latex x^{(0)}$$ is the value of the independent variables when the
140		corresponding
141		AD of $icode Base$$
142		$cref/operation sequence/glossary/Operation/Sequence/$$ was recorded.
143
144
145		$head W$$
146		The functions
147		$latex W_0 : B^n \rightarrow B$$ and
148		$latex W_1 : B^n \rightarrow B$$
149		are defined by
150		$latex \[
151		\begin{array}{rcl}
152		W_0 ( u ) & = & w_0 * F_0 ( u ) + \cdots + w_{m-1} * F_{m-1} (u)
153		\\
154		W_1 ( u ) & = &
155		w_0 * F_0^{(1)} ( u ) * x^{(1)}
156		+ \cdots + w_{m-1} * F_{m-1}^{(1)} (u) * x^{(1)}
157		\end{array}
158		\] $$
159		This operation computes the derivatives
160		$latex \[
161		\begin{array}{rcl}
162		W_0^{(1)} (u) & = &
163		w_0 * F_0^{(1)} ( u ) + \cdots + w_{m-1} * F_{m-1}^{(1)} (u)
164		\\
165		W_1^{(1)} (u) & = &
166		w_0 * \left( x^{(1)} \right)^\R{T} * F_0^{(2)} ( u )
167		+ \cdots +
168		w_{m-1} * \left( x^{(1)} \right)^\R{T} F_{m-1}^{(2)} (u)
169		\end{array}
170		\] $$
171		at $latex u = x^{(0)}$$.
172
173		$head f$$
174		The object $icode f$$ has prototype
175		$codei%
176		const ADFun<%Base%> %f%
177		%$$
178		Before this call to $code Reverse$$, the value returned by
179		$codei%
180		%f%.size_taylor()
181		%$$
182		must be greater than or equal two (see $cref size_taylor$$).
183
184		$head w$$
185		The argument $icode w$$ has prototype
186		$codei%
187		const %Vector% &%w%
188		%$$
189		(see $cref/Vector/reverse_two/Vector/$$ below)
190		and its size
191		must be equal to $icode m$$, the dimension of the
192		$cref/range/seq_property/Range/$$ space for $icode f$$.
193
194		$head dw$$
195		The result $icode dw$$ has prototype
196		$codei%
197		%Vector% %dw%
198		%$$
199		(see $cref/Vector/reverse_two/Vector/$$ below).
200		It contains both the derivative
201		$latex W^{(1)} (x)$$ and the derivative $latex U^{(1)} (x)$$.
202		The size of $icode dw$$
203		is equal to $latex n \times 2$$,
204		where $latex n$$ is the dimension of the
205		$cref/domain/seq_property/Domain/$$ space for $icode f$$.
206
207		$subhead First Order Partials$$
208		For $latex j = 0 , \ldots , n - 1$$,
209		$latex \[
210		dw [ j * 2 + 0 ]
211		=
212		\D{ W_0 }{ u_j } \left( x^{(0)} \right)
213		=
214		w_0 * \D{ F_0 }{ u_j } \left( x^{(0)} \right)
215		+ \cdots +
216		w_{m-1} * \D{ F_{m-1} }{ u_j } \left( x^{(0)} \right)
217		\] $$
218		This part of $icode dw$$ contains the same values as are returned
219		by $cref reverse_one$$.
220
221		$subhead Second Order Partials$$
222		For $latex j = 0 , \ldots , n - 1$$,
223		$latex \[
224		dw [ j * 2 + 1 ]
225		=
226		\D{ W_1 }{ u_j } \left( x^{(0)} \right)
227		=
228		\sum_{\ell=0}^{n-1} x_\ell^{(1)} \left[
229		w_0 * \DD{ F_0 }{ u_\ell }{ u_j } \left( x^{(0)} \right)
230		+ \cdots +
231		w_{m-1} * \DD{ F_{m-1} }{ u_\ell }{ u_j } \left( x^{(0)} \right)
232		\right]
233		\] $$
234
235
236		$head Vector$$
237		The type $icode Vector$$ must be a $cref SimpleVector$$ class with
238		$cref/elements of type/SimpleVector/Elements of Specified Type/$$
239		$icode Base$$.
240		The routine $cref CheckSimpleVector$$ will generate an error message
241		if this is not the case.
242
243
244		$head Hessian Times Direction$$
245		Suppose that $latex w$$ is the $th i$$ elementary vector.
246		It follows that for $latex j = 0, \ldots, n-1$$
247		$latex \[
248		\begin{array}{rcl}
249		dw[ j * 2 + 1 ]
250		& = &
251		w_i \sum_{\ell=0}^{n-1}
252		\DD{F_i}{ u_j }{ u_\ell } \left( x^{(0)} \right) x_\ell^{(1)}
253		\\
254		& = &
255		\left[ F_i^{(2)} \left( x^{(0)} \right) * x^{(1)} \right]_j
256		\end{array}
257		\] $$
258		Thus the vector $latex ( dw[1], dw[3], \ldots , dw[ n * p - 1 ] )$$
259		is equal to the Hessian of $latex F_i (x)$$ times the direction
260		$latex x^{(1)}$$.
261		In the special case where
262		$latex x^{(1)}$$ is the $th l$$
263		$cref/elementary vector/glossary/Elementary Vector/$$,
264		$latex \[
265		dw[ j * 2 + 1 ] = \DD{ F_i }{ x_j }{ x_\ell } \left( x^{(0)} \right)
266		\] $$
267
268		$head Example$$
269		$children%
270		example/reverse_two.cpp%
271		example/hes_times_dir.cpp
272		%$$
273		The files
274		$cref reverse_two.cpp$$
275		and
276		$cref hes_times_dir.cpp$$
277		contain a examples and tests of reverse mode calculations.
278		They return true if they succeed and false otherwise.
279
280		$end
281		-----------------------------------------------------------------------
282		$begin reverse_any$$
283		$spell
284		checkpointing
285		typename
286		xk
287		xp
288		dw
289		Ind
290		uj
291		std
292		arg
293		const
294		Taylor
295		$$
296
297		$section Any Order Reverse Mode$$
298
299
300		$index reverse, any order mode$$
301		$index any, order reverse mode$$
302		$index mode, any order reverse$$
303		$index derivative, reverse mode$$
304
305		$head Syntax$$
306		$icode%dw% = %f%.Reverse(%p%, %w%)%$$
307
308
309		$head Purpose$$
310		We use $latex F : B^n \rightarrow B^m$$ to denote the
311		$cref/AD function/glossary/AD Function/$$ corresponding to $icode f$$.
312		Reverse mode computes the derivative of the $cref Forward$$ mode
313		$cref/Taylor coefficients/glossary/Taylor Coefficient/$$
314		with respect to the domain variable $latex x$$.
315		To be specific, it computes the derivative
316		$latex W^{(1)} (u)$$ at $latex u = x$$
317		which is specified by the following notation:
318
319		$head Notation$$
320
321		$subhead x^(k)$$
322		For $latex k = 0, \ldots , p-1$$,
323		the vector $latex x^{(k)} \in B^n$$ is defined as the value of
324		$icode x_k$$ in the previous calls of the form
325		$codei%
326		%f%.Forward(%k%, %x_k%)
327		%$$
328		If there is no previous call with $latex k = 0$$,
329		$latex x^{(0)}$$ is the value of the independent variables when the
330		corresponding
331		AD of $icode Base$$
332		$cref/operation sequence/glossary/Operation/Sequence/$$ was recorded.
333
334
335		$subhead X(t, u)$$
336		The function
337		$latex X : B \times B^{n \times p} \rightarrow B^n$$ is defined by
338		$latex \[
339		X ( t , u ) = u^{(0)} + u^{(1)} * t + \cdots + u^{(p-1)} * t^{p-1}
340		\] $$
341		Note that for $latex k = 0 , \ldots , p-1$$,
342		$latex u^{(k)}$$ is related to the $th k$$ partial of $latex X(t, u)$$
343		with respect to $latex t$$ by
344		$latex \[
345		u^{(k)} = \frac{1}{k !} \Dpow{k}{t} X(0, u)
346		\] $$
347
348		$subhead Y(t, u)$$
349		The function
350		$latex Y : B \times B^{n \times p} \rightarrow B^m$$ is defined by
351		$latex \[
352		Y(t, u) = F [ X(t,u) ]
353		\]$$
354
355		$subhead w^(k)$$
356		If the argument $icode w$$ has size $icode%m% * %p%$$,
357		for $latex k = 0 , \ldots , p-1$$ and $latex i = 0, \ldots , m-1$$,
358		$latex \[
359		w_i^{(k)} = w [ i * p + k ]
360		\] $$
361		If the argument $icode w$$ has size $icode m$$,
362		for $latex k = 0 , \ldots , p-1$$ and $latex i = 0, \ldots , m-1$$,
363		$latex \[
364		w_i^{(k)} = \left\{ \begin{array}{ll}
365		w [ i ] & {\rm if} \; k = p-1
366		\\
367		0 & {\rm otherwise}
368		\end{array} \right.
369		\] $$
370
371
372		$subhead W(u)$$
373		The function $latex W : B^{n \times p} \rightarrow B$$ is defined by
374		$latex \[
375		W(u) = \sum_{k=0}^{p-1} ( w^{(k)} )^\R{T} \frac{1}{k !} \Dpow{k}{t} Y(0, u)
376		\] $$
377
378
379		$head f$$
380		The object $icode f$$ has prototype
381		$codei%
382		const ADFun<%Base%> %f%
383		%$$
384		Before this call to $code Reverse$$, the value returned by
385		$codei%
386		%f%.size_taylor()
387		%$$
388		must be greater than or equal $icode p$$
389		(see $cref size_taylor$$).
390
391		$head p$$
392		The argument $icode p$$ has prototype
393		$codei%
394		size_t %p%
395		%$$
396		and specifies the number of Taylor coefficients to be differentiated
397		(for each variable).
398
399
400		$head w$$
401		The argument $icode w$$ has prototype
402		$codei%
403		const %Vector% &%w%
404		%$$
405		(see $cref/Vector/reverse_any/Vector/$$ below)
406		and its size
407		must be equal to $icode m$$ or $icode%m% * %p%$$,
408		It specifies the weighting vector $icode w$$
409		in the definition of
410		$cref/W(u)/reverse_any/Notation/W(u)/$$.
411
412
413		$head dw$$
414		The return value $icode dw$$ has prototype
415		$codei%
416		%Vector% %dw%
417		%$$
418		(see $cref/Vector/reverse_any/Vector/$$ below).
419		It is a vector with size $latex n \times p$$.
420		For $latex j = 0, \ldots, n-1$$ and $latex k = 0 , \ldots , p-1$$
421		If the argument $icode w$$ has size $icode%m% * %p%$$,
422		$latex \[
423		dw[ j * p + k ] = W^{(1)} ( x )_{j,k}
424		\] $$
425		where $latex u = x$$ is value of the Taylor coefficients where the
426		derivative is evaluated.
427		$pre
428
429		$$
430		If the argument $icode w$$ has size $icode m$$,
431		$latex \[
432		dw[ j * p + p - k - 1 ] = W^{(1)} ( x )_{j,k}
433		\] $$
434		where $latex u = x$$ is value of the Taylor coefficients where the
435		derivative is evaluated.
436		Note the reverse order in which the order indices are stored.
437		This is an unfortunate consequence of keeping $code Reverse$$ backward
438		compatible.
439
440		$head First Order$$
441		We consider the case where
442		$icode%p% = 1%$$ and $icode%w%.size() == %m%$$.
443		In this case
444		$latex \[
445		\begin{array}{rcl}
446		W(u) & = & w_0 Y_0 (0, u) + \cdots + w_m Y_m (0, u)
447		\\
448		W(u) & = & w_0 F_0 [ X(0, u) ] + \cdots + w_m F_m [ X(0, u) ]
449		\\
450		W^{(1)} (x) & = &
451		w_0 F_0^{(1)} ( x^{(0)} ) + \cdots + w_m F_m^{(1)} ( x^{(0)} )
452		\end{array}
453		\] $$
454		This is the same as the result documented in $cref reverse_one$$.
455
456
457		$head Second Order$$
458		We consider the case where
459		$icode%p% = 2%$$ and $icode%w%.size() == %m%$$.
460		In this case
461		$latex \[
462		\begin{array}{rcl}
463		W(u) & = & w_0 \partial_t Y_0 (0, u) + \cdots + w_m \partial_t Y_m (0, u)
464		\\
465		W(u) & = &
466		w_0 \partial_t \{ F_0 [ X(t, u) ] \}_{t = 0}
467		+ \cdots +
468		w_m \partial_t \{ F_m [ X(t, u) ] \}_{t = 0}
469		\\
470		W(u) & = &
471		w_0 F_0^{(1)} ( u^{(0)} ) u^{(1)}
472		+ \cdots +
473		w_0 F_m^{(1)} ( u^{(0)} ) u^{(1)}
474		\\
475		\partial_{u(0)} W(x) & = &
476		w_0 ( x^{(1)} )^\R{T} F_0^{(2)} ( x^{(0)} )
477		+ \cdots +
478		w_m ( x^{(1)} )^\R{T} F_m^{(2)} ( x^{(0)} )
479		\\
480		\partial_{u(1)} W(x) & = &
481		w_0 F_0^{(1)} ( x^{(0)} )
482		+ \cdots +
483		w_m F_m^{(1)} ( x^{(0)} )
484		\end{array}
485		\] $$
486		where $latex \partial{u(0)} $$
487		denotes partial with respect to $latex u^{(0)}$$.
488		These are the same as the result documented in $cref reverse_two$$.
489
490
491		$head Vector$$
492		The type $icode Vector$$ must be a $cref SimpleVector$$ class with
493		$cref/elements of type/SimpleVector/Elements of Specified Type/$$
494		$icode Base$$.
495		The routine $cref CheckSimpleVector$$ will generate an error message
496		if this is not the case.
497
498
499		$head Example$$
500		$children%
501		example/reverse_three.cpp%
502		example/reverse_any.cpp
503		%$$
504
505		$list number$$
506		The file $cref reverse_three.cpp$$
507		contains an example and test of using reverse mode
508		to compute third order derivatives.
509		$lnext
510		The file $cref reverse_any.cpp$$
511		contains an example and test of the general reverse mode case.
512		$lend
513
514		$end

-156

~~omh/reverse_identity.omh~~ less more

0		$Id: reverse_identity.omh 2506 2012-10-24 19:36:49Z bradbell $
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		$begin reverse_identity$$
13		$spell
14		Taylor
15		Griewank
16		Andreas
17		$$
18
19
20
21		$section An Important Reverse Mode Identity$$
22		The theorem and the proof below is a restatement
23		of the results on page 236 of
24		$cref/Evaluating Derivatives/Bib/Evaluating Derivatives/$$.
25
26		$head Notation$$
27		Given a function $latex f(u, v)$$ where $latex u \in B^n$$
28		we use the notation
29		$latex \[
30		\D{f}{u} (u, v) = \left[ \D{f}{u_1} (u, v) , \cdots , \D{f}{u_n} (u, v) \right]
31		\] $$
32
33		$head Reverse Sweep$$
34		When using $cref/reverse mode/reverse_any/$$
35		we are given a function $latex F : B^n \rightarrow B^m$$,
36		a matrix of Taylor coefficients $latex x \in B^{n \times p}$$,
37		and a weight vector $latex w \in B^m$$.
38		We define the functions $latex X : B \times B^{n \times p} \rightarrow B^n$$,
39		$latex W : B \times B^{n \times p} \rightarrow B$$, and
40		$latex W_j : B^{n \times p} \rightarrow B$$ by
41		$latex \[
42		\begin{array}{rcl}
43		X(t , x) & = & x^{(0)} + x^{(1)} t + \cdots + x^{(p-1)} t^{p-1}
44		\\
45		W(t, x) & = & w_0 F_0 [X(t, x)] + \cdots + w_{m-1} F_{m-1} [X(t, x)]
46		\\
47		W_j (x) & = & \frac{1}{j!} \Dpow{j}{t} W(0, x)
48		\end{array}
49		\]$$
50		where $latex x^{(j)}$$ is the $th j$$ column of $latex x \in B^{n \times p}$$.
51		The theorem below implies that
52		$latex \[
53		\D{ W_j }{ x^{(i)} } (x) = \D{ W_{j-i} }{ x^{(0)} } (x)
54		\] $$
55		A $cref/general reverse sweep/reverse_any/$$ calculates the values
56		$latex \[
57		\D{ W_{p-1} }{ x^{(i)} } (x) \hspace{1cm} (i = 0 , \ldots , p-1)
58		\] $$
59		But the return values for a reverse sweep are specified
60		in terms of the more useful values
61		$latex \[
62		\D{ W_j }{ x^{(0)} } (x) \hspace{1cm} (j = 0 , \ldots , p-1)
63		\] $$
64
65		$head Theorem$$
66		Suppose that $latex F : B^n \rightarrow B^m$$ is a $latex p$$ times
67		continuously differentiable function.
68		Define the functions
69		$latex Z : B \times B^{n \times p} \rightarrow B^n$$,
70		$latex Y : B \times B^{n \times p }\rightarrow B^m$$,
71		and
72		$latex y^{(j)} : B^{n \times p }\rightarrow B^m$$ by
73		$latex \[
74		\begin{array}{rcl}
75		Z(t, x) & = & x^{(0)} + x^{(1)} t + \cdots + x^{(p-1)} t^{p-1}
76		\\
77		Y(t, x) & = & F [ Z(t, x) ]
78		\\
79		y^{(j)} (x) & = & \frac{1}{j !} \Dpow{j}{t} Y(0, x)
80		\end{array}
81		\] $$
82		where $latex x^{(j)}$$ denotes the $th j$$ column of
83		$latex x \in B^{n \times p}$$.
84		It follows that
85		for all $latex i, j$$ such that $latex i \leq j < p$$,
86		$latex \[
87		\begin{array}{rcl}
88		\D{ y^{(j)} }{ x^{(i)} } (x) & = & \D{ y^{(j-i)} }{ x^{(0)} } (x)
89		\end{array}
90		\] $$
91
92
93		$head Proof$$
94		If follows from the definitions that
95		$latex \[
96		\begin{array}{rclr}
97		\D{ y^{(j)} }{ x^{(i)} } (x)
98		& = &
99		\frac{1}{j ! } \D{ }{ x^{(i)} }
100		\left[ \Dpow{j}{t} (F \circ Z) (t, x) \right]_{t=0}
101		\\
102		& = &
103		\frac{1}{j ! } \left[ \Dpow{j}{t}
104		\D{ }{ x^{(i)} } (F \circ Z) (t, x)
105		\right]_{t=0}
106		\\
107		& = &
108		\frac{1}{j ! } \left\{
109		\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
110		\right\}_{t=0}
111		\end{array}
112		\] $$
113		For $latex k > i$$, the $th k$$
114		partial of $latex t^i$$ with respect to $latex t$$ is zero.
115		Thus, the partial with respect to $latex t$$ is given by
116		$latex \[
117		\begin{array}{rcl}
118		\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
119		& = &
120		\sum_{k=0}^i
121		\left( \begin{array}{c} j \\ k \end{array} \right)
122		\frac{ i ! }{ (i - k) ! } t^{i-k} \;
123		\Dpow{j-k}{t} ( F^{(1)} \circ Z ) (t, x)
124		\\
125		\left\{
126		\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
127		\right\}_{t=0}
128		& = &
129		\left( \begin{array}{c} j \\ i \end{array} \right)
130		i ! \Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
131		\\
132		& = &
133		\frac{ j ! }{ (j - i) ! }
134		\Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
135		\\
136		\D{ y^{(j)} }{ x^{(i)} } (x)
137		& = &
138		\frac{ 1 }{ (j - i) ! }
139		\Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
140		\end{array}
141		\] $$
142		Applying this formula to the case where $latex j$$
143		is replaced by $latex j - i$$ and $latex i$$ is replaced by zero,
144		we obtain
145		$latex \[
146		\D{ y^{(j-i)} }{ x^{(0)} } (x)
147		=
148		\frac{ 1 }{ (j - i) ! }
149		\Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
150		=
151		\D{ y^{(j)} }{ x^{(i)} } (x)
152		\] $$
153		which completes the proof
154
155		$end

-183

~~omh/reverse_theory.omh~~ less more

0		$Id: reverse_theory.omh 2506 2012-10-24 19:36:49Z bradbell $
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		$begin ReverseTheory$$
13		$spell
14		Taylor
15		Arctangent
16		$$
17
18		$section The Theory of Reverse Mode$$
19
20		$head Taylor Notation$$
21		In Taylor notation, each variable corresponds to
22		a function of a single argument which we denote by $icode t$$
23		(see Section 10.2 of
24		$cref/Evaluating Derivatives/Bib/Evaluating Derivatives/$$).
25		Here and below
26		$latex X(t)$$, $latex Y(t)$$, and $icode Z(t)$$ are scalar valued functions
27		and the corresponding $th p$$ order Taylor coefficients row vectors are
28		$latex x$$, $latex y$$ and $latex z$$; i.e.,
29		$latex \[
30		\begin{array}{lcr}
31		X(t) & = & x^{(0)} + x^{(1)} * t + \cdots + x^{(p)} * t^p + O( t^{p+1} ) \\
32		Y(t) & = & y^{(0)} + y^{(1)} * t + \cdots + y^{(p)} * t^p + O( t^{p+1} ) \\
33		Z(t) & = & z^{(0)} + z^{(1)} * t + \cdots + z^{(p)} * t^p + O( t^{p+1} )
34		\end{array}
35		\] $$
36		For the purposes of this discussion,
37		we are given the $th p$$ order Taylor coefficient row vectors
38		$latex x$$, $latex y$$, and $latex z$$.
39		In addition, we are given the partial derivatives of a scalar valued function
40		$latex \[
41		G ( z^{(j)} , \ldots , z^{(0)}, x, y)
42		\] $$
43		We need to compute the partial derivatives of the scalar valued function
44		$latex \[
45		H ( z^{(j-1)} , \ldots , z^{(0)}, x, y) =
46		G ( z^{(j)}, z^{(j-1)} , \ldots , z^{(0)}, x , y )
47		\] $$
48		where $latex z^{(j)}$$ is expressed as a function of the
49		$th j-1$$ order Taylor coefficient row
50		vector for $latex Z$$ and the vectors $latex x$$, $latex y$$; i.e.,
51		$latex z^{(j)}$$ above is a shorthand for
52		$latex \[
53		z^{(j)} ( z^{(j-1)} , \ldots , z^{(0)}, x, y )
54		\] $$
55		If we do not provide a formula for
56		a partial derivative of $latex H$$, then that partial derivative
57		has the same value as for the function $latex G$$.
58
59		$head Binary Operators$$
60
61		$subhead Addition$$
62		The forward mode formula for
63		$cref/addition/ForwardTheory/Binary Operators/Addition/$$ is
64		$latex \[
65		z^{(j)} = x^{(j)} + y^{(j)}
66		\] $$
67		If follows that for $latex k = 0 , \ldots , j$$
68		and $latex l = 0 , \ldots , j-1$$
69		$latex \[
70		\begin{array}{rcl}
71		\D{H}{ x^{(k)} } & = &
72		\D{G}{ x^{(k)} } + \D{G}{ z^{(k)} } \\
73		\\
74		\D{H}{ y^{(k)} } & = &
75		\D{G}{ y^{(k)} } + \D{G}{ z^{(k)} }
76		\\
77		\D{H}{ z^{(l)} } & = & \D{G}{ z^{(l)} }
78		\end{array}
79		\] $$
80
81		$subhead Subtraction$$
82		The forward mode formula for
83		$cref/subtraction/ForwardTheory/Binary Operators/Subtraction/$$ is
84		$latex \[
85		z^{(j)} = x^{(j)} - y^{(j)}
86		\] $$
87		If follows that for $latex k = 0 , \ldots , j$$
88		$latex \[
89		\begin{array}{rcl}
90		\D{H}{ x^{(k)} } & = &
91		\D{G}{ x^{(k)} } - \D{G}{ z^{(k)} } \\
92		\\
93		\D{H}{ y^{(k)} } & = &
94		\D{G}{ y^{(k)} } - \D{G}{ z^{(k)} }
95		\end{array}
96		\] $$
97
98		$subhead Multiplication$$
99		The forward mode formula for
100		$cref/multiplication/ForwardTheory/Binary Operators/Multiplication/$$ is
101		$latex \[
102		z^{(j)} = \sum_{k=0}^j x^{(j-k)} * y^{(k)}
103		\] $$
104		If follows that for $latex k = 0 , \ldots , j$$
105		and $latex l = 0 , \ldots , j-1$$
106		$latex \[
107		\begin{array}{rcl}
108		\D{H}{ x^{(j-k)} } & = &
109		\D{G}{ x^{(j-k)} } +
110		\sum_{k=0}^j \D{G}{ z^{(j)} } y^{(k)}
111		\\
112		\D{H}{ y^{(k)} } & = &
113		\D{G}{ y^{(k)} } +
114		\sum_{k=0}^j \D{G}{ z^{(j)} } x^{(j-k)}
115		\end{array}
116		\] $$
117
118		$subhead Division$$
119		The forward mode formula for
120		$cref/division/ForwardTheory/Binary Operators/Division/$$ is
121		$latex \[
122		z^{(j)} =
123		\frac{1}{y^{(0)}}
124		\left(
125		x^{(j)} - \sum_{k=1}^j z^{(j-k)} y^{(k)}
126		\right)
127		\] $$
128		If follows that for $latex k = 1 , \ldots , j$$
129		$latex \[
130		\begin{array}{rcl}
131		\D{H}{ x^{(j)} } & = &
132		\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{y^{(0)}}
133		\\
134		\D{H}{ z^{(j-k)} } & = &
135		\D{G}{ z^{(j-k)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} y^{(k)}
136		\\
137		\D{H}{ y^{(k)} } & = &
138		\D{G}{ y^{(k)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} z^{(j-k)}
139		\\
140		\D{H}{ y^{(0)} } & = &
141		\D{G}{ y^{(0)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} \frac{1}{y^{(0)}}
142		\left(
143		x^{(j)} - \sum_{k=1}^j z^{(j-k)} y^{(k)}
144		\right)
145		\\
146		& = &
147		\D{G}{ y^{(0)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} z^{(j)}
148		\end{array}
149		\] $$
150
151		$head Standard Math Functions$$
152		The standard math functions have only one argument.
153		Hence we are given the partial derivatives of a scalar valued function
154		$latex \[
155		G ( z^{(j)} , \ldots , z^{(0)}, x)
156		\] $$
157		We need to compute the partial derivatives of the scalar valued function
158		$latex \[
159		H ( z^{(j-1)} , \ldots , z^{(0)}, x) =
160		G ( z^{(j)}, z^{(j-1)} , \ldots , z^{(0)}, x)
161		\] $$
162		where $latex z^{(j)}$$ is expressed as a function of the
163		$th j-1$$ order Taylor coefficient row
164		vector for $latex Z$$ and the vector $latex x$$; i.e.,
165		$latex z^{(j)}$$ above is a shorthand for
166		$latex \[
167		z^{(j)} ( z^{(j-1)} , \ldots , z^{(0)}, x )
168		\] $$
169
170
171		$childtable%
172		omh/exp_reverse.omh%
173		omh/log_reverse.omh%
174		omh/sqrt_reverse.omh%
175		omh/sin_cos_reverse.omh%
176		omh/atan_reverse.omh%
177		omh/asin_reverse.omh%
178		omh/acos_reverse.omh%
179		omh/tan_reverse.omh
180		%$$
181
182		$end

-5

omh/seq_property.omh less more

0		$Id: seq_property.omh 2991 2013-10-22 16:25:15Z bradbell $
	0	$Id: seq_property.omh 3214 2014-03-18 20:50:38Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

50	50	%$$
51	51
52	52	$subhead See Also$$
53		$cref size_taylor$$, $cref capacity_taylor$$.
	53	$cref size_order$$, $cref capacity_order$$.
54	54
55	55	$head Purpose$$
56	56	The operations above return properties of the

136	136	one for each component of the range that is a parameter.
137	137	The amount of work and memory necessary for computing function values
138	138	and derivatives using $icode f$$ is roughly proportional to $icode s$$.
139		(The function call $cref/f.size_taylor()/size_taylor/$$
140		returns the number of Taylor coefficients, per variable,
	139	(The function call $cref/f.size_order()/size_order/$$
	140	returns the number of Taylor coefficient orders, per variable,direction,
141	141	currently stored in $icode f$$.)
142	142	$pre
143	143

-122

~~omh/sin_cos_forward.omh~~ less more

0		$Id: sin_cos_forward.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin SinCosForward$$
15		$spell
16		sin
17		cos
18		sinh
19		cosh
20		Taylor
21		$$
22
23
24		$index sin, forward$$
25		$index sinh, forward$$
26		$index cos, forward$$
27		$index cosh, forward$$
28
29		$index theory, sin$$
30		$index theory, sinh$$
31		$index theory, cos$$
32		$index theory, cosh$$
33
34		$index forward, sin$$
35		$index forward, sinh$$
36		$index forward, cos$$
37		$index forward, cosh$$
38
39		$section Trigonometric and Hyperbolic Sine and Cosine Forward Theory$$
40
41		$head Differential Equation$$
42		The
43		$xref/
44		ForwardTheory/
45		Standard Math Functions/
46		Differential Equation/
47		standard math function differential equation/
48		1
49		/$$
50		is
51		$latex \[
52		B(u) * F^{(1)} (u) - A(u) * F (u) = D(u)
53		\] $$
54		In this sections we consider forward mode for the following choices:
55
56		$table
57		$pre $$
58		$cnext $cnext $latex F(u)$$
59		$cnext $cnext $latex \sin(u)$$
60		$cnext $cnext $latex \cos(u)$$
61		$cnext $cnext $latex \sinh(u)$$
62		$cnext $cnext $latex \cosh(u)$$
63		$rnext
64		$cnext $cnext $latex A(u)$$
65		$cnext $cnext $latex 0$$
66		$cnext $cnext $latex 0$$
67		$cnext $cnext $latex 0$$
68		$cnext $cnext $latex 0$$
69		$rnext
70		$cnext $cnext $latex B(u)$$
71		$cnext $cnext $latex 1$$
72		$cnext $cnext $latex 1$$
73		$cnext $cnext $latex 1$$
74		$cnext $cnext $latex 1$$
75		$rnext
76		$cnext $cnext $latex D(u)$$
77		$cnext $cnext $latex \cos(u)$$
78		$cnext $cnext $latex - \sin(u)$$
79		$cnext $cnext $latex \cosh(u)$$
80		$cnext $cnext $latex \sinh(u)$$
81		$tend
82
83		We use $latex a$$, $latex b$$, $latex d$$ and $latex f$$ for the
84		Taylor coefficients of
85		$latex A [ X (t) ]$$,
86		$latex B [ X (t) ]$$,
87		$latex D [ X (t) ] $$,
88		and $latex F [ X(t) ] $$ respectively.
89		It now follows from the general
90		$xref/
91		ForwardTheory/
92		Standard Math Functions/
93		Taylor Coefficients Recursion Formula/
94		Taylor coefficients recursion formula/
95		1
96		/$$
97		that for $latex j = 0 , 1, \ldots$$,
98		$latex \[
99		\begin{array}{rcl}
100		f^{(0)} & = & D ( x^{(0)} )
101		\\
102		e^{(j)}
103		& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * f^{(k)}
104		\\
105		& = & d^{(j)}
106		\\
107		f^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
108		\left(
109		\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
110		- \sum_{k=1}^j k f^{(k)} b^{(j+1-k)}
111		\right)
112		\\
113		& = & \frac{1}{j+1}
114		\sum_{k=1}^{j+1} k x^{(k)} d^{(j+1-k)}
115		\end{array}
116		\] $$
117		The formula above generates the
118		order $latex j+1$$ coefficient of $latex F[ X(t) ]$$ from the
119		lower order coefficients for $latex X(t)$$ and $latex D[ X(t) ]$$.
120
121		$end

-123

~~omh/sin_cos_reverse.omh~~ less more

0		$Id: sin_cos_reverse.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin SinCosReverse$$
15		$spell
16		Taylor
17		cos
18		$$
19
20		$index sin, reverse$$
21		$index sinh, reverse$$
22		$index cos, reverse$$
23		$index cosh, reverse$$
24
25		$index theory, sin$$
26		$index theory, sinh$$
27		$index theory, cos$$
28		$index theory, cosh$$
29
30		$index reverse, sin$$
31		$index reverse, sinh$$
32		$index reverse, cos$$
33		$index reverse, cosh$$
34
35
36		$section Trigonometric and Hyperbolic Sine and Cosine Reverse Theory$$
37
38
39		We use the reverse theory
40		$xref%
41		ReverseTheory%
42		Standard Math Functions%
43		standard math function
44		%$$
45		definition for the functions $latex H$$ and $latex G$$.
46		In addition,
47		we use the following definitions for $latex s$$ and $latex c$$
48		and the integer $latex \ell$$
49
50		$table
51		Coefficients
52		$cnext $cnext $latex s$$
53		$cnext $cnext $latex c$$
54		$cnext $cnext $latex \ell$$
55		$rnext
56		Trigonometric Case
57		$cnext $cnext $latex \sin [ X(t) ]$$
58		$cnext $cnext $latex \cos [ X(t) ]$$
59		$cnext $cnext 1
60		$rnext
61		Hyperbolic Case
62		$cnext $cnext $latex \sinh [ X(t) ]$$
63		$cnext $cnext $latex \cosh [ X(t) ]$$
64		$cnext $cnext -1
65		$tend
66		We use the value
67		$latex \[
68		z^{(j)} = ( s^{(j)} , c^{(j)} )
69		\] $$
70		in the definition for $latex G$$ and $latex H$$.
71		The forward mode formulas for the
72		$cref/sine and cosine/SinCosForward/$$ functions are
73		$latex \[
74		\begin{array}{rcl}
75		s^{(j)} & = & \frac{1 + \ell}{2} \sin ( x^{(0)} )
76		+ \frac{1 - \ell}{2} \sinh ( x^{(0)} )
77		\\
78		c^{(j)} & = & \frac{1 + \ell}{2} \cos ( x^{(0)} )
79		+ \frac{1 - \ell}{2} \cosh ( x^{(0)} )
80		\end{array}
81		\] $$
82
83		for the case $latex j = 0$$, and for $latex j > 0$$,
84
85		$latex \[
86		\begin{array}{rcl}
87		s^{(j)} & = & \frac{1}{j}
88		\sum_{k=1}^{j} k x^{(k)} c^{(j-k)} \\
89		c^{(j)} & = & \ell \frac{1}{j}
90		\sum_{k=1}^{j} k x^{(k)} s^{(j-k)}
91		\end{array}
92		\] $$
93
94		If $latex j = 0$$, we have the relation
95
96		$latex \[
97		\begin{array}{rcl}
98		\D{H}{ x^{(j)} } & = &
99		\D{G}{ x^{(j)} }
100		+ \D{G}{ s^{(j)} } c^{(0)}
101		+ \ell \D{G}{ c^{(j)} } s^{(0)}
102		\end{array}
103		\] $$
104
105		If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
106
107		$latex \[
108		\begin{array}{rcl}
109		\D{H}{ x^{(k)} } & = &
110		\D{G}{ x^{(k)} }
111		+ \D{G}{ s^{(j)} } \frac{1}{j} k c^{(j-k)}
112		+ \ell \D{G}{ c^{(j)} } \frac{1}{j} k s^{(j-k)}
113		\\
114		\D{H}{ s^{(j-k)} } & = &
115		\D{G}{ s^{(j-k)} } + \ell \D{G}{ c^{(j)} } k x^{(k)}
116		\\
117		\D{H}{ c^{(j-k)} } & = &
118		\D{G}{ c^{(j-k)} } + \D{G}{ s^{(j)} } k x^{(k)}
119		\end{array}
120		\] $$
121
122		$end

-25

omh/speed/speed.omh less more

0		$Id: speed.omh 2579 2012-11-17 18:58:29Z bradbell $
	0	$Id: speed.omh 3311 2014-05-28 16:21:08Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

25	25	$index speed, test$$
26	26	$index test, speed$$
27	27
28		$section AD Speed Test Routines$$
	28	$section Speed Test an Operator Overloading AD Package$$
29	29
30	30	$head Purpose$$
31	31	CppAD has a set of speed tests that are used to determine if
32		certain changes improve its execution speed
33		and to compare the C++ AD packages
	32	certain changes improve its execution speed.
	33	These tests can also be used to compare the AD packages
34	34	$href%
35	35	https://projects.coin-or.org/ADOL-C%
36	36	Adolc

47	47	http://trilinos.sandia.gov/packages/sacado/%
48	48	Sacado
49	49	%$$.
50		This section explains how you can run these tests on your computer.
	50	The sections below explain how you can run these tests on your computer.
51	51
52		$head Windows$$
53		$index windows, speed test$$
54		$index test, speed windows$$
55		$index speed, test windows$$
56		The speed test routines have not yet been compiled or tested using
57		the MS Windows C++ compiler.
58		Under Windows, you can use
59		$href%
60		http://www.cygwin.com%
61		Cygwin
62		%$$
63		or,
64		$href%
65		http://www.mingw.org%
66		MinGW with MSYS
67		%$$
68		to run these speed tests.
69
70		$contents%
	52	$childtable%
71	53	speed/main.cpp%
72	54	omh/speed/speed_utility.omh%
73	55	omh/speed/speed_double.omh%

+11

-19

omh/speed/speed_adolc.omh less more

0		$Id: speed_adolc.omh 2579 2012-11-17 18:58:29Z bradbell $
	0	$Id: speed_adolc.omh 3308 2014-05-26 14:29:01Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11
12	12	$begin speed_adolc$$
13	13	$spell
	14	cmake
14	15	AdolcDir
15	16	CppAD
16	17	Cygwin

28	29	This section links to the source code the Adolc speed tests
29	30	(any suggestions to make the Adolc results faster are welcome).
30	31
31		$head adolc_dir$$
32		To run these tests, you must include the $code configure$$ command line option
33		$codei%
34		ADOLC_DIR=%adolc_dir%
35		%$$
36		during $cref/installation/InstallUnix/adolc_dir/$$.
	32	$head adolc_prefix$$
	33	To run these tests,
	34	you must include the $cref adolc_prefix$$
	35	in you $cref/cmake command/cmake/CMake Command/$$.
	36
37	37
38	38	$head Running Tests$$
39	39	To build these speed tests, and run their correctness tests,
40	40	execute the following commands starting in the
41		$cref/work directory/InstallUnix/Work Directory/$$:
	41	$cref/build directory/cmake/CMake Command/Build Directory/$$:
42	42	$codei%
43	43	cd speed/adolc
44		make test
	44	make check_speed_adolc VERBOSE=1
45	45	%$$
46	46	You can then run the corresponding speed tests
47	47	with the following command
48	48	$codei%
49		./adolc speed %seed%
	49	./speed_adolc speed %seed%
50	50	%$$
51	51	where $icode seed$$ is a positive integer.
52	52	See $cref speed_main$$ for more options.
53
54		$head C++ Compiler Flags$$
55		The C++ compiler flags used to build the Adolc speed tests are
56		$code
57		$verbatim%speed/adolc/makefile.am%5%# BEGIN OPTIMIZE%# END OPTIMIZE%$$
58		$$
59		where $code CXX_FLAGS$$ is specified by the
60		$cref/configure/InstallUnix/Configure/$$ command.
61	53
62	54	$contents%
63	55	speed/adolc/det_minor.cpp%

-15

omh/speed/speed_cppad.omh less more

0		$Id: speed_cppad.omh 2579 2012-11-17 18:58:29Z bradbell $
	0	$Id: speed_cppad.omh 3308 2014-05-26 14:29:01Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11
12	12	$begin speed_cppad$$
13	13	$spell
	14	cmake
14	15	cppad
15	16	CppAD
16	17	Cygwin

35	36	This section links to the source code the CppAD speed tests
36	37	(any suggestions to make the CppAD results faster are welcome).
37	38
	39
38	40	$head Running Tests$$
39	41	To build these speed tests, and run their correctness tests,
40	42	execute the following commands starting in the
41		$cref/work directory/InstallUnix/Work Directory/$$:
	43	$cref/build directory/cmake/CMake Command/Build Directory/$$:
42	44	$codei%
43	45	cd speed/cppad
44		make test
	46	make check_speed_cppad VERBOSE=1
45	47	%$$
46	48	You can then run the corresponding speed tests
47	49	with the following command
48	50	$codei%
49		./cppad speed %seed%
	51	./speed_cppad speed %seed%
50	52	%$$
51	53	where $icode seed$$ is a positive integer.
52	54	See $cref speed_main$$ for more options.
53
54		$head C++ Compiler Flags$$
55		The C++ compiler flags used to build the CppAD speed tests are
56		$code
57		$verbatim%speed/cppad/makefile.am%5%# BEGIN OPTIMIZE%# END OPTIMIZE%$$
58		$$
59		where $code CXX_FLAGS$$ is specified by the
60		$cref/configure/InstallUnix/Configure/$$ command.
61	55
62	56	$contents%
63	57	speed/cppad/det_minor.cpp%

66	60	speed/cppad/ode.cpp%
67	61	speed/cppad/poly.cpp%
68	62	speed/cppad/sparse_hessian.cpp%
69		speed/cppad/sparse_jacobian.cpp%
70		speed/cppad/print_optimize.cpp
	63	speed/cppad/sparse_jacobian.cpp
71	64	%$$
72	65
73	66	$end

-13

omh/speed/speed_double.omh less more

0		$Id: speed_double.omh 2579 2012-11-17 18:58:29Z bradbell $
	0	$Id: speed_double.omh 3308 2014-05-26 14:29:01Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11
12	12	$begin speed_double$$
13	13	$spell
	14	cmake
14	15	cppad
15	16	CppAD
16	17	Cygwin

36	37	$head Running Tests$$
37	38	To build these speed tests, and run their correctness tests,
38	39	execute the following commands starting in the
39		$cref/work directory/InstallUnix/Work Directory/$$:
	40	$cref/build directory/cmake/CMake Command/Build Directory/$$:
40	41	$codei%
41	42	cd speed/double
42		make test
	43	make check_speed_double VERBOSE=1
43	44	%$$
44	45	You can then run the corresponding speed tests
45	46	with the following command
46	47	$codei%
47		./double speed %seed%
	48	./speed_double speed %seed%
48	49	%$$
49	50	where $icode seed$$ is a positive integer.
50	51	See $cref speed_main$$ for more options.
51
52		$head C++ Compiler Flags$$
53		The C++ compiler flags used to build the $code double$$ program are
54		$code
55		$verbatim%speed/double/makefile.am%5%# BEGIN OPTIMIZE%# END OPTIMIZE%$$
56		$$
57		where $code CXX_FLAGS$$ is specified by the
58		$cref/configure/InstallUnix/Configure/$$ command.
59	52
60	53	$contents%
61	54	speed/double/det_minor.cpp%

+12

-18

omh/speed/speed_fadbad.omh less more

0		$Id: speed_fadbad.omh 2579 2012-11-17 18:58:29Z bradbell $
	0	$Id: speed_fadbad.omh 3308 2014-05-26 14:29:01Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11
12	12	$begin speed_fadbad$$
13	13	$spell
	14	cmake
14	15	FadbadDir
15	16	CppAD
16	17	Cygwin

28	29	This section links to the source code the Fadbad speed tests
29	30	(any suggestions to make the Fadbad results faster are welcome).
30	31
31		$head fadbad_dir$$
32		To run these tests, you must include the $code configure$$ command line option
33		$codei%
34		FADBAD_DIR=%fadbad_dir%
35		%$$
36		during $cref/installation/InstallUnix/fadbad_dir/$$.
	32	$head fadbad_prefix$$
	33	To run these tests,
	34	you must include the $cref fadbad_prefix$$
	35	in you $cref/cmake command/cmake/CMake Command/$$.
	36
37	37
38	38	$head Running Tests$$
39	39	To build these speed tests, and run their correctness tests,
40	40	execute the following commands starting in the
41		$cref/work directory/InstallUnix/Work Directory/$$:
	41	$cref/build directory/cmake/CMake Command/Build Directory/$$:
42	42	$codei%
43		cd speed/double
44		make test
	43	cd speed/fadbad
	44	make check_speed_fadbad VERBOSE=1
45	45	%$$
46	46	You can then run the corresponding speed tests
47	47	with the following command
48	48	$codei%
49		./double speed %seed%
	49	./speed_fadbad speed %seed%
50	50	%$$
51	51	where $icode seed$$ is a positive integer.
52	52	See $cref speed_main$$ for more options.
53
54		$head C++ Compiler Flags$$
55		The C++ compiler flags used to build the Fadbad speed tests are
56		$code
57		$verbatim%speed/fadbad/makefile.am%5%# BEGIN OPTIMIZE%# END OPTIMIZE%$$
58		$$
59	53
60	54	$contents%
61	55	speed/fadbad/det_minor.cpp%

+10

-19

omh/speed/speed_sacado.omh less more

0		$Id: speed_sacado.omh 2579 2012-11-17 18:58:29Z bradbell $
	0	$Id: speed_sacado.omh 3308 2014-05-26 14:29:01Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11
12	12	$begin speed_sacado$$
13	13	$spell
	14	cmake
14	15	SacadoDir
15	16	CppAD
16	17	Cygwin

28	29	This section links to the source code the Sacado speed tests
29	30	(any suggestions to make the Sacado results faster are welcome).
30	31
31		$head sacado_dir$$
32		To run these tests, you must include the $code configure$$ command line option
33		$codei%
34		SACADO_DIR=%sacado_dir%
35		%$$
36		during $cref/installation/InstallUnix/sacado_dir/$$.
	32	$head sacado_prefix$$
	33	To run these tests,
	34	you must include the $cref sacado_prefix$$
	35	in you $cref/cmake command/cmake/CMake Command/$$.
37	36
38	37
39	38	$head Running Tests$$
40	39	To build these speed tests, and run their correctness tests,
41	40	execute the following commands starting in the
42		$cref/work directory/InstallUnix/Work Directory/$$:
	41	$cref/build directory/cmake/CMake Command/Build Directory/$$:
43	42	$codei%
44	43	cd speed/sacado
45		make test
	44	make check_speed_sacado VERBOSE=1
46	45	%$$
47	46	You can then run the corresponding speed tests
48	47	with the following command
49	48	$codei%
50		./sacado speed %seed%
	49	./speed_sacado speed %seed%
51	50	%$$
52	51	where $icode seed$$ is a positive integer.
53	52	See $cref speed_main$$ for more options.
54
55		$head C++ Compiler Flags$$
56		The C++ compiler flags used to build the Sacado speed tests are
57		$code
58		$verbatim%speed/sacado/makefile.am%5%# BEGIN OPTIMIZE%# END OPTIMIZE%$$
59		$$
60		where $code CXX_FLAGS$$ is specified by the
61		$cref/configure/InstallUnix/Configure/$$ command.
62	53
63	54	$contents%
64	55	speed/sacado/det_minor.cpp%

-2

omh/speed/speed_utility.omh less more

0		$Id: speed_utility.omh 2579 2012-11-17 18:58:29Z bradbell $
	0	$Id: speed_utility.omh 3123 2014-02-26 21:40:18Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

42	42	$rref det_33$$
43	43	$rref det_grad_33$$
44	44	$rref mat_sum_sq$$
	45	$rref ode_evaluate$$
45	46	$rref sparse_jac_fun$$
46	47	$rref sparse_hes_fun$$
47	48	$rref uniform_01$$

-85

~~omh/sqrt_forward.omh~~ less more

0		$Id: sqrt_forward.omh 2506 2012-10-24 19:36:49Z bradbell $
1		// BEGIN SHORT COPYRIGHT
2		/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
4
5		CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
7		GNU General Public License Version 3.
8
9		A copy of this license is included in the COPYING file of this distribution.
10		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11		-------------------------------------------------------------------------- */
12		// END SHORT COPYRIGHT
13
14		$begin SqrtForward$$
15		$spell
16		sqrt
17		Arctangent
18		Taylor
19		$$
20
21		$index sqrt, forward theory$$
22		$index theory, sqrt forward$$
23		$index forward, sqrt theory$$
24
25		$section Square Root Function Forward Taylor Polynomial Theory$$
26
27		If $latex F(x) = \sqrt{x} $$
28		$latex \[
29		F(x) * F^{(1)} (x) - 0 * F (x) = 1/2
30		\] $$
31		and in the
32		$xref/
33		ForwardTheory/
34		Standard Math Functions/
35		Differential Equation/
36		standard math function differential equation/
37		1
38		/$$,
39		$latex A(x) = 0$$,
40		$latex B(x) = F(x)$$,
41		and $latex D(x) = 1/2$$.
42		We use $latex a$$, $latex b$$, $latex d$$,
43		and $latex z$$ to denote the
44		Taylor coefficients for
45		$latex A [ X (t) ] $$,
46		$latex B [ X (t) ]$$,
47		$latex D [ X (t) ] $$,
48		and $latex F [ X(t) ] $$ respectively.
49		It now follows from the general
50		$xref/
51		ForwardTheory/
52		Standard Math Functions/
53		Taylor Coefficients Recursion Formula/
54		Taylor coefficients recursion formula/
55		1
56		/$$
57		that for $latex j = 0 , 1, \ldots$$,
58		$latex \[
59		\begin{array}{rcl}
60		z^{(0)} & = & \sqrt { x^{(0)} }
61		\\
62		e^{(j)}
63		& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
64		\\
65		& = & \left\{ \begin{array}{ll}
66		1/2 & {\rm if} \; j = 0 \\
67		0 & {\rm otherwise}
68		\end{array} \right.
69		\\
70		z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
71		\left(
72		\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
73		- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
74		\right)
75		\\
76		& = & \frac{1}{j+1} \frac{1}{ z^{(0)} }
77		\left(
78		\frac{j+1}{2} x^{(j+1) }
79		- \sum_{k=1}^j k z^{(k)} z^{(j+1-k)}
80		\right)
81		\end{array}
82		\] $$
83
84		$end

-88

~~omh/sqrt_reverse.omh~~ less more

0		$Id: sqrt_reverse.omh 2506 2012-10-24 19:36:49Z bradbell $
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		$begin SqrtReverse$$
13		$spell
14		sqrt
15		Taylor
16		$$
17
18		$index sqrt, reverse theory$$
19		$index theory, sqrt reverse$$
20		$index reverse, sqrt theory$$
21
22		$section Square Root Function Reverse Mode Theory$$
23
24
25		We use the reverse theory
26		$xref%
27		ReverseTheory%
28		Standard Math Functions%
29		standard math function
30		%$$
31		definition for the functions $latex H$$ and $latex G$$.
32
33		The forward mode formulas for the
34		$cref/square root/SqrtForward/$$
35		function are
36		$latex \[
37		z^{(j)} = \sqrt { x^{(0)} }
38		\] $$
39
40		for the case $latex j = 0$$, and for $latex j > 0$$,
41
42		$latex \[
43		z^{(j)} = \frac{1}{j} \frac{1}{ z^{(0)} }
44		\left(
45		\frac{j}{2} x^{(j) }
46		- \sum_{\ell=1}^{j-1} \ell z^{(\ell)} z^{(j-\ell)}
47		\right)
48		\] $$
49
50		If $latex j = 0$$, we have the relation
51
52		$latex \[
53		\begin{array}{rcl}
54		\D{H}{ x^{(j)} } & = &
55		\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
56		\\
57		& = &
58		\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{2 z^{(0)} }
59		\end{array}
60		\] $$
61
62		If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
63
64		$latex \[
65		\begin{array}{rcl}
66		\D{H}{ z^{(0)} } & = &
67		\D{G}{ z^{(0)} } + \D{G} { z^{(j)} } \D{ z^{(j)} }{ z^{(0)} }
68		\\
69		& = &
70		\D{G}{ z^{(0)} } -
71		\D{G}{ z^{(j)} } \frac{ z^{(j)} }{ z^{(0)} }
72		\\
73		\D{H}{ x^{(j)} } & = &
74		\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
75		\\
76		& = &
77		\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{ 2 z^{(0)} }
78		\\
79		\D{H}{ z^{(k)} } & = &
80		\D{G}{ z^{(k)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
81		\\
82		& = &
83		\D{G}{ z^{(k)} } - \D{G}{ z^{(j)} } \frac{ z^{(j-k)} }{ z^{(0)} }
84		\end{array}
85		\] $$
86
87		$end

-87

~~omh/tan_forward.omh~~ less more

0		$Id: tan_forward.omh 2506 2012-10-24 19:36:49Z bradbell $
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		$begin tan_forward$$
13		$spell
14		Taylor
15		$$
16
17		$index tan, forward theory$$
18		$index theory, tan forward$$
19		$index forward, tan theory$$
20
21		$section Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory$$
22
23		$head Derivatives$$
24		$latex \[
25		\begin{array}{rcl}
26		\tan^{(1)} ( u ) & = & [ \cos (u)^2 + \sin (u)^2 ] / \cos (u)^2
27		\\
28		& = & 1 + \tan (u)^2
29		\\
30		\tanh^{(1)} ( u ) & = & [ \cosh (u)^2 - \sinh (u)^2 ] / \cosh (u)^2
31		\\
32		& = & 1 - \tanh (u)^2
33		\end{array}
34		\] $$
35		If $latex F(u)$$ is $latex \tan (u)$$ or $latex \tanh (u)$$
36		the corresponding derivative is given by
37		$latex \[
38		F^{(1)} (u) = 1 \pm F(u)^2
39		\]$$
40		Given $latex X(t)$$, we define the function $latex Z(t) = F[ X(t) ]$$.
41		It follows that
42		$latex \[
43		Z^{(1)} (t) = F^{(1)} [ X(t) ] X^{(1)} (t) = [ 1 \pm Y(t) ] X^{(1)} (t)
44		\] $$
45		where we define the function $latex Y(t) = Z(t)^2$$.
46
47		$head Taylor Coefficients Recursion$$
48		Suppose that we are given the Taylor coefficients
49		up to order $latex j$$ for the function $latex X(t)$$ and
50		up to order $latex j-1$$ for the functions $latex Y(t)$$ and $latex Z(t)$$.
51		We need a formula that computes the coefficient of order $latex j$$
52		for $latex Y(t)$$ and $latex Z(t)$$.
53		Using the equation above for $latex Z^{(1)} (t)$$, we have
54		$latex \[
55		\begin{array}{rcl}
56		\sum_{k=1}^j k z^{(k)} t^{k-1}
57		& = &
58		\sum_{k=1}^j k x^{(k)} t^{k-1}
59		\pm
60		\left[ \sum_{k=0}^{j-1} y^{(k)} t^k \right]
61		\left[ \sum_{k=1}^j k x^{(k)} t^{k-1} \right]
62		+
63		o( t^{j-1} )
64		\end{array}
65		\] $$
66		Setting the coefficients of $latex t^{j-1}$$ equal, we have
67		$latex \[
68		\begin{array}{rcl}
69		j z^{(j)}
70		=
71		j x^{(j)}
72		\pm
73		\sum_{k=1}^j k x^{(k)} y^{(j-k)}
74		\\
75		z^{(j)}
76		=
77		x^{(j)} \pm \frac{1}{j} \sum_{k=1}^j k x^{(k)} y^{(j-k)}
78		\end{array}
79		\] $$
80		Once we have computed $latex z^{(j+1)}$$,
81		we can compute $latex y^{(j+1)}$$ as follows:
82		$latex \[
83		y^{(j)} = \sum_{k=0}^j z^{(k)} z^{(j-k)}
84		\] $$
85
86		$end

-117

~~omh/tan_reverse.omh~~ less more

0		$Id: tan_reverse.omh 2506 2012-10-24 19:36:49Z bradbell $
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		$begin tan_reverse$$
13		$spell
14		Taylor
15		$$
16
17		$index tan, reverse theory$$
18		$index theory, tan reverse$$
19		$index reverse, tan theory$$
20
21		$section Tangent and Hyperbolic Tangent Reverse Mode Theory$$
22
23		$head Notation$$
24		We use the reverse theory
25		$cref/standard math function/ReverseTheory/Standard Math Functions/$$
26		definition for the functions $latex H$$ and $latex G$$.
27		In addition, we use the forward mode notation in $cref tan_forward$$ for
28		$latex X(t)$$, $latex Y(t)$$ and $latex Z(t)$$.
29
30		$head Eliminating Y(t)$$
31		For $latex j > 0$$, the forward mode coefficients are given by
32		$latex \[
33		y^{(j-1)} = \sum_{k=0}^{j-1} z^{(k)} z^{(j-k-1)}
34		\] $$
35		Fix $latex j > 0$$ and suppose that $latex H$$ is the same as $latex G$$
36		except that $latex y^{(j-1)}$$ is replaced as a function of the Taylor
37		coefficients for $latex Z(t)$$.
38		To be specific, for $latex k = 0 , \ldots , j-1$$,
39		$latex \[
40		\begin{array}{rcl}
41		\D{H}{ z^{(k)} }
42		& = &
43		\D{G}{ z^{(k)} } + \D{G}{ y^{(j-1)} } \D{ y^{(j-1)} }{ z^{(k)} }
44		\\
45		& = &
46		\D{G}{ z^{(k)} } + \D{G}{ y^{(j-1)} } 2 z^{(j-k-1)}
47		\end{array}
48		\] $$
49
50
51		$head Positive Orders Z(t)$$
52		For order $latex j > 0$$,
53		suppose that $latex H$$ is the same as $latex G$$ except that
54		$latex z^{(j)}$$ is expressed as a function of
55		the coefficients for $latex X(t)$$, and the
56		lower order Taylor coefficients for $latex Y(t)$$, $latex Z(t)$$.
57		$latex \[
58		z^{(j)}
59		=
60		x^{(j)} \pm \frac{1}{j} \sum_{k=1}^j k x^{(k)} y^{(j-k)}
61		\] $$
62		For $latex k = 1 , \ldots , j$$,
63		the partial of $latex H$$ with respect to $latex x^{(k)}$$ is given by
64		$latex \[
65		\begin{array}{rcl}
66		\D{H}{ x^{(k)} } & = &
67		\D{G}{ x^{(k)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
68		\\
69		& = &
70		\D{G}{ x^{(k)} } +
71		\D{G}{ z^{(j)} }
72		\left[ \delta ( j - k ) \pm \D{G}{ z^{(j)} }\frac{k}{j} y^{(j-k)} \right]
73		\end{array}
74		\] $$
75		where $latex \delta ( j - k )$$ is one if $latex j = k$$ and zero
76		otherwise.
77		For $latex k = 1 , \ldots , j$$
78		The partial of $latex H$$ with respect to $latex y^{j-k}$$,
79		is given by
80		$latex \[
81		\begin{array}{rcl}
82		\D{H}{ y^{(j-k)} } & = &
83		\D{G}{ y^{(j-k)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ y^{(j-k)} }
84		\\
85		& = &
86		\D{G}{ y^{(j-k)} } \pm \D{G}{ z^{(j)} }\frac{k}{j} x^{k}
87		\end{array}
88		\] $$
89
90
91		$head Order Zero Z(t)$$
92		The order zero coefficients for the tangent and hyperbolic tangent are
93		$latex \[
94		\begin{array}{rcl}
95		z^{(0)} & = & \left\{
96		\begin{array}{c} \tan ( x^{(0)} ) \\ \tanh ( x^{(0)} ) \end{array}
97		\right.
98		\end{array}
99		\] $$
100		Suppose that $latex H$$ is the same as $latex G$$ except that
101		$latex z^{(0)}$$ is expressed as a function of the Taylor coefficients
102		for $latex X(t)$$.
103		In this case,
104		$latex \[
105		\begin{array}{rcl}
106		\D{H}{ x^{(0)} }
107		& = &
108		\D{G}{ x^{(0)} }
109		+ \D{G}{ z^{(0)} } \D{ z^{(0)} }{ x^{(0)} }
110		\\
111		& = &
112		\D{G}{ x^{(0)} } + \D{G}{ z^{(0)} } ( 1 \pm y^{(0)} )
113		\end{array}
114		\] $$
115
116		$end

+115

-0

omh/theory/acos_forward.omh less more

	0	$Id: acos_forward.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin AcosForward$$
	15	$spell
	16	acos
	17	Arccosine
	18	Taylor
	19	$$
	20
	21	$index acos, forward theory$$
	22	$index theory, acos forward$$
	23	$index forward, acos theory$$
	24
	25	$section Arccosine Function Forward Taylor Polynomial Theory$$
	26
	27	If $latex F(x) = \arccos(x) $$ it follows that
	28	$latex \[
	29	\sqrt{ 1 - x * x } * F^{(1)} (x) - 0 * F (u) = -1
	30	\] $$
	31	and in the
	32	$xref/
	33	ForwardTheory/
	34	Standard Math Functions/
	35	Differential Equation/
	36	standard math function differential equation/
	37	1
	38	/$$,
	39	$latex A(x) = 0$$,
	40	$latex B(x) = \sqrt{1 - x * x }$$,
	41	and $latex D(x) = -1$$.
	42	We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the
	43	Taylor coefficients for
	44	$latex A [ X (t) ] $$,
	45	$latex B [ X (t) ]$$,
	46	$latex D [ X (t) ] $$,
	47	and $latex F [ X(t) ] $$ respectively.
	48	$pre
	49
	50	$$
	51	We define $latex Q(x) = 1 - x * x$$
	52	and let $latex q$$ be the corresponding Taylor coefficients for
	53	$latex Q[ X(t) ]$$.
	54	It follows that
	55	$latex \[
	56	q^{(j)} = \left\{ \begin{array}{ll}
	57	1 - x^{(0)} * x^{(0)} & {\rm if} \; j = 0 \\
	58	- \sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
	59	\end{array} \right.
	60	\] $$
	61	It follows that
	62	$latex B[ X(t) ] = \sqrt{ Q[ X(t) ] }$$ and
	63	from the equations for the
	64	$cref/square root/SqrtForward/$$
	65	that for $latex j = 0 , 1, \ldots$$,
	66	$latex \[
	67	\begin{array}{rcl}
	68	b^{(0)} & = & \sqrt{ q^{(0)} }
	69	\\
	70	b^{(j+1)} & = &
	71	\frac{1}{j+1} \frac{1}{ b^{(0)} }
	72	\left(
	73	\frac{j+1}{2} q^{(j+1) }
	74	- \sum_{k=1}^j k b^{(k)} b^{(j+1-k)}
	75	\right)
	76	\end{array}
	77	\] $$
	78	It now follows from the general
	79	$xref/
	80	ForwardTheory/
	81	Standard Math Functions/
	82	Taylor Coefficients Recursion Formula/
	83	Taylor coefficients recursion formula/
	84	1
	85	/$$
	86	that for $latex j = 0 , 1, \ldots$$,
	87	$latex \[
	88	\begin{array}{rcl}
	89	z^{(0)} & = & \arccos ( x^{(0)} )
	90	\\
	91	e^{(j)}
	92	& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
	93	\\
	94	& = & \left\{ \begin{array}{ll}
	95	-1 & {\rm if} \; j = 0 \\
	96	0 & {\rm otherwise}
	97	\end{array} \right.
	98	\\
	99	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	100	\left(
	101	\sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
	102	- \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
	103	\right)
	104	\\
	105	z^{(j+1)} & = & - \frac{1}{j+1} \frac{1}{ b^{(0)} }
	106	\left(
	107	(j+1) x^{(j+1)}
	108	+ \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
	109	\right)
	110	\end{array}
	111	\] $$
	112
	113
	114	$end

+164

-0

omh/theory/acos_reverse.omh less more

	0	$Id: acos_reverse.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin AcosReverse$$
	15	$spell
	16	acos
	17	Taylor
	18	Arccosine
	19	$$
	20
	21	$index acos, reverse theory$$
	22	$index theory, acos reverse$$
	23	$index reverse, acos theory$$
	24
	25	$section Arccosine Function Reverse Mode Theory$$
	26
	27
	28	We use the reverse theory
	29	$xref%
	30	ReverseTheory%
	31	Standard Math Functions%
	32	standard math function
	33	%$$
	34	definition for the functions $latex H$$ and $latex G$$.
	35	In addition,
	36
	37	we use $latex q$$ and $latex b$$
	38	for the $th p$$ order Taylor coefficient
	39	row vectors corresponding to functions
	40	$latex \[
	41	\begin{array}{rcl}
	42	Q(t) & = & 1 - X(t) * X(t) \\
	43	B(t) & = & \sqrt{ Q(t) }
	44	\end{array}
	45	\] $$
	46	and replace $latex z^{(j)}$$ by
	47	$latex \[
	48	( z^{(j)} , b^{(j)} )
	49	\] $$
	50	in the definition for $latex G$$ and $latex H$$.
	51	The forward mode formulas for the
	52	$cref/acos/AcosForward/$$
	53	function are
	54	$latex \[
	55	\begin{array}{rcl}
	56	q^{(0)} & = & 1 - x^{(0)} x^{(0)} \\
	57	b^{(j)} & = & \sqrt{ q^{(0)} } \\
	58	z^{(j)} & = & \arccos ( x^{(0)} )
	59	\end{array}
	60	\] $$
	61
	62	for the case $latex j = 0$$, and for $latex j > 0$$,
	63
	64	$latex \[
	65	\begin{array}{rcl}
	66	q^{(j)} & = &
	67	- \sum_{k=0}^j x^{(k)} x^{(j-k)}
	68	\\
	69	b^{(j)} & = &
	70	\frac{1}{j} \frac{1}{ b^{(0)} }
	71	\left(
	72	\frac{j}{2} q^{(j)}
	73	- \sum_{k=1}^{j-1} k b^{(k)} b^{(j-k)}
	74	\right)
	75	\\
	76	z^{(j)} & = & - \frac{1}{j} \frac{1}{ b^{(0)} }
	77	\left(
	78	j x^{(j)}
	79	+ \sum_{k=1}^{j-1} k z^{(k)} b^{(j-k)}
	80	\right)
	81	\end{array}
	82	\] $$
	83
	84	If $latex j = 0$$, we have the relation
	85
	86	$latex \[
	87	\begin{array}{rcl}
	88	\D{H}{ x^{(j)} } & = &
	89	\D{G}{ x^{(0)} }
	90	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
	91	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(0)} } \D{ q^{(0)} }{ x^{(0)} }
	92	\\
	93	& = &
	94	\D{G}{ x^{(j)} }
	95	- \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
	96	- \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
	97	\end{array}
	98	\] $$
	99
	100	If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
	101
	102	$latex \[
	103	\begin{array}{rcl}
	104	\D{H}{ b^{(0)} } & = &
	105	\D{G}{ b^{(0)} }
	106	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(0)} }
	107	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(0)} }
	108	\\
	109	& = &
	110	\D{G}{ b^{(0)} }
	111	- \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} }
	112	- \D{G}{ b^{(j)} } \frac{ b^{(j)} }{ b^{(0)} }
	113	\\
	114	\D{H}{ x^{(0)} } & = &
	115	\D{G}{ x^{(0)} }
	116	+
	117	\D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(0)} }
	118	\\
	119	& = &
	120	\D{G}{ x^{(0)} }
	121	- \D{G}{ b^{(j)} } \frac{ x^{(j)} }{ b^{(0)} }
	122	\\
	123	\D{H}{ x^{(j)} } & = &
	124	\D{G}{ x^{(j)} }
	125	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
	126	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(j)} }
	127	\\
	128	& = &
	129	\D{G}{ x^{(j)} }
	130	- \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
	131	- \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
	132	\\
	133	\D{H}{ b^{(j - k)} } & = &
	134	\D{G}{ b^{(j - k)} }
	135	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(j - k)} }
	136	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(j - k)} }
	137	\\
	138	& = &
	139	\D{G}{ b^{(j - k)} }
	140	- \D{G}{ z^{(j)} } \frac{k z^{(k)} }{j b^{(0)} }
	141	- \D{G}{ b^{(j)} } \frac{ b^{(k)} }{ b^{(0)} }
	142	\\
	143	\D{H}{ x^{(k)} } & = &
	144	\D{G}{ x^{(k)} }
	145	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
	146	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(k)} }
	147	\\
	148	& = &
	149	\D{G}{ x^{(k)} }
	150	- \D{G}{ b^{(j)} } \frac{ x^{(j-k)} }{ b^{(0)} }
	151	\\
	152	\D{H}{ z^{(k)} } & = &
	153	\D{G}{ z^{(k)} }
	154	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
	155	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ z^{(k)} }
	156	\\
	157	& = &
	158	\D{G}{ z^{(k)} }
	159	- \D{G}{ z^{(j)} } \frac{k b^{(j-k)} }{ j b^{(0)} }
	160	\end{array}
	161	\] $$
	162
	163	$end

+115

-0

omh/theory/asin_forward.omh less more

	0	$Id: asin_forward.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin AsinForward$$
	15	$spell
	16	asin
	17	Arcsine
	18	Taylor
	19	$$
	20
	21	$index asin, forward theory$$
	22	$index theory, asin forward$$
	23	$index forward, asin theory$$
	24
	25	$section Arcsine Function Forward Taylor Polynomial Theory$$
	26
	27	If $latex F(x) = \arcsin(x) $$ it follows that
	28	$latex \[
	29	\sqrt{ 1 - x * x } * F^{(1)} (x) - 0 * F (u) = 1
	30	\] $$
	31	and in the
	32	$xref/
	33	ForwardTheory/
	34	Standard Math Functions/
	35	Differential Equation/
	36	standard math function differential equation/
	37	1
	38	/$$,
	39	$latex A(x) = 0$$,
	40	$latex B(x) = \sqrt{1 - x * x }$$,
	41	and $latex D(x) = 1$$.
	42	We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the
	43	Taylor coefficients for
	44	$latex A [ X (t) ] $$,
	45	$latex B [ X (t) ]$$,
	46	$latex D [ X (t) ] $$,
	47	and $latex F [ X(t) ] $$ respectively.
	48	$pre
	49
	50	$$
	51	We define $latex Q(x) = 1 - x * x$$
	52	and let $latex q$$ be the corresponding Taylor coefficients for
	53	$latex Q[ X(t) ]$$.
	54	It follows that
	55	$latex \[
	56	q^{(j)} = \left\{ \begin{array}{ll}
	57	1 - x^{(0)} * x^{(0)} & {\rm if} \; j = 0 \\
	58	- \sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
	59	\end{array} \right.
	60	\] $$
	61	It follows that
	62	$latex B[ X(t) ] = \sqrt{ Q[ X(t) ] }$$ and
	63	from the equations for the
	64	$cref/square root/SqrtForward/$$
	65	that for $latex j = 0 , 1, \ldots$$,
	66	$latex \[
	67	\begin{array}{rcl}
	68	b^{(0)} & = & \sqrt{ q^{(0)} }
	69	\\
	70	b^{(j+1)} & = &
	71	\frac{1}{j+1} \frac{1}{ b^{(0)} }
	72	\left(
	73	\frac{j+1}{2} q^{(j+1) }
	74	- \sum_{k=1}^j k b^{(k)} b^{(j+1-k)}
	75	\right)
	76	\end{array}
	77	\] $$
	78	It now follows from the general
	79	$xref/
	80	ForwardTheory/
	81	Standard Math Functions/
	82	Taylor Coefficients Recursion Formula/
	83	Taylor coefficients recursion formula/
	84	1
	85	/$$
	86	that for $latex j = 0 , 1, \ldots$$,
	87	$latex \[
	88	\begin{array}{rcl}
	89	z^{(0)} & = & \arcsin ( x^{(0)} )
	90	\\
	91	e^{(j)}
	92	& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
	93	\\
	94	& = & \left\{ \begin{array}{ll}
	95	1 & {\rm if} \; j = 0 \\
	96	0 & {\rm otherwise}
	97	\end{array} \right.
	98	\\
	99	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	100	\left(
	101	\sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
	102	- \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
	103	\right)
	104	\\
	105	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	106	\left(
	107	(j+1) x^{(j+1)}
	108	- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
	109	\right)
	110	\end{array}
	111	\] $$
	112
	113
	114	$end

+164

-0

omh/theory/asin_reverse.omh less more

	0	$Id: asin_reverse.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin AsinReverse$$
	15	$spell
	16	asin
	17	Taylor
	18	Arcsine
	19	$$
	20
	21	$index asin, reverse theory$$
	22	$index theory, asin reverse$$
	23	$index reverse, asin theory$$
	24
	25	$section Arcsine Function Reverse Mode Theory$$
	26
	27
	28	We use the reverse theory
	29	$xref%
	30	ReverseTheory%
	31	Standard Math Functions%
	32	standard math function
	33	%$$
	34	definition for the functions $latex H$$ and $latex G$$.
	35	In addition,
	36
	37	we use $latex q$$ and $latex b$$
	38	for the $th p$$ order Taylor coefficient
	39	row vectors corresponding to functions
	40	$latex \[
	41	\begin{array}{rcl}
	42	Q(t) & = & 1 - X(t) * X(t) \\
	43	B(t) & = & \sqrt{ Q(t) }
	44	\end{array}
	45	\] $$
	46	and replace $latex z^{(j)}$$ by
	47	$latex \[
	48	( z^{(j)} , b^{(j)} )
	49	\] $$
	50	in the definition for $latex G$$ and $latex H$$.
	51	The forward mode formulas for the
	52	$cref/asin/AsinForward/$$
	53	function are
	54	$latex \[
	55	\begin{array}{rcl}
	56	q^{(0)} & = & 1 - x^{(0)} x^{(0)} \\
	57	b^{(j)} & = & \sqrt{ q^{(0)} } \\
	58	z^{(j)} & = & \arcsin ( x^{(0)} )
	59	\end{array}
	60	\] $$
	61
	62	for the case $latex j = 0$$, and for $latex j > 0$$,
	63
	64	$latex \[
	65	\begin{array}{rcl}
	66	q^{(j)} & = &
	67	- \sum_{k=0}^j x^{(k)} x^{(j-k)}
	68	\\
	69	b^{(j)} & = &
	70	\frac{1}{j} \frac{1}{ b^{(0)} }
	71	\left(
	72	\frac{j}{2} q^{(j)}
	73	- \sum_{k=1}^{j-1} k b^{(k)} b^{(j-k)}
	74	\right)
	75	\\
	76	z^{(j)} & = & \frac{1}{j} \frac{1}{ b^{(0)} }
	77	\left(
	78	j x^{(j)}
	79	- \sum_{k=1}^{j-1} k z^{(k)} b^{(j-k)}
	80	\right)
	81	\end{array}
	82	\] $$
	83
	84	If $latex j = 0$$, we have the relation
	85
	86	$latex \[
	87	\begin{array}{rcl}
	88	\D{H}{ x^{(j)} } & = &
	89	\D{G}{ x^{(0)} }
	90	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
	91	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(0)} } \D{ q^{(0)} }{ x^{(0)} }
	92	\\
	93	& = &
	94	\D{G}{ x^{(j)} }
	95	+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
	96	- \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
	97	\end{array}
	98	\] $$
	99
	100	If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
	101
	102	$latex \[
	103	\begin{array}{rcl}
	104	\D{H}{ b^{(0)} } & = &
	105	\D{G}{ b^{(0)} }
	106	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(0)} }
	107	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(0)} }
	108	\\
	109	& = &
	110	\D{G}{ b^{(0)} }
	111	- \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} }
	112	- \D{G}{ b^{(j)} } \frac{ b^{(j)} }{ b^{(0)} }
	113	\\
	114	\D{H}{ x^{(0)} } & = &
	115	\D{G}{ x^{(0)} }
	116	+
	117	\D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(0)} }
	118	\\
	119	& = &
	120	\D{G}{ x^{(0)} }
	121	- \D{G}{ b^{(j)} } \frac{ x^{(j)} }{ b^{(0)} }
	122	\\
	123	\D{H}{ x^{(j)} } & = &
	124	\D{G}{ x^{(j)} }
	125	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
	126	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(j)} }
	127	\\
	128	& = &
	129	\D{G}{ x^{(j)} }
	130	+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
	131	- \D{G}{ b^{(j)} } \frac{ x^{(0)} }{ b^{(0)} }
	132	\\
	133	\D{H}{ b^{(j - k)} } & = &
	134	\D{G}{ b^{(j - k)} }
	135	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(j - k)} }
	136	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(j - k)} }
	137	\\
	138	& = &
	139	\D{G}{ b^{(j - k)} }
	140	- \D{G}{ z^{(j)} } \frac{k z^{(k)} }{j b^{(0)} }
	141	- \D{G}{ b^{(j)} } \frac{ b^{(k)} }{ b^{(0)} }
	142	\\
	143	\D{H}{ x^{(k)} } & = &
	144	\D{G}{ x^{(k)} }
	145	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
	146	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ q^{(j)} } \D{ q^{(j)} }{ x^{(k)} }
	147	\\
	148	& = &
	149	\D{G}{ x^{(k)} }
	150	- \D{G}{ b^{(j)} } \frac{ x^{(j-k)} }{ b^{(0)} }
	151	\\
	152	\D{H}{ z^{(k)} } & = &
	153	\D{G}{ z^{(k)} }
	154	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
	155	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ z^{(k)} }
	156	\\
	157	& = &
	158	\D{G}{ z^{(k)} }
	159	- \D{G}{ z^{(j)} } \frac{k b^{(j-k)} }{ j b^{(0)} }
	160	\end{array}
	161	\] $$
	162
	163	$end

+90

-0

omh/theory/atan_forward.omh less more

	0	$Id: atan_forward.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin AtanForward$$
	15	$spell
	16	atan
	17	Arctangent
	18	Taylor
	19	$$
	20
	21	$index atan, forward theory$$
	22	$index theory, atan forward$$
	23	$index forward, atan theory$$
	24
	25	$section Arctangent Function Forward Taylor Polynomial Theory$$
	26
	27	If $latex F(x) = \arctan(x) $$
	28	$latex \[
	29	(1 + x * x ) * F^{(1)} (x) - 0 * F (x) = 1
	30	\] $$
	31	and in the
	32	$xref/
	33	ForwardTheory/
	34	Standard Math Functions/
	35	Differential Equation/
	36	standard math function differential equation/
	37	1
	38	/$$,
	39	$latex A(x) = 0$$,
	40	$latex B(x) = 1 + x * x $$,
	41	and $latex D(x) = 1$$.
	42	We use $latex a$$, $latex b$$, $latex d$$ and $latex z$$ to denote the
	43	Taylor coefficients for
	44	$latex A [ X (t) ] $$,
	45	$latex B [ X (t) ]$$,
	46	$latex D [ X (t) ] $$,
	47	and $latex F [ X(t) ] $$ respectively.
	48	It now follows from the general
	49	$xref/
	50	ForwardTheory/
	51	Standard Math Functions/
	52	Taylor Coefficients Recursion Formula/
	53	Taylor coefficients recursion formula/
	54	1
	55	/$$
	56	that for $latex j = 0 , 1, \ldots$$,
	57	$latex \[
	58	\begin{array}{rcl}
	59	z^{(0)} & = & \arctan ( x^{(0)} )
	60	\\
	61	b^{(j)}
	62	& = & \left\{ \begin{array}{ll}
	63	1 + x^{(0)} * x^{(0)} & {\rm if} \; j = 0 \\
	64	\sum_{k=0}^j x^{(k)} x^{(j-k)} & {\rm otherwise}
	65	\end{array} \right.
	66	\\
	67	e^{(j)}
	68	& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
	69	\\
	70	& = & \left\{ \begin{array}{ll}
	71	1 & {\rm if} \; j = 0 \\
	72	0 & {\rm otherwise}
	73	\end{array} \right.
	74	\\
	75	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	76	\left(
	77	\sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
	78	- \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
	79	\right)
	80	\\
	81	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	82	\left(
	83	(j+1) x^{(j+1)}
	84	- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
	85	\right)
	86	\end{array}
	87	\] $$
	88
	89	$end

+148

-0

omh/theory/atan_reverse.omh less more

	0	$Id: atan_reverse.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin AtanReverse$$
	15	$spell
	16	Arctangent
	17	atan
	18	Taylor
	19	$$
	20
	21	$index atan, reverse theory$$
	22	$index theory, atan reverse$$
	23	$index reverse, atan theory$$
	24
	25	$section Arctangent Function Reverse Mode Theory$$
	26
	27
	28	We use the reverse theory
	29	$xref%
	30	ReverseTheory%
	31	Standard Math Functions%
	32	standard math function
	33	%$$
	34	definition for the functions $latex H$$ and $latex G$$.
	35	In addition,
	36
	37	we use $latex b$$
	38	for the $th p$$ order Taylor coefficient
	39	row vectors corresponding to
	40	$latex 1 + X(t) * X(t)$$
	41	and replace $latex z^{(j)}$$ by
	42	$latex \[
	43	( z^{(j)} , b^{(j)} )
	44	\] $$
	45	in the definition for $latex G$$ and $latex H$$.
	46	The forward mode formulas for the
	47	$cref/arctangent/AtanForward/$$
	48	function are
	49	$latex \[
	50	\begin{array}{rcl}
	51	z^{(j)} & = & \arctan ( x^{(0)} ) \\
	52	b^{(j)} & = & 1 + x^{(0)} x^{(0)}
	53	\end{array}
	54	\] $$
	55
	56	for the case $latex j = 0$$, and for $latex j > 0$$,
	57
	58	$latex \[
	59	\begin{array}{rcl}
	60	b^{(j)} & = &
	61	\sum_{k=0}^j x^{(k)} x^{(j-k)}
	62	\\
	63	z^{(j)} & = & \frac{1}{j} \frac{1}{ b^{(0)} }
	64	\left(
	65	j x^{(j)}
	66	- \sum_{k=1}^{j-1} k z^{(k)} b^{(j-k)}
	67	\right)
	68	\end{array}
	69	\] $$
	70
	71	If $latex j = 0$$, we have the relation
	72
	73	$latex \[
	74	\begin{array}{rcl}
	75	\D{H}{ x^{(j)} } & = &
	76	\D{G}{ x^{(j)} }
	77	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
	78	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(0)} }
	79	\\
	80	& = &
	81	\D{G}{ x^{(j)} }
	82	+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
	83	+ \D{G}{ b^{(j)} } 2 x^{(0)}
	84	\end{array}
	85	\] $$
	86
	87	If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
	88
	89	$latex \[
	90	\begin{array}{rcl}
	91	\D{H}{ b^{(0)} } & = &
	92	\D{G}{ b^{(0)} }
	93	- \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(0)} }
	94	\\
	95	& = &
	96	\D{G}{ b^{(0)} }
	97	- \D{G}{ z^{(j)} } \frac{ z^{(j)} }{ b^{(0)} }
	98	\\
	99	\D{H}{ x^{(j)} } & = &
	100	\D{G}{ x^{(j)} }
	101	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
	102	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(j)} }
	103	\\
	104	& = &
	105	\D{G}{ x^{(j)} }
	106	+ \D{G}{ z^{(j)} } \frac{1}{ b^{(0)} }
	107	+ \D{G}{ b^{(j)} } 2 x^{(0)}
	108	\\
	109	\D{H}{ x^{(0)} } & = &
	110	\D{G}{ x^{(0)} }
	111	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
	112	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(0)} }
	113	\\
	114	& = &
	115	\D{G}{ x^{(0)} } +
	116	\D{G}{ b^{(j)} } 2 x^{(j)}
	117	\\
	118	\D{H}{ x^{(k)} } & = &
	119	\D{G}{ x^{(k)} }
	120	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
	121	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ x^{(k)} }
	122	\\
	123	& = &
	124	\D{G}{ x^{(k)} }
	125	+ \D{G}{ b^{(j)} } 2 x^{(j-k)}
	126	\\
	127	\D{H}{ z^{(k)} } & = &
	128	\D{G}{ z^{(k)} }
	129	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
	130	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ z^{(k)} }
	131	\\
	132	& = &
	133	\D{G}{ z^{(k)} }
	134	- \D{G}{ z^{(j)} } \frac{k b^{(j-k)} }{ j b^{(0)} }
	135	\\
	136	\D{H}{ b^{(j-k)} } & = &
	137	\D{G}{ b^{(j-k)} }
	138	+ \D{G}{ z^{(j)} } \D{ z^{(j)} }{ b^{(j-k)} }
	139	+ \D{G}{ b^{(j)} } \D{ b^{(j)} }{ b^{(j-k)} }
	140	\\
	141	& = &
	142	\D{G}{ b^{(j-k)} }
	143	- \D{G}{ z^{(j)} } \frac{k z^{(k)} }{ j b^{(0)} }
	144	\end{array}
	145	\] $$
	146
	147	$end

+72

-0

omh/theory/erf_forward.omh less more

	0	$Id:$
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin erf_forward$$
	13	$spell
	14	erf
	15	Taylor
	16	$$
	17
	18	$index erf, forward theory$$
	19	$index theory, erf forward$$
	20	$index forward, erf theory$$
	21
	22	$section Error Function Forward Taylor Polynomial Theory$$
	23
	24	$head Derivatives$$
	25	Given $latex X(t)$$, we define the function
	26	$latex \[
	27	Z(t) = \R{erf}[ X(t) ]
	28	\]$$
	29	It follows that
	30	$latex \[
	31	\begin{array}{rcl}
	32	\R{erf}^{(1)} ( u ) & = & ( 2 / \sqrt{\pi} ) \exp \left( - u^2 \right)
	33	\\
	34	Z^{(1)} (t) & = & \R{erf}^{(1)} [ X(t) ] X^{(1)} (t) = Y(t) X^{(1)} (t)
	35	\end{array}
	36	\] $$
	37	where we define the function
	38	$latex \[
	39	Y(t) = \frac{2}{ \sqrt{\pi} } \exp \left[ - X(t)^2 \right]
	40	\] $$
	41
	42	$head Taylor Coefficients Recursion$$
	43	Suppose that we are given the Taylor coefficients
	44	up to order $latex j$$ for the function $latex X(t)$$ and $latex Y(t)$$.
	45	We need a formula that computes the coefficient of order $latex j$$
	46	for $latex Z(t)$$.
	47	Using the equation above for $latex Z^{(1)} (t)$$, we have
	48	$latex \[
	49	\begin{array}{rcl}
	50	\sum_{k=1}^j k z^{(k)} t^{k-1}
	51	& = &
	52	\left[ \sum_{k=0}^j y^{(k)} t^k \right]
	53	\left[ \sum_{k=1}^j k x^{(k)} t^{k-1} \right]
	54	+
	55	o( t^{j-1} )
	56	\end{array}
	57	\] $$
	58	Setting the coefficients of $latex t^{j-1}$$ equal, we have
	59	$latex \[
	60	\begin{array}{rcl}
	61	j z^{(j)}
	62	=
	63	\sum_{k=1}^j k x^{(k)} y^{(j-k)}
	64	\\
	65	z^{(j)}
	66	=
	67	\frac{1}{j} \sum_{k=1}^j k x^{(k)} y^{(j-k)}
	68	\end{array}
	69	\] $$
	70
	71	$end

+72

-0

omh/theory/erf_reverse.omh less more

	0	$Id:$
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin erf_reverse$$
	13	$spell
	14	erf
	15	Taylor
	16	$$
	17
	18	$index erf, reverse theory$$
	19	$index theory, erf reverse$$
	20	$index reverse, erf theory$$
	21
	22	$section Error Function Reverse Mode Theory$$
	23
	24	$head Notation$$
	25	We use the reverse theory
	26	$cref/standard math function/ReverseTheory/Standard Math Functions/$$
	27	definition for the functions $latex H$$ and $latex G$$.
	28
	29	$head Positive Orders Z(t)$$
	30	For order $latex j > 0$$,
	31	suppose that $latex H$$ is the same as $latex G$$.
	32	$latex \[
	33	z^{(j)}
	34	=
	35	\frac{1}{j} \sum_{k=1}^j k x^{(k)} y^{(j-k)}
	36	\] $$
	37	For $latex k = 1 , \ldots , j$$,
	38	the partial of $latex H$$ with respect to $latex x^{(k)}$$ is given by
	39	$latex \[
	40	\D{H}{ x^{(k)} }
	41	=
	42	\D{G}{ x^{(k)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
	43	=
	44	\D{G}{ x^{(k)} } + \D{G}{ z^{(j)} } \frac{k}{j} y^{(j-k)}
	45	\] $$
	46	For $latex k = 1 , \ldots , j$$
	47	The partial of $latex H$$ with respect to $latex y^{j-k}$$,
	48	is given by
	49	$latex \[
	50	\D{H}{ y^{(j-k)} }
	51	=
	52	\D{G}{ y^{(j-k)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ y^{(j-k)} }
	53	=
	54	\D{G}{ y^{(j-k)} } + \D{G}{ z^{(j)} } \frac{k}{j} x^{k}
	55	\] $$
	56
	57
	58	$head Order Zero Z(t)$$
	59	The $latex z^{(0)}$$ coefficient
	60	is expressed as a function of the Taylor coefficients
	61	for $latex X(t)$$ and $latex Y(t)$$ as follows:
	62	In this case,
	63	$latex \[
	64	\D{H}{ x^{(0)} }
	65	=
	66	\D{G}{ x^{(0)} } + \D{G}{ z^{(0)} } \D{ z^{(0)} }{ x^{(0)} }
	67	=
	68	\D{G}{ x^{(0)} } + \D{G}{ z^{(0)} } y^{(0)}
	69	\] $$
	70
	71	$end

+78

-0

omh/theory/exp_forward.omh less more

	0	$Id: exp_forward.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin ExpForward$$
	15	$spell
	16	exp
	17	Taylor
	18	$$
	19
	20	$index exp, forward theory$$
	21	$index theory, exp forward$$
	22	$index forward, exp theory$$
	23
	24	$section Exponential Function Forward Taylor Polynomial Theory$$
	25
	26	If $latex F(x) = \exp(x) $$
	27	$latex \[
	28	1 * F^{(1)} (x) - 1 * F (x) = 0
	29	\] $$
	30	and in the
	31	$xref/
	32	ForwardTheory/
	33	Standard Math Functions/
	34	Differential Equation/
	35	standard math function differential equation/
	36	1
	37	/$$,
	38	$latex A(x) = 1$$,
	39	$latex B(x) = 1$$,
	40	and $latex D(x) = 0$$.
	41	We use $latex a$$, $latex b$$, $latex d$$,
	42	and $latex z$$ to denote the
	43	Taylor coefficients for
	44	$latex A [ X (t) ] $$,
	45	$latex B [ X (t) ]$$,
	46	$latex D [ X (t) ] $$,
	47	and $latex F [ X(t) ] $$ respectively.
	48	It now follows from the general
	49	$xref/
	50	ForwardTheory/
	51	Standard Math Functions/
	52	Taylor Coefficients Recursion Formula/
	53	Taylor coefficients recursion formula/
	54	1
	55	/$$
	56	that for $latex j = 0 , 1, \ldots$$,
	57	$latex \[
	58	\begin{array}{rcl}
	59	z^{(0)} & = & \exp ( x^{(0)} )
	60	\\
	61	e^{(j)}
	62	& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
	63	\\
	64	& = & z^{(j)}
	65	\\
	66	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	67	\left(
	68	\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
	69	- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
	70	\right)
	71	\\
	72	& = & \frac{1}{j+1}
	73	\sum_{k=1}^{j+1} k x^{(k)} z^{(j+1-k)}
	74	\end{array}
	75	\] $$
	76
	77	$end

+68

-0

omh/theory/exp_reverse.omh less more

	0	$Id: exp_reverse.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin ExpReverse$$
	15	$spell
	16	Taylor
	17	exp
	18	$$
	19
	20	$index exp, reverse theory$$
	21	$index theory, exp reverse$$
	22	$index reverse, exp theory$$
	23
	24	$section Exponential Function Reverse Mode Theory$$
	25
	26	We use the reverse theory
	27	$xref%
	28	ReverseTheory%
	29	Standard Math Functions%
	30	standard math function
	31	%$$
	32	definition for the functions $latex H$$ and $latex G$$.
	33
	34	The forward mode formulas for the
	35	$cref/exponential/ExpForward/$$
	36	function are
	37	$latex \[
	38	z^{(j)} = \exp ( x^{(0)} )
	39	\] $$
	40	if $latex j = 0$$, and
	41	$latex \[
	42	z^{(j)} = \frac{1}{j}
	43	\sum_{k=1}^{j} k x^{(k)} z^{(j-k)}
	44	\] $$
	45
	46	for the case $latex j = 0$$, and for $latex j > 0$$,
	47
	48	$latex \[
	49	\begin{array}{rcl}
	50	\D{H}{ x^{(j)} } & = &
	51	\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } z^{(j)}
	52	\end{array}
	53	\] $$
	54
	55	If $latex j > 0$$, then for $latex k = 1 , \ldots , j$$
	56
	57	$latex \[
	58	\begin{array}{rcl}
	59	\D{H}{ x^{(k)} } & = &
	60	\D{G}{ x^{(k)} } + \D{G}{ z^{(j)} } \frac{1}{j} k z^{(j-k)}
	61	\\
	62	\D{H}{ z^{(j-k)} } & = &
	63	\D{G}{ z^{(j-k)} } + \D{G}{ z^{(j)} } \frac{1}{j} k x^{(k)}
	64	\end{array}
	65	\] $$
	66
	67	$end

+222

-0

omh/theory/forward_theory.omh less more

	0	$Id: forward_theory.omh 3495 2014-12-24 01:16:15Z bradbell $
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin ForwardTheory$$
	13	$spell
	14	Taylor
	15	$$
	16
	17	$section The Theory of Forward Mode$$
	18
	19	$head Taylor Notation$$
	20	In Taylor notation, each variable corresponds to
	21	a function of a single argument which we denote by $icode t$$
	22	(see Section 10.2 of
	23	$cref/Evaluating Derivatives/Bib/Evaluating Derivatives/$$).
	24	Here and below
	25	$latex X(t)$$, $latex Y(t)$$, and $icode Z(t)$$ are scalar valued functions
	26	and the corresponding $th p$$ order Taylor coefficients row vectors are
	27	$latex x$$, $latex y$$ and $latex z$$; i.e.,
	28	$latex \[
	29	\begin{array}{lcr}
	30	X(t) & = & x^{(0)} + x^{(1)} * t + \cdots + x^{(p)} * t^p + o( t^p ) \\
	31	Y(t) & = & y^{(0)} + y^{(1)} * t + \cdots + y^{(p)} * t^p + o( t^p ) \\
	32	Z(t) & = & z^{(0)} + z^{(1)} * t + \cdots + z^{(p)} * t^p + o( t^p )
	33	\end{array}
	34	\] $$
	35	For the purposes of this section, we are given $latex x$$ and $latex y$$
	36	and need to determine $latex z$$.
	37
	38	$head Binary Operators$$
	39
	40	$subhead Addition$$
	41	$latex \[
	42	\begin{array}{rcl}
	43	Z(t)
	44	& = & X(t) + Y(t)
	45	\\
	46	\sum_{j=0}^p z^{(j)} * t^j
	47	& = & \sum_{j=0}^p x^{(j)} * t^j + \sum_{j=0}^p y^{(j)} * t^j + o( t^p )
	48	\\
	49	z^{(j)} & = & x^{(j)} + y^{(j)}
	50	\end{array}
	51	\] $$
	52
	53	$subhead Subtraction$$
	54	$latex \[
	55	\begin{array}{rcl}
	56	Z(t)
	57	& = & X(t) - Y(t)
	58	\\
	59	\sum_{j=0}^p z^{(j)} * t^j
	60	& = & \sum_{j=0}^p x^{(j)} * t^j - \sum_{j=0}^p y^{(j)} * t^j + o( t^p )
	61	\\
	62	z^{(j)} & = & x^{(j)} - y^{(j)}
	63	\end{array}
	64	\] $$
	65
	66	$subhead Multiplication$$
	67	$latex \[
	68	\begin{array}{rcl}
	69	Z(t)
	70	& = & X(t) * Y(t)
	71	\\
	72	\sum_{j=0}^p z^{(j)} * t^j
	73	& = & \left( \sum_{j=0}^p x^{(j)} * t^j \right)
	74	*
	75	\left( \sum_{j=0}^p y^{(j)} * t^j \right) + o( t^p )
	76	\\
	77	z^{(j)} & = & \sum_{k=0}^j x^{(j-k)} * y^{(k)}
	78	\end{array}
	79	\] $$
	80
	81	$subhead Division$$
	82	$latex \[
	83	\begin{array}{rcl}
	84	Z(t)
	85	& = & X(t) / Y(t)
	86	\\
	87	x
	88	& = & z * y
	89	\\
	90	\sum_{j=0}^p x^{(j)} * t^j
	91	& = &
	92	\left( \sum_{j=0}^p z^{(j)} * t^j \right)
	93	*
	94	\left( \sum_{j=0}^p y^{(j)} * t^j \right)
	95	+
	96	o( t^p )
	97	\\
	98	x^{(j)} & = & \sum_{k=0}^j z^{(j-k)} y^{(k)}
	99	\\
	100	z^{(j)} & = & \frac{1}{y^{(0)}} \left( x^{(j)} - \sum_{k=1}^j z^{(j-k)} y^{(k)} \right)
	101	\end{array}
	102
	103	\] $$
	104
	105	$head Standard Math Functions$$
	106	Suppose that $latex F $$ is a standard math function and
	107	$latex \[
	108	Z(t) = F[ X(t) ]
	109	\]$$
	110
	111	$subhead Differential Equation$$
	112	All of the standard math functions
	113	satisfy a differential equation of the form
	114	$latex \[
	115	B(u) * F^{(1)} (u) - A(u) * F (u) = D(u)
	116	\] $$
	117	We use $latex a$$, $latex b$$ and $latex d$$ to denote the
	118	$th p$$ order Taylor coefficient row vectors for
	119	$latex A [ X (t) ] $$, $latex B [ X (t) ]$$ and $latex D [ X (t) ] $$
	120	respectively.
	121	We assume that these coefficients are known functions of $latex x$$,
	122	the $th p$$ order Taylor coefficients for $latex X(t)$$.
	123
	124	$subhead Taylor Coefficients Recursion Formula$$
	125	Our problem here is to express $latex z$$,
	126	the $th p$$ order Taylor coefficient row vector for $latex Z(t)$$,
	127	in terms of these other known coefficients.
	128	It follows from the formulas above that
	129	$latex \[
	130	\begin{array}{rcl}
	131	Z^{(1)} (t)
	132	& = & F^{(1)} [ X(t) ] * X^{(1)} (t)
	133	\\
	134	B[ X(t) ] * Z^{(1)} (t)
	135	& = & \{ D[ X(t) ] + A[ X(t) ] * Z(t) \} * X^{(1)} (t)
	136	\\
	137	B[ X(t) ] * Z^{(1)} (t) & = & E(t) * X^{(1)} (t)
	138	\end{array}
	139	\] $$
	140	where we define
	141	$latex \[
	142	E(t) = D[X(t)] + A[X(t)] * Z(t)
	143	\] $$
	144
	145	We can compute the value of $latex z^{(0)}$$ using the formula
	146	$latex \[
	147	z^{(0)} = F ( x^{(0)} )
	148	\]$$
	149	Suppose by induction (on $latex j$$) that we are given the
	150	Taylor coefficients of $latex E(t)$$ up to order $latex j-1$$; i.e.,
	151	$latex e^{(k)}$$ for $latex k = 0 , \ldots , j-1$$
	152	and the coefficients
	153	$latex z^{(k)}$$ for $latex k = 0 , \ldots , j$$.
	154	We can compute $latex e^{(j)}$$ using the formula
	155	$latex \[
	156	e^{(j)} = d^{(j)} + \sum_{k=0}^j a^{(j-k)} * z^{(k)}
	157	\] $$
	158	We need to complete the induction by finding formulas for $latex z^{(j+1)}$$.
	159	It follows for the formula for the
	160	$cref/multiplication/ForwardTheory/Binary Operators/Multiplication/$$
	161	operator that
	162	$latex \[
	163	\begin{array}{rcl}
	164	\left( \sum_{k=0}^j b^{(k)} t^k \right)
	165	*
	166	\left( \sum_{k=1}^{j+1} k z^{(k)} * t^{k-1} \right)
	167	& = &
	168	\left( \sum_{k=0}^j e^{(k)} * t^k \right)
	169	*
	170	\left( \sum_{k=1}^{j+1} k x^{(k)} * t^{k-1} \right)
	171	+
	172	o( t^p )
	173	\\
	174	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	175	\left(
	176	\sum_{k=0}^j e^{(k)} (j+1-k) x^{(j+1-k)}
	177	- \sum_{k=1}^j b^{(k)} (j+1-k) z^{(j+1-k)}
	178	\right)
	179	\\
	180	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	181	\left(
	182	\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
	183	- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
	184	\right)
	185	\end{array}
	186	\] $$
	187	This completes the induction that computes $latex e^{(j)}$$
	188	and $latex z^{(j+1)}$$.
	189
	190
	191
	192
	193	$children%
	194	omh/theory/exp_forward.omh%
	195	omh/theory/log_forward.omh%
	196	omh/theory/sqrt_forward.omh%
	197	omh/theory/sin_cos_forward.omh%
	198	omh/theory/atan_forward.omh%
	199	omh/theory/asin_forward.omh%
	200	omh/theory/acos_forward.omh%
	201	omh/theory/tan_forward.omh%
	202	omh/theory/erf_forward.omh
	203	%$$
	204
	205	$subhead Cases that Apply Recursion Above$$
	206	$table
	207	$rref ExpForward$$
	208	$rref LogForward$$
	209	$rref SqrtForward$$
	210	$rref SinCosForward$$
	211	$rref AtanForward$$
	212	$rref AsinForward$$
	213	$rref AcosForward$$
	214	$tend
	215
	216	$subhead Special Cases$$
	217	$table
	218	$rref tan_forward$$
	219	$tend
	220
	221	$end

+83

-0

omh/theory/log_forward.omh less more

	0	$Id: log_forward.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin LogForward$$
	15	$spell
	16	Taylor
	17	$$
	18
	19	$index log, forward theory$$
	20	$index theory, log forward$$
	21	$index forward, log theory$$
	22
	23	$section Logarithm Function Forward Taylor Polynomial Theory$$
	24
	25	If $latex F(x) = \log(x) $$
	26	$latex \[
	27	x * F^{(1)} (x) - 0 * F (x) = 1
	28	\] $$
	29	and in the
	30	$xref/
	31	ForwardTheory/
	32	Standard Math Functions/
	33	Differential Equation/
	34	standard math function differential equation/
	35	1
	36	/$$,
	37	$latex A(x) = 0$$,
	38	$latex B(x) = x$$,
	39	and $latex D(x) = 1$$.
	40	We use $latex a$$, $latex b$$, $latex d$$,
	41	and $latex z$$ to denote the
	42	Taylor coefficients for
	43	$latex A [ X (t) ] $$,
	44	$latex B [ X (t) ]$$,
	45	$latex D [ X (t) ] $$,
	46	and $latex F [ X(t) ] $$ respectively.
	47	It now follows from the general
	48	$xref/
	49	ForwardTheory/
	50	Standard Math Functions/
	51	Taylor Coefficients Recursion Formula/
	52	Taylor coefficients recursion formula/
	53	1
	54	/$$
	55	that for $latex j = 0 , 1, \ldots$$,
	56	$latex \[
	57	\begin{array}{rcl}
	58	z^{(0)} & = & \log ( x^{(0)} )
	59	\\
	60	e^{(j)}
	61	& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
	62	\\
	63	& = & \left\{ \begin{array}{ll}
	64	1 & {\rm if} \; j = 0 \\
	65	0 & {\rm otherwise}
	66	\end{array} \right.
	67	\\
	68	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	69	\left(
	70	\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
	71	- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
	72	\right)
	73	\\
	74	& = & \frac{1}{j+1} \frac{1}{ x^{(0)} }
	75	\left(
	76	(j+1) x^{(j+1) }
	77	- \sum_{k=1}^j k z^{(k)} x^{(j+1-k)}
	78	\right)
	79	\end{array}
	80	\] $$
	81
	82	$end

+87

-0

omh/theory/log_reverse.omh less more

	0	$Id: log_reverse.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin LogReverse$$
	15	$spell
	16	Taylor
	17	$$
	18
	19	$index log, reverse theory$$
	20	$index theory, log reverse$$
	21	$index reverse, log theory$$
	22
	23	$section Logarithm Function Reverse Mode Theory$$
	24
	25
	26	We use the reverse theory
	27	$xref%
	28	ReverseTheory%
	29	Standard Math Functions%
	30	standard math function
	31	%$$
	32	definition for the functions $latex H$$ and $latex G$$.
	33
	34	The forward mode formulas for the
	35	$cref/logarithm/LogForward/$$
	36	function are
	37	$latex \[
	38	z^{(j)} = \log ( x^{(0)} )
	39	\] $$
	40
	41	for the case $latex j = 0$$, and for $latex j > 0$$,
	42
	43	$latex \[
	44	z^{(j)}
	45	= \frac{1}{ x^{(0)} } \frac{1}{j}
	46	\left(
	47	j x^{(j)}
	48	- \sum_{k=1}^{j-1} k z^{(k)} x^{(j-k)}
	49	\right)
	50	\] $$
	51	otherwise.
	52	If $latex j = 0$$, we have the relation
	53	$latex \[
	54	\D{H}{ x^{(j)} } =
	55	\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{ x^{(0)} }
	56	\] $$
	57
	58	If $latex j > 0$$, then for $latex k = 1 , \ldots , j-1$$
	59
	60	$latex \[
	61	\begin{array}{rcl}
	62	\D{H}{ x^{(0)} } & = &
	63	\D{G}{ x^{(0)} } - \D{G}{ z^{(j)} } \frac{1}{ x^{(0)} }
	64	\frac{1}{ x^{(0)} } \frac{1}{j}
	65	\left(
	66	j x^{(j)}
	67	- \sum_{m=1}^{j-1} m z^{(m)} x^{(j-m)}
	68	\right)
	69	\\
	70	& = &
	71	\D{G}{ x^{(0)} } - \D{G}{ z^{(j)} } \frac{1}{ x^{(0)} } z^{(j)}
	72	\\
	73	\D{H}{ x^{(j)} } & = &
	74	\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{ x^{(0)} }
	75	\\
	76	\D{H}{ x^{(j-k)} } & = &
	77	\D{G}{ x^{(j-k)} } -
	78	\D{G}{ z^{(j)} } \frac{1}{ x^{(0)} } \frac{1}{j} k z^{(k)}
	79	\\
	80	\D{H}{ z^{(k)} } & = &
	81	\D{G}{ z^{(k)} } -
	82	\D{G}{ z^{(j)} } \frac{1}{ x^{(0)} } \frac{1}{j} k x^{(j-k)}
	83	\end{array}
	84	\] $$
	85
	86	$end

+156

-0

omh/theory/reverse_identity.omh less more

	0	$Id: reverse_identity.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin reverse_identity$$
	13	$spell
	14	Taylor
	15	Griewank
	16	Andreas
	17	$$
	18
	19
	20
	21	$section An Important Reverse Mode Identity$$
	22	The theorem and the proof below is a restatement
	23	of the results on page 236 of
	24	$cref/Evaluating Derivatives/Bib/Evaluating Derivatives/$$.
	25
	26	$head Notation$$
	27	Given a function $latex f(u, v)$$ where $latex u \in B^n$$
	28	we use the notation
	29	$latex \[
	30	\D{f}{u} (u, v) = \left[ \D{f}{u_1} (u, v) , \cdots , \D{f}{u_n} (u, v) \right]
	31	\] $$
	32
	33	$head Reverse Sweep$$
	34	When using $cref/reverse mode/reverse_any/$$
	35	we are given a function $latex F : B^n \rightarrow B^m$$,
	36	a matrix of Taylor coefficients $latex x \in B^{n \times p}$$,
	37	and a weight vector $latex w \in B^m$$.
	38	We define the functions $latex X : B \times B^{n \times p} \rightarrow B^n$$,
	39	$latex W : B \times B^{n \times p} \rightarrow B$$, and
	40	$latex W_j : B^{n \times p} \rightarrow B$$ by
	41	$latex \[
	42	\begin{array}{rcl}
	43	X(t , x) & = & x^{(0)} + x^{(1)} t + \cdots + x^{(p-1)} t^{p-1}
	44	\\
	45	W(t, x) & = & w_0 F_0 [X(t, x)] + \cdots + w_{m-1} F_{m-1} [X(t, x)]
	46	\\
	47	W_j (x) & = & \frac{1}{j!} \Dpow{j}{t} W(0, x)
	48	\end{array}
	49	\]$$
	50	where $latex x^{(j)}$$ is the $th j$$ column of $latex x \in B^{n \times p}$$.
	51	The theorem below implies that
	52	$latex \[
	53	\D{ W_j }{ x^{(i)} } (x) = \D{ W_{j-i} }{ x^{(0)} } (x)
	54	\] $$
	55	A $cref/general reverse sweep/reverse_any/$$ calculates the values
	56	$latex \[
	57	\D{ W_{p-1} }{ x^{(i)} } (x) \hspace{1cm} (i = 0 , \ldots , p-1)
	58	\] $$
	59	But the return values for a reverse sweep are specified
	60	in terms of the more useful values
	61	$latex \[
	62	\D{ W_j }{ x^{(0)} } (x) \hspace{1cm} (j = 0 , \ldots , p-1)
	63	\] $$
	64
	65	$head Theorem$$
	66	Suppose that $latex F : B^n \rightarrow B^m$$ is a $latex p$$ times
	67	continuously differentiable function.
	68	Define the functions
	69	$latex Z : B \times B^{n \times p} \rightarrow B^n$$,
	70	$latex Y : B \times B^{n \times p }\rightarrow B^m$$,
	71	and
	72	$latex y^{(j)} : B^{n \times p }\rightarrow B^m$$ by
	73	$latex \[
	74	\begin{array}{rcl}
	75	Z(t, x) & = & x^{(0)} + x^{(1)} t + \cdots + x^{(p-1)} t^{p-1}
	76	\\
	77	Y(t, x) & = & F [ Z(t, x) ]
	78	\\
	79	y^{(j)} (x) & = & \frac{1}{j !} \Dpow{j}{t} Y(0, x)
	80	\end{array}
	81	\] $$
	82	where $latex x^{(j)}$$ denotes the $th j$$ column of
	83	$latex x \in B^{n \times p}$$.
	84	It follows that
	85	for all $latex i, j$$ such that $latex i \leq j < p$$,
	86	$latex \[
	87	\begin{array}{rcl}
	88	\D{ y^{(j)} }{ x^{(i)} } (x) & = & \D{ y^{(j-i)} }{ x^{(0)} } (x)
	89	\end{array}
	90	\] $$
	91
	92
	93	$head Proof$$
	94	If follows from the definitions that
	95	$latex \[
	96	\begin{array}{rclr}
	97	\D{ y^{(j)} }{ x^{(i)} } (x)
	98	& = &
	99	\frac{1}{j ! } \D{ }{ x^{(i)} }
	100	\left[ \Dpow{j}{t} (F \circ Z) (t, x) \right]_{t=0}
	101	\\
	102	& = &
	103	\frac{1}{j ! } \left[ \Dpow{j}{t}
	104	\D{ }{ x^{(i)} } (F \circ Z) (t, x)
	105	\right]_{t=0}
	106	\\
	107	& = &
	108	\frac{1}{j ! } \left\{
	109	\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
	110	\right\}_{t=0}
	111	\end{array}
	112	\] $$
	113	For $latex k > i$$, the $th k$$
	114	partial of $latex t^i$$ with respect to $latex t$$ is zero.
	115	Thus, the partial with respect to $latex t$$ is given by
	116	$latex \[
	117	\begin{array}{rcl}
	118	\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
	119	& = &
	120	\sum_{k=0}^i
	121	\left( \begin{array}{c} j \\ k \end{array} \right)
	122	\frac{ i ! }{ (i - k) ! } t^{i-k} \;
	123	\Dpow{j-k}{t} ( F^{(1)} \circ Z ) (t, x)
	124	\\
	125	\left\{
	126	\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
	127	\right\}_{t=0}
	128	& = &
	129	\left( \begin{array}{c} j \\ i \end{array} \right)
	130	i ! \Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
	131	\\
	132	& = &
	133	\frac{ j ! }{ (j - i) ! }
	134	\Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
	135	\\
	136	\D{ y^{(j)} }{ x^{(i)} } (x)
	137	& = &
	138	\frac{ 1 }{ (j - i) ! }
	139	\Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
	140	\end{array}
	141	\] $$
	142	Applying this formula to the case where $latex j$$
	143	is replaced by $latex j - i$$ and $latex i$$ is replaced by zero,
	144	we obtain
	145	$latex \[
	146	\D{ y^{(j-i)} }{ x^{(0)} } (x)
	147	=
	148	\frac{ 1 }{ (j - i) ! }
	149	\Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
	150	=
	151	\D{ y^{(j)} }{ x^{(i)} } (x)
	152	\] $$
	153	which completes the proof
	154
	155	$end

+184

-0

omh/theory/reverse_theory.omh less more

	0	$Id: reverse_theory.omh 3495 2014-12-24 01:16:15Z bradbell $
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin ReverseTheory$$
	13	$spell
	14	Taylor
	15	Arctangent
	16	$$
	17
	18	$section The Theory of Reverse Mode$$
	19
	20	$head Taylor Notation$$
	21	In Taylor notation, each variable corresponds to
	22	a function of a single argument which we denote by $icode t$$
	23	(see Section 10.2 of
	24	$cref/Evaluating Derivatives/Bib/Evaluating Derivatives/$$).
	25	Here and below
	26	$latex X(t)$$, $latex Y(t)$$, and $icode Z(t)$$ are scalar valued functions
	27	and the corresponding $th p$$ order Taylor coefficients row vectors are
	28	$latex x$$, $latex y$$ and $latex z$$; i.e.,
	29	$latex \[
	30	\begin{array}{lcr}
	31	X(t) & = & x^{(0)} + x^{(1)} * t + \cdots + x^{(p)} * t^p + O( t^{p+1} ) \\
	32	Y(t) & = & y^{(0)} + y^{(1)} * t + \cdots + y^{(p)} * t^p + O( t^{p+1} ) \\
	33	Z(t) & = & z^{(0)} + z^{(1)} * t + \cdots + z^{(p)} * t^p + O( t^{p+1} )
	34	\end{array}
	35	\] $$
	36	For the purposes of this discussion,
	37	we are given the $th p$$ order Taylor coefficient row vectors
	38	$latex x$$, $latex y$$, and $latex z$$.
	39	In addition, we are given the partial derivatives of a scalar valued function
	40	$latex \[
	41	G ( z^{(j)} , \ldots , z^{(0)}, x, y)
	42	\] $$
	43	We need to compute the partial derivatives of the scalar valued function
	44	$latex \[
	45	H ( z^{(j-1)} , \ldots , z^{(0)}, x, y) =
	46	G ( z^{(j)}, z^{(j-1)} , \ldots , z^{(0)}, x , y )
	47	\] $$
	48	where $latex z^{(j)}$$ is expressed as a function of the
	49	$th j-1$$ order Taylor coefficient row
	50	vector for $latex Z$$ and the vectors $latex x$$, $latex y$$; i.e.,
	51	$latex z^{(j)}$$ above is a shorthand for
	52	$latex \[
	53	z^{(j)} ( z^{(j-1)} , \ldots , z^{(0)}, x, y )
	54	\] $$
	55	If we do not provide a formula for
	56	a partial derivative of $latex H$$, then that partial derivative
	57	has the same value as for the function $latex G$$.
	58
	59	$head Binary Operators$$
	60
	61	$subhead Addition$$
	62	The forward mode formula for
	63	$cref/addition/ForwardTheory/Binary Operators/Addition/$$ is
	64	$latex \[
	65	z^{(j)} = x^{(j)} + y^{(j)}
	66	\] $$
	67	If follows that for $latex k = 0 , \ldots , j$$
	68	and $latex l = 0 , \ldots , j-1$$
	69	$latex \[
	70	\begin{array}{rcl}
	71	\D{H}{ x^{(k)} } & = &
	72	\D{G}{ x^{(k)} } + \D{G}{ z^{(k)} } \\
	73	\\
	74	\D{H}{ y^{(k)} } & = &
	75	\D{G}{ y^{(k)} } + \D{G}{ z^{(k)} }
	76	\\
	77	\D{H}{ z^{(l)} } & = & \D{G}{ z^{(l)} }
	78	\end{array}
	79	\] $$
	80
	81	$subhead Subtraction$$
	82	The forward mode formula for
	83	$cref/subtraction/ForwardTheory/Binary Operators/Subtraction/$$ is
	84	$latex \[
	85	z^{(j)} = x^{(j)} - y^{(j)}
	86	\] $$
	87	If follows that for $latex k = 0 , \ldots , j$$
	88	$latex \[
	89	\begin{array}{rcl}
	90	\D{H}{ x^{(k)} } & = &
	91	\D{G}{ x^{(k)} } - \D{G}{ z^{(k)} } \\
	92	\\
	93	\D{H}{ y^{(k)} } & = &
	94	\D{G}{ y^{(k)} } - \D{G}{ z^{(k)} }
	95	\end{array}
	96	\] $$
	97
	98	$subhead Multiplication$$
	99	The forward mode formula for
	100	$cref/multiplication/ForwardTheory/Binary Operators/Multiplication/$$ is
	101	$latex \[
	102	z^{(j)} = \sum_{k=0}^j x^{(j-k)} * y^{(k)}
	103	\] $$
	104	If follows that for $latex k = 0 , \ldots , j$$
	105	and $latex l = 0 , \ldots , j-1$$
	106	$latex \[
	107	\begin{array}{rcl}
	108	\D{H}{ x^{(j-k)} } & = &
	109	\D{G}{ x^{(j-k)} } +
	110	\sum_{k=0}^j \D{G}{ z^{(j)} } y^{(k)}
	111	\\
	112	\D{H}{ y^{(k)} } & = &
	113	\D{G}{ y^{(k)} } +
	114	\sum_{k=0}^j \D{G}{ z^{(j)} } x^{(j-k)}
	115	\end{array}
	116	\] $$
	117
	118	$subhead Division$$
	119	The forward mode formula for
	120	$cref/division/ForwardTheory/Binary Operators/Division/$$ is
	121	$latex \[
	122	z^{(j)} =
	123	\frac{1}{y^{(0)}}
	124	\left(
	125	x^{(j)} - \sum_{k=1}^j z^{(j-k)} y^{(k)}
	126	\right)
	127	\] $$
	128	If follows that for $latex k = 1 , \ldots , j$$
	129	$latex \[
	130	\begin{array}{rcl}
	131	\D{H}{ x^{(j)} } & = &
	132	\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{y^{(0)}}
	133	\\
	134	\D{H}{ z^{(j-k)} } & = &
	135	\D{G}{ z^{(j-k)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} y^{(k)}
	136	\\
	137	\D{H}{ y^{(k)} } & = &
	138	\D{G}{ y^{(k)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} z^{(j-k)}
	139	\\
	140	\D{H}{ y^{(0)} } & = &
	141	\D{G}{ y^{(0)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} \frac{1}{y^{(0)}}
	142	\left(
	143	x^{(j)} - \sum_{k=1}^j z^{(j-k)} y^{(k)}
	144	\right)
	145	\\
	146	& = &
	147	\D{G}{ y^{(0)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} z^{(j)}
	148	\end{array}
	149	\] $$
	150
	151	$head Standard Math Functions$$
	152	The standard math functions have only one argument.
	153	Hence we are given the partial derivatives of a scalar valued function
	154	$latex \[
	155	G ( z^{(j)} , \ldots , z^{(0)}, x)
	156	\] $$
	157	We need to compute the partial derivatives of the scalar valued function
	158	$latex \[
	159	H ( z^{(j-1)} , \ldots , z^{(0)}, x) =
	160	G ( z^{(j)}, z^{(j-1)} , \ldots , z^{(0)}, x)
	161	\] $$
	162	where $latex z^{(j)}$$ is expressed as a function of the
	163	$th j-1$$ order Taylor coefficient row
	164	vector for $latex Z$$ and the vector $latex x$$; i.e.,
	165	$latex z^{(j)}$$ above is a shorthand for
	166	$latex \[
	167	z^{(j)} ( z^{(j-1)} , \ldots , z^{(0)}, x )
	168	\] $$
	169
	170
	171	$childtable%
	172	omh/theory/exp_reverse.omh%
	173	omh/theory/log_reverse.omh%
	174	omh/theory/sqrt_reverse.omh%
	175	omh/theory/sin_cos_reverse.omh%
	176	omh/theory/atan_reverse.omh%
	177	omh/theory/asin_reverse.omh%
	178	omh/theory/acos_reverse.omh%
	179	omh/theory/tan_reverse.omh%
	180	omh/theory/erf_reverse.omh
	181	%$$
	182
	183	$end

+122

-0

omh/theory/sin_cos_forward.omh less more

	0	$Id: sin_cos_forward.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin SinCosForward$$
	15	$spell
	16	sin
	17	cos
	18	sinh
	19	cosh
	20	Taylor
	21	$$
	22
	23
	24	$index sin, forward$$
	25	$index sinh, forward$$
	26	$index cos, forward$$
	27	$index cosh, forward$$
	28
	29	$index theory, sin$$
	30	$index theory, sinh$$
	31	$index theory, cos$$
	32	$index theory, cosh$$
	33
	34	$index forward, sin$$
	35	$index forward, sinh$$
	36	$index forward, cos$$
	37	$index forward, cosh$$
	38
	39	$section Trigonometric and Hyperbolic Sine and Cosine Forward Theory$$
	40
	41	$head Differential Equation$$
	42	The
	43	$xref/
	44	ForwardTheory/
	45	Standard Math Functions/
	46	Differential Equation/
	47	standard math function differential equation/
	48	1
	49	/$$
	50	is
	51	$latex \[
	52	B(u) * F^{(1)} (u) - A(u) * F (u) = D(u)
	53	\] $$
	54	In this sections we consider forward mode for the following choices:
	55
	56	$table
	57	$pre $$
	58	$cnext $cnext $latex F(u)$$
	59	$cnext $cnext $latex \sin(u)$$
	60	$cnext $cnext $latex \cos(u)$$
	61	$cnext $cnext $latex \sinh(u)$$
	62	$cnext $cnext $latex \cosh(u)$$
	63	$rnext
	64	$cnext $cnext $latex A(u)$$
	65	$cnext $cnext $latex 0$$
	66	$cnext $cnext $latex 0$$
	67	$cnext $cnext $latex 0$$
	68	$cnext $cnext $latex 0$$
	69	$rnext
	70	$cnext $cnext $latex B(u)$$
	71	$cnext $cnext $latex 1$$
	72	$cnext $cnext $latex 1$$
	73	$cnext $cnext $latex 1$$
	74	$cnext $cnext $latex 1$$
	75	$rnext
	76	$cnext $cnext $latex D(u)$$
	77	$cnext $cnext $latex \cos(u)$$
	78	$cnext $cnext $latex - \sin(u)$$
	79	$cnext $cnext $latex \cosh(u)$$
	80	$cnext $cnext $latex \sinh(u)$$
	81	$tend
	82
	83	We use $latex a$$, $latex b$$, $latex d$$ and $latex f$$ for the
	84	Taylor coefficients of
	85	$latex A [ X (t) ]$$,
	86	$latex B [ X (t) ]$$,
	87	$latex D [ X (t) ] $$,
	88	and $latex F [ X(t) ] $$ respectively.
	89	It now follows from the general
	90	$xref/
	91	ForwardTheory/
	92	Standard Math Functions/
	93	Taylor Coefficients Recursion Formula/
	94	Taylor coefficients recursion formula/
	95	1
	96	/$$
	97	that for $latex j = 0 , 1, \ldots$$,
	98	$latex \[
	99	\begin{array}{rcl}
	100	f^{(0)} & = & D ( x^{(0)} )
	101	\\
	102	e^{(j)}
	103	& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * f^{(k)}
	104	\\
	105	& = & d^{(j)}
	106	\\
	107	f^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	108	\left(
	109	\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
	110	- \sum_{k=1}^j k f^{(k)} b^{(j+1-k)}
	111	\right)
	112	\\
	113	& = & \frac{1}{j+1}
	114	\sum_{k=1}^{j+1} k x^{(k)} d^{(j+1-k)}
	115	\end{array}
	116	\] $$
	117	The formula above generates the
	118	order $latex j+1$$ coefficient of $latex F[ X(t) ]$$ from the
	119	lower order coefficients for $latex X(t)$$ and $latex D[ X(t) ]$$.
	120
	121	$end

+123

-0

omh/theory/sin_cos_reverse.omh less more

	0	$Id: sin_cos_reverse.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin SinCosReverse$$
	15	$spell
	16	Taylor
	17	cos
	18	$$
	19
	20	$index sin, reverse$$
	21	$index sinh, reverse$$
	22	$index cos, reverse$$
	23	$index cosh, reverse$$
	24
	25	$index theory, sin$$
	26	$index theory, sinh$$
	27	$index theory, cos$$
	28	$index theory, cosh$$
	29
	30	$index reverse, sin$$
	31	$index reverse, sinh$$
	32	$index reverse, cos$$
	33	$index reverse, cosh$$
	34
	35
	36	$section Trigonometric and Hyperbolic Sine and Cosine Reverse Theory$$
	37
	38
	39	We use the reverse theory
	40	$xref%
	41	ReverseTheory%
	42	Standard Math Functions%
	43	standard math function
	44	%$$
	45	definition for the functions $latex H$$ and $latex G$$.
	46	In addition,
	47	we use the following definitions for $latex s$$ and $latex c$$
	48	and the integer $latex \ell$$
	49
	50	$table
	51	Coefficients
	52	$cnext $cnext $latex s$$
	53	$cnext $cnext $latex c$$
	54	$cnext $cnext $latex \ell$$
	55	$rnext
	56	Trigonometric Case
	57	$cnext $cnext $latex \sin [ X(t) ]$$
	58	$cnext $cnext $latex \cos [ X(t) ]$$
	59	$cnext $cnext 1
	60	$rnext
	61	Hyperbolic Case
	62	$cnext $cnext $latex \sinh [ X(t) ]$$
	63	$cnext $cnext $latex \cosh [ X(t) ]$$
	64	$cnext $cnext -1
	65	$tend
	66	We use the value
	67	$latex \[
	68	z^{(j)} = ( s^{(j)} , c^{(j)} )
	69	\] $$
	70	in the definition for $latex G$$ and $latex H$$.
	71	The forward mode formulas for the
	72	$cref/sine and cosine/SinCosForward/$$ functions are
	73	$latex \[
	74	\begin{array}{rcl}
	75	s^{(j)} & = & \frac{1 + \ell}{2} \sin ( x^{(0)} )
	76	+ \frac{1 - \ell}{2} \sinh ( x^{(0)} )
	77	\\
	78	c^{(j)} & = & \frac{1 + \ell}{2} \cos ( x^{(0)} )
	79	+ \frac{1 - \ell}{2} \cosh ( x^{(0)} )
	80	\end{array}
	81	\] $$
	82
	83	for the case $latex j = 0$$, and for $latex j > 0$$,
	84
	85	$latex \[
	86	\begin{array}{rcl}
	87	s^{(j)} & = & \frac{1}{j}
	88	\sum_{k=1}^{j} k x^{(k)} c^{(j-k)} \\
	89	c^{(j)} & = & \ell \frac{1}{j}
	90	\sum_{k=1}^{j} k x^{(k)} s^{(j-k)}
	91	\end{array}
	92	\] $$
	93
	94	If $latex j = 0$$, we have the relation
	95
	96	$latex \[
	97	\begin{array}{rcl}
	98	\D{H}{ x^{(j)} } & = &
	99	\D{G}{ x^{(j)} }
	100	+ \D{G}{ s^{(j)} } c^{(0)}
	101	+ \ell \D{G}{ c^{(j)} } s^{(0)}
	102	\end{array}
	103	\] $$
	104
	105	If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
	106
	107	$latex \[
	108	\begin{array}{rcl}
	109	\D{H}{ x^{(k)} } & = &
	110	\D{G}{ x^{(k)} }
	111	+ \D{G}{ s^{(j)} } \frac{1}{j} k c^{(j-k)}
	112	+ \ell \D{G}{ c^{(j)} } \frac{1}{j} k s^{(j-k)}
	113	\\
	114	\D{H}{ s^{(j-k)} } & = &
	115	\D{G}{ s^{(j-k)} } + \ell \D{G}{ c^{(j)} } k x^{(k)}
	116	\\
	117	\D{H}{ c^{(j-k)} } & = &
	118	\D{G}{ c^{(j-k)} } + \D{G}{ s^{(j)} } k x^{(k)}
	119	\end{array}
	120	\] $$
	121
	122	$end

+85

-0

omh/theory/sqrt_forward.omh less more

	0	$Id: sqrt_forward.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	// BEGIN SHORT COPYRIGHT
	2	/* --------------------------------------------------------------------------
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	4
	5	CppAD is distributed under multiple licenses. This distribution is under
	6	the terms of the
	7	GNU General Public License Version 3.
	8
	9	A copy of this license is included in the COPYING file of this distribution.
	10	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	11	-------------------------------------------------------------------------- */
	12	// END SHORT COPYRIGHT
	13
	14	$begin SqrtForward$$
	15	$spell
	16	sqrt
	17	Arctangent
	18	Taylor
	19	$$
	20
	21	$index sqrt, forward theory$$
	22	$index theory, sqrt forward$$
	23	$index forward, sqrt theory$$
	24
	25	$section Square Root Function Forward Taylor Polynomial Theory$$
	26
	27	If $latex F(x) = \sqrt{x} $$
	28	$latex \[
	29	F(x) * F^{(1)} (x) - 0 * F (x) = 1/2
	30	\] $$
	31	and in the
	32	$xref/
	33	ForwardTheory/
	34	Standard Math Functions/
	35	Differential Equation/
	36	standard math function differential equation/
	37	1
	38	/$$,
	39	$latex A(x) = 0$$,
	40	$latex B(x) = F(x)$$,
	41	and $latex D(x) = 1/2$$.
	42	We use $latex a$$, $latex b$$, $latex d$$,
	43	and $latex z$$ to denote the
	44	Taylor coefficients for
	45	$latex A [ X (t) ] $$,
	46	$latex B [ X (t) ]$$,
	47	$latex D [ X (t) ] $$,
	48	and $latex F [ X(t) ] $$ respectively.
	49	It now follows from the general
	50	$xref/
	51	ForwardTheory/
	52	Standard Math Functions/
	53	Taylor Coefficients Recursion Formula/
	54	Taylor coefficients recursion formula/
	55	1
	56	/$$
	57	that for $latex j = 0 , 1, \ldots$$,
	58	$latex \[
	59	\begin{array}{rcl}
	60	z^{(0)} & = & \sqrt { x^{(0)} }
	61	\\
	62	e^{(j)}
	63	& = & d^{(j)} + \sum_{k=0}^{j} a^{(j-k)} * z^{(k)}
	64	\\
	65	& = & \left\{ \begin{array}{ll}
	66	1/2 & {\rm if} \; j = 0 \\
	67	0 & {\rm otherwise}
	68	\end{array} \right.
	69	\\
	70	z^{(j+1)} & = & \frac{1}{j+1} \frac{1}{ b^{(0)} }
	71	\left(
	72	\sum_{k=1}^{j+1} k x^{(k)} e^{(j+1-k)}
	73	- \sum_{k=1}^j k z^{(k)} b^{(j+1-k)}
	74	\right)
	75	\\
	76	& = & \frac{1}{j+1} \frac{1}{ z^{(0)} }
	77	\left(
	78	\frac{j+1}{2} x^{(j+1) }
	79	- \sum_{k=1}^j k z^{(k)} z^{(j+1-k)}
	80	\right)
	81	\end{array}
	82	\] $$
	83
	84	$end

+88

-0

omh/theory/sqrt_reverse.omh less more

	0	$Id: sqrt_reverse.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin SqrtReverse$$
	13	$spell
	14	sqrt
	15	Taylor
	16	$$
	17
	18	$index sqrt, reverse theory$$
	19	$index theory, sqrt reverse$$
	20	$index reverse, sqrt theory$$
	21
	22	$section Square Root Function Reverse Mode Theory$$
	23
	24
	25	We use the reverse theory
	26	$xref%
	27	ReverseTheory%
	28	Standard Math Functions%
	29	standard math function
	30	%$$
	31	definition for the functions $latex H$$ and $latex G$$.
	32
	33	The forward mode formulas for the
	34	$cref/square root/SqrtForward/$$
	35	function are
	36	$latex \[
	37	z^{(j)} = \sqrt { x^{(0)} }
	38	\] $$
	39
	40	for the case $latex j = 0$$, and for $latex j > 0$$,
	41
	42	$latex \[
	43	z^{(j)} = \frac{1}{j} \frac{1}{ z^{(0)} }
	44	\left(
	45	\frac{j}{2} x^{(j) }
	46	- \sum_{\ell=1}^{j-1} \ell z^{(\ell)} z^{(j-\ell)}
	47	\right)
	48	\] $$
	49
	50	If $latex j = 0$$, we have the relation
	51
	52	$latex \[
	53	\begin{array}{rcl}
	54	\D{H}{ x^{(j)} } & = &
	55	\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(0)} }
	56	\\
	57	& = &
	58	\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{2 z^{(0)} }
	59	\end{array}
	60	\] $$
	61
	62	If $latex j > 0$$, then for $latex k = 1, \ldots , j-1$$
	63
	64	$latex \[
	65	\begin{array}{rcl}
	66	\D{H}{ z^{(0)} } & = &
	67	\D{G}{ z^{(0)} } + \D{G} { z^{(j)} } \D{ z^{(j)} }{ z^{(0)} }
	68	\\
	69	& = &
	70	\D{G}{ z^{(0)} } -
	71	\D{G}{ z^{(j)} } \frac{ z^{(j)} }{ z^{(0)} }
	72	\\
	73	\D{H}{ x^{(j)} } & = &
	74	\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(j)} }
	75	\\
	76	& = &
	77	\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{ 2 z^{(0)} }
	78	\\
	79	\D{H}{ z^{(k)} } & = &
	80	\D{G}{ z^{(k)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ z^{(k)} }
	81	\\
	82	& = &
	83	\D{G}{ z^{(k)} } - \D{G}{ z^{(j)} } \frac{ z^{(j-k)} }{ z^{(0)} }
	84	\end{array}
	85	\] $$
	86
	87	$end

+87

-0

omh/theory/tan_forward.omh less more

	0	$Id: tan_forward.omh 3272 2014-05-20 13:50:52Z bradbell $
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin tan_forward$$
	13	$spell
	14	Taylor
	15	$$
	16
	17	$index tan, forward theory$$
	18	$index theory, tan forward$$
	19	$index forward, tan theory$$
	20
	21	$section Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory$$
	22
	23	$head Derivatives$$
	24	$latex \[
	25	\begin{array}{rcl}
	26	\tan^{(1)} ( u ) & = & [ \cos (u)^2 + \sin (u)^2 ] / \cos (u)^2
	27	\\
	28	& = & 1 + \tan (u)^2
	29	\\
	30	\tanh^{(1)} ( u ) & = & [ \cosh (u)^2 - \sinh (u)^2 ] / \cosh (u)^2
	31	\\
	32	& = & 1 - \tanh (u)^2
	33	\end{array}
	34	\] $$
	35	If $latex F(u)$$ is $latex \tan (u)$$ or $latex \tanh (u)$$
	36	the corresponding derivative is given by
	37	$latex \[
	38	F^{(1)} (u) = 1 \pm F(u)^2
	39	\]$$
	40	Given $latex X(t)$$, we define the function $latex Z(t) = F[ X(t) ]$$.
	41	It follows that
	42	$latex \[
	43	Z^{(1)} (t) = F^{(1)} [ X(t) ] X^{(1)} (t) = [ 1 \pm Y(t) ] X^{(1)} (t)
	44	\] $$
	45	where we define the function $latex Y(t) = Z(t)^2$$.
	46
	47	$head Taylor Coefficients Recursion$$
	48	Suppose that we are given the Taylor coefficients
	49	up to order $latex j$$ for the function $latex X(t)$$ and
	50	up to order $latex j-1$$ for the functions $latex Y(t)$$ and $latex Z(t)$$.
	51	We need a formula that computes the coefficient of order $latex j$$
	52	for $latex Y(t)$$ and $latex Z(t)$$.
	53	Using the equation above for $latex Z^{(1)} (t)$$, we have
	54	$latex \[
	55	\begin{array}{rcl}
	56	\sum_{k=1}^j k z^{(k)} t^{k-1}
	57	& = &
	58	\sum_{k=1}^j k x^{(k)} t^{k-1}
	59	\pm
	60	\left[ \sum_{k=0}^{j-1} y^{(k)} t^k \right]
	61	\left[ \sum_{k=1}^j k x^{(k)} t^{k-1} \right]
	62	+
	63	o( t^{j-1} )
	64	\end{array}
	65	\] $$
	66	Setting the coefficients of $latex t^{j-1}$$ equal, we have
	67	$latex \[
	68	\begin{array}{rcl}
	69	j z^{(j)}
	70	=
	71	j x^{(j)}
	72	\pm
	73	\sum_{k=1}^j k x^{(k)} y^{(j-k)}
	74	\\
	75	z^{(j)}
	76	=
	77	x^{(j)} \pm \frac{1}{j} \sum_{k=1}^j k x^{(k)} y^{(j-k)}
	78	\end{array}
	79	\] $$
	80	Once we have computed $latex z^{(j)}$$,
	81	we can compute $latex y^{(j)}$$ as follows:
	82	$latex \[
	83	y^{(j)} = \sum_{k=0}^j z^{(k)} z^{(j-k)}
	84	\] $$
	85
	86	$end

+117

-0

omh/theory/tan_reverse.omh less more

	0	$Id: tan_reverse.omh 3495 2014-12-24 01:16:15Z bradbell $
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin tan_reverse$$
	13	$spell
	14	Taylor
	15	$$
	16
	17	$index tan, reverse theory$$
	18	$index theory, tan reverse$$
	19	$index reverse, tan theory$$
	20
	21	$section Tangent and Hyperbolic Tangent Reverse Mode Theory$$
	22
	23	$head Notation$$
	24	We use the reverse theory
	25	$cref/standard math function/ReverseTheory/Standard Math Functions/$$
	26	definition for the functions $latex H$$ and $latex G$$.
	27	In addition, we use the forward mode notation in $cref tan_forward$$ for
	28	$latex X(t)$$, $latex Y(t)$$ and $latex Z(t)$$.
	29
	30	$head Eliminating Y(t)$$
	31	For $latex j > 0$$, the forward mode coefficients are given by
	32	$latex \[
	33	y^{(j-1)} = \sum_{k=0}^{j-1} z^{(k)} z^{(j-k-1)}
	34	\] $$
	35	Fix $latex j > 0$$ and suppose that $latex H$$ is the same as $latex G$$
	36	except that $latex y^{(j-1)}$$ is replaced as a function of the Taylor
	37	coefficients for $latex Z(t)$$.
	38	To be specific, for $latex k = 0 , \ldots , j-1$$,
	39	$latex \[
	40	\begin{array}{rcl}
	41	\D{H}{ z^{(k)} }
	42	& = &
	43	\D{G}{ z^{(k)} } + \D{G}{ y^{(j-1)} } \D{ y^{(j-1)} }{ z^{(k)} }
	44	\\
	45	& = &
	46	\D{G}{ z^{(k)} } + \D{G}{ y^{(j-1)} } 2 z^{(j-k-1)}
	47	\end{array}
	48	\] $$
	49
	50
	51	$head Positive Orders Z(t)$$
	52	For order $latex j > 0$$,
	53	suppose that $latex H$$ is the same as $latex G$$ except that
	54	$latex z^{(j)}$$ is expressed as a function of
	55	the coefficients for $latex X(t)$$, and the
	56	lower order Taylor coefficients for $latex Y(t)$$, $latex Z(t)$$.
	57	$latex \[
	58	z^{(j)}
	59	=
	60	x^{(j)} \pm \frac{1}{j} \sum_{k=1}^j k x^{(k)} y^{(j-k)}
	61	\] $$
	62	For $latex k = 1 , \ldots , j$$,
	63	the partial of $latex H$$ with respect to $latex x^{(k)}$$ is given by
	64	$latex \[
	65	\begin{array}{rcl}
	66	\D{H}{ x^{(k)} } & = &
	67	\D{G}{ x^{(k)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ x^{(k)} }
	68	\\
	69	& = &
	70	\D{G}{ x^{(k)} } +
	71	\D{G}{ z^{(j)} }
	72	\left[ \delta ( j - k ) \pm \frac{k}{j} y^{(j-k)} \right]
	73	\end{array}
	74	\] $$
	75	where $latex \delta ( j - k )$$ is one if $latex j = k$$ and zero
	76	otherwise.
	77	For $latex k = 1 , \ldots , j$$
	78	The partial of $latex H$$ with respect to $latex y^{j-k}$$,
	79	is given by
	80	$latex \[
	81	\begin{array}{rcl}
	82	\D{H}{ y^{(j-k)} } & = &
	83	\D{G}{ y^{(j-k)} } + \D{G}{ z^{(j)} } \D{ z^{(j)} }{ y^{(j-k)} }
	84	\\
	85	& = &
	86	\D{G}{ y^{(j-k)} } \pm \D{G}{ z^{(j)} }\frac{k}{j} x^{k}
	87	\end{array}
	88	\] $$
	89
	90
	91	$head Order Zero Z(t)$$
	92	The order zero coefficients for the tangent and hyperbolic tangent are
	93	$latex \[
	94	\begin{array}{rcl}
	95	z^{(0)} & = & \left\{
	96	\begin{array}{c} \tan ( x^{(0)} ) \\ \tanh ( x^{(0)} ) \end{array}
	97	\right.
	98	\end{array}
	99	\] $$
	100	Suppose that $latex H$$ is the same as $latex G$$ except that
	101	$latex z^{(0)}$$ is expressed as a function of the Taylor coefficients
	102	for $latex X(t)$$.
	103	In this case,
	104	$latex \[
	105	\begin{array}{rcl}
	106	\D{H}{ x^{(0)} }
	107	& = &
	108	\D{G}{ x^{(0)} }
	109	+ \D{G}{ z^{(0)} } \D{ z^{(0)} }{ x^{(0)} }
	110	\\
	111	& = &
	112	\D{G}{ x^{(0)} } + \D{G}{ z^{(0)} } ( 1 \pm y^{(0)} )
	113	\end{array}
	114	\] $$
	115
	116	$end

+22

-0

omh/theory/theory.omh less more

	0	$Id: theory.omh 3169 2014-03-09 13:37:59Z bradbell $
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin Theory$$
	13
	14	$section The Theory of Derivative Calculations$$
	15
	16	$contents%
	17	omh/theory/forward_theory.omh%
	18	omh/theory/reverse_theory.omh%
	19	omh/theory/reverse_identity.omh%$$
	20
	21	$end

-22

~~omh/theory.omh~~ less more

0		$Id: theory.omh 2506 2012-10-24 19:36:49Z bradbell $
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		$begin Theory$$
13
14		$section The Theory of Derivative Calculations$$
15
16		$contents%
17		omh/forward_theory.omh%
18		omh/reverse_theory.omh%
19		omh/reverse_identity.omh%$$
20
21		$end

-3

omh/whats_new/whats_new.omh less more

0		$Id: whats_new.omh 2709 2013-01-02 14:19:41Z bradbell $
	0	$Id: whats_new.omh 3083 2014-01-10 18:35:07Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

23	23	assist you in learning about changes between various versions of CppAD.
24	24
25	25	$children%
	26	omh/whats_new/whats_new_14.omh%
26	27	omh/whats_new/whats_new_13.omh%
27	28	omh/whats_new/whats_new_12.omh%
28	29	omh/whats_new/whats_new_11.omh%

37	38	%$$
38	39
39	40	$head This Year$$
40		$cref whats_new_13$$
	41	$cref whats_new_14$$
41	42
42	43	$head Previous Years$$
	44	$cref whats_new_13$$
43	45	$cref whats_new_12$$
44	46	$cref whats_new_11$$,
45	47	$cref whats_new_10$$,

-3

omh/whats_new/whats_new_04.omh less more

0		$Id: whats_new_04.omh 2579 2012-11-17 18:58:29Z bradbell $
	0	$Id: whats_new_04.omh 3170 2014-03-09 14:33:53Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

116	116	If $code NDEBUG$$ is not defined during compile time,
117	117	all $codei%AD<%Base%>%$$
118	118	$cref/comparison/Compare/$$ operations are checked during
119		$cref/zero order/ForwardZero/$$ forward mode calculations.
	119	$cref/zero order/forward_zero/$$ forward mode calculations.
120	120	The
121	121	$cref CompareChange$$ function
122	122	returns the number of comparison operations that have changed.

-7

omh/whats_new/whats_new_06.omh less more

0		$Id: whats_new_06.omh 2691 2012-12-30 23:39:57Z bradbell $
	0	$Id: whats_new_06.omh 3214 2014-03-18 20:50:38Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

575	575	for a subsequent AD operation sequence."
576	576
577	577	$subhead 06-17$$
578		Added $cref capacity_taylor$$ which can be used to control
	578	Added $cref capacity_order$$ which can be used to control
579	579	the amount of memory used to store $cref Forward$$ results.
580	580	Also $cref/deprecated/FunDeprecated/$$ $code taylor_size$$, and defined
581		$cref size_taylor$$ in its place.
	581	$cref size_order$$ in its place.
582	582
583	583	$subhead 06-18$$
584	584	Added the $cref/ADFun default constructor/FunConstruct/$$

762	762	independent variable values.
763	763	In this case, the sparsity pattern can be (and has been)
764	764	made more efficient; i.e., fewer true values
765		(because it only applies to the current $cref ForwardZero$$).
	765	(because it only applies to the current $cref forward_zero$$).
766	766	$pre
767	767
768	768	$$

814	814
815	815	$head 04-03$$
816	816	Create separate sections for the
817		$cref/zero/ForwardZero/$$ and $cref ForwardOne$$ first order case
	817	$cref/zero/forward_zero/$$ and $cref forward_one$$ first order case
818	818	of $cref Forward$$ mode.
819	819	$pre
820	820
821	821	$$
822	822	The ADFun $cref/Size/FunDeprecated/Size/$$ member function
823		has been deprecated (use $cref size_taylor$$ instead).
	823	has been deprecated (use $cref size_order$$ instead).
824	824	$pre
825	825
826	826	$$

-5

omh/whats_new/whats_new_07.omh less more

0		$Id: whats_new_07.omh 2579 2012-11-17 18:58:29Z bradbell $
	0	$Id: whats_new_07.omh 3308 2014-05-26 14:29:01Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

162	162	Added the $code -DRAD_EQ_ALIAS$$ compiler flag to the
163	163	$cref/Sacado speed tests/speed_sacado/$$.
164	164	In addition, compiler flag documentation was included for
165		$cref/Sacado/speed_sacado/C++ Compiler Flags/$$ and
166		all the other speed tests.
	165	Sacado and all the other speed tests.
167	166
168	167	$head 11-05$$
169	168	MS project files have been added for running the

699	698
700	699	$$
701	700	There was a typo in the
702		$cref/second order/ForwardAny/Second Order/$$ discussion
	701	$cref/second order/forward_order/Second Order/$$ discussion
703	702	(found by Kipp Martin).
704	703	It has been fixed.
705	704

-2

omh/whats_new/whats_new_08.omh less more

0		$Id: whats_new_08.omh 2863 2013-05-29 13:15:30Z bradbell $
	0	$Id: whats_new_08.omh 3301 2014-05-24 05:20:21Z bradbell $
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3

114	114	$head 09-30$$
115	115	Add or modify some wish list entries; see
116	116	$code cppad_ipopt_nlp$$ (since removed),
117		$cref/multiple arguments/WishList/Multiple Argument Forward/$$,
	117	multiple argument forward (completed with $cref forward_dir$$),
118	118	and sparsity patterns
119	119	($cref/sparsity patterns/glossary/Sparsity Pattern/$$ has been fulfilled).
120	120

-5

omh/whats_new/whats_new_09.omh less more

0		$Id: whats_new_09.omh 2683 2012-12-30 18:17:03Z bradbell $
	0	$Id: whats_new_09.omh 3214 2014-03-18 20:50:38Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

66	66	was changed so that it now copies forward mode
67	67	Taylor coefficients and sparsity pattern information.
68	68	(This assignment operator was added on $cref/10-24/whats_new_09/10-24/$$.)
69		You can use $cref capacity_taylor$$ to delete the Taylor coefficients
	69	You can use $cref capacity_order$$ to delete the Taylor coefficients
70	70	before copying them.
71	71	Two new functions were added so that you can query and delete the
72	72	forward mode sparsity information;

267	267	$code branches/optimize$$.
268	268
269	269	$subhead 08-13$$
270		An automatic check of the $cref ForwardZero$$ results was added
	270	An automatic check of the $cref forward_zero$$ results was added
271	271	after each call to $cref/f.optimize()/optimize/$$
272	272	(this $cref/check/optimize/Checking Optimization/$$
273	273	is skipped when $code NDEBUG$$ is defined).

281	281	This will make it possible to add options in the future with out
282	282	having to change all the existing tests because the options are now
283	283	global variables instead of arguments to the speed test routines; for example,
284		see $cref/retape/speed_main/option_list/retape/$$.
	284	see $code retape$$ speed test option.
285	285
286	286	$subhead 08-10$$
287	287	The routine for $cref/optimizing/optimize/$$ the operation sequence

-3

omh/whats_new/whats_new_11.omh less more

0		$Id: whats_new_11.omh 2936 2013-10-13 11:44:13Z bradbell $
	0	$Id: whats_new_11.omh 3170 2014-03-09 14:33:53Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

435	435	$codei%
436	436	%f%.Forward(0, %x%, %s%)
437	437	%$$
438		See $cref/zero order forward mode/ForwardZero/$$ and $cref PrintFor$$.
	438	See $cref/zero order forward mode/forward_zero/$$ and $cref PrintFor$$.
439	439	$lnext
440	440	Improve $cref omp_alloc.cpp$$ example.
441	441	$lend

-8

omh/whats_new/whats_new_12.omh less more

0		$Id: whats_new_12.omh 2958 2013-10-17 13:33:48Z bradbell $
	0	$Id: whats_new_12.omh 3214 2014-03-18 20:50:38Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

134	134	instructions.
135	135	$lnext
136	136	Include the $cref Introduction$$ programs in the
137		$cref cppad_test$$ built using $cref cmake$$.
	137	$cref cmake_check$$ built using $cref cmake$$.
138	138	$lnext
139	139	Deprecate $cref cppad_ipopt_nlp$$ and replace it by $cref ipopt_solve$$
140	140	which is easier to use.

626	626	$cref/p == 0/ode_evaluate/p/p == 0/$$ in its documentation.
627	627	$lnext
628	628	Use same argument for taping and derivative evaluation when
629		$cref/retape/speed_main/option_list/retape/$$ is true.
	629	$code retape$$ speed test option is true.
630	630	$lnext
631	631	Implement the $icode%retape% == false%$$ option
632	632	in $cref cppad_ode.cpp$$.

650	650	to use
651	651	the $icode row$$, $icode col$$ interface to $cref sparse_hessian$$.
652	652	In addition, implement the speed test
653		$cref/retape/speed_main/option_list/retape/$$ option for these tests.
	653	$code retape$$ speed test option for these tests.
654	654
655	655	$head 05-31$$
656		Add the $cref cppad_print_optimize$$ routine to so that the corresponding
	656	Add the $code cppad_print_optimize$$ routine to so that the corresponding
657	657	code does not need to be reproduced for all the
658	658	$cref speed_cppad$$ tests.
659	659	In addition, during CppAD speed tests,

664	664	$cref link_sparse_hessian$$ so that the row and column indices are
665	665	inputs (instead of being chosen randomly by the test for each repetition).
666	666	This enables use of the
667		$cref/retape/speed_main/option_list/retape/$$ option
	667	$code retape$$ speed test option
668	668	during sparse Hessian speed tests.
669	669
670	670	$head 05-29$$

791	791	$head 03-26$$
792	792	Calling $code taylor_capacity$$, with to with capacity equal to zero,
793	793	was not
794		$cref/freeing memory/capacity_taylor/c/Freeing Memory/$$.
	794	$cref/freeing memory/capacity_order/c/Freeing Memory/$$.
795	795	This has been fixed.
796	796
797	797	$head 03-23$$

-4

omh/whats_new/whats_new_13.omh less more

0		$Id: whats_new_13.omh 3073 2014-01-01 11:48:13Z bradbell $
	0	$Id: whats_new_13.omh 3214 2014-03-18 20:50:38Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

303	303	$lnext
304	304	Check $cref/reverse/reverse_any/$$ mode results when
305	305	$cref check_for_nan$$ is true.
306		(It used to be the case that only $cref/forward/ForwardAny/$$ results
	306	(It used to be the case that only $cref/forward/forward_order/$$ results
307	307	were checked for $code nan$$.)
308	308	$lend
309	309

383	383
384	384	$head 05-04$$
385	385	The option to compute
386		$cref/multiple orders/ForwardAny/x_p/Multiple Orders/$$ was added.
	386	$cref/multiple orders/forward_order/xq/Multiple Orders/$$ was added.
387	387	The $cref old_usead_2.cpp$$ example shows the need for this.
388	388	The problem is that a new atomic function interface needs to be designed
389	389	with checkpointing as a particular application.

+432

-0

omh/whats_new/whats_new_14.omh less more

	0	$Id: whats_new_14.omh 3507 2014-12-27 16:30:12Z bradbell $
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	$begin whats_new_14$$
	13	$dollar @$$
	14	$spell
	15	cstdint
	16	addr
	17	omhelp
	18	autoconf
	19	automake
	20	alloc
	21	ifndef
	22	asin
	23	acos
	24	uj
	25	op
	26	hpp
	27	taylor
	28	forwardzero
	29	forwardone
	30	forwardany
	31	const
	32	doxygen
	33	ipopt
	34	adolc
	35	colpack
	36	Jacobian
	37	openmp
	38	pthread
	39	bthread
	40	isnan
	41	onetape
	42	retape
	43	fadbad
	44	sacado
	45	boolsparsity
	46	cmake
	47	docdir
	48	CppAD
	49	cppad
	50	datadir
	51	erf
	52	cmath
	53	$$
	54
	55	$section CppAD Changes and Additions During 2014$$
	56
	57	$head Introduction$$
	58	This section contains a list of the changes to CppAD during 2014
	59	(in reverse order by date).
	60	The purpose of this section is to
	61	assist you in learning about changes between various versions of CppAD.
	62
	63	$head 12-27$$
	64	More work on the bug in
	65	$cref/optimizing/CondExp/Optimize/$$
	66	conditional expressions.
	67
	68	$head 12-26$$
	69	A minimal example for computing cross terms in atomic operation
	70	Hessian sparsity patterns $cref atomic_hes_sparse.cpp$$ was added.
	71
	72	$head 12-25$$
	73	More work on the bug in
	74	$cref/optimizing/CondExp/Optimize/$$
	75	conditional expressions.
	76
	77	$head 12-23$$
	78	The c++11 standard includes the error function $cref erf$$ in
	79	$code cmath$$.
	80	If the c++ compiler has the error function defined in $code cmath$$,
	81	the complier version of the error function is used and it corresponds to an
	82	atomic operation.
	83	$pre
	84
	85	$$
	86	Fix typo in tangent reverse mode theory for
	87	$cref/Positive Orders/tan_reverse/Positive Orders Z(t)/$$.
	88
	89	$head 12-22$$
	90	There was a bug related to
	91	$cref/optimizing/CondExp/Optimize/$$
	92	conditional expressions.
	93	This has been fixed.
	94
	95	$head 12-17$$
	96	Fix some compiler warnings and $cref speed$$ program names
	97	when using the deprecated $cref/auto-tools/InstallUnix/$$ install procedure.
	98
	99	$head 12-16$$
	100	If the $code c++11$$ include file $code <cstdint>$$
	101	defines all the standard types, they can be used by to specify
	102	$cref/cppad_tape_addr_type/cmake/cppad_tape_addr_type/cstdint/$$ and
	103	$cref/cppad_tape_id_type/cmake/cppad_tape_id_type/cstdint/$$.
	104
	105	$head 12-15$$
	106	Correct the title and $cref _index$$ entries for $cref forward_two$$
	107	from first to second order.
	108
	109	$head 11-28$$
	110	Improve the $cref/index/_index/$$ and $code search$$ using
	111	a new version of the $code omhelp$$ documentation tool.
	112
	113	$head 11-27$$
	114	$list number$$
	115	Add alignment to the
	116	$cref/get_memory/ta_get_memory/Alignment/$$ and
	117	$cref/create_array/ta_create_array/Alignment/$$ specifications
	118	and
	119	$cref/thread_alloc example/thread_alloc.cpp/$$.
	120	$lnext
	121	Advance the deprecated $cref/unix install/InstallUnix/$$ utilities to
	122	autoconf-2.69 and automake-1.13.4.
	123	$lend
	124
	125	$head 09-28$$
	126	Fix more bugs related to optimizing condition conditional expressions.
	127	$list number$$
	128	Using old instead of new operator indices.
	129	$lnext
	130	Not properly following dependence back through atomic operations.
	131	$lnext
	132	Aborting during forward order zero, when skipping computation for a variable
	133	that was already completed (the skip is still useful for higher orders
	134	and for reverse mode).
	135	$lnext
	136	Reverse mode not properly handling the variable number of arguments in the
	137	conditional skip operation.
	138	$lnext
	139	Reverse mode tracing not properly handling the variable number
	140	of argument operations; i.e., conditional skip and cumulative summation.
	141	$lend
	142
	143	$head 09-27$$
	144	Fix a bug that occurred when
	145	$cref/f.optimize/optimize/$$ was used with a function $icode f$$
	146	that contained calls to user defined $cref atomic$$ operations
	147	and $cref/conditional expressions/CondExp/$$.
	148
	149	$head 09-25$$
	150	Fix a bug that occurred when
	151	$cref/f.optimize/optimize/$$ was used with a function $icode f$$
	152	that contained $cref discrete$$ functions.
	153
	154	$head 09-21$$
	155	Fix a typo in documentation for
	156	$cref/any order reverse/reverse_any/$$.
	157	To be specific, $latex x^{(k)}$$ was changed to be $latex u^{(k)}$$.
	158
	159	$head 05-28$$
	160	$list number$$
	161	Change the $cref/boolsparsity/speed_main/Sparsity Options/boolsparsity/$$
	162	so that it only affects the sparsity speed tests
	163	$cref/sparse_jacobian/link_sparse_jacobian/$$ and
	164	$cref/sparse_hessian/link_sparse_hessian/$$;
	165	i.e., it is now ignored by the other tests.
	166	$lnext
	167	Improve the $cref speed$$ documentation page.
	168	$lend
	169
	170	$head 05-27$$
	171	$list number$$
	172	The $cref/cppad_colpack.cpp/colpack_prefix/cppad_colpack.cpp/$$
	173	file was not being copied to the specified directory.
	174	In addition, the specified directory was changed from an include
	175	directory to data directory
	176	($code cppad_colpack.cpp$$ is not an include file).
	177	$lnext
	178	If $cref colpack_prefix$$ was specified, the CppAD
	179	$cref pkgconfig$$ file was missing some information.
	180	This has been fixed.
	181	$lend
	182
	183	$head 05-23$$
	184	The $cref speed$$ test instructions were converted from using
	185	the old auto-tools $cref/unix install/InstallUnix/$$ instructions
	186	to use the $cref cmake$$ install instructions.
	187	These instructions should work on any system, not just unix.
	188
	189	$head 05-22$$
	190	$list number$$
	191	Add multiple direction for mode
	192	$cref forward_dir$$ and use it to speed up the forward
	193	version of $cref sparse_jacobian$$.
	194	Below is an example run of $cref cppad_sparse_jacobian.cpp$$ results
	195	before this change:
	196	$codep
	197	cppad_sparse_jacobian_size = [ 100, 400, 900, 1600, 2500 ]
	198	cppad_sparse_jacobian_rate = [ 2973, 431.94, 142.25, 78.64, 26.87 ]
	199	$$
	200	and after this change:
	201	$codep
	202	cppad_sparse_jacobian_size = [ 100, 400, 900, 1600, 2500 ]
	203	cppad_sparse_jacobian_rate = [ 6389, 954.26, 314.04, 180.06, 56.95 ]
	204	$$
	205	Due to the success of this change, other
	206	$cref/multiple direction/WishList/Multiple Directions/$$ items
	207	were added to the wish list.
	208	$lnext
	209	Improve the forward mode tracing of arguments to,
	210	and results from, user defined $cref atomic$$ operations.
	211	$lend
	212
	213	$head 05-20$$
	214	$list number$$
	215	Move $code speed/adolc/alloc_mat.hpp$$ to
	216	$code speed/adolc/adolc_alloc_mat.hpp$$ so it has the
	217	same name is its $code # ifndef$$ command.
	218	$lnext
	219	Fix $code # ifndef$$ command in
	220	$code cppad/ipopt/solve_callback.hpp$$.
	221	$lnext
	222	Add $code # ifndef$$ command to $code test_more/extern_value.hpp$$.
	223	$lend
	224
	225
	226	$head 05-19$$
	227	In the files
	228	$code cppad/local/asin_op.hpp$$ and $code cppad/local/acos_op.hpp$$
	229	there were assignments of the form $code uj = 0.$$ where $code u_j$$
	230	has type $cref/Base/glossary/Base Type/$$.
	231	These may have not be defined operations in certain cases and
	232	have been converted to $code uj = Base(0)$$.
	233
	234
	235	$head 05-16$$
	236	There was a mistake in printing the arguments for
	237	$code CSumOp$$ and $code CSkipOp$$ when using the undocumented
	238	$code TRACE$$ option during forward mode (available in files of the form
	239	$codei%cppad/local/%*%sweep.hpp/%$$).
	240	This has been fixed.
	241
	242	$head 05-14$$
	243	$list number$$
	244	There were some global variables in the file
	245	$code cppad/local/op_code.hpp$$ that might have caused multiple definitions
	246	during link time for CppAD applications.
	247	These variables have been changed to be local so that this cannot happen.
	248	$lnext
	249	There was a mistaken assert that the number of arguments for the
	250	$code BeginOp$$ was zero that caused an abort when using the undocumented
	251	$code TRACE$$ option available in files of the form
	252	$codei%cppad/local/%*%sweep.hpp/%$$.
	253	This has been fixed.
	254	$lend
	255
	256	$head 03-18$$
	257	$list number$$
	258	The
	259	$cref/size_taylor/FunDeprecated/size_taylor/$$
	260	and
	261	$cref/capacity_taylor/FunDeprecated/capacity_taylor/$$
	262	functions were deprecated;
	263	use $cref size_order$$ and $cref capacity_order$$ instead.
	264	$lnext
	265	The documentation for $cref forward$$ and the examples
	266	$cref forward.cpp$$, $cref forward_order.cpp$$, have been improved.
	267	To be more specific, $cref forward_order$$ now references the special
	268	cases $cref forward_zero$$, $cref forward_one$$ and the new case
	269	$cref forward_two$$.
	270	$lend
	271
	272	$head 03-17$$
	273	The
	274	$cref/move semantics/CppAD_vector/Assignment/Move Semantics/$$
	275	version of the $code CppAD::vector$$ assignment statement
	276	was not checking vector sizes.
	277	This has been fixed so that things work the same with compilers
	278	that do not have move semantics.
	279	(Note that with move semantics, no extra memory allocation is done
	280	even if the target vector has a different size.)
	281
	282	$head 03-09$$
	283	The documentation links
	284	$code forwardzero$$, $code forwardone$$, and $code forwardany$$
	285	have been changed to
	286	$cref forward_zero$$, $cref forward_one$$,
	287	and $cref forward_order$$ respectively.
	288	This may affect links from other web pages to the CppAD documentation.
	289
	290	$head 03-05$$
	291	The names $icode p$$ and $icode q$$ in the
	292	$cref/forward/forward_order/$$,
	293	$cref/reverse/reverse_any/$$,
	294	$cref atomic_forward$$, and
	295	$cref atomic_reverse$$ functions
	296	were reverse so that $icode%p% <= %q%$$.
	297	This is only a notational change to make the arguments easier to remember.
	298
	299	$head 03-02$$
	300	$list number$$
	301	In the output for the speed
	302	$cref/correct/speed_main/test/correct/$$ test,
	303	mention which tests are not available.
	304	Note that the set of available tests can depend on the
	305	$cref/list of options/speed_main/option_list/$$.
	306	$lnext
	307	In the documentation for
	308	$cref/n_sweep/sparse_jacobian/n_sweep/$$,
	309	mention that it is equal to the number of colors determined by the
	310	$cref/color_method/sparse_jacobian/work/color_method/$$.
	311	$lnext
	312	The $cref speed_cppad$$ tests were simplified by removing the printing
	313	of auxillary information related to the
	314	$cref/optimize/speed_main/option_list/optimize/$$ option.
	315	Future auxillary information will be passed back in a manner similar to
	316	$cref/n_sweep/link_sparse_jacobian/n_sweep/$$ for the sparse jacobian test.
	317	$lnext
	318	$cref/Move semantics/CppAD_vector/Assignment/Move Semantics/$$
	319	were added to the $code CppAD::vector$$ assignment operator.
	320	$lend
	321
	322	$head 03-01$$
	323	$list number$$
	324	Change the prototype for $icode row$$ and $icode col$$ in the
	325	$cref link_sparse_jacobian$$ speed test to be $code const$$; i.e.,
	326	they are not changed.
	327	$lnext
	328	Move $icode x$$ near end of $cref link_sparse_hessian$$ speed test
	329	parameter list,
	330	(as is the case for $cref link_sparse_jacobian$$).
	331	$lend
	332
	333	$head 02-28$$
	334	The $cref/data/CppAD_vector/data/$$ function was added to the
	335	$code CppAD::vector$$ template class.
	336
	337	$head 02-27$$
	338	The CppAD developer documentation for the subdirectory
	339	$code cppad/ipopt$$ was not being built by the command
	340	$code bin/run_doxygen.sh$$.
	341	This has been fixed.
	342
	343	$head 02-26$$
	344	$list number$$
	345	The
	346	$cref/adolc/speed_adolc/$$ and
	347	$cref/cppad/speed_cppad/$$ sparse jacobian speed tests now print out
	348	$cref/n_sweep/sparse_jacobian/n_sweep/$$.
	349	$lnext
	350	The size of some of the $cref speed$$ test cases has been increased
	351	to test behavior for larger problems.
	352	$lnext
	353	A link to $cref ode_evaluate$$ was missing in the
	354	$cref/Speed Utility Routines/speed_utility/Speed Utility Routines/$$ table.
	355	This has been fixed.
	356	$lend
	357
	358
	359	$head 02-23$$
	360	The $cref/color_method/sparse_jacobian/work/color_method/$$
	361	option was added to the sparse Jacobian calculations.
	362	This enables one to use $cref/ColPack/colpack_prefix/$$
	363	do color the rows or columns.
	364	The speed test $cref/colpack/speed_main/Sparsity Options/colpack/$$ option
	365	was also added (but not yet implemented for
	366	$cref/sparse_hessian/link_sparse_hessian/$$ speed tests).
	367
	368
	369	$head 02-22$$
	370	The program names in
	371	$cref thread_test.cpp$$ where changes from
	372	$icode%threading%_test%$$ to $codei%multi_thread_%threading%$$
	373	where $icode threading$$ is $code openmp$$, $code pthread$$ or $code bthread$$.
	374
	375	$head 02-17$$
	376	Fix ambiguous call to $cref/isnan/nan/isnan/$$
	377	during MS Visual Studio 2012 compilation.
	378
	379	$head 02-15$$
	380	$list number$$
	381	The $cref/boolsparsity/speed_main/Sparsity Options/boolsparsity/$$ option
	382	was added to the $cref speed_main$$ program.
	383	$lnext
	384	The $code retape$$ option what changed to
	385	$cref/onetape/speed_main/option_list/onetape/$$ so that the default
	386	is to retape (option not present).
	387	This was done because
	388	$cref/fadbad/fadbad_prefix/$$ and
	389	$cref/sacado/sacado_prefix/$$ always retape.
	390	$lnext
	391	The documentation, and example source code, for all the speed
	392	$cref/options/speed_main/option_list/$$ was improved
	393	(made clearer).
	394	$lnext
	395	Improve the success rate for
	396	$cref speed_test.cpp$$ and $cref time_test.cpp$$.
	397	$lend
	398
	399	$head 01-26$$
	400	The destination directory for the
	401	$cref/cppad documentation/cmake/cmake_install_docdir/$$
	402	is now set separately from the data directory
	403	using the $code cmake$$ option
	404	$codei%
	405	-D cmake_install_docdir=%cmake_install_docdir%
	406	%$$
	407	This has increased the flexibility of the documentation installation
	408	and removed the need for the option
	409	$codei%
	410	-D cppad_documentation=%yes_or_no%
	411	%$$
	412	which has been removed.
	413
	414	$head 01-21$$
	415	The destination directory for the
	416	cppad documentation
	417	used to be one of the following:
	418	$codei%
	419	%prefix%/%datadir%/doc/cppad-%version%
	420	%prefix%/%datadir%/doc/%postfix%cppad-%version%
	421	%$$
	422	This has been changed by dropping the $icode version$$ number
	423	at the end of the directory name.
	424
	425	$head 01-10$$
	426	The change on $cref/2013-12-27/whats_new_13/12-27/$$
	427	caused a conversion error in $cref atan2$$ when it was used with
	428	$code AD< AD<double> >$$ arguments (and other similar cases).
	429	This has been fixed.
	430
	431	$end

+17

-10

omh/wish_list.omh less more

0		$Id: wish_list.omh 3019 2013-12-04 11:24:06Z bradbell $
	0	$Id: wish_list.omh 3301 2014-05-24 05:20:21Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

108	108
109	109	$head Forward Mode Recomputation$$
110	110	$index forward$$
111		If the results of $cref ForwardAny$$ have already been computed and are still
112		stored in the $cref ADFun$$ object (see $cref size_taylor$$),
	111	If the results of $cref forward_order$$ have already been computed and are still
	112	stored in the $cref ADFun$$ object (see $cref size_order$$),
113	113	then they do not need to be recomputed and the results can just be returned.
114	114
115	115	$head Iterator Interface$$

133	133	This would speed up compilation for the most common usage where
134	134	the $icode Base$$ type is $code double$$.
135	135
136		$head Multiple Argument Forward$$
	136	$head Multiple Directions$$
137	137	$index speed, forward$$
138	138	$index forward, speed$$
139		It has been suggested that computing and storing forward mode
140		results for multiple argument values
141		is faster for Adolc.
142		Perhaps CppAD should allow for forward mode at
143		multiple argument values.
	139	$list number$$
	140	Extend the $cref forward_dir$$ routine so they can do multiple orders
	141	as well as multiple directions at the same time.
	142	$lnext
	143	Extend the $cref atomic$$ functions so they can use multiple directions
	144	and multiple orders at the same time
	145	(currently they compute one direction and one order at a time).
	146	$lnext
	147	Extend the $cref Reverse$$ routines so they can handle one reverse direction
	148	for multiple forward directions, or multiple reverse directions for
	149	one forward direction.
	150	$lend
144	151
145	152	$head Numeric Limits$$
146	153	$index testing, machine epsilon$$

+20

-2

pkgconfig/CMakeLists.txt less more

0		#CppAD $Id: CMakeLists.txt 2606 2012-12-15 14:08:30Z bradbell $
	0	# $Id: CMakeLists.txt 3491 2014-12-21 13:15:12Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

23	23	ENDIF(IS_DIRECTORY ${ipopt_prefix}/${dir} )
24	24	ENDFOREACH(dir)
25	25	ENDIF( ipopt_prefix )
	26	#
	27	IF( colpack_prefix )
	28	# Cannot use requires because colpack does not have a pkgconfig file.
	29	# SET(cppad_requires "colpack")
	30	SET(cppad_libs "${cppad_libs} -lColPack")
	31	FOREACH(dir ${cmake_install_libdirs})
	32	IF(IS_DIRECTORY ${colpack_prefix}/${dir} )
	33	SET(cppad_cflags "${cppad_cflags} -L${colpack_prefix}/${dir}" )
	34	ENDIF(IS_DIRECTORY ${colpack_prefix}/${dir} )
	35	ENDFOREACH(dir)
	36	FOREACH(dir ${cmake_install_includedirs})
	37	SET(check_dir ${colpack_prefix}/${dir} )
	38	IF(IS_DIRECTORY ${check_dir} )
	39	SET(cppad_cflags "${cppad_cflags} -I${check_dir}" )
	40	ENDIF(IS_DIRECTORY ${check_dir} )
	41	ENDFOREACH(dir)
	42	ENDIF( colpack_prefix )
	43	#
26	44	MESSAGE(STATUS "cppad_cflags = ${cppad_cflags}")
27	45	MESSAGE(STATUS "cppad_libs = ${cppad_libs}")
28	46	MESSAGE(STATUS "cppad_requires = ${cppad_requires}")

+144

-73

print_for/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
	77	build_triplet = @build@
	78	host_triplet = @host@
50	79	check_PROGRAMS = print_for$(EXEEXT)
51	80	subdir = print_for
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

60	90	am_print_for_OBJECTS = print_for.$(OBJEXT)
61	91	print_for_OBJECTS = $(am_print_for_OBJECTS)
62	92	print_for_LDADD = $(LDADD)
	93	AM_V_P = $(am__v_P_@AM_V@)
	94	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	95	am__v_P_0 = false
	96	am__v_P_1 = :
	97	AM_V_GEN = $(am__v_GEN_@AM_V@)
	98	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	99	am__v_GEN_0 = @echo " GEN " $@;
	100	am__v_GEN_1 =
	101	AM_V_at = $(am__v_at_@AM_V@)
	102	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	103	am__v_at_0 = @
	104	am__v_at_1 =
63	105	DEFAULT_INCLUDES =
64	106	depcomp = $(SHELL) $(top_srcdir)/depcomp
65	107	am__depfiles_maybe = depfiles

68	110	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
69	111	AM_V_CXX = $(am__v_CXX_@AM_V@)
70	112	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
71		am__v_CXX_0 = @echo " CXX " $@;
72		AM_V_at = $(am__v_at_@AM_V@)
73		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
74		am__v_at_0 = @
	113	am__v_CXX_0 = @echo " CXX " $@;
	114	am__v_CXX_1 =
75	115	CXXLD = $(CXX)
76	116	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
77	117	-o $@
78	118	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
79	119	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
80		am__v_CXXLD_0 = @echo " CXXLD " $@;
81		AM_V_GEN = $(am__v_GEN_@AM_V@)
82		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
83		am__v_GEN_0 = @echo " GEN " $@;
	120	am__v_CXXLD_0 = @echo " CXXLD " $@;
	121	am__v_CXXLD_1 =
84	122	SOURCES = $(print_for_SOURCES)
85	123	DIST_SOURCES = $(print_for_SOURCES)
86	124	am__can_run_installinfo = \

88	126	n\|no\|NO) false;; \
89	127	*) (install-info --version) >/dev/null 2>&1;; \
90	128	esac
	129	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	130	# Read a list of newline-separated strings from the standard input,
	131	# and print each of them once, without duplicates. Input order is
	132	# not preserved.
	133	am__uniquify_input = $(AWK) '\
	134	BEGIN { nonempty = 0; } \
	135	{ items[$$0] = 1; nonempty = 1; } \
	136	END { if (nonempty) { for (i in items) print i; }; } \
	137	'
	138	# Make sure the list of sources is unique. This is necessary because,
	139	# e.g., the same source file might be shared among _SOURCES variables
	140	# for different programs/libraries.
	141	am__define_uniq_tagged_files = \
	142	list='$(am__tagged_files)'; \
	143	unique=`for i in $$list; do \
	144	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	145	done \| $(am__uniquify_input)`
91	146	ETAGS = etags
92	147	CTAGS = ctags
93	148	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

97	152	ADOLC_DIR = @ADOLC_DIR@
98	153	AMTAR = @AMTAR@
99	154	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	155	AR = @AR@
100	156	AUTOCONF = @AUTOCONF@
101	157	AUTOHEADER = @AUTOHEADER@
102	158	AUTOMAKE = @AUTOMAKE@

119	175	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
120	176	CYGPATH_W = @CYGPATH_W@
121	177
122		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	178	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
123	179	# -----------------------------------------------------------------------------
124	180	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
125	181	#

186	242	abs_srcdir = @abs_srcdir@
187	243	abs_top_builddir = @abs_top_builddir@
188	244	abs_top_srcdir = @abs_top_srcdir@
	245	ac_ct_AR = @ac_ct_AR@
189	246	ac_ct_CC = @ac_ct_CC@
190	247	ac_ct_CXX = @ac_ct_CXX@
191	248	ac_ct_FC = @ac_ct_FC@

196	253	am__tar = @am__tar@
197	254	am__untar = @am__untar@
198	255	bindir = @bindir@
	256	build = @build@
199	257	build_alias = @build_alias@
	258	build_cpu = @build_cpu@
	259	build_os = @build_os@
	260	build_vendor = @build_vendor@
200	261	builddir = @builddir@
201	262	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
202	263	cppad_boostvector = @cppad_boostvector@
203	264	cppad_cflags = @cppad_cflags@
	265	cppad_compiler_has_erf = @cppad_compiler_has_erf@
204	266	cppad_cppadvector = @cppad_cppadvector@
205	267	cppad_description = @cppad_description@
206	268	cppad_eigenvector = @cppad_eigenvector@
	269	cppad_has_colpack = @cppad_has_colpack@
	270	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
207	271	cppad_has_gettimeofday = @cppad_has_gettimeofday@
208	272	cppad_has_nullptr = @cppad_has_nullptr@
	273	cppad_has_rvalue = @cppad_has_rvalue@
209	274	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
210	275	cppad_internal_sparse_set = @cppad_internal_sparse_set@
211	276	cppad_libs = @cppad_libs@
212	277	cppad_max_num_threads = @cppad_max_num_threads@
213	278	cppad_requires = @cppad_requires@
214		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	279	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
215	280	cppad_stdvector = @cppad_stdvector@
216	281	cppad_tape_addr_type = @cppad_tape_addr_type@
217	282	cppad_tape_id_type = @cppad_tape_id_type@

223	288	dvidir = @dvidir@
224	289	eigen_prefix = @eigen_prefix@
225	290	exec_prefix = @exec_prefix@
226		have_ar = @have_ar@
227	291	have_pkg_config = @have_pkg_config@
	292	host = @host@
228	293	host_alias = @host_alias@
	294	host_cpu = @host_cpu@
	295	host_os = @host_os@
	296	host_vendor = @host_vendor@
229	297	htmldir = @htmldir@
230	298	includedir = @includedir@
231	299	infodir = @infodir@

304	372
305	373	clean-checkPROGRAMS:
306	374	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	375
307	376	print_for$(EXEEXT): $(print_for_OBJECTS) $(print_for_DEPENDENCIES) $(EXTRA_print_for_DEPENDENCIES)
308	377	@rm -f print_for$(EXEEXT)
309	378	$(AM_V_CXXLD)$(CXXLINK) $(print_for_OBJECTS) $(print_for_LDADD) $(LIBS)

317	386	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print_for.Po@am__quote@
318	387
319	388	.cpp.o:
320		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
321		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	389	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	390	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	391	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
322	392	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
323	393	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
324	394	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
325	395
326	396	.cpp.obj:
327		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
328		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	397	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	398	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	399	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
329	400	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
330	401	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
331	402	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
332	403
333		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
334		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
335		unique=`for i in $$list; do \
336		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
337		done \| \
338		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
339		END { if (nonempty) { for (i in files) print i; }; }'`; \
340		mkid -fID $$unique
341		tags: TAGS
342
343		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
344		$(TAGS_FILES) $(LISP)
	404	ID: $(am__tagged_files)
	405	$(am__define_uniq_tagged_files); mkid -fID $$unique
	406	tags: tags-am
	407	TAGS: tags
	408
	409	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
345	410	set x; \
346	411	here=`pwd`; \
347		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
348		unique=`for i in $$list; do \
349		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
350		done \| \
351		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
352		END { if (nonempty) { for (i in files) print i; }; }'`; \
	412	$(am__define_uniq_tagged_files); \
353	413	shift; \
354	414	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
355	415	test -n "$$unique" \|\| unique=$$empty_fix; \

361	421	$$unique; \
362	422	fi; \
363	423	fi
364		ctags: CTAGS
365		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
366		$(TAGS_FILES) $(LISP)
367		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
368		unique=`for i in $$list; do \
369		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
370		done \| \
371		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
372		END { if (nonempty) { for (i in files) print i; }; }'`; \
	424	ctags: ctags-am
	425
	426	CTAGS: ctags
	427	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	428	$(am__define_uniq_tagged_files); \
373	429	test -z "$(CTAGS_ARGS)$$unique" \
374	430	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
375	431	$$unique

378	434	here=`$(am__cd) $(top_builddir) && pwd` \
379	435	&& $(am__cd) $(top_srcdir) \
380	436	&& gtags -i $(GTAGS_ARGS) "$$here"
	437	cscopelist: cscopelist-am
	438
	439	cscopelist-am: $(am__tagged_files)
	440	list='$(am__tagged_files)'; \
	441	case "$(srcdir)" in \
	442	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	443	*) sdir=$(subdir)/$(srcdir) ;; \
	444	esac; \
	445	for i in $$list; do \
	446	if test -f "$$i"; then \
	447	echo "$(subdir)/$$i"; \
	448	else \
	449	echo "$$sdir/$$i"; \
	450	fi; \
	451	done >> $(top_builddir)/cscope.files
381	452
382	453	distclean-tags:
383	454	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

518	589
519	590	.MAKE: check-am install-am install-strip
520	591
521		.PHONY: CTAGS GTAGS all all-am check check-am clean \
522		clean-checkPROGRAMS clean-generic ctags distclean \
523		distclean-compile distclean-generic distclean-tags distdir dvi \
524		dvi-am html html-am info info-am install install-am \
525		install-data install-data-am install-dvi install-dvi-am \
526		install-exec install-exec-am install-html install-html-am \
527		install-info install-info-am install-man install-pdf \
528		install-pdf-am install-ps install-ps-am install-strip \
529		installcheck installcheck-am installdirs maintainer-clean \
530		maintainer-clean-generic mostlyclean mostlyclean-compile \
531		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
532		uninstall-am
	592	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	593	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	594	distclean distclean-compile distclean-generic distclean-tags \
	595	distdir dvi dvi-am html html-am info info-am install \
	596	install-am install-data install-data-am install-dvi \
	597	install-dvi-am install-exec install-exec-am install-html \
	598	install-html-am install-info install-info-am install-man \
	599	install-pdf install-pdf-am install-ps install-ps-am \
	600	install-strip installcheck installcheck-am installdirs \
	601	maintainer-clean maintainer-clean-generic mostlyclean \
	602	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	603	tags tags-am uninstall uninstall-am
533	604
534	605
535	606	test: check

-3

print_for/print_for.cpp less more

0		/* $Id: print_for.cpp 2683 2012-12-30 18:17:03Z bradbell $ */
	0	/* $Id: print_for.cpp 3114 2014-02-22 16:20:39Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

37	37	$index print, example forward mode$$
38	38
39	39	$head Running$$
40		To build this program and run its correctness test see $cref cppad_test$$.
	40	To build this program and run its correctness test see $cref cmake_check$$.
41	41
42	42	$head Source Code$$
43	43	$codep */

+23

-11

speed/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2565 2012-11-12 23:16:00Z bradbell $
	0	# $Id: CMakeLists.txt 3301 2014-05-24 05:20:21Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

11	11	# Build the speed/* directory tests
12	12	# Inherit environment from ../CMakeList.txt
13	13
	14	# CppAD developers use MinSizeRel for profiling the speed tests
	15	SET(CMAKE_CXX_FLAGS_MINSIZEREL "-O0 -DNDEBUG")
	16	SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
	17
	18	# Specify build type for this directory and all its subdirectories.
	19	# Possible values are DEBUG, RELEASE, RelWithDebInfo and MinSizeRel
	20	SET(CMAKE_BUILD_TYPE RELEASE)
	21
	22	# colpack_prefix
	23	SET(sources ../../cppad/local/cppad_colpack.cpp)
	24	sources_libs_define(colpack "${sources}" ColPack COLPACK_SPEED)
	25
14	26	# Initialize list of tests as empty
15		SET(list_speed "")
	27	SET(check_depends "")
16	28
17	29	# The CMakeLists.txt file in the specified source directory is processed
18	30	# before the current input file continues beyond this command.

20	32	ADD_SUBDIRECTORY(src)
21	33	#
22	34	ADD_SUBDIRECTORY(cppad)
23		add_to_list(list_speed check_speed_cppad)
	35	add_to_list(check_depends check_speed_cppad)
24	36	#
25	37	ADD_SUBDIRECTORY(double)
26		add_to_list(list_speed check_speed_double)
	38	add_to_list(check_depends check_speed_double)
27	39	#
28	40	ADD_SUBDIRECTORY(example)
29		add_to_list(list_speed check_speed_example)
	41	add_to_list(check_depends check_speed_example)
30	42	#
31	43	ADD_SUBDIRECTORY(profile)
32		add_to_list(list_speed check_speed_profile)
	44	add_to_list(check_depends check_speed_profile)
33	45	#
34	46	IF ( adolc_prefix )
35	47	ADD_SUBDIRECTORY(adolc)
36		add_to_list(list_speed check_speed_adolc)
	48	add_to_list(check_depends check_speed_adolc)
37	49	ENDIF( adolc_prefix )
38	50	IF ( fadbad_prefix )
39	51	ADD_SUBDIRECTORY(fadbad)
40		add_to_list(list_speed check_speed_fadbad)
	52	add_to_list(check_depends check_speed_fadbad)
41	53	ENDIF( fadbad_prefix )
42	54	IF ( sacado_prefix )
43	55	ADD_SUBDIRECTORY(sacado)
44		add_to_list(list_speed check_speed_sacado)
	56	add_to_list(check_depends check_speed_sacado)
45	57	ENDIF( sacado_prefix )
46	58
47	59	# check_speed
48		ADD_CUSTOM_TARGET(check_speed DEPENDS ${list_speed} )
	60	ADD_CUSTOM_TARGET(check_speed DEPENDS ${check_depends} )

+10

-10

speed/adolc/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2572 2012-11-15 19:43:06Z bradbell $
	0	# $Id: CMakeLists.txt 3141 2014-03-02 23:24:45Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

10	10	# -----------------------------------------------------------------------------
11	11	# Build the speed/adolc directory tests
12	12	# Inherit environment from ../CMakeList.txt
	13	# CMAKE_BUILD_TYPE determined by parent directory
13	14
14	15	# assert adolc_prefix is defined
15	16	IF ( NOT adolc_prefix )

18	19	)
19	20	ENDIF ( NOT adolc_prefix )
20	21
21		# Specifies build type for this directory. Possible values are
22		# empty, Debug, Release, RelWithDebInfo and MinSizeRel
23		SET(CMAKE_BUILD_TYPE RELEASE)
24	22
25	23	# Adds flags to the compiler command line for sources in the current directory
26	24	# and below. This command can be used to add any flags, but it was originally
27	25	# intended to add preprocessor definitions.
28		ADD_DEFINITIONS("-DSPEED_ADOLC")
	26	ADD_DEFINITIONS("-DCPPAD_ADOLC_SPEED")
29	27
30	28	# Local include directories to search (not in package_prefix/includdir)
31	29	INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/../src )

47	45	add_cppad_cxx_flags( speed_adolc )
48	46
49	47	# List of libraries to be linked into the specified target
50		TARGET_LINK_LIBRARIES(speed_adolc speed_src adolc )
	48	TARGET_LINK_LIBRARIES(speed_adolc speed_src adolc ${colpack_libs} )
51	49
52	50	# Add the check_speed_adolc target
53		ADD_CUSTOM_TARGET(check_speed_adolc
54		speed_adolc correct 54321
55		DEPENDS speed_adolc speed_src
	51	ADD_CUSTOM_TARGET(
	52	check_speed_adolc
	53	speed_adolc correct 54321 colpack
	54	DEPENDS
	55	speed_adolc speed_src
56	56	)

+18

-0

speed/adolc/adolc_alloc_mat.hpp less more

	0	/* $Id: adolc_alloc_mat.hpp 3275 2014-05-20 17:35:11Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	# ifndef CPPAD_ADOLC_ALLOC_MAT_INCLUDED
	12	# define CPPAD_ADOLC_ALLOC_MAT_INCLUDED
	13
	14	double** adolc_alloc_mat(size_t m, size_t n);
	15	void adolc_free_mat(double** mat);
	16
	17	# endif

-3

speed/adolc/adolc_usrparms.sh less more

0	0	#! /bin/bash -e
1		# $Id: adolc_usrparms.sh 2506 2012-10-24 19:36:49Z bradbell $
	1	# $Id: adolc_usrparms.sh 3217 2014-03-19 05:09:01Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

10	10	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11	11	# -----------------------------------------------------------------------------
12	12	#! /bin/bash
13		# $Id: adolc_usrparms.sh 2506 2012-10-24 19:36:49Z bradbell $
14	13	#
15	14	message="
16	15	usage: adolc_usrparms.sh <dir>

-18

~~speed/adolc/alloc_mat.hpp~~ less more

0		/* $Id: alloc_mat.hpp 2506 2012-10-24 19:36:49Z bradbell $ */
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11		# ifndef CPPAD_ADOLC_ALLOC_MAT_INCLUDED
12		# define CPPAD_ADOLC_ALLOC_MAT_INCLUDED
13
14		double** adolc_alloc_mat(size_t m, size_t n);
15		void adolc_free_mat(double** mat);
16
17		# endif

-6

speed/adolc/det_lu.cpp less more

0		/* $Id: det_lu.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_lu.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin adolc_det_lu.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	thread_alloc
16	16	cppad
17	17	fos

49	49	# include <cppad/speed/uniform_01.hpp>
50	50	# include <cppad/track_new_del.hpp>
51	51
	52	// list of possible options
	53	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	54
52	55	bool link_det_lu(
53	56	size_t size ,
54	57	size_t repeat ,

56	59	CppAD::vector<double> &gradient )
57	60	{
58	61	// speed test global option values
59		extern bool global_retape, global_atomic, global_optimize;
60		if( ! global_retape \|\| global_optimize \|\| global_atomic )
	62	if( global_onetape \|\| global_atomic )
61	63	return false;
62
	64	if( global_memory \|\| global_optimize )
	65	return false;
63	66	// -----------------------------------------------------
64	67	// setup
65	68	int tag = 0; // tape identifier

+10

-7

speed/adolc/det_minor.cpp less more

0		/* $Id: det_minor.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_minor.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

12	12	$begin adolc_det_minor.cpp$$
13	13	$spell
14	14	thread_alloc
15		retape
	15	onetape
16	16	cppad
17	17	zos
18	18	fos

48	48	# include <cppad/speed/det_by_minor.hpp>
49	49	# include <cppad/speed/uniform_01.hpp>
50	50
	51	// list of possible options
	52	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	53
51	54	bool link_det_minor(
52	55	size_t size ,
53	56	size_t repeat ,

55	58	CppAD::vector<double> &gradient )
56	59	{
57	60	// speed test global option values
58		extern bool global_retape, global_atomic, global_optimize;
59		if( global_atomic \|\| global_optimize )
	61	if( global_atomic )
60	62	return false;
61
	63	if( global_memory \|\| global_optimize )
	64	return false;
62	65	// -----------------------------------------------------
63	66	// setup
64	67	typedef adouble ADScalar;

94	97	double* grad = thread_alloc::create_array<double>(size_t(n), capacity);
95	98
96	99	// ----------------------------------------------------------------------
97		if( global_retape ) while(repeat--)
	100	if( ! global_onetape ) while(repeat--)
98	101	{ // choose a matrix
99	102	CppAD::uniform_01(n, mat);
100	103

+15

-11

speed/adolc/makefile.am less more

0		# $Id: makefile.am 2940 2013-10-14 16:14:52Z bradbell $
	0	# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

9	9	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10	10	# -----------------------------------------------------------------------------
11	11	#
12		# automake input file
	12	# Copy source file so that main.o does not end up in parent directory
	13	BUILT_SOURCES = main.cpp
	14	main.cpp:
	15	cp $(srcdir)/../main.cpp main.cpp
	16	#
13	17	#
14	18	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
15	19	DEFS =
16	20	#
17		check_PROGRAMS = adolc
	21	check_PROGRAMS = speed_adolc
18	22	#
19	23	AM_CPPFLAGS = \
20	24	-I$(top_srcdir) \

23	27	$(EIGEN_INCLUDE)
24	28	#
25	29	# BEGIN OPTIMIZE
26		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_ADOLC $(CXX_FLAGS)
	30	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_ADOLC_SPEED $(CXX_FLAGS)
27	31	# END OPTIMIZE
28	32	#
29	33	# BEGIN DEBUG
30		# AM_CXXFLAGS = -g $(CXX_FLAGS) -DSPEED_ADOLC
	34	# AM_CXXFLAGS = -g $(CXX_FLAGS) -DCPPAD_ADOLC_SPEED
31	35	# END DEBUG
32	36	#
33	37	LDADD = -lspeed -ladolc -lColPack
34	38	AM_LDFLAGS = -L../src -L$(ADOLC_DIR)/lib -L$(ADOLC_DIR)/lib64
35	39	#
36		adolc_SOURCES = \
37		alloc_mat.hpp \
	40	speed_adolc_SOURCES = \
	41	adolc_alloc_mat.hpp \
38	42	alloc_mat.cpp \
39		../main.cpp \
	43	main.cpp \
40	44	det_lu.cpp \
41	45	det_minor.cpp \
42	46	mat_mul.cpp \

46	50	sparse_jacobian.cpp
47	51
48	52	test: check
49		./adolc correct 123
50		./adolc correct 123 retape
	53	./speed_adolc correct 123 colpack
	54	./speed_adolc correct 123 onetape colpack

+194

-130

speed/adolc/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
50		check_PROGRAMS = adolc$(EXEEXT)
	77	build_triplet = @build@
	78	host_triplet = @host@
	79	check_PROGRAMS = speed_adolc$(EXEEXT)
51	80	subdir = speed/adolc
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

57	87	mkinstalldirs = $(install_sh) -d
58	88	CONFIG_CLEAN_FILES =
59	89	CONFIG_CLEAN_VPATH_FILES =
60		am_adolc_OBJECTS = alloc_mat.$(OBJEXT) main.$(OBJEXT) det_lu.$(OBJEXT) \
61		det_minor.$(OBJEXT) mat_mul.$(OBJEXT) ode.$(OBJEXT) \
62		poly.$(OBJEXT) sparse_hessian.$(OBJEXT) \
	90	am_speed_adolc_OBJECTS = alloc_mat.$(OBJEXT) main.$(OBJEXT) \
	91	det_lu.$(OBJEXT) det_minor.$(OBJEXT) mat_mul.$(OBJEXT) \
	92	ode.$(OBJEXT) poly.$(OBJEXT) sparse_hessian.$(OBJEXT) \
63	93	sparse_jacobian.$(OBJEXT)
64		adolc_OBJECTS = $(am_adolc_OBJECTS)
65		adolc_LDADD = $(LDADD)
66		adolc_DEPENDENCIES =
	94	speed_adolc_OBJECTS = $(am_speed_adolc_OBJECTS)
	95	speed_adolc_LDADD = $(LDADD)
	96	speed_adolc_DEPENDENCIES =
	97	AM_V_P = $(am__v_P_@AM_V@)
	98	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	99	am__v_P_0 = false
	100	am__v_P_1 = :
	101	AM_V_GEN = $(am__v_GEN_@AM_V@)
	102	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	103	am__v_GEN_0 = @echo " GEN " $@;
	104	am__v_GEN_1 =
	105	AM_V_at = $(am__v_at_@AM_V@)
	106	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	107	am__v_at_0 = @
	108	am__v_at_1 =
67	109	DEFAULT_INCLUDES =
68	110	depcomp = $(SHELL) $(top_srcdir)/depcomp
69	111	am__depfiles_maybe = depfiles
70	112	am__mv = mv -f
71		AM_V_lt = $(am__v_lt_@AM_V@)
72		am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
73		am__v_lt_0 = --silent
74	113	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
75	114	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
76	115	AM_V_CXX = $(am__v_CXX_@AM_V@)
77	116	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
78		am__v_CXX_0 = @echo " CXX " $@;
79		AM_V_at = $(am__v_at_@AM_V@)
80		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
81		am__v_at_0 = @
	117	am__v_CXX_0 = @echo " CXX " $@;
	118	am__v_CXX_1 =
82	119	CXXLD = $(CXX)
83	120	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
84	121	-o $@
85	122	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
86	123	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
87		am__v_CXXLD_0 = @echo " CXXLD " $@;
	124	am__v_CXXLD_0 = @echo " CXXLD " $@;
	125	am__v_CXXLD_1 =
88	126	COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
89	127	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
90	128	AM_V_CC = $(am__v_CC_@AM_V@)
91	129	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
92		am__v_CC_0 = @echo " CC " $@;
	130	am__v_CC_0 = @echo " CC " $@;
	131	am__v_CC_1 =
93	132	CCLD = $(CC)
94	133	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
95	134	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
96	135	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
97		am__v_CCLD_0 = @echo " CCLD " $@;
98		AM_V_GEN = $(am__v_GEN_@AM_V@)
99		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
100		am__v_GEN_0 = @echo " GEN " $@;
101		SOURCES = $(adolc_SOURCES)
102		DIST_SOURCES = $(adolc_SOURCES)
	136	am__v_CCLD_0 = @echo " CCLD " $@;
	137	am__v_CCLD_1 =
	138	SOURCES = $(speed_adolc_SOURCES)
	139	DIST_SOURCES = $(speed_adolc_SOURCES)
103	140	am__can_run_installinfo = \
104	141	case $$AM_UPDATE_INFO_DIR in \
105	142	n\|no\|NO) false;; \
106	143	*) (install-info --version) >/dev/null 2>&1;; \
107	144	esac
	145	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	146	# Read a list of newline-separated strings from the standard input,
	147	# and print each of them once, without duplicates. Input order is
	148	# not preserved.
	149	am__uniquify_input = $(AWK) '\
	150	BEGIN { nonempty = 0; } \
	151	{ items[$$0] = 1; nonempty = 1; } \
	152	END { if (nonempty) { for (i in items) print i; }; } \
	153	'
	154	# Make sure the list of sources is unique. This is necessary because,
	155	# e.g., the same source file might be shared among _SOURCES variables
	156	# for different programs/libraries.
	157	am__define_uniq_tagged_files = \
	158	list='$(am__tagged_files)'; \
	159	unique=`for i in $$list; do \
	160	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	161	done \| $(am__uniquify_input)`
108	162	ETAGS = etags
109	163	CTAGS = ctags
110	164	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

114	168	ADOLC_DIR = @ADOLC_DIR@
115	169	AMTAR = @AMTAR@
116	170	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	171	AR = @AR@
117	172	AUTOCONF = @AUTOCONF@
118	173	AUTOHEADER = @AUTOHEADER@
119	174	AUTOMAKE = @AUTOMAKE@

135	190	CXX_FLAGS_EIGEN = @CXX_FLAGS_EIGEN@
136	191	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
137	192	CYGPATH_W = @CYGPATH_W@
138
139		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
140		# -----------------------------------------------------------------------------
141		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
142		#
143		# CppAD is distributed under multiple licenses. This distribution is under
144		# the terms of the
145		# GNU General Public License Version 3.
146		#
147		# A copy of this license is included in the COPYING file of this distribution.
148		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
149		# -----------------------------------------------------------------------------
150		#
151		# automake input file
	193	#
152	194	#
153	195	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
154	196	DEFS =

204	246	abs_srcdir = @abs_srcdir@
205	247	abs_top_builddir = @abs_top_builddir@
206	248	abs_top_srcdir = @abs_top_srcdir@
	249	ac_ct_AR = @ac_ct_AR@
207	250	ac_ct_CC = @ac_ct_CC@
208	251	ac_ct_CXX = @ac_ct_CXX@
209	252	ac_ct_FC = @ac_ct_FC@

214	257	am__tar = @am__tar@
215	258	am__untar = @am__untar@
216	259	bindir = @bindir@
	260	build = @build@
217	261	build_alias = @build_alias@
	262	build_cpu = @build_cpu@
	263	build_os = @build_os@
	264	build_vendor = @build_vendor@
218	265	builddir = @builddir@
219	266	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
220	267	cppad_boostvector = @cppad_boostvector@
221	268	cppad_cflags = @cppad_cflags@
	269	cppad_compiler_has_erf = @cppad_compiler_has_erf@
222	270	cppad_cppadvector = @cppad_cppadvector@
223	271	cppad_description = @cppad_description@
224	272	cppad_eigenvector = @cppad_eigenvector@
	273	cppad_has_colpack = @cppad_has_colpack@
	274	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
225	275	cppad_has_gettimeofday = @cppad_has_gettimeofday@
226	276	cppad_has_nullptr = @cppad_has_nullptr@
	277	cppad_has_rvalue = @cppad_has_rvalue@
227	278	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
228	279	cppad_internal_sparse_set = @cppad_internal_sparse_set@
229	280	cppad_libs = @cppad_libs@
230	281	cppad_max_num_threads = @cppad_max_num_threads@
231	282	cppad_requires = @cppad_requires@
232		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	283	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
233	284	cppad_stdvector = @cppad_stdvector@
234	285	cppad_tape_addr_type = @cppad_tape_addr_type@
235	286	cppad_tape_id_type = @cppad_tape_id_type@

241	292	dvidir = @dvidir@
242	293	eigen_prefix = @eigen_prefix@
243	294	exec_prefix = @exec_prefix@
244		have_ar = @have_ar@
245	295	have_pkg_config = @have_pkg_config@
	296	host = @host@
246	297	host_alias = @host_alias@
	298	host_cpu = @host_cpu@
	299	host_os = @host_os@
	300	host_vendor = @host_vendor@
247	301	htmldir = @htmldir@
248	302	includedir = @includedir@
249	303	infodir = @infodir@

268	322	top_build_prefix = @top_build_prefix@
269	323	top_builddir = @top_builddir@
270	324	top_srcdir = @top_srcdir@
	325
	326	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
	327	# -----------------------------------------------------------------------------
	328	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	329	#
	330	# CppAD is distributed under multiple licenses. This distribution is under
	331	# the terms of the
	332	# GNU General Public License Version 3.
	333	#
	334	# A copy of this license is included in the COPYING file of this distribution.
	335	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	336	# -----------------------------------------------------------------------------
	337	#
	338	# Copy source file so that main.o does not end up in parent directory
	339	BUILT_SOURCES = main.cpp
271	340	#
272	341	AM_CPPFLAGS = \
273	342	-I$(top_srcdir) \

277	346
278	347	#
279	348	# BEGIN OPTIMIZE
280		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_ADOLC $(CXX_FLAGS)
	349	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_ADOLC_SPEED $(CXX_FLAGS)
281	350	# END OPTIMIZE
282	351	#
283	352	# BEGIN DEBUG
284		# AM_CXXFLAGS = -g $(CXX_FLAGS) -DSPEED_ADOLC
	353	# AM_CXXFLAGS = -g $(CXX_FLAGS) -DCPPAD_ADOLC_SPEED
285	354	# END DEBUG
286	355	#
287	356	LDADD = -lspeed -ladolc -lColPack
288	357	AM_LDFLAGS = -L../src -L$(ADOLC_DIR)/lib -L$(ADOLC_DIR)/lib64
289	358	#
290		adolc_SOURCES = \
291		alloc_mat.hpp \
	359	speed_adolc_SOURCES = \
	360	adolc_alloc_mat.hpp \
292	361	alloc_mat.cpp \
293		../main.cpp \
	362	main.cpp \
294	363	det_lu.cpp \
295	364	det_minor.cpp \
296	365	mat_mul.cpp \

299	368	sparse_hessian.cpp \
300	369	sparse_jacobian.cpp
301	370
302		all: all-am
	371	all: $(BUILT_SOURCES)
	372	$(MAKE) $(AM_MAKEFLAGS) all-am
303	373
304	374	.SUFFIXES:
305	375	.SUFFIXES: .cpp .o .obj

336	406
337	407	clean-checkPROGRAMS:
338	408	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
339		adolc$(EXEEXT): $(adolc_OBJECTS) $(adolc_DEPENDENCIES) $(EXTRA_adolc_DEPENDENCIES)
340		@rm -f adolc$(EXEEXT)
341		$(AM_V_CXXLD)$(CXXLINK) $(adolc_OBJECTS) $(adolc_LDADD) $(LIBS)
	409
	410	speed_adolc$(EXEEXT): $(speed_adolc_OBJECTS) $(speed_adolc_DEPENDENCIES) $(EXTRA_speed_adolc_DEPENDENCIES)
	411	@rm -f speed_adolc$(EXEEXT)
	412	$(AM_V_CXXLD)$(CXXLINK) $(speed_adolc_OBJECTS) $(speed_adolc_LDADD) $(LIBS)
342	413
343	414	mostlyclean-compile:
344	415	-rm -f *.$(OBJEXT)

357	428	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_jacobian.Po@am__quote@
358	429
359	430	.cpp.o:
360		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
361		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	431	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	432	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	433	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
362	434	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
363	435	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
364	436	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
365	437
366	438	.cpp.obj:
367		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
368		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	439	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	440	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	441	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
369	442	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
370	443	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
371	444	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
372	445
373		main.o: ../main.cpp
374		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.o -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
375		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
376		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.o' libtool=no @AMDEPBACKSLASH@
377		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
378		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
379
380		main.obj: ../main.cpp
381		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.obj -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
382		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
383		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.obj' libtool=no @AMDEPBACKSLASH@
384		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
385		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
386
387		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
388		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
389		unique=`for i in $$list; do \
390		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
391		done \| \
392		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
393		END { if (nonempty) { for (i in files) print i; }; }'`; \
394		mkid -fID $$unique
395		tags: TAGS
396
397		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
398		$(TAGS_FILES) $(LISP)
	446	ID: $(am__tagged_files)
	447	$(am__define_uniq_tagged_files); mkid -fID $$unique
	448	tags: tags-am
	449	TAGS: tags
	450
	451	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
399	452	set x; \
400	453	here=`pwd`; \
401		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
402		unique=`for i in $$list; do \
403		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
404		done \| \
405		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
406		END { if (nonempty) { for (i in files) print i; }; }'`; \
	454	$(am__define_uniq_tagged_files); \
407	455	shift; \
408	456	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
409	457	test -n "$$unique" \|\| unique=$$empty_fix; \

415	463	$$unique; \
416	464	fi; \
417	465	fi
418		ctags: CTAGS
419		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
420		$(TAGS_FILES) $(LISP)
421		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
422		unique=`for i in $$list; do \
423		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
424		done \| \
425		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
426		END { if (nonempty) { for (i in files) print i; }; }'`; \
	466	ctags: ctags-am
	467
	468	CTAGS: ctags
	469	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	470	$(am__define_uniq_tagged_files); \
427	471	test -z "$(CTAGS_ARGS)$$unique" \
428	472	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
429	473	$$unique

432	476	here=`$(am__cd) $(top_builddir) && pwd` \
433	477	&& $(am__cd) $(top_srcdir) \
434	478	&& gtags -i $(GTAGS_ARGS) "$$here"
	479	cscopelist: cscopelist-am
	480
	481	cscopelist-am: $(am__tagged_files)
	482	list='$(am__tagged_files)'; \
	483	case "$(srcdir)" in \
	484	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	485	*) sdir=$(subdir)/$(srcdir) ;; \
	486	esac; \
	487	for i in $$list; do \
	488	if test -f "$$i"; then \
	489	echo "$(subdir)/$$i"; \
	490	else \
	491	echo "$$sdir/$$i"; \
	492	fi; \
	493	done >> $(top_builddir)/cscope.files
435	494
436	495	distclean-tags:
437	496	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

468	527	done
469	528	check-am: all-am
470	529	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
471		check: check-am
	530	check: $(BUILT_SOURCES)
	531	$(MAKE) $(AM_MAKEFLAGS) check-am
472	532	all-am: makefile
473	533	installdirs:
474		install: install-am
	534	install: $(BUILT_SOURCES)
	535	$(MAKE) $(AM_MAKEFLAGS) install-am
475	536	install-exec: install-exec-am
476	537	install-data: install-data-am
477	538	uninstall: uninstall-am

501	562	maintainer-clean-generic:
502	563	@echo "This command is intended for maintainers to use"
503	564	@echo "it deletes files that may require special tools to rebuild."
	565	-test -z "$(BUILT_SOURCES)" \|\| rm -f $(BUILT_SOURCES)
504	566	clean: clean-am
505	567
506	568	clean-am: clean-checkPROGRAMS clean-generic mostlyclean-am

570	632
571	633	uninstall-am:
572	634
573		.MAKE: check-am install-am install-strip
574
575		.PHONY: CTAGS GTAGS all all-am check check-am clean \
576		clean-checkPROGRAMS clean-generic ctags distclean \
577		distclean-compile distclean-generic distclean-tags distdir dvi \
578		dvi-am html html-am info info-am install install-am \
579		install-data install-data-am install-dvi install-dvi-am \
580		install-exec install-exec-am install-html install-html-am \
581		install-info install-info-am install-man install-pdf \
582		install-pdf-am install-ps install-ps-am install-strip \
583		installcheck installcheck-am installdirs maintainer-clean \
584		maintainer-clean-generic mostlyclean mostlyclean-compile \
585		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
586		uninstall-am
587
	635	.MAKE: all check check-am install install-am install-strip
	636
	637	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	638	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	639	distclean distclean-compile distclean-generic distclean-tags \
	640	distdir dvi dvi-am html html-am info info-am install \
	641	install-am install-data install-data-am install-dvi \
	642	install-dvi-am install-exec install-exec-am install-html \
	643	install-html-am install-info install-info-am install-man \
	644	install-pdf install-pdf-am install-ps install-ps-am \
	645	install-strip installcheck installcheck-am installdirs \
	646	maintainer-clean maintainer-clean-generic mostlyclean \
	647	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	648	tags tags-am uninstall uninstall-am
	649
	650	main.cpp:
	651	cp $(srcdir)/../main.cpp main.cpp
588	652
589	653	test: check
590		./adolc correct 123
591		./adolc correct 123 retape
	654	./speed_adolc correct 123 colpack
	655	./speed_adolc correct 123 onetape colpack
592	656
593	657	# Tell versions [3.59,3.63) of GNU make to not export all variables.
594	658	# Otherwise a system limit (for SysV at least) may be exceeded.

+10

-8

speed/adolc/mat_mul.cpp less more

0		/* $Id: mat_mul.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: mat_mul.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

12	12	$begin adolc_mat_mul.cpp$$
13	13	$spell
14	14	sq
15		retape
	15	onetape
16	16	adouble
17	17	typedef
18	18	alloc

46	46	# include <cppad/speed/mat_sum_sq.hpp>
47	47	# include <cppad/speed/uniform_01.hpp>
48	48	# include <cppad/vector.hpp>
	49
	50	// list of possible options
	51	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	52
49	53	bool link_mat_mul(
50	54	size_t size ,
51	55	size_t repeat ,

54	58	CppAD::vector<double>& dz )
55	59	{
56	60	// speed test global option values
57		extern bool global_retape, global_atomic, global_optimize;
58		if( global_atomic \|\| global_optimize )
59		return false;
60
	61	if( global_memory \|\| global_atomic \|\| global_optimize )
	62	return false;
61	63	// -----------------------------------------------------
62	64	// setup
63	65	typedef adouble ADScalar;

93	95	double* grad = thread_alloc::create_array<double>(size_t(n), capacity);
94	96
95	97	// ----------------------------------------------------------------------
96		if( global_retape ) while(repeat--)
	98	if( ! global_onetape ) while(repeat--)
97	99	{ // choose a matrix
98	100	CppAD::uniform_01(n, mat);
99	101

+13

-11

speed/adolc/ode.cpp less more

0		/* $Id: ode.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: ode.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

21	21	Adolc
22	22	bool
23	23	CppAD
24		retape
	24	onetape
25	25	$$
26	26
27	27	$section Adolc Speed: Ode$$

44	44	# include <cppad/speed/ode_evaluate.hpp>
45	45	# include <cppad/speed/uniform_01.hpp>
46	46
	47	// list of possible options
	48	extern bool global_memory, global_onetape, global_atomic, global_optimize;
47	49
48	50	bool link_ode(
49	51	size_t size ,

52	54	CppAD::vector<double> &jac
53	55	)
54	56	{
	57	// speed test global option values
	58	if( global_atomic )
	59	return false;
	60	if( global_memory \|\| global_optimize )
	61	return false;
	62	// -------------------------------------------------------------
	63	// setup
55	64	assert( x.size() == size );
56	65	assert( jac.size() == size * size );
57	66
58		// speed test global option values
59		extern bool global_retape, global_atomic, global_optimize;
60		if( global_atomic \|\| global_optimize )
61		return false;
62
63		// -------------------------------------------------------------
64		// setup
65	67	typedef CppAD::vector<adouble> ADVector;
66	68	typedef CppAD::vector<double> DblVector;
67	69

90	92	jac_ptr[i] = jac_raw + i * n;
91	93
92	94	// -------------------------------------------------------------
93		if( global_retape) while(repeat--)
	95	if( ! global_onetape ) while(repeat--)
94	96	{ // choose next x value
95	97	uniform_01(n, x);
96	98

+11

-9

speed/adolc/poly.cpp less more

0		/* $Id: poly.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: poly.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

12	12	$begin adolc_poly.cpp$$
13	13	$spell
14	14	alloc
15		retape
	15	onetape
16	16	coef
17	17	cppad
18	18	hos

54	54	# include <cppad/poly.hpp>
55	55	# include <cppad/vector.hpp>
56	56	# include <cppad/thread_alloc.hpp>
	57	# include "adolc_alloc_mat.hpp"
57	58
58		# include "alloc_mat.hpp"
	59	// list of possible options
	60	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	61
59	62	bool link_poly(
60	63	size_t size ,
61	64	size_t repeat ,

63	66	CppAD::vector<double> &z , // polynomial argument value
64	67	CppAD::vector<double> &ddp ) // second derivative w.r.t z
65	68	{
66		// speed test global option values
67		extern bool global_retape, global_atomic, global_optimize;
68		if( global_atomic \|\| global_optimize )
	69	if( global_atomic )
69	70	return false;
70
	71	if( global_memory \|\| global_optimize )
	72	return false;
71	73	// -----------------------------------------------------
72	74	// setup
73	75	size_t i;

104	106	x[0][1] = 0.; // second order
105	107
106	108	// ----------------------------------------------------------------------
107		if( global_retape ) while(repeat--)
	109	if( ! global_onetape ) while(repeat--)
108	110	{ // choose an argument value
109	111	CppAD::uniform_01(1, z);
110	112

+17

-12

speed/adolc/sparse_hessian.cpp less more

0		/* $Id: sparse_hessian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: sparse_hessian.cpp 3136 2014-03-02 11:54:07Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin adolc_sparse_hessian.cpp$$
13	13	$spell
14		retape
	14	colpack
	15	boolsparsity
	16	onetape
15	17	hess
16	18	int int_n
17	19	nnz

52	54	# include <cppad/thread_alloc.hpp>
53	55	# include <cppad/speed/sparse_hes_fun.hpp>
54	56
	57	// list of possible options
	58	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	59	extern bool global_colpack, global_boolsparsity;
	60
55	61	bool link_sparse_hessian(
56	62	size_t size ,
57	63	size_t repeat ,
58		CppAD::vector<double> &x_return ,
59		const CppAD::vector<size_t> &row ,
60		const CppAD::vector<size_t> &col ,
61		CppAD::vector<double> &hessian )
	64	const CppAD::vector<size_t>& row ,
	65	const CppAD::vector<size_t>& col ,
	66	CppAD::vector<double>& x_return ,
	67	CppAD::vector<double>& hessian )
62	68	{
63		// speed test global option values
64		extern bool global_retape, global_atomic, global_optimize;
65		if( global_atomic \|\| global_optimize )
	69	if( global_atomic \|\| (! global_colpack) )
66	70	return false;
67
	71	if( global_memory \|\| global_optimize \|\| global_boolsparsity )
	72	return false;
68	73	// -----------------------------------------------------
69	74	// setup
70	75	typedef unsigned int* SizeVector;

110	115	hessian[ i * n + j ] = 0.;
111	116	}
112	117	// ----------------------------------------------------------------------
113		if( global_retape ) while(repeat--)
	118	if( ! global_onetape ) while(repeat--)
114	119	{ // choose a value for x
115	120	CppAD::uniform_01(n, x);
116	121

+59

-42

speed/adolc/sparse_jacobian.cpp less more

0		/* $Id: sparse_jacobian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: sparse_jacobian.cpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

14	14	/*
15	15	$begin adolc_sparse_jacobian.cpp$$
16	16	$spell
	17	const
	18	sparsedrivers.cpp
	19	colpack
	20	boolsparsity
17	21	adouble
18	22	int int_n
19	23	cppad.hpp
20		retape
	24	onetape
21	25	typedef
22	26	alloc
23	27	jac

50	54	# include <cppad/speed/uniform_01.hpp>
51	55	# include <cppad/speed/sparse_jac_fun.hpp>
52	56
	57	// list of possible options
	58	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	59	extern bool global_colpack, global_boolsparsity;
	60
53	61	bool link_sparse_jacobian(
54		size_t size ,
55		size_t repeat ,
56		size_t m ,
57		CppAD::vector<double> &x_return ,
58		CppAD::vector<size_t> &row ,
59		CppAD::vector<size_t> &col ,
60		CppAD::vector<double> &jacobian )
	62	size_t size ,
	63	size_t repeat ,
	64	size_t m ,
	65	const CppAD::vector<size_t>& row ,
	66	const CppAD::vector<size_t>& col ,
	67	CppAD::vector<double>& x_return ,
	68	CppAD::vector<double>& jacobian ,
	69	size_t& n_sweep )
61	70	{
62		// speed test global option values
63		extern bool global_retape, global_atomic, global_optimize;
64		if( global_atomic \|\| global_optimize )
	71	if( global_atomic \|\| (! global_colpack) )
65	72	return false;
66
	73	if( global_memory \|\| global_optimize )
	74	return false;
67	75	// -----------------------------------------------------
68	76	// setup
69	77	typedef unsigned int* SizeVector;

90	98	// function value in double
91	99	DblVector y = thread_alloc::create_array<double>(m, capacity);
92	100
	101
93	102	// options that control sparse_jac
94	103	int options[4];
95		options[0] = 0; // sparsity pattern by index domains
96		options[1] = 0; // safe mode
97		options[2] = 0; // not used if options[0] == 0
98		options[3] = 0; // forward mode (column compression)
	104	extern bool global_boolsparsity;
	105	if( global_boolsparsity )
	106	options[0] = 1; // sparsity by propagation of bit pattern
	107	else
	108	options[0] = 0; // sparsity pattern by index domains
	109	options[1] = 0; // (0 = safe mode, 1 = tight mode)
	110	options[2] = 0; // see changing to -1 and back to 0 below
	111	options[3] = 0; // (0 = column compression, 1 = row compression)
99	112
100	113	// structure that holds some of the work done by sparse_jac
101	114	int nnz; // number of non-zero values

108	121	{ for(j = 0; j < n; j++)
109	122	jacobian[ i * n + j ] = 0.;
110	123	}
	124
	125	// choose a value for x
	126	CppAD::uniform_01(n, x);
	127
	128	// declare independent variables
	129	int keep = 0; // keep forward mode results
	130	trace_on(tag, keep);
	131	for(j = 0; j < n; j++)
	132	a_x[j] <<= x[j];
	133
	134	// AD computation of f (x)
	135	CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
	136
	137	// create function object f : x -> y
	138	for(i = 0; i < m; i++)
	139	a_y[i] >>= y[i];
	140	trace_off();
	141
	142	// Retrieve n_sweep using undocumented feature of sparsedrivers.cpp
	143	int same_pattern = 0;
	144	options[2] = -1;
	145	n_sweep = sparse_jac(tag, int(m), int(n),
	146	same_pattern, x, &nnz, &rind, &cind, &values, options
	147	);
	148	options[2] = 0;
111	149	// ----------------------------------------------------------------------
112		if( global_retape ) while(repeat--)
	150	if( ! global_onetape ) while(repeat--)
113	151	{ // choose a value for x
114	152	CppAD::uniform_01(n, x);
115	153
116	154	// declare independent variables
117		int keep = 0; // keep forward mode results
118	155	trace_on(tag, keep);
119	156	for(j = 0; j < n; j++)
120	157	a_x[j] <<= x[j];

128	165	trace_off();
129	166
130	167	// is this a repeat call with the same sparsity pattern
131		int same_pattern = 0;
	168	same_pattern = 0;
132	169
133	170	// calculate the jacobian at this x
134	171	rind = CPPAD_NULL;

147	184	free(values);
148	185	}
149	186	else
150		{ // choose a value for x
151		CppAD::uniform_01(n, x);
152
153		// declare independent variables
154		int keep = 0; // keep forward mode results
155		trace_on(tag, keep);
156		for(j = 0; j < n; j++)
157		a_x[j] <<= x[j];
158
159		// AD computation of f (x)
160		CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
161
162		// create function object f : x -> y
163		for(i = 0; i < m; i++)
164		a_y[i] >>= y[i];
165		trace_off();
166
167		// is this a repeat call at the same argument
168		int same_pattern = 0;
169
170		while(repeat--)
	187	{ while(repeat--)
171	188	{ // choose a value for x
172	189	CppAD::uniform_01(n, x);
173	190

-9

speed/cppad/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2572 2012-11-15 19:43:06Z bradbell $
	0	# $Id: CMakeLists.txt 3139 2014-03-02 21:12:00Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

10	10	# -----------------------------------------------------------------------------
11	11	# Build the speed/cppad directory tests
12	12	# Inherit environment from ../CMakeList.txt
13
14		# Specifies build type for this directory. Possible values are
15		# empty, Debug, Release, RelWithDebInfo and MinSizeRel
16		SET(CMAKE_BUILD_TYPE RELEASE)
	13	# CMAKE_BUILD_TYPE determined by parent directory
17	14
18	15	# Adds flags to the compiler command line for sources in the current directory
19	16	# and below. This command can be used to add any flags, but it was originally
20	17	# intended to add preprocessor definitions.
21		ADD_DEFINITIONS("-DSPEED_CPPAD")
	18	ADD_DEFINITIONS("-DCPPAD_CPPAD_SPEED")
22	19
23	20	# Local include directories to search (not in package_prefix/includdir)
24	21	INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/../src )

26	23	# add_executable(<name> [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL]
27	24	# source1 source2 ... sourceN
28	25	# )
29		ADD_EXECUTABLE(speed_cppad EXCLUDE_FROM_ALL ../main.cpp print_optimize.cpp
	26	ADD_EXECUTABLE(speed_cppad EXCLUDE_FROM_ALL ../main.cpp
30	27	det_lu.cpp
31	28	det_minor.cpp
32	29	mat_mul.cpp

40	37	add_cppad_cxx_flags( speed_cppad )
41	38
42	39	# List of libraries to be linked into the specified target
43		TARGET_LINK_LIBRARIES(speed_cppad speed_src )
	40	TARGET_LINK_LIBRARIES(speed_cppad speed_src ${colpack_libs})
44	41
45	42	# Add the check_speed_cppad target
46	43	ADD_CUSTOM_TARGET(check_speed_cppad

-16

speed/cppad/det_lu.cpp less more

0		/* $Id: det_lu.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_lu.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin cppad_det_lu.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	bool
16	16	CppAD
17	17	vector Vector

46	46	# include <cppad/vector.hpp>
47	47	# include <cppad/speed/det_by_lu.hpp>
48	48	# include <cppad/speed/uniform_01.hpp>
49		# include "print_optimize.hpp"
	49
	50	// Note that CppAD uses global_memory at the main program level
	51	extern bool
	52	global_onetape, global_atomic, global_optimize;
50	53
51	54	bool link_det_lu(
52	55	size_t size ,

55	58	CppAD::vector<double> &gradient )
56	59	{
57	60	// speed test global option values
58		extern bool global_retape, global_atomic, global_optimize;
59		if( ! global_retape \|\| global_atomic )
	61	if( global_onetape \|\| global_atomic )
60	62	return false;
61	63
62	64	// -----------------------------------------------------

76	78	CppAD::vector<double> w(1);
77	79	w[0] = 1.;
78	80
79		// use the unspecified fact that size is non-decreasing between calls
80		static size_t previous_size = 0;
81		bool print = (repeat > 1) & (previous_size != size);
82		previous_size = size;
83
84
85	81	// ------------------------------------------------------
86	82	while(repeat--)
87	83	{ // get the next matrix

97	93
98	94	// create function object f : A -> detA
99	95	f.Dependent(A, detA);
100
101	96	if( global_optimize )
102		{ print_optimize(f, print, "cppad_det_lu_optimize", size);
103		print = false;
104		}
	97	f.optimize();
105	98
106	99	// evaluate and return gradient using reverse mode
107	100	f.Forward(0, matrix);

+10

-17

speed/cppad/det_minor.cpp less more

0		/* $Id: det_minor.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_minor.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin cppad_det_minor.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	vector Vector
16	16	typedef
17	17	cppad

46	46	# include <cppad/vector.hpp>
47	47	# include <cppad/speed/det_by_minor.hpp>
48	48	# include <cppad/speed/uniform_01.hpp>
49		# include "print_optimize.hpp"
	49
	50	// Note that CppAD uses global_memory at the main program level
	51	extern bool
	52	global_onetape, global_atomic, global_optimize;
50	53
51	54	bool link_det_minor(
52	55	size_t size ,

55	58	CppAD::vector<double> &gradient )
56	59	{
57	60	// speed test global option values
58		extern bool global_retape, global_atomic, global_optimize;
59	61	if( global_atomic )
60	62	return false;
61	63

80	82	// the AD function object
81	83	CppAD::ADFun<double> f;
82	84
83		// use the unspecified fact that size is non-decreasing between calls
84		static size_t previous_size = 0;
85		bool print = (repeat > 1) & (previous_size != size);
86		previous_size = size;
87
88	85	// ---------------------------------------------------------------------
89		if( global_retape ) while(repeat--)
	86	if( ! global_onetape ) while(repeat--)
90	87	{
91	88	// choose a matrix
92	89	CppAD::uniform_01(n, matrix);

103	100	f.Dependent(A, detA);
104	101
105	102	if( global_optimize )
106		{ print_optimize(f, print, "cppad_det_minor_optimize", size);
107		print = false;
108		}
	103	f.optimize();
109	104
110	105	// evaluate the determinant at the new matrix value
111	106	f.Forward(0, matrix);

130	125	f.Dependent(A, detA);
131	126
132	127	if( global_optimize )
133		{ print_optimize(f, print, "cppad_det_minor_optimize", size);
134		print = false;
135		}
	128	f.optimize();
136	129
137	130	// ------------------------------------------------------
138	131	while(repeat--)

+17

-15

speed/cppad/makefile.am less more

0		# $Id: makefile.am 2541 2012-11-06 16:32:36Z bradbell $
	0	# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

9	9	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10	10	# -----------------------------------------------------------------------------
11	11	#
12		# automake input file
	12	# Copy source file so that main.o does not end up in parent directory
	13	BUILT_SOURCES = main.cpp
	14	main.cpp:
	15	cp $(srcdir)/../main.cpp main.cpp
13	16	#
14	17	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
15	18	DEFS =
16	19	#
17		check_PROGRAMS = cppad
	20	check_PROGRAMS = speed_cppad
18	21	#
19	22	AM_CPPFLAGS = -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
20	23	#
21	24	# BEGIN OPTIMIZE
22		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_CPPAD $(CXX_FLAGS)
	25	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_CPPAD_SPEED $(CXX_FLAGS)
23	26	# END OPTIMIZE
24	27	#
25	28	# BEGIN DEBUG
26		# AM_CXXFLAGS = -g $(CXX_FLAGS) -DSPEED_CPPAD
	29	# AM_CXXFLAGS = -g $(CXX_FLAGS) -DCPPAD_CPPAD_SPEED
27	30	# END DEBUG
28	31	#
29	32	LDADD = -lspeed
30	33	AM_LDFLAGS = -L../src
31	34	#
32		cppad_SOURCES = \
33		print_optimize.hpp \
34		print_optimize.cpp \
35		../main.cpp \
	35	speed_cppad_SOURCES = \
	36	main.cpp \
36	37	det_lu.cpp \
37	38	det_minor.cpp \
38	39	mat_mul.cpp \

42	43	sparse_jacobian.cpp
43	44
44	45	test: check
45		./cppad correct 123
46		./cppad correct 123 retape
47		./cppad correct 123 optimize
48		./cppad correct 123 atomic
49		./cppad correct 123 memory
	46	./speed_cppad correct 123
	47	./speed_cppad correct 123 onetape
	48	./speed_cppad correct 123 optimize
	49	./speed_cppad correct 123 atomic
	50	./speed_cppad correct 123 memory
	51	./speed_cppad correct 123 boolsparsity

+192

-143

speed/cppad/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
50		check_PROGRAMS = cppad$(EXEEXT)
	77	build_triplet = @build@
	78	host_triplet = @host@
	79	check_PROGRAMS = speed_cppad$(EXEEXT)
51	80	subdir = speed/cppad
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

57	87	mkinstalldirs = $(install_sh) -d
58	88	CONFIG_CLEAN_FILES =
59	89	CONFIG_CLEAN_VPATH_FILES =
60		am_cppad_OBJECTS = print_optimize.$(OBJEXT) main.$(OBJEXT) \
61		det_lu.$(OBJEXT) det_minor.$(OBJEXT) mat_mul.$(OBJEXT) \
62		ode.$(OBJEXT) poly.$(OBJEXT) sparse_hessian.$(OBJEXT) \
	90	am_speed_cppad_OBJECTS = main.$(OBJEXT) det_lu.$(OBJEXT) \
	91	det_minor.$(OBJEXT) mat_mul.$(OBJEXT) ode.$(OBJEXT) \
	92	poly.$(OBJEXT) sparse_hessian.$(OBJEXT) \
63	93	sparse_jacobian.$(OBJEXT)
64		cppad_OBJECTS = $(am_cppad_OBJECTS)
65		cppad_LDADD = $(LDADD)
66		cppad_DEPENDENCIES =
	94	speed_cppad_OBJECTS = $(am_speed_cppad_OBJECTS)
	95	speed_cppad_LDADD = $(LDADD)
	96	speed_cppad_DEPENDENCIES =
	97	AM_V_P = $(am__v_P_@AM_V@)
	98	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	99	am__v_P_0 = false
	100	am__v_P_1 = :
	101	AM_V_GEN = $(am__v_GEN_@AM_V@)
	102	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	103	am__v_GEN_0 = @echo " GEN " $@;
	104	am__v_GEN_1 =
	105	AM_V_at = $(am__v_at_@AM_V@)
	106	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	107	am__v_at_0 = @
	108	am__v_at_1 =
67	109	DEFAULT_INCLUDES =
68	110	depcomp = $(SHELL) $(top_srcdir)/depcomp
69	111	am__depfiles_maybe = depfiles
70	112	am__mv = mv -f
71		AM_V_lt = $(am__v_lt_@AM_V@)
72		am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
73		am__v_lt_0 = --silent
74	113	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
75	114	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
76	115	AM_V_CXX = $(am__v_CXX_@AM_V@)
77	116	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
78		am__v_CXX_0 = @echo " CXX " $@;
79		AM_V_at = $(am__v_at_@AM_V@)
80		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
81		am__v_at_0 = @
	117	am__v_CXX_0 = @echo " CXX " $@;
	118	am__v_CXX_1 =
82	119	CXXLD = $(CXX)
83	120	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
84	121	-o $@
85	122	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
86	123	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
87		am__v_CXXLD_0 = @echo " CXXLD " $@;
88		COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
89		$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
90		AM_V_CC = $(am__v_CC_@AM_V@)
91		am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
92		am__v_CC_0 = @echo " CC " $@;
93		CCLD = $(CC)
94		LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
95		AM_V_CCLD = $(am__v_CCLD_@AM_V@)
96		am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
97		am__v_CCLD_0 = @echo " CCLD " $@;
98		AM_V_GEN = $(am__v_GEN_@AM_V@)
99		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
100		am__v_GEN_0 = @echo " GEN " $@;
101		SOURCES = $(cppad_SOURCES)
102		DIST_SOURCES = $(cppad_SOURCES)
	124	am__v_CXXLD_0 = @echo " CXXLD " $@;
	125	am__v_CXXLD_1 =
	126	SOURCES = $(speed_cppad_SOURCES)
	127	DIST_SOURCES = $(speed_cppad_SOURCES)
103	128	am__can_run_installinfo = \
104	129	case $$AM_UPDATE_INFO_DIR in \
105	130	n\|no\|NO) false;; \
106	131	*) (install-info --version) >/dev/null 2>&1;; \
107	132	esac
	133	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	134	# Read a list of newline-separated strings from the standard input,
	135	# and print each of them once, without duplicates. Input order is
	136	# not preserved.
	137	am__uniquify_input = $(AWK) '\
	138	BEGIN { nonempty = 0; } \
	139	{ items[$$0] = 1; nonempty = 1; } \
	140	END { if (nonempty) { for (i in items) print i; }; } \
	141	'
	142	# Make sure the list of sources is unique. This is necessary because,
	143	# e.g., the same source file might be shared among _SOURCES variables
	144	# for different programs/libraries.
	145	am__define_uniq_tagged_files = \
	146	list='$(am__tagged_files)'; \
	147	unique=`for i in $$list; do \
	148	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	149	done \| $(am__uniquify_input)`
108	150	ETAGS = etags
109	151	CTAGS = ctags
110	152	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

114	156	ADOLC_DIR = @ADOLC_DIR@
115	157	AMTAR = @AMTAR@
116	158	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	159	AR = @AR@
117	160	AUTOCONF = @AUTOCONF@
118	161	AUTOHEADER = @AUTOHEADER@
119	162	AUTOMAKE = @AUTOMAKE@

135	178	CXX_FLAGS_EIGEN = @CXX_FLAGS_EIGEN@
136	179	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
137	180	CYGPATH_W = @CYGPATH_W@
138
139		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
140		# -----------------------------------------------------------------------------
141		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
142		#
143		# CppAD is distributed under multiple licenses. This distribution is under
144		# the terms of the
145		# GNU General Public License Version 3.
146		#
147		# A copy of this license is included in the COPYING file of this distribution.
148		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
149		# -----------------------------------------------------------------------------
150		#
151		# automake input file
152	181	#
153	182	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
154	183	DEFS =

204	233	abs_srcdir = @abs_srcdir@
205	234	abs_top_builddir = @abs_top_builddir@
206	235	abs_top_srcdir = @abs_top_srcdir@
	236	ac_ct_AR = @ac_ct_AR@
207	237	ac_ct_CC = @ac_ct_CC@
208	238	ac_ct_CXX = @ac_ct_CXX@
209	239	ac_ct_FC = @ac_ct_FC@

214	244	am__tar = @am__tar@
215	245	am__untar = @am__untar@
216	246	bindir = @bindir@
	247	build = @build@
217	248	build_alias = @build_alias@
	249	build_cpu = @build_cpu@
	250	build_os = @build_os@
	251	build_vendor = @build_vendor@
218	252	builddir = @builddir@
219	253	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
220	254	cppad_boostvector = @cppad_boostvector@
221	255	cppad_cflags = @cppad_cflags@
	256	cppad_compiler_has_erf = @cppad_compiler_has_erf@
222	257	cppad_cppadvector = @cppad_cppadvector@
223	258	cppad_description = @cppad_description@
224	259	cppad_eigenvector = @cppad_eigenvector@
	260	cppad_has_colpack = @cppad_has_colpack@
	261	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
225	262	cppad_has_gettimeofday = @cppad_has_gettimeofday@
226	263	cppad_has_nullptr = @cppad_has_nullptr@
	264	cppad_has_rvalue = @cppad_has_rvalue@
227	265	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
228	266	cppad_internal_sparse_set = @cppad_internal_sparse_set@
229	267	cppad_libs = @cppad_libs@
230	268	cppad_max_num_threads = @cppad_max_num_threads@
231	269	cppad_requires = @cppad_requires@
232		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	270	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
233	271	cppad_stdvector = @cppad_stdvector@
234	272	cppad_tape_addr_type = @cppad_tape_addr_type@
235	273	cppad_tape_id_type = @cppad_tape_id_type@

241	279	dvidir = @dvidir@
242	280	eigen_prefix = @eigen_prefix@
243	281	exec_prefix = @exec_prefix@
244		have_ar = @have_ar@
245	282	have_pkg_config = @have_pkg_config@
	283	host = @host@
246	284	host_alias = @host_alias@
	285	host_cpu = @host_cpu@
	286	host_os = @host_os@
	287	host_vendor = @host_vendor@
247	288	htmldir = @htmldir@
248	289	includedir = @includedir@
249	290	infodir = @infodir@

268	309	top_build_prefix = @top_build_prefix@
269	310	top_builddir = @top_builddir@
270	311	top_srcdir = @top_srcdir@
	312
	313	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
	314	# -----------------------------------------------------------------------------
	315	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	316	#
	317	# CppAD is distributed under multiple licenses. This distribution is under
	318	# the terms of the
	319	# GNU General Public License Version 3.
	320	#
	321	# A copy of this license is included in the COPYING file of this distribution.
	322	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	323	# -----------------------------------------------------------------------------
	324	#
	325	# Copy source file so that main.o does not end up in parent directory
	326	BUILT_SOURCES = main.cpp
271	327	#
272	328	AM_CPPFLAGS = -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
273	329	#
274	330	# BEGIN OPTIMIZE
275		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_CPPAD $(CXX_FLAGS)
	331	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_CPPAD_SPEED $(CXX_FLAGS)
276	332	# END OPTIMIZE
277	333	#
278	334	# BEGIN DEBUG
279		# AM_CXXFLAGS = -g $(CXX_FLAGS) -DSPEED_CPPAD
	335	# AM_CXXFLAGS = -g $(CXX_FLAGS) -DCPPAD_CPPAD_SPEED
280	336	# END DEBUG
281	337	#
282	338	LDADD = -lspeed
283	339	AM_LDFLAGS = -L../src
284	340	#
285		cppad_SOURCES = \
286		print_optimize.hpp \
287		print_optimize.cpp \
288		../main.cpp \
	341	speed_cppad_SOURCES = \
	342	main.cpp \
289	343	det_lu.cpp \
290	344	det_minor.cpp \
291	345	mat_mul.cpp \

294	348	sparse_hessian.cpp \
295	349	sparse_jacobian.cpp
296	350
297		all: all-am
	351	all: $(BUILT_SOURCES)
	352	$(MAKE) $(AM_MAKEFLAGS) all-am
298	353
299	354	.SUFFIXES:
300	355	.SUFFIXES: .cpp .o .obj

331	386
332	387	clean-checkPROGRAMS:
333	388	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
334		cppad$(EXEEXT): $(cppad_OBJECTS) $(cppad_DEPENDENCIES) $(EXTRA_cppad_DEPENDENCIES)
335		@rm -f cppad$(EXEEXT)
336		$(AM_V_CXXLD)$(CXXLINK) $(cppad_OBJECTS) $(cppad_LDADD) $(LIBS)
	389
	390	speed_cppad$(EXEEXT): $(speed_cppad_OBJECTS) $(speed_cppad_DEPENDENCIES) $(EXTRA_speed_cppad_DEPENDENCIES)
	391	@rm -f speed_cppad$(EXEEXT)
	392	$(AM_V_CXXLD)$(CXXLINK) $(speed_cppad_OBJECTS) $(speed_cppad_LDADD) $(LIBS)
337	393
338	394	mostlyclean-compile:
339	395	-rm -f *.$(OBJEXT)

347	403	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mat_mul.Po@am__quote@
348	404	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ode.Po@am__quote@
349	405	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/poly.Po@am__quote@
350		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print_optimize.Po@am__quote@
351	406	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_hessian.Po@am__quote@
352	407	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_jacobian.Po@am__quote@
353	408
354	409	.cpp.o:
355		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
356		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	410	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	411	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	412	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
357	413	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
358	414	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
359	415	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
360	416
361	417	.cpp.obj:
362		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
363		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	418	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	419	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	420	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
364	421	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
365	422	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
366	423	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
367	424
368		main.o: ../main.cpp
369		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.o -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
370		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
371		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.o' libtool=no @AMDEPBACKSLASH@
372		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
373		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
374
375		main.obj: ../main.cpp
376		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.obj -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
377		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
378		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.obj' libtool=no @AMDEPBACKSLASH@
379		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
380		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
381
382		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
383		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
384		unique=`for i in $$list; do \
385		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
386		done \| \
387		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
388		END { if (nonempty) { for (i in files) print i; }; }'`; \
389		mkid -fID $$unique
390		tags: TAGS
391
392		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
393		$(TAGS_FILES) $(LISP)
	425	ID: $(am__tagged_files)
	426	$(am__define_uniq_tagged_files); mkid -fID $$unique
	427	tags: tags-am
	428	TAGS: tags
	429
	430	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
394	431	set x; \
395	432	here=`pwd`; \
396		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
397		unique=`for i in $$list; do \
398		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
399		done \| \
400		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
401		END { if (nonempty) { for (i in files) print i; }; }'`; \
	433	$(am__define_uniq_tagged_files); \
402	434	shift; \
403	435	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
404	436	test -n "$$unique" \|\| unique=$$empty_fix; \

410	442	$$unique; \
411	443	fi; \
412	444	fi
413		ctags: CTAGS
414		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
415		$(TAGS_FILES) $(LISP)
416		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
417		unique=`for i in $$list; do \
418		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
419		done \| \
420		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
421		END { if (nonempty) { for (i in files) print i; }; }'`; \
	445	ctags: ctags-am
	446
	447	CTAGS: ctags
	448	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	449	$(am__define_uniq_tagged_files); \
422	450	test -z "$(CTAGS_ARGS)$$unique" \
423	451	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
424	452	$$unique

427	455	here=`$(am__cd) $(top_builddir) && pwd` \
428	456	&& $(am__cd) $(top_srcdir) \
429	457	&& gtags -i $(GTAGS_ARGS) "$$here"
	458	cscopelist: cscopelist-am
	459
	460	cscopelist-am: $(am__tagged_files)
	461	list='$(am__tagged_files)'; \
	462	case "$(srcdir)" in \
	463	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	464	*) sdir=$(subdir)/$(srcdir) ;; \
	465	esac; \
	466	for i in $$list; do \
	467	if test -f "$$i"; then \
	468	echo "$(subdir)/$$i"; \
	469	else \
	470	echo "$$sdir/$$i"; \
	471	fi; \
	472	done >> $(top_builddir)/cscope.files
430	473
431	474	distclean-tags:
432	475	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

463	506	done
464	507	check-am: all-am
465	508	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
466		check: check-am
	509	check: $(BUILT_SOURCES)
	510	$(MAKE) $(AM_MAKEFLAGS) check-am
467	511	all-am: makefile
468	512	installdirs:
469		install: install-am
	513	install: $(BUILT_SOURCES)
	514	$(MAKE) $(AM_MAKEFLAGS) install-am
470	515	install-exec: install-exec-am
471	516	install-data: install-data-am
472	517	uninstall: uninstall-am

496	541	maintainer-clean-generic:
497	542	@echo "This command is intended for maintainers to use"
498	543	@echo "it deletes files that may require special tools to rebuild."
	544	-test -z "$(BUILT_SOURCES)" \|\| rm -f $(BUILT_SOURCES)
499	545	clean: clean-am
500	546
501	547	clean-am: clean-checkPROGRAMS clean-generic mostlyclean-am

565	611
566	612	uninstall-am:
567	613
568		.MAKE: check-am install-am install-strip
569
570		.PHONY: CTAGS GTAGS all all-am check check-am clean \
571		clean-checkPROGRAMS clean-generic ctags distclean \
572		distclean-compile distclean-generic distclean-tags distdir dvi \
573		dvi-am html html-am info info-am install install-am \
574		install-data install-data-am install-dvi install-dvi-am \
575		install-exec install-exec-am install-html install-html-am \
576		install-info install-info-am install-man install-pdf \
577		install-pdf-am install-ps install-ps-am install-strip \
578		installcheck installcheck-am installdirs maintainer-clean \
579		maintainer-clean-generic mostlyclean mostlyclean-compile \
580		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
581		uninstall-am
582
	614	.MAKE: all check check-am install install-am install-strip
	615
	616	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	617	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	618	distclean distclean-compile distclean-generic distclean-tags \
	619	distdir dvi dvi-am html html-am info info-am install \
	620	install-am install-data install-data-am install-dvi \
	621	install-dvi-am install-exec install-exec-am install-html \
	622	install-html-am install-info install-info-am install-man \
	623	install-pdf install-pdf-am install-ps install-ps-am \
	624	install-strip installcheck installcheck-am installdirs \
	625	maintainer-clean maintainer-clean-generic mostlyclean \
	626	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	627	tags tags-am uninstall uninstall-am
	628
	629	main.cpp:
	630	cp $(srcdir)/../main.cpp main.cpp
583	631
584	632	test: check
585		./cppad correct 123
586		./cppad correct 123 retape
587		./cppad correct 123 optimize
588		./cppad correct 123 atomic
589		./cppad correct 123 memory
	633	./speed_cppad correct 123
	634	./speed_cppad correct 123 onetape
	635	./speed_cppad correct 123 optimize
	636	./speed_cppad correct 123 atomic
	637	./speed_cppad correct 123 memory
	638	./speed_cppad correct 123 boolsparsity
590	639
591	640	# Tell versions [3.59,3.63) of GNU make to not export all variables.
592	641	# Otherwise a system limit (for SysV at least) may be exceeded.

+10

-19

speed/cppad/mat_mul.cpp less more

0		/* $Id: mat_mul.cpp 2859 2013-05-28 06:03:21Z bradbell $ */
	0	/* $Id: mat_mul.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

18	18	mul
19	19	hpp
20	20	bool
21		retape
	21	onetape
22	22	sq
23	23	var
24	24	std::cout

47	47	# include <cppad/speed/mat_sum_sq.hpp>
48	48	# include <cppad/speed/uniform_01.hpp>
49	49	# include <cppad/example/matrix_mul.hpp>
50		# include "print_optimize.hpp"
	50
	51	// Note that CppAD uses global_memory at the main program level
	52	extern bool
	53	global_onetape, global_atomic, global_optimize;
51	54
52	55	bool link_mat_mul(
53	56	size_t size ,

57	60	CppAD::vector<double>& dz
58	61	)
59	62	{
60		// speed test global option values
61		extern bool global_retape, global_atomic, global_optimize;
62
63	63	// -----------------------------------------------------
64	64	// setup
65	65	typedef CppAD::AD<double> ADScalar;

84	84	size_t nc_result = size;
85	85	matrix_mul atom_mul(nr_result, n_middle, nc_result);
86	86
87		// use the unspecified fact that size is non-decreasing between calls
88		static size_t previous_size = 0;
89		bool print = (repeat > 1) & (previous_size != size);
90		previous_size = size;
91
92	87	// ------------------------------------------------------
93		if( global_retape ) while(repeat--)
	88	if( ! global_onetape ) while(repeat--)
94	89	{ // get the next matrix
95	90	CppAD::uniform_01(n, x);
96	91	for( j = 0; j < n; j++)

117	112	f.Dependent(X, Z);
118	113
119	114	if( global_optimize )
120		{ print_optimize(f, print, "cppad_mat_mul_optimize", size);
121		print = false;
122		}
	115	f.optimize();
123	116
124	117	// evaluate and return gradient using reverse mode
125	118	z = f.Forward(0, x);

153	146	f.Dependent(X, Z);
154	147
155	148	if( global_optimize )
156		{ print_optimize(f, print, "cppad_mat_mul_optimize", size);
157		print = false;
158		}
	149	f.optimize();
159	150	while(repeat--)
160	151	{ // get a next matrix
161	152	CppAD::uniform_01(n, x);

+17

-23

speed/cppad/ode.cpp less more

0		/* $Id: ode.cpp 2870 2013-07-28 17:00:59Z bradbell $ */
	0	/* $Id: ode.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

22	22	cppad
23	23	hpp
24	24	bool
25		retape
	25	onetape
26	26	typedef
27	27	cassert
28	28	$$

45	45	# include <cppad/speed/ode_evaluate.hpp>
46	46	# include <cppad/speed/uniform_01.hpp>
47	47	# include <cassert>
48		# include "print_optimize.hpp"
	48
	49	// Note that CppAD uses global_memory at the main program level
	50	extern bool
	51	global_onetape, global_atomic, global_optimize;
49	52
50	53	bool link_ode(
51	54	size_t size ,

54	57	CppAD::vector<double> &jacobian
55	58	)
56	59	{
	60	// speed test global option values
	61	if( global_atomic )
	62	return false;
	63
	64	// --------------------------------------------------------------------
	65	// setup
57	66	assert( x.size() == size );
58	67	assert( jacobian.size() == size * size );
59	68
60		// speed test global option values
61		extern bool global_retape, global_atomic, global_optimize;
62		if( global_atomic )
63		return false;
64
65		// -------------------------------------------------------------
66		// setup
67	69	typedef CppAD::AD<double> ADScalar;
68	70	typedef CppAD::vector<ADScalar> ADVector;
69	71

74	76	ADVector X(n), Y(m); // independent and dependent variables
75	77	CppAD::ADFun<double> f; // AD function
76	78
77		// use the unspecified fact that size is non-decreasing between calls
78		static size_t previous_size = 0;
79		bool print = (repeat > 1) & (previous_size != size);
80		previous_size = size;
81
82	79	// -------------------------------------------------------------
83		if( global_retape) while(repeat--)
	80	if( ! global_onetape ) while(repeat--)
84	81	{ // choose next x value
85	82	uniform_01(n, x);
86	83	for(j = 0; j < n; j++)

96	93	f.Dependent(X, Y);
97	94
98	95	if( global_optimize )
99		{ print_optimize(f, print, "cppad_ode_optimize", size);
100		print = false;
101		}
	96	f.optimize();
	97
102	98	jacobian = f.Jacobian(x);
103	99	}
104	100	else

117	113	f.Dependent(X, Y);
118	114
119	115	if( global_optimize )
120		{ print_optimize(f, print, "cppad_ode_optimize", size);
121		print = false;
122		}
	116	f.optimize();
123	117	while(repeat--)
124	118	{ // get next argument value
125	119	uniform_01(n, x);

+11

-19

speed/cppad/poly.cpp less more

0		/* $Id: poly.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: poly.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin cppad_poly.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	coef
16	16	ddp
17	17	ADScalar

50	50	$codep */
51	51	# include <cppad/cppad.hpp>
52	52	# include <cppad/speed/uniform_01.hpp>
53		# include "print_optimize.hpp"
	53
	54	// Note that CppAD uses global_memory at the main program level
	55	extern bool
	56	global_onetape, global_atomic, global_optimize;
54	57
55	58	bool link_poly(
56	59	size_t size ,

60	63	CppAD::vector<double> &ddp ) // second derivative w.r.t z
61	64	{
62	65	// speed test global option values
63		extern bool global_retape, global_atomic, global_optimize;
64	66	if( global_atomic )
65	67	return false;
66	68

91	93	// AD function object
92	94	CppAD::ADFun<double> f;
93	95
94		// use the unspecified fact that size is non-decreasing between calls
95		static size_t previous_size = 0;
96		bool print = (repeat > 1) & (previous_size != size);
97		previous_size = size;
98
99	96	// --------------------------------------------------------------------
100		if( global_retape ) while(repeat--)
	97	if( ! global_onetape ) while(repeat--)
101	98	{
102	99	// choose an argument value
103	100	CppAD::uniform_01(1, z);

113	110	f.Dependent(Z, P);
114	111
115	112	if( global_optimize )
116		{ print_optimize(f, print, "cppad_poly_optimize", size);
117		print = false;
118		}
	113	f.optimize();
119	114
120	115	// pre-allocate memory for three forward mode calculations
121		f.capacity_taylor(3);
	116	f.capacity_order(3);
122	117
123	118	// evaluate the polynomial
124	119	p = f.Forward(0, z);

145	140	// create function object f : A -> detA
146	141	f.Dependent(Z, P);
147	142
148		extern bool global_optimize;
149	143	if( global_optimize )
150		{ print_optimize(f, print, "cppad_poly_optimize", size);
151		print = false;
152		}
	144	f.optimize();
153	145
154	146	while(repeat--)
155	147	{ // sufficient memory is allocated by second repetition

-90

~~speed/cppad/print_optimize.cpp~~ less more

0		/* $Id: print_optimize.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11		/*
12		$begin cppad_print_optimize$$
13		$spell
14		cppad
15		CppAD
16		bool
17		std::cout
18		const
19		var
20		$$
21
22		$section Speed Test Utility: Optimize Operation Sequences and Print Results$$
23		$index print_optimize, cppad speed test$$
24		$index optimize, print cppad speed test$$
25
26		$head Syntax$$
27		$codei%print_optimize(%f%, %print%, %label%, %test_id%)%$$
28
29		$head Purpose$$
30		This routine $cref/optimizes/optimize/$$ the operation sequences
31		and prints the results of the optimization.
32		It is used by the CppAD speed tests when the
33		$cref/optimize/speed_main/option_list/optimize/$$ option is true.
34		This helps when improving optimization of operation sequences.
35
36		$head f$$
37		The argument $icode f$$ has prototype
38		$codei%
39		ADFun<double>& %f%
40		%$$
41		It contains the operation sequences that is
42		$cref/optimized/optimize/$$.
43
44		$head print$$
45		The argument $icode print$$ has prototype
46		$codei%
47		bool %print%
48		%$$
49		If it is true, the following values are printed on $code std::cout$$:
50		$codei%
51		%label% = [ %test_id%, %size_before%, %size_after% ]
52		%$$
53		Where $icode size_before$$ and $icode size_after$$ are the value
54		corresponding to $icode%f%.size_var()%$$ before and after the optimization.
55
56		$head label$$
57		The argument $icode label$$ has prototype
58		$codei%
59		const char* %label%
60		%$$
61		It is the label that is used when printing the optimization results.
62
63		$head test_id$$
64		The argument $icode test_id$$ has prototype
65		$codei%
66		size_t %test_id%
67		%$$
68		and is an identifier for this speed test.
69
70		$end
71		*/
72		# include <cppad/cppad.hpp>
73
74		void print_optimize(
75		CppAD::ADFun<double>& f ,
76		bool print ,
77		const char* label ,
78		size_t test_id )
79		{ size_t before = f.size_var();
80		f.optimize();
81		size_t after = f.size_var();
82		if( print )
83		{ std::cout << label << " = [ ";
84		std::cout << int(test_id) << ", ";
85		std::cout << int(before) << ", ";
86		std::cout << int(after) << " ]";
87		std::cout << std::endl;
88		}
89		}

-24

~~speed/cppad/print_optimize.hpp~~ less more

0		/* $Id: print_optimize.hpp 2506 2012-10-24 19:36:49Z bradbell $ */
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11		# ifndef CPPAD_PRINT_OPTIMIZE_INCLUDED
12		# define CPPAD_PRINT_OPTIMIZE_INCLUDED
13
14		# include <cppad/cppad.hpp>
15
16		void print_optimize(
17		CppAD::ADFun<double>& f ,
18		bool print ,
19		const char* label ,
20		size_t test_id
21		);
22
23		# endif

+36

-34

speed/cppad/sparse_hessian.cpp less more

0		/* $Id: sparse_hessian.cpp 2870 2013-07-28 17:00:59Z bradbell $ */
	0	/* $Id: sparse_hessian.cpp 3139 2014-03-02 21:12:00Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin cppad_sparse_hessian.cpp$$
13	13	$spell
	14	colpack
	15	boolsparsity
14	16	namespace
15	17	Jac
16		retape
	18	onetape
17	19	work work
18	20	const
19	21	hes

48	50	# include <cppad/cppad.hpp>
49	51	# include <cppad/speed/uniform_01.hpp>
50	52	# include <cppad/speed/sparse_hes_fun.hpp>
51		# include "print_optimize.hpp"
52
53		// determines if we are using bool or set sparsity patterns
54		# define USE_SET_SPARSITY 1
	53
	54	// Note that CppAD uses global_memory at the main program level
	55	extern bool
	56	global_onetape, global_colpack,
	57	global_atomic, global_optimize, global_boolsparsity;
55	58
56	59	namespace {
57	60	using CppAD::vector;

96	99	bool link_sparse_hessian(
97	100	size_t size ,
98	101	size_t repeat ,
99		CppAD::vector<double>& x ,
100	102	const CppAD::vector<size_t>& row ,
101	103	const CppAD::vector<size_t>& col ,
102		CppAD::vector<double>& hessian )
	104	CppAD::vector<double>& x ,
	105	CppAD::vector<double>& hessian )
103	106	{
	107	if( global_atomic \|\| global_colpack )
	108	return false;
104	109	// -----------------------------------------------------
105	110	// setup
106	111	typedef vector<double> DblVector;

122	127	// weights for hessian calculation (only one component of f)
123	128	w[0] = 1.;
124	129
125		// use the unspecified fact that size is non-decreasing between calls
126		static size_t previous_size = 0;
127		bool print = (repeat > 1) & (previous_size != size);
128		previous_size = size;
129
130	130	// declare sparsity pattern
131		# if USE_SET_SPARSITY
132		SetVector sparsity(n);
133		# else
134		typedef vector<bool> BoolVector;
135		BoolVector sparsity(n * n);
136		# endif
	131	SetVector set_sparsity(n);
	132	BoolVector bool_sparsity(n * n);
	133
137	134	// initialize all entries as zero
138	135	for(i = 0; i < n; i++)
139	136	{ for(j = 0; j < n; j++)
140	137	hessian[ i * n + j] = 0.;
141	138	}
142	139	// ------------------------------------------------------
143		extern bool global_retape;
144		if( global_retape) while(repeat--)
	140	if( ! global_onetape ) while(repeat--)
145	141	{ // choose a value for x
146	142	CppAD::uniform_01(n, x);
147	143	for(j = 0; j < n; j++)

156	152	// create function object f : X -> Y
157	153	f.Dependent(a_x, a_y);
158	154
159		extern bool global_optimize;
160	155	if( global_optimize )
161		{ print_optimize(f, print, "cppad_sparse_hessian_optimize", size);
162		print = false;
163		}
	156	f.optimize();
164	157
165	158	// calculate the Hessian sparsity pattern for this function
166		calc_sparsity(sparsity, f);
	159	if( global_boolsparsity )
	160	calc_sparsity(bool_sparsity, f);
	161	else
	162	calc_sparsity(set_sparsity, f);
167	163
168	164	// structure that holds some of work done by SparseHessian
169	165	CppAD::sparse_hessian_work work;
170	166
171	167	// calculate this Hessian at this x
172		f.SparseHessian(x, w, sparsity, row, col, hes, work);
	168	if( global_boolsparsity)
	169	f.SparseHessian(x, w, bool_sparsity, row, col, hes, work);
	170	else
	171	f.SparseHessian(x, w, set_sparsity, row, col, hes, work);
173	172	for(k = 0; k < K; k++)
174	173	{ hessian[ row[k] * n + col[k] ] = hes[k];
175	174	hessian[ col[k] * n + row[k] ] = hes[k];

190	189	// create function object f : X -> Y
191	190	f.Dependent(a_x, a_y);
192	191
193		extern bool global_optimize;
194	192	if( global_optimize )
195		{ print_optimize(f, print, "cppad_sparse_hessian_optimize", size);
196		print = false;
197		}
	193	f.optimize();
198	194
199	195	// calculate the Hessian sparsity pattern for this function
200		calc_sparsity(sparsity, f);
	196	if( global_boolsparsity)
	197	calc_sparsity(bool_sparsity, f);
	198	else
	199	calc_sparsity(set_sparsity, f);
201	200
202	201	// declare structure that holds some of work done by SparseHessian
203	202	CppAD::sparse_hessian_work work;

207	206	CppAD::uniform_01(n, x);
208	207
209	208	// calculate sparsity at this x
210		f.SparseHessian(x, w, sparsity, row, col, hes, work);
	209	if( global_boolsparsity )
	210	f.SparseHessian(x, w, bool_sparsity, row, col, hes, work);
	211	else
	212	f.SparseHessian(x, w, set_sparsity, row, col, hes, work);
211	213
212	214	for(k = 0; k < K; k++)
213	215	{ hessian[ row[k] * n + col[k] ] = hes[k];

+61

-40

speed/cppad/sparse_jacobian.cpp less more

0		/* $Id: sparse_jacobian.cpp 2870 2013-07-28 17:00:59Z bradbell $ */
	0	/* $Id: sparse_jacobian.cpp 3139 2014-03-02 21:12:00Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin cppad_sparse_jacobian.cpp$$
13	13	$spell
	14	const
	15	ifdef
	16	ifndef
	17	colpack
	18	boolsparsity
14	19	namespace
15		retape
	20	onetape
16	21	work work
17	22	jac
18	23	CppAD

48	53	# include <cppad/cppad.hpp>
49	54	# include <cppad/speed/uniform_01.hpp>
50	55	# include <cppad/speed/sparse_jac_fun.hpp>
51		# include "print_optimize.hpp"
52
53		// determines if we are using bool or set sparsity patterns
54		# define USE_SET_SPARSITY 1
	56
	57	// Note that CppAD uses global_memory at the main program level
	58	extern bool
	59	global_onetape, global_colpack,
	60	global_atomic, global_optimize, global_boolsparsity;
55	61
56	62	namespace {
57	63	using CppAD::vector;

80	86	}
81	87
82	88	bool link_sparse_jacobian(
83		size_t size ,
84		size_t repeat ,
85		size_t m ,
86		CppAD::vector<double> &x ,
87		CppAD::vector<size_t> &row ,
88		CppAD::vector<size_t> &col ,
89		CppAD::vector<double> &jacobian )
	89	size_t size ,
	90	size_t repeat ,
	91	size_t m ,
	92	const CppAD::vector<size_t>& row ,
	93	const CppAD::vector<size_t>& col ,
	94	CppAD::vector<double>& x ,
	95	CppAD::vector<double>& jacobian ,
	96	size_t& n_sweep )
90	97	{
	98	if( global_atomic )
	99	return false;
	100	# ifndef CPPAD_COLPACK_SPEED
	101	if( global_colpack )
	102	return false;
	103	# endif
91	104	// -----------------------------------------------------
92	105	// setup
93	106	typedef vector< std::set<size_t> > SetVector;

104	117	DblVector jac(K); // non-zeros in Jacobian
105	118	CppAD::ADFun<double> f; // AD function object
106	119
107		// use the unspecified fact that size is non-decreasing between calls
108		static size_t previous_size = 0;
109		bool print = (repeat > 1) & (previous_size != size);
110		previous_size = size;
111
112	120	// declare sparsity pattern
113		# if USE_SET_SPARSITY
114		SetVector sparsity(m);
115		# else
116		typedef vector<bool> BoolVector;
117		BoolVector sparsity(m * n);
118		# endif
	121	SetVector set_sparsity(m);
	122	BoolVector bool_sparsity(m * n);
	123
119	124	// initialize all entries as zero
120	125	for(i = 0; i < m; i++)
121	126	{ for(j = 0; j < n; j++)
122	127	jacobian[ i * n + j ] = 0.;
123	128	}
124	129	// ------------------------------------------------------
125		extern bool global_retape;
126		if( global_retape ) while(repeat--)
	130	if( ! global_onetape ) while(repeat--)
127	131	{ // choose a value for x
128	132	CppAD::uniform_01(n, x);
129	133	for(k = 0; k < n; k++)

138	142	// create function object f : X -> Y
139	143	f.Dependent(a_x, a_y);
140	144
141		extern bool global_optimize;
142	145	if( global_optimize )
143		{ print_optimize(f, print, "cppad_sparse_jacobian_optimize", size);
144		print = false;
145		}
	146	f.optimize();
146	147
147	148	// calculate the Jacobian sparsity pattern for this function
148		calc_sparsity(sparsity, f);
	149	if( global_boolsparsity )
	150	calc_sparsity(bool_sparsity, f);
	151	else
	152	calc_sparsity(set_sparsity, f);
149	153
150	154	// structure that holds some of the work done by SparseJacobian
151	155	CppAD::sparse_jacobian_work work;
152
	156	# ifdef CPPAD_COLPACK_SPEED
	157	if( global_colpack )
	158	work.color_method = "colpack";
	159	# endif
153	160	// calculate the Jacobian at this x
154	161	// (use forward mode because m > n ?)
155		f.SparseJacobianForward(x, sparsity, row, col, jac, work);
	162	if( global_boolsparsity) n_sweep = f.SparseJacobianForward(
	163	x, bool_sparsity, row, col, jac, work
	164	);
	165	else n_sweep = f.SparseJacobianForward(
	166	x, set_sparsity, row, col, jac, work
	167	);
156	168	for(k = 0; k < K; k++)
157	169	jacobian[ row[k] * n + col[k] ] = jac[k];
158	170	}

171	183	// create function object f : X -> Y
172	184	f.Dependent(a_x, a_y);
173	185
174		extern bool global_optimize;
175	186	if( global_optimize )
176		{ print_optimize(f, print, "cppad_sparse_jacobian_optimize", size);
177		print = false;
178		}
	187	f.optimize();
179	188
180	189	// calculate the Jacobian sparsity pattern for this function
181		calc_sparsity(sparsity, f);
	190	if( global_boolsparsity )
	191	calc_sparsity(bool_sparsity, f);
	192	else
	193	calc_sparsity(set_sparsity, f);
182	194
183	195	// structure that holds some of the work done by SparseJacobian
184	196	CppAD::sparse_jacobian_work work;
	197	# ifdef CPPAD_COLPACK_SPEED
	198	if( global_colpack )
	199	work.color_method = "colpack";
	200	# endif
185	201
186	202	while(repeat--)
187	203	{ // choose a value for x

189	205
190	206	// calculate the Jacobian at this x
191	207	// (use forward mode because m > n ?)
192		f.SparseJacobianForward(x, sparsity, row, col, jac, work);
	208	if( global_boolsparsity ) n_sweep = f.SparseJacobianForward(
	209	x, bool_sparsity, row, col, jac, work
	210	);
	211	else n_sweep = f.SparseJacobianForward(
	212	x, set_sparsity, row, col, jac, work
	213	);
193	214	for(k = 0; k < K; k++)
194	215	jacobian[ row[k] * n + col[k] ] = jac[k];
195	216	}

-7

speed/double/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2572 2012-11-15 19:43:06Z bradbell $
	0	# $Id: CMakeLists.txt 3122 2014-02-26 03:23:19Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

10	10	# -----------------------------------------------------------------------------
11	11	# Build the speed/double directory tests
12	12	# Inherit environment from ../CMakeList.txt
13
14		# Specifies build type for this directory. Possible values are
15		# empty, Debug, Release, RelWithDebInfo and MinSizeRel
16		SET(CMAKE_BUILD_TYPE RELEASE)
	13	# CMAKE_BUILD_TYPE determined by parent directory
17	14
18	15	# Adds flags to the compiler command line for sources in the current directory
19	16	# and below. This command can be used to add any flags, but it was originally
20	17	# intended to add preprocessor definitions.
21		ADD_DEFINITIONS("-DSPEED_DOUBLE")
	18	ADD_DEFINITIONS("-DCPPAD_DOUBLE_SPEED")
22	19
23	20	# Local include directories to search (not in package_prefix/includdir)
24	21	INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/../src )

-2

speed/double/det_lu.cpp less more

0		/* $Id: det_lu.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_lu.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin double_det_lu.cpp$$
13	13	$spell
	14	onetape
14	15	bool
15	16	cppad
16	17	hpp

38	39	# include <cppad/speed/det_by_lu.hpp>
39	40	# include <cppad/speed/uniform_01.hpp>
40	41
	42	// Note that CppAD uses global_memory at the main program level
	43	extern bool
	44	global_onetape, global_atomic, global_optimize;
	45
41	46	bool link_det_lu(
42	47	size_t size ,
43	48	size_t repeat ,
44	49	CppAD::vector<double> &matrix ,
45	50	CppAD::vector<double> &det )
46	51	{
	52	if(global_onetape\|\|global_atomic\|\|global_optimize)
	53	return false;
47	54	// -----------------------------------------------------
48	55	// setup
49	56	CppAD::det_by_lu<double> Det(size);

-2

speed/double/det_minor.cpp less more

0		/* $Id: det_minor.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_minor.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin double_det_minor.cpp$$
13	13	$spell
	14	onetape
14	15	retape
15	16	bool
16	17	cppad

38	39	# include <cppad/speed/det_by_minor.hpp>
39	40	# include <cppad/speed/uniform_01.hpp>
40	41
	42	// Note that CppAD uses global_memory at the main program level
	43	extern bool
	44	global_onetape, global_atomic, global_optimize;
	45
41	46	bool link_det_minor(
42	47	size_t size ,
43	48	size_t repeat ,
44	49	CppAD::vector<double> &matrix ,
45	50	CppAD::vector<double> &det )
46	51	{
	52	if(global_onetape\|\|global_atomic\|\|global_optimize)
	53	return false;
47	54	// -----------------------------------------------------
48	55	// setup
49	56	CppAD::det_by_minor<double> Det(size);

+12

-9

speed/double/makefile.am less more

0		# $Id: makefile.am 2541 2012-11-06 16:32:36Z bradbell $
	0	# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

9	9	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10	10	# -----------------------------------------------------------------------------
11	11	#
12		# automake input file
	12	# Copy source file so that main.o does not end up in parent directory
	13	BUILT_SOURCES = main.cpp
	14	main.cpp:
	15	cp $(srcdir)/../main.cpp main.cpp
13	16	#
14	17	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
15	18	DEFS =
16	19	#
17		check_PROGRAMS = double
	20	check_PROGRAMS = speed_double
18	21	#
19	22	AM_CPPFLAGS = -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
20	23	#
21	24	# BEGIN OPTIMIZE
22		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_DOUBLE $(CXX_FLAGS)
	25	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_DOUBLE_SPEED $(CXX_FLAGS)
23	26	# END OPTIMIZE
24	27	#
25	28	# BEGIN DEBUG
26		# AM_CXXFLAGS = -g $(CXX_FLAGS) -DSPEED_DOUBLE
	29	# AM_CXXFLAGS = -g $(CXX_FLAGS) -DCPPAD_DOUBLE_SPEED
27	30	# END DEBUG
28	31	#
29	32	LDADD = -lspeed
30	33	AM_LDFLAGS = -L../src
31	34	#
32		double_SOURCES = \
33		../main.cpp \
	35	speed_double_SOURCES = \
	36	main.cpp \
34	37	det_lu.cpp \
35	38	det_minor.cpp \
36	39	mat_mul.cpp \

40	43	sparse_jacobian.cpp
41	44
42	45	test: check
43		./double correct 123
	46	./speed_double correct 123

+185

-124

speed/double/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
50		check_PROGRAMS = double$(EXEEXT)
	77	build_triplet = @build@
	78	host_triplet = @host@
	79	check_PROGRAMS = speed_double$(EXEEXT)
51	80	subdir = speed/double
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

57	87	mkinstalldirs = $(install_sh) -d
58	88	CONFIG_CLEAN_FILES =
59	89	CONFIG_CLEAN_VPATH_FILES =
60		am_double_OBJECTS = main.$(OBJEXT) det_lu.$(OBJEXT) \
	90	am_speed_double_OBJECTS = main.$(OBJEXT) det_lu.$(OBJEXT) \
61	91	det_minor.$(OBJEXT) mat_mul.$(OBJEXT) ode.$(OBJEXT) \
62	92	poly.$(OBJEXT) sparse_hessian.$(OBJEXT) \
63	93	sparse_jacobian.$(OBJEXT)
64		double_OBJECTS = $(am_double_OBJECTS)
65		double_LDADD = $(LDADD)
66		double_DEPENDENCIES =
	94	speed_double_OBJECTS = $(am_speed_double_OBJECTS)
	95	speed_double_LDADD = $(LDADD)
	96	speed_double_DEPENDENCIES =
	97	AM_V_P = $(am__v_P_@AM_V@)
	98	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	99	am__v_P_0 = false
	100	am__v_P_1 = :
	101	AM_V_GEN = $(am__v_GEN_@AM_V@)
	102	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	103	am__v_GEN_0 = @echo " GEN " $@;
	104	am__v_GEN_1 =
	105	AM_V_at = $(am__v_at_@AM_V@)
	106	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	107	am__v_at_0 = @
	108	am__v_at_1 =
67	109	DEFAULT_INCLUDES =
68	110	depcomp = $(SHELL) $(top_srcdir)/depcomp
69	111	am__depfiles_maybe = depfiles
70	112	am__mv = mv -f
71		AM_V_lt = $(am__v_lt_@AM_V@)
72		am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
73		am__v_lt_0 = --silent
74	113	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
75	114	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
76	115	AM_V_CXX = $(am__v_CXX_@AM_V@)
77	116	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
78		am__v_CXX_0 = @echo " CXX " $@;
79		AM_V_at = $(am__v_at_@AM_V@)
80		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
81		am__v_at_0 = @
	117	am__v_CXX_0 = @echo " CXX " $@;
	118	am__v_CXX_1 =
82	119	CXXLD = $(CXX)
83	120	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
84	121	-o $@
85	122	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
86	123	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
87		am__v_CXXLD_0 = @echo " CXXLD " $@;
88		AM_V_GEN = $(am__v_GEN_@AM_V@)
89		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
90		am__v_GEN_0 = @echo " GEN " $@;
91		SOURCES = $(double_SOURCES)
92		DIST_SOURCES = $(double_SOURCES)
	124	am__v_CXXLD_0 = @echo " CXXLD " $@;
	125	am__v_CXXLD_1 =
	126	SOURCES = $(speed_double_SOURCES)
	127	DIST_SOURCES = $(speed_double_SOURCES)
93	128	am__can_run_installinfo = \
94	129	case $$AM_UPDATE_INFO_DIR in \
95	130	n\|no\|NO) false;; \
96	131	*) (install-info --version) >/dev/null 2>&1;; \
97	132	esac
	133	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	134	# Read a list of newline-separated strings from the standard input,
	135	# and print each of them once, without duplicates. Input order is
	136	# not preserved.
	137	am__uniquify_input = $(AWK) '\
	138	BEGIN { nonempty = 0; } \
	139	{ items[$$0] = 1; nonempty = 1; } \
	140	END { if (nonempty) { for (i in items) print i; }; } \
	141	'
	142	# Make sure the list of sources is unique. This is necessary because,
	143	# e.g., the same source file might be shared among _SOURCES variables
	144	# for different programs/libraries.
	145	am__define_uniq_tagged_files = \
	146	list='$(am__tagged_files)'; \
	147	unique=`for i in $$list; do \
	148	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	149	done \| $(am__uniquify_input)`
98	150	ETAGS = etags
99	151	CTAGS = ctags
100	152	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

104	156	ADOLC_DIR = @ADOLC_DIR@
105	157	AMTAR = @AMTAR@
106	158	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	159	AR = @AR@
107	160	AUTOCONF = @AUTOCONF@
108	161	AUTOHEADER = @AUTOHEADER@
109	162	AUTOMAKE = @AUTOMAKE@

125	178	CXX_FLAGS_EIGEN = @CXX_FLAGS_EIGEN@
126	179	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
127	180	CYGPATH_W = @CYGPATH_W@
128
129		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
130		# -----------------------------------------------------------------------------
131		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
132		#
133		# CppAD is distributed under multiple licenses. This distribution is under
134		# the terms of the
135		# GNU General Public License Version 3.
136		#
137		# A copy of this license is included in the COPYING file of this distribution.
138		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
139		# -----------------------------------------------------------------------------
140		#
141		# automake input file
142	181	#
143	182	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
144	183	DEFS =

194	233	abs_srcdir = @abs_srcdir@
195	234	abs_top_builddir = @abs_top_builddir@
196	235	abs_top_srcdir = @abs_top_srcdir@
	236	ac_ct_AR = @ac_ct_AR@
197	237	ac_ct_CC = @ac_ct_CC@
198	238	ac_ct_CXX = @ac_ct_CXX@
199	239	ac_ct_FC = @ac_ct_FC@

204	244	am__tar = @am__tar@
205	245	am__untar = @am__untar@
206	246	bindir = @bindir@
	247	build = @build@
207	248	build_alias = @build_alias@
	249	build_cpu = @build_cpu@
	250	build_os = @build_os@
	251	build_vendor = @build_vendor@
208	252	builddir = @builddir@
209	253	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
210	254	cppad_boostvector = @cppad_boostvector@
211	255	cppad_cflags = @cppad_cflags@
	256	cppad_compiler_has_erf = @cppad_compiler_has_erf@
212	257	cppad_cppadvector = @cppad_cppadvector@
213	258	cppad_description = @cppad_description@
214	259	cppad_eigenvector = @cppad_eigenvector@
	260	cppad_has_colpack = @cppad_has_colpack@
	261	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
215	262	cppad_has_gettimeofday = @cppad_has_gettimeofday@
216	263	cppad_has_nullptr = @cppad_has_nullptr@
	264	cppad_has_rvalue = @cppad_has_rvalue@
217	265	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
218	266	cppad_internal_sparse_set = @cppad_internal_sparse_set@
219	267	cppad_libs = @cppad_libs@
220	268	cppad_max_num_threads = @cppad_max_num_threads@
221	269	cppad_requires = @cppad_requires@
222		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	270	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
223	271	cppad_stdvector = @cppad_stdvector@
224	272	cppad_tape_addr_type = @cppad_tape_addr_type@
225	273	cppad_tape_id_type = @cppad_tape_id_type@

231	279	dvidir = @dvidir@
232	280	eigen_prefix = @eigen_prefix@
233	281	exec_prefix = @exec_prefix@
234		have_ar = @have_ar@
235	282	have_pkg_config = @have_pkg_config@
	283	host = @host@
236	284	host_alias = @host_alias@
	285	host_cpu = @host_cpu@
	286	host_os = @host_os@
	287	host_vendor = @host_vendor@
237	288	htmldir = @htmldir@
238	289	includedir = @includedir@
239	290	infodir = @infodir@

258	309	top_build_prefix = @top_build_prefix@
259	310	top_builddir = @top_builddir@
260	311	top_srcdir = @top_srcdir@
	312
	313	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
	314	# -----------------------------------------------------------------------------
	315	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	316	#
	317	# CppAD is distributed under multiple licenses. This distribution is under
	318	# the terms of the
	319	# GNU General Public License Version 3.
	320	#
	321	# A copy of this license is included in the COPYING file of this distribution.
	322	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	323	# -----------------------------------------------------------------------------
	324	#
	325	# Copy source file so that main.o does not end up in parent directory
	326	BUILT_SOURCES = main.cpp
261	327	#
262	328	AM_CPPFLAGS = -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
263	329	#
264	330	# BEGIN OPTIMIZE
265		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_DOUBLE $(CXX_FLAGS)
	331	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_DOUBLE_SPEED $(CXX_FLAGS)
266	332	# END OPTIMIZE
267	333	#
268	334	# BEGIN DEBUG
269		# AM_CXXFLAGS = -g $(CXX_FLAGS) -DSPEED_DOUBLE
	335	# AM_CXXFLAGS = -g $(CXX_FLAGS) -DCPPAD_DOUBLE_SPEED
270	336	# END DEBUG
271	337	#
272	338	LDADD = -lspeed
273	339	AM_LDFLAGS = -L../src
274	340	#
275		double_SOURCES = \
276		../main.cpp \
	341	speed_double_SOURCES = \
	342	main.cpp \
277	343	det_lu.cpp \
278	344	det_minor.cpp \
279	345	mat_mul.cpp \

282	348	sparse_hessian.cpp \
283	349	sparse_jacobian.cpp
284	350
285		all: all-am
	351	all: $(BUILT_SOURCES)
	352	$(MAKE) $(AM_MAKEFLAGS) all-am
286	353
287	354	.SUFFIXES:
288	355	.SUFFIXES: .cpp .o .obj

319	386
320	387	clean-checkPROGRAMS:
321	388	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
322		double$(EXEEXT): $(double_OBJECTS) $(double_DEPENDENCIES) $(EXTRA_double_DEPENDENCIES)
323		@rm -f double$(EXEEXT)
324		$(AM_V_CXXLD)$(CXXLINK) $(double_OBJECTS) $(double_LDADD) $(LIBS)
	389
	390	speed_double$(EXEEXT): $(speed_double_OBJECTS) $(speed_double_DEPENDENCIES) $(EXTRA_speed_double_DEPENDENCIES)
	391	@rm -f speed_double$(EXEEXT)
	392	$(AM_V_CXXLD)$(CXXLINK) $(speed_double_OBJECTS) $(speed_double_LDADD) $(LIBS)
325	393
326	394	mostlyclean-compile:
327	395	-rm -f *.$(OBJEXT)

339	407	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_jacobian.Po@am__quote@
340	408
341	409	.cpp.o:
342		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
343		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	410	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	411	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	412	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
344	413	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
345	414	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
346	415	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
347	416
348	417	.cpp.obj:
349		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
350		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	418	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	419	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	420	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
351	421	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
352	422	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
353	423	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
354	424
355		main.o: ../main.cpp
356		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.o -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
357		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
358		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.o' libtool=no @AMDEPBACKSLASH@
359		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
360		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
361
362		main.obj: ../main.cpp
363		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.obj -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
364		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
365		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.obj' libtool=no @AMDEPBACKSLASH@
366		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
367		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
368
369		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
370		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
371		unique=`for i in $$list; do \
372		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
373		done \| \
374		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
375		END { if (nonempty) { for (i in files) print i; }; }'`; \
376		mkid -fID $$unique
377		tags: TAGS
378
379		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
380		$(TAGS_FILES) $(LISP)
	425	ID: $(am__tagged_files)
	426	$(am__define_uniq_tagged_files); mkid -fID $$unique
	427	tags: tags-am
	428	TAGS: tags
	429
	430	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
381	431	set x; \
382	432	here=`pwd`; \
383		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
384		unique=`for i in $$list; do \
385		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
386		done \| \
387		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
388		END { if (nonempty) { for (i in files) print i; }; }'`; \
	433	$(am__define_uniq_tagged_files); \
389	434	shift; \
390	435	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
391	436	test -n "$$unique" \|\| unique=$$empty_fix; \

397	442	$$unique; \
398	443	fi; \
399	444	fi
400		ctags: CTAGS
401		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
402		$(TAGS_FILES) $(LISP)
403		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
404		unique=`for i in $$list; do \
405		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
406		done \| \
407		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
408		END { if (nonempty) { for (i in files) print i; }; }'`; \
	445	ctags: ctags-am
	446
	447	CTAGS: ctags
	448	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	449	$(am__define_uniq_tagged_files); \
409	450	test -z "$(CTAGS_ARGS)$$unique" \
410	451	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
411	452	$$unique

414	455	here=`$(am__cd) $(top_builddir) && pwd` \
415	456	&& $(am__cd) $(top_srcdir) \
416	457	&& gtags -i $(GTAGS_ARGS) "$$here"
	458	cscopelist: cscopelist-am
	459
	460	cscopelist-am: $(am__tagged_files)
	461	list='$(am__tagged_files)'; \
	462	case "$(srcdir)" in \
	463	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	464	*) sdir=$(subdir)/$(srcdir) ;; \
	465	esac; \
	466	for i in $$list; do \
	467	if test -f "$$i"; then \
	468	echo "$(subdir)/$$i"; \
	469	else \
	470	echo "$$sdir/$$i"; \
	471	fi; \
	472	done >> $(top_builddir)/cscope.files
417	473
418	474	distclean-tags:
419	475	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

450	506	done
451	507	check-am: all-am
452	508	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
453		check: check-am
	509	check: $(BUILT_SOURCES)
	510	$(MAKE) $(AM_MAKEFLAGS) check-am
454	511	all-am: makefile
455	512	installdirs:
456		install: install-am
	513	install: $(BUILT_SOURCES)
	514	$(MAKE) $(AM_MAKEFLAGS) install-am
457	515	install-exec: install-exec-am
458	516	install-data: install-data-am
459	517	uninstall: uninstall-am

483	541	maintainer-clean-generic:
484	542	@echo "This command is intended for maintainers to use"
485	543	@echo "it deletes files that may require special tools to rebuild."
	544	-test -z "$(BUILT_SOURCES)" \|\| rm -f $(BUILT_SOURCES)
486	545	clean: clean-am
487	546
488	547	clean-am: clean-checkPROGRAMS clean-generic mostlyclean-am

552	611
553	612	uninstall-am:
554	613
555		.MAKE: check-am install-am install-strip
556
557		.PHONY: CTAGS GTAGS all all-am check check-am clean \
558		clean-checkPROGRAMS clean-generic ctags distclean \
559		distclean-compile distclean-generic distclean-tags distdir dvi \
560		dvi-am html html-am info info-am install install-am \
561		install-data install-data-am install-dvi install-dvi-am \
562		install-exec install-exec-am install-html install-html-am \
563		install-info install-info-am install-man install-pdf \
564		install-pdf-am install-ps install-ps-am install-strip \
565		installcheck installcheck-am installdirs maintainer-clean \
566		maintainer-clean-generic mostlyclean mostlyclean-compile \
567		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
568		uninstall-am
569
	614	.MAKE: all check check-am install install-am install-strip
	615
	616	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	617	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	618	distclean distclean-compile distclean-generic distclean-tags \
	619	distdir dvi dvi-am html html-am info info-am install \
	620	install-am install-data install-data-am install-dvi \
	621	install-dvi-am install-exec install-exec-am install-html \
	622	install-html-am install-info install-info-am install-man \
	623	install-pdf install-pdf-am install-ps install-ps-am \
	624	install-strip installcheck installcheck-am installdirs \
	625	maintainer-clean maintainer-clean-generic mostlyclean \
	626	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	627	tags tags-am uninstall uninstall-am
	628
	629	main.cpp:
	630	cp $(srcdir)/../main.cpp main.cpp
570	631
571	632	test: check
572		./double correct 123
	633	./speed_double correct 123
573	634
574	635	# Tell versions [3.59,3.63) of GNU make to not export all variables.
575	636	# Otherwise a system limit (for SysV at least) may be exceeded.

-2

speed/double/mat_mul.cpp less more

0		/* $Id: mat_mul.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: mat_mul.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin double_mat_mul.cpp$$
13	13	$spell
	14	onetape
14	15	CppAD
15	16	cppad
16	17	mul_mat

39	40	# include <cppad/speed/mat_sum_sq.hpp>
40	41	# include <cppad/speed/uniform_01.hpp>
41	42
	43	// Note that CppAD uses global_memory at the main program level
	44	extern bool
	45	global_onetape, global_atomic, global_optimize;
	46
42	47	bool link_mat_mul(
43	48	size_t size ,
44	49	size_t repeat ,

47	52	CppAD::vector<double>& dz
48	53	)
49	54	{
	55	if(global_onetape\|\|global_atomic\|\|global_optimize)
	56	return false;
50	57	// -----------------------------------------------------
51	58	size_t n = size * size; // number of independent variables
52	59	CppAD::vector<double> y(n);

+10

-4

speed/double/ode.cpp less more

0		/* $Id: ode.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: ode.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin double_ode.cpp$$
13	13	$spell
	14	onetape
14	15	Jacobian
15	16	CppAD
16	17	cppad

41	42	# include <cppad/speed/ode_evaluate.hpp>
42	43	# include <cppad/speed/uniform_01.hpp>
43	44
	45	// Note that CppAD uses global_memory at the main program level
	46	extern bool
	47	global_onetape, global_atomic, global_optimize;
	48
44	49	bool link_ode(
45	50	size_t size ,
46	51	size_t repeat ,

48	53	CppAD::vector<double> &jacobian
49	54	)
50	55	{
51		assert( x.size() == size );
52
	56	if(global_onetape\|\|global_atomic\|\|global_optimize)
	57	return false;
53	58	// -------------------------------------------------------------
54	59	// setup
	60	assert( x.size() == size );
55	61
56	62	size_t n = size;
57	63

-2

speed/double/poly.cpp less more

0		/* $Id: poly.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: poly.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin double_poly.cpp$$
13	13	$spell
	14	onetape
14	15	retape
15	16	bool
16	17	cppad

36	37	# include <cppad/cppad.hpp>
37	38	# include <cppad/speed/uniform_01.hpp>
38	39
	40	// Note that CppAD uses global_memory at the main program level
	41	extern bool
	42	global_onetape, global_atomic, global_optimize;
	43
39	44	bool link_poly(
40	45	size_t size ,
41	46	size_t repeat ,

43	48	CppAD::vector<double> &z , // polynomial argument value
44	49	CppAD::vector<double> &p ) // second derivative w.r.t z
45	50	{
	51	if(global_onetape\|\|global_atomic\|\|global_optimize)
	52	return false;
46	53	// -----------------------------------------------------
47	54	// setup
48	55

+14

-6

speed/double/sparse_hessian.cpp less more

0		/* $Id: sparse_hessian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: sparse_hessian.cpp 3136 2014-03-02 11:54:07Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin double_sparse_hessian.cpp$$
13	13	$spell
	14	onetape
	15	boolsparsity
14	16	const
15	17	hes
16	18	bool

38	40	# include <cppad/speed/uniform_01.hpp>
39	41	# include <cppad/speed/sparse_hes_fun.hpp>
40	42
	43	// Note that CppAD uses global_memory at the main program level
	44	extern bool
	45	global_onetape, global_atomic, global_optimize, global_boolsparsity;
	46
41	47	bool link_sparse_hessian(
42	48	size_t size ,
43	49	size_t repeat ,
44		CppAD::vector<double> &x ,
45		const CppAD::vector<size_t> &row ,
46		const CppAD::vector<size_t> &col ,
47		CppAD::vector<double> &hessian )
	50	const CppAD::vector<size_t>& row ,
	51	const CppAD::vector<size_t>& col ,
	52	CppAD::vector<double>& x ,
	53	CppAD::vector<double>& hessian )
48	54	{
	55	if(global_onetape\|\|global_atomic\|\|global_optimize\|\|global_boolsparsity)
	56	return false;
49	57	// -----------------------------------------------------
50	58	// setup
51	59	using CppAD::vector;

+24

-31

speed/double/sparse_jacobian.cpp less more

0		/* $Id: sparse_jacobian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: sparse_jacobian.cpp 3138 2014-03-02 18:46:11Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin double_sparse_jacobian.cpp$$
13	13	$spell
	14	const
	15	onetape
	16	boolsparsity
14	17	yp
15	18	jac
16	19	Jacobian

21	24	CppAD
22	25	cmath
23	26	exp
24		tmp
25	27	std
26	28	$$
27	29

44	46	# include <cppad/speed/uniform_01.hpp>
45	47	# include <cppad/speed/sparse_jac_fun.hpp>
46	48
	49	// Note that CppAD uses global_memory at the main program level
	50	extern bool
	51	global_onetape, global_atomic, global_optimize, global_boolsparsity;
	52
47	53	bool link_sparse_jacobian(
48		size_t size ,
49		size_t repeat ,
50		size_t m ,
51		CppAD::vector<double> &x ,
52		CppAD::vector<size_t> &row ,
53		CppAD::vector<size_t> &col ,
54		CppAD::vector<double> &jacobian )
	54	size_t size ,
	55	size_t repeat ,
	56	size_t m ,
	57	const CppAD::vector<size_t>& row ,
	58	const CppAD::vector<size_t>& col ,
	59	CppAD::vector<double>& x ,
	60	CppAD::vector<double>& jacobian ,
	61	size_t& n_sweep )
55	62	{
	63	if(global_onetape\|\|global_atomic\|\|global_optimize\|\|global_boolsparsity)
	64	return false;
56	65	// -----------------------------------------------------
57	66	// setup
58	67	using CppAD::vector;
59		size_t i, k;
	68	size_t i;
60	69	size_t order = 0; // order for computing function value
61	70	size_t n = size; // argument space dimension
62		size_t K = row.size(); // size of index vectors
63	71	vector<double> yp(m); // function value yp = f(x)
64	72
65		// temporaries
66		vector<double> tmp(2 * K);
67
68		// choose a value for x
69		CppAD::uniform_01(n, x);
	73	// ------------------------------------------------------
	74	while(repeat--)
	75	{ // choose a value for x
	76	CppAD::uniform_01(n, x);
70	77
71		// ------------------------------------------------------
72
73		while(repeat--)
74		{
75		// get the next set of indices
76		CppAD::uniform_01(2 * K, tmp);
77		for(k = 0; k < K; k++)
78		{ row[k] = size_t( n * tmp[k] );
79		row[k] = std::min(n-1, row[k]);
80		//
81		col[k] = size_t( n * tmp[k + K] );
82		col[k] = std::min(n-1, col[k]);
83		}
84
85	78	// computation of the function
86	79	CppAD::sparse_jac_fun<double>(m, n, x, row, col, order, yp);
87	80	}

-6

speed/example/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2733 2013-01-08 01:59:14Z bradbell $
	0	# $Id: CMakeLists.txt 3122 2014-02-26 03:23:19Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

10	10	# -----------------------------------------------------------------------------
11	11	# Build the speed/cppad directory tests
12	12	# Inherit environment from ../CMakeList.txt
13
14		# Specifies build type for this directory. Possible values are
15		# empty, Debug, Release, RelWithDebInfo and MinSizeRel
16		SET(CMAKE_BUILD_TYPE RELEASE)
	13	# CMAKE_BUILD_TYPE determined by parent directory
17	14
18	15	# add_executable(<name> [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL]
19	16	# source1 source2 ... sourceN

-3

speed/example/example.cpp less more

0		/* $Id: example.cpp 2683 2012-12-30 18:17:03Z bradbell $ */
	0	/* $Id: example.cpp 3114 2014-02-22 16:20:39Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

22	22	$section Run the Speed Examples$$
23	23
24	24	$head Running Tests$$
25		To build this program and run its correctness tests see $cref cppad_test$$.
	25	To build this program and run its correctness tests see $cref cmake_check$$.
26	26
27	27
28	28	$code

-4

speed/example/makefile.am less more

0		# $Id: makefile.am 2733 2013-01-08 01:59:14Z bradbell $
	0	# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3	#

16	16	EXTRA_DIST = \
17	17	speed_program.cpp
18	18	#
19		check_PROGRAMS = example
	19	check_PROGRAMS = speed_example
20	20	#
21	21	AM_CPPFLAGS = -I. -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
22	22	#

24	24	#
25	25	LDADD = -lspeed
26	26	AM_LDFLAGS = -L../src
27		example_SOURCES = \
	27	speed_example_SOURCES = \
28	28	example.cpp \
29	29	det_by_lu.cpp \
30	30	det_by_minor.cpp \

39	39	../src/microsoft_timer.cpp
40	40
41	41	test: check
42		./example
	42	./speed_example

+172

-106

speed/example/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
50		check_PROGRAMS = example$(EXEEXT)
	77	build_triplet = @build@
	78	host_triplet = @host@
	79	check_PROGRAMS = speed_example$(EXEEXT)
51	80	subdir = speed/example
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

57	87	mkinstalldirs = $(install_sh) -d
58	88	CONFIG_CLEAN_FILES =
59	89	CONFIG_CLEAN_VPATH_FILES =
60		am_example_OBJECTS = example.$(OBJEXT) det_by_lu.$(OBJEXT) \
	90	am__dirstamp = $(am__leading_dot)dirstamp
	91	am_speed_example_OBJECTS = example.$(OBJEXT) det_by_lu.$(OBJEXT) \
61	92	det_by_minor.$(OBJEXT) det_of_minor.$(OBJEXT) \
62	93	elapsed_seconds.$(OBJEXT) mat_sum_sq.$(OBJEXT) \
63	94	ode_evaluate.$(OBJEXT) sparse_hes_fun.$(OBJEXT) \
64	95	sparse_jac_fun.$(OBJEXT) speed_test.$(OBJEXT) \
65		time_test.$(OBJEXT) microsoft_timer.$(OBJEXT)
66		example_OBJECTS = $(am_example_OBJECTS)
67		example_LDADD = $(LDADD)
68		example_DEPENDENCIES =
	96	time_test.$(OBJEXT) ../src/microsoft_timer.$(OBJEXT)
	97	speed_example_OBJECTS = $(am_speed_example_OBJECTS)
	98	speed_example_LDADD = $(LDADD)
	99	speed_example_DEPENDENCIES =
	100	AM_V_P = $(am__v_P_@AM_V@)
	101	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	102	am__v_P_0 = false
	103	am__v_P_1 = :
	104	AM_V_GEN = $(am__v_GEN_@AM_V@)
	105	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	106	am__v_GEN_0 = @echo " GEN " $@;
	107	am__v_GEN_1 =
	108	AM_V_at = $(am__v_at_@AM_V@)
	109	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	110	am__v_at_0 = @
	111	am__v_at_1 =
69	112	DEFAULT_INCLUDES =
70	113	depcomp = $(SHELL) $(top_srcdir)/depcomp
71	114	am__depfiles_maybe = depfiles
72	115	am__mv = mv -f
73		AM_V_lt = $(am__v_lt_@AM_V@)
74		am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
75		am__v_lt_0 = --silent
76	116	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
77	117	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
78	118	AM_V_CXX = $(am__v_CXX_@AM_V@)
79	119	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
80		am__v_CXX_0 = @echo " CXX " $@;
81		AM_V_at = $(am__v_at_@AM_V@)
82		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
83		am__v_at_0 = @
	120	am__v_CXX_0 = @echo " CXX " $@;
	121	am__v_CXX_1 =
84	122	CXXLD = $(CXX)
85	123	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
86	124	-o $@
87	125	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
88	126	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
89		am__v_CXXLD_0 = @echo " CXXLD " $@;
90		AM_V_GEN = $(am__v_GEN_@AM_V@)
91		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
92		am__v_GEN_0 = @echo " GEN " $@;
93		SOURCES = $(example_SOURCES)
94		DIST_SOURCES = $(example_SOURCES)
	127	am__v_CXXLD_0 = @echo " CXXLD " $@;
	128	am__v_CXXLD_1 =
	129	SOURCES = $(speed_example_SOURCES)
	130	DIST_SOURCES = $(speed_example_SOURCES)
95	131	am__can_run_installinfo = \
96	132	case $$AM_UPDATE_INFO_DIR in \
97	133	n\|no\|NO) false;; \
98	134	*) (install-info --version) >/dev/null 2>&1;; \
99	135	esac
	136	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	137	# Read a list of newline-separated strings from the standard input,
	138	# and print each of them once, without duplicates. Input order is
	139	# not preserved.
	140	am__uniquify_input = $(AWK) '\
	141	BEGIN { nonempty = 0; } \
	142	{ items[$$0] = 1; nonempty = 1; } \
	143	END { if (nonempty) { for (i in items) print i; }; } \
	144	'
	145	# Make sure the list of sources is unique. This is necessary because,
	146	# e.g., the same source file might be shared among _SOURCES variables
	147	# for different programs/libraries.
	148	am__define_uniq_tagged_files = \
	149	list='$(am__tagged_files)'; \
	150	unique=`for i in $$list; do \
	151	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	152	done \| $(am__uniquify_input)`
100	153	ETAGS = etags
101	154	CTAGS = ctags
102	155	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

106	159	ADOLC_DIR = @ADOLC_DIR@
107	160	AMTAR = @AMTAR@
108	161	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	162	AR = @AR@
109	163	AUTOCONF = @AUTOCONF@
110	164	AUTOHEADER = @AUTOHEADER@
111	165	AUTOMAKE = @AUTOMAKE@

128	182	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
129	183	CYGPATH_W = @CYGPATH_W@
130	184
131		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	185	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
132	186	# -----------------------------------------------------------------------------
133	187	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
134	188	#

195	249	abs_srcdir = @abs_srcdir@
196	250	abs_top_builddir = @abs_top_builddir@
197	251	abs_top_srcdir = @abs_top_srcdir@
	252	ac_ct_AR = @ac_ct_AR@
198	253	ac_ct_CC = @ac_ct_CC@
199	254	ac_ct_CXX = @ac_ct_CXX@
200	255	ac_ct_FC = @ac_ct_FC@

205	260	am__tar = @am__tar@
206	261	am__untar = @am__untar@
207	262	bindir = @bindir@
	263	build = @build@
208	264	build_alias = @build_alias@
	265	build_cpu = @build_cpu@
	266	build_os = @build_os@
	267	build_vendor = @build_vendor@
209	268	builddir = @builddir@
210	269	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
211	270	cppad_boostvector = @cppad_boostvector@
212	271	cppad_cflags = @cppad_cflags@
	272	cppad_compiler_has_erf = @cppad_compiler_has_erf@
213	273	cppad_cppadvector = @cppad_cppadvector@
214	274	cppad_description = @cppad_description@
215	275	cppad_eigenvector = @cppad_eigenvector@
	276	cppad_has_colpack = @cppad_has_colpack@
	277	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
216	278	cppad_has_gettimeofday = @cppad_has_gettimeofday@
217	279	cppad_has_nullptr = @cppad_has_nullptr@
	280	cppad_has_rvalue = @cppad_has_rvalue@
218	281	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
219	282	cppad_internal_sparse_set = @cppad_internal_sparse_set@
220	283	cppad_libs = @cppad_libs@
221	284	cppad_max_num_threads = @cppad_max_num_threads@
222	285	cppad_requires = @cppad_requires@
223		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	286	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
224	287	cppad_stdvector = @cppad_stdvector@
225	288	cppad_tape_addr_type = @cppad_tape_addr_type@
226	289	cppad_tape_id_type = @cppad_tape_id_type@

232	295	dvidir = @dvidir@
233	296	eigen_prefix = @eigen_prefix@
234	297	exec_prefix = @exec_prefix@
235		have_ar = @have_ar@
236	298	have_pkg_config = @have_pkg_config@
	299	host = @host@
237	300	host_alias = @host_alias@
	301	host_cpu = @host_cpu@
	302	host_os = @host_os@
	303	host_vendor = @host_vendor@
238	304	htmldir = @htmldir@
239	305	includedir = @includedir@
240	306	infodir = @infodir@

270	336	#
271	337	LDADD = -lspeed
272	338	AM_LDFLAGS = -L../src
273		example_SOURCES = \
	339	speed_example_SOURCES = \
274	340	example.cpp \
275	341	det_by_lu.cpp \
276	342	det_by_minor.cpp \

321	387
322	388	clean-checkPROGRAMS:
323	389	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
324		example$(EXEEXT): $(example_OBJECTS) $(example_DEPENDENCIES) $(EXTRA_example_DEPENDENCIES)
325		@rm -f example$(EXEEXT)
326		$(AM_V_CXXLD)$(CXXLINK) $(example_OBJECTS) $(example_LDADD) $(LIBS)
	390	../src/$(am__dirstamp):
	391	@$(MKDIR_P) ../src
	392	@: > ../src/$(am__dirstamp)
	393	../src/$(DEPDIR)/$(am__dirstamp):
	394	@$(MKDIR_P) ../src/$(DEPDIR)
	395	@: > ../src/$(DEPDIR)/$(am__dirstamp)
	396	../src/microsoft_timer.$(OBJEXT): ../src/$(am__dirstamp) \
	397	../src/$(DEPDIR)/$(am__dirstamp)
	398
	399	speed_example$(EXEEXT): $(speed_example_OBJECTS) $(speed_example_DEPENDENCIES) $(EXTRA_speed_example_DEPENDENCIES)
	400	@rm -f speed_example$(EXEEXT)
	401	$(AM_V_CXXLD)$(CXXLINK) $(speed_example_OBJECTS) $(speed_example_LDADD) $(LIBS)
327	402
328	403	mostlyclean-compile:
329	404	-rm -f *.$(OBJEXT)
	405	-rm -f ../src/*.$(OBJEXT)
330	406
331	407	distclean-compile:
332	408	-rm -f *.tab.c
333	409
	410	@AMDEP_TRUE@@am__include@ @am__quote@../src/$(DEPDIR)/microsoft_timer.Po@am__quote@
334	411	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/det_by_lu.Po@am__quote@
335	412	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/det_by_minor.Po@am__quote@
336	413	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/det_of_minor.Po@am__quote@
337	414	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elapsed_seconds.Po@am__quote@
338	415	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/example.Po@am__quote@
339	416	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mat_sum_sq.Po@am__quote@
340		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/microsoft_timer.Po@am__quote@
341	417	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ode_evaluate.Po@am__quote@
342	418	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_hes_fun.Po@am__quote@
343	419	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_jac_fun.Po@am__quote@

345	421	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/time_test.Po@am__quote@
346	422
347	423	.cpp.o:
348		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
349		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	424	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	425	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	426	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
350	427	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
351	428	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
352	429	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
353	430
354	431	.cpp.obj:
355		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
356		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	432	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	433	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	434	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
357	435	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
358	436	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
359	437	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
360	438
361		microsoft_timer.o: ../src/microsoft_timer.cpp
362		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT microsoft_timer.o -MD -MP -MF $(DEPDIR)/microsoft_timer.Tpo -c -o microsoft_timer.o `test -f '../src/microsoft_timer.cpp' \|\| echo '$(srcdir)/'`../src/microsoft_timer.cpp
363		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/microsoft_timer.Tpo $(DEPDIR)/microsoft_timer.Po
364		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/microsoft_timer.cpp' object='microsoft_timer.o' libtool=no @AMDEPBACKSLASH@
365		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
366		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o microsoft_timer.o `test -f '../src/microsoft_timer.cpp' \|\| echo '$(srcdir)/'`../src/microsoft_timer.cpp
367
368		microsoft_timer.obj: ../src/microsoft_timer.cpp
369		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT microsoft_timer.obj -MD -MP -MF $(DEPDIR)/microsoft_timer.Tpo -c -o microsoft_timer.obj `if test -f '../src/microsoft_timer.cpp'; then $(CYGPATH_W) '../src/microsoft_timer.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/microsoft_timer.cpp'; fi`
370		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/microsoft_timer.Tpo $(DEPDIR)/microsoft_timer.Po
371		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/microsoft_timer.cpp' object='microsoft_timer.obj' libtool=no @AMDEPBACKSLASH@
372		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
373		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o microsoft_timer.obj `if test -f '../src/microsoft_timer.cpp'; then $(CYGPATH_W) '../src/microsoft_timer.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/microsoft_timer.cpp'; fi`
374
375		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
376		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
377		unique=`for i in $$list; do \
378		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
379		done \| \
380		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
381		END { if (nonempty) { for (i in files) print i; }; }'`; \
382		mkid -fID $$unique
383		tags: TAGS
384
385		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
386		$(TAGS_FILES) $(LISP)
	439	ID: $(am__tagged_files)
	440	$(am__define_uniq_tagged_files); mkid -fID $$unique
	441	tags: tags-am
	442	TAGS: tags
	443
	444	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
387	445	set x; \
388	446	here=`pwd`; \
389		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
390		unique=`for i in $$list; do \
391		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
392		done \| \
393		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
394		END { if (nonempty) { for (i in files) print i; }; }'`; \
	447	$(am__define_uniq_tagged_files); \
395	448	shift; \
396	449	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
397	450	test -n "$$unique" \|\| unique=$$empty_fix; \

403	456	$$unique; \
404	457	fi; \
405	458	fi
406		ctags: CTAGS
407		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
408		$(TAGS_FILES) $(LISP)
409		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
410		unique=`for i in $$list; do \
411		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
412		done \| \
413		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
414		END { if (nonempty) { for (i in files) print i; }; }'`; \
	459	ctags: ctags-am
	460
	461	CTAGS: ctags
	462	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	463	$(am__define_uniq_tagged_files); \
415	464	test -z "$(CTAGS_ARGS)$$unique" \
416	465	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
417	466	$$unique

420	469	here=`$(am__cd) $(top_builddir) && pwd` \
421	470	&& $(am__cd) $(top_srcdir) \
422	471	&& gtags -i $(GTAGS_ARGS) "$$here"
	472	cscopelist: cscopelist-am
	473
	474	cscopelist-am: $(am__tagged_files)
	475	list='$(am__tagged_files)'; \
	476	case "$(srcdir)" in \
	477	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	478	*) sdir=$(subdir)/$(srcdir) ;; \
	479	esac; \
	480	for i in $$list; do \
	481	if test -f "$$i"; then \
	482	echo "$(subdir)/$$i"; \
	483	else \
	484	echo "$$sdir/$$i"; \
	485	fi; \
	486	done >> $(top_builddir)/cscope.files
423	487
424	488	distclean-tags:
425	489	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

485	549	distclean-generic:
486	550	-test -z "$(CONFIG_CLEAN_FILES)" \|\| rm -f $(CONFIG_CLEAN_FILES)
487	551	-test . = "$(srcdir)" \|\| test -z "$(CONFIG_CLEAN_VPATH_FILES)" \|\| rm -f $(CONFIG_CLEAN_VPATH_FILES)
	552	-rm -f ../src/$(DEPDIR)/$(am__dirstamp)
	553	-rm -f ../src/$(am__dirstamp)
488	554
489	555	maintainer-clean-generic:
490	556	@echo "This command is intended for maintainers to use"

494	560	clean-am: clean-checkPROGRAMS clean-generic mostlyclean-am
495	561
496	562	distclean: distclean-am
497		-rm -rf ./$(DEPDIR)
	563	-rm -rf ../src/$(DEPDIR) ./$(DEPDIR)
498	564	-rm -f makefile
499	565	distclean-am: clean-am distclean-compile distclean-generic \
500	566	distclean-tags

540	606	installcheck-am:
541	607
542	608	maintainer-clean: maintainer-clean-am
543		-rm -rf ./$(DEPDIR)
	609	-rm -rf ../src/$(DEPDIR) ./$(DEPDIR)
544	610	-rm -f makefile
545	611	maintainer-clean-am: distclean-am maintainer-clean-generic
546	612

560	626
561	627	.MAKE: check-am install-am install-strip
562	628
563		.PHONY: CTAGS GTAGS all all-am check check-am clean \
564		clean-checkPROGRAMS clean-generic ctags distclean \
565		distclean-compile distclean-generic distclean-tags distdir dvi \
566		dvi-am html html-am info info-am install install-am \
567		install-data install-data-am install-dvi install-dvi-am \
568		install-exec install-exec-am install-html install-html-am \
569		install-info install-info-am install-man install-pdf \
570		install-pdf-am install-ps install-ps-am install-strip \
571		installcheck installcheck-am installdirs maintainer-clean \
572		maintainer-clean-generic mostlyclean mostlyclean-compile \
573		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
574		uninstall-am
	629	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	630	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	631	distclean distclean-compile distclean-generic distclean-tags \
	632	distdir dvi dvi-am html html-am info info-am install \
	633	install-am install-data install-data-am install-dvi \
	634	install-dvi-am install-exec install-exec-am install-html \
	635	install-html-am install-info install-info-am install-man \
	636	install-pdf install-pdf-am install-ps install-ps-am \
	637	install-strip installcheck installcheck-am installdirs \
	638	maintainer-clean maintainer-clean-generic mostlyclean \
	639	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	640	tags tags-am uninstall uninstall-am
575	641
576	642
577	643	test: check
578		./example
	644	./speed_example
579	645
580	646	# Tell versions [3.59,3.63) of GNU make to not export all variables.
581	647	# Otherwise a system limit (for SysV at least) may be exceeded.

+11

-9

speed/example/speed_test.cpp less more

0		/* $Id: speed_test.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: speed_test.cpp 3094 2014-02-15 22:51:31Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

57	57	{ i = size;;
58	58	while(i)
59	59	{ --i;
60		c[i] = a[i] + b[i];
	60	c[i] = a[i] * b[i];
61	61	}
62	62	}
63	63	// teardown

72	72
73	73	// size of the test cases
74	74	std::vector<size_t> size_vec(2);
75		size_vec[0] = 10;
76		size_vec[1] = 20;
	75	size_vec[0] = 40;
	76	size_vec[1] = 80;
77	77
78		// use a small amout of time (we do not need accurate results)
79		double time_min = .2;
	78	// minimum amount of time to run test
	79	double time_min = 0.5;
80	80
81	81	// run the test cases
82	82	std::vector<size_t> rate_vec(2);

88	88
89	89	// for this case, time should be linear w.r.t size
90	90	double check = double(size_vec[1]) * time_0 / double(size_vec[0]);
91		double rel_diff = std::abs(check - time_1) / time_1;
92		ok &= (rel_diff <= .1);
	91	double rel_diff = (check - time_1) / time_1;
	92	ok &= (std::fabs(rel_diff) <= .1);
	93	if( ! ok )
	94	std::cout << std::endl << "rel_diff = " << rel_diff << std::endl;
93	95
94	96	return ok;
95	97	}

+10

-8

speed/example/time_test.cpp less more

0		/* $Id: time_test.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: time_test.cpp 3094 2014-02-15 22:51:31Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

61	61	{ i = size_;
62	62	while(i)
63	63	{ --i;
64		c[i] = a[i] + b[i];
	64	c[i] = a[i] * b[i];
65	65	}
66	66	}
67	67	// teardown

74	74	bool time_test(void)
75	75	{ bool ok = true;
76	76
77		// use a small amount of time (we do not need accurate results)
78		double time_min = .2;
	77	// minimum amount of time to run test
	78	double time_min = 0.5;
79	79
80	80	// size of first test case
81		size_ = 10;
	81	size_ = 20;
82	82
83	83	// run the first test case
84	84	double time_first = CppAD::time_test(test, time_min);

90	90	double time_second = CppAD::time_test(test, time_min);
91	91
92	92	// for this case, time should be linear w.r.t size
93		double rel_diff = std::abs(1. - 2. * time_first / time_second );
94		ok &= (rel_diff <= .1);
	93	double rel_diff = 1. - 2. * time_first / time_second;
	94	ok &= (std::fabs(rel_diff) <= .1);
	95	if( ! ok )
	96	std::cout << std::endl << "rel_diff = " << rel_diff << std::endl;
95	97
96	98	return ok;
97	99	}

-7

speed/fadbad/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2572 2012-11-15 19:43:06Z bradbell $
	0	# $Id: CMakeLists.txt 3122 2014-02-26 03:23:19Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

10	10	# -----------------------------------------------------------------------------
11	11	# Build the speed/fadbad directory tests
12	12	# Inherit environment from ../CMakeList.txt
	13	# CMAKE_BUILD_TYPE determined by parent directory
13	14
14	15	# assert fadbad_prefix is defined
15	16	IF ( NOT fadbad_prefix )

18	19	)
19	20	ENDIF ( NOT fadbad_prefix )
20	21
21		# Specifies build type for this directory. Possible values are
22		# empty, Debug, Release, RelWithDebInfo and MinSizeRel
23		SET(CMAKE_BUILD_TYPE RELEASE)
24
25	22	# Adds flags to the compiler command line for sources in the current directory
26	23	# and below. This command can be used to add any flags, but it was originally
27	24	# intended to add preprocessor definitions.
28		ADD_DEFINITIONS("-DSPEED_FADBAD")
	25	ADD_DEFINITIONS("-DCPPAD_FADBAD_SPEED")
29	26
30	27	# Local include directories to search (not in package_prefix/includdir)
31	28	INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/../src )

+12

-9

speed/fadbad/det_lu.cpp less more

0		/* $Id: det_lu.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_lu.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin fadbad_det_lu.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	cppad
16	16	std
17	17	Lu

46	46	# include <cppad/speed/uniform_01.hpp>
47	47	# include <cppad/vector.hpp>
48	48
	49	// list of possible options
	50	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	51
49	52	bool link_det_lu(
50	53	size_t size ,
51	54	size_t repeat ,
52		CppAD::vector<double> &matrix ,
53		CppAD::vector<double> &gradient )
	55	CppAD::vector<double> &matrix ,
	56	CppAD::vector<double> &gradient )
54	57	{
55	58	// speed test global option values
56		extern bool global_retape, global_atomic, global_optimize;
57		if( ! global_retape \|\| global_optimize \|\| global_atomic )
	59	if( global_onetape \|\| global_atomic )
58	60	return false;
59
	61	if( global_memory \|\| global_optimize )
	62	return false;
60	63	// -----------------------------------------------------
61	64	// setup
62
	65	//
63	66	// object for computing determinant
64	67	typedef fadbad::B<double> ADScalar;
65	68	typedef CppAD::vector<ADScalar> ADVector;

+11

-7

speed/fadbad/det_minor.cpp less more

0		/* $Id: det_minor.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_minor.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin fadbad_det_minor.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	cppad
16	16	std
17	17	Fadbad

44	44	# include <cppad/speed/det_by_minor.hpp>
45	45	# include <cppad/speed/uniform_01.hpp>
46	46	# include <cppad/vector.hpp>
	47
	48	// list of possible options
	49	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	50
47	51	bool link_det_minor(
48	52	size_t size ,
49	53	size_t repeat ,

51	55	CppAD::vector<double> &gradient )
52	56	{
53	57	// speed test global option values
54		extern bool global_retape, global_atomic, global_optimize;
55		if( ! global_retape \|\| global_atomic \|\| global_optimize )
56		return false;
57
	58	if( global_atomic )
	59	return false;
	60	if( global_memory \|\| global_onetape \|\| global_optimize )
	61	return false;
58	62	// -----------------------------------------------------
59	63	// setup
60	64

+13

-9

speed/fadbad/makefile.am less more

0		# $Id: makefile.am 2527 2012-10-31 07:12:36Z bradbell $
	0	# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

9	9	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10	10	# -----------------------------------------------------------------------------
11	11	#
12		# automake input file
	12	# Copy source file so that main.o does not end up in parent directory
	13	BUILT_SOURCES = main.cpp
	14	main.cpp:
	15	cp $(srcdir)/../main.cpp main.cpp
	16	#
13	17	#
14	18	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
15	19	DEFS =
16	20	#
17		check_PROGRAMS = fadbad
	21	check_PROGRAMS = speed_fadbad
18	22	#
19	23	AM_CPPFLAGS = \
20	24	-I$(top_srcdir) \

24	28	#
25	29	# BEGIN OPTIMIZE
26	30	# Use special version of CXX_FLAGS with -Wshadow removed (if present).
27		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_FADBAD $(CXX_FLAGS_FADBAD)
	31	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_FADBAD_SPEED $(CXX_FLAGS_FADBAD)
28	32	# END OPTIMIZE
29	33	#
30	34	# BEGIN DEBUG
31		# AM_CXXFLAGS = -g -DSPEED_FADBAD $(CXX_FLAGS_FADBAD)
	35	# AM_CXXFLAGS = -g -DCPPAD_FADBAD_SPEED $(CXX_FLAGS_FADBAD)
32	36	# END DEBUG
33	37	#
34	38	LDADD = -lspeed
35	39	AM_LDFLAGS = -L../src
36	40	#
37		fadbad_SOURCES = \
38		../main.cpp \
	41	speed_fadbad_SOURCES = \
	42	main.cpp \
39	43	det_lu.cpp \
40	44	det_minor.cpp \
41	45	mat_mul.cpp \

45	49	sparse_jacobian.cpp
46	50
47	51	test: check
48		./fadbad correct 123 retape
	52	./speed_fadbad correct 123

+186

-124

speed/fadbad/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
50		check_PROGRAMS = fadbad$(EXEEXT)
	77	build_triplet = @build@
	78	host_triplet = @host@
	79	check_PROGRAMS = speed_fadbad$(EXEEXT)
51	80	subdir = speed/fadbad
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

57	87	mkinstalldirs = $(install_sh) -d
58	88	CONFIG_CLEAN_FILES =
59	89	CONFIG_CLEAN_VPATH_FILES =
60		am_fadbad_OBJECTS = main.$(OBJEXT) det_lu.$(OBJEXT) \
	90	am_speed_fadbad_OBJECTS = main.$(OBJEXT) det_lu.$(OBJEXT) \
61	91	det_minor.$(OBJEXT) mat_mul.$(OBJEXT) ode.$(OBJEXT) \
62	92	poly.$(OBJEXT) sparse_hessian.$(OBJEXT) \
63	93	sparse_jacobian.$(OBJEXT)
64		fadbad_OBJECTS = $(am_fadbad_OBJECTS)
65		fadbad_LDADD = $(LDADD)
66		fadbad_DEPENDENCIES =
	94	speed_fadbad_OBJECTS = $(am_speed_fadbad_OBJECTS)
	95	speed_fadbad_LDADD = $(LDADD)
	96	speed_fadbad_DEPENDENCIES =
	97	AM_V_P = $(am__v_P_@AM_V@)
	98	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	99	am__v_P_0 = false
	100	am__v_P_1 = :
	101	AM_V_GEN = $(am__v_GEN_@AM_V@)
	102	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	103	am__v_GEN_0 = @echo " GEN " $@;
	104	am__v_GEN_1 =
	105	AM_V_at = $(am__v_at_@AM_V@)
	106	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	107	am__v_at_0 = @
	108	am__v_at_1 =
67	109	DEFAULT_INCLUDES =
68	110	depcomp = $(SHELL) $(top_srcdir)/depcomp
69	111	am__depfiles_maybe = depfiles
70	112	am__mv = mv -f
71		AM_V_lt = $(am__v_lt_@AM_V@)
72		am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
73		am__v_lt_0 = --silent
74	113	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
75	114	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
76	115	AM_V_CXX = $(am__v_CXX_@AM_V@)
77	116	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
78		am__v_CXX_0 = @echo " CXX " $@;
79		AM_V_at = $(am__v_at_@AM_V@)
80		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
81		am__v_at_0 = @
	117	am__v_CXX_0 = @echo " CXX " $@;
	118	am__v_CXX_1 =
82	119	CXXLD = $(CXX)
83	120	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
84	121	-o $@
85	122	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
86	123	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
87		am__v_CXXLD_0 = @echo " CXXLD " $@;
88		AM_V_GEN = $(am__v_GEN_@AM_V@)
89		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
90		am__v_GEN_0 = @echo " GEN " $@;
91		SOURCES = $(fadbad_SOURCES)
92		DIST_SOURCES = $(fadbad_SOURCES)
	124	am__v_CXXLD_0 = @echo " CXXLD " $@;
	125	am__v_CXXLD_1 =
	126	SOURCES = $(speed_fadbad_SOURCES)
	127	DIST_SOURCES = $(speed_fadbad_SOURCES)
93	128	am__can_run_installinfo = \
94	129	case $$AM_UPDATE_INFO_DIR in \
95	130	n\|no\|NO) false;; \
96	131	*) (install-info --version) >/dev/null 2>&1;; \
97	132	esac
	133	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	134	# Read a list of newline-separated strings from the standard input,
	135	# and print each of them once, without duplicates. Input order is
	136	# not preserved.
	137	am__uniquify_input = $(AWK) '\
	138	BEGIN { nonempty = 0; } \
	139	{ items[$$0] = 1; nonempty = 1; } \
	140	END { if (nonempty) { for (i in items) print i; }; } \
	141	'
	142	# Make sure the list of sources is unique. This is necessary because,
	143	# e.g., the same source file might be shared among _SOURCES variables
	144	# for different programs/libraries.
	145	am__define_uniq_tagged_files = \
	146	list='$(am__tagged_files)'; \
	147	unique=`for i in $$list; do \
	148	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	149	done \| $(am__uniquify_input)`
98	150	ETAGS = etags
99	151	CTAGS = ctags
100	152	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

104	156	ADOLC_DIR = @ADOLC_DIR@
105	157	AMTAR = @AMTAR@
106	158	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	159	AR = @AR@
107	160	AUTOCONF = @AUTOCONF@
108	161	AUTOHEADER = @AUTOHEADER@
109	162	AUTOMAKE = @AUTOMAKE@

125	178	CXX_FLAGS_EIGEN = @CXX_FLAGS_EIGEN@
126	179	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
127	180	CYGPATH_W = @CYGPATH_W@
128
129		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
130		# -----------------------------------------------------------------------------
131		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
132		#
133		# CppAD is distributed under multiple licenses. This distribution is under
134		# the terms of the
135		# GNU General Public License Version 3.
136		#
137		# A copy of this license is included in the COPYING file of this distribution.
138		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
139		# -----------------------------------------------------------------------------
140		#
141		# automake input file
	181	#
142	182	#
143	183	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
144	184	DEFS =

194	234	abs_srcdir = @abs_srcdir@
195	235	abs_top_builddir = @abs_top_builddir@
196	236	abs_top_srcdir = @abs_top_srcdir@
	237	ac_ct_AR = @ac_ct_AR@
197	238	ac_ct_CC = @ac_ct_CC@
198	239	ac_ct_CXX = @ac_ct_CXX@
199	240	ac_ct_FC = @ac_ct_FC@

204	245	am__tar = @am__tar@
205	246	am__untar = @am__untar@
206	247	bindir = @bindir@
	248	build = @build@
207	249	build_alias = @build_alias@
	250	build_cpu = @build_cpu@
	251	build_os = @build_os@
	252	build_vendor = @build_vendor@
208	253	builddir = @builddir@
209	254	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
210	255	cppad_boostvector = @cppad_boostvector@
211	256	cppad_cflags = @cppad_cflags@
	257	cppad_compiler_has_erf = @cppad_compiler_has_erf@
212	258	cppad_cppadvector = @cppad_cppadvector@
213	259	cppad_description = @cppad_description@
214	260	cppad_eigenvector = @cppad_eigenvector@
	261	cppad_has_colpack = @cppad_has_colpack@
	262	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
215	263	cppad_has_gettimeofday = @cppad_has_gettimeofday@
216	264	cppad_has_nullptr = @cppad_has_nullptr@
	265	cppad_has_rvalue = @cppad_has_rvalue@
217	266	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
218	267	cppad_internal_sparse_set = @cppad_internal_sparse_set@
219	268	cppad_libs = @cppad_libs@
220	269	cppad_max_num_threads = @cppad_max_num_threads@
221	270	cppad_requires = @cppad_requires@
222		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	271	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
223	272	cppad_stdvector = @cppad_stdvector@
224	273	cppad_tape_addr_type = @cppad_tape_addr_type@
225	274	cppad_tape_id_type = @cppad_tape_id_type@

231	280	dvidir = @dvidir@
232	281	eigen_prefix = @eigen_prefix@
233	282	exec_prefix = @exec_prefix@
234		have_ar = @have_ar@
235	283	have_pkg_config = @have_pkg_config@
	284	host = @host@
236	285	host_alias = @host_alias@
	286	host_cpu = @host_cpu@
	287	host_os = @host_os@
	288	host_vendor = @host_vendor@
237	289	htmldir = @htmldir@
238	290	includedir = @includedir@
239	291	infodir = @infodir@

258	310	top_build_prefix = @top_build_prefix@
259	311	top_builddir = @top_builddir@
260	312	top_srcdir = @top_srcdir@
	313
	314	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
	315	# -----------------------------------------------------------------------------
	316	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	317	#
	318	# CppAD is distributed under multiple licenses. This distribution is under
	319	# the terms of the
	320	# GNU General Public License Version 3.
	321	#
	322	# A copy of this license is included in the COPYING file of this distribution.
	323	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	324	# -----------------------------------------------------------------------------
	325	#
	326	# Copy source file so that main.o does not end up in parent directory
	327	BUILT_SOURCES = main.cpp
261	328	#
262	329	AM_CPPFLAGS = \
263	330	-I$(top_srcdir) \

268	335	#
269	336	# BEGIN OPTIMIZE
270	337	# Use special version of CXX_FLAGS with -Wshadow removed (if present).
271		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_FADBAD $(CXX_FLAGS_FADBAD)
	338	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_FADBAD_SPEED $(CXX_FLAGS_FADBAD)
272	339	# END OPTIMIZE
273	340	#
274	341	# BEGIN DEBUG
275		# AM_CXXFLAGS = -g -DSPEED_FADBAD $(CXX_FLAGS_FADBAD)
	342	# AM_CXXFLAGS = -g -DCPPAD_FADBAD_SPEED $(CXX_FLAGS_FADBAD)
276	343	# END DEBUG
277	344	#
278	345	LDADD = -lspeed
279	346	AM_LDFLAGS = -L../src
280	347	#
281		fadbad_SOURCES = \
282		../main.cpp \
	348	speed_fadbad_SOURCES = \
	349	main.cpp \
283	350	det_lu.cpp \
284	351	det_minor.cpp \
285	352	mat_mul.cpp \

288	355	sparse_hessian.cpp \
289	356	sparse_jacobian.cpp
290	357
291		all: all-am
	358	all: $(BUILT_SOURCES)
	359	$(MAKE) $(AM_MAKEFLAGS) all-am
292	360
293	361	.SUFFIXES:
294	362	.SUFFIXES: .cpp .o .obj

325	393
326	394	clean-checkPROGRAMS:
327	395	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
328		fadbad$(EXEEXT): $(fadbad_OBJECTS) $(fadbad_DEPENDENCIES) $(EXTRA_fadbad_DEPENDENCIES)
329		@rm -f fadbad$(EXEEXT)
330		$(AM_V_CXXLD)$(CXXLINK) $(fadbad_OBJECTS) $(fadbad_LDADD) $(LIBS)
	396
	397	speed_fadbad$(EXEEXT): $(speed_fadbad_OBJECTS) $(speed_fadbad_DEPENDENCIES) $(EXTRA_speed_fadbad_DEPENDENCIES)
	398	@rm -f speed_fadbad$(EXEEXT)
	399	$(AM_V_CXXLD)$(CXXLINK) $(speed_fadbad_OBJECTS) $(speed_fadbad_LDADD) $(LIBS)
331	400
332	401	mostlyclean-compile:
333	402	-rm -f *.$(OBJEXT)

345	414	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_jacobian.Po@am__quote@
346	415
347	416	.cpp.o:
348		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
349		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	417	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	418	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	419	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
350	420	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
351	421	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
352	422	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
353	423
354	424	.cpp.obj:
355		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
356		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	425	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	426	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	427	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
357	428	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
358	429	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
359	430	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
360	431
361		main.o: ../main.cpp
362		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.o -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
363		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
364		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.o' libtool=no @AMDEPBACKSLASH@
365		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
366		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
367
368		main.obj: ../main.cpp
369		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.obj -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
370		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
371		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.obj' libtool=no @AMDEPBACKSLASH@
372		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
373		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
374
375		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
376		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
377		unique=`for i in $$list; do \
378		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
379		done \| \
380		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
381		END { if (nonempty) { for (i in files) print i; }; }'`; \
382		mkid -fID $$unique
383		tags: TAGS
384
385		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
386		$(TAGS_FILES) $(LISP)
	432	ID: $(am__tagged_files)
	433	$(am__define_uniq_tagged_files); mkid -fID $$unique
	434	tags: tags-am
	435	TAGS: tags
	436
	437	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
387	438	set x; \
388	439	here=`pwd`; \
389		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
390		unique=`for i in $$list; do \
391		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
392		done \| \
393		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
394		END { if (nonempty) { for (i in files) print i; }; }'`; \
	440	$(am__define_uniq_tagged_files); \
395	441	shift; \
396	442	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
397	443	test -n "$$unique" \|\| unique=$$empty_fix; \

403	449	$$unique; \
404	450	fi; \
405	451	fi
406		ctags: CTAGS
407		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
408		$(TAGS_FILES) $(LISP)
409		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
410		unique=`for i in $$list; do \
411		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
412		done \| \
413		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
414		END { if (nonempty) { for (i in files) print i; }; }'`; \
	452	ctags: ctags-am
	453
	454	CTAGS: ctags
	455	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	456	$(am__define_uniq_tagged_files); \
415	457	test -z "$(CTAGS_ARGS)$$unique" \
416	458	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
417	459	$$unique

420	462	here=`$(am__cd) $(top_builddir) && pwd` \
421	463	&& $(am__cd) $(top_srcdir) \
422	464	&& gtags -i $(GTAGS_ARGS) "$$here"
	465	cscopelist: cscopelist-am
	466
	467	cscopelist-am: $(am__tagged_files)
	468	list='$(am__tagged_files)'; \
	469	case "$(srcdir)" in \
	470	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	471	*) sdir=$(subdir)/$(srcdir) ;; \
	472	esac; \
	473	for i in $$list; do \
	474	if test -f "$$i"; then \
	475	echo "$(subdir)/$$i"; \
	476	else \
	477	echo "$$sdir/$$i"; \
	478	fi; \
	479	done >> $(top_builddir)/cscope.files
423	480
424	481	distclean-tags:
425	482	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

456	513	done
457	514	check-am: all-am
458	515	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
459		check: check-am
	516	check: $(BUILT_SOURCES)
	517	$(MAKE) $(AM_MAKEFLAGS) check-am
460	518	all-am: makefile
461	519	installdirs:
462		install: install-am
	520	install: $(BUILT_SOURCES)
	521	$(MAKE) $(AM_MAKEFLAGS) install-am
463	522	install-exec: install-exec-am
464	523	install-data: install-data-am
465	524	uninstall: uninstall-am

489	548	maintainer-clean-generic:
490	549	@echo "This command is intended for maintainers to use"
491	550	@echo "it deletes files that may require special tools to rebuild."
	551	-test -z "$(BUILT_SOURCES)" \|\| rm -f $(BUILT_SOURCES)
492	552	clean: clean-am
493	553
494	554	clean-am: clean-checkPROGRAMS clean-generic mostlyclean-am

558	618
559	619	uninstall-am:
560	620
561		.MAKE: check-am install-am install-strip
562
563		.PHONY: CTAGS GTAGS all all-am check check-am clean \
564		clean-checkPROGRAMS clean-generic ctags distclean \
565		distclean-compile distclean-generic distclean-tags distdir dvi \
566		dvi-am html html-am info info-am install install-am \
567		install-data install-data-am install-dvi install-dvi-am \
568		install-exec install-exec-am install-html install-html-am \
569		install-info install-info-am install-man install-pdf \
570		install-pdf-am install-ps install-ps-am install-strip \
571		installcheck installcheck-am installdirs maintainer-clean \
572		maintainer-clean-generic mostlyclean mostlyclean-compile \
573		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
574		uninstall-am
575
	621	.MAKE: all check check-am install install-am install-strip
	622
	623	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	624	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	625	distclean distclean-compile distclean-generic distclean-tags \
	626	distdir dvi dvi-am html html-am info info-am install \
	627	install-am install-data install-data-am install-dvi \
	628	install-dvi-am install-exec install-exec-am install-html \
	629	install-html-am install-info install-info-am install-man \
	630	install-pdf install-pdf-am install-ps install-ps-am \
	631	install-strip installcheck installcheck-am installdirs \
	632	maintainer-clean maintainer-clean-generic mostlyclean \
	633	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	634	tags tags-am uninstall uninstall-am
	635
	636	main.cpp:
	637	cp $(srcdir)/../main.cpp main.cpp
576	638
577	639	test: check
578		./fadbad correct 123 retape
	640	./speed_fadbad correct 123
579	641
580	642	# Tell versions [3.59,3.63) of GNU make to not export all variables.
581	643	# Otherwise a system limit (for SysV at least) may be exceeded.

-6

speed/fadbad/mat_mul.cpp less more

0		/* $Id: mat_mul.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: mat_mul.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

13	13	$spell
14	14	badiff
15	15	sq
16		retape
	16	onetape
17	17	typedef
18	18	diff
19	19	Fadbad

44	44	# include <cppad/speed/mat_sum_sq.hpp>
45	45	# include <cppad/speed/uniform_01.hpp>
46	46	# include <cppad/vector.hpp>
	47
	48	// list of possible options
	49	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	50
47	51	bool link_mat_mul(
48	52	size_t size ,
49	53	size_t repeat ,

52	56	CppAD::vector<double>& dz )
53	57	{
54	58	// speed test global option values
55		extern bool global_retape, global_atomic, global_optimize;
56		if( ! global_retape \|\| global_atomic \|\| global_optimize )
	59	if( global_memory \|\| global_onetape \|\| global_atomic \|\| global_optimize )
57	60	return false;
58
59	61	// The correctness check for this test is failing, so abort (for now).
60	62	return false;
61	63

+16

-13

speed/fadbad/ode.cpp less more

0		/* $Id: ode.cpp 2870 2013-07-28 17:00:59Z bradbell $ */
	0	/* $Id: ode.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

23	23	cstring
24	24	cppad
25	25	hpp
26		retape
27		Fadbad
28		bool
29		CppAD
	26	onetape
	27	Fadbad
	28	bool
	29	CppAD
30	30	$$
31	31
32	32	$section Fadbad Speed: Ode$$

51	51	# include <cppad/speed/uniform_01.hpp>
52	52	# include <cppad/speed/ode_evaluate.hpp>
53	53
	54	// list of possible options
	55	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	56
54	57	namespace fadbad {
55	58	// define fabs for use by ode_evaluate
56	59	fadbad::F<double> fabs(const fadbad::F<double>& x)

64	67	CppAD::vector<double> &jacobian
65	68	)
66	69	{
	70	// speed test global option values
	71	if( global_atomic )
	72	return false;
	73	if( global_memory \|\| global_onetape \|\| global_optimize )
	74	return false;
	75	// -------------------------------------------------------------
	76	// setup
67	77	assert( x.size() == size );
68	78	assert( jacobian.size() == size * size );
69	79
70		// speed test global option values
71		extern bool global_retape, global_atomic, global_optimize;
72		if( ! global_retape \|\| global_atomic \|\| global_optimize )
73		return false;
74
75		// -------------------------------------------------------------
76		// setup
77	80	typedef fadbad::F<double> ADScalar;
78	81	typedef CppAD::vector<ADScalar> ADVector;
79	82

-7

speed/fadbad/poly.cpp less more

0		/* $Id: poly.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: poly.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin fadbad_poly.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	std
16	16	cppad
17	17	cpp

52	52	# include <cppad/speed/uniform_01.hpp>
53	53	# include <FADBAD++/tadiff.h>
54	54
	55	// list of possible options
	56	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	57
55	58	bool link_poly(
56	59	size_t size ,
57	60	size_t repeat ,

59	62	CppAD::vector<double> &z , // polynomial argument value
60	63	CppAD::vector<double> &ddp ) // second derivative w.r.t z
61	64	{
62		// speed test global option values
63		extern bool global_retape, global_atomic, global_optimize;
64		if( ! global_retape \|\| global_atomic \|\| global_optimize )
	65	if( global_atomic )
65	66	return false;
66
	67	if( global_memory \|\| global_onetape \|\| global_optimize )
	68	return false;
67	69	// -----------------------------------------------------
68	70	// setup
69	71	size_t i; // temporary index

-7

speed/fadbad/sparse_hessian.cpp less more

0		/* $Id: sparse_hessian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: sparse_hessian.cpp 3136 2014-03-02 11:54:07Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

23	23	$section Fadbad Speed: Sparse Hessian$$
24	24
25	25	$codep */
26		// The fadbad version of this test is not yet available
	26	// A fadbad version of this test is not yet available
27	27	bool link_sparse_hessian(
28	28	size_t size ,
29	29	size_t repeat ,
30		CppAD::vector<double> &x ,
31		const CppAD::vector<size_t> &row ,
32		const CppAD::vector<size_t> &col ,
33		CppAD::vector<double> &hessian
	30	const CppAD::vector<size_t>& row ,
	31	const CppAD::vector<size_t>& col ,
	32	CppAD::vector<double>& x ,
	33	CppAD::vector<double>& hessian
34	34	)
35	35	{
36	36	return false;

+15

-13

speed/fadbad/sparse_jacobian.cpp less more

0		/* $Id: sparse_jacobian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: sparse_jacobian.cpp 3138 2014-03-02 18:46:11Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

14	14	/*
15	15	$begin fadbad_sparse_jacobian.cpp$$
16	16	$spell
17		bool
18		CppAD
19		fadbad
	17	const
	18	bool
	19	CppAD
	20	fadbad
20	21	sparse_jacobian
21	22	$$
22	23
23	24	$section fadbad Speed: sparse_jacobian$$
24	25
25	26	$codep */
26		// The fadbad version of this test is not yet available
	27	// A fadbad version of this test is not yet available
27	28	bool link_sparse_jacobian(
28		size_t size ,
29		size_t repeat ,
30		size_t m ,
31		CppAD::vector<double> &x ,
32		CppAD::vector<size_t> &i ,
33		CppAD::vector<size_t> &j ,
34		CppAD::vector<double> &jacobian )
	29	size_t size ,
	30	size_t repeat ,
	31	size_t m ,
	32	const CppAD::vector<size_t>& row ,
	33	const CppAD::vector<size_t>& col ,
	34	CppAD::vector<double>& x ,
	35	CppAD::vector<double>& jacobian ,
	36	size_t& n_sweep )
35	37	{
36	38	return false;
37	39	}

+209

-107

speed/main.cpp less more

0		/* $Id: main.cpp 2859 2013-05-28 06:03:21Z bradbell $ */
	0	/* $Id: main.cpp 3320 2014-09-11 23:06:21Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

24	24	# include <cppad/track_new_del.hpp>
25	25	# include <cppad/thread_alloc.hpp>
26	26
27		# ifdef SPEED_ADOLC
	27	# ifdef CPPAD_ADOLC_SPEED
28	28	# define AD_PACKAGE "adolc"
29	29	# endif
30		# ifdef SPEED_CPPAD
	30	# ifdef CPPAD_CPPAD_SPEED
31	31	# define AD_PACKAGE "cppad"
32	32	# endif
33		# ifdef SPEED_DOUBLE
	33	# ifdef CPPAD_DOUBLE_SPEED
34	34	# define AD_PACKAGE "double"
35	35	# endif
36		# ifdef SPEED_FADBAD
	36	# ifdef CPPAD_FADBAD_SPEED
37	37	# define AD_PACKAGE "fadbad"
38	38	# endif
39		# ifdef SPEED_PROFILE
	39	# ifdef CPPAD_PROFILE_SPEED
40	40	# define AD_PACKAGE "profile"
41	41	# endif
42		# ifdef SPEED_SACADO
	42	# ifdef CPPAD_SACADO_SPEED
43	43	# define AD_PACKAGE "sacado"
44	44	# endif
45	45
46	46	/*
47	47	$begin speed_main$$
48	48	$spell
	49	colpack
	50	onetape
	51	boolsparsity
49	52	optionlist
50	53	underbar
51	54	alloc
52	55	mat_mul
53	56	retaped
54		retape
55	57	bool
56	58	ddp
57	59	cppad

68	70	$index speed, test cppad$$
69	71	$index test, cppad speed$$
70	72
71		$section Speed Testing Main Program$$
	73	$section Running the Speed Test Program$$
72	74
73	75	$head Syntax$$
74		$codei%speed/%package%/%package% %test% %seed% %option_list%$$
	76	$codei%speed/%package%/speed_%package% %test% %seed% %option_list%$$
75	77
76	78	$head Purpose$$
77	79	A version of this program runs the correctness tests

81	83
82	84	$subhead AD Package$$
83	85	The command line argument
84		$icode package$$ specifies one of the following AD packages:
	86	$icode package$$ specifies one of the AD package.
	87	The CppAD distribution comes with support for the following packages:
85	88	$cref/adolc/speed_adolc/$$,
86	89	$cref/cppad/speed_cppad/$$,
87	90	$cref/fadbad/speed_fadbad/$$,
88	91	$cref/sacado/speed_sacado/$$.
	92	You can extend this program to include other package.
	93	Such an extension need not include all the tests.
	94	For example,
	95	$cref link_sparse_hessian$$ just returns $code false$$ for the
	96	$cref/fadbad/fadbad_sparse_hessian.cpp/$$ and
	97	$cref/sacado/sacado_sparse_hessian.cpp/$$ packages.
	98
89	99
90	100	$subhead double$$
91	101	The value

114	124	$cref/poly/link_poly/$$,
115	125	$cref/sparse_hessian/link_sparse_hessian/$$,
116	126	$cref/sparse_jacobian/link_sparse_jacobian/$$.
	127	You can experiment with changing the implementation of a
	128	particular test for a particular package.
117	129
118	130	$subhead correct$$
119	131	If $icode test$$ is equal to $code correct$$,

138	150	The order of the options does not matter and the list can be empty.
139	151	Each option in the list, must be separate
140	152	command line argument to the main program.
141
142		$subhead retape$$
143		If the option $code retape$$ is present, the symbol
	153	The documentation below specifics how CppAD uses these options,
	154	see the examples in $cref speed_adolc$$ for how another package might
	155	uses these options.
	156
	157	$subhead onetape$$
	158	If the option $code onetape$$ is present, the symbol
144	159	$codep
145		extern bool global_retape
	160	extern bool global_onetape
146	161	$$
147	162	is true and otherwise it is false.
148	163	If this external symbol is true,
149		every test must retape the
	164	CppAD will use one taping of the operation
	165	sequence for all the repetitions of that speed test.
	166	Otherwise, the
150	167	$cref/operation sequence/glossary/Operation/Sequence/$$
151		for each test repetition.
152		If it is false,
153		the AD package is allowed to use one taping of the operation
154		sequence for all the repetitions of that speed test.
	168	will be retaped for each test repetition.
155	169	$pre
156	170
157	171	$$

160	174	The operation sequence for $code det_lu$$
161	175	may be different for each repetition of the test because it
162	176	depends on the matrix for which the determinant is being calculated.
163		For this reason,
	177	For this reason, the CppAD test
164	178	$cref cppad_det_lu.cpp$$ returns false
165		(for test not implemented)
166		when $code global_retape$$ is false.
	179	(indicating that the test not implemented)
	180	when $code global_onetape$$ is true.
167	181
168	182	$subhead optimize$$
169	183	If the option $code optimize$$ is present, the symbol

172	186	$$
173	187	is true and otherwise it is false.
174	188	If this external symbol is true,
175		and the AD package has an optional way to spend time optimizing
176		the operation sequence,
177		this optimization should be done before doing computations.
178		If it is false,
179		this optimization should not be done.
	189	CppAD will optimize the operation sequence before doing computations.
	190	If it is false, this optimization will not be done.
180	191
181	192	$subhead atomic$$
182	193	If the option $code atomic$$ is present, the symbol

184	195	extern bool global_atomic
185	196	$$
186	197	is true and otherwise it is false.
187		If this external symbol is true,
188		and the AD package has a way to speed up the processing
189		by adding $cref old_atomic$$ operations,
190		this should be included in computations.
191		If it is false, user defined atomic operations should not be done.
	198	If this external symbol is true, CppAD will use its user defined
	199	$cref/atomic/atomic_base/$$ operation is used for the test.
	200	If no such atomic operation exists,
	201	and atomic is chosen, CppAD returns false for the test.
192	202
193	203	$subhead memory$$
194	204	If the option $code memory$$ is present, the symbol

200	210	$cref/hold_memory/ta_hold_memory/$$ routine will be called by
201	211	the main program before any of the tests are executed.
202	212	This should make the CppAD $code thread_alloc$$ allocator faster.
203		If it is false, standard memory allocation should be done by.
204		Otherwise the test can use special memory allocation to try
205		and improve speed.
	213	If it is false, CppAD will used standard memory allocation.
	214
	215	$head Sparsity Options$$
	216	The following options only apply to the
	217	$cref/sparse_jacobian/link_sparse_jacobian/$$ and
	218	$cref/sparse_hessian/link_sparse_hessian/$$ tests.
	219	The other tests will ignore these options:
	220
	221	$subhead boolsparsity$$
	222	If the option $code boolsparsity$$ is present, the symbol
	223	$codep
	224	extern bool global_boolsparsity
	225	$$
	226	is true and otherwise it is false.
	227	If it is true, CppAD will use a
	228	$cref/vector of bool/glossary/Sparsity Pattern/Vector of Boolean/$$
	229	for its sparsity patterns.
	230	Otherwise it will use a
	231	$cref/vector of sets/glossary/Sparsity Pattern/Vector of Sets/$$.
	232
	233	$subhead colpack$$
	234	If the option $code colpack$$ is present, the symbol
	235	$codep
	236	extern bool global_colpack
	237	$$
	238	is true and otherwise it is false.
	239	If this external symbol is true,
	240	CppAD will use $cref/colpack/colpack_prefix/$$ to do the coloring
	241	for its
	242	Otherwise, it will use it's own coloring algorithm.
206	243
207	244	$head Correctness Results$$
208		An output line of the following form:
	245	One, but not both, of the following two output lines
209	246	$codei%
	247	%package%_%test%_%optionlist%_available = false
210	248	%package%_%test%_%optionlist%_ok = %flag%
211	249	%$$
212	250	is generated for each correctness test where

221	259	following form are generated:
222	260	$codei%
223	261	%package%_%test%_%optionlist%_ok = %flag%
224		%package%_%test%_%optionlist%_size = [ %size_1%, %...%, %size_n% ]
225		%package%_%test%_%optionlist%_rate = [ %rate_1%, %...%, %rate_n% ]
	262	%package%_%test%_size = [ %size_1%, %...%, %size_n% ]
	263	%package%_%test%_rate = [ %rate_1%, %...%, %rate_n% ]
226	264	%$$
227	265	The values $icode package$$, $icode test$$, $icode optionlist$$,
228	266	and $icode flag$$ are as in the correctness results above.

230	268	size arguments used for the corresponding tests.
231	269	The values $icode rate_1$$, ..., $icode rate_n$$ are the number of times
232	270	per second that the corresponding size problem executed.
	271
	272	$subhead sparse_jacobian$$
	273	The $cref/sparse_jacobian/link_sparse_jacobian/$$ test has an extra output
	274	line with the following form
	275	$codei%
	276	%package%_sparse_jacobian_n_sweep = [ %n_sweep_1%, %...%, %n_sweep_n% ]
	277	%$$
	278	The values $icode n_sweep_1$$, ..., $icode n_sweep_n$$ are the number of
	279	sweeps (colors) used for each sparse Jacobian calculation; see
	280	$cref/n_sweep/sparse_jacobian/n_sweep/$$.
	281
233	282
234	283	$children%
235	284	speed/src/link_det_lu.cpp%

243	292	%$$
244	293
245	294	$head Link Functions$$
246		Each speed test defines it's own version of one of the following
247		functions that link the speed test to the main program described above:
	295	Each $cref/package/speed_main/package/$$
	296	defines it's own version of one of the link functions listed below.
	297	Each of these functions links this main program to the corresponding test:
248	298	$table
249	299	$rref link_det_lu$$
250	300	$rref link_det_minor$$

259	309	$end
260	310	-----------------------------------------------------------------------------
261	311	*/
	312	// external routines
262	313
263	314	# define CPPAD_DECLARE_SPEED(name) \
264	315	extern bool available_##name(void); \

273	324	CPPAD_DECLARE_SPEED(sparse_hessian);
274	325	CPPAD_DECLARE_SPEED(sparse_jacobian);
275	326
276		bool global_retape;
	327	// info is different for each test
	328	extern void info_sparse_jacobian(size_t size, size_t& n_sweep);
	329
	330	// --------------------------------------------------------------------------
	331
	332	bool global_onetape;
	333	bool global_colpack;
277	334	bool global_optimize;
278	335	bool global_atomic;
279	336	bool global_memory;
	337	bool global_boolsparsity;
280	338
281	339	namespace {
282	340	using std::cout;

286	344	void not_available_message(const char* test_name)
287	345	{ cout << AD_PACKAGE << ": " << test_name;
288	346	cout << " is not availabe with " << endl;
289		cout << "global_retape = " << global_retape;
290		cout << ", global_optimize = " << global_optimize;
291		cout << ", global_atomic = " << global_atomic;
292		cout << ", global_memory = " << global_memory;
293		cout << endl;
	347	cout << "onetape = " << global_onetape << endl;
	348	cout << "colpack = " << global_colpack << endl;
	349	cout << "optimize = " << global_optimize << endl;
	350	cout << "atomic = " << global_atomic << endl;
	351	cout << "memory = " << global_memory << endl;
	352	cout << "boolsparsity = " << global_boolsparsity << endl;
294	353	}
295	354
296	355	// ------------------------------------------------------

311	370	// function that runs one correctness case
312	371	static size_t Run_ok_count = 0;
313	372	static size_t Run_error_count = 0;
314		bool run_correct(bool correct_case(bool), const char *case_name)
315		{ bool ok;
316		# ifdef SPEED_DOUBLE
317		ok = correct_case(true);
	373	bool run_correct(
	374	bool available_case(void) ,
	375	bool correct_case(bool) ,
	376	const char *case_name )
	377	{ bool available = available_case();
	378	bool ok = true;
	379	if( available )
	380	{
	381	# ifdef CPPAD_DOUBLE_SPEED
	382	ok = correct_case(true);
318	383	# else
319		ok = correct_case(false);
	384	ok = correct_case(false);
320	385	# endif
	386	}
321	387	cout << AD_PACKAGE << "_" << case_name;
322		if( global_retape )
323		cout << "_retape";
	388	if( global_onetape )
	389	cout << "_onetape";
	390	if( global_colpack )
	391	cout << "_colpack";
324	392	if( global_optimize )
325	393	cout << "_optimize";
326	394	if( global_atomic )
327	395	cout << "_atomic";
328	396	if( global_memory )
329	397	cout << "_memory";
	398	if( global_boolsparsity )
	399	cout << "_boolsparsity";
	400	if( ! available )
	401	{ cout << "_available = false" << endl;
	402	return ok;
	403	}
330	404	cout << "_ok = ";
331	405	if( ok )
332	406	{ cout << " true" << endl;

348	422	cout << AD_PACKAGE << "_" << case_name << "_size = ";
349	423	output(size_vec);
350	424	cout << endl;
351		cout << AD_PACKAGE << "_" << case_name;
352		if( global_retape )
353		cout << "_retape";
354		if( global_optimize )
355		cout << "_optimize";
356		if( global_atomic )
357		cout << "_atomic";
358		if( global_memory )
359		cout << "_memory";
360		cout << "_rate = ";
361
	425	cout << AD_PACKAGE << "_" << case_name << "_rate = ";
362	426	cout << std::fixed;
363	427	for(size_t i = 0; i < size_vec.size(); i++)
364	428	{ if( i == 0 )

420	484	error = match == test_error;
421	485	iseed = std::atoi( argv[2] );
422	486	error \|= iseed < 0;
423		global_retape = false;
424		global_optimize = false;
425		global_atomic = false;
426		global_memory = false;
	487	global_onetape = false;
	488	global_colpack = false;
	489	global_optimize = false;
	490	global_atomic = false;
	491	global_memory = false;
	492	global_boolsparsity = false;
427	493	for(i = 3; i < size_t(argc); i++)
428		{ if( strcmp(argv[i], "retape") == 0 )
429		global_retape = true;
	494	{ if( strcmp(argv[i], "onetape") == 0 )
	495	global_onetape = true;
	496	else if( strcmp(argv[i], "colpack") == 0 )
	497	global_colpack = true;
430	498	else if( strcmp(argv[i], "optimize") == 0 )
431	499	global_optimize = true;
432	500	else if( strcmp(argv[i], "atomic") == 0 )
433	501	global_atomic = true;
434	502	else if( strcmp(argv[i], "memory") == 0 )
435	503	global_memory = true;
	504	else if( strcmp(argv[i], "boolsparsity") == 0 )
	505	global_boolsparsity = true;
436	506	else
437	507	error = true;
438	508	}
439	509	}
440	510	if( error )
441		{ cout << "usage: ./"
	511	{ cout << "usage: ./speed_"
442	512	<< AD_PACKAGE << " test seed option_list" << endl;
443	513	cout << "test choices: " << endl;
444	514	for(i = 0; i < n_test; i++)

446	516	cout << "seed choices: ";
447	517	cout << "a positive integer used as a random seed." << endl;
448	518	cout << "option choices: ";
449		cout << " \"retape\",";
	519	cout << " \"onetape\",";
	520	cout << " \"colpack\",";
450	521	cout << " \"optimize\",";
451	522	cout << " \"atomic\",";
452		cout << " \"memory\"." << endl << endl;
	523	cout << " \"memory\",";
	524	cout << " \"boolsparsity\"." << endl << endl;
453	525	return 1;
454	526	}
455	527	if( global_memory )

468	540	CppAD::vector<size_t> size_sparse_hessian(n_size);
469	541	CppAD::vector<size_t> size_sparse_jacobian(n_size);
470	542	for(i = 0; i < n_size; i++)
471		{ size_det_lu[i] = 3 * i + 1;
472		size_det_minor[i] = i + 1;
473		size_mat_mul[i] = 10 * (i + 1);
474		size_ode[i] = 3 * i + 1;
475		size_poly[i] = 8 * i + 1;
	543	{ size_det_minor[i] = i + 1;
	544	size_det_lu[i] = 10 * i + 1;
	545	size_mat_mul[i] = 10 * i + 1;
	546	size_ode[i] = 10 * i + 1;
	547	size_poly[i] = 10 * i + 1;
476	548	size_sparse_hessian[i] = 100 * (i + 1) * (i + 1);
477	549	size_sparse_jacobian[i] = 100 * (i + 1) * (i + 1);
478	550	}

481	553	{
482	554	// run all the correctness tests
483	555	case test_correct:
484		if( available_det_lu() ) ok &= run_correct(
485		correct_det_lu, "det_lu"
486		);
487		if( available_det_minor() ) ok &= run_correct(
488		correct_det_minor, "det_minor"
489		);
490		if( available_mat_mul() ) ok &= run_correct(
491		correct_mat_mul, "mat_mul"
492		);
493		if( available_ode() ) ok &= run_correct(
494		correct_ode, "ode"
495		);
496		if( available_poly() ) ok &= run_correct(
497		correct_poly, "poly"
498		);
499		if( available_sparse_hessian() ) ok &= run_correct(
500		correct_sparse_hessian, "sparse_hessian"
501		);
502		if( available_sparse_jacobian() ) ok &= run_correct(
503		correct_sparse_jacobian, "sparse_jacobian"
	556	ok &= run_correct( available_det_lu, correct_det_lu, "det_lu"
	557	);
	558	ok &= run_correct(
	559	available_det_minor, correct_det_minor, "det_minor"
	560	);
	561	ok &= run_correct(
	562	available_mat_mul, correct_mat_mul, "mat_mul"
	563	);
	564	ok &= run_correct(
	565	available_ode, correct_ode, "ode"
	566	);
	567	ok &= run_correct( available_poly, correct_poly, "poly"
	568	);
	569	ok &= run_correct(
	570	available_sparse_hessian,
	571	correct_sparse_hessian,
	572	"sparse_hessian"
	573	);
	574	ok &= run_correct(
	575	available_sparse_jacobian,
	576	correct_sparse_jacobian,
	577	"sparse_jacobian"
504	578	);
505	579	// summarize results
506	580	assert( ok \|\| (Run_error_count > 0) );

546	620	{ not_available_message( argv[1] );
547	621	exit(1);
548	622	}
549		ok &= run_correct(correct_det_lu, "det_lu");
	623	ok &= run_correct(
	624	available_det_lu, correct_det_lu, "det_lu")
	625	;
550	626	run_speed(speed_det_lu, size_det_lu, "det_lu");
551	627	break;
552	628	// ---------------------------------------------------------

556	632	{ not_available_message( argv[1] );
557	633	exit(1);
558	634	}
559		ok &= run_correct(correct_det_minor, "det_minor");
	635	ok &= run_correct(
	636	available_det_minor, correct_det_minor, "det_minor"
	637	);
560	638	run_speed(speed_det_minor, size_det_minor, "det_minor");
561	639	break;
562	640	// ---------------------------------------------------------

566	644	{ not_available_message( argv[1] );
567	645	exit(1);
568	646	}
569		ok &= run_correct(correct_mat_mul, "mat_mul");
	647	ok &= run_correct(
	648	available_mat_mul, correct_mat_mul, "mat_mul"
	649	);
570	650	run_speed(speed_mat_mul, size_mat_mul, "mat_mul");
571	651	break;
572	652	// ---------------------------------------------------------

576	656	{ not_available_message( argv[1] );
577	657	exit(1);
578	658	}
579		ok &= run_correct(correct_ode, "ode");
	659	ok &= run_correct(
	660	available_ode, correct_ode, "ode"
	661	);
580	662	run_speed(speed_ode, size_ode, "ode");
581	663	break;
582	664	// ---------------------------------------------------------

586	668	{ not_available_message( argv[1] );
587	669	exit(1);
588	670	}
589		ok &= run_correct(correct_poly, "poly");
	671	ok &= run_correct(
	672	available_poly, correct_poly, "poly"
	673	);
590	674	run_speed(speed_poly, size_poly, "poly");
591	675	break;
592	676	// ---------------------------------------------------------

596	680	{ not_available_message( argv[1] );
597	681	exit(1);
598	682	}
599		ok &= run_correct(correct_sparse_hessian, "sparse_hessian");
	683	ok &= run_correct(
	684	available_sparse_hessian,
	685	correct_sparse_hessian,
	686	"sparse_hessian"
	687	);
600	688	run_speed(
601	689	speed_sparse_hessian, size_sparse_hessian, "sparse_hessian");
602	690	break;

607	695	{ not_available_message( argv[1] );
608	696	exit(1);
609	697	}
610		ok &= run_correct(correct_sparse_jacobian, "sparse_jacobian");
	698	ok &= run_correct(
	699	available_sparse_jacobian,
	700	correct_sparse_jacobian,
	701	"sparse_jacobian"
	702	);
611	703	run_speed(
612	704	speed_sparse_jacobian, size_sparse_jacobian, "sparse_jacobian"
613	705	);
	706	cout << AD_PACKAGE << "_sparse_jacobian_n_sweep = ";
	707	for(i = 0; i < size_sparse_jacobian.size(); i++)
	708	{ if( i == 0 )
	709	cout << "[ ";
	710	else cout << ", ";
	711	size_t n_sweep;
	712	info_sparse_jacobian(size_sparse_jacobian[i], n_sweep);
	713	cout << n_sweep;
	714	}
	715	cout << " ]" << endl;
614	716	break;
615	717	// ---------------------------------------------------------
616	718

-9

speed/profile/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2608 2012-12-15 17:47:33Z bradbell $
	0	# $Id: CMakeLists.txt 3139 2014-03-02 21:12:00Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

10	10	# -----------------------------------------------------------------------------
11	11	# Build the speed/profile directory tests
12	12	# Inherit environment from ../CMakeList.txt
13
14		# Specifies build type for this directory. Possible values are
15		# empty, Debug, Release, RelWithDebInfo and MinSizeRel
16		SET(CMAKE_BUILD_TYPE RELEASE)
	13	# CMAKE_BUILD_TYPE determined by parent directory
17	14
18	15	# Adds flags to the compiler command line for sources in the current directory
19	16	# and below. This command can be used to add any flags, but it was originally
20	17	# intended to add preprocessor definitions.
21		ADD_DEFINITIONS("-DSPEED_PROFILE -pg")
	18	ADD_DEFINITIONS("-DCPPAD_PROFILE_SPEED -pg")
22	19
23	20	# Extra flags used by the linker when creating an executable.
24	21	SET(CMAKE_EXE_LINKER_FLAGS "-pg")

30	27	# source1 source2 ... sourceN
31	28	# )
32	29	ADD_EXECUTABLE(speed_profile EXCLUDE_FROM_ALL ../main.cpp
33		../cppad/print_optimize.hpp
34		../cppad/print_optimize.cpp
35	30	../cppad/ode.cpp
36	31	../cppad/det_lu.cpp
37	32	../cppad/det_minor.cpp

47	42	../src/link_sparse_hessian.cpp
48	43	../src/link_sparse_jacobian.cpp
49	44	../src/microsoft_timer.cpp
	45	${colpack_sources}
50	46	)
51	47
52	48	# Compiler flags for cppad source

54	50
55	51	# profile builds it own copy of src/speed library (see ADD_EXECUTABLE above)
56	52	# TARGET_LINK_LIBRARIES(speed_profile speed_src )
	53	TARGET_LINK_LIBRARIES(speed_profile ${colpack_libs} )
57	54
58	55	# Add the check_speed_profile target
59	56	ADD_CUSTOM_TARGET(check_speed_profile

+60

-27

speed/profile/makefile.am less more

0		# $Id: makefile.am 2529 2012-10-31 17:37:50Z bradbell $
	0	# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

8	8	# A copy of this license is included in the COPYING file of this distribution.
9	9	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10	10	# -----------------------------------------------------------------------------
	11	source_list = \
	12	main.cpp \
	13	ode.cpp \
	14	det_lu.cpp \
	15	det_minor.cpp \
	16	mat_mul.cpp \
	17	poly.cpp \
	18	sparse_hessian.cpp \
	19	sparse_jacobian.cpp \
	20	link_det_lu.cpp \
	21	link_det_minor.cpp \
	22	link_mat_mul.cpp \
	23	link_ode.cpp \
	24	link_poly.cpp \
	25	link_sparse_hessian.cpp \
	26	link_sparse_jacobian.cpp \
	27	microsoft_timer.cpp
11	28	#
12		# automake input file
	29	# make separate copy of source files because building with different flags
	30	BUILT_SOURCES = $(source_list)
	31	#
	32	main.cpp: $(srcdir)/../main.cpp
	33	cp $(srcdir)/../main.cpp main.cpp
	34	ode.cpp: $(srcdir)/../cppad/ode.cpp
	35	cp $(srcdir)/../cppad/ode.cpp ode.cpp
	36	det_lu.cpp: $(srcdir)/../cppad/det_lu.cpp
	37	cp $(srcdir)/../cppad/det_lu.cpp det_lu.cpp
	38	det_minor.cpp: $(srcdir)/../cppad/det_minor.cpp
	39	cp $(srcdir)/../cppad/det_minor.cpp det_minor.cpp
	40	mat_mul.cpp: $(srcdir)/../cppad/mat_mul.cpp
	41	cp $(srcdir)/../cppad/mat_mul.cpp mat_mul.cpp
	42	poly.cpp: $(srcdir)/../cppad/poly.cpp
	43	cp $(srcdir)/../cppad/poly.cpp poly.cpp
	44	sparse_hessian.cpp: $(srcdir)/../cppad/sparse_hessian.cpp
	45	cp $(srcdir)/../cppad/sparse_hessian.cpp sparse_hessian.cpp
	46	sparse_jacobian.cpp: $(srcdir)/../cppad/sparse_jacobian.cpp
	47	cp $(srcdir)/../cppad/sparse_jacobian.cpp sparse_jacobian.cpp
	48	link_det_lu.cpp: $(srcdir)/../src/link_det_lu.cpp
	49	cp $(srcdir)/../src/link_det_lu.cpp link_det_lu.cpp
	50	link_det_minor.cpp: $(srcdir)/../src/link_det_minor.cpp
	51	cp $(srcdir)/../src/link_det_minor.cpp link_det_minor.cpp
	52	link_mat_mul.cpp: $(srcdir)/../src/link_mat_mul.cpp
	53	cp $(srcdir)/../src/link_mat_mul.cpp link_mat_mul.cpp
	54	link_ode.cpp: $(srcdir)/../src/link_ode.cpp
	55	cp $(srcdir)/../src/link_ode.cpp link_ode.cpp
	56	link_poly.cpp: $(srcdir)/../src/link_poly.cpp
	57	cp $(srcdir)/../src/link_poly.cpp link_poly.cpp
	58	link_sparse_hessian.cpp: $(srcdir)/../src/link_sparse_hessian.cpp
	59	cp $(srcdir)/../src/link_sparse_hessian.cpp link_sparse_hessian.cpp
	60	link_sparse_jacobian.cpp: $(srcdir)/../src/link_sparse_jacobian.cpp
	61	cp $(srcdir)/../src/link_sparse_jacobian.cpp link_sparse_jacobian.cpp
	62	microsoft_timer.cpp: $(srcdir)/../src/microsoft_timer.cpp
	63	cp $(srcdir)/../src/microsoft_timer.cpp microsoft_timer.cpp
13	64	#
14	65	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
15	66	DEFS =

17	68	EXTRA_DIST = \
18	69	gprof.sed
19	70	#
20		check_PROGRAMS = profile
	71	check_PROGRAMS = speed_profile
21	72	#
22	73	AM_CPPFLAGS = -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
23	74	#
24	75	# BEGIN OPTIMIZE
25		AM_CXXFLAGS = -pg -O2 -DSPEED_PROFILE -DNDEBUG $(CXX_FLAGS)
	76	AM_CXXFLAGS = -pg -O2 -DCPPAD_PROFILE_SPEED -DNDEBUG $(CXX_FLAGS)
26	77	# END OPTIMIZE
27	78	#
28	79	# BEGIN DEBUG
29		# AM_CXXFLAGS = -g $(CXX_FLAGS) -DSPEED_PROFILE
	80	# AM_CXXFLAGS = -g $(CXX_FLAGS) -DCPPAD_PROFILE_SPEED
30	81	# END DEBUG
31	82	#
32	83	AM_LDFLAGS = -pg
33	84	#
34		profile_SOURCES = \
35		../cppad/print_optimize.hpp \
36		../cppad/print_optimize.cpp \
37		../main.cpp \
38		../cppad/ode.cpp \
39		../cppad/det_lu.cpp \
40		../cppad/det_minor.cpp \
41		../cppad/mat_mul.cpp \
42		../cppad/poly.cpp \
43		../cppad/sparse_hessian.cpp \
44		../cppad/sparse_jacobian.cpp \
45		../src/link_det_lu.cpp \
46		../src/link_det_minor.cpp \
47		../src/link_mat_mul.cpp \
48		../src/link_ode.cpp \
49		../src/link_poly.cpp \
50		../src/link_sparse_hessian.cpp \
51		../src/link_sparse_jacobian.cpp \
52		../src/microsoft_timer.cpp
53
	85	speed_profile_SOURCES = $(source_list)
	86	#
54	87	test: check
55		./profile correct 123
	88	./speed_profile correct 123

+238

-383

speed/profile/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
50		check_PROGRAMS = profile$(EXEEXT)
	77	build_triplet = @build@
	78	host_triplet = @host@
	79	check_PROGRAMS = speed_profile$(EXEEXT)
51	80	subdir = speed/profile
52		DIST_COMMON = $(srcdir)/gprof.sed.in $(srcdir)/makefile.am \
53		$(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(srcdir)/gprof.sed.in $(top_srcdir)/depcomp
54	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
55	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
56	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

58	87	mkinstalldirs = $(install_sh) -d
59	88	CONFIG_CLEAN_FILES = gprof.sed
60	89	CONFIG_CLEAN_VPATH_FILES =
61		am_profile_OBJECTS = print_optimize.$(OBJEXT) main.$(OBJEXT) \
62		ode.$(OBJEXT) det_lu.$(OBJEXT) det_minor.$(OBJEXT) \
63		mat_mul.$(OBJEXT) poly.$(OBJEXT) sparse_hessian.$(OBJEXT) \
64		sparse_jacobian.$(OBJEXT) link_det_lu.$(OBJEXT) \
65		link_det_minor.$(OBJEXT) link_mat_mul.$(OBJEXT) \
66		link_ode.$(OBJEXT) link_poly.$(OBJEXT) \
	90	am__objects_1 = main.$(OBJEXT) ode.$(OBJEXT) det_lu.$(OBJEXT) \
	91	det_minor.$(OBJEXT) mat_mul.$(OBJEXT) poly.$(OBJEXT) \
	92	sparse_hessian.$(OBJEXT) sparse_jacobian.$(OBJEXT) \
	93	link_det_lu.$(OBJEXT) link_det_minor.$(OBJEXT) \
	94	link_mat_mul.$(OBJEXT) link_ode.$(OBJEXT) link_poly.$(OBJEXT) \
67	95	link_sparse_hessian.$(OBJEXT) link_sparse_jacobian.$(OBJEXT) \
68	96	microsoft_timer.$(OBJEXT)
69		profile_OBJECTS = $(am_profile_OBJECTS)
70		profile_LDADD = $(LDADD)
	97	am_speed_profile_OBJECTS = $(am__objects_1)
	98	speed_profile_OBJECTS = $(am_speed_profile_OBJECTS)
	99	speed_profile_LDADD = $(LDADD)
	100	AM_V_P = $(am__v_P_@AM_V@)
	101	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	102	am__v_P_0 = false
	103	am__v_P_1 = :
	104	AM_V_GEN = $(am__v_GEN_@AM_V@)
	105	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	106	am__v_GEN_0 = @echo " GEN " $@;
	107	am__v_GEN_1 =
	108	AM_V_at = $(am__v_at_@AM_V@)
	109	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	110	am__v_at_0 = @
	111	am__v_at_1 =
71	112	DEFAULT_INCLUDES =
72	113	depcomp = $(SHELL) $(top_srcdir)/depcomp
73	114	am__depfiles_maybe = depfiles
74	115	am__mv = mv -f
75		AM_V_lt = $(am__v_lt_@AM_V@)
76		am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
77		am__v_lt_0 = --silent
78	116	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
79	117	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
80	118	AM_V_CXX = $(am__v_CXX_@AM_V@)
81	119	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
82		am__v_CXX_0 = @echo " CXX " $@;
83		AM_V_at = $(am__v_at_@AM_V@)
84		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
85		am__v_at_0 = @
	120	am__v_CXX_0 = @echo " CXX " $@;
	121	am__v_CXX_1 =
86	122	CXXLD = $(CXX)
87	123	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
88	124	-o $@
89	125	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
90	126	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
91		am__v_CXXLD_0 = @echo " CXXLD " $@;
92		COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
93		$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
94		AM_V_CC = $(am__v_CC_@AM_V@)
95		am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
96		am__v_CC_0 = @echo " CC " $@;
97		CCLD = $(CC)
98		LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
99		AM_V_CCLD = $(am__v_CCLD_@AM_V@)
100		am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
101		am__v_CCLD_0 = @echo " CCLD " $@;
102		AM_V_GEN = $(am__v_GEN_@AM_V@)
103		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
104		am__v_GEN_0 = @echo " GEN " $@;
105		SOURCES = $(profile_SOURCES)
106		DIST_SOURCES = $(profile_SOURCES)
	127	am__v_CXXLD_0 = @echo " CXXLD " $@;
	128	am__v_CXXLD_1 =
	129	SOURCES = $(speed_profile_SOURCES)
	130	DIST_SOURCES = $(speed_profile_SOURCES)
107	131	am__can_run_installinfo = \
108	132	case $$AM_UPDATE_INFO_DIR in \
109	133	n\|no\|NO) false;; \
110	134	*) (install-info --version) >/dev/null 2>&1;; \
111	135	esac
	136	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	137	# Read a list of newline-separated strings from the standard input,
	138	# and print each of them once, without duplicates. Input order is
	139	# not preserved.
	140	am__uniquify_input = $(AWK) '\
	141	BEGIN { nonempty = 0; } \
	142	{ items[$$0] = 1; nonempty = 1; } \
	143	END { if (nonempty) { for (i in items) print i; }; } \
	144	'
	145	# Make sure the list of sources is unique. This is necessary because,
	146	# e.g., the same source file might be shared among _SOURCES variables
	147	# for different programs/libraries.
	148	am__define_uniq_tagged_files = \
	149	list='$(am__tagged_files)'; \
	150	unique=`for i in $$list; do \
	151	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	152	done \| $(am__uniquify_input)`
112	153	ETAGS = etags
113	154	CTAGS = ctags
114	155	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

118	159	ADOLC_DIR = @ADOLC_DIR@
119	160	AMTAR = @AMTAR@
120	161	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	162	AR = @AR@
121	163	AUTOCONF = @AUTOCONF@
122	164	AUTOHEADER = @AUTOHEADER@
123	165	AUTOMAKE = @AUTOMAKE@

139	181	CXX_FLAGS_EIGEN = @CXX_FLAGS_EIGEN@
140	182	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
141	183	CYGPATH_W = @CYGPATH_W@
142
143		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
144		# -----------------------------------------------------------------------------
145		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
146		#
147		# CppAD is distributed under multiple licenses. This distribution is under
148		# the terms of the
149		# GNU General Public License Version 3.
150		#
151		# A copy of this license is included in the COPYING file of this distribution.
152		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
153		# -----------------------------------------------------------------------------
154		#
155		# automake input file
156	184	#
157	185	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
158	186	DEFS =

208	236	abs_srcdir = @abs_srcdir@
209	237	abs_top_builddir = @abs_top_builddir@
210	238	abs_top_srcdir = @abs_top_srcdir@
	239	ac_ct_AR = @ac_ct_AR@
211	240	ac_ct_CC = @ac_ct_CC@
212	241	ac_ct_CXX = @ac_ct_CXX@
213	242	ac_ct_FC = @ac_ct_FC@

218	247	am__tar = @am__tar@
219	248	am__untar = @am__untar@
220	249	bindir = @bindir@
	250	build = @build@
221	251	build_alias = @build_alias@
	252	build_cpu = @build_cpu@
	253	build_os = @build_os@
	254	build_vendor = @build_vendor@
222	255	builddir = @builddir@
223	256	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
224	257	cppad_boostvector = @cppad_boostvector@
225	258	cppad_cflags = @cppad_cflags@
	259	cppad_compiler_has_erf = @cppad_compiler_has_erf@
226	260	cppad_cppadvector = @cppad_cppadvector@
227	261	cppad_description = @cppad_description@
228	262	cppad_eigenvector = @cppad_eigenvector@
	263	cppad_has_colpack = @cppad_has_colpack@
	264	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
229	265	cppad_has_gettimeofday = @cppad_has_gettimeofday@
230	266	cppad_has_nullptr = @cppad_has_nullptr@
	267	cppad_has_rvalue = @cppad_has_rvalue@
231	268	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
232	269	cppad_internal_sparse_set = @cppad_internal_sparse_set@
233	270	cppad_libs = @cppad_libs@
234	271	cppad_max_num_threads = @cppad_max_num_threads@
235	272	cppad_requires = @cppad_requires@
236		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	273	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
237	274	cppad_stdvector = @cppad_stdvector@
238	275	cppad_tape_addr_type = @cppad_tape_addr_type@
239	276	cppad_tape_id_type = @cppad_tape_id_type@

245	282	dvidir = @dvidir@
246	283	eigen_prefix = @eigen_prefix@
247	284	exec_prefix = @exec_prefix@
248		have_ar = @have_ar@
249	285	have_pkg_config = @have_pkg_config@
	286	host = @host@
250	287	host_alias = @host_alias@
	288	host_cpu = @host_cpu@
	289	host_os = @host_os@
	290	host_vendor = @host_vendor@
251	291	htmldir = @htmldir@
252	292	includedir = @includedir@
253	293	infodir = @infodir@

272	312	top_build_prefix = @top_build_prefix@
273	313	top_builddir = @top_builddir@
274	314	top_srcdir = @top_srcdir@
	315
	316	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
	317	# -----------------------------------------------------------------------------
	318	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	319	#
	320	# CppAD is distributed under multiple licenses. This distribution is under
	321	# the terms of the
	322	# GNU General Public License Version 3.
	323	#
	324	# A copy of this license is included in the COPYING file of this distribution.
	325	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	326	# -----------------------------------------------------------------------------
	327	source_list = \
	328	main.cpp \
	329	ode.cpp \
	330	det_lu.cpp \
	331	det_minor.cpp \
	332	mat_mul.cpp \
	333	poly.cpp \
	334	sparse_hessian.cpp \
	335	sparse_jacobian.cpp \
	336	link_det_lu.cpp \
	337	link_det_minor.cpp \
	338	link_mat_mul.cpp \
	339	link_ode.cpp \
	340	link_poly.cpp \
	341	link_sparse_hessian.cpp \
	342	link_sparse_jacobian.cpp \
	343	microsoft_timer.cpp
	344
	345	#
	346	# make separate copy of source files because building with different flags
	347	BUILT_SOURCES = $(source_list)
275	348	#
276	349	EXTRA_DIST = \
277	350	gprof.sed

280	353	AM_CPPFLAGS = -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
281	354	#
282	355	# BEGIN OPTIMIZE
283		AM_CXXFLAGS = -pg -O2 -DSPEED_PROFILE -DNDEBUG $(CXX_FLAGS)
	356	AM_CXXFLAGS = -pg -O2 -DCPPAD_PROFILE_SPEED -DNDEBUG $(CXX_FLAGS)
284	357	# END OPTIMIZE
285	358	#
286	359	# BEGIN DEBUG
287		# AM_CXXFLAGS = -g $(CXX_FLAGS) -DSPEED_PROFILE
	360	# AM_CXXFLAGS = -g $(CXX_FLAGS) -DCPPAD_PROFILE_SPEED
288	361	# END DEBUG
289	362	#
290	363	AM_LDFLAGS = -pg
291	364	#
292		profile_SOURCES = \
293		../cppad/print_optimize.hpp \
294		../cppad/print_optimize.cpp \
295		../main.cpp \
296		../cppad/ode.cpp \
297		../cppad/det_lu.cpp \
298		../cppad/det_minor.cpp \
299		../cppad/mat_mul.cpp \
300		../cppad/poly.cpp \
301		../cppad/sparse_hessian.cpp \
302		../cppad/sparse_jacobian.cpp \
303		../src/link_det_lu.cpp \
304		../src/link_det_minor.cpp \
305		../src/link_mat_mul.cpp \
306		../src/link_ode.cpp \
307		../src/link_poly.cpp \
308		../src/link_sparse_hessian.cpp \
309		../src/link_sparse_jacobian.cpp \
310		../src/microsoft_timer.cpp
311
312		all: all-am
	365	speed_profile_SOURCES = $(source_list)
	366	all: $(BUILT_SOURCES)
	367	$(MAKE) $(AM_MAKEFLAGS) all-am
313	368
314	369	.SUFFIXES:
315	370	.SUFFIXES: .cpp .o .obj

348	403
349	404	clean-checkPROGRAMS:
350	405	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
351		profile$(EXEEXT): $(profile_OBJECTS) $(profile_DEPENDENCIES) $(EXTRA_profile_DEPENDENCIES)
352		@rm -f profile$(EXEEXT)
353		$(AM_V_CXXLD)$(CXXLINK) $(profile_OBJECTS) $(profile_LDADD) $(LIBS)
	406
	407	speed_profile$(EXEEXT): $(speed_profile_OBJECTS) $(speed_profile_DEPENDENCIES) $(EXTRA_speed_profile_DEPENDENCIES)
	408	@rm -f speed_profile$(EXEEXT)
	409	$(AM_V_CXXLD)$(CXXLINK) $(speed_profile_OBJECTS) $(speed_profile_LDADD) $(LIBS)
354	410
355	411	mostlyclean-compile:
356	412	-rm -f *.$(OBJEXT)

372	428	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/microsoft_timer.Po@am__quote@
373	429	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ode.Po@am__quote@
374	430	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/poly.Po@am__quote@
375		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print_optimize.Po@am__quote@
376	431	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_hessian.Po@am__quote@
377	432	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_jacobian.Po@am__quote@
378	433
379	434	.cpp.o:
380		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
381		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	435	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	436	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	437	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
382	438	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
383	439	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
384	440	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
385	441
386	442	.cpp.obj:
387		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
388		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	443	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	444	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	445	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
389	446	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
390	447	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
391	448	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
392	449
393		print_optimize.o: ../cppad/print_optimize.cpp
394		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT print_optimize.o -MD -MP -MF $(DEPDIR)/print_optimize.Tpo -c -o print_optimize.o `test -f '../cppad/print_optimize.cpp' \|\| echo '$(srcdir)/'`../cppad/print_optimize.cpp
395		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/print_optimize.Tpo $(DEPDIR)/print_optimize.Po
396		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/print_optimize.cpp' object='print_optimize.o' libtool=no @AMDEPBACKSLASH@
397		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
398		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o print_optimize.o `test -f '../cppad/print_optimize.cpp' \|\| echo '$(srcdir)/'`../cppad/print_optimize.cpp
399
400		print_optimize.obj: ../cppad/print_optimize.cpp
401		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT print_optimize.obj -MD -MP -MF $(DEPDIR)/print_optimize.Tpo -c -o print_optimize.obj `if test -f '../cppad/print_optimize.cpp'; then $(CYGPATH_W) '../cppad/print_optimize.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/print_optimize.cpp'; fi`
402		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/print_optimize.Tpo $(DEPDIR)/print_optimize.Po
403		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/print_optimize.cpp' object='print_optimize.obj' libtool=no @AMDEPBACKSLASH@
404		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
405		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o print_optimize.obj `if test -f '../cppad/print_optimize.cpp'; then $(CYGPATH_W) '../cppad/print_optimize.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/print_optimize.cpp'; fi`
406
407		main.o: ../main.cpp
408		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.o -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
409		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
410		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.o' libtool=no @AMDEPBACKSLASH@
411		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
412		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
413
414		main.obj: ../main.cpp
415		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.obj -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
416		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
417		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.obj' libtool=no @AMDEPBACKSLASH@
418		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
419		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
420
421		ode.o: ../cppad/ode.cpp
422		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT ode.o -MD -MP -MF $(DEPDIR)/ode.Tpo -c -o ode.o `test -f '../cppad/ode.cpp' \|\| echo '$(srcdir)/'`../cppad/ode.cpp
423		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/ode.Tpo $(DEPDIR)/ode.Po
424		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/ode.cpp' object='ode.o' libtool=no @AMDEPBACKSLASH@
425		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
426		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o ode.o `test -f '../cppad/ode.cpp' \|\| echo '$(srcdir)/'`../cppad/ode.cpp
427
428		ode.obj: ../cppad/ode.cpp
429		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT ode.obj -MD -MP -MF $(DEPDIR)/ode.Tpo -c -o ode.obj `if test -f '../cppad/ode.cpp'; then $(CYGPATH_W) '../cppad/ode.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/ode.cpp'; fi`
430		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/ode.Tpo $(DEPDIR)/ode.Po
431		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/ode.cpp' object='ode.obj' libtool=no @AMDEPBACKSLASH@
432		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
433		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o ode.obj `if test -f '../cppad/ode.cpp'; then $(CYGPATH_W) '../cppad/ode.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/ode.cpp'; fi`
434
435		det_lu.o: ../cppad/det_lu.cpp
436		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT det_lu.o -MD -MP -MF $(DEPDIR)/det_lu.Tpo -c -o det_lu.o `test -f '../cppad/det_lu.cpp' \|\| echo '$(srcdir)/'`../cppad/det_lu.cpp
437		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/det_lu.Tpo $(DEPDIR)/det_lu.Po
438		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/det_lu.cpp' object='det_lu.o' libtool=no @AMDEPBACKSLASH@
439		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
440		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o det_lu.o `test -f '../cppad/det_lu.cpp' \|\| echo '$(srcdir)/'`../cppad/det_lu.cpp
441
442		det_lu.obj: ../cppad/det_lu.cpp
443		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT det_lu.obj -MD -MP -MF $(DEPDIR)/det_lu.Tpo -c -o det_lu.obj `if test -f '../cppad/det_lu.cpp'; then $(CYGPATH_W) '../cppad/det_lu.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/det_lu.cpp'; fi`
444		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/det_lu.Tpo $(DEPDIR)/det_lu.Po
445		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/det_lu.cpp' object='det_lu.obj' libtool=no @AMDEPBACKSLASH@
446		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
447		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o det_lu.obj `if test -f '../cppad/det_lu.cpp'; then $(CYGPATH_W) '../cppad/det_lu.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/det_lu.cpp'; fi`
448
449		det_minor.o: ../cppad/det_minor.cpp
450		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT det_minor.o -MD -MP -MF $(DEPDIR)/det_minor.Tpo -c -o det_minor.o `test -f '../cppad/det_minor.cpp' \|\| echo '$(srcdir)/'`../cppad/det_minor.cpp
451		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/det_minor.Tpo $(DEPDIR)/det_minor.Po
452		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/det_minor.cpp' object='det_minor.o' libtool=no @AMDEPBACKSLASH@
453		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
454		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o det_minor.o `test -f '../cppad/det_minor.cpp' \|\| echo '$(srcdir)/'`../cppad/det_minor.cpp
455
456		det_minor.obj: ../cppad/det_minor.cpp
457		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT det_minor.obj -MD -MP -MF $(DEPDIR)/det_minor.Tpo -c -o det_minor.obj `if test -f '../cppad/det_minor.cpp'; then $(CYGPATH_W) '../cppad/det_minor.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/det_minor.cpp'; fi`
458		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/det_minor.Tpo $(DEPDIR)/det_minor.Po
459		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/det_minor.cpp' object='det_minor.obj' libtool=no @AMDEPBACKSLASH@
460		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
461		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o det_minor.obj `if test -f '../cppad/det_minor.cpp'; then $(CYGPATH_W) '../cppad/det_minor.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/det_minor.cpp'; fi`
462
463		mat_mul.o: ../cppad/mat_mul.cpp
464		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT mat_mul.o -MD -MP -MF $(DEPDIR)/mat_mul.Tpo -c -o mat_mul.o `test -f '../cppad/mat_mul.cpp' \|\| echo '$(srcdir)/'`../cppad/mat_mul.cpp
465		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/mat_mul.Tpo $(DEPDIR)/mat_mul.Po
466		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/mat_mul.cpp' object='mat_mul.o' libtool=no @AMDEPBACKSLASH@
467		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
468		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o mat_mul.o `test -f '../cppad/mat_mul.cpp' \|\| echo '$(srcdir)/'`../cppad/mat_mul.cpp
469
470		mat_mul.obj: ../cppad/mat_mul.cpp
471		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT mat_mul.obj -MD -MP -MF $(DEPDIR)/mat_mul.Tpo -c -o mat_mul.obj `if test -f '../cppad/mat_mul.cpp'; then $(CYGPATH_W) '../cppad/mat_mul.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/mat_mul.cpp'; fi`
472		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/mat_mul.Tpo $(DEPDIR)/mat_mul.Po
473		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/mat_mul.cpp' object='mat_mul.obj' libtool=no @AMDEPBACKSLASH@
474		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
475		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o mat_mul.obj `if test -f '../cppad/mat_mul.cpp'; then $(CYGPATH_W) '../cppad/mat_mul.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/mat_mul.cpp'; fi`
476
477		poly.o: ../cppad/poly.cpp
478		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT poly.o -MD -MP -MF $(DEPDIR)/poly.Tpo -c -o poly.o `test -f '../cppad/poly.cpp' \|\| echo '$(srcdir)/'`../cppad/poly.cpp
479		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/poly.Tpo $(DEPDIR)/poly.Po
480		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/poly.cpp' object='poly.o' libtool=no @AMDEPBACKSLASH@
481		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
482		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o poly.o `test -f '../cppad/poly.cpp' \|\| echo '$(srcdir)/'`../cppad/poly.cpp
483
484		poly.obj: ../cppad/poly.cpp
485		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT poly.obj -MD -MP -MF $(DEPDIR)/poly.Tpo -c -o poly.obj `if test -f '../cppad/poly.cpp'; then $(CYGPATH_W) '../cppad/poly.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/poly.cpp'; fi`
486		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/poly.Tpo $(DEPDIR)/poly.Po
487		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/poly.cpp' object='poly.obj' libtool=no @AMDEPBACKSLASH@
488		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
489		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o poly.obj `if test -f '../cppad/poly.cpp'; then $(CYGPATH_W) '../cppad/poly.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/poly.cpp'; fi`
490
491		sparse_hessian.o: ../cppad/sparse_hessian.cpp
492		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT sparse_hessian.o -MD -MP -MF $(DEPDIR)/sparse_hessian.Tpo -c -o sparse_hessian.o `test -f '../cppad/sparse_hessian.cpp' \|\| echo '$(srcdir)/'`../cppad/sparse_hessian.cpp
493		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/sparse_hessian.Tpo $(DEPDIR)/sparse_hessian.Po
494		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/sparse_hessian.cpp' object='sparse_hessian.o' libtool=no @AMDEPBACKSLASH@
495		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
496		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o sparse_hessian.o `test -f '../cppad/sparse_hessian.cpp' \|\| echo '$(srcdir)/'`../cppad/sparse_hessian.cpp
497
498		sparse_hessian.obj: ../cppad/sparse_hessian.cpp
499		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT sparse_hessian.obj -MD -MP -MF $(DEPDIR)/sparse_hessian.Tpo -c -o sparse_hessian.obj `if test -f '../cppad/sparse_hessian.cpp'; then $(CYGPATH_W) '../cppad/sparse_hessian.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/sparse_hessian.cpp'; fi`
500		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/sparse_hessian.Tpo $(DEPDIR)/sparse_hessian.Po
501		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/sparse_hessian.cpp' object='sparse_hessian.obj' libtool=no @AMDEPBACKSLASH@
502		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
503		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o sparse_hessian.obj `if test -f '../cppad/sparse_hessian.cpp'; then $(CYGPATH_W) '../cppad/sparse_hessian.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/sparse_hessian.cpp'; fi`
504
505		sparse_jacobian.o: ../cppad/sparse_jacobian.cpp
506		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT sparse_jacobian.o -MD -MP -MF $(DEPDIR)/sparse_jacobian.Tpo -c -o sparse_jacobian.o `test -f '../cppad/sparse_jacobian.cpp' \|\| echo '$(srcdir)/'`../cppad/sparse_jacobian.cpp
507		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/sparse_jacobian.Tpo $(DEPDIR)/sparse_jacobian.Po
508		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/sparse_jacobian.cpp' object='sparse_jacobian.o' libtool=no @AMDEPBACKSLASH@
509		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
510		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o sparse_jacobian.o `test -f '../cppad/sparse_jacobian.cpp' \|\| echo '$(srcdir)/'`../cppad/sparse_jacobian.cpp
511
512		sparse_jacobian.obj: ../cppad/sparse_jacobian.cpp
513		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT sparse_jacobian.obj -MD -MP -MF $(DEPDIR)/sparse_jacobian.Tpo -c -o sparse_jacobian.obj `if test -f '../cppad/sparse_jacobian.cpp'; then $(CYGPATH_W) '../cppad/sparse_jacobian.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/sparse_jacobian.cpp'; fi`
514		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/sparse_jacobian.Tpo $(DEPDIR)/sparse_jacobian.Po
515		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../cppad/sparse_jacobian.cpp' object='sparse_jacobian.obj' libtool=no @AMDEPBACKSLASH@
516		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
517		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o sparse_jacobian.obj `if test -f '../cppad/sparse_jacobian.cpp'; then $(CYGPATH_W) '../cppad/sparse_jacobian.cpp'; else $(CYGPATH_W) '$(srcdir)/../cppad/sparse_jacobian.cpp'; fi`
518
519		link_det_lu.o: ../src/link_det_lu.cpp
520		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_det_lu.o -MD -MP -MF $(DEPDIR)/link_det_lu.Tpo -c -o link_det_lu.o `test -f '../src/link_det_lu.cpp' \|\| echo '$(srcdir)/'`../src/link_det_lu.cpp
521		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_det_lu.Tpo $(DEPDIR)/link_det_lu.Po
522		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_det_lu.cpp' object='link_det_lu.o' libtool=no @AMDEPBACKSLASH@
523		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
524		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_det_lu.o `test -f '../src/link_det_lu.cpp' \|\| echo '$(srcdir)/'`../src/link_det_lu.cpp
525
526		link_det_lu.obj: ../src/link_det_lu.cpp
527		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_det_lu.obj -MD -MP -MF $(DEPDIR)/link_det_lu.Tpo -c -o link_det_lu.obj `if test -f '../src/link_det_lu.cpp'; then $(CYGPATH_W) '../src/link_det_lu.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_det_lu.cpp'; fi`
528		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_det_lu.Tpo $(DEPDIR)/link_det_lu.Po
529		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_det_lu.cpp' object='link_det_lu.obj' libtool=no @AMDEPBACKSLASH@
530		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
531		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_det_lu.obj `if test -f '../src/link_det_lu.cpp'; then $(CYGPATH_W) '../src/link_det_lu.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_det_lu.cpp'; fi`
532
533		link_det_minor.o: ../src/link_det_minor.cpp
534		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_det_minor.o -MD -MP -MF $(DEPDIR)/link_det_minor.Tpo -c -o link_det_minor.o `test -f '../src/link_det_minor.cpp' \|\| echo '$(srcdir)/'`../src/link_det_minor.cpp
535		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_det_minor.Tpo $(DEPDIR)/link_det_minor.Po
536		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_det_minor.cpp' object='link_det_minor.o' libtool=no @AMDEPBACKSLASH@
537		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
538		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_det_minor.o `test -f '../src/link_det_minor.cpp' \|\| echo '$(srcdir)/'`../src/link_det_minor.cpp
539
540		link_det_minor.obj: ../src/link_det_minor.cpp
541		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_det_minor.obj -MD -MP -MF $(DEPDIR)/link_det_minor.Tpo -c -o link_det_minor.obj `if test -f '../src/link_det_minor.cpp'; then $(CYGPATH_W) '../src/link_det_minor.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_det_minor.cpp'; fi`
542		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_det_minor.Tpo $(DEPDIR)/link_det_minor.Po
543		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_det_minor.cpp' object='link_det_minor.obj' libtool=no @AMDEPBACKSLASH@
544		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
545		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_det_minor.obj `if test -f '../src/link_det_minor.cpp'; then $(CYGPATH_W) '../src/link_det_minor.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_det_minor.cpp'; fi`
546
547		link_mat_mul.o: ../src/link_mat_mul.cpp
548		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_mat_mul.o -MD -MP -MF $(DEPDIR)/link_mat_mul.Tpo -c -o link_mat_mul.o `test -f '../src/link_mat_mul.cpp' \|\| echo '$(srcdir)/'`../src/link_mat_mul.cpp
549		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_mat_mul.Tpo $(DEPDIR)/link_mat_mul.Po
550		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_mat_mul.cpp' object='link_mat_mul.o' libtool=no @AMDEPBACKSLASH@
551		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
552		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_mat_mul.o `test -f '../src/link_mat_mul.cpp' \|\| echo '$(srcdir)/'`../src/link_mat_mul.cpp
553
554		link_mat_mul.obj: ../src/link_mat_mul.cpp
555		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_mat_mul.obj -MD -MP -MF $(DEPDIR)/link_mat_mul.Tpo -c -o link_mat_mul.obj `if test -f '../src/link_mat_mul.cpp'; then $(CYGPATH_W) '../src/link_mat_mul.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_mat_mul.cpp'; fi`
556		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_mat_mul.Tpo $(DEPDIR)/link_mat_mul.Po
557		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_mat_mul.cpp' object='link_mat_mul.obj' libtool=no @AMDEPBACKSLASH@
558		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
559		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_mat_mul.obj `if test -f '../src/link_mat_mul.cpp'; then $(CYGPATH_W) '../src/link_mat_mul.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_mat_mul.cpp'; fi`
560
561		link_ode.o: ../src/link_ode.cpp
562		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_ode.o -MD -MP -MF $(DEPDIR)/link_ode.Tpo -c -o link_ode.o `test -f '../src/link_ode.cpp' \|\| echo '$(srcdir)/'`../src/link_ode.cpp
563		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_ode.Tpo $(DEPDIR)/link_ode.Po
564		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_ode.cpp' object='link_ode.o' libtool=no @AMDEPBACKSLASH@
565		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
566		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_ode.o `test -f '../src/link_ode.cpp' \|\| echo '$(srcdir)/'`../src/link_ode.cpp
567
568		link_ode.obj: ../src/link_ode.cpp
569		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_ode.obj -MD -MP -MF $(DEPDIR)/link_ode.Tpo -c -o link_ode.obj `if test -f '../src/link_ode.cpp'; then $(CYGPATH_W) '../src/link_ode.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_ode.cpp'; fi`
570		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_ode.Tpo $(DEPDIR)/link_ode.Po
571		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_ode.cpp' object='link_ode.obj' libtool=no @AMDEPBACKSLASH@
572		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
573		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_ode.obj `if test -f '../src/link_ode.cpp'; then $(CYGPATH_W) '../src/link_ode.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_ode.cpp'; fi`
574
575		link_poly.o: ../src/link_poly.cpp
576		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_poly.o -MD -MP -MF $(DEPDIR)/link_poly.Tpo -c -o link_poly.o `test -f '../src/link_poly.cpp' \|\| echo '$(srcdir)/'`../src/link_poly.cpp
577		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_poly.Tpo $(DEPDIR)/link_poly.Po
578		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_poly.cpp' object='link_poly.o' libtool=no @AMDEPBACKSLASH@
579		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
580		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_poly.o `test -f '../src/link_poly.cpp' \|\| echo '$(srcdir)/'`../src/link_poly.cpp
581
582		link_poly.obj: ../src/link_poly.cpp
583		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_poly.obj -MD -MP -MF $(DEPDIR)/link_poly.Tpo -c -o link_poly.obj `if test -f '../src/link_poly.cpp'; then $(CYGPATH_W) '../src/link_poly.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_poly.cpp'; fi`
584		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_poly.Tpo $(DEPDIR)/link_poly.Po
585		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_poly.cpp' object='link_poly.obj' libtool=no @AMDEPBACKSLASH@
586		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
587		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_poly.obj `if test -f '../src/link_poly.cpp'; then $(CYGPATH_W) '../src/link_poly.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_poly.cpp'; fi`
588
589		link_sparse_hessian.o: ../src/link_sparse_hessian.cpp
590		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_sparse_hessian.o -MD -MP -MF $(DEPDIR)/link_sparse_hessian.Tpo -c -o link_sparse_hessian.o `test -f '../src/link_sparse_hessian.cpp' \|\| echo '$(srcdir)/'`../src/link_sparse_hessian.cpp
591		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_sparse_hessian.Tpo $(DEPDIR)/link_sparse_hessian.Po
592		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_sparse_hessian.cpp' object='link_sparse_hessian.o' libtool=no @AMDEPBACKSLASH@
593		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
594		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_sparse_hessian.o `test -f '../src/link_sparse_hessian.cpp' \|\| echo '$(srcdir)/'`../src/link_sparse_hessian.cpp
595
596		link_sparse_hessian.obj: ../src/link_sparse_hessian.cpp
597		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_sparse_hessian.obj -MD -MP -MF $(DEPDIR)/link_sparse_hessian.Tpo -c -o link_sparse_hessian.obj `if test -f '../src/link_sparse_hessian.cpp'; then $(CYGPATH_W) '../src/link_sparse_hessian.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_sparse_hessian.cpp'; fi`
598		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_sparse_hessian.Tpo $(DEPDIR)/link_sparse_hessian.Po
599		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_sparse_hessian.cpp' object='link_sparse_hessian.obj' libtool=no @AMDEPBACKSLASH@
600		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
601		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_sparse_hessian.obj `if test -f '../src/link_sparse_hessian.cpp'; then $(CYGPATH_W) '../src/link_sparse_hessian.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_sparse_hessian.cpp'; fi`
602
603		link_sparse_jacobian.o: ../src/link_sparse_jacobian.cpp
604		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_sparse_jacobian.o -MD -MP -MF $(DEPDIR)/link_sparse_jacobian.Tpo -c -o link_sparse_jacobian.o `test -f '../src/link_sparse_jacobian.cpp' \|\| echo '$(srcdir)/'`../src/link_sparse_jacobian.cpp
605		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_sparse_jacobian.Tpo $(DEPDIR)/link_sparse_jacobian.Po
606		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_sparse_jacobian.cpp' object='link_sparse_jacobian.o' libtool=no @AMDEPBACKSLASH@
607		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
608		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_sparse_jacobian.o `test -f '../src/link_sparse_jacobian.cpp' \|\| echo '$(srcdir)/'`../src/link_sparse_jacobian.cpp
609
610		link_sparse_jacobian.obj: ../src/link_sparse_jacobian.cpp
611		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT link_sparse_jacobian.obj -MD -MP -MF $(DEPDIR)/link_sparse_jacobian.Tpo -c -o link_sparse_jacobian.obj `if test -f '../src/link_sparse_jacobian.cpp'; then $(CYGPATH_W) '../src/link_sparse_jacobian.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_sparse_jacobian.cpp'; fi`
612		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/link_sparse_jacobian.Tpo $(DEPDIR)/link_sparse_jacobian.Po
613		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/link_sparse_jacobian.cpp' object='link_sparse_jacobian.obj' libtool=no @AMDEPBACKSLASH@
614		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
615		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o link_sparse_jacobian.obj `if test -f '../src/link_sparse_jacobian.cpp'; then $(CYGPATH_W) '../src/link_sparse_jacobian.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/link_sparse_jacobian.cpp'; fi`
616
617		microsoft_timer.o: ../src/microsoft_timer.cpp
618		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT microsoft_timer.o -MD -MP -MF $(DEPDIR)/microsoft_timer.Tpo -c -o microsoft_timer.o `test -f '../src/microsoft_timer.cpp' \|\| echo '$(srcdir)/'`../src/microsoft_timer.cpp
619		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/microsoft_timer.Tpo $(DEPDIR)/microsoft_timer.Po
620		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/microsoft_timer.cpp' object='microsoft_timer.o' libtool=no @AMDEPBACKSLASH@
621		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
622		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o microsoft_timer.o `test -f '../src/microsoft_timer.cpp' \|\| echo '$(srcdir)/'`../src/microsoft_timer.cpp
623
624		microsoft_timer.obj: ../src/microsoft_timer.cpp
625		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT microsoft_timer.obj -MD -MP -MF $(DEPDIR)/microsoft_timer.Tpo -c -o microsoft_timer.obj `if test -f '../src/microsoft_timer.cpp'; then $(CYGPATH_W) '../src/microsoft_timer.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/microsoft_timer.cpp'; fi`
626		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/microsoft_timer.Tpo $(DEPDIR)/microsoft_timer.Po
627		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../src/microsoft_timer.cpp' object='microsoft_timer.obj' libtool=no @AMDEPBACKSLASH@
628		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
629		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o microsoft_timer.obj `if test -f '../src/microsoft_timer.cpp'; then $(CYGPATH_W) '../src/microsoft_timer.cpp'; else $(CYGPATH_W) '$(srcdir)/../src/microsoft_timer.cpp'; fi`
630
631		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
632		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
633		unique=`for i in $$list; do \
634		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
635		done \| \
636		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
637		END { if (nonempty) { for (i in files) print i; }; }'`; \
638		mkid -fID $$unique
639		tags: TAGS
640
641		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
642		$(TAGS_FILES) $(LISP)
	450	ID: $(am__tagged_files)
	451	$(am__define_uniq_tagged_files); mkid -fID $$unique
	452	tags: tags-am
	453	TAGS: tags
	454
	455	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
643	456	set x; \
644	457	here=`pwd`; \
645		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
646		unique=`for i in $$list; do \
647		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
648		done \| \
649		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
650		END { if (nonempty) { for (i in files) print i; }; }'`; \
	458	$(am__define_uniq_tagged_files); \
651	459	shift; \
652	460	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
653	461	test -n "$$unique" \|\| unique=$$empty_fix; \

659	467	$$unique; \
660	468	fi; \
661	469	fi
662		ctags: CTAGS
663		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
664		$(TAGS_FILES) $(LISP)
665		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
666		unique=`for i in $$list; do \
667		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
668		done \| \
669		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
670		END { if (nonempty) { for (i in files) print i; }; }'`; \
	470	ctags: ctags-am
	471
	472	CTAGS: ctags
	473	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	474	$(am__define_uniq_tagged_files); \
671	475	test -z "$(CTAGS_ARGS)$$unique" \
672	476	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
673	477	$$unique

676	480	here=`$(am__cd) $(top_builddir) && pwd` \
677	481	&& $(am__cd) $(top_srcdir) \
678	482	&& gtags -i $(GTAGS_ARGS) "$$here"
	483	cscopelist: cscopelist-am
	484
	485	cscopelist-am: $(am__tagged_files)
	486	list='$(am__tagged_files)'; \
	487	case "$(srcdir)" in \
	488	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	489	*) sdir=$(subdir)/$(srcdir) ;; \
	490	esac; \
	491	for i in $$list; do \
	492	if test -f "$$i"; then \
	493	echo "$(subdir)/$$i"; \
	494	else \
	495	echo "$$sdir/$$i"; \
	496	fi; \
	497	done >> $(top_builddir)/cscope.files
679	498
680	499	distclean-tags:
681	500	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

712	531	done
713	532	check-am: all-am
714	533	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
715		check: check-am
	534	check: $(BUILT_SOURCES)
	535	$(MAKE) $(AM_MAKEFLAGS) check-am
716	536	all-am: makefile
717	537	installdirs:
718		install: install-am
	538	install: $(BUILT_SOURCES)
	539	$(MAKE) $(AM_MAKEFLAGS) install-am
719	540	install-exec: install-exec-am
720	541	install-data: install-data-am
721	542	uninstall: uninstall-am

745	566	maintainer-clean-generic:
746	567	@echo "This command is intended for maintainers to use"
747	568	@echo "it deletes files that may require special tools to rebuild."
	569	-test -z "$(BUILT_SOURCES)" \|\| rm -f $(BUILT_SOURCES)
748	570	clean: clean-am
749	571
750	572	clean-am: clean-checkPROGRAMS clean-generic mostlyclean-am

814	636
815	637	uninstall-am:
816	638
817		.MAKE: check-am install-am install-strip
818
819		.PHONY: CTAGS GTAGS all all-am check check-am clean \
820		clean-checkPROGRAMS clean-generic ctags distclean \
821		distclean-compile distclean-generic distclean-tags distdir dvi \
822		dvi-am html html-am info info-am install install-am \
823		install-data install-data-am install-dvi install-dvi-am \
824		install-exec install-exec-am install-html install-html-am \
825		install-info install-info-am install-man install-pdf \
826		install-pdf-am install-ps install-ps-am install-strip \
827		installcheck installcheck-am installdirs maintainer-clean \
828		maintainer-clean-generic mostlyclean mostlyclean-compile \
829		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
830		uninstall-am
831
832
	639	.MAKE: all check check-am install install-am install-strip
	640
	641	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	642	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	643	distclean distclean-compile distclean-generic distclean-tags \
	644	distdir dvi dvi-am html html-am info info-am install \
	645	install-am install-data install-data-am install-dvi \
	646	install-dvi-am install-exec install-exec-am install-html \
	647	install-html-am install-info install-info-am install-man \
	648	install-pdf install-pdf-am install-ps install-ps-am \
	649	install-strip installcheck installcheck-am installdirs \
	650	maintainer-clean maintainer-clean-generic mostlyclean \
	651	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	652	tags tags-am uninstall uninstall-am
	653
	654	#
	655	main.cpp: $(srcdir)/../main.cpp
	656	cp $(srcdir)/../main.cpp main.cpp
	657	ode.cpp: $(srcdir)/../cppad/ode.cpp
	658	cp $(srcdir)/../cppad/ode.cpp ode.cpp
	659	det_lu.cpp: $(srcdir)/../cppad/det_lu.cpp
	660	cp $(srcdir)/../cppad/det_lu.cpp det_lu.cpp
	661	det_minor.cpp: $(srcdir)/../cppad/det_minor.cpp
	662	cp $(srcdir)/../cppad/det_minor.cpp det_minor.cpp
	663	mat_mul.cpp: $(srcdir)/../cppad/mat_mul.cpp
	664	cp $(srcdir)/../cppad/mat_mul.cpp mat_mul.cpp
	665	poly.cpp: $(srcdir)/../cppad/poly.cpp
	666	cp $(srcdir)/../cppad/poly.cpp poly.cpp
	667	sparse_hessian.cpp: $(srcdir)/../cppad/sparse_hessian.cpp
	668	cp $(srcdir)/../cppad/sparse_hessian.cpp sparse_hessian.cpp
	669	sparse_jacobian.cpp: $(srcdir)/../cppad/sparse_jacobian.cpp
	670	cp $(srcdir)/../cppad/sparse_jacobian.cpp sparse_jacobian.cpp
	671	link_det_lu.cpp: $(srcdir)/../src/link_det_lu.cpp
	672	cp $(srcdir)/../src/link_det_lu.cpp link_det_lu.cpp
	673	link_det_minor.cpp: $(srcdir)/../src/link_det_minor.cpp
	674	cp $(srcdir)/../src/link_det_minor.cpp link_det_minor.cpp
	675	link_mat_mul.cpp: $(srcdir)/../src/link_mat_mul.cpp
	676	cp $(srcdir)/../src/link_mat_mul.cpp link_mat_mul.cpp
	677	link_ode.cpp: $(srcdir)/../src/link_ode.cpp
	678	cp $(srcdir)/../src/link_ode.cpp link_ode.cpp
	679	link_poly.cpp: $(srcdir)/../src/link_poly.cpp
	680	cp $(srcdir)/../src/link_poly.cpp link_poly.cpp
	681	link_sparse_hessian.cpp: $(srcdir)/../src/link_sparse_hessian.cpp
	682	cp $(srcdir)/../src/link_sparse_hessian.cpp link_sparse_hessian.cpp
	683	link_sparse_jacobian.cpp: $(srcdir)/../src/link_sparse_jacobian.cpp
	684	cp $(srcdir)/../src/link_sparse_jacobian.cpp link_sparse_jacobian.cpp
	685	microsoft_timer.cpp: $(srcdir)/../src/microsoft_timer.cpp
	686	cp $(srcdir)/../src/microsoft_timer.cpp microsoft_timer.cpp
	687	#
833	688	test: check
834		./profile correct 123
	689	./speed_profile correct 123
835	690
836	691	# Tell versions [3.59,3.63) of GNU make to not export all variables.
837	692	# Otherwise a system limit (for SysV at least) may be exceeded.

+33

-9

speed/sacado/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2765 2013-03-03 15:48:35Z bradbell $
	0	# $Id: CMakeLists.txt 3320 2014-09-11 23:06:21Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

10	10	# -----------------------------------------------------------------------------
11	11	# Build the speed/sacado directory tests
12	12	# Inherit environment from ../CMakeList.txt
	13	# CMAKE_BUILD_TYPE determined by parent directory
13	14
14	15	# assert sacado_prefix is defined
15	16	IF ( NOT sacado_prefix )

18	19	)
19	20	ENDIF ( NOT sacado_prefix )
20	21
21		# Specifies build type for this directory. Possible values are
22		# empty, Debug, Release, RelWithDebInfo and MinSizeRel
23		SET(CMAKE_BUILD_TYPE RELEASE)
24
25	22	# Adds flags to the compiler command line for sources in the current directory
26	23	# and below. This command can be used to add any flags, but it was originally
27	24	# intended to add preprocessor definitions.
28		ADD_DEFINITIONS("-DSPEED_SACADO -DRAD_AUTO_AD_Const")
	25	ADD_DEFINITIONS("-DCPPAD_SACADO_SPEED -DRAD_AUTO_AD_Const")
29	26
30	27	# Local include directories to search (not in package_prefix/includdir)
31	28	INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/../src )

46	43	# Compiler flags for cppad source
47	44	add_cppad_cxx_flags( speed_sacado )
48	45
	46	# Find name used for teuchos library
	47	SET(teuchos_lib NOTFOUND)
	48	FOREACH(dir ${cmake_install_libdirs})
	49	FILE(GLOB file_list ${sacado_prefix}/${dir}/libteuchoscore.*)
	50	IF(file_list)
	51	SET(teuchos_lib teuchoscore)
	52	ENDIF(file_list)
	53	FILE(GLOB file_list ${sacado_prefix}/${dir}/libteuchos.*)
	54	IF(file_list)
	55	SET(teuchos_lib teuchos)
	56	ENDIF(file_list)
	57	ENDFOREACH(dir)
	58
49	59	# List of libraries to be linked into the specified target
50		TARGET_LINK_LIBRARIES(speed_sacado speed_src sacado teuchos)
51
	60	IF(teuchos_lib)
	61	TARGET_LINK_LIBRARIES(speed_sacado speed_src sacado ${teuchos_lib})
	62	ELSE(teuchos_lib)
	63	MESSAGE(FATAT_ERROR
	64	"
	65	For all dir in cmake_install_libdirs, cannot find either
	66	sacado_prefix/dir/teuchos
	67	sacado_prefix/dir/teuchoscore
	68	where
	69	sacado_prefix = ${sacado_prefix}
	70	cmake_install_libdirs = ${cmake_install_libdirs}
	71	teuchos_lib= ${teuchos_lib}
	72	"
	73	)
	74	ENDIF(teuchos_lib)
	75	#
52	76	# Add the check_speed_sacado target
53	77	ADD_CUSTOM_TARGET(check_speed_sacado
54	78	speed_sacado correct 54321

+10

-7

speed/sacado/det_lu.cpp less more

0		/* $Id: det_lu.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_lu.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin sacado_det_lu.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	cppad
16	16	Lu
17	17	det

48	48	# include <cppad/speed/uniform_01.hpp>
49	49	# include <cppad/vector.hpp>
50	50
	51	// list of possible options
	52	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	53
51	54	bool link_det_lu(
52	55	size_t size ,
53	56	size_t repeat ,

55	58	CppAD::vector<double> &gradient )
56	59	{
57	60	// speed test global option values
58		extern bool global_retape, global_atomic, global_optimize;
59		if( ! global_retape \|\| global_optimize \|\| global_atomic )
	61	if( global_onetape \|\| global_atomic )
60	62	return false;
61
	63	if( global_memory \|\| global_optimize )
	64	return false;
62	65	// -----------------------------------------------------
63	66	// setup
64
	67	//
65	68	// object for computing determinant
66	69	typedef Sacado::Rad::ADvar<double> ADScalar;
67	70	typedef CppAD::vector<ADScalar> ADVector;

+11

-7

speed/sacado/det_minor.cpp less more

0		/* $Id: det_minor.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: det_minor.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin sacado_det_minor.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	cppad
16	16	det
17	17	const

44	44	# include <cppad/speed/det_by_minor.hpp>
45	45	# include <cppad/speed/uniform_01.hpp>
46	46	# include <cppad/vector.hpp>
	47
	48	// list of possible options
	49	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	50
47	51	bool link_det_minor(
48	52	size_t size ,
49	53	size_t repeat ,

51	55	CppAD::vector<double> &gradient )
52	56	{
53	57	// speed test global option values
54		extern bool global_retape, global_atomic, global_optimize;
55		if( ! global_retape \|\| global_optimize \|\| global_atomic )
56		return false;
57
	58	if( global_atomic )
	59	return false;
	60	if( global_memory \|\| global_onetape \|\| global_optimize )
	61	return false;
58	62	// -----------------------------------------------------
59	63	// setup
60	64

+14

-10

speed/sacado/makefile.am less more

0		# $Id: makefile.am 2765 2013-03-03 15:48:35Z bradbell $
	0	# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

9	9	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10	10	# -----------------------------------------------------------------------------
11	11	#
12		# automake input file
	12	# Copy source file so that main.o does not end up in parent directory
	13	BUILT_SOURCES = main.cpp
	14	main.cpp:
	15	cp $(srcdir)/../main.cpp main.cpp
	16	#
13	17	#
14	18	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
15	19	DEFS =
16	20	#
17		check_PROGRAMS = sacado
	21	check_PROGRAMS = speed_sacado
18	22	#
19	23	AM_CPPFLAGS = \
20	24	-I$(top_srcdir) \

23	27	$(EIGEN_INCLUDE)
24	28	#
25	29	# BEGIN OPTIMIZE
26		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_SACADO \
	30	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_SACADO_SPEED \
27	31	-DRAD_EQ_ALIAS -DRAD_AUTO_AD_Const $(CXX_FLAGS)
28	32	# END OPTIMIZE
29	33	#
30	34	# BEGIN DEBUG
31		# AM_CXXFLAGS = -g $(CXX_FLAGS) $(CXX_FLAGS) -DSPEED_SACADO -DRAD_AUTO_AD_Const
	35	# AM_CXXFLAGS = -g $(CXX_FLAGS) $(CXX_FLAGS) -DCPPAD_SACADO_SPEED -DRAD_AUTO_AD_Const
32	36	# END DEBUG
33	37	#
34		LDADD = -lspeed -lsacado -lteuchos
	38	LDADD = -lspeed -lsacado -lteuchoscore
35	39	AM_LDFLAGS = -L../src -L$(SACADO_DIR)/lib -L$(SACADO_DIR)/lib64
36	40	#
37		sacado_SOURCES = \
38		../main.cpp \
	41	speed_sacado_SOURCES = \
	42	main.cpp \
39	43	det_lu.cpp \
40	44	det_minor.cpp \
41	45	mat_mul.cpp \

45	49	sparse_jacobian.cpp
46	50
47	51	test: check
48		./sacado correct 123 retape
	52	./speed_sacado correct 123

+187

-125

speed/sacado/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

14	13
15	14	@SET_MAKE@
16	15	VPATH = @srcdir@
17		am__make_dryrun = \
18		{ \
19		am__dry=no; \
	16	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	17	am__make_running_with_option = \
	18	case $${target_option-} in \
	19	?) ;; \
	20	*) echo "am__make_running_with_option: internal error: invalid" \
	21	"target option '$${target_option-}' specified" >&2; \
	22	exit 1;; \
	23	esac; \
	24	has_opt=no; \
	25	sane_makeflags=$$MAKEFLAGS; \
	26	if $(am__is_gnu_make); then \
	27	sane_makeflags=$$MFLAGS; \
	28	else \
20	29	case $$MAKEFLAGS in \
21	30	\\[\ \ ]) \
22		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
23		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
24		*) \
25		for am__flg in $$MAKEFLAGS; do \
26		case $$am__flg in \
27		=\|--*) ;; \
28		n) am__dry=yes; break;; \
29		esac; \
30		done;; \
	31	bs=\\; \
	32	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	33	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
31	34	esac; \
32		test $$am__dry = yes; \
33		}
	35	fi; \
	36	skip_next=no; \
	37	strip_trailopt () \
	38	{ \
	39	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	40	}; \
	41	for flg in $$sane_makeflags; do \
	42	test $$skip_next = yes && { skip_next=no; continue; }; \
	43	case $$flg in \
	44	=\|--*) continue;; \
	45	-*I) strip_trailopt 'I'; skip_next=yes;; \
	46	-I?) strip_trailopt 'I';; \
	47	-*O) strip_trailopt 'O'; skip_next=yes;; \
	48	-O?) strip_trailopt 'O';; \
	49	-*l) strip_trailopt 'l'; skip_next=yes;; \
	50	-l?) strip_trailopt 'l';; \
	51	-[dEDm]) skip_next=yes;; \
	52	-[JT]) skip_next=yes;; \
	53	esac; \
	54	case $$flg in \
	55	$$target_option) has_opt=yes; break;; \
	56	esac; \
	57	done; \
	58	test $$has_opt = yes
	59	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	60	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
34	61	pkgdatadir = $(datadir)/@PACKAGE@
35	62	pkgincludedir = $(includedir)/@PACKAGE@
36	63	pkglibdir = $(libdir)/@PACKAGE@

47	74	NORMAL_UNINSTALL = :
48	75	PRE_UNINSTALL = :
49	76	POST_UNINSTALL = :
50		check_PROGRAMS = sacado$(EXEEXT)
	77	build_triplet = @build@
	78	host_triplet = @host@
	79	check_PROGRAMS = speed_sacado$(EXEEXT)
51	80	subdir = speed/sacado
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

57	87	mkinstalldirs = $(install_sh) -d
58	88	CONFIG_CLEAN_FILES =
59	89	CONFIG_CLEAN_VPATH_FILES =
60		am_sacado_OBJECTS = main.$(OBJEXT) det_lu.$(OBJEXT) \
	90	am_speed_sacado_OBJECTS = main.$(OBJEXT) det_lu.$(OBJEXT) \
61	91	det_minor.$(OBJEXT) mat_mul.$(OBJEXT) ode.$(OBJEXT) \
62	92	poly.$(OBJEXT) sparse_hessian.$(OBJEXT) \
63	93	sparse_jacobian.$(OBJEXT)
64		sacado_OBJECTS = $(am_sacado_OBJECTS)
65		sacado_LDADD = $(LDADD)
66		sacado_DEPENDENCIES =
	94	speed_sacado_OBJECTS = $(am_speed_sacado_OBJECTS)
	95	speed_sacado_LDADD = $(LDADD)
	96	speed_sacado_DEPENDENCIES =
	97	AM_V_P = $(am__v_P_@AM_V@)
	98	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	99	am__v_P_0 = false
	100	am__v_P_1 = :
	101	AM_V_GEN = $(am__v_GEN_@AM_V@)
	102	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	103	am__v_GEN_0 = @echo " GEN " $@;
	104	am__v_GEN_1 =
	105	AM_V_at = $(am__v_at_@AM_V@)
	106	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	107	am__v_at_0 = @
	108	am__v_at_1 =
67	109	DEFAULT_INCLUDES =
68	110	depcomp = $(SHELL) $(top_srcdir)/depcomp
69	111	am__depfiles_maybe = depfiles
70	112	am__mv = mv -f
71		AM_V_lt = $(am__v_lt_@AM_V@)
72		am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
73		am__v_lt_0 = --silent
74	113	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
75	114	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
76	115	AM_V_CXX = $(am__v_CXX_@AM_V@)
77	116	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
78		am__v_CXX_0 = @echo " CXX " $@;
79		AM_V_at = $(am__v_at_@AM_V@)
80		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
81		am__v_at_0 = @
	117	am__v_CXX_0 = @echo " CXX " $@;
	118	am__v_CXX_1 =
82	119	CXXLD = $(CXX)
83	120	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
84	121	-o $@
85	122	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
86	123	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
87		am__v_CXXLD_0 = @echo " CXXLD " $@;
88		AM_V_GEN = $(am__v_GEN_@AM_V@)
89		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
90		am__v_GEN_0 = @echo " GEN " $@;
91		SOURCES = $(sacado_SOURCES)
92		DIST_SOURCES = $(sacado_SOURCES)
	124	am__v_CXXLD_0 = @echo " CXXLD " $@;
	125	am__v_CXXLD_1 =
	126	SOURCES = $(speed_sacado_SOURCES)
	127	DIST_SOURCES = $(speed_sacado_SOURCES)
93	128	am__can_run_installinfo = \
94	129	case $$AM_UPDATE_INFO_DIR in \
95	130	n\|no\|NO) false;; \
96	131	*) (install-info --version) >/dev/null 2>&1;; \
97	132	esac
	133	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	134	# Read a list of newline-separated strings from the standard input,
	135	# and print each of them once, without duplicates. Input order is
	136	# not preserved.
	137	am__uniquify_input = $(AWK) '\
	138	BEGIN { nonempty = 0; } \
	139	{ items[$$0] = 1; nonempty = 1; } \
	140	END { if (nonempty) { for (i in items) print i; }; } \
	141	'
	142	# Make sure the list of sources is unique. This is necessary because,
	143	# e.g., the same source file might be shared among _SOURCES variables
	144	# for different programs/libraries.
	145	am__define_uniq_tagged_files = \
	146	list='$(am__tagged_files)'; \
	147	unique=`for i in $$list; do \
	148	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	149	done \| $(am__uniquify_input)`
98	150	ETAGS = etags
99	151	CTAGS = ctags
100	152	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

104	156	ADOLC_DIR = @ADOLC_DIR@
105	157	AMTAR = @AMTAR@
106	158	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	159	AR = @AR@
107	160	AUTOCONF = @AUTOCONF@
108	161	AUTOHEADER = @AUTOHEADER@
109	162	AUTOMAKE = @AUTOMAKE@

125	178	CXX_FLAGS_EIGEN = @CXX_FLAGS_EIGEN@
126	179	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
127	180	CYGPATH_W = @CYGPATH_W@
128
129		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
130		# -----------------------------------------------------------------------------
131		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
132		#
133		# CppAD is distributed under multiple licenses. This distribution is under
134		# the terms of the
135		# GNU General Public License Version 3.
136		#
137		# A copy of this license is included in the COPYING file of this distribution.
138		# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
139		# -----------------------------------------------------------------------------
140		#
141		# automake input file
	181	#
142	182	#
143	183	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
144	184	DEFS =

194	234	abs_srcdir = @abs_srcdir@
195	235	abs_top_builddir = @abs_top_builddir@
196	236	abs_top_srcdir = @abs_top_srcdir@
	237	ac_ct_AR = @ac_ct_AR@
197	238	ac_ct_CC = @ac_ct_CC@
198	239	ac_ct_CXX = @ac_ct_CXX@
199	240	ac_ct_FC = @ac_ct_FC@

204	245	am__tar = @am__tar@
205	246	am__untar = @am__untar@
206	247	bindir = @bindir@
	248	build = @build@
207	249	build_alias = @build_alias@
	250	build_cpu = @build_cpu@
	251	build_os = @build_os@
	252	build_vendor = @build_vendor@
208	253	builddir = @builddir@
209	254	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
210	255	cppad_boostvector = @cppad_boostvector@
211	256	cppad_cflags = @cppad_cflags@
	257	cppad_compiler_has_erf = @cppad_compiler_has_erf@
212	258	cppad_cppadvector = @cppad_cppadvector@
213	259	cppad_description = @cppad_description@
214	260	cppad_eigenvector = @cppad_eigenvector@
	261	cppad_has_colpack = @cppad_has_colpack@
	262	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
215	263	cppad_has_gettimeofday = @cppad_has_gettimeofday@
216	264	cppad_has_nullptr = @cppad_has_nullptr@
	265	cppad_has_rvalue = @cppad_has_rvalue@
217	266	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
218	267	cppad_internal_sparse_set = @cppad_internal_sparse_set@
219	268	cppad_libs = @cppad_libs@
220	269	cppad_max_num_threads = @cppad_max_num_threads@
221	270	cppad_requires = @cppad_requires@
222		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	271	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
223	272	cppad_stdvector = @cppad_stdvector@
224	273	cppad_tape_addr_type = @cppad_tape_addr_type@
225	274	cppad_tape_id_type = @cppad_tape_id_type@

231	280	dvidir = @dvidir@
232	281	eigen_prefix = @eigen_prefix@
233	282	exec_prefix = @exec_prefix@
234		have_ar = @have_ar@
235	283	have_pkg_config = @have_pkg_config@
	284	host = @host@
236	285	host_alias = @host_alias@
	286	host_cpu = @host_cpu@
	287	host_os = @host_os@
	288	host_vendor = @host_vendor@
237	289	htmldir = @htmldir@
238	290	includedir = @includedir@
239	291	infodir = @infodir@

258	310	top_build_prefix = @top_build_prefix@
259	311	top_builddir = @top_builddir@
260	312	top_srcdir = @top_srcdir@
	313
	314	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
	315	# -----------------------------------------------------------------------------
	316	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	317	#
	318	# CppAD is distributed under multiple licenses. This distribution is under
	319	# the terms of the
	320	# GNU General Public License Version 3.
	321	#
	322	# A copy of this license is included in the COPYING file of this distribution.
	323	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	324	# -----------------------------------------------------------------------------
	325	#
	326	# Copy source file so that main.o does not end up in parent directory
	327	BUILT_SOURCES = main.cpp
261	328	#
262	329	AM_CPPFLAGS = \
263	330	-I$(top_srcdir) \

267	334
268	335	#
269	336	# BEGIN OPTIMIZE
270		AM_CXXFLAGS = -O2 -DNDEBUG -DSPEED_SACADO \
	337	AM_CXXFLAGS = -O2 -DNDEBUG -DCPPAD_SACADO_SPEED \
271	338	-DRAD_EQ_ALIAS -DRAD_AUTO_AD_Const $(CXX_FLAGS)
272	339
273	340	# END OPTIMIZE
274	341	#
275	342	# BEGIN DEBUG
276		# AM_CXXFLAGS = -g $(CXX_FLAGS) $(CXX_FLAGS) -DSPEED_SACADO -DRAD_AUTO_AD_Const
	343	# AM_CXXFLAGS = -g $(CXX_FLAGS) $(CXX_FLAGS) -DCPPAD_SACADO_SPEED -DRAD_AUTO_AD_Const
277	344	# END DEBUG
278	345	#
279		LDADD = -lspeed -lsacado -lteuchos
	346	LDADD = -lspeed -lsacado -lteuchoscore
280	347	AM_LDFLAGS = -L../src -L$(SACADO_DIR)/lib -L$(SACADO_DIR)/lib64
281	348	#
282		sacado_SOURCES = \
283		../main.cpp \
	349	speed_sacado_SOURCES = \
	350	main.cpp \
284	351	det_lu.cpp \
285	352	det_minor.cpp \
286	353	mat_mul.cpp \

289	356	sparse_hessian.cpp \
290	357	sparse_jacobian.cpp
291	358
292		all: all-am
	359	all: $(BUILT_SOURCES)
	360	$(MAKE) $(AM_MAKEFLAGS) all-am
293	361
294	362	.SUFFIXES:
295	363	.SUFFIXES: .cpp .o .obj

326	394
327	395	clean-checkPROGRAMS:
328	396	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
329		sacado$(EXEEXT): $(sacado_OBJECTS) $(sacado_DEPENDENCIES) $(EXTRA_sacado_DEPENDENCIES)
330		@rm -f sacado$(EXEEXT)
331		$(AM_V_CXXLD)$(CXXLINK) $(sacado_OBJECTS) $(sacado_LDADD) $(LIBS)
	397
	398	speed_sacado$(EXEEXT): $(speed_sacado_OBJECTS) $(speed_sacado_DEPENDENCIES) $(EXTRA_speed_sacado_DEPENDENCIES)
	399	@rm -f speed_sacado$(EXEEXT)
	400	$(AM_V_CXXLD)$(CXXLINK) $(speed_sacado_OBJECTS) $(speed_sacado_LDADD) $(LIBS)
332	401
333	402	mostlyclean-compile:
334	403	-rm -f *.$(OBJEXT)

346	415	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sparse_jacobian.Po@am__quote@
347	416
348	417	.cpp.o:
349		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
350		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	418	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	419	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	420	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
351	421	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
352	422	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
353	423	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
354	424
355	425	.cpp.obj:
356		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
357		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	426	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	427	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	428	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
358	429	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
359	430	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
360	431	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
361	432
362		main.o: ../main.cpp
363		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.o -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
364		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
365		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.o' libtool=no @AMDEPBACKSLASH@
366		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
367		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.o `test -f '../main.cpp' \|\| echo '$(srcdir)/'`../main.cpp
368
369		main.obj: ../main.cpp
370		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT main.obj -MD -MP -MF $(DEPDIR)/main.Tpo -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
371		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/main.Tpo $(DEPDIR)/main.Po
372		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../main.cpp' object='main.obj' libtool=no @AMDEPBACKSLASH@
373		@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
374		@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o main.obj `if test -f '../main.cpp'; then $(CYGPATH_W) '../main.cpp'; else $(CYGPATH_W) '$(srcdir)/../main.cpp'; fi`
375
376		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
377		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
378		unique=`for i in $$list; do \
379		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
380		done \| \
381		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
382		END { if (nonempty) { for (i in files) print i; }; }'`; \
383		mkid -fID $$unique
384		tags: TAGS
385
386		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
387		$(TAGS_FILES) $(LISP)
	433	ID: $(am__tagged_files)
	434	$(am__define_uniq_tagged_files); mkid -fID $$unique
	435	tags: tags-am
	436	TAGS: tags
	437
	438	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
388	439	set x; \
389	440	here=`pwd`; \
390		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
391		unique=`for i in $$list; do \
392		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
393		done \| \
394		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
395		END { if (nonempty) { for (i in files) print i; }; }'`; \
	441	$(am__define_uniq_tagged_files); \
396	442	shift; \
397	443	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
398	444	test -n "$$unique" \|\| unique=$$empty_fix; \

404	450	$$unique; \
405	451	fi; \
406	452	fi
407		ctags: CTAGS
408		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
409		$(TAGS_FILES) $(LISP)
410		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
411		unique=`for i in $$list; do \
412		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
413		done \| \
414		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
415		END { if (nonempty) { for (i in files) print i; }; }'`; \
	453	ctags: ctags-am
	454
	455	CTAGS: ctags
	456	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	457	$(am__define_uniq_tagged_files); \
416	458	test -z "$(CTAGS_ARGS)$$unique" \
417	459	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
418	460	$$unique

421	463	here=`$(am__cd) $(top_builddir) && pwd` \
422	464	&& $(am__cd) $(top_srcdir) \
423	465	&& gtags -i $(GTAGS_ARGS) "$$here"
	466	cscopelist: cscopelist-am
	467
	468	cscopelist-am: $(am__tagged_files)
	469	list='$(am__tagged_files)'; \
	470	case "$(srcdir)" in \
	471	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	472	*) sdir=$(subdir)/$(srcdir) ;; \
	473	esac; \
	474	for i in $$list; do \
	475	if test -f "$$i"; then \
	476	echo "$(subdir)/$$i"; \
	477	else \
	478	echo "$$sdir/$$i"; \
	479	fi; \
	480	done >> $(top_builddir)/cscope.files
424	481
425	482	distclean-tags:
426	483	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

457	514	done
458	515	check-am: all-am
459	516	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
460		check: check-am
	517	check: $(BUILT_SOURCES)
	518	$(MAKE) $(AM_MAKEFLAGS) check-am
461	519	all-am: makefile
462	520	installdirs:
463		install: install-am
	521	install: $(BUILT_SOURCES)
	522	$(MAKE) $(AM_MAKEFLAGS) install-am
464	523	install-exec: install-exec-am
465	524	install-data: install-data-am
466	525	uninstall: uninstall-am

490	549	maintainer-clean-generic:
491	550	@echo "This command is intended for maintainers to use"
492	551	@echo "it deletes files that may require special tools to rebuild."
	552	-test -z "$(BUILT_SOURCES)" \|\| rm -f $(BUILT_SOURCES)
493	553	clean: clean-am
494	554
495	555	clean-am: clean-checkPROGRAMS clean-generic mostlyclean-am

559	619
560	620	uninstall-am:
561	621
562		.MAKE: check-am install-am install-strip
563
564		.PHONY: CTAGS GTAGS all all-am check check-am clean \
565		clean-checkPROGRAMS clean-generic ctags distclean \
566		distclean-compile distclean-generic distclean-tags distdir dvi \
567		dvi-am html html-am info info-am install install-am \
568		install-data install-data-am install-dvi install-dvi-am \
569		install-exec install-exec-am install-html install-html-am \
570		install-info install-info-am install-man install-pdf \
571		install-pdf-am install-ps install-ps-am install-strip \
572		installcheck installcheck-am installdirs maintainer-clean \
573		maintainer-clean-generic mostlyclean mostlyclean-compile \
574		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
575		uninstall-am
576
	622	.MAKE: all check check-am install install-am install-strip
	623
	624	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	625	clean-checkPROGRAMS clean-generic cscopelist-am ctags ctags-am \
	626	distclean distclean-compile distclean-generic distclean-tags \
	627	distdir dvi dvi-am html html-am info info-am install \
	628	install-am install-data install-data-am install-dvi \
	629	install-dvi-am install-exec install-exec-am install-html \
	630	install-html-am install-info install-info-am install-man \
	631	install-pdf install-pdf-am install-ps install-ps-am \
	632	install-strip installcheck installcheck-am installdirs \
	633	maintainer-clean maintainer-clean-generic mostlyclean \
	634	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
	635	tags tags-am uninstall uninstall-am
	636
	637	main.cpp:
	638	cp $(srcdir)/../main.cpp main.cpp
577	639
578	640	test: check
579		./sacado correct 123 retape
	641	./speed_sacado correct 123
580	642
581	643	# Tell versions [3.59,3.63) of GNU make to not export all variables.
582	644	# Otherwise a system limit (for SysV at least) may be exceeded.

-6

speed/sacado/mat_mul.cpp less more

0		/* $Id: mat_mul.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: mat_mul.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

12	12	$begin sacado_mat_mul.cpp$$
13	13	$spell
14	14	sq
15		retape
	15	onetape
16	16	typedef
17	17	ADvar
18	18	Gradcomp

43	43	# include <cppad/vector.hpp>
44	44	# include <cppad/speed/mat_sum_sq.hpp>
45	45	# include <cppad/speed/uniform_01.hpp>
	46
	47	// list of possible options
	48	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	49
46	50	bool link_mat_mul(
47	51	size_t size ,
48	52	size_t repeat ,

51	55	CppAD::vector<double>& dz )
52	56	{
53	57	// speed test global option values
54		extern bool global_retape, global_atomic, global_optimize;
55		if( ! global_retape \|\| global_atomic \|\| global_optimize )
	58	if( global_memory \|\| global_onetape \|\| global_atomic \|\| global_optimize )
56	59	return false;
57
58	60	// -----------------------------------------------------
59	61	// setup
60	62

+13

-10

speed/sacado/ode.cpp less more

0		/* $Id: ode.cpp 2870 2013-07-28 17:00:59Z bradbell $ */
	0	/* $Id: ode.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

16	16	cppad
17	17	hpp
18	18	bool
19		retape
	19	onetape
20	20	CppAD
21	21	typedef
22	22	endif

44	44	# include <cppad/speed/uniform_01.hpp>
45	45	# include <cppad/speed/ode_evaluate.hpp>
46	46
	47	// list of possible options
	48	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	49
47	50	bool link_ode(
48	51	size_t size ,
49	52	size_t repeat ,

51	54	CppAD::vector<double> &jacobian
52	55	)
53	56	{
	57	// speed test global option values
	58	if( global_atomic )
	59	return false;
	60	if( global_memory \|\| global_onetape \|\| global_optimize )
	61	return false;
	62	// -------------------------------------------------------------
	63	// setup
54	64	assert( x.size() == size );
55	65	assert( jacobian.size() == size * size );
56	66
57		// speed test global option values
58		extern bool global_retape, global_atomic, global_optimize;
59		if( ! global_retape \|\| global_atomic \|\| global_optimize )
60		return false;
61
62		// -------------------------------------------------------------
63		// setup
64	67	typedef Sacado::Fad::DFad<double> ADScalar;
65	68	typedef CppAD::vector<ADScalar> ADVector;
66	69

-7

speed/sacado/poly.cpp less more

0		/* $Id: poly.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: poly.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

11	11	/*
12	12	$begin sacado_poly.cpp$$
13	13	$spell
14		retape
	14	onetape
15	15	cppad
16	16	cpp
17	17	tadiff

54	54	# include <cppad/speed/uniform_01.hpp>
55	55	# include <Sacado.hpp>
56	56
	57	// list of possible options
	58	extern bool global_memory, global_onetape, global_atomic, global_optimize;
	59
57	60	bool link_poly(
58	61	size_t size ,
59	62	size_t repeat ,

61	64	CppAD::vector<double> &z , // polynomial argument value
62	65	CppAD::vector<double> &ddp ) // second derivative w.r.t z
63	66	{
64		// speed test global option values
65		extern bool global_retape, global_atomic, global_optimize;
66		if( ! global_retape \|\| global_atomic \|\| global_optimize )
	67	if( global_atomic )
67	68	return false;
68
	69	if( global_memory \|\| global_onetape \|\| global_optimize )
	70	return false;
69	71	// -----------------------------------------------------
70	72	// setup
71	73	typedef Sacado::Tay::Taylor<double> ADScalar;

-7

speed/sacado/sparse_hessian.cpp less more

0		/* $Id: sparse_hessian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: sparse_hessian.cpp 3136 2014-03-02 11:54:07Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

14	14	/*
15	15	$begin sacado_sparse_hessian.cpp$$
16	16	$spell
	17	boolsparsity
17	18	const
18	19	Sacado
19	20	bool

23	24	$section Sacado Speed: Sparse Hessian$$
24	25
25	26	$codep */
26		// The sacado version of this test is not yet available
	27	// A sacado version of this test is not yet implemented
27	28	extern bool link_sparse_hessian(
28	29	size_t size ,
29	30	size_t repeat ,
30		CppAD::vector<double> &x ,
31		const CppAD::vector<size_t> &row ,
32		const CppAD::vector<size_t> &col ,
33		CppAD::vector<double> &hessian
	31	const CppAD::vector<size_t>& row ,
	32	const CppAD::vector<size_t>& col ,
	33	CppAD::vector<double>& x ,
	34	CppAD::vector<double>& hessian
34	35	)
35	36	{
36	37	return false;

+15

-13

speed/sacado/sparse_jacobian.cpp less more

0		/* $Id: sparse_jacobian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: sparse_jacobian.cpp 3138 2014-03-02 18:46:11Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

14	14	/*
15	15	$begin sacado_sparse_jacobian.cpp$$
16	16	$spell
17		bool
18		CppAD
19		sacado
	17	const
	18	bool
	19	CppAD
	20	sacado
20	21	sparse_jacobian
21	22	$$
22	23
23	24	$section sacado Speed: sparse_jacobian$$
24	25
25	26	$codep */
26		// The sacado version of this test is not yet available
	27	// A sacado version of this test is not yet available
27	28	bool link_sparse_jacobian(
28		size_t size ,
29		size_t repeat ,
30		size_t m ,
31		CppAD::vector<double> &x ,
32		CppAD::vector<size_t> &i ,
33		CppAD::vector<size_t> &j ,
34		CppAD::vector<double> &jacobian )
	29	size_t size ,
	30	size_t repeat ,
	31	size_t m ,
	32	const CppAD::vector<size_t>& row ,
	33	const CppAD::vector<size_t>& col ,
	34	CppAD::vector<double>& x ,
	35	CppAD::vector<double>& jacobian ,
	36	size_t& n_sweep )
35	37	{
36	38	return false;
37	39	}

-6

speed/src/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2564 2012-11-12 21:55:25Z bradbell $
	0	# $Id: CMakeLists.txt 3122 2014-02-26 03:23:19Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

10	10	# -----------------------------------------------------------------------------
11	11	# Build the cppad_ipopt/src library
12	12	# Inherit environment from ../CMakeList.txt
13
14		# Specifies build type for this directory. Possible values are
15		# empty, Debug, Release, RelWithDebInfo and MinSizeRel
16		SET(CMAKE_BUILD_TYPE RELEASE)
	13	# CMAKE_BUILD_TYPE determined by parent directory
17	14
18	15	# add_library(<name> [STATIC \| SHARED \| MODULE] [EXCLUDE_FROM_ALL]
19	16	# source1 source2 ... sourceN)

27	24	link_sparse_hessian.cpp
28	25	link_sparse_jacobian.cpp
29	26	microsoft_timer.cpp
	27	${colpack_sources}
30	28	)
31	29
32	30	# Compiler flags for cppad source

+16

-15

speed/src/link_sparse_hessian.cpp less more

0		/* $Id: link_sparse_hessian.cpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: link_sparse_hessian.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

68	68	$head x$$
69	69	The argument $icode x$$ has prototype
70	70	$codei%
71		CppAD::vector<double> &%x%
	71	CppAD::vector<double>& %x%
72	72	%$$
73	73	and its size is $latex n$$; i.e., $icode%x%.size() == %size%$$.
74	74	The input value of the elements of $icode x$$ does not matter.

114	114	$head hessian$$
115	115	The argument $icode hessian$$ has prototype
116	116	$codei%
117		CppAD::vector<double> &hessian
	117	CppAD::vector<double>& hessian
118	118	%$$
119	119	and its size is $latex n \times n$$.
120	120	The input value of its elements does not matter.

141	141	# include <cppad/index_sort.hpp>
142	142
143	143	/*!
144		\defgroup link_sparse_hessian_cpp link_sparse_hessian.cpp
145	144	\{
146	145	\file link_sparse_hessian.cpp
147	146	Defines and implement sparse Hessian speed link to package specific code.

280	279	and false otherwise.
281	280	*/
282	281	extern bool link_sparse_hessian(
283		size_t size ,
284		size_t repeat ,
285		CppAD::vector<double> &x ,
286		const CppAD::vector<size_t> &row ,
287		const CppAD::vector<size_t> &col ,
288		CppAD::vector<double> &hessian
	282	size_t size ,
	283	size_t repeat ,
	284	const CppAD::vector<size_t>& row ,
	285	const CppAD::vector<size_t>& col ,
	286	CppAD::vector<double>& x ,
	287	CppAD::vector<double>& hessian
289	288	);
290	289
291	290	/*!

303	302	vector<size_t> row, col;
304	303	choose_row_col(n, row, col);
305	304
306		return link_sparse_hessian(n, repeat, x, row, col, hessian);
	305	return link_sparse_hessian(n, repeat, row, col, x, hessian);
307	306	exit(0);
308	307	}
309	308	/*!
310	309	Does final sparse Hessian value pass correctness test.
	310
	311	\param is_package_double
	312	if true, we are checking function values instead of derivatives.
311	313
312	314	\return
313	315	true, if correctness test passes, and false otherwise.

321	323	vector<size_t> row, col;
322	324	choose_row_col(n, row, col);
323	325
324		link_sparse_hessian(n, repeat, x, row, col, hessian);
	326	link_sparse_hessian(n, repeat, row, col, x, hessian);
325	327
326	328	size_t order, size;
327	329	if( is_package_double)

359	361	choose_row_col(n, row, col);
360	362
361	363	// note that cppad/sparse_hessian.cpp assumes that x.size() == size
362		link_sparse_hessian(n, repeat, x, row, col, hessian);
	364	link_sparse_hessian(n, repeat, row, col, x, hessian);
363	365	return;
364	366	}
365	367
366		/! \} /

+108

-59

speed/src/link_sparse_jacobian.cpp less more

0		/* $Id: link_sparse_jacobian.cpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: link_sparse_jacobian.cpp 3311 2014-05-28 16:21:08Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

12	12	/*
13	13	$begin link_sparse_jacobian$$
14	14	$spell
	15	colpack
	16	cppad
	17	const
15	18	bool
16	19	CppAD
17	20	Jacobian

26	29
27	30	$head Prototype$$
28	31	$codei%extern bool link_sparse_jacobian(
29		size_t %size% ,
30		size_t %repeat% ,
31		size_t %m% ,
32		CppAD::vector<double> &%x% ,
33		CppAD::vector<size_t> &%row% ,
34		CppAD::vector<size_t> &%col% ,
35		CppAD::vector<double> &%jacobian%
	32	size_t %size% ,
	33	size_t %repeat% ,
	34	size_t %m% ,
	35	const CppAD::vector<size_t>& %row% ,
	36	const CppAD::vector<size_t>& %col% ,
	37	CppAD::vector<double>& %x% ,
	38	CppAD::vector<double>& %jacobian% ,
	39	size_t& %n_sweep%
36	40	);
37	41	%$$
38	42

63	67	$head m$$
64	68	Is the dimension of the range space for the function $latex f(x)$$.
65	69
66		$head x$$
67		The argument $icode x$$ has prototype
68		$codei%
69		CppAD::vector<double> &%x%
70		%$$
71		and its size is $latex n$$; i.e., $icode%x%.size() == %size%$$.
72		The input value of the elements of $icode x$$ does not matter.
73		On output, it has been set to the
74		argument value for which the function,
75		or its derivative, is being evaluated.
76		The value of this vector need not change with each repetition.
77
78	70	$head row$$
79	71	The size of the vector $icode row$$ defines the value $latex K$$.
80		The input value of the elements of $icode row$$ does not matter.
81		On output, it has been set the row index vector
82		for the last repetition.
83		All the elements of $icode row$$ must are between zero and $latex m-1$$.
	72	All the elements of $icode row$$ are between zero and $latex m-1$$.
84	73
85	74	$head col$$
86	75	The argument $icode col$$ is a vector with size $latex K$$.
87	76	The input value of its elements does not matter.
88	77	On output, it has been set the column index vector
89	78	for the last repetition.
90		All the elements of $icode col$$ must are between zero and $latex n-1$$.
	79	All the elements of $icode col$$ are between zero and $latex n-1$$.
91	80	$pre
92	81
93	82	$$

96	85	%row%[%j%] != %row%[%k%] \|\| %col%[%j%] != %col%[%k%]
97	86	%$$
98	87
	88	$head x$$
	89	The argument $icode x$$ has prototype
	90	$codei%
	91	CppAD::vector<double>& %x%
	92	%$$
	93	and its size is $latex n$$; i.e., $icode%x%.size() == %size%$$.
	94	The input value of the elements of $icode x$$ does not matter.
	95	On output, it has been set to the
	96	argument value for which the function,
	97	or its derivative, is being evaluated and placed in $icode jacobian$$.
	98	The value of this vector need not change with each repetition.
	99
99	100	$head jacobian$$
100	101	The argument $icode jacobian$$ is a vector with
101	102	$latex m \times n$$ elements.
102	103	The input value of its elements does not matter.
103	104	The output value of its elements is the Jacobian of the function $latex f(x)$$
104		that corresponds to output values of
105		$icode row$$, $icode col$$, and $icode x$$.
	105	that corresponds to output values of $icode x$$.
106	106	To be more specific, for
107	107	$latex i = 0 , \ldots , m - 1$$,
108	108	$latex j = 0 , \ldots , n-1$$,

110	110	\D{f[i]}{x[j]} (x) = jacobian [ i * n + j ]
111	111	\] $$
112	112
	113	$head n_sweep$$
	114	The input value of $icode n_sweep$$ does not matter. On output,
	115	it is the value $cref/n_sweep/sparse_jacobian/n_sweep/$$ corresponding
	116	to the evaluation of $icode jacobian$$.
	117	This is also the number of colors corresponding to the
	118	$cref/coloring method/sparse_jacobian/work/color_method/$$
	119	which can be set to $cref/colpack/speed_main/Sparsity Options/colpack/$$
	120	and is otherwise $code cppad$$.
	121
113	122	$subhead double$$
114	123	In the case where $icode package$$ is $code double$$,
115	124	only the first $latex m$$

126	135	# include <cppad/index_sort.hpp>
127	136
128	137	/*!
129		\defgroup link_sparse_jacobian_cpp link_sparse_jacobian.cpp
130	138	\{
131	139	\file link_sparse_jacobian.cpp
132	140	Defines and implement sparse Jacobian speed link to package specific code.

135	143	using CppAD::vector;
136	144
137	145	/*!
138		Class used by choose_row_col to determin order of row and column indices
	146	Class used by choose_row_col to determine order of row and column indices
139	147	*/
140	148	class Key {
141	149	public:

175	183	Function that randomly choose the row and column indices
176	184
177	185	\param n [in]
178		is the dimension of the argument space for the function f(x).
	186	is the dimension of the domain space for the function f(x).
	187
	188	\param m [in]
	189	is the dimension of the range space for the function f(x).
179	190
180	191	\param row [out]
181	192	the input size and elements of \c row do not matter.

244	255	\param m [in]
245	256	is the dimension of the range space for f(x).
246	257
	258	\param row [in]
	259	is the row indices correpsonding to non-zero Jacobian entries.
	260
	261	\param col [in]
	262	is the column indices corresponding to non-zero Jacobian entries.
	263
247	264	\param x [out]
248	265	is a vector of size \c n containing
249	266	the argument at which the Jacobian was evaluated during the last repetition.
250
251		\param row [in]
252		is the row indices correpsonding to non-zero Jacobian entries.
253
254		\param col [in]
255		is the column indices corresponding to non-zero Jacobian entries.
256	267
257	268	\param jacobian [out]
258	269	is a vector with size <code>m * n</code>
259	270	containing the value of the Jacobian of f(x)
260	271	corresponding to the last repetition.
261	272
	273	\param n_sweep [out]
	274	The input value of this parameter does not matter.
	275	Upon return, it is the number of sweeps (colors) corresponding
	276	to the sparse jacobian claculation.
	277
262	278	\return
263	279	is true, if the sparse Jacobian speed test is implemented for this package,
264	280	and false otherwise.
265	281	*/
266	282	extern bool link_sparse_jacobian(
267		size_t size ,
268		size_t repeat ,
269		size_t m ,
270		CppAD::vector<double> &x ,
271		CppAD::vector<size_t> &row ,
272		CppAD::vector<size_t> &col ,
273		CppAD::vector<double> &jacobian
	283	size_t size ,
	284	size_t repeat ,
	285	size_t m ,
	286	const CppAD::vector<size_t>& row ,
	287	const CppAD::vector<size_t>& col ,
	288	CppAD::vector<double>& x ,
	289	CppAD::vector<double>& jacobian ,
	290	size_t& n_sweep
274	291	);
275	292
276	293	/*!

281	298	*/
282	299	bool available_sparse_jacobian(void)
283	300	{ size_t n = 10;
284		size_t m = 3 * n;
	301	size_t m = 2 * n;
285	302	size_t repeat = 1;
	303	vector<size_t> row, col;
	304	choose_row_col(n, m, row, col);
	305
286	306	vector<double> x(n);
287	307	vector<double> jacobian(m * n);
288		vector<size_t> row, col;
289		choose_row_col(n, m, row, col);
290
291		return link_sparse_jacobian(n, repeat, m, x, row, col, jacobian);
	308	size_t n_sweep;
	309	return link_sparse_jacobian(n, repeat, m, row, col, x, jacobian, n_sweep);
292	310	}
293	311	/*!
294	312	Does final sparse Jacobian value pass correctness test.
	313
	314	\param is_package_double [in]
	315	if true, we are checking function values instead of derivatives.
295	316
296	317	\return
297	318	true, if correctness test passes, and false otherwise.

301	322	bool ok = true;
302	323	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
303	324	size_t n = 5;
304		size_t m = 3 * n;
	325	size_t m = 2 * n;
305	326	size_t repeat = 1;
	327	vector<size_t> row, col;
	328	choose_row_col(n, m, row, col);
	329
306	330	vector<double> x(n);
307	331	vector<double> jacobian(m * n);
308		vector<size_t> row, col;
309		choose_row_col(n, m, row, col);
310
311		link_sparse_jacobian(n, repeat, m, x, row, col, jacobian);
	332	size_t n_sweep;
	333	link_sparse_jacobian(n, repeat, m, row, col, x, jacobian, n_sweep);
312	334
313	335	if( is_package_double)
314	336	{ // check f(x)

339	361	/*!
340	362	Sparse Jacobian speed test.
341	363
342		\param size
	364	\param size [in]
343	365	is the dimension of the argument space for this speed test.
344	366
345		\param repeat
	367	\param repeat [in]
346	368	is the number of times to repeate the speed test.
347	369	*/
348	370	void speed_sparse_jacobian(size_t size, size_t repeat)
349	371	{ size_t n = size;
350		size_t m = 3 * n;
	372	size_t m = 2 * n;
	373	vector<size_t> row, col;
	374	choose_row_col(n, m, row, col);
	375
	376	// note that cppad/sparse_jacobian.cpp assumes that x.size()
	377	// is the size corresponding to this test
351	378	vector<double> x(n);
352	379	vector<double> jacobian(m * n);
	380	size_t n_sweep;
	381	link_sparse_jacobian(n, repeat, m, row, col, x, jacobian, n_sweep);
	382	return;
	383	}
	384	/*!
	385	Sparse Jacobian speed test information.
	386
	387	\param size [in]
	388	is the \c size parameter in the corresponding call to speed_sparse_jacobian.
	389
	390	\param n_sweep [out]
	391	The input value of this parameter does not matter.
	392	Upon return, it is the value \c n_sweep retruned by the corresponding
	393	call to \c link_sparse_jacobian.
	394	*/
	395	void info_sparse_jacobian(size_t size, size_t& n_sweep)
	396	{ size_t n = size;
	397	size_t m = 2 * n;
	398	size_t repeat = 1;
353	399	vector<size_t> row, col;
354	400	choose_row_col(n, m, row, col);
355	401
356	402	// note that cppad/sparse_jacobian.cpp assumes that x.size()
357	403	// is the size corresponding to this test
358		link_sparse_jacobian(n, repeat, m, x, row, col, jacobian);
	404	vector<double> x(n);
	405	vector<double> jacobian(m * n);
	406	link_sparse_jacobian(n, repeat, m, row, col, x, jacobian, n_sweep);
359	407	return;
360	408	}
361		/! \} /
	409
	410

+144

-73

speed/src/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

15	14	@SET_MAKE@
16	15
17	16	VPATH = @srcdir@
18		am__make_dryrun = \
19		{ \
20		am__dry=no; \
	17	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	18	am__make_running_with_option = \
	19	case $${target_option-} in \
	20	?) ;; \
	21	*) echo "am__make_running_with_option: internal error: invalid" \
	22	"target option '$${target_option-}' specified" >&2; \
	23	exit 1;; \
	24	esac; \
	25	has_opt=no; \
	26	sane_makeflags=$$MAKEFLAGS; \
	27	if $(am__is_gnu_make); then \
	28	sane_makeflags=$$MFLAGS; \
	29	else \
21	30	case $$MAKEFLAGS in \
22	31	\\[\ \ ]) \
23		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
24		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
25		*) \
26		for am__flg in $$MAKEFLAGS; do \
27		case $$am__flg in \
28		=\|--*) ;; \
29		n) am__dry=yes; break;; \
30		esac; \
31		done;; \
	32	bs=\\; \
	33	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	34	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
32	35	esac; \
33		test $$am__dry = yes; \
34		}
	36	fi; \
	37	skip_next=no; \
	38	strip_trailopt () \
	39	{ \
	40	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	41	}; \
	42	for flg in $$sane_makeflags; do \
	43	test $$skip_next = yes && { skip_next=no; continue; }; \
	44	case $$flg in \
	45	=\|--*) continue;; \
	46	-*I) strip_trailopt 'I'; skip_next=yes;; \
	47	-I?) strip_trailopt 'I';; \
	48	-*O) strip_trailopt 'O'; skip_next=yes;; \
	49	-O?) strip_trailopt 'O';; \
	50	-*l) strip_trailopt 'l'; skip_next=yes;; \
	51	-l?) strip_trailopt 'l';; \
	52	-[dEDm]) skip_next=yes;; \
	53	-[JT]) skip_next=yes;; \
	54	esac; \
	55	case $$flg in \
	56	$$target_option) has_opt=yes; break;; \
	57	esac; \
	58	done; \
	59	test $$has_opt = yes
	60	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	61	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
35	62	pkgdatadir = $(datadir)/@PACKAGE@
36	63	pkgincludedir = $(includedir)/@PACKAGE@
37	64	pkglibdir = $(libdir)/@PACKAGE@

48	75	NORMAL_UNINSTALL = :
49	76	PRE_UNINSTALL = :
50	77	POST_UNINSTALL = :
	78	build_triplet = @build@
	79	host_triplet = @host@
51	80	subdir = speed/src
52		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in
	81	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	82	$(top_srcdir)/depcomp
53	83	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
54	84	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
55	85	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

58	88	CONFIG_CLEAN_FILES =
59	89	CONFIG_CLEAN_VPATH_FILES =
60	90	LIBRARIES = $(noinst_LIBRARIES)
61		AR = ar
62	91	ARFLAGS = cru
63	92	AM_V_AR = $(am__v_AR_@AM_V@)
64	93	am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
65		am__v_AR_0 = @echo " AR " $@;
66		AM_V_at = $(am__v_at_@AM_V@)
67		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
68		am__v_at_0 = @
	94	am__v_AR_0 = @echo " AR " $@;
	95	am__v_AR_1 =
69	96	libspeed_a_AR = $(AR) $(ARFLAGS)
70	97	libspeed_a_LIBADD =
71	98	am_libspeed_a_OBJECTS = link_det_lu.$(OBJEXT) link_det_minor.$(OBJEXT) \

73	100	link_sparse_hessian.$(OBJEXT) link_sparse_jacobian.$(OBJEXT) \
74	101	microsoft_timer.$(OBJEXT)
75	102	libspeed_a_OBJECTS = $(am_libspeed_a_OBJECTS)
	103	AM_V_P = $(am__v_P_@AM_V@)
	104	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	105	am__v_P_0 = false
	106	am__v_P_1 = :
	107	AM_V_GEN = $(am__v_GEN_@AM_V@)
	108	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	109	am__v_GEN_0 = @echo " GEN " $@;
	110	am__v_GEN_1 =
	111	AM_V_at = $(am__v_at_@AM_V@)
	112	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	113	am__v_at_0 = @
	114	am__v_at_1 =
76	115	DEFAULT_INCLUDES =
77	116	depcomp = $(SHELL) $(top_srcdir)/depcomp
78	117	am__depfiles_maybe = depfiles

81	120	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
82	121	AM_V_CXX = $(am__v_CXX_@AM_V@)
83	122	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
84		am__v_CXX_0 = @echo " CXX " $@;
	123	am__v_CXX_0 = @echo " CXX " $@;
	124	am__v_CXX_1 =
85	125	CXXLD = $(CXX)
86	126	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
87	127	-o $@
88	128	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
89	129	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
90		am__v_CXXLD_0 = @echo " CXXLD " $@;
91		AM_V_GEN = $(am__v_GEN_@AM_V@)
92		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
93		am__v_GEN_0 = @echo " GEN " $@;
	130	am__v_CXXLD_0 = @echo " CXXLD " $@;
	131	am__v_CXXLD_1 =
94	132	SOURCES = $(libspeed_a_SOURCES)
95	133	DIST_SOURCES = $(libspeed_a_SOURCES)
96	134	am__can_run_installinfo = \

98	136	n\|no\|NO) false;; \
99	137	*) (install-info --version) >/dev/null 2>&1;; \
100	138	esac
	139	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	140	# Read a list of newline-separated strings from the standard input,
	141	# and print each of them once, without duplicates. Input order is
	142	# not preserved.
	143	am__uniquify_input = $(AWK) '\
	144	BEGIN { nonempty = 0; } \
	145	{ items[$$0] = 1; nonempty = 1; } \
	146	END { if (nonempty) { for (i in items) print i; }; } \
	147	'
	148	# Make sure the list of sources is unique. This is necessary because,
	149	# e.g., the same source file might be shared among _SOURCES variables
	150	# for different programs/libraries.
	151	am__define_uniq_tagged_files = \
	152	list='$(am__tagged_files)'; \
	153	unique=`for i in $$list; do \
	154	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	155	done \| $(am__uniquify_input)`
101	156	ETAGS = etags
102	157	CTAGS = ctags
103	158	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

107	162	ADOLC_DIR = @ADOLC_DIR@
108	163	AMTAR = @AMTAR@
109	164	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	165	AR = @AR@
110	166	AUTOCONF = @AUTOCONF@
111	167	AUTOHEADER = @AUTOHEADER@
112	168	AUTOMAKE = @AUTOMAKE@

129	185	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
130	186	CYGPATH_W = @CYGPATH_W@
131	187
132		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	188	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
133	189	# -----------------------------------------------------------------------------
134	190	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
135	191	#

196	252	abs_srcdir = @abs_srcdir@
197	253	abs_top_builddir = @abs_top_builddir@
198	254	abs_top_srcdir = @abs_top_srcdir@
	255	ac_ct_AR = @ac_ct_AR@
199	256	ac_ct_CC = @ac_ct_CC@
200	257	ac_ct_CXX = @ac_ct_CXX@
201	258	ac_ct_FC = @ac_ct_FC@

206	263	am__tar = @am__tar@
207	264	am__untar = @am__untar@
208	265	bindir = @bindir@
	266	build = @build@
209	267	build_alias = @build_alias@
	268	build_cpu = @build_cpu@
	269	build_os = @build_os@
	270	build_vendor = @build_vendor@
210	271	builddir = @builddir@
211	272	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
212	273	cppad_boostvector = @cppad_boostvector@
213	274	cppad_cflags = @cppad_cflags@
	275	cppad_compiler_has_erf = @cppad_compiler_has_erf@
214	276	cppad_cppadvector = @cppad_cppadvector@
215	277	cppad_description = @cppad_description@
216	278	cppad_eigenvector = @cppad_eigenvector@
	279	cppad_has_colpack = @cppad_has_colpack@
	280	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
217	281	cppad_has_gettimeofday = @cppad_has_gettimeofday@
218	282	cppad_has_nullptr = @cppad_has_nullptr@
	283	cppad_has_rvalue = @cppad_has_rvalue@
219	284	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
220	285	cppad_internal_sparse_set = @cppad_internal_sparse_set@
221	286	cppad_libs = @cppad_libs@
222	287	cppad_max_num_threads = @cppad_max_num_threads@
223	288	cppad_requires = @cppad_requires@
224		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	289	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
225	290	cppad_stdvector = @cppad_stdvector@
226	291	cppad_tape_addr_type = @cppad_tape_addr_type@
227	292	cppad_tape_id_type = @cppad_tape_id_type@

233	298	dvidir = @dvidir@
234	299	eigen_prefix = @eigen_prefix@
235	300	exec_prefix = @exec_prefix@
236		have_ar = @have_ar@
237	301	have_pkg_config = @have_pkg_config@
	302	host = @host@
238	303	host_alias = @host_alias@
	304	host_cpu = @host_cpu@
	305	host_os = @host_os@
	306	host_vendor = @host_vendor@
239	307	htmldir = @htmldir@
240	308	includedir = @includedir@
241	309	infodir = @infodir@

324	392
325	393	clean-noinstLIBRARIES:
326	394	-test -z "$(noinst_LIBRARIES)" \|\| rm -f $(noinst_LIBRARIES)
	395
327	396	libspeed.a: $(libspeed_a_OBJECTS) $(libspeed_a_DEPENDENCIES) $(EXTRA_libspeed_a_DEPENDENCIES)
328	397	$(AM_V_at)-rm -f libspeed.a
329	398	$(AM_V_AR)$(libspeed_a_AR) libspeed.a $(libspeed_a_OBJECTS) $(libspeed_a_LIBADD)

345	414	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/microsoft_timer.Po@am__quote@
346	415
347	416	.cpp.o:
348		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
349		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	417	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	418	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	419	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
350	420	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
351	421	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
352	422	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
353	423
354	424	.cpp.obj:
355		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
356		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	425	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	426	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	427	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
357	428	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
358	429	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
359	430	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
360	431
361		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
362		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
363		unique=`for i in $$list; do \
364		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
365		done \| \
366		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
367		END { if (nonempty) { for (i in files) print i; }; }'`; \
368		mkid -fID $$unique
369		tags: TAGS
370
371		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
372		$(TAGS_FILES) $(LISP)
	432	ID: $(am__tagged_files)
	433	$(am__define_uniq_tagged_files); mkid -fID $$unique
	434	tags: tags-am
	435	TAGS: tags
	436
	437	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
373	438	set x; \
374	439	here=`pwd`; \
375		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
376		unique=`for i in $$list; do \
377		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
378		done \| \
379		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
380		END { if (nonempty) { for (i in files) print i; }; }'`; \
	440	$(am__define_uniq_tagged_files); \
381	441	shift; \
382	442	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
383	443	test -n "$$unique" \|\| unique=$$empty_fix; \

389	449	$$unique; \
390	450	fi; \
391	451	fi
392		ctags: CTAGS
393		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
394		$(TAGS_FILES) $(LISP)
395		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
396		unique=`for i in $$list; do \
397		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
398		done \| \
399		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
400		END { if (nonempty) { for (i in files) print i; }; }'`; \
	452	ctags: ctags-am
	453
	454	CTAGS: ctags
	455	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	456	$(am__define_uniq_tagged_files); \
401	457	test -z "$(CTAGS_ARGS)$$unique" \
402	458	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
403	459	$$unique

406	462	here=`$(am__cd) $(top_builddir) && pwd` \
407	463	&& $(am__cd) $(top_srcdir) \
408	464	&& gtags -i $(GTAGS_ARGS) "$$here"
	465	cscopelist: cscopelist-am
	466
	467	cscopelist-am: $(am__tagged_files)
	468	list='$(am__tagged_files)'; \
	469	case "$(srcdir)" in \
	470	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	471	*) sdir=$(subdir)/$(srcdir) ;; \
	472	esac; \
	473	for i in $$list; do \
	474	if test -f "$$i"; then \
	475	echo "$(subdir)/$$i"; \
	476	else \
	477	echo "$$sdir/$$i"; \
	478	fi; \
	479	done >> $(top_builddir)/cscope.files
409	480
410	481	distclean-tags:
411	482	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

545	616
546	617	.MAKE: install-am install-strip
547	618
548		.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
549		clean-noinstLIBRARIES ctags distclean distclean-compile \
550		distclean-generic distclean-tags distdir dvi dvi-am html \
551		html-am info info-am install install-am install-data \
552		install-data-am install-dvi install-dvi-am install-exec \
553		install-exec-am install-html install-html-am install-info \
554		install-info-am install-man install-pdf install-pdf-am \
555		install-ps install-ps-am install-strip installcheck \
556		installcheck-am installdirs maintainer-clean \
	619	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
	620	clean-noinstLIBRARIES cscopelist-am ctags ctags-am distclean \
	621	distclean-compile distclean-generic distclean-tags distdir dvi \
	622	dvi-am html html-am info info-am install install-am \
	623	install-data install-data-am install-dvi install-dvi-am \
	624	install-exec install-exec-am install-html install-html-am \
	625	install-info install-info-am install-man install-pdf \
	626	install-pdf-am install-ps install-ps-am install-strip \
	627	installcheck installcheck-am installdirs maintainer-clean \
557	628	maintainer-clean-generic mostlyclean mostlyclean-compile \
558		mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
	629	mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \
559	630	uninstall-am
560	631
561	632

-4

speed/src/microsoft_timer.cpp less more

0		/* $Id: microsoft_timer.cpp 2625 2012-12-23 14:34:12Z bradbell $ */
	0	/* $Id: microsoft_timer.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

49	49	// _MSC_VER is not defined during generation. In general, it is a problem
50	50	// that not all preprocessor options get documented.
51	51	/*!
52		\defgroup microsoft_timer_cpp microsoft_timer.cpp
53	52	\{
54	53	\file microsoft_timer.cpp
55	54	\brief Microsoft version of elapsed_seconds.

85	84	return diff;
86	85	}
87	86
88		/! \} /
89	87	# endif

+26

-37

test_more/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 2862 2013-05-29 05:58:38Z bradbell $
	0	# $Id: CMakeLists.txt 3301 2014-05-24 05:20:21Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

19	19	# test using CPPAD_MAX_NUM_THREADS equal to one (its smallest value)
20	20	ADD_DEFINITIONS("-DCPPAD_MAX_NUM_THREADS=1")
21	21
22		# sources that use adolc
23		IF ( adolc_prefix )
24		# Extra source files if we are including adolc
25		SET(adolc_sources base_adolc.cpp)
26		# Adds -D define flags to the compilation of source files.
27		ADD_DEFINITIONS("-DCPPAD_ADOLC_TEST")
28		# add adolc to list of libraries
29		SET(test_more_adolc adolc)
30		ELSE ( adolc_prefix )
31		SET(adolc_sources "")
32		SET(test_more_adolc "")
33		ENDIF ( adolc_prefix )
	22	# adolc_prefix
	23	SET(sources base_adolc.cpp)
	24	sources_libs_define(adolc "${sources}" adolc ADOLC_TEST)
34	25
35		# sources that use ipopt
36		IF ( ipopt_prefix )
37		# Extra source files if we are including ipopt
38		SET(ipopt_sources ipopt_solve.cpp)
39		# Adds -D define flags to the compilation of source files.
40		ADD_DEFINITIONS("-DCPPAD_IPOPT_TEST")
41		# add ipopt (and libraries it depends on) to list of libraries
42		SET(test_more_ipopt ${ipopt_LIBRARIES} )
43		ELSE ( ipopt_prefix )
44		SET(ipopt_sources "")
45		SET(test_more_ipopt "")
46		ENDIF ( ipopt_prefix )
	26	# colpack_prefix
	27	SET(sources ../cppad/local/cppad_colpack.cpp)
	28	sources_libs_define(colpack "${sources}" ColPack COLPACK_TEST)
	29
	30	# ipopt_prefix
	31	SET(sources ipopt_solve.cpp)
	32	sources_libs_define(ipopt "${sources}" "${ipopt_LIBRARIES}" IPOPT_TEST)
47	33
48	34	# sources that use eigen
49	35	IF ( eigen_prefix )
50	36	# compile eigen library separately so can use different compiler flags
51		ADD_LIBRARY(test_more_eigen EXCLUDE_FROM_ALL cppad_eigen.cpp)
	37	ADD_LIBRARY(test_more_eigen_lib EXCLUDE_FROM_ALL
	38	cppad_eigen.cpp
	39	)
52	40	# Adds -D define flags to the compilation of source files.
53	41	ADD_DEFINITIONS("-DCPPAD_EIGEN_TEST")
54	42	# Add other compiler flags
55		add_cppad_cxx_flags(test_more_eigen)
	43	add_cppad_cxx_flags(test_more_eigen_lib)
56	44	#
57	45	# Add eigen to list of libraries
58		SET(test_more_eigen test_more_eigen)
	46	SET(eigen_libs test_more_eigen_lib)
59	47	ELSE ( eigen_prefix )
60	48	SET(eigen_sources "")
61		SET(test_more_eigen "")
	49	SET(eigen_libs "")
62	50	ENDIF ( eigen_prefix )
63	51
64	52	# Copy a file to another location and modify its contents.

73	61	# )
74	62	ADD_EXECUTABLE(test_more EXCLUDE_FROM_ALL test_more.cpp
75	63	${adolc_sources}
	64	${colpack_sources}
76	65	${ipopt_sources}
77	66	${eigen_sources}
78	67	abs.cpp

104	93	for_hess.cpp
105	94	for_sparse_jac.cpp
106	95	forward.cpp
107		forward_mul.cpp
	96	forward_dir.cpp
	97	forward_order.cpp
108	98	from_base.cpp
109	99	fun_check.cpp
110	100	jacobian.cpp

158	148
159	149	# List of libraries to be linked into the specified target
160	150	TARGET_LINK_LIBRARIES(test_more
161		${test_more_adolc}
162		${test_more_ipopt}
163		${test_more_eigen}
	151	${colpack_libs}
	152	${adolc_libs}
	153	${ipopt_libs}
	154	${eigen_libs}
164	155	)
165	156
166	157	# Add the check_test_more target
167		ADD_CUSTOM_TARGET(
168		check_test_more test_more DEPENDS test_more ${test_more_eigen}
169		)
	158	ADD_CUSTOM_TARGET( check_test_more test_more DEPENDS test_more )

+26

-3

test_more/atan2.cpp less more

0		/* $Id: atan2.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: atan2.cpp 3083 2014-01-10 18:35:07Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

16	16	# include <cppad/cppad.hpp>
17	17	# include <cmath>
18	18
19		bool Atan2(void)
	19	namespace { // begin empty namespace
	20
	21	bool ad_ad(void)
	22	{ bool ok = true;
	23	using CppAD::AD;
	24
	25	AD< AD<double> > x(2.), y(2.);
	26	AD< AD<double> > z = atan2(y, x);
	27	CppAD::NearEqual( Value( Value(z) ), atan(1.), 1e-10, 1e-10 );
	28
	29	return ok;
	30	}
	31
	32	bool general(void)
20	33	{ bool ok = true;
21	34
22	35	using CppAD::atan;

88	101
89	102	return ok;
90	103	}
	104
	105	} // end empty namespace
	106
	107	bool atan2(void)
	108	{ bool ok = true;
	109	ok &= ad_ad();
	110	ok &= general();
	111
	112	return ok;
	113	}

-1

test_more/cppad_eigen.cpp less more

0		/* $Id: cppad_eigen.cpp 3067 2013-12-29 17:35:34Z bradbell $ */
	0	/* $Id: cppad_eigen.cpp 3070 2013-12-31 15:09:11Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3

+73

-31

test_more/erf.cpp less more

0		/* $Id: erf.cpp 3062 2013-12-28 10:40:48Z bradbell $ */
	0	/* $Id: erf.cpp 3501 2014-12-25 01:10:32Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3

21	21	using CppAD::atan;
22	22	using CppAD::exp;
23	23	using CppAD::sqrt;
	24	# if CPPAD_COMPILER_HAS_ERF
	25	double eps = 100.0 * std::numeric_limits<double>::epsilon();
	26	# endif
	27	// Construct function object corresponding to erf
	28	CPPAD_TESTVECTOR(AD<double>) ax(1);
	29	CPPAD_TESTVECTOR(AD<double>) ay(1);
	30	ax[0] = 0.;
	31	Independent(ax);
	32	ay[0] = erf(ax[0]);
	33	ADFun<double> f(ax, ay);
24	34
25		// Construct function object corresponding to erf
26		CPPAD_TESTVECTOR(AD<double>) X(1);
27		CPPAD_TESTVECTOR(AD<double>) Y(1);
28		X[0] = 0.;
29		Independent(X);
30		Y[0] = erf(X[0]);
31		ADFun<double> Erf(X, Y);
	35	// Construct function object corresponding to derivative of erf
	36	Independent(ax);
	37	double pi = 4.0 * atan(1.0);
	38	ay[0] = exp( - ax[0] * ax[0] ) * 2.0 / sqrt(pi);
	39	ADFun<double> df(ax, ay);
32	40
33	41	// vectors to use with function object
34		CPPAD_TESTVECTOR(double) x(1);
35		CPPAD_TESTVECTOR(double) y(1);
36		CPPAD_TESTVECTOR(double) dx(1);
37		CPPAD_TESTVECTOR(double) dy(1);
	42	CPPAD_TESTVECTOR(double) x0(1), y0(1), x1(1), y1(1), check(1);
38	43
39	44	// check value at zero
40		x[0] = 0.;
41		y = Erf.Forward(0, x);
42		ok &= NearEqual(0., y[0], 4e-4, 0.);
	45	x0[0] = 1.5;
	46	y0 = f.Forward(0, x0);
	47	check[0] = 0.96611;
	48	ok &= std::fabs(check[0] - y0[0]) <= 4e-4;
43	49
44	50	// check the derivative of error function
45		dx[0] = 1.;
46		double pi = 4. * atan(1.);
47		double factor = 2. / sqrt( pi );
48		int i;
49		for(i = -10; i <= 10; i++)
50		{ x[0] = i / 4.;
51		y = Erf.Forward(0, x);
	51	x1[0] = 1.0;
	52	y1 = f.Forward(1, x1);
	53	check = df.Forward(0, x0);
	54	ok &= NearEqual(check[0], y1[0], 0., 2e-3);
	55	# if CPPAD_COMPILER_HAS_ERF
	56	ok &= NearEqual(check[0], y1[0], eps, eps);
	57	# endif
52	58
53		// check derivative
54		double derf = factor * exp( - x[0] * x[0] );
55		dy = Erf.Forward(1, dx);
56		ok &= NearEqual(derf, dy[0], 0., 2e-3);
	59	// check second derivative
	60	CPPAD_TESTVECTOR(double) x2(1), y2(1);
	61	x2[0] = 0.0;
	62	y2 = f.Forward(2, x2);
	63	check = df.Forward(1, x1);
	64	ok &= NearEqual(check[0] / 2.0, y2[0], 0., 2e-3);
	65	# if CPPAD_COMPILER_HAS_ERF
	66	ok &= NearEqual(check[0] / 2.0, y2[0], eps, eps);
	67	# endif
57	68
58		// test using erf with AD< AD<double> >
59		AD< AD<double> > X0 = AD<double>( x[0] );
60		AD< AD<double> > Y0 = erf(X0);
	69	// check third derivative
	70	CPPAD_TESTVECTOR(double) x3(1), y3(1);
	71	x3[0] = 0.0;
	72	y3 = f.Forward(3, x3);
	73	check = df.Forward(2, x2);
	74	ok &= NearEqual(check[0] / 3.0, y3[0], 0., 2e-3);
	75	# if CPPAD_COMPILER_HAS_ERF
	76	ok &= NearEqual(check[0] / 3.0, y3[0], eps, eps);
	77	# endif
61	78
62		ok &= ( y[0] == Value( Value(Y0) ) );
63		}
	79	// check 4-th order of reverse mode
	80	CPPAD_TESTVECTOR(double) w(1), dy(4), x4(1), y4(1);
	81	x4[0] = 0.0;
	82	w[0] = 1.0;
	83	dy = f.Reverse(4, w);
	84	y4 = f.Forward(4, x4);
	85	//
	86	ok &= NearEqual(dy[0], y1[0], 0., 2e-3);
	87	# if CPPAD_COMPILER_HAS_ERF
	88	ok &= NearEqual(dy[0], y1[0], eps, eps);
	89	# endif
	90	//
	91	ok &= NearEqual(dy[1], 2.0 * y2[0], 0., 2e-3);
	92	# if CPPAD_COMPILER_HAS_ERF
	93	ok &= NearEqual(dy[1], 2.0 * y2[0], eps, eps);
	94	# endif
	95	//
	96	ok &= NearEqual(dy[2], 3.0 * y3[0], 0., 2e-3);
	97	# if CPPAD_COMPILER_HAS_ERF
	98	ok &= NearEqual(dy[2], 3.0 * y3[0], eps, eps);
	99	# endif
	100	//
	101	ok &= NearEqual(dy[3], 4.0 * y4[0], 0., 2e-3);
	102	# if CPPAD_COMPILER_HAS_ERF
	103	ok &= NearEqual(dy[3], 4.0 * y4[0], eps, eps);
	104	# endif
	105
64	106	return ok;
65	107	}

-2

test_more/extern_value.hpp less more

0		/* $Id: extern_value.hpp 2756 2013-02-27 18:49:28Z bradbell $ */
	0	/* $Id: extern_value.hpp 3275 2014-05-20 17:35:11Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

8	8	A copy of this license is included in the COPYING file of this distribution.
9	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10	10	-------------------------------------------------------------------------- */
	11
	12	# ifndef CPPAD_EXTERN_VALUE_INCLUDED
	13	# define CPPAD_EXTERN_VALUE_INCLUDED
11	14
12	15	template <class Type>
13	16	class extern_value {

18	21	void set(Type value);
19	22	Type get(void);
20	23	};
	24
	25	# endif

+1573

-0

test_more/forward_dir.cpp less more

	0	/* $Id: forward_dir.cpp 3305 2014-05-24 16:37:42Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11	// test multiple directions operators
	12	// MulvvOp is tested by example/forward_dir.cpp
	13
	14	# include <limits>
	15	# include <cmath>
	16	# include <cppad/cppad.hpp>
	17
	18	namespace {
	19	using CppAD::AD;
	20	using CppAD::NearEqual;
	21	// ---------------------------------------------------------------------
	22	// Used the check that fun is an idenity funciton
	23	typedef AD<double> (*adfun)(const AD<double>&);
	24	bool check_identity(adfun identity, double argument)
	25	{
	26	bool ok = true;
	27	double eps = 10. * std::numeric_limits<double>::epsilon();
	28	size_t j;
	29
	30
	31	// domain space vector
	32	size_t n = 1;
	33	CPPAD_TESTVECTOR(AD<double>) ax(n);
	34	ax[0] = argument;
	35
	36	// declare independent variables and starting recording
	37	CppAD::Independent(ax);
	38
	39	// range space vector
	40	size_t m = 1;
	41	CPPAD_TESTVECTOR(AD<double>) ay(m);
	42	ay[0] = identity(ax[0]);
	43
	44	// create f: x -> y and stop tape recording
	45	CppAD::ADFun<double> f(ax, ay);
	46
	47	// first order Taylor coefficients
	48	size_t r = 2, ell;
	49	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	50	for(ell = 0; ell < r; ell++)
	51	{ for(j = 0; j < n; j++)
	52	x1[ r * j + ell ] = double(j + ell + 1);
	53	}
	54	y1 = f.Forward(1, r, x1);
	55	ok &= y1.size() == r*m;
	56
	57	// secondorder Taylor coefficients
	58	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	59	for(ell = 0; ell < r; ell++)
	60	{ for(j = 0; j < n; j++)
	61	x2[ r * j + ell ] = double(j + ell + 2);
	62	}
	63	y2 = f.Forward(2, r, x2);
	64	ok &= y2.size() == r*m;
	65	//
	66	// Y_0 (t) = F[X_0(t)] = X_0(t)
	67	// = 0.5 + 1t + 2t^2
	68	double y_1_0 = 1.0;
	69	double y_2_0 = 2.0;
	70	//
	71	// Y_1 (t) = F[X_1(t)] = X_1(t)
	72	// = 0.5 + 2t + 3t^2
	73	double y_1_1 = 2.0;
	74	double y_2_1 = 3.0;
	75	//
	76	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	77	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	78	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	79	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	80	//
	81	return ok;
	82	}
	83	// ---------------------------------------------------------------------
	84	// AbsOp
	85	bool abs_op(void)
	86	{ bool ok = true;
	87	double eps = 10. * std::numeric_limits<double>::epsilon();
	88	size_t j;
	89
	90	// domain space vector
	91	size_t n = 2;
	92	CPPAD_TESTVECTOR(AD<double>) ax(n);
	93	ax[0] = 0.5;
	94	ax[1] = -1.0;
	95
	96	// declare independent variables and starting recording
	97	CppAD::Independent(ax);
	98
	99	// range space vector
	100	size_t m = 1;
	101	CPPAD_TESTVECTOR(AD<double>) ay(m);
	102	ay[0] = abs( ax[0] ) + abs( 2.0 * ax[1] );
	103
	104	// create f: x -> y and stop tape recording
	105	CppAD::ADFun<double> f(ax, ay);
	106
	107	// first order Taylor coefficients
	108	size_t r = 2, ell;
	109	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	110	for(ell = 0; ell < r; ell++)
	111	{ for(j = 0; j < n; j++)
	112	x1[ r * j + ell ] = double(j + ell + 1);
	113	}
	114	y1 = f.Forward(1, r, x1);
	115	ok &= y1.size() == r*m;
	116
	117	// secondorder Taylor coefficients
	118	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	119	for(ell = 0; ell < r; ell++)
	120	{ for(j = 0; j < n; j++)
	121	x2[ r * j + ell ] = double(j + ell + 2);
	122	}
	123	y2 = f.Forward(2, r, x2);
	124	ok &= y2.size() == r*m;
	125	//
	126	// Y_0 (t) = F[X_0(t)]
	127	// = abs(0.5 + 1t + 2t^2) + abs( 2*(-1.0 + 2t + 3t^2 ) )
	128	double y_1_0 = -3.0;
	129	double y_2_0 = -4.0;
	130	//
	131	// Y_1 (t) = F[X_1(t)]
	132	// = abs(0.5 + 2t + 3t^2) + abs( 2*(-1.0 + 3t + 4t^2 ) )
	133	double y_1_1 = -4.0;
	134	double y_2_1 = -5.0;
	135	//
	136	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	137	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	138	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	139	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	140	//
	141	return ok;
	142	}
	143	// ---------------------------------------------------------------------
	144	// AddpvOp
	145	bool addpv_op(void)
	146	{ bool ok = true;
	147	double eps = 10. * std::numeric_limits<double>::epsilon();
	148	size_t j;
	149
	150	// domain space vector
	151	size_t n = 1;
	152	CPPAD_TESTVECTOR(AD<double>) ax(n);
	153	ax[0] = 0.5;
	154
	155	// declare independent variables and starting recording
	156	CppAD::Independent(ax);
	157
	158	// range space vector
	159	size_t m = 1;
	160	CPPAD_TESTVECTOR(AD<double>) ay(m);
	161	ay[0] = 2.0 + ax[0];
	162
	163	// create f: x -> y and stop tape recording
	164	CppAD::ADFun<double> f(ax, ay);
	165
	166	// first order Taylor coefficients
	167	size_t r = 2, ell;
	168	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	169	for(ell = 0; ell < r; ell++)
	170	{ for(j = 0; j < n; j++)
	171	x1[ r * j + ell ] = double(j + ell + 1);
	172	}
	173	y1 = f.Forward(1, r, x1);
	174	ok &= y1.size() == r*m;
	175
	176	// secondorder Taylor coefficients
	177	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	178	for(ell = 0; ell < r; ell++)
	179	{ for(j = 0; j < n; j++)
	180	x2[ r * j + ell ] = double(j + ell + 3);
	181	}
	182	y2 = f.Forward(2, r, x2);
	183	ok &= y2.size() == r*m;
	184	//
	185	// Y_0 (t) = F[X_0(t)]
	186	// = 2.0 + (0.5 + 1t + 3t^2)
	187	double y_1_0 = 1.0;
	188	double y_2_0 = 3.0;
	189	//
	190	// Y_1 (t) = F[X_1(t)]
	191	// = 2.0 + (0.5 + 2t + 4t^2)
	192	double y_1_1 = 2.0;
	193	double y_2_1 = 4.0;
	194	//
	195	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	196	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	197	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	198	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	199	//
	200	return ok;
	201	}
	202	// ---------------------------------------------------------------------
	203	// AddvvOp
	204	bool addvv_op(void)
	205	{ bool ok = true;
	206	double eps = 10. * std::numeric_limits<double>::epsilon();
	207	size_t j;
	208
	209	// domain space vector
	210	size_t n = 2;
	211	CPPAD_TESTVECTOR(AD<double>) ax(n);
	212	ax[0] = 0.5;
	213	ax[1] = 2.0;
	214
	215	// declare independent variables and starting recording
	216	CppAD::Independent(ax);
	217
	218	// range space vector
	219	size_t m = 1;
	220	CPPAD_TESTVECTOR(AD<double>) ay(m);
	221	ay[0] = ax[0] + ax[1];
	222
	223	// create f: x -> y and stop tape recording
	224	CppAD::ADFun<double> f(ax, ay);
	225
	226	// first order Taylor coefficients
	227	size_t r = 2, ell;
	228	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	229	for(ell = 0; ell < r; ell++)
	230	{ for(j = 0; j < n; j++)
	231	x1[ r * j + ell ] = double(j + ell + 1);
	232	}
	233	y1 = f.Forward(1, r, x1);
	234	ok &= y1.size() == r*m;
	235
	236	// secondorder Taylor coefficients
	237	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	238	for(ell = 0; ell < r; ell++)
	239	{ for(j = 0; j < n; j++)
	240	x2[ r * j + ell ] = double(j + ell + 2);
	241	}
	242	y2 = f.Forward(2, r, x2);
	243	ok &= y2.size() == r*m;
	244	//
	245	// Y_0 (t) = F[X_0(t)]
	246	// = (0.5 + 1t + 2t^2) + (2.0 + 2t + 3t^2)
	247	double y_1_0 = 1.0 + 2.0;
	248	double y_2_0 = 2.0 + 3.0;
	249	//
	250	// Y_1 (t) = F[X_1(t)]
	251	// = (2.0 + 2t + 3t^2) + (2.0 + 3t + 4t^2)
	252	double y_1_1 = 2.0 + 3.0;
	253	double y_2_1 = 3.0 + 4.0;
	254	//
	255	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	256	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	257	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	258	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	259	//
	260	return ok;
	261	}
	262	// ---------------------------------------------------------------------
	263	// CosOp
	264	bool cos_op(void)
	265	{ bool ok = true;
	266	double eps = 10. * std::numeric_limits<double>::epsilon();
	267	size_t j;
	268
	269
	270	// domain space vector
	271	size_t n = 1;
	272	CPPAD_TESTVECTOR(AD<double>) ax(n);
	273	ax[0] = 0.5;
	274
	275	// declare independent variables and starting recording
	276	CppAD::Independent(ax);
	277
	278	// range space vector
	279	size_t m = 1;
	280	CPPAD_TESTVECTOR(AD<double>) ay(m);
	281	ay[0] = cos( ax[0] );
	282
	283	// create f: x -> y and stop tape recording
	284	CppAD::ADFun<double> f(ax, ay);
	285
	286	// first order Taylor coefficients
	287	size_t r = 2, ell;
	288	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	289	for(ell = 0; ell < r; ell++)
	290	{ for(j = 0; j < n; j++)
	291	x1[ r * j + ell ] = double(j + ell + 1);
	292	}
	293	y1 = f.Forward(1, r, x1);
	294	ok &= y1.size() == r*m;
	295
	296	// secondorder Taylor coefficients
	297	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	298	for(ell = 0; ell < r; ell++)
	299	{ for(j = 0; j < n; j++)
	300	x2[ r * j + ell ] = double(j + ell + 2);
	301	}
	302	y2 = f.Forward(2, r, x2);
	303	ok &= y2.size() == r*m;
	304	//
	305	// Y_0 (t) = F[X_0(t)]
	306	// = cos( 0.5 + 1t + 2t^2 )
	307	// Y_0' (t) = -sin( 0.5 + 1t + 2t^2) * (1 + 4t)
	308	double y_1_0 = - sin(0.5);
	309	double y_2_0 = - ( cos(0.5) + 4.0 * sin(0.5) ) / 2.0;
	310	//
	311	// Y_1 (t) = F[X_1(t)]
	312	// = cos( 0.5 + 2t + 3t^2 )
	313	// Y_1' (t) = -sin( 0.5 + 2t + 3t^2) * (2 + 6t)
	314	double y_1_1 = - sin(0.5) * 2.0;
	315	double y_2_1 = - ( cos(0.5) * 4.0 + 6.0 * sin(0.5) ) / 2.0;
	316	//
	317	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	318	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	319	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	320	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	321	//
	322	return ok;
	323	}
	324	// ---------------------------------------------------------------------
	325	// CoshOp
	326	bool cosh_op(void)
	327	{ bool ok = true;
	328	double eps = 10. * std::numeric_limits<double>::epsilon();
	329	size_t j;
	330
	331
	332	// domain space vector
	333	size_t n = 1;
	334	CPPAD_TESTVECTOR(AD<double>) ax(n);
	335	ax[0] = 0.5;
	336
	337	// declare independent variables and starting recording
	338	CppAD::Independent(ax);
	339
	340	// range space vector
	341	size_t m = 1;
	342	CPPAD_TESTVECTOR(AD<double>) ay(m);
	343	ay[0] = cosh( ax[0] );
	344
	345	// create f: x -> y and stop tape recording
	346	CppAD::ADFun<double> f(ax, ay);
	347
	348	// first order Taylor coefficients
	349	size_t r = 2, ell;
	350	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	351	for(ell = 0; ell < r; ell++)
	352	{ for(j = 0; j < n; j++)
	353	x1[ r * j + ell ] = double(j + ell + 1);
	354	}
	355	y1 = f.Forward(1, r, x1);
	356	ok &= y1.size() == r*m;
	357
	358	// secondorder Taylor coefficients
	359	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	360	for(ell = 0; ell < r; ell++)
	361	{ for(j = 0; j < n; j++)
	362	x2[ r * j + ell ] = double(j + ell + 2);
	363	}
	364	y2 = f.Forward(2, r, x2);
	365	ok &= y2.size() == r*m;
	366	//
	367	// Y_0 (t) = F[X_0(t)]
	368	// = cosh( 0.5 + 1t + 2t^2 )
	369	// Y_0' (t) = sinh( 0.5 + 1t + 2t^2) * (1 + 4t)
	370	double y_1_0 = sinh(0.5);
	371	double y_2_0 = ( sinh(0.5) * 4.0 + cosh(0.5) ) / 2.0;
	372	//
	373	// Y_1 (t) = F[X_1(t)]
	374	// = cosh( 0.5 + 2t + 3t^2 )
	375	// Y_1' (t) = sinh( 0.5 + 2t + 3t^2) * (2 + 6t)
	376	double y_1_1 = sinh(0.5) * 2.0;
	377	double y_2_1 = ( sinh(0.5) * 6.0 + cosh(0.5) * 4.0 ) / 2.0;
	378	//
	379	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	380	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	381	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	382	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	383	//
	384	return ok;
	385	}
	386	// ---------------------------------------------------------------------
	387	// CExpOp
	388	bool cexp_op(void)
	389	{ bool ok = true;
	390	double eps = 10. * std::numeric_limits<double>::epsilon();
	391	size_t j;
	392
	393	// domain space vector
	394	size_t n = 4;
	395	CPPAD_TESTVECTOR(AD<double>) ax(n);
	396	for(j = 0; j < n; j++)
	397	ax[j] = double(j);
	398
	399	// declare independent variables and starting recording
	400	CppAD::Independent(ax);
	401
	402	// range space vector
	403	size_t m = 2;
	404	CPPAD_TESTVECTOR(AD<double>) ay(m);
	405	ay[0] = CondExpLt(ax[0], ax[1], ax[2], ax[3]);
	406	ay[1] = CondExpGt(ax[0], ax[1], ax[2], ax[3]);
	407
	408	// create f: x -> y and stop tape recording
	409	CppAD::ADFun<double> f(ax, ay);
	410
	411	// first order Taylor coefficients
	412	size_t r = 2, ell;
	413	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	414	for(ell = 0; ell < r; ell++)
	415	{ for(j = 0; j < n; j++)
	416	x1[ r * j + ell ] = double(j + ell + 1);
	417	}
	418	y1 = f.Forward(1, r, x1);
	419	ok &= y1.size() == r*m;
	420
	421	// secondorder Taylor coefficients
	422	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	423	for(ell = 0; ell < r; ell++)
	424	{ for(j = 0; j < n; j++)
	425	x2[ r * j + ell ] = double(j + ell + 2);
	426	}
	427	y2 = f.Forward(2, r, x2);
	428	ok &= y2.size() == r*m;
	429	//
	430	// Y0_0 (t) = X2_0(t)
	431	// = 2.0 + 3t + 4t^2
	432	double y0_1_0 = 3.0;
	433	double y0_2_0 = 4.0;
	434	//
	435	// Y1_0 (t) = X3_0(t)
	436	// = 3.0 + 4t + 5t^2
	437	double y1_1_0 = 4.0;
	438	double y1_2_0 = 5.0;
	439	//
	440	// Y0_1 (t) = X2_1(t)
	441	// = 2.0 + 4t + 5t^2
	442	double y0_1_1 = 4.0;
	443	double y0_2_1 = 5.0;
	444	//
	445	// Y1_1 (t) = X3_0(t)
	446	// = 3.0 + 5t + 6t^2
	447	double y1_1_1 = 5.0;
	448	double y1_2_1 = 6.0;
	449	//
	450	ok &= NearEqual(y1[0*r+0] , y0_1_0, eps, eps);
	451	ok &= NearEqual(y1[1*r+0] , y1_1_0, eps, eps);
	452	ok &= NearEqual(y1[0*r+1] , y0_1_1, eps, eps);
	453	ok &= NearEqual(y1[1*r+1] , y1_1_1, eps, eps);
	454	//
	455	ok &= NearEqual(y2[0*r+0] , y0_2_0, eps, eps);
	456	ok &= NearEqual(y2[1*r+0] , y1_2_0, eps, eps);
	457	ok &= NearEqual(y2[0*r+1] , y0_2_1, eps, eps);
	458	ok &= NearEqual(y2[1*r+1] , y1_2_1, eps, eps);
	459	//
	460	return ok;
	461	}
	462
	463	// ---------------------------------------------------------------------
	464	// CSumOp
	465	bool csum_op(void)
	466	{ bool ok = true;
	467	double eps = 10. * std::numeric_limits<double>::epsilon();
	468	size_t j;
	469
	470	// domain space vector
	471	size_t n = 3;
	472	CPPAD_TESTVECTOR(AD<double>) ax(n);
	473	for(j = 0; j < n; j++)
	474	ax[j] = double(j);
	475
	476	// declare independent variables and starting recording
	477	CppAD::Independent(ax);
	478
	479	// range space vector
	480	size_t m = 1;
	481	CPPAD_TESTVECTOR(AD<double>) ay(m);
	482	ay[0] = 0.0;
	483	for(j = 0; j < n; j++)
	484	ay[0] += ax[j];
	485
	486	// create f: x -> y and stop tape recording
	487	CppAD::ADFun<double> f(ax, ay);
	488
	489	// optmize the tape so converts summation to on CSumOp operator
	490	f.optimize();
	491
	492	// zero order
	493	CPPAD_TESTVECTOR(double) x0(n);
	494	for(j = 0; j < n; j++)
	495	x0[j] = double(j);
	496	f.Forward(0, x0);
	497
	498	// first order Taylor coefficients
	499	size_t r = 2, ell;
	500	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	501	for(ell = 0; ell < r; ell++)
	502	{ for(j = 0; j < n; j++)
	503	x1[ r * j + ell ] = double(j + ell + 1);
	504	}
	505	y1 = f.Forward(1, r, x1);
	506	ok &= y1.size() == r*m;
	507
	508	// secondorder Taylor coefficients
	509	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	510	for(ell = 0; ell < r; ell++)
	511	{ for(j = 0; j < n; j++)
	512	x2[ r * j + ell ] = double(j + ell + 3);
	513	}
	514	y2 = f.Forward(2, r, x2);
	515	ok &= y2.size() == r*m;
	516	//
	517	double check = 0.0;
	518	for(j = 0; j < n; j++)
	519	check += x1[ r * j + 0];
	520	ok &= NearEqual(y1[0] , check, eps, eps);
	521	//
	522	check = 0.0;
	523	for(j = 0; j < n; j++)
	524	check += x1[ r * j + 1];
	525	ok &= NearEqual(y1[1] , check, eps, eps);
	526	//
	527	check = 0.0;
	528	for(j = 0; j < n; j++)
	529	check += x2[ r * j + 0];
	530	ok &= NearEqual(y2[0] , check, eps, eps);
	531	//
	532	check = 0.0;
	533	for(j = 0; j < n; j++)
	534	check += x2[ r * j + 1];
	535	ok &= NearEqual(y2[1] , check, eps, eps);
	536	//
	537	return ok;
	538	}
	539	// ---------------------------------------------------------------------
	540	// DisOp (test assuming that AddvvOp is correct)
	541	double round_off(const double& x)
	542	{ // std::round(x); is C++11, so we avoid using it
	543	return std::floor( x + 0.5 );
	544	}
	545	CPPAD_DISCRETE_FUNCTION(double, round_off)
	546	bool dis_op(void)
	547	{ bool ok = true;
	548	double eps = 10. * std::numeric_limits<double>::epsilon();
	549	size_t j;
	550
	551	// domain space vector
	552	size_t n = 1;
	553	CPPAD_TESTVECTOR(AD<double>) ax(n);
	554	ax[0] = 0.5;
	555
	556	// declare independent variables and starting recording
	557	CppAD::Independent(ax);
	558
	559	// range space vector
	560	size_t m = 1;
	561	CPPAD_TESTVECTOR(AD<double>) ay(m);
	562	ay[0] = round_off( ax[0] ) + ax[0];
	563
	564	// create f: x -> y and stop tape recording
	565	CppAD::ADFun<double> f(ax, ay);
	566
	567	// zero order
	568	CPPAD_TESTVECTOR(double) x0(n), y0;
	569	x0[0] = 2.2;
	570	y0 = f.Forward(0, x0);
	571	ok &= y0.size() == m;
	572	ok &= NearEqual(y0[0], round_off(x0[0]) + x0[0], eps, eps);
	573
	574	// first order Taylor coefficients
	575	size_t r = 2, ell;
	576	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	577	for(ell = 0; ell < r; ell++)
	578	{ for(j = 0; j < n; j++)
	579	x1[ r * j + ell ] = double(j + ell + 1);
	580	}
	581	y1 = f.Forward(1, r, x1);
	582	ok &= y1.size() == r*m;
	583
	584	// secondorder Taylor coefficients
	585	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	586	for(ell = 0; ell < r; ell++)
	587	{ for(j = 0; j < n; j++)
	588	x2[ r * j + ell ] = double(j + ell + 2);
	589	}
	590	y2 = f.Forward(2, r, x2);
	591	ok &= y2.size() == r*m;
	592	//
	593	//
	594	// Y_0 (t) = F[X_0(t)]
	595	// = 2.0 + (2.2 + 1t + 2t^2)
	596	double y_1_0 = 1.0;
	597	double y_2_0 = 2.0;
	598	//
	599	// Y_1 (t) = F[X_1(t)]
	600	// = 2.0 + (2.2 + 2t + 3t^2)
	601	double y_1_1 = 2.0;
	602	double y_2_1 = 3.0;
	603	//
	604	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	605	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	606	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	607	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	608	//
	609	return ok;
	610	}
	611	// ---------------------------------------------------------------------
	612	// DivpvOp (testing assumping MulpvOp is correct)
	613	bool divpv_op(void)
	614	{ bool ok = true;
	615	double eps = 10. * std::numeric_limits<double>::epsilon();
	616	size_t j;
	617
	618	// domain space vector
	619	size_t n = 1;
	620	CPPAD_TESTVECTOR(AD<double>) ax(n);
	621	ax[0] = 0.5;
	622
	623	// declare independent variables and starting recording
	624	CppAD::Independent(ax);
	625
	626	// range space vector
	627	size_t m = 1;
	628	CPPAD_TESTVECTOR(AD<double>) ay(m);
	629	ay[0] = (2.0 / ax[0]) * (ax[0] * ax[0]);
	630
	631	// create f: x -> y and stop tape recording
	632	CppAD::ADFun<double> f(ax, ay);
	633
	634	// first order Taylor coefficients
	635	size_t r = 2, ell;
	636	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	637	for(ell = 0; ell < r; ell++)
	638	{ for(j = 0; j < n; j++)
	639	x1[ r * j + ell ] = double(j + ell + 1);
	640	}
	641	y1 = f.Forward(1, r, x1);
	642	ok &= y1.size() == r*m;
	643
	644	// secondorder Taylor coefficients
	645	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	646	for(ell = 0; ell < r; ell++)
	647	{ for(j = 0; j < n; j++)
	648	x2[ r * j + ell ] = double(j + ell + 2);
	649	}
	650	y2 = f.Forward(2, r, x2);
	651	ok &= y2.size() == r*m;
	652	//
	653	// Y_0 (t) = F[X_0(t)]
	654	// = 2.0 * (0.5 + 1t + 2t^2)
	655	double y_1_0 = 2.0;
	656	double y_2_0 = 4.0;
	657	//
	658	// Y_1 (t) = F[X_1(t)]
	659	// = 2.0 * (0.5 + 2t + 3t^2)/2.0
	660	double y_1_1 = 4.0;
	661	double y_2_1 = 6.0;
	662	//
	663	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	664	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	665	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	666	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	667	//
	668	return ok;
	669	}
	670	// ---------------------------------------------------------------------
	671	// DivvpOp
	672	bool divvp_op(void)
	673	{ bool ok = true;
	674	double eps = 10. * std::numeric_limits<double>::epsilon();
	675	size_t j;
	676
	677	// domain space vector
	678	size_t n = 1;
	679	CPPAD_TESTVECTOR(AD<double>) ax(n);
	680	ax[0] = 0.5;
	681
	682	// declare independent variables and starting recording
	683	CppAD::Independent(ax);
	684
	685	// range space vector
	686	size_t m = 1;
	687	CPPAD_TESTVECTOR(AD<double>) ay(m);
	688	ay[0] = ax[0] / 2.0;
	689
	690	// create f: x -> y and stop tape recording
	691	CppAD::ADFun<double> f(ax, ay);
	692
	693	// first order Taylor coefficients
	694	size_t r = 2, ell;
	695	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	696	for(ell = 0; ell < r; ell++)
	697	{ for(j = 0; j < n; j++)
	698	x1[ r * j + ell ] = double(j + ell + 1);
	699	}
	700	y1 = f.Forward(1, r, x1);
	701	ok &= y1.size() == r*m;
	702
	703	// secondorder Taylor coefficients
	704	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	705	for(ell = 0; ell < r; ell++)
	706	{ for(j = 0; j < n; j++)
	707	x2[ r * j + ell ] = double(j + ell + 3);
	708	}
	709	y2 = f.Forward(2, r, x2);
	710	ok &= y2.size() == r*m;
	711	//
	712	// Y_0 (t) = F[X_0(t)]
	713	// = (0.5 + 1t + 3t^2)/2.0
	714	double y_1_0 = 1.0 / 2.0;
	715	double y_2_0 = 3.0 / 2.0;
	716	//
	717	// Y_1 (t) = F[X_1(t)]
	718	// = (0.5 + 2t + 4t^2)/2.0
	719	double y_1_1 = 2.0 / 2.0;
	720	double y_2_1 = 4.0 / 2.0;
	721	//
	722	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	723	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	724	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	725	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	726	//
	727	return ok;
	728	}
	729	// ---------------------------------------------------------------------
	730	// ExpOp
	731	bool exp_op(void)
	732	{ bool ok = true;
	733	double eps = 10. * std::numeric_limits<double>::epsilon();
	734	size_t j;
	735
	736	// domain space vector
	737	size_t n = 1;
	738	CPPAD_TESTVECTOR(AD<double>) ax(n);
	739	ax[0] = 0.5;
	740
	741	// declare independent variables and starting recording
	742	CppAD::Independent(ax);
	743
	744	// range space vector
	745	size_t m = 1;
	746	CPPAD_TESTVECTOR(AD<double>) ay(m);
	747	ay[0] = exp( ax[0] );
	748
	749	// create f: x -> y and stop tape recording
	750	CppAD::ADFun<double> f(ax, ay);
	751
	752	// first order Taylor coefficients
	753	size_t r = 2, ell;
	754	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	755	for(ell = 0; ell < r; ell++)
	756	{ for(j = 0; j < n; j++)
	757	x1[ r * j + ell ] = double(j + ell + 1);
	758	}
	759	y1 = f.Forward(1, r, x1);
	760	ok &= y1.size() == r*m;
	761
	762	// secondorder Taylor coefficients
	763	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	764	for(ell = 0; ell < r; ell++)
	765	{ for(j = 0; j < n; j++)
	766	x2[ r * j + ell ] = double(j + ell + 2);
	767	}
	768	y2 = f.Forward(2, r, x2);
	769	ok &= y2.size() == r*m;
	770	//
	771	// Y_0 (t) = F[X_0(t)]
	772	// = exp(0.5 + 1t + 2t^2)
	773	// Y_0' (t) = exp(0.5 + 1t + 2t^2)*(1 + 4t)
	774	double y_1_0 = exp(0.5);
	775	double y_2_0 = ( exp(0.5)*4.0 + exp(0.5) ) / 2.0;
	776	//
	777	// Y_1 (t) = F[X_1(t)]
	778	// = exp(0.5 + 2t + 3t^2)
	779	// Y_1' (t) = exp(0.5 + 2t + 3t^2)*(2 + 6t)
	780	double y_1_1 = exp(0.5)*2.0;
	781	double y_2_1 = ( exp(0.5)6.0 + exp(0.5)2.0*2.0 ) / 2.0;
	782	//
	783	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	784	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	785	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	786	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	787	//
	788	return ok;
	789	}
	790	// ---------------------------------------------------------------------
	791	// LdpOp and LdvOp (test assuming AdvvOp is correct)
	792	bool load_op(void)
	793	{ bool ok = true;
	794	double eps = 10. * std::numeric_limits<double>::epsilon();
	795	size_t j;
	796
	797	// domain space vector
	798	size_t n = 2;
	799	CPPAD_TESTVECTOR(AD<double>) ax(n);
	800	ax[0] = 0.0;
	801	ax[1] = 1.0;
	802
	803	// declare independent variables and starting recording
	804	CppAD::Independent(ax);
	805
	806	// Store operations
	807	CppAD::VecAD<double> avec(3);
	808	avec[ AD<double>(0) ] = ax[0]; // store a variable
	809	avec[ AD<double>(1) ] = ax[1]; // store a variable
	810	avec[ AD<double>(2) ] = 5.0; // store a parameter
	811
	812	// range space vector
	813	size_t m = 2;
	814	CPPAD_TESTVECTOR(AD<double>) ay(m);
	815	ay[0] = avec[ AD<double>(0) ]; // load using parameter index
	816	ay[1] = avec[ ax[0] ]; // load using variable index
	817
	818	// create f: x -> y and stop tape recording
	819	CppAD::ADFun<double> f(ax, ay);
	820
	821	// zero order Taylor coefficients
	822	CPPAD_TESTVECTOR(double) x0(n), y0;
	823	x0[0] = 2;
	824	x0[1] = 3;
	825	y0 = f.Forward(0, x0);
	826	ok &= y0.size() == m;
	827	// y[0] = avec[0] = x[0]
	828	ok &= y0[0] == x0[0];
	829	// y[1] = avec[ x[0] ] = avec[2] = 5.0
	830	ok &= y0[1] == 5.0;
	831
	832	// first order Taylor coefficients
	833	size_t r = 2, ell;
	834	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	835	for(ell = 0; ell < r; ell++)
	836	{ for(j = 0; j < n; j++)
	837	x1[ r * j + ell ] = double(j + ell + 1);
	838	}
	839	y1 = f.Forward(1, r, x1);
	840	ok &= y1.size() == r*m;
	841
	842	// secondorder Taylor coefficients
	843	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	844	for(ell = 0; ell < r; ell++)
	845	{ for(j = 0; j < n; j++)
	846	x2[ r * j + ell ] = double(j + ell + 2);
	847	}
	848	y2 = f.Forward(2, r, x2);
	849	ok &= y2.size() == r*m;
	850	//
	851	// Y0_0 (t) = 2.0 + 1t + 2t^2
	852	double y0_1_0 = 1.0;
	853	double y0_2_0 = 2.0;
	854	//
	855	// Y1_0 (t) = 5.0
	856	double y1_1_0 = 0.0;
	857	double y1_2_0 = 0.0;
	858	//
	859	// Y0_1 (t) = 2.0 + 2t + 3t^2
	860	double y0_1_1 = 2.0;
	861	double y0_2_1 = 3.0;
	862	//
	863	// Y1_1 (t) = 5.0
	864	double y1_1_1 = 0.0;
	865	double y1_2_1 = 0.0;
	866	//
	867	ok &= NearEqual(y1[0*r+0] , y0_1_0, eps, eps);
	868	ok &= NearEqual(y1[1*r+0] , y1_1_0, eps, eps);
	869	ok &= NearEqual(y1[0*r+1] , y0_1_1, eps, eps);
	870	ok &= NearEqual(y1[1*r+1] , y1_1_1, eps, eps);
	871	//
	872	ok &= NearEqual(y2[0*r+0] , y0_2_0, eps, eps);
	873	ok &= NearEqual(y2[1*r+0] , y1_2_0, eps, eps);
	874	ok &= NearEqual(y2[0*r+1] , y0_2_1, eps, eps);
	875	ok &= NearEqual(y2[1*r+1] , y1_2_1, eps, eps);
	876	//
	877	return ok;
	878	}
	879
	880	// ---------------------------------------------------------------------
	881	// MulpvOp
	882	bool mulpv_op(void)
	883	{ bool ok = true;
	884	double eps = 10. * std::numeric_limits<double>::epsilon();
	885	size_t j;
	886
	887	// domain space vector
	888	size_t n = 1;
	889	CPPAD_TESTVECTOR(AD<double>) ax(n);
	890	ax[0] = 0.5;
	891
	892	// declare independent variables and starting recording
	893	CppAD::Independent(ax);
	894
	895	// range space vector
	896	size_t m = 1;
	897	CPPAD_TESTVECTOR(AD<double>) ay(m);
	898	ay[0] = 2.0 * ax[0];
	899
	900	// create f: x -> y and stop tape recording
	901	CppAD::ADFun<double> f(ax, ay);
	902
	903	// first order Taylor coefficients
	904	size_t r = 2, ell;
	905	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	906	for(ell = 0; ell < r; ell++)
	907	{ for(j = 0; j < n; j++)
	908	x1[ r * j + ell ] = double(j + ell + 1);
	909	}
	910	y1 = f.Forward(1, r, x1);
	911	ok &= y1.size() == r*m;
	912
	913	// secondorder Taylor coefficients
	914	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	915	for(ell = 0; ell < r; ell++)
	916	{ for(j = 0; j < n; j++)
	917	x2[ r * j + ell ] = double(j + ell + 3);
	918	}
	919	y2 = f.Forward(2, r, x2);
	920	ok &= y2.size() == r*m;
	921	//
	922	// Y_0 (t) = F[X_0(t)]
	923	// = 2.0 * (0.5 + 1t + 3t^2)
	924	double y_1_0 = 2.0 * 1.0;
	925	double y_2_0 = 2.0 * 3.0;
	926	//
	927	// Y_1 (t) = F[X_1(t)]
	928	// = 2.0 * (0.5 + 2t + 4t^2)
	929	double y_1_1 = 2.0 * 2.0;
	930	double y_2_1 = 2.0 * 4.0;
	931	//
	932	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	933	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	934	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	935	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	936	//
	937	return ok;
	938	}
	939	// ---------------------------------------------------------------------
	940	// PowvvOp (test assuming LogOp, ExpOp and DivvvOp are correct)
	941	bool powvv_op(void)
	942	{ bool ok = true;
	943	double eps = 10. * std::numeric_limits<double>::epsilon();
	944	size_t j;
	945
	946	// domain space vector
	947	size_t n = 2;
	948	CPPAD_TESTVECTOR(AD<double>) ax(n);
	949	ax[0] = 0.5;
	950	ax[1] = 2.0;
	951
	952	// declare independent variables and starting recording
	953	CppAD::Independent(ax);
	954
	955	// range space vector
	956	size_t m = 2;
	957	CPPAD_TESTVECTOR(AD<double>) ay(m);
	958	ay[0] = log( pow( exp(ax[0]) , ax[1] ) ) / ax[1] ;
	959	ay[1] = log( pow( exp(ax[0]) , ax[1] ) ) / ax[0] ;
	960
	961	// create f: x -> y and stop tape recording
	962	CppAD::ADFun<double> f(ax, ay);
	963
	964	// first order Taylor coefficients
	965	size_t r = 2, ell;
	966	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	967	for(ell = 0; ell < r; ell++)
	968	{ for(j = 0; j < n; j++)
	969	x1[ r * j + ell ] = double(j + ell + 1);
	970	}
	971	y1 = f.Forward(1, r, x1);
	972	ok &= y1.size() == r*m;
	973
	974	// secondorder Taylor coefficients
	975	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	976	for(ell = 0; ell < r; ell++)
	977	{ for(j = 0; j < n; j++)
	978	x2[ r * j + ell ] = double(j + ell + 2);
	979	}
	980	y2 = f.Forward(2, r, x2);
	981	ok &= y2.size() == r*m;
	982	//
	983	// Y0_0 (t) = 0.5 + 1t + 2t^2
	984	double y0_1_0 = 1.0;
	985	double y0_2_0 = 2.0;
	986	//
	987	// Y0_1 (t) = 0.5 + 2t + 3t^2
	988	double y0_1_1 = 2.0;
	989	double y0_2_1 = 3.0;
	990	//
	991	// Y1_0 (t) = 2.0 + 2t + 3t^2
	992	double y1_1_0 = 2.0;
	993	double y1_2_0 = 3.0;
	994	//
	995	// Y1_1 (t) = 2.0 + 3t + 4t^2
	996	double y1_1_1 = 3.0;
	997	double y1_2_1 = 4.0;
	998	//
	999	ok &= NearEqual(y1[0*r+0] , y0_1_0, eps, eps);
	1000	ok &= NearEqual(y1[1*r+0] , y1_1_0, eps, eps);
	1001	ok &= NearEqual(y1[0*r+1] , y0_1_1, eps, eps);
	1002	ok &= NearEqual(y1[1*r+1] , y1_1_1, eps, eps);
	1003	//
	1004	ok &= NearEqual(y2[0*r+0] , y0_2_0, eps, eps);
	1005	ok &= NearEqual(y2[1*r+0] , y1_2_0, eps, eps);
	1006	ok &= NearEqual(y2[0*r+1] , y0_2_1, eps, eps);
	1007	ok &= NearEqual(y2[1*r+1] , y1_2_1, eps, eps);
	1008	//
	1009	return ok;
	1010	}
	1011	// ---------------------------------------------------------------------
	1012	// SignOp (test assuming that MulvvOp is correct)
	1013	bool sign_op(void)
	1014	{ bool ok = true;
	1015	double eps = 10. * std::numeric_limits<double>::epsilon();
	1016	size_t j;
	1017
	1018	// domain space vector
	1019	size_t n = 1;
	1020	CPPAD_TESTVECTOR(AD<double>) ax(n);
	1021	ax[0] = 0.5;
	1022
	1023	// declare independent variables and starting recording
	1024	CppAD::Independent(ax);
	1025
	1026	// range space vector
	1027	size_t m = 1;
	1028	CPPAD_TESTVECTOR(AD<double>) ay(m);
	1029	ay[0] = sign( ax[0] ) * ax[0];
	1030
	1031	// create f: x -> y and stop tape recording
	1032	CppAD::ADFun<double> f(ax, ay);
	1033
	1034	// zero order
	1035	CPPAD_TESTVECTOR(double) x0(n), y0;
	1036	x0[0] = -3.0;
	1037	y0 = f.Forward(0, x0);
	1038	ok &= y0.size() == m;
	1039	ok &= NearEqual(y0[0], CppAD::abs(x0[0]), eps, eps);
	1040
	1041	// first order Taylor coefficients
	1042	size_t r = 2, ell;
	1043	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	1044	for(ell = 0; ell < r; ell++)
	1045	{ for(j = 0; j < n; j++)
	1046	x1[ r * j + ell ] = double(j + ell + 1);
	1047	}
	1048	y1 = f.Forward(1, r, x1);
	1049	ok &= y1.size() == r*m;
	1050
	1051	// secondorder Taylor coefficients
	1052	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	1053	for(ell = 0; ell < r; ell++)
	1054	{ for(j = 0; j < n; j++)
	1055	x2[ r * j + ell ] = double(j + ell + 2);
	1056	}
	1057	y2 = f.Forward(2, r, x2);
	1058	ok &= y2.size() == r*m;
	1059	//
	1060	//
	1061	// Y_0 (t) = F[X_0(t)]
	1062	// = -(-3.0 + 1t + 2t^2)
	1063	double y_1_0 = -1.0;
	1064	double y_2_0 = -2.0;
	1065	//
	1066	// Y_1 (t) = F[X_1(t)]
	1067	// = -(-3.0 + 2t + 3t^2)
	1068	double y_1_1 = -2.0;
	1069	double y_2_1 = -3.0;
	1070	//
	1071	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	1072	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	1073	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	1074	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	1075	//
	1076	return ok;
	1077	}
	1078
	1079	// ---------------------------------------------------------------------
	1080	// SinOp
	1081	bool sin_op(void)
	1082	{ bool ok = true;
	1083	double eps = 10. * std::numeric_limits<double>::epsilon();
	1084	size_t j;
	1085
	1086
	1087	// domain space vector
	1088	size_t n = 1;
	1089	CPPAD_TESTVECTOR(AD<double>) ax(n);
	1090	ax[0] = 0.5;
	1091
	1092	// declare independent variables and starting recording
	1093	CppAD::Independent(ax);
	1094
	1095	// range space vector
	1096	size_t m = 1;
	1097	CPPAD_TESTVECTOR(AD<double>) ay(m);
	1098	ay[0] = sin( ax[0] );
	1099
	1100	// create f: x -> y and stop tape recording
	1101	CppAD::ADFun<double> f(ax, ay);
	1102
	1103	// first order Taylor coefficients
	1104	size_t r = 2, ell;
	1105	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	1106	for(ell = 0; ell < r; ell++)
	1107	{ for(j = 0; j < n; j++)
	1108	x1[ r * j + ell ] = double(j + ell + 1);
	1109	}
	1110	y1 = f.Forward(1, r, x1);
	1111	ok &= y1.size() == r*m;
	1112
	1113	// secondorder Taylor coefficients
	1114	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	1115	for(ell = 0; ell < r; ell++)
	1116	{ for(j = 0; j < n; j++)
	1117	x2[ r * j + ell ] = double(j + ell + 2);
	1118	}
	1119	y2 = f.Forward(2, r, x2);
	1120	ok &= y2.size() == r*m;
	1121	//
	1122	// Y_0 (t) = F[X_0(t)]
	1123	// = sin( 0.5 + 1t + 2t^2 )
	1124	// Y_0' (t) = cos( 0.5 + 1t + 2t^2) * (1 + 4t)
	1125	double y_1_0 = cos(0.5);
	1126	double y_2_0 = ( cos(0.5) * 4.0 - sin(0.5) ) / 2.0;
	1127	//
	1128	// Y_1 (t) = F[X_1(t)]
	1129	// = sin( 0.5 + 2t + 3t^2 )
	1130	// Y_1' (t) = cos( 0.5 + 2t + 3t^2) * (2 + 6t)
	1131	double y_1_1 = cos(0.5) * 2.0;
	1132	double y_2_1 = ( cos(0.5) * 6.0 - sin(0.5) * 4.0 ) / 2.0;
	1133	//
	1134	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	1135	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	1136	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	1137	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	1138	//
	1139	return ok;
	1140	}
	1141	// ---------------------------------------------------------------------
	1142	// SinhOp
	1143	bool sinh_op(void)
	1144	{ bool ok = true;
	1145	double eps = 10. * std::numeric_limits<double>::epsilon();
	1146	size_t j;
	1147
	1148
	1149	// domain space vector
	1150	size_t n = 1;
	1151	CPPAD_TESTVECTOR(AD<double>) ax(n);
	1152	ax[0] = 0.5;
	1153
	1154	// declare independent variables and starting recording
	1155	CppAD::Independent(ax);
	1156
	1157	// range space vector
	1158	size_t m = 1;
	1159	CPPAD_TESTVECTOR(AD<double>) ay(m);
	1160	ay[0] = sinh( ax[0] );
	1161
	1162	// create f: x -> y and stop tape recording
	1163	CppAD::ADFun<double> f(ax, ay);
	1164
	1165	// first order Taylor coefficients
	1166	size_t r = 2, ell;
	1167	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	1168	for(ell = 0; ell < r; ell++)
	1169	{ for(j = 0; j < n; j++)
	1170	x1[ r * j + ell ] = double(j + ell + 1);
	1171	}
	1172	y1 = f.Forward(1, r, x1);
	1173	ok &= y1.size() == r*m;
	1174
	1175	// secondorder Taylor coefficients
	1176	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	1177	for(ell = 0; ell < r; ell++)
	1178	{ for(j = 0; j < n; j++)
	1179	x2[ r * j + ell ] = double(j + ell + 2);
	1180	}
	1181	y2 = f.Forward(2, r, x2);
	1182	ok &= y2.size() == r*m;
	1183	//
	1184	// Y_0 (t) = F[X_0(t)]
	1185	// = sinh( 0.5 + 1t + 2t^2 )
	1186	// Y_0' (t) = cosh( 0.5 + 1t + 2t^2) * (1 + 4t)
	1187	double y_1_0 = cosh(0.5);
	1188	double y_2_0 = ( cosh(0.5) * 4.0 + sinh(0.5) ) / 2.0;
	1189	//
	1190	// Y_1 (t) = F[X_1(t)]
	1191	// = sinh( 0.5 + 2t + 3t^2 )
	1192	// Y_1' (t) = cosh( 0.5 + 2t + 3t^2) * (2 + 6t)
	1193	double y_1_1 = cosh(0.5) * 2.0;
	1194	double y_2_1 = ( cosh(0.5) * 6.0 + sinh(0.5) * 4.0 ) / 2.0;
	1195	//
	1196	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	1197	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	1198	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	1199	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	1200	//
	1201	return ok;
	1202	}
	1203	// ---------------------------------------------------------------------
	1204	// SubpvOp
	1205	bool subpv_op(void)
	1206	{ bool ok = true;
	1207	double eps = 10. * std::numeric_limits<double>::epsilon();
	1208	size_t j;
	1209
	1210	// domain space vector
	1211	size_t n = 1;
	1212	CPPAD_TESTVECTOR(AD<double>) ax(n);
	1213	ax[0] = 0.5;
	1214
	1215	// declare independent variables and starting recording
	1216	CppAD::Independent(ax);
	1217
	1218	// range space vector
	1219	size_t m = 1;
	1220	CPPAD_TESTVECTOR(AD<double>) ay(m);
	1221	ay[0] = 2.0 - ax[0];
	1222
	1223	// create f: x -> y and stop tape recording
	1224	CppAD::ADFun<double> f(ax, ay);
	1225
	1226	// first order Taylor coefficients
	1227	size_t r = 2, ell;
	1228	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	1229	for(ell = 0; ell < r; ell++)
	1230	{ for(j = 0; j < n; j++)
	1231	x1[ r * j + ell ] = double(j + ell + 1);
	1232	}
	1233	y1 = f.Forward(1, r, x1);
	1234	ok &= y1.size() == r*m;
	1235
	1236	// secondorder Taylor coefficients
	1237	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	1238	for(ell = 0; ell < r; ell++)
	1239	{ for(j = 0; j < n; j++)
	1240	x2[ r * j + ell ] = double(j + ell + 3);
	1241	}
	1242	y2 = f.Forward(2, r, x2);
	1243	ok &= y2.size() == r*m;
	1244	//
	1245	// Y_0 (t) = F[X_0(t)]
	1246	// = 2.0 - (0.5 + 1t + 3t^2)/2.0
	1247	double y_1_0 = - 1.0;
	1248	double y_2_0 = - 3.0;
	1249	//
	1250	// Y_1 (t) = F[X_1(t)]
	1251	// = 3.0 - (0.5 + 2t + 4t^2)/2.0
	1252	double y_1_1 = - 2.0;
	1253	double y_2_1 = - 4.0;
	1254	//
	1255	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	1256	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	1257	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	1258	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	1259	//
	1260	return ok;
	1261	}
	1262	// ---------------------------------------------------------------------
	1263	// SubvvOp
	1264	bool subvv_op(void)
	1265	{ bool ok = true;
	1266	double eps = 10. * std::numeric_limits<double>::epsilon();
	1267	size_t j;
	1268
	1269	// domain space vector
	1270	size_t n = 2;
	1271	CPPAD_TESTVECTOR(AD<double>) ax(n);
	1272	ax[0] = 0.5;
	1273	ax[1] = 2.0;
	1274
	1275	// declare independent variables and starting recording
	1276	CppAD::Independent(ax);
	1277
	1278	// range space vector
	1279	size_t m = 1;
	1280	CPPAD_TESTVECTOR(AD<double>) ay(m);
	1281	ay[0] = ax[0] - 2.0 * ax[1];
	1282
	1283	// create f: x -> y and stop tape recording
	1284	CppAD::ADFun<double> f(ax, ay);
	1285
	1286	// first order Taylor coefficients
	1287	size_t r = 2, ell;
	1288	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	1289	for(ell = 0; ell < r; ell++)
	1290	{ for(j = 0; j < n; j++)
	1291	x1[ r * j + ell ] = double(j + ell + 1);
	1292	}
	1293	y1 = f.Forward(1, r, x1);
	1294	ok &= y1.size() == r*m;
	1295
	1296	// secondorder Taylor coefficients
	1297	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	1298	for(ell = 0; ell < r; ell++)
	1299	{ for(j = 0; j < n; j++)
	1300	x2[ r * j + ell ] = double(j + ell + 2);
	1301	}
	1302	y2 = f.Forward(2, r, x2);
	1303	ok &= y2.size() == r*m;
	1304	//
	1305	// Y_0 (t) = F[X_0(t)]
	1306	// = (0.5 + 1t + 2t^2) - 2.0 * (2.0 + 2t + 3t^2)
	1307	double y_1_0 = 1.0 - 4.0;
	1308	double y_2_0 = 2.0 - 6.0;
	1309	//
	1310	// Y_1 (t) = F[X_1(t)]
	1311	// = (2.0 + 2t + 3t^2) - 2.0 * (2.0 + 3t + 4t^2)
	1312	double y_1_1 = 2.0 - 6.0;
	1313	double y_2_1 = 3.0 - 8.0;
	1314	//
	1315	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	1316	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	1317	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	1318	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	1319	//
	1320	return ok;
	1321	}
	1322	// ---------------------------------------------------------------------
	1323	// TanOp
	1324	bool tan_op(void)
	1325	{ bool ok = true;
	1326	double eps = 10. * std::numeric_limits<double>::epsilon();
	1327	size_t j;
	1328
	1329	// domain space vector
	1330	size_t n = 1;
	1331	CPPAD_TESTVECTOR(AD<double>) ax(n);
	1332	ax[0] = 0.5;
	1333
	1334	// declare independent variables and starting recording
	1335	CppAD::Independent(ax);
	1336
	1337	// range space vector
	1338	size_t m = 1;
	1339	CPPAD_TESTVECTOR(AD<double>) ay(m);
	1340	ay[0] = tan( ax[0] );
	1341
	1342	// create f: x -> y and stop tape recording
	1343	CppAD::ADFun<double> f(ax, ay);
	1344
	1345	// first order Taylor coefficients
	1346	size_t r = 2, ell;
	1347	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	1348	for(ell = 0; ell < r; ell++)
	1349	{ for(j = 0; j < n; j++)
	1350	x1[ r * j + ell ] = double(j + ell + 1);
	1351	}
	1352	y1 = f.Forward(1, r, x1);
	1353	ok &= y1.size() == r*m;
	1354
	1355	// secondorder Taylor coefficients
	1356	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	1357	for(ell = 0; ell < r; ell++)
	1358	{ for(j = 0; j < n; j++)
	1359	x2[ r * j + ell ] = double(j + ell + 2);
	1360	}
	1361	y2 = f.Forward(2, r, x2);
	1362	ok &= y2.size() == r*m;
	1363	//
	1364	// Y_0 (t) = F[X_0(t)]
	1365	// = tan(0.5 + 1t + 2t^2)
	1366	// Y_0' (t) = cos(0.5 + 1t + 2t^2)^(-2)*(1 + 4t)
	1367	// Y_0''(0) = 2cos(0.5)^(-3)sin(0.5) + 4*cos(0.5)^(-2)
	1368	double sec_sq = 1.0 / ( cos(0.5) * cos(0.5) );
	1369	double y_1_0 = sec_sq;
	1370	double y_2_0 = (2.0 * tan(0.5) + 4.0) * sec_sq / 2.0;
	1371	//
	1372	// Y_1 (t) = F[X_1(t)]
	1373	// = tan(0.5 + 2t + 3t^2)
	1374	// Y_1' (t) = cos(0.5 + 2t + 3t^2)^(-2)*(2 + 6t)
	1375	// Y_1''(0) = 2cos(0.5)^(-3)sin(0.5)22 + 6*cos(0.5)^(-2)
	1376	double y_1_1 = 2.0 * sec_sq;
	1377	double y_2_1 = (8.0 * tan(0.5) + 6.0) * sec_sq / 2.0;
	1378	//
	1379	ok &= NearEqual(y1[0] , y_1_0, eps, eps);
	1380	ok &= NearEqual(y1[1] , y_1_1, eps, eps);
	1381	ok &= NearEqual(y2[0] , y_2_0, eps, eps);
	1382	ok &= NearEqual(y2[1] , y_2_1, eps, eps);
	1383	//
	1384	return ok;
	1385	}
	1386	// ---------------------------------------------------------------------
	1387	// Usr*Op
	1388	typedef CPPAD_TESTVECTOR(AD<double>) avector;
	1389	void usr_algo(const avector& x, avector& z)
	1390	{ z[0] = ( x[0] + x[1] ) / 2.0;
	1391	z[1] = x[0] * x[1];
	1392	z[2] = ( x[0] - x[1] ) / 2.0;
	1393	return;
	1394	}
	1395	bool usr_op(void)
	1396	{ bool ok = true;
	1397	double eps = 10. * std::numeric_limits<double>::epsilon();
	1398	size_t j;
	1399
	1400	// define checkpoint function
	1401	size_t n = 2;
	1402	avector ax(n), az(3);
	1403	ax[0] = 0.5;
	1404	ax[1] = 2.0;
	1405	CppAD::checkpoint<double> usr_check("usr_check", usr_algo, ax, az);
	1406
	1407	// declare independent variables and starting recording
	1408	CppAD::Independent(ax);
	1409
	1410	// record checkpoint function
	1411	usr_check(ax, az);
	1412
	1413	// range space vector
	1414	size_t m = 2;
	1415	avector ay(m);
	1416	ay[0] = az[0] + az[2]; // = ax[0]
	1417	ay[1] = az[0] - az[2]; // = ax[1]
	1418
	1419	// create f: x -> y and stop tape recording
	1420	CppAD::ADFun<double> f(ax, ay);
	1421
	1422	// first order Taylor coefficients
	1423	size_t r = 2, ell;
	1424	CPPAD_TESTVECTOR(double) x1(r*n), y1;
	1425	for(ell = 0; ell < r; ell++)
	1426	{ for(j = 0; j < n; j++)
	1427	x1[ r * j + ell ] = double(j + ell + 1);
	1428	}
	1429	y1 = f.Forward(1, r, x1);
	1430	ok &= y1.size() == r*m;
	1431
	1432	// secondorder Taylor coefficients
	1433	CPPAD_TESTVECTOR(double) x2(r*n), y2;
	1434	for(ell = 0; ell < r; ell++)
	1435	{ for(j = 0; j < n; j++)
	1436	x2[ r * j + ell ] = double(j + ell + 2);
	1437	}
	1438	y2 = f.Forward(2, r, x2);
	1439	ok &= y2.size() == r*m;
	1440	//
	1441	// Y0_0 (t) = 0.5 + 1t + 2t^2
	1442	double y0_1_0 = 1.0;
	1443	double y0_2_0 = 2.0;
	1444	//
	1445	// Y0_1 (t) = 0.5 + 2t + 3t^2
	1446	double y0_1_1 = 2.0;
	1447	double y0_2_1 = 3.0;
	1448	//
	1449	// Y1_0 (t) = 2.0 + 2t + 3t^2
	1450	double y1_1_0 = 2.0;
	1451	double y1_2_0 = 3.0;
	1452	//
	1453	// Y1_1 (t) = 2.0 + 3t + 4t^2
	1454	double y1_1_1 = 3.0;
	1455	double y1_2_1 = 4.0;
	1456	//
	1457	ok &= NearEqual(y1[0*r+0] , y0_1_0, eps, eps);
	1458	ok &= NearEqual(y1[1*r+0] , y1_1_0, eps, eps);
	1459	ok &= NearEqual(y1[0*r+1] , y0_1_1, eps, eps);
	1460	ok &= NearEqual(y1[1*r+1] , y1_1_1, eps, eps);
	1461	//
	1462	ok &= NearEqual(y2[0*r+0] , y0_2_0, eps, eps);
	1463	ok &= NearEqual(y2[1*r+0] , y1_2_0, eps, eps);
	1464	ok &= NearEqual(y2[0*r+1] , y0_2_1, eps, eps);
	1465	ok &= NearEqual(y2[1*r+1] , y1_2_1, eps, eps);
	1466	//
	1467	return ok;
	1468	}
	1469	// ---------------------------------------------------------------------
	1470	// Inverse functions assume the following already tested:
	1471	// CosOp, SinOp, TanOp, ExpOp, MulvvOp, DivvpOp, AddpvOp
	1472	//
	1473	// AcosOp
	1474	AD<double> acos_fun(const AD<double>& x)
	1475	{ return acos( cos(x) ); }
	1476	bool acos_op(void)
	1477	{ return check_identity(acos_fun, 0.5); }
	1478	//
	1479	// AsinOp
	1480	AD<double> asin_fun(const AD<double>& x)
	1481	{ return asin( sin(x) ); }
	1482	bool asin_op(void)
	1483	{ return check_identity(asin_fun, 0.5); }
	1484	//
	1485	// AtanOp
	1486	AD<double> atan_fun(const AD<double>& x)
	1487	{ return atan( tan(x) ); }
	1488	bool atan_op(void)
	1489	{ return check_identity(atan_fun, 0.5); }
	1490	//
	1491	// LogOp
	1492	AD<double> log_fun(const AD<double>& x)
	1493	{ return log( exp(x) ); }
	1494	bool log_op(void)
	1495	{ return check_identity(log_fun, 0.5); }
	1496	//
	1497	// DivvvOp
	1498	AD<double> divvv_fun(const AD<double>& x)
	1499	{ return (x * x) / x; }
	1500	bool divvv_op(void)
	1501	{ return check_identity(divvv_fun, 0.5); }
	1502	//
	1503	// PowpvOp
	1504	AD<double> powpv_fun(const AD<double>& x )
	1505	{ return log( pow( exp(3.0) , x ) ) / 3.0; }
	1506	bool powpv_op(void)
	1507	{ return check_identity(powpv_fun, 0.5); }
	1508	//
	1509	// PowvpOp
	1510	AD<double> powvp_fun(const AD<double>& x )
	1511	{ return log( pow( exp(x) , 3.0 ) ) / 3.0; }
	1512	bool powvp_op(void)
	1513	{ return check_identity(powvp_fun, 0.5); }
	1514	//
	1515	// SqrtOp
	1516	AD<double> sqrt_fun(const AD<double>& x )
	1517	{ return sqrt( x * x ); }
	1518	bool sqrt_op(void)
	1519	{ return check_identity(sqrt_fun, 0.5); }
	1520	//
	1521	// SubvpOp
	1522	AD<double> subvp_fun(const AD<double>& x )
	1523	{ return 3.0 + ( x - 3.0 ); }
	1524	bool subvp_op(void)
	1525	{ return check_identity(subvp_fun, 0.5); }
	1526	//
	1527	// TanhOp
	1528	AD<double> tanh_fun(const AD<double>& x )
	1529	{ AD<double> z = tanh(x);
	1530	return log( (1.0 + z) / (1.0 - z) ) / 2.0;
	1531	}
	1532	bool tanh_op(void)
	1533	{ return check_identity(tanh_fun, 0.5); }
	1534	}
	1535
	1536	bool forward_dir(void)
	1537	{ bool ok = true;
	1538	//
	1539	ok &= abs_op();
	1540	ok &= acos_op();
	1541	ok &= asin_op();
	1542	ok &= atan_op();
	1543	ok &= addpv_op();
	1544	ok &= addvv_op();
	1545	ok &= cexp_op();
	1546	ok &= cosh_op();
	1547	ok &= cos_op();
	1548	ok &= csum_op();
	1549	ok &= dis_op();
	1550	ok &= divpv_op();
	1551	ok &= divvp_op();
	1552	ok &= divvv_op();
	1553	ok &= exp_op();
	1554	ok &= load_op();
	1555	ok &= log_op();
	1556	ok &= mulpv_op();
	1557	ok &= powpv_op();
	1558	ok &= powvp_op();
	1559	ok &= powvv_op();
	1560	ok &= sign_op();
	1561	ok &= sin_op();
	1562	ok &= sinh_op();
	1563	ok &= subpv_op();
	1564	ok &= subvp_op();
	1565	ok &= subvv_op();
	1566	ok &= sqrt_op();
	1567	ok &= tan_op();
	1568	ok &= tanh_op();
	1569	ok &= usr_op();
	1570	//
	1571	return ok;
	1572	}

-217

~~test_more/forward_mul.cpp~~ less more

0		/* $Id: forward_mul.cpp 2859 2013-05-28 06:03:21Z bradbell $ */
1		/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3
4		CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
6		GNU General Public License Version 3.
7
8		A copy of this license is included in the COPYING file of this distribution.
9		Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10		-------------------------------------------------------------------------- */
11
12		/*
13		$begin forward_mul.cpp$$
14		$spell
15		Cpp
16		$$
17
18		$section Forward Mode: Example and Test of Multiple Orders$$
19		$index forward, multiple orders$$
20		$index multiple, forward orders$$
21		$index order, multiple forward$$
22		$index example, forward multiple orders$$
23		$index test, forward multiple orders$$
24
25		$code
26		$verbatim%example/forward_mul.cpp%0%// BEGIN C++%// END C++%1%$$
27		$$
28
29		$end
30		*/
31		// BEGIN C++
32		# include <cppad/cppad.hpp>
33
34		namespace {
35
36		double my_discrete(const double& x)
37		{ return static_cast<int> ( x ); }
38		CPPAD_DISCRETE_FUNCTION(double, my_discrete)
39
40		}
41		bool forward_mul(void)
42		{ bool ok = true;
43		using CppAD::AD;
44		using CppAD::NearEqual;
45		size_t j, k;
46		double eps = 10. * CppAD::numeric_limits<double>::epsilon();
47
48		// domain space vector
49		size_t n = 23, m = n;
50		CPPAD_TESTVECTOR(AD<double>) X(n), Y(m);
51		for(j = 0; j < n; j++)
52		X[j] = 0.0;
53
54		// declare independent variables and starting recording
55		CppAD::Independent(X);
56
57		// identity function values
58		size_t i = 0;
59		size_t identity_begin = i;
60		Y[i] = cos( acos( X[i] ) ); i++; // AcosOp, CosOp
61		Y[i] = sin( asin( X[i] ) ); i++; // AsinOp, SinOp
62		Y[i] = tan( atan( X[i] ) ); i++; // AtanOp, TanOp
63		Y[i] = CondExpGt(X[i], X[i-1], X[i], X[i-2]); i++; // CExpOp
64		Y[i] = X[i-1] * X[i] / X[i-1]; i++; // DivvvOp, MulvvOp
65		Y[i] = X[i] * X[i] * 1.0 / X[i]; i++; // DivpvOp
66		Y[i] = 5.0 * X[i] / 5.0; i++; // DivvpOp, MulpvOp
67		Y[i] = exp( log( X[i] ) ); i++; // ExpOp, LogOp
68		Y[i] = pow( sqrt( X[i] ), 2.0); i++; // PowvpOp, SqrtOp
69		Y[i] = log( pow( std::exp(1.), X[i] ) ); i++; // PowpvOp
70		Y[i] = log( pow( X[i], X[i] ) ) / log( X[i]); i++; // PowvvOp
71		Y[i] = -2. - ((X[i-1] - X[i]) - 2.) + X[i-1]; i++; // Sub*Op: pv, vv, vp
72		size_t identity_end = i;
73
74		// other functions
75		Y[i] = abs( X[i] ); i++; // AbsOp
76		Y[i] = X[i-1] + X[i] + 2.0; i++; // AddvvOp, AddvpOp
77		Y[i] = cosh( X[i] ); i++; // CoshOp
78		Y[i] = my_discrete( X[i] ); i++; // DisOp
79		Y[i] = 4.0; i++; // ParOp
80		Y[i] = sign( X[i] ); i++; // SignOp
81		Y[i] = sinh( X[i] ); i++; // SinhOp
82		Y[i] = tanh(X[i]); i++; // TanhOp
83
84		// VecAD operations
85		CppAD::VecAD<double> V(n);
86		AD<double> index = 1.;
87		V[index] = 3.0;
88		Y[i] = V[index]; i++; // StppOp, LdpOp
89		V[index] = X[0];
90		Y[i] = V[index]; i++; // StpvOp, LdpOp
91		index = double(n) * X[3];
92		V[index] = X[1];
93		Y[i] = V[index]; i++; // StvvOp, LdvOp
94
95		// create f: X -> Y and stop tape recording
96		assert( i == m );
97		CppAD::ADFun<double> f;
98		f.Dependent(X, Y);
99
100		// initially, no values stored in f
101		ok &= f.size_taylor() == 0;
102
103		// Set X_j (t) = x + t
104		size_t p = 2, p1 = p+1;
105		CPPAD_TESTVECTOR(double) x(n), x_p(n * p1), y_p(m * p1);
106		for(j = 0; j < n; j++)
107		{ x[j] = double(j) / double(n);
108		x_p[j * p1 + 0] = x[j]; // order 0
109		x_p[j * p1 + 1] = 1.; // order 1
110		x_p[j * p1 + 2] = 0.; // order 2
111		}
112		// compute orders 0, 1, 2
113		y_p = f.Forward(p, x_p);
114
115		// identity functions
116		CPPAD_TESTVECTOR(double) y(p1);
117		i = 0;
118		for(j = identity_begin; j != identity_end; j++)
119		{ y[0] = x[j];
120		y[1] = 1.0;
121		y[2] = 0.0;
122		for(k = 0; k < p1; k++)
123		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
124		i++;
125		}
126
127		// y_i = abs( x_i )
128		y[0] = CppAD::abs( x[i] );
129		y[1] = CppAD::sign( x[i] );
130		y[2] = 0.0;
131		for(k = 0; k < p1; k++)
132		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
133
134		// y_i = x_[i-1] + x_i + 2
135		i++;
136		y[0] = x[i-1] + x[i] + 2.0;
137		y[1] = 2.0;
138		y[2] = 0.0;
139		for(k = 0; k < p1; k++)
140		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
141
142		// y_i = cosh( x_i )
143		i++;
144		y[0] = CppAD::cosh( x[i] );
145		y[1] = CppAD::sinh( x[i] );
146		y[2] = CppAD::cosh( x[i] ) / 2.0;
147		for(k = 0; k < p1; k++)
148		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
149
150		// y_i = my_discrete( x_i )
151		i++;
152		y[0] = my_discrete( x[i] );
153		y[1] = 0.0;
154		y[2] = 0.0;
155		for(k = 0; k < p1; k++)
156		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
157
158		// y_i = 4
159		i++;
160		y[0] = 4.0;
161		y[1] = 0.0;
162		y[2] = 0.0;
163		for(k = 0; k < p1; k++)
164		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
165
166		// y_i = sign( x_i )
167		i++;
168		y[0] = CppAD::sign( x[i] );
169		y[1] = 0.0;
170		y[2] = 0.0;
171		for(k = 0; k < p1; k++)
172		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
173
174		// y_i = sinh( x_i )
175		i++;
176		y[0] = CppAD::sinh( x[i] );
177		y[1] = CppAD::cosh( x[i] );
178		y[2] = CppAD::sinh( x[i] ) / 2.0;
179		for(k = 0; k < p1; k++)
180		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
181
182		// y_i = tanh( x_i )
183		i++;
184		y[0] = CppAD::tanh( x[i] );
185		y[1] = 1.0 - y[0] * y[0];
186		y[2] = - 2.0 * y[0] * y[1] / 2.0;
187		for(k = 0; k < p1; k++)
188		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
189
190		// y_i = 3.0;
191		i++;
192		y[0] = 3.0;
193		y[1] = 0.0;
194		y[2] = 0.0;
195		for(k = 0; k < p1; k++)
196		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
197
198		// y_i = x_0
199		i++;
200		y[0] = x[0];
201		y[1] = 1.0;
202		y[2] = 0.0;
203		for(k = 0; k < p1; k++)
204		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
205
206		// y_i = x_1
207		i++;
208		y[0] = x[1];
209		y[1] = 1.0;
210		y[2] = 0.0;
211		for(k = 0; k < p1; k++)
212		ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
213
214		return ok;
215		}
216		// END C++

+200

-0

test_more/forward_order.cpp less more

	0	/* $Id: forward_order.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
	1	/* --------------------------------------------------------------------------
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	3
	4	CppAD is distributed under multiple licenses. This distribution is under
	5	the terms of the
	6	GNU General Public License Version 3.
	7
	8	A copy of this license is included in the COPYING file of this distribution.
	9	Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
	10	-------------------------------------------------------------------------- */
	11
	12	/*
	13	*/
	14	// BEGIN C++
	15	# include <cppad/cppad.hpp>
	16
	17	namespace {
	18
	19	double my_discrete(const double& x)
	20	{ return static_cast<int> ( x ); }
	21	CPPAD_DISCRETE_FUNCTION(double, my_discrete)
	22
	23	}
	24	bool forward_order(void)
	25	{ bool ok = true;
	26	using CppAD::AD;
	27	using CppAD::NearEqual;
	28	size_t j, k;
	29	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	30
	31	// domain space vector
	32	size_t n = 23, m = n;
	33	CPPAD_TESTVECTOR(AD<double>) X(n), Y(m);
	34	for(j = 0; j < n; j++)
	35	X[j] = 0.0;
	36
	37	// declare independent variables and starting recording
	38	CppAD::Independent(X);
	39
	40	// identity function values
	41	size_t i = 0;
	42	size_t identity_begin = i;
	43	Y[i] = cos( acos( X[i] ) ); i++; // AcosOp, CosOp
	44	Y[i] = sin( asin( X[i] ) ); i++; // AsinOp, SinOp
	45	Y[i] = tan( atan( X[i] ) ); i++; // AtanOp, TanOp
	46	Y[i] = CondExpGt(X[i], X[i-1], X[i], X[i-2]); i++; // CExpOp
	47	Y[i] = X[i-1] * X[i] / X[i-1]; i++; // DivvvOp, MulvvOp
	48	Y[i] = X[i] * X[i] * 1.0 / X[i]; i++; // DivpvOp
	49	Y[i] = 5.0 * X[i] / 5.0; i++; // DivvpOp, MulpvOp
	50	Y[i] = exp( log( X[i] ) ); i++; // ExpOp, LogOp
	51	Y[i] = pow( sqrt( X[i] ), 2.0); i++; // PowvpOp, SqrtOp
	52	Y[i] = log( pow( std::exp(1.), X[i] ) ); i++; // PowpvOp
	53	Y[i] = log( pow( X[i], X[i] ) ) / log( X[i]); i++; // PowvvOp
	54	Y[i] = -2. - ((X[i-1] - X[i]) - 2.) + X[i-1]; i++; // Sub*Op: pv, vv, vp
	55	size_t identity_end = i;
	56
	57	// other functions
	58	Y[i] = abs( X[i] ); i++; // AbsOp
	59	Y[i] = X[i-1] + X[i] + 2.0; i++; // AddvvOp, AddvpOp
	60	Y[i] = cosh( X[i] ); i++; // CoshOp
	61	Y[i] = my_discrete( X[i] ); i++; // DisOp
	62	Y[i] = 4.0; i++; // ParOp
	63	Y[i] = sign( X[i] ); i++; // SignOp
	64	Y[i] = sinh( X[i] ); i++; // SinhOp
	65	Y[i] = tanh(X[i]); i++; // TanhOp
	66
	67	// VecAD operations
	68	CppAD::VecAD<double> V(n);
	69	AD<double> index = 1.;
	70	V[index] = 3.0;
	71	Y[i] = V[index]; i++; // StppOp, LdpOp
	72	V[index] = X[0];
	73	Y[i] = V[index]; i++; // StpvOp, LdpOp
	74	index = double(n) * X[3];
	75	V[index] = X[1];
	76	Y[i] = V[index]; i++; // StvvOp, LdvOp
	77
	78	// create f: X -> Y and stop tape recording
	79	assert( i == m );
	80	CppAD::ADFun<double> f;
	81	f.Dependent(X, Y);
	82
	83	// initially, no values stored in f
	84	ok &= f.size_order() == 0;
	85
	86	// Set X_j (t) = x + t
	87	size_t p = 2, p1 = p+1;
	88	CPPAD_TESTVECTOR(double) x(n), x_p(n * p1), y_p(m * p1);
	89	for(j = 0; j < n; j++)
	90	{ x[j] = double(j) / double(n);
	91	x_p[j * p1 + 0] = x[j]; // order 0
	92	x_p[j * p1 + 1] = 1.; // order 1
	93	x_p[j * p1 + 2] = 0.; // order 2
	94	}
	95	// compute orders 0, 1, 2
	96	y_p = f.Forward(p, x_p);
	97
	98	// identity functions
	99	CPPAD_TESTVECTOR(double) y(p1);
	100	i = 0;
	101	for(j = identity_begin; j != identity_end; j++)
	102	{ y[0] = x[j];
	103	y[1] = 1.0;
	104	y[2] = 0.0;
	105	for(k = 0; k < p1; k++)
	106	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	107	i++;
	108	}
	109
	110	// y_i = abs( x_i )
	111	y[0] = CppAD::abs( x[i] );
	112	y[1] = CppAD::sign( x[i] );
	113	y[2] = 0.0;
	114	for(k = 0; k < p1; k++)
	115	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	116
	117	// y_i = x_[i-1] + x_i + 2
	118	i++;
	119	y[0] = x[i-1] + x[i] + 2.0;
	120	y[1] = 2.0;
	121	y[2] = 0.0;
	122	for(k = 0; k < p1; k++)
	123	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	124
	125	// y_i = cosh( x_i )
	126	i++;
	127	y[0] = CppAD::cosh( x[i] );
	128	y[1] = CppAD::sinh( x[i] );
	129	y[2] = CppAD::cosh( x[i] ) / 2.0;
	130	for(k = 0; k < p1; k++)
	131	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	132
	133	// y_i = my_discrete( x_i )
	134	i++;
	135	y[0] = my_discrete( x[i] );
	136	y[1] = 0.0;
	137	y[2] = 0.0;
	138	for(k = 0; k < p1; k++)
	139	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	140
	141	// y_i = 4
	142	i++;
	143	y[0] = 4.0;
	144	y[1] = 0.0;
	145	y[2] = 0.0;
	146	for(k = 0; k < p1; k++)
	147	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	148
	149	// y_i = sign( x_i )
	150	i++;
	151	y[0] = CppAD::sign( x[i] );
	152	y[1] = 0.0;
	153	y[2] = 0.0;
	154	for(k = 0; k < p1; k++)
	155	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	156
	157	// y_i = sinh( x_i )
	158	i++;
	159	y[0] = CppAD::sinh( x[i] );
	160	y[1] = CppAD::cosh( x[i] );
	161	y[2] = CppAD::sinh( x[i] ) / 2.0;
	162	for(k = 0; k < p1; k++)
	163	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	164
	165	// y_i = tanh( x_i )
	166	i++;
	167	y[0] = CppAD::tanh( x[i] );
	168	y[1] = 1.0 - y[0] * y[0];
	169	y[2] = - 2.0 * y[0] * y[1] / 2.0;
	170	for(k = 0; k < p1; k++)
	171	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	172
	173	// y_i = 3.0;
	174	i++;
	175	y[0] = 3.0;
	176	y[1] = 0.0;
	177	y[2] = 0.0;
	178	for(k = 0; k < p1; k++)
	179	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	180
	181	// y_i = x_0
	182	i++;
	183	y[0] = x[0];
	184	y[1] = 1.0;
	185	y[2] = 0.0;
	186	for(k = 0; k < p1; k++)
	187	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	188
	189	// y_i = x_1
	190	i++;
	191	y[0] = x[1];
	192	y[1] = 1.0;
	193	y[2] = 0.0;
	194	for(k = 0; k < p1; k++)
	195	ok &= NearEqual(y[k] , y_p[i * p1 + k], eps, eps);
	196
	197	return ok;
	198	}
	199	// END C++

-4

test_more/fun_check.cpp less more

0		/* $Id: fun_check.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: fun_check.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

68	68
69	69	// stop tape and store operation sequence in f : X -> Y
70	70	f.Dependent(Y);
71		ok &= (f.size_taylor() == 0); // no implicit forward operation
	71	ok &= (f.size_order() == 0); // no implicit forward operation
72	72
73	73	// create function object to use with double
74	74	Fun<double, Vector> g(n);

97	97
98	98	// stop tape and store operation sequence in f : X -> Y
99	99	f.Dependent(Y);
100		ok &= (f.size_taylor() == 0); // no implicit forward with this x
	100	ok &= (f.size_order() == 0); // no implicit forward with this x
101	101
102	102	// function values should agree now
103	103	ok &= FunCheck(f, g, x, a, r);

-3

test_more/makefile.am less more

0		# $Id: makefile.am 2940 2013-10-14 16:14:52Z bradbell $
	0	# $Id: makefile.am 3301 2014-05-24 05:20:21Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5	5	# the terms of the

118	118	for_hess.cpp \
119	119	for_sparse_jac.cpp \
120	120	forward.cpp \
121		forward_mul.cpp \
	121	forward_dir.cpp \
	122	forward_order.cpp \
122	123	from_base.cpp \
123	124	fun_check.cpp \
124	125	jacobian.cpp \

+174

-97

test_more/makefile.in less more

0		# makefile.in generated by automake 1.11.6 from makefile.am.
	0	# makefile.in generated by automake 1.13.4 from makefile.am.
1	1	# @configure_input@
2	2
3		# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4		# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
5		# Foundation, Inc.
	3	# Copyright (C) 1994-2013 Free Software Foundation, Inc.
	4
6	5	# This Makefile.in is free software; the Free Software Foundation
7	6	# gives unlimited permission to copy and/or distribute it,
8	7	# with or without modifications, as long as this notice is preserved.

15	14	@SET_MAKE@
16	15
17	16	VPATH = @srcdir@
18		am__make_dryrun = \
19		{ \
20		am__dry=no; \
	17	am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
	18	am__make_running_with_option = \
	19	case $${target_option-} in \
	20	?) ;; \
	21	*) echo "am__make_running_with_option: internal error: invalid" \
	22	"target option '$${target_option-}' specified" >&2; \
	23	exit 1;; \
	24	esac; \
	25	has_opt=no; \
	26	sane_makeflags=$$MAKEFLAGS; \
	27	if $(am__is_gnu_make); then \
	28	sane_makeflags=$$MFLAGS; \
	29	else \
21	30	case $$MAKEFLAGS in \
22	31	\\[\ \ ]) \
23		echo 'am--echo: ; @echo "AM" OK' \| $(MAKE) -f - 2>/dev/null \
24		\| grep '^AM OK$$' >/dev/null \|\| am__dry=yes;; \
25		*) \
26		for am__flg in $$MAKEFLAGS; do \
27		case $$am__flg in \
28		=\|--*) ;; \
29		n) am__dry=yes; break;; \
30		esac; \
31		done;; \
	32	bs=\\; \
	33	sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
	34	\| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
32	35	esac; \
33		test $$am__dry = yes; \
34		}
	36	fi; \
	37	skip_next=no; \
	38	strip_trailopt () \
	39	{ \
	40	flg=`printf '%s\n' "$$flg" \| sed "s/$$1.*$$//"`; \
	41	}; \
	42	for flg in $$sane_makeflags; do \
	43	test $$skip_next = yes && { skip_next=no; continue; }; \
	44	case $$flg in \
	45	=\|--*) continue;; \
	46	-*I) strip_trailopt 'I'; skip_next=yes;; \
	47	-I?) strip_trailopt 'I';; \
	48	-*O) strip_trailopt 'O'; skip_next=yes;; \
	49	-O?) strip_trailopt 'O';; \
	50	-*l) strip_trailopt 'l'; skip_next=yes;; \
	51	-l?) strip_trailopt 'l';; \
	52	-[dEDm]) skip_next=yes;; \
	53	-[JT]) skip_next=yes;; \
	54	esac; \
	55	case $$flg in \
	56	$$target_option) has_opt=yes; break;; \
	57	esac; \
	58	done; \
	59	test $$has_opt = yes
	60	am__make_dryrun = (target_option=n; $(am__make_running_with_option))
	61	am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
35	62	pkgdatadir = $(datadir)/@PACKAGE@
36	63	pkgincludedir = $(includedir)/@PACKAGE@
37	64	pkglibdir = $(libdir)/@PACKAGE@

48	75	NORMAL_UNINSTALL = :
49	76	PRE_UNINSTALL = :
50	77	POST_UNINSTALL = :
	78	build_triplet = @build@
	79	host_triplet = @host@
51	80	check_PROGRAMS = test_more$(EXEEXT)
52	81	subdir = test_more
53		DIST_COMMON = $(srcdir)/makefile.am $(srcdir)/makefile.in \
54		$(srcdir)/test_one.sh.in
	82	DIST_COMMON = $(srcdir)/makefile.in $(srcdir)/makefile.am \
	83	$(srcdir)/test_one.sh.in $(top_srcdir)/depcomp
55	84	ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
56	85	am__aclocal_m4_deps = $(top_srcdir)/configure.ac
57	86	am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \

60	89	CONFIG_CLEAN_FILES = test_one.sh
61	90	CONFIG_CLEAN_VPATH_FILES =
62	91	LIBRARIES = $(noinst_LIBRARIES)
63		AR = ar
64	92	ARFLAGS = cru
65	93	AM_V_AR = $(am__v_AR_@AM_V@)
66	94	am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
67		am__v_AR_0 = @echo " AR " $@;
68		AM_V_at = $(am__v_at_@AM_V@)
69		am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
70		am__v_at_0 = @
	95	am__v_AR_0 = @echo " AR " $@;
	96	am__v_AR_1 =
71	97	libeigen_a_AR = $(AR) $(ARFLAGS)
72	98	libeigen_a_LIBADD =
73	99	am__libeigen_a_SOURCES_DIST = cppad_eigen.cpp

82	108	copy.cpp cos.cpp cosh.cpp dbl_epsilon.cpp div.cpp div_eq.cpp \
83	109	div_zero_one.cpp erf.cpp exp.cpp extern_value.cpp \
84	110	extern_value.hpp for_hess.cpp for_sparse_jac.cpp forward.cpp \
85		forward_mul.cpp from_base.cpp fun_check.cpp jacobian.cpp \
86		limits.cpp log.cpp log10.cpp mul.cpp mul_eq.cpp mul_level.cpp \
87		mul_zero_one.cpp ndebug.cpp near_equal_ext.cpp neg.cpp \
88		ode_err_control.cpp optimize.cpp parameter.cpp poly.cpp \
89		pow.cpp pow_int.cpp print_for.cpp romberg_one.cpp rosen_34.cpp \
90		runge_45.cpp reverse.cpp rev_sparse_hes.cpp rev_sparse_jac.cpp \
91		rev_two.cpp simple_vector.cpp sin.cpp sin_cos.cpp sinh.cpp \
92		sparse_hessian.cpp sparse_jacobian.cpp sparse_vec_ad.cpp \
93		sqrt.cpp std_math.cpp sub.cpp sub_eq.cpp sub_zero.cpp tan.cpp \
94		test_vector.cpp track_new_del.cpp value.cpp vec_ad.cpp \
95		vec_ad_par.cpp vec_unary.cpp
	111	forward_dir.cpp forward_order.cpp from_base.cpp fun_check.cpp \
	112	jacobian.cpp limits.cpp log.cpp log10.cpp mul.cpp mul_eq.cpp \
	113	mul_level.cpp mul_zero_one.cpp ndebug.cpp near_equal_ext.cpp \
	114	neg.cpp ode_err_control.cpp optimize.cpp parameter.cpp \
	115	poly.cpp pow.cpp pow_int.cpp print_for.cpp romberg_one.cpp \
	116	rosen_34.cpp runge_45.cpp reverse.cpp rev_sparse_hes.cpp \
	117	rev_sparse_jac.cpp rev_two.cpp simple_vector.cpp sin.cpp \
	118	sin_cos.cpp sinh.cpp sparse_hessian.cpp sparse_jacobian.cpp \
	119	sparse_vec_ad.cpp sqrt.cpp std_math.cpp sub.cpp sub_eq.cpp \
	120	sub_zero.cpp tan.cpp test_vector.cpp track_new_del.cpp \
	121	value.cpp vec_ad.cpp vec_ad_par.cpp vec_unary.cpp
96	122	@CppAD_ADOLC_TRUE@am__objects_1 = base_adolc.$(OBJEXT)
97	123	@CppAD_IPOPT_TRUE@am__objects_2 = ipopt_solve.$(OBJEXT)
98	124	@CppAD_OPENMP_TRUE@am__objects_3 = alloc_openmp.$(OBJEXT)

108	134	div_eq.$(OBJEXT) div_zero_one.$(OBJEXT) erf.$(OBJEXT) \
109	135	exp.$(OBJEXT) extern_value.$(OBJEXT) for_hess.$(OBJEXT) \
110	136	for_sparse_jac.$(OBJEXT) forward.$(OBJEXT) \
111		forward_mul.$(OBJEXT) from_base.$(OBJEXT) fun_check.$(OBJEXT) \
112		jacobian.$(OBJEXT) limits.$(OBJEXT) log.$(OBJEXT) \
113		log10.$(OBJEXT) mul.$(OBJEXT) mul_eq.$(OBJEXT) \
114		mul_level.$(OBJEXT) mul_zero_one.$(OBJEXT) ndebug.$(OBJEXT) \
115		near_equal_ext.$(OBJEXT) neg.$(OBJEXT) \
	137	forward_dir.$(OBJEXT) forward_order.$(OBJEXT) \
	138	from_base.$(OBJEXT) fun_check.$(OBJEXT) jacobian.$(OBJEXT) \
	139	limits.$(OBJEXT) log.$(OBJEXT) log10.$(OBJEXT) mul.$(OBJEXT) \
	140	mul_eq.$(OBJEXT) mul_level.$(OBJEXT) mul_zero_one.$(OBJEXT) \
	141	ndebug.$(OBJEXT) near_equal_ext.$(OBJEXT) neg.$(OBJEXT) \
116	142	ode_err_control.$(OBJEXT) optimize.$(OBJEXT) \
117	143	parameter.$(OBJEXT) poly.$(OBJEXT) pow.$(OBJEXT) \
118	144	pow_int.$(OBJEXT) print_for.$(OBJEXT) romberg_one.$(OBJEXT) \

133	159	@CppAD_IPOPT_TRUE@ $(am__DEPENDENCIES_1)
134	160	test_more_DEPENDENCIES = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_2) \
135	161	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
	162	AM_V_P = $(am__v_P_@AM_V@)
	163	am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
	164	am__v_P_0 = false
	165	am__v_P_1 = :
	166	AM_V_GEN = $(am__v_GEN_@AM_V@)
	167	am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
	168	am__v_GEN_0 = @echo " GEN " $@;
	169	am__v_GEN_1 =
	170	AM_V_at = $(am__v_at_@AM_V@)
	171	am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
	172	am__v_at_0 = @
	173	am__v_at_1 =
136	174	DEFAULT_INCLUDES =
137	175	depcomp = $(SHELL) $(top_srcdir)/depcomp
138	176	am__depfiles_maybe = depfiles

140	178	AM_V_lt = $(am__v_lt_@AM_V@)
141	179	am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
142	180	am__v_lt_0 = --silent
	181	am__v_lt_1 =
143	182	CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
144	183	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
145	184	AM_V_CXX = $(am__v_CXX_@AM_V@)
146	185	am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
147		am__v_CXX_0 = @echo " CXX " $@;
	186	am__v_CXX_0 = @echo " CXX " $@;
	187	am__v_CXX_1 =
148	188	CXXLD = $(CXX)
149	189	CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
150	190	-o $@
151	191	AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
152	192	am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
153		am__v_CXXLD_0 = @echo " CXXLD " $@;
	193	am__v_CXXLD_0 = @echo " CXXLD " $@;
	194	am__v_CXXLD_1 =
154	195	COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
155	196	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
156	197	AM_V_CC = $(am__v_CC_@AM_V@)
157	198	am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
158		am__v_CC_0 = @echo " CC " $@;
	199	am__v_CC_0 = @echo " CC " $@;
	200	am__v_CC_1 =
159	201	CCLD = $(CC)
160	202	LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
161	203	AM_V_CCLD = $(am__v_CCLD_@AM_V@)
162	204	am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
163		am__v_CCLD_0 = @echo " CCLD " $@;
164		AM_V_GEN = $(am__v_GEN_@AM_V@)
165		am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
166		am__v_GEN_0 = @echo " GEN " $@;
	205	am__v_CCLD_0 = @echo " CCLD " $@;
	206	am__v_CCLD_1 =
167	207	SOURCES = $(libeigen_a_SOURCES) $(test_more_SOURCES)
168	208	DIST_SOURCES = $(am__libeigen_a_SOURCES_DIST) \
169	209	$(am__test_more_SOURCES_DIST)

172	212	n\|no\|NO) false;; \
173	213	*) (install-info --version) >/dev/null 2>&1;; \
174	214	esac
	215	am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
	216	# Read a list of newline-separated strings from the standard input,
	217	# and print each of them once, without duplicates. Input order is
	218	# not preserved.
	219	am__uniquify_input = $(AWK) '\
	220	BEGIN { nonempty = 0; } \
	221	{ items[$$0] = 1; nonempty = 1; } \
	222	END { if (nonempty) { for (i in items) print i; }; } \
	223	'
	224	# Make sure the list of sources is unique. This is necessary because,
	225	# e.g., the same source file might be shared among _SOURCES variables
	226	# for different programs/libraries.
	227	am__define_uniq_tagged_files = \
	228	list='$(am__tagged_files)'; \
	229	unique=`for i in $$list; do \
	230	if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	231	done \| $(am__uniquify_input)`
175	232	ETAGS = etags
176	233	CTAGS = ctags
177	234	DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)

181	238	ADOLC_DIR = @ADOLC_DIR@
182	239	AMTAR = @AMTAR@
183	240	AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
	241	AR = @AR@
184	242	AUTOCONF = @AUTOCONF@
185	243	AUTOHEADER = @AUTOHEADER@
186	244	AUTOMAKE = @AUTOMAKE@

203	261	CXX_FLAGS_FADBAD = @CXX_FLAGS_FADBAD@
204	262	CYGPATH_W = @CYGPATH_W@
205	263
206		# $Id: makefile.in 3067 2013-12-29 17:35:34Z bradbell $
	264	# $Id: makefile.in 3497 2014-12-24 13:38:30Z bradbell $
207	265	# -----------------------------------------------------------------------------
208		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	266	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
209	267	#
210	268	# CppAD is distributed under multiple licenses. This distribution is under
211	269	# the terms of the

270	328	abs_srcdir = @abs_srcdir@
271	329	abs_top_builddir = @abs_top_builddir@
272	330	abs_top_srcdir = @abs_top_srcdir@
	331	ac_ct_AR = @ac_ct_AR@
273	332	ac_ct_CC = @ac_ct_CC@
274	333	ac_ct_CXX = @ac_ct_CXX@
275	334	ac_ct_FC = @ac_ct_FC@

280	339	am__tar = @am__tar@
281	340	am__untar = @am__untar@
282	341	bindir = @bindir@
	342	build = @build@
283	343	build_alias = @build_alias@
	344	build_cpu = @build_cpu@
	345	build_os = @build_os@
	346	build_vendor = @build_vendor@
284	347	builddir = @builddir@
285	348	cppad_SOURCE_DIR = @cppad_SOURCE_DIR@
286	349	cppad_boostvector = @cppad_boostvector@
287	350	cppad_cflags = @cppad_cflags@
	351	cppad_compiler_has_erf = @cppad_compiler_has_erf@
288	352	cppad_cppadvector = @cppad_cppadvector@
289	353	cppad_description = @cppad_description@
290	354	cppad_eigenvector = @cppad_eigenvector@
	355	cppad_has_colpack = @cppad_has_colpack@
	356	cppad_has_cstdint_8_to_64 = @cppad_has_cstdint_8_to_64@
291	357	cppad_has_gettimeofday = @cppad_has_gettimeofday@
292	358	cppad_has_nullptr = @cppad_has_nullptr@
	359	cppad_has_rvalue = @cppad_has_rvalue@
293	360	cppad_implicit_ctor_from_any_type = @cppad_implicit_ctor_from_any_type@
294	361	cppad_internal_sparse_set = @cppad_internal_sparse_set@
295	362	cppad_libs = @cppad_libs@
296	363	cppad_max_num_threads = @cppad_max_num_threads@
297	364	cppad_requires = @cppad_requires@
298		cppad_size_t_same_unsigned_int = @cppad_size_t_same_unsigned_int@
	365	cppad_size_t_not_unsigned_int = @cppad_size_t_not_unsigned_int@
299	366	cppad_stdvector = @cppad_stdvector@
300	367	cppad_tape_addr_type = @cppad_tape_addr_type@
301	368	cppad_tape_id_type = @cppad_tape_id_type@

307	374	dvidir = @dvidir@
308	375	eigen_prefix = @eigen_prefix@
309	376	exec_prefix = @exec_prefix@
310		have_ar = @have_ar@
311	377	have_pkg_config = @have_pkg_config@
	378	host = @host@
312	379	host_alias = @host_alias@
	380	host_cpu = @host_cpu@
	381	host_os = @host_os@
	382	host_vendor = @host_vendor@
313	383	htmldir = @htmldir@
314	384	includedir = @includedir@
315	385	infodir = @infodir@

430	500	for_hess.cpp \
431	501	for_sparse_jac.cpp \
432	502	forward.cpp \
433		forward_mul.cpp \
	503	forward_dir.cpp \
	504	forward_order.cpp \
434	505	from_base.cpp \
435	506	fun_check.cpp \
436	507	jacobian.cpp \

517	588
518	589	clean-noinstLIBRARIES:
519	590	-test -z "$(noinst_LIBRARIES)" \|\| rm -f $(noinst_LIBRARIES)
	591
520	592	libeigen.a: $(libeigen_a_OBJECTS) $(libeigen_a_DEPENDENCIES) $(EXTRA_libeigen_a_DEPENDENCIES)
521	593	$(AM_V_at)-rm -f libeigen.a
522	594	$(AM_V_AR)$(libeigen_a_AR) libeigen.a $(libeigen_a_OBJECTS) $(libeigen_a_LIBADD)

524	596
525	597	clean-checkPROGRAMS:
526	598	-test -z "$(check_PROGRAMS)" \|\| rm -f $(check_PROGRAMS)
	599
527	600	test_more$(EXEEXT): $(test_more_OBJECTS) $(test_more_DEPENDENCIES) $(EXTRA_test_more_DEPENDENCIES)
528	601	@rm -f test_more$(EXEEXT)
529	602	$(AM_V_CXXLD)$(CXXLINK) $(test_more_OBJECTS) $(test_more_LDADD) $(LIBS)

565	638	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_hess.Po@am__quote@
566	639	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_sparse_jac.Po@am__quote@
567	640	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward.Po@am__quote@
568		@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward_mul.Po@am__quote@
	641	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward_dir.Po@am__quote@
	642	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward_order.Po@am__quote@
569	643	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/from_base.Po@am__quote@
570	644	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fun_check.Po@am__quote@
571	645	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipopt_solve.Po@am__quote@

617	691	@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vec_unary.Po@am__quote@
618	692
619	693	.cpp.o:
620		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
621		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	694	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.o$$\|\|'`;\
	695	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
	696	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
622	697	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
623	698	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
624	699	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
625	700
626	701	.cpp.obj:
627		@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
628		@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$.Tpo $(DEPDIR)/$.Po
	702	@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ \| sed 's\|[^/]*$$\|$(DEPDIR)/&\|;s\|\.obj$$\|\|'`;\
	703	@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
	704	@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
629	705	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
630	706	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
631	707	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`

644	720	@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
645	721	@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libeigen_a_CXXFLAGS) $(CXXFLAGS) -c -o libeigen_a-cppad_eigen.obj `if test -f 'cppad_eigen.cpp'; then $(CYGPATH_W) 'cppad_eigen.cpp'; else $(CYGPATH_W) '$(srcdir)/cppad_eigen.cpp'; fi`
646	722
647		ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
648		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
649		unique=`for i in $$list; do \
650		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
651		done \| \
652		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
653		END { if (nonempty) { for (i in files) print i; }; }'`; \
654		mkid -fID $$unique
655		tags: TAGS
656
657		TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
658		$(TAGS_FILES) $(LISP)
	723	ID: $(am__tagged_files)
	724	$(am__define_uniq_tagged_files); mkid -fID $$unique
	725	tags: tags-am
	726	TAGS: tags
	727
	728	tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
659	729	set x; \
660	730	here=`pwd`; \
661		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
662		unique=`for i in $$list; do \
663		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
664		done \| \
665		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
666		END { if (nonempty) { for (i in files) print i; }; }'`; \
	731	$(am__define_uniq_tagged_files); \
667	732	shift; \
668	733	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
669	734	test -n "$$unique" \|\| unique=$$empty_fix; \

675	740	$$unique; \
676	741	fi; \
677	742	fi
678		ctags: CTAGS
679		CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
680		$(TAGS_FILES) $(LISP)
681		list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
682		unique=`for i in $$list; do \
683		if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
684		done \| \
685		$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
686		END { if (nonempty) { for (i in files) print i; }; }'`; \
	743	ctags: ctags-am
	744
	745	CTAGS: ctags
	746	ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	747	$(am__define_uniq_tagged_files); \
687	748	test -z "$(CTAGS_ARGS)$$unique" \
688	749	\|\| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
689	750	$$unique

692	753	here=`$(am__cd) $(top_builddir) && pwd` \
693	754	&& $(am__cd) $(top_srcdir) \
694	755	&& gtags -i $(GTAGS_ARGS) "$$here"
	756	cscopelist: cscopelist-am
	757
	758	cscopelist-am: $(am__tagged_files)
	759	list='$(am__tagged_files)'; \
	760	case "$(srcdir)" in \
	761	[\\/]* \| ?:[\\/]*) sdir="$(srcdir)" ;; \
	762	*) sdir=$(subdir)/$(srcdir) ;; \
	763	esac; \
	764	for i in $$list; do \
	765	if test -f "$$i"; then \
	766	echo "$(subdir)/$$i"; \
	767	else \
	768	echo "$$sdir/$$i"; \
	769	fi; \
	770	done >> $(top_builddir)/cscope.files
695	771
696	772	distclean-tags:
697	773	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

833	909
834	910	.MAKE: check-am install-am install-strip
835	911
836		.PHONY: CTAGS GTAGS all all-am check check-am clean \
837		clean-checkPROGRAMS clean-generic clean-noinstLIBRARIES ctags \
838		distclean distclean-compile distclean-generic distclean-tags \
839		distdir dvi dvi-am html html-am info info-am install \
840		install-am install-data install-data-am install-dvi \
841		install-dvi-am install-exec install-exec-am install-html \
842		install-html-am install-info install-info-am install-man \
843		install-pdf install-pdf-am install-ps install-ps-am \
844		install-strip installcheck installcheck-am installdirs \
845		maintainer-clean maintainer-clean-generic mostlyclean \
846		mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
847		tags uninstall uninstall-am
	912	.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
	913	clean-checkPROGRAMS clean-generic clean-noinstLIBRARIES \
	914	cscopelist-am ctags ctags-am distclean distclean-compile \
	915	distclean-generic distclean-tags distdir dvi dvi-am html \
	916	html-am info info-am install install-am install-data \
	917	install-data-am install-dvi install-dvi-am install-exec \
	918	install-exec-am install-html install-html-am install-info \
	919	install-info-am install-man install-pdf install-pdf-am \
	920	install-ps install-ps-am install-strip installcheck \
	921	installcheck-am installdirs maintainer-clean \
	922	maintainer-clean-generic mostlyclean mostlyclean-compile \
	923	mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \
	924	uninstall-am
848	925
849	926
850	927	ndebug.$(OBJEXT): ndebug.cpp

-1

test_more/mul_level.cpp less more

0		/* $Id: mul_level.cpp 3073 2014-01-01 11:48:13Z bradbell $ */
	0	/* $Id: mul_level.cpp 3071 2014-01-01 04:02:27Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3

+209

-1

test_more/optimize.cpp less more

0		/* $Id: optimize.cpp 3008 2013-11-13 14:59:21Z bradbell $ */
	0	/* $Id: optimize.cpp 3507 2014-12-27 16:30:12Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3

1429	1429
1430	1430	return ok;
1431	1431	}
	1432	// -----------------------------------------------------------------------
	1433	double floor(const double& x)
	1434	{ return std::floor(x); }
	1435	CPPAD_DISCRETE_FUNCTION(double, floor)
	1436	bool discrete_function(void)
	1437	{ bool ok = true;
	1438	using CppAD::vector;
	1439
	1440	vector< CppAD::AD<double> > ax(1), ay(1);
	1441	ax[0] = 0.0;
	1442	CppAD::Independent(ax);
	1443	ay[0] = floor(ax[0]) + floor(ax[0]);
	1444	CppAD::ADFun<double> f(ax, ay);
	1445
	1446	size_t size_before = f.size_var();
	1447	f.optimize();
	1448	size_t size_after = f.size_var();
	1449	ok &= size_after + 1 == size_before;
	1450
	1451	vector<double> x(1), y(1);
	1452	x[0] = -2.2;
	1453	y = f.Forward(0, x);
	1454	ok &= y[0] == -6.0;
	1455
	1456	return ok;
	1457	}
	1458	// ----------------------------------------------------------------
	1459	void i_algo(
	1460	const CppAD::vector< CppAD::AD<double> >& ax ,
	1461	CppAD::vector< CppAD::AD<double> >& ay )
	1462	{ ay[0] = 1.0 / ax[0]; }
	1463	//
	1464	// Test bug where atomic functions were not properly conditionally skipped.
	1465	bool cond_exp_skip_atomic(void)
	1466	{ bool ok = true;
	1467	using CppAD::AD;
	1468	using CppAD::vector;
	1469
	1470	// Create a checkpoint version of the function i_algo
	1471	vector< AD<double> > au(1), av(1), aw(1);
	1472	au[0] = 1.0;
	1473	CppAD::checkpoint<double> i_check("i_check", i_algo, au, av);
	1474
	1475	// independent variable vector
	1476	vector< AD<double> > ax(2), ay(1);
	1477	ax[0] = 1.0;
	1478	ax[1] = 2.0;
	1479	Independent(ax);
	1480
	1481	// call atomic function that does not get used
	1482	au[0] = ax[0];
	1483	i_check(au, av);
	1484	au[0] = ax[1];
	1485	i_check(au, aw);
	1486	AD<double> zero = 0.0;
	1487	ay[0] = CondExpGt(av[0], zero, av[0], aw[0]);
	1488
	1489	// create function object f : ax -> ay
	1490	CppAD::ADFun<double> f(ax, ay);
	1491
	1492	// run case that skips the second call to afun
	1493	// (can use trace in forward0sweep.hpp to see this).
	1494	vector<double> x(2), y_before(1), y_after(1);
	1495	x[0] = 1.0;
	1496	x[1] = 2.0;
	1497	y_before = f.Forward(0, x);
	1498	f.optimize();
	1499	y_after = f.Forward(0, x);
	1500
	1501	ok &= y_before[0] == y_after[0];
	1502
	1503	return ok;
	1504	}
	1505	//
	1506	// Test bug where conditional dependence did not pass through
	1507	// atomic functions
	1508	bool cond_exp_atomic_dependence(void)
	1509	{ bool ok = true;
	1510	using CppAD::AD;
	1511	using CppAD::vector;
	1512
	1513	// Create a checkpoint version of the function i_algo
	1514	vector< AD<double> > au(1), av(1), aw(1);
	1515	au[0] = 1.0;
	1516	CppAD::checkpoint<double> i_check("i_check", i_algo, au, av);
	1517
	1518	vector< AD<double> > ax(2), ay(1);
	1519	AD<double> zero = 0.0;
	1520	ax[0] = 1.0;
	1521	ax[1] = 1.0;
	1522	Independent(ax);
	1523	av[0] = ax[0] + ax[1];
	1524	i_check(av, aw);
	1525	ay[0] = CondExpGt(aw[0], zero, zero, aw[0]);
	1526	CppAD::ADFun<double> f;
	1527	f.Dependent(ax, ay);
	1528
	1529	// run case that skips the second call to afun
	1530	// (but not for order zero)
	1531	vector<double> x(2), y_before(1), y_after(1);
	1532	vector<double> dx(2), dy_before(1), dy_after(1);
	1533	x[0] = 1.0;
	1534	x[1] = 1.0;
	1535	y_before = f.Forward(0, x);
	1536	dx[0] = 2.0;
	1537	dx[1] = 2.0;
	1538	dy_before = f.Forward(1, dx);
	1539	f.optimize();
	1540	y_after = f.Forward(0, x);
	1541	dy_after = f.Forward(1, dx);
	1542
	1543	ok &= y_before[0] == y_after[0];
	1544	ok &= dy_before[0] == dy_after[0];
	1545
	1546	return ok;
	1547	}
	1548	// -----------------------------------------------------------------------
	1549	// Test reverse mode conditionalay skipping commands.
	1550	template <class Type>
	1551	Type my_max(const CppAD::vector<Type>& arg)
	1552	{ Type res = arg[0];
	1553	for(size_t j = 0;j < arg.size(); j++)
	1554	res = CondExpGt(res, arg[j], res, arg[j]);
	1555	return res;
	1556	}
	1557	bool cond_exp_reverse(void)
	1558	{ bool ok = true;
	1559	size_t n = 3;
	1560	using CppAD::vector;
	1561	using CppAD::AD;
	1562
	1563	vector< AD<double> > ax(n), ay(1);
	1564	for(size_t j = 0; j < n; j++)
	1565	ax[j] = 1.0;
	1566	Independent(ax);
	1567	ay[0] = my_max(ax) + my_max(ax);
	1568	CppAD::ADFun<double> f(ax, ay);
	1569
	1570	f.optimize();
	1571
	1572	vector<double> x(n), w(1), dx(n);
	1573	for(size_t j = 0;j < n; j++)
	1574	x[j] = double(j);
	1575	f.Forward(0, x);
	1576	w[0] = 1.0;
	1577	dx = f.Reverse(1, w);
	1578	for(size_t j = 0; j < n; j++)
	1579	{ if( j == n-1 )
	1580	ok &= dx[j] == 2.0;
	1581	else
	1582	ok &= dx[j] == 0.0;
	1583	}
	1584	return ok;
	1585	}
	1586	// Test case where an expression depends on both the true
	1587	// and false cases (bug fixed 2014-12-22)
	1588	bool cond_exp_both_true_and_false(void)
	1589	{ bool ok = true;
	1590	using CppAD::vector;
	1591	using CppAD::AD;
	1592
	1593	// f(x) = x[0] + x[0] if x[0] >= 3
	1594	// = x[0] + x[1] otherwise
	1595	vector< AD<double> > ax(2), ay(3);
	1596	ax[0] = 1.0;
	1597	ax[1] = 2.0;
	1598	Independent(ax);
	1599	AD<double> three(3);
	1600	AD<double> value = ax[0] + ax[1];
	1601	// a simple value
	1602	ay[0] = CppAD::CondExpGe(ax[0], three, value, value);
	1603	// a binary exprpression
	1604	ay[1] = CppAD::CondExpGe(ax[0], three, ax[0]-ax[1], ax[0]-ax[1]);
	1605	// a unary expression
	1606	ay[2] = CppAD::CondExpGe(ax[0], three, exp(ax[0]), exp(ax[0]) );
	1607	CppAD::ADFun<double> f(ax, ay);
	1608	f.optimize();
	1609
	1610	// check case where x[0] >= 3
	1611	vector<double> x(2), y(3);
	1612	x[0] = 4.0;
	1613	x[1] = 2.0;
	1614	y = f.Forward(0, x);
	1615	ok &= y[0] == x[0] + x[1];
	1616	ok &= y[1] == x[0] - x[1];
	1617	ok &= y[2] == exp(x[0]);
	1618
	1619	// check case where x[0] < 3
	1620	x[0] = 1.0;
	1621	x[1] = 2.0;
	1622	y = f.Forward(0, x);
	1623	ok &= y[0] == x[0] + x[1];
	1624	ok &= y[1] == x[0] - x[1];
	1625	ok &= y[2] == exp(x[0]);
	1626
	1627	return ok;
	1628	}
1432	1629	}
1433	1630
1434	1631	bool optimize(void)
1435	1632	{ bool ok = true;
	1633
1436	1634	atomic_sparsity_option = CppAD::atomic_base<double>::bool_sparsity_enum;
1437	1635	for(size_t i = 0; i < 2; i++)
1438	1636	{ // check conditional expression sparsity pattern

1471	1669	ok &= old_atomic_test();
1472	1670	// case where results are not identically equal
1473	1671	ok &= not_identically_equal();
	1672	// case where a discrete function is used
	1673	ok &= discrete_function();
	1674	// check conditional skip of an atomic function
	1675	ok &= cond_exp_skip_atomic();
	1676	// check conditional dependence through atomic function
	1677	ok &= cond_exp_atomic_dependence();
	1678	// check reverse mode conditional skipping
	1679	ok &= cond_exp_reverse();
	1680	// check case where an expresion needed by both true and false case
	1681	ok &= cond_exp_both_true_and_false();
1474	1682	//
1475	1683	CppAD::user_atomic<double>::clear();
1476	1684	return ok;

-1

test_more/romberg_one.cpp less more

0		/* $Id: romberg_one.cpp 3062 2013-12-28 10:40:48Z bradbell $ */
	0	/* $Id: romberg_one.cpp 3060 2013-12-27 20:38:57Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3

-6

test_more/sparse_jacobian.cpp less more

0		/* $Id: sparse_jacobian.cpp 2870 2013-07-28 17:00:59Z bradbell $ */
	0	/* $Id: sparse_jacobian.cpp 3108 2014-02-20 13:51:45Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

317	317	s[i * m + i] = true;
318	318	}
319	319	p = f.RevSparseJac(m, s);
320		jac = f.SparseJacobian(x);
	320	jac = f.SparseJacobian(x, p);
321	321	for(k = 0; k < 12; k++)
322	322	ok &= NearEqual(check[k], jac[k], 1e-10, 1e-10 );
323	323

374	374	for(i = 0; i < m; i++)
375	375	s[i].insert(i);
376	376	p = f.RevSparseJac(m, s);
377		jac = f.SparseJacobian(x);
	377	jac = f.SparseJacobian(x, p);
378	378	for(k = 0; k < 12; k++)
379	379	ok &= NearEqual(check[k], jac[k], 1e-10, 1e-10 );
380	380

438	438	r[j * n + j] = true;
439	439	}
440	440	p = f.ForSparseJac(n, r);
441		jac = f.SparseJacobian(x);
	441	jac = f.SparseJacobian(x, p);
442	442	for(k = 0; k < 12; k++)
443	443	ok &= NearEqual(check[k], jac[k], 1e-10, 1e-10 );
444	444

498	498	for(j = 0; j < n; j++)
499	499	r[j].insert(j);
500	500	p = f.ForSparseJac(n, r);
501		jac = f.SparseJacobian(x);
	501	jac = f.SparseJacobian(x, p);
502	502	for(k = 0; k < 12; k++)
503	503	ok &= NearEqual(check[k], jac[k], 1e-10, 1e-10 );
504	504

-1

test_more/std_math.cpp less more

0		/* $Id: std_math.cpp 3062 2013-12-28 10:40:48Z bradbell $ */
	0	/* $Id: std_math.cpp 3060 2013-12-27 20:38:57Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
3	3

+52

-2

test_more/tan.cpp less more

0		/* $Id: tan.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	/* $Id: tan.cpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

17	17	# include <cppad/cppad.hpp>
18	18
19	19	namespace {
	20	bool tan_two(void)
	21	{ bool ok = true;
	22	using CppAD::AD;
	23	using CppAD::NearEqual;
	24	double eps = 10. * std::numeric_limits<double>::epsilon();
	25
	26	// domain space vector
	27	size_t n = 1;
	28	CPPAD_TESTVECTOR(AD<double>) ax(n);
	29	ax[0] = 0.5;
	30
	31	// declare independent variables and starting recording
	32	CppAD::Independent(ax);
	33
	34	// range space vector
	35	size_t m = 1;
	36	CPPAD_TESTVECTOR(AD<double>) ay(m);
	37	ay[0] = tan( ax[0] );
	38
	39	// create f: x -> y and stop tape recording
	40	CppAD::ADFun<double> f(ax, ay);
	41
	42	// first order Taylor coefficient
	43	CPPAD_TESTVECTOR(double) x1(n), y1;
	44	x1[0] = 2.0;
	45	y1 = f.Forward(1, x1);
	46	ok &= y1.size() == m;
	47
	48	// secondorder Taylor coefficients
	49	CPPAD_TESTVECTOR(double) x2(n), y2;
	50	x2[0] = 0.0;
	51	y2 = f.Forward(2, x2);
	52	ok &= y2.size() == m;
	53	//
	54	// Y (t) = F[X_0(t)]
	55	// = tan(0.5 + 2t )
	56	// Y' (t) = 2 * cos(0.5 + 2t )^(-2)
	57	double sec_sq = 1.0 / ( cos(0.5) * cos(0.5) );
	58	double check = 2.0 * sec_sq;
	59	ok &= NearEqual(y1[0] , check, eps, eps);
	60	//
	61	// Y''(0) = 8cos(0.5)^(-3)sin(0.5)
	62	check = 8.0 * tan(0.5) * sec_sq / 2.0;
	63	ok &= NearEqual(y2[0] , check, eps, eps);
	64	//
	65	return ok;
	66	}
20	67	bool tan_case(bool tan_first)
21	68	{ bool ok = true;
22	69	double eps = 100. * std::numeric_limits<double>::epsilon();

119	166	}
120	167	bool tan(void)
121	168	{ bool ok = true;
	169	//
122	170	ok &= tan_case(true);
123	171	ok &= tan_case(false);
124	172	ok &= tanh_case(true);
125	173	ok &= tanh_case(false);
	174	//
	175	ok &= tan_two();
126	176	return ok;
127	177	}

-6

test_more/test_more.cpp less more

0		/* $Id: test_more.cpp 2859 2013-05-28 06:03:21Z bradbell $ */
	0	/* $Id: test_more.cpp 3301 2014-05-24 05:20:21Z bradbell $ */
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5	5	the terms of the

25	25	extern bool Asin(void);
26	26	extern bool assign(void);
27	27	extern bool Atan(void);
28		extern bool Atan2(void);
	28	extern bool atan2(void);
29	29	extern bool base_adolc(void);
30	30	extern bool base_alloc_test(void);
31	31	extern bool check_simple_vector(void);

47	47	extern bool ForHess(void);
48	48	extern bool for_sparse_jac(void);
49	49	extern bool Forward(void);
50		extern bool forward_mul(void);
	50	extern bool forward_dir(void);
	51	extern bool forward_order(void);
51	52	extern bool FromBase(void);
52	53	extern bool FunCheck(void);
53	54	extern bool ipopt_solve(void);

137	138	ok &= Run( Asin, "Asin" );
138	139	ok &= Run( assign, "assign" );
139	140	ok &= Run( Atan, "Atan" );
140		ok &= Run( Atan2, "Atan2" );
	141	ok &= Run( atan2, "atan2" );
141	142	ok &= Run( check_simple_vector, "check_simple_vector" );
142	143	ok &= Run( checkpoint, "checkpoint" );
143	144	ok &= Run( Compare, "Compare" );

156	157	ok &= Run( ForHess, "ForHess" );
157	158	ok &= Run( for_sparse_jac, "for_sparse_jac" );
158	159	ok &= Run( Forward, "Forward" );
159		ok &= Run( forward_mul, "forward_mul" );
	160	ok &= Run( forward_dir, "forward_dir" );
	161	ok &= Run( forward_order, "forward_order" );
160	162	ok &= Run( FromBase, "FromBase" );
161	163	ok &= Run( FunCheck, "FunCheck" );
162	164	ok &= Run( jacobian, "jacobian" );

+11

-2

test_more/test_one.sh.in less more

0	0	#! /bin/bash -e
1		# $Id: test_one.sh.in 3073 2014-01-01 11:48:13Z bradbell $
	1	# $Id: test_one.sh.in 3116 2014-02-24 21:44:26Z bradbell $
2	2	# -----------------------------------------------------------------------------
3		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
4	4	#
5	5	# CppAD is distributed under multiple licenses. This distribution is under
6	6	# the terms of the

54	54	then
55	55	cmd="$cmd -I@adolc_prefix@/include"
56	56	fi
	57	if [ -e @colpack_prefix@/include ]
	58	then
	59	cmd="$cmd -I@colpack_prefix@/include"
	60	fi
57	61	if [ -e @eigen_prefix@/include ]
58	62	then
59	63	cmd="$cmd -I@eigen_prefix@/include"

64	68	then
65	69	cmd="$cmd -L@adolc_prefix@/$lib -ladolc -lColPack"
66	70	export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:@adolc_prefix@/$lib"
	71	fi
	72	if [ -e @colpack_prefix@/$lib ]
	73	then
	74	cmd="$cmd -L@colpack_prefix@/$lib -lColPack"
	75	export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:@colpack_prefix@/$lib"
67	76	fi
68	77	if [ -e @ipopt_prefix@/$lib/pkgconfig ]
69	78	then