Commit 4e7f9058c709c8990293f829ddc45331de07cf93 - cppad

+8

-4

CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3772 2015-12-31 14:01:01Z bradbell $
	0	# $Id: CMakeLists.txt 3786 2016-02-08 13:14:26Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

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

142	142	# sacado_prefix
143	143	optional_package(sacado_prefix "sacado install prefix")
144	144	# -----------------------------------------------------------------------------
145		# cppad_has_colpack, colpack_libs
	145	# cppad_has_colpack, colpack_libs, cppad_lib
146	146	#
147	147	IF( colpack_prefix )
148	148	SET(cppad_has_colpack 1)
149	149	SET( colpack_libs "ColPack" )
	150	SET( cppad_lib "cppad_lib" )
150	151	ELSE( colpack_prefix )
151	152	SET(cppad_has_colpack 0)
152	153	SET( colpack_libs "" )
	154	SET( cppad_lib "" )
153	155	ENDIF( colpack_prefix )
154	156	# =============================================================================
155	157	# automated system configuration

287	289	#
288	290	ADD_SUBDIRECTORY(cppad)
289	291	ADD_SUBDIRECTORY(pkgconfig)
290		ADD_SUBDIRECTORY(cppad_lib)
	292	IF( colpack_prefix )
	293	ADD_SUBDIRECTORY(cppad_lib)
	294	ENDIF( colpack_prefix)
291	295	#
292	296	ADD_SUBDIRECTORY(compare_c)
293	297	add_to_list(check_depends check_compare_c)

+31

-175

bin/batch_edit.sh less more

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	move_sed='s\|list_files.sh\|ls_files.sh\|'
	13	move_list='
	14	'
	15	cat << EOF > junk.sed
	16	s\|^# cppad_has_colpack, colpack_libs\|&, cppad_lib\|
	17	s\|^\\tSET( colpack_libs "ColPack" )\|&\\
	18	SET( cppad_lib "cppad_lib" )\|
	19	s\|^\\tSET( colpack_libs "" )\|&\\
	20	SET( cppad_lib "" )\|
	21	s\|^\\tcppad_lib\$\|\\t\${cppad_lib}\|
	22	#
	23	s\|^ADD_SUBDIRECTORY(cppad_lib)\|IF( colpack_prefix )\\
	24	&\\
	25	ENDIF( colpack_prefix)\|
	26	EOF
	27	# -----------------------------------------------------------------------------
12	28	if [ $0 != "bin/batch_edit.sh" ]
13	29	then
14	30	echo "bin/batch_edit.sh: must be executed from its parent directory"
15	31	exit 1
16	32	fi
17		# -----------------------------------------------------------------------------
18		# 1. With a few exceptions, move cppad/.hpp to cppad/utility/.hpp
19		# 2. Remove index commands that became redundant when the words in
20		# section, head, and subhead commands were automatically indexed.
21		# 3. Change include gaurd from CPPAD_<NAME>_INCLUDED to CPPAD_<NAME>_HPP
22		# 4. Make the source code control $Id$ commands more uniform.
23		# 5. Remove invisible white space
24		# 6. Create utility.hpp (includes entire utilty directory)
25		# 7. cppad/utility/CMakeLists.txt create deprecated include file links
26	33	# -----------------------------------------------------------------------------
27	34	# bash function that echos and executes a command
28	35	echo_eval() {

30	37	eval $*
31	38	}
32	39	# -----------------------------------------------------------------------------
33		#
	40	cp bin/batch_edit.sh $HOME/trash/batch_edit.sh
34	41	git reset --hard
	42	cp $HOME/trash/batch_edit.sh bin/batch_edit.sh
35	43	# ---------------------------------------------------------------------------
36		# cleanup from a previous run
37		#
38		list='
39		cppad/utility
40		cppad/utility.hpp
41		junk.sed
42		'
43		for name in $list
	44	list_all=`git ls-files`
	45	for file in $list_all
44	46	do
45		if [ -e "$name" ]
	47	if [ "$file" != 'bin/batch_edit.sh' ]
46	48	then
47		echo_eval "rm -r $name"
	49	echo_eval sed -f junk.sed -i $file
48	50	fi
49	51	done
50		echo_eval mkdir cppad/utility
51		# ---------------------------------------------------------------------------
52		# files that are hand edited
53		list='
54		add_copyright.sh
55		reduce_index.py
56		doxyfile.sh
57		batch_edit.sh
58		'
59		for file in $list
	52	# ----------------------------------------------------------------------------
	53	for old in $move_list
60	54	do
61		echo_eval cp bin/new/$file bin/$file
62		done
63		chmod +x bin/batch_edit.sh
64		# ---------------------------------------------------------------------------
65		# cppad/*.hpp files, move to utility drectory
66		# except for cppad.hpp, configure.hpp, configure.hpp.in
67		#
68		list=`ls cppad/*.hpp \| sed \
69		-e 's\|cppad/\|\|' \
70		-e '/cppad\.hpp/d' \
71		-e '/configure\.hpp/d' \
72		-e '/base_require.hpp/d' `
73		for file in $list
74		do
75		echo_eval git mv cppad/$file cppad/utility/$file
76		cat << EOF >> junk.sed
77		s\|^# include <cppad/$file>\|# include <cppad/utility/$file>\|
78		s\|^\\tcppad/$file%\|\\tcppad/utility/$file%\|
79		s\|^\\tcppad/$file \|\\tcppad/utility/$file \|
80		s\|^\\tcppad/$file\$\|\\tcppad/utility/$file\|
81		s\|^\\t%cppad/$file\$\|\\t%cppad/utility/$file\|
82		s\|%cppad/$file%\|%cppad/utility/$file%\|
83		EOF
84		done
85		# ---------------------------------------------------------------------------
86		# junk.sed
87		cat << EOF >> junk.sed
88		# fix double word errors inside of mindex commands
89		# that are created by reduce_index.py below
90		s\|mindex SparseJacobian jacobian\|mindex SparseJacobian\|
91		s\|index OdeErrControl control\|index OdeErrControl\|
92		s\|mindex OdeGearControl control\|mindex OdeGearControl\|
93		s\|mindex bool CppAD::vector vectorBool\|mindex bool vectorBool\|
94		s\|mindex Bender BenderQuad\|mindex BenderQuad\|
95		s\|mindex log log1p\|mindex log1p\|
96		#
97		# change include gaurd to more standard fom
98		# (works better when you have name.h and name.hpp)
99		s\|# ifndef CPPAD_\$[A-Z0-9_]*\$_INCLUDED\|# ifndef CPPAD_\\1_HPP\|
100		s\|# define CPPAD_\$[A-Z0-9_]*\$_INCLUDED\|# define CPPAD_\\1_HPP\|
101		#
102		# change source code control Id commands to be more iniform
103		s\|^# \$Id[^\$]*\$\$\|# \$Id\$\|
104		s\|^// \$Id[^\$]*\$\$\|// \$Id\$\|
105		s\|^/\\* \$Id[^\$]\$ \\/\$\|// \$Id\$\|
106		EOF
107		# ----------------------------------------------------------------------------
108		list=`git ls-files \| sed -n \
109		-e '/\.omh$/p' \
110		-e '/\.hpp$/p' \
111		-e '/\.hpp\.in$/p' \
112		-e '/\.cpp$/p' \
113		-e '/makefile.am$/p' \
114		`
115		for file in $list
116		do
117		# remove redundant index entries
118		bin/reduce_index.py $file
119		# see comments in junk.sed above
120		sed -f junk.sed -i $file
121		# remove invisible white space
122		sed -e 's\|[ \t][ \t]$\|\|' -e 's\| \t\|\t\|g' -i $file
	55	new=`echo $old \| sed -e "$move_sed"`
	56	echo_eval git mv $old $new
123	57	done
124	58	# ----------------------------------------------------------------------------
125		# move changes corresponding to new include gaurd
126		sed -e 's\|_INCLUDED\|_HPP\|' -i bin/check_define.sh
127		sed -e 's\|_INCLUDED\|_HPP\|' -i bin/check_include_def.sh
128		# ----------------------------------------------------------------------------
129		# create utility.hpp and
130		# change examples to use utility.hpp instead if individual include files
131		list=`ls cppad/utility/*.hpp`
132		for file in $list
133		do
134		echo "# include <$file>" >> cppad/utility.hpp
135		root=`echo $file \| sed -e 's\|.*/\|\|'`
136		sed \
137		-e "s\|$codei%# include <cppad/$root>\|%# include <cppad/utility.hpp>\|" \
138		-e "s\|$code # include *<cppad/$root>\|%# include <cppad/utility.hpp>\|" \
139		-i $file
140		done
141		bin/add_copyright.sh cppad/utility.hpp
142		sed \
143		-e '1s/$/\n# ifndef CPPAD_UTILITY_HPP\n# define CPPAD_UTILITY_HPP/' \
144		-e '$s/$/\n# endif/' \
145		-i cppad/utility.hpp
146		git add cppad/utility.hpp
147		#
148		sed -e 's\|\tcppad/base_require.hpp\|\tcppad/utility.hpp\n&\|' -i makefile.am
149		# ----------------------------------------------------------------------------
150		# use utility.hpp in cppad.hpp
151		sed \
152		-e '25,48d' \
153		-e '24s\|$\|\n# include <cppad/utility.hpp>\|' \
154		-i cppad/cppad.hpp
155		# ----------------------------------------------------------------------------
156		# change examples and documentation to use utility.hpp
157		list=`git ls-files \| sed -n \
158		-e '/\.omh$/p' \
159		-e '/^example\//p' \
160		-e '/^cppad_ipopt\/example\//p' \
161		`
162		for file in $list
163		do
164		sed \
165		-e 's\|^# include <cppad/utility/[a-z_]\.hpp>]>\|# include <cppad/utility.hpp>\|' \
166		-i $file
167		done
168		# ----------------------------------------------------------------------------
169		# create cppad/utility/CMakeLists.txt and delete cppad/*.h
170		#
171		cmake_file='cppad/utility/CMakeLists.txt'
172		touch $cmake_file
173		bin/add_copyright.sh $cmake_file
174		echo "FOREACH(old_include_file" >> $cmake_file
175		#
176		list=`git ls-files cppad/utility/*.hpp`
177		for file in $list
178		do
179		name=`echo $file \| sed -e 's\|cppad/utility/\|\|'`
180		echo " $name" >> $cmake_file
181		done
182		#
183		list=`git ls-files cppad/*.h`
184		for file in $list
185		do
186		name=`echo $file \| sed -e 's\|cppad/\|\|'`
187		echo " $name" >> $cmake_file
188		git rm $file
189		done
190		cat << EOF >> $cmake_file
191		)
192		FILE(WRITE
193		\${CMAKE_BINARY_DIR}/cppad/utility/\${old_include_file}
194		"# include <cppad/utility.hpp>\\n"
195		)
196		ENDFOREACH(old_include_file)
197		EOF
198		git add $cmake_file
199		#
200		git checkout CMakeLists.txt
201		sed \
202		-e 's\|ADD_SUBDIRECTORY(cppad_lib)\|&\nADD_SUBDIRECTORY(cppad/utility)\|' \
203		-e '329s\|cppad/\|${CMAKE_BINARY_DIR}/cppad/utility/\|' \
204		-e '331,331d' \
205		-e '334s\|cppad/\|${CMAKE_SOURCE_DIR}/cppad/\|' \
206		-i CMakeLists.txt
207		sed -e '/\tcppad\/.*\.h \\/d' -i makefile.am
	59	# files that were hand edited and cached using 'git_new.sh to'
	60	if [ -e new ]
	61	then
	62	echo_eval git_new.sh from
	63	fi
208	64	# ----------------------------------------------------------------------------
209	65	echo "$0: OK"
210	66	exit 0

+13

-14

bin/check_all.sh less more

0	0	#! /bin/bash -e
1		# $Id: check_all.sh 3770 2015-12-31 12:28:29Z bradbell $
	1	# $Id: check_all.sh 3785 2016-02-08 12:53:06Z bradbell $
2	2	# -----------------------------------------------------------------------------
3	3	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
4	4	#

47	47	fi
48	48	top_srcdir=`pwd`
49	49	echo "top_srcdir = $top_srcdir"
	50	#
	51	if ! random_zero_one=`expr $RANDOM % 2`
	52	then
	53	# expr exit status is 1 when the expression result is zero
	54	# supress shell exit in this case
	55	:
	56	fi
	57	echo "random_zero_one = $random_zero_one"
50	58	# ---------------------------------------------------------------------------
51	59	# circular shift program list and set program to first entry in list
52	60	next_program() {

54	62	program=`echo "$program_list" \| sed -e 's\| $[^ ]$.*\|\1\|'`
55	63	}
56	64	# ---------------------------------------------------------------------------
57		list="
58		$HOME/prefix/cppad
59		build
60		"
61		for name in $list
62		do
63		if [ -e "$name" ]
64		then
65		echo_log_eval rm -r $name
66		fi
67		done
68		random_zero_one=`expr $RANDOM % 2`
69		echo "random_zero_one = $random_zero_one"
	65	if [ -e "$HOME/prefix/cppad" ]
	66	then
	67	echo_log_eval rm -r $HOME/prefix/cppad
	68	fi
70	69	# ---------------------------------------------------------------------------
71	70	# Create package to run test in
72	71	echo "bin/package.sh"

+8

-8

compare_c/makefile.am less more

0		# $Id: makefile.am 2580 2012-11-17 22:01:48Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

10	10	# -----------------------------------------------------------------------------
11	11	# automake input file
12	12	# See ./CMakeLists.txt for specifications.
13		#
	13	#
14	14	BUILT_SOURCES = det_by_minor_c.c det_by_minor_cpp.cpp
15	15	det_by_minor_c.c: det_by_minor.c
16	16	cp $(srcdir)/det_by_minor.c det_by_minor_c.c

23	23	# erase configures choice of flags
24	24	DEFS =
25	25	#
26		# AM_CXXFLAGS = -g
27		# AM_CFLAGS = -g
	26	# AM_CXXFLAGS = -g
	27	# AM_CFLAGS = -g
28	28	#
29		AM_CXXFLAGS = -O2 -DNDEBUG
30		AM_CFLAGS = -O2 -DNDEBUG
	29	AM_CXXFLAGS = -O2 -DNDEBUG
	30	AM_CFLAGS = -O2 -DNDEBUG
31	31	#
32	32	check_PROGRAMS = det_by_minor_c det_by_minor_cpp
33	33	#

+10

-10

configure less more

0	0	#! /bin/sh
1	1	# Guess values for system-dependent variables and create Makefiles.
2		# Generated by GNU Autoconf 2.69 for cppad 20160000.0.
	2	# Generated by GNU Autoconf 2.69 for cppad 20160000.1.
3	3	#
4	4	# Report bugs to <cppad@list.coin-or.org>.
5	5	#

579	579	# Identity of this package.
580	580	PACKAGE_NAME='cppad'
581	581	PACKAGE_TARNAME='cppad'
582		PACKAGE_VERSION='20160000.0'
583		PACKAGE_STRING='cppad 20160000.0'
	582	PACKAGE_VERSION='20160000.1'
	583	PACKAGE_STRING='cppad 20160000.1'
584	584	PACKAGE_BUGREPORT='cppad@list.coin-or.org'
585	585	PACKAGE_URL=''
586	586

1406	1406	# Omit some internal or obsolete options to make the list less imposing.
1407	1407	# This message is too long to be a string in the A/UX 3.1 sh.
1408	1408	cat <<_ACEOF
1409		\`configure' configures cppad 20160000.0 to adapt to many kinds of systems.
	1409	\`configure' configures cppad 20160000.1 to adapt to many kinds of systems.
1410	1410
1411	1411	Usage: $0 [OPTION]... [VAR=VALUE]...
1412	1412

1476	1476
1477	1477	if test -n "$ac_init_help"; then
1478	1478	case $ac_init_help in
1479		short \| recursive ) echo "Configuration of cppad 20160000.0:";;
	1479	short \| recursive ) echo "Configuration of cppad 20160000.1:";;
1480	1480	esac
1481	1481	cat <<\_ACEOF
1482	1482

1610	1610	test -n "$ac_init_help" && exit $ac_status
1611	1611	if $ac_init_version; then
1612	1612	cat <<\_ACEOF
1613		cppad configure 20160000.0
	1613	cppad configure 20160000.1
1614	1614	generated by GNU Autoconf 2.69
1615	1615
1616	1616	Copyright (C) 2012 Free Software Foundation, Inc.

2239	2239	This file contains any messages produced by compilers while
2240	2240	running configure, to aid debugging if configure makes a mistake.
2241	2241
2242		It was created by cppad $as_me 20160000.0, which was
	2242	It was created by cppad $as_me 20160000.1, which was
2243	2243	generated by GNU Autoconf 2.69. Invocation command line was
2244	2244
2245	2245	$ $0 $@

3129	3129
3130	3130	# Define the identity of the package.
3131	3131	PACKAGE='cppad'
3132		VERSION='20160000.0'
	3132	VERSION='20160000.1'
3133	3133
3134	3134
3135	3135	cat >>confdefs.h <<_ACEOF

8581	8581	# report actual input values of CONFIG_FILES etc. instead of their
8582	8582	# values after options handling.
8583	8583	ac_log="
8584		This file was extended by cppad $as_me 20160000.0, which was
	8584	This file was extended by cppad $as_me 20160000.1, which was
8585	8585	generated by GNU Autoconf 2.69. Invocation command line was
8586	8586
8587	8587	CONFIG_FILES = $CONFIG_FILES

8638	8638	cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
8639	8639	ac_cs_config="`$as_echo "$ac_configure_args" \| sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
8640	8640	ac_cs_version="\\
8641		cppad config.status 20160000.0
	8641	cppad config.status 20160000.1
8642	8642	configured by $0, generated by GNU Autoconf 2.69,
8643	8643	with options \\"\$ac_cs_config\\"
8644	8644

+2

-2

configure.ac less more

0		dnl $Id: configure.ac 3772 2015-12-31 14:01:01Z bradbell $
	0	dnl $Id: configure.ac 3786 2016-02-08 13:14:26Z bradbell $
1	1	dnl ---------------------------------------------------------------------------
2	2	dnl CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 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], [20160000.0], [cppad@list.coin-or.org])
	14	AC_INIT([cppad], [20160000.1], [cppad@list.coin-or.org])
15	15	AM_SILENT_RULES([yes])
16	16
17	17	dnl By defalut disable maintainer mode when running configure;

+2

-2

cppad_ipopt/example/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3754 2015-11-26 22:23:05Z bradbell $
	0	# $Id: CMakeLists.txt 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

43	43	# List of libraries to be linked into the specified target
44	44	TARGET_LINK_LIBRARIES(cppad_ipopt_example
45	45	cppad_ipopt
46		cppad_lib
	46	${cppad_lib}
47	47	${ipopt_LIBRARIES}
48	48	${colpack_libs}
49	49	)

+4

-4

cppad_ipopt/example/example.cpp less more

0		/* $Id: example.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: example.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

50	50	ok &= Run( ipopt_get_started, "ipopt_get_started" );
51	51	ok &= Run( ode_simple_check, "ode_simple_check" );
52	52	ok &= Run( ode_fast_check, "ode_fast_check" );
53
	53
54	54	// check for errors
55	55	using std::cout;
56	56	using std::endl;

+5

-5

cppad_ipopt/example/makefile.am less more

0		# $Id: makefile.am 2683 2012-12-30 18:17:03Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

19	19	#
20	20	check_PROGRAMS = example
21	21	#
22		AM_CXXFLAGS = -g $(CXX_FLAGS)
	22	AM_CXXFLAGS = -g $(CXX_FLAGS)
23	23	#
24	24	AM_CPPFLAGS = -I. \
25	25	-I$(top_srcdir) \

34	34	$(FCLIBS) \
35	35	$(PTHREAD_LIB) \
36	36	$(DL_LIB)
37		AM_LDFLAGS = -L../src
	37	AM_LDFLAGS = -L../src
38	38	#
39	39	example_SOURCES = \
40	40	example.cpp \

+4

-4

cppad_ipopt/example/ode1.omh less more

0		$Id: ode1.omh 2683 2012-12-30 18:17:03Z bradbell $
	0	$Id: ode1.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

17	17	cppad_ipopt/example/ode_run.hpp%
18	18	cppad_ipopt/example/ode_check.cpp
19	19	%$$
20
	20
21	21
22	22	$end

+4

-4

cppad_ipopt/example/ode_check.cpp less more

0		/* $Id: ode_check.cpp 3623 2015-01-29 11:42:49Z bradbell $ */
	0	// $Id: ode_check.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

47	47	{ y_0[j] = x[j];
48	48	y_1[j] = x[Ny + j];
49	49	y_2[j] = x[2 * Ny + j];
50		}
	50	}
51	51
52	52	// Check some of the optimal a value
53	53	Number rel_tol = max_step * max_step;

55	55	Number check_a[] = {a0, a1, a2}; // see the y_one function
56	56	for(j = 0; j < Na; j++)
57	57	{
58		ok &= CppAD::NearEqual(
	58	ok &= CppAD::NearEqual(
59	59	check_a[j], a[j], rel_tol, abs_tol
60	60	);
61	61	}

+4

-4

cppad_ipopt/example/ode_fast_check.cpp less more

0		/* $Id: ode_fast_check.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: ode_fast_check.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

31	31	ipopt_ode_case<FG_fast>(retape, N, x);
32	32	ok &= ode_check(N, x);
33	33	}
34
	34
35	35	return ok;
36	36	}

+4

-4

cppad_ipopt/example/ode_simple_check.cpp less more

0		/* $Id: ode_simple_check.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: ode_simple_check.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

31	31	ipopt_ode_case<FG_simple>(retape, N, x);
32	32	ok &= ode_check(N, x);
33	33	}
34
	34
35	35	return ok;
36	36	}

+2

-2

cppad_ipopt/speed/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3754 2015-11-26 22:23:05Z bradbell $
	0	# $Id: CMakeLists.txt 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

44	44	TARGET_LINK_LIBRARIES(
45	45	cppad_ipopt_speed
46	46	cppad_ipopt
47		cppad_lib
	47	${cppad_lib}
48	48	${ipopt_LIBRARIES}
49	49	${colpack_libs}
50	50	)

+7

-7

cppad_ipopt/speed/makefile.am less more

0		# $Id: makefile.am 2506 2012-10-24 19:36:49Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

16	16	EXTRA_DIST = test.sh.in
17	17	#
18	18	check_PROGRAMS = speed
19		#
	19	#
20	20	# BEGIN OPTIMIZE
21	21	AM_CXXFLAGS = -O2 -DNDEBUG $(CXX_FLAGS)
22	22	# END OPTIMIZE

37	37	$(FCLIBS) \
38	38	$(PTHREAD_LIB) \
39	39	$(DL_LIB)
40		AM_LDFLAGS = -L../src
	40	AM_LDFLAGS = -L../src
41	41	#
42	42	# Cannot use ../src/libcppad_ipopt.a becasue it is compiled for debugging
43		# so build an optimized version here to use here.
	43	# so build an optimized version here to use here.
44	44	speed_SOURCES = \
45	45	speed.cpp \
46	46	../src/cppad_ipopt_nlp.cpp \

49	49	../src/jac_g_map.cpp \
50	50	../src/sparse_map2vec.cpp \
51	51	../src/vec_fun_pattern.cpp \
52		ode_speed.cpp
	52	ode_speed.cpp
53	53
54	54	test: check
55	55	./test.sh

+3

-3

cppad_ipopt/speed/ode_speed.cpp less more

0		/* $Id: ode_speed.cpp 2769 2013-03-05 14:28:47Z bradbell $ */
	0	// $Id: ode_speed.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

+5

-5

cppad_ipopt/speed/speed.cpp less more

0		/* $Id: speed.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: speed.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-11 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

24	24
25	25	name = "simple_retape_yes";
26	26	seconds = ode_speed(name, count);
27		printf("ode %20s: seconds = %5.2f: eval_r_count = %d\n",
	27	printf("ode %20s: seconds = %5.2f: eval_r_count = %d\n",
28	28	name, seconds, int(count) );
29	29
30	30	name = "simple_retape_no";

41	41	seconds = ode_speed(name, count);
42	42	printf("ode %20s: seconds = %5.2f: eval_r_count = %d\n",
43	43	name, seconds, int(count) );
44
	44
45	45	return 0;
46	46	}

+20

-20

cppad_ipopt/src/hes_fg_map.cpp less more

0		/* $Id: hes_fg_map.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
	0	// $Id: hes_fg_map.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

17	17	/*!
18	18	\{
19	19	\file hes_fg_map.cpp
20		\brief Creates a mapping between two representations for Hessian of fg.
	20	\brief Creates a mapping between two representations for Hessian of fg.
21	21	*/
22	22
23	23
24	24	/*!
25	25	Create mapping from CppAD to Ipopt sparse representations of Hessian of F(x).
26	26
27		The functions
	27	The functions
28	28	\f$ f : {\bf R}^n \rightarrow {\bf R} \f$ and
29		\f$ g : {\bf R}^n \rightarrow {\bf R}^m \f$ are defined by the
	29	\f$ g : {\bf R}^n \rightarrow {\bf R}^m \f$ are defined by the
30	30	\ref Users_Representation.
31		We define the function
	31	We define the function
32	32	\f$ F : {\bf R}^n \rightarrow {\bf R} \f$ by
33	33	\f[
34	34	F(x) = \sum_{i=0}^m fg(x)_i

37	37	\param fg_info
38	38	For <tt>k = 0 , ... , K-1</tt>,
39	39	for <tt>ell = 0 , ... , L[k]</tt>,
40		the function call
	40	the function call
41	41	\verbatim
42		fg_info->index(k, ell, I, J);
	42	fg_info->index(k, ell, I, J);
43	43	\endverbatim
44		is made by \c hes_fg_map.
	44	is made by \c hes_fg_map.
45	45	The values \c k and \c ell are inputs.
46		The input size of \c I ( \c J )
	46	The input size of \c I ( \c J )
47	47	is greater than or equal <tt>p[k] ( q[k] )</tt>
48	48	and this size is not changed.
49	49	The input values of the elements of \c I and \c J are not specified.

65	65	i.e., \f$ x \in {\bf R}^n \f$.
66	66
67	67	\param K
68		is the number of functions \f$ r_k ( u ) \f$ used for the representation of
	68	is the number of functions \f$ r_k ( u ) \f$ used for the representation of
69	69	\f$ f(x) \f$ and \f$ g(x) \f$.
70	70
71	71	\param L

89	89	\param pattern_hes_r
90	90	is a vector with size \c K.
91	91	For <tt>k = 0 , ... , K-1, pattern_jac_r[k]</tt>
92		is a CppAD sparsity pattern for the Hessian of the function
	92	is a CppAD sparsity pattern for the Hessian of the function
93	93	\f[
94	94	R(u) = \sum_{i=0}^{p[k]-1} r_k (u)_i
95	95	\f]

107	107
108	108	\param index_hes_fg:
109	109	On input, this is empty; i.e., <tt>index_jac_g.size() == 0</tt>.
110		On output, it is the index mapping from \f$ (i, j) \f$ in the Jacobian of
	110	On output, it is the index mapping from \f$ (i, j) \f$ in the Jacobian of
111	111	\f$ g(x) \f$ to the corresponding index value used by Ipopt to represent
112	112	the Jacobian.
113	113	Furthermore, if <tt>index_jac_g[i].find(j) == index_jac_g[i].end()</tt>,
114	114	then the \f$ (i, j)\f$ entry in the Jacobian of \f$ g(x) \f$ is always zero.
115	115	*/
116	116	void hes_fg_map(
117		cppad_ipopt_fg_info* fg_info ,
	117	cppad_ipopt_fg_info* fg_info ,
118	118	size_t m ,
119	119	size_t n ,
120	120	size_t K ,

140	140	CPPAD_ASSERT_UNKNOWN( q[k]*q[k] == pattern_hes_r[k].size() );
141	141	}
142	142	# endif
143
	143
144	144	// Now compute pattern for fg
145	145	// (use standard set representation because can be huge).
146	146	CppAD::vector< std::set<size_t> > pattern_hes_fg(n);
147	147	for(k = 0; k < K; k++) for(ell = 0; ell < L[k]; ell++)
148		{ fg_info->index(k, ell, I, J);
149		for(i = 0; i < q[k]; i++)
	148	{ fg_info->index(k, ell, I, J);
	149	for(i = 0; i < q[k]; i++)
150	150	{ for(j = 0; j < q[k]; j++)
151	151	{ ij = i * q[k] + j;
152	152	if( pattern_hes_r[k][ij] )

155	155	}
156	156	}
157	157
158		// Now compute the mapping from (i, j) in the Hessian of fg to the
	158	// Now compute the mapping from (i, j) in the Hessian of fg to the
159	159	// corresponding index value used by Ipopt to represent the Hessian.
160	160	CPPAD_ASSERT_UNKNOWN( index_hes_fg.size() == 0 );
161	161	index_hes_fg.resize(n);
162	162	std::set<size_t>::const_iterator itr;
163	163	ell = 0;
164	164	for(i = 0; i < n; i++)
165		{ for( itr = pattern_hes_fg[i].begin();
	165	{ for( itr = pattern_hes_fg[i].begin();
166	166	itr != pattern_hes_fg[i].end(); itr++)
167	167	{
168	168	index_hes_fg[i][*itr] = ell++;

+16

-16

cppad_ipopt/src/jac_g_map.cpp less more

0		/* $Id: jac_g_map.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
	0	// $Id: jac_g_map.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

16	16	/*!
17	17	\{
18	18	\file jac_g_map.cpp
19		\brief Creates a mapping between two representations for Jacobian of g.
	19	\brief Creates a mapping between two representations for Jacobian of g.
20	20	*/
21	21
22	22
23	23	/*!
24	24	Create mapping from CppAD to Ipopt sparse representations of Jacobian of g.
25	25
26		The functions
	26	The functions
27	27	\f$ f : {\bf R}^n \rightarrow {\bf R} \f$ and
28	28	\f$ g : {\bf R}^n \rightarrow {\bf R}^m \f$ are defined by
29	29	the \ref Users_Representation.

31	31	\param fg_info
32	32	For <tt>k = 0 , ... , K-1</tt>,
33	33	for <tt>ell = 0 , ... , L[k]</tt>,
34		the function call
	34	the function call
35	35	\verbatim
36		fg_info->index(k, ell, I, J);
	36	fg_info->index(k, ell, I, J);
37	37	\endverbatim
38		is made by \c jac_g_map.
	38	is made by \c jac_g_map.
39	39	The values \c k and \c ell are inputs.
40		The input size of \c I ( \c J )
	40	The input size of \c I ( \c J )
41	41	is greater than or equal <tt>p[k] ( q[k] )</tt>
42	42	and this size is not changed.
43	43	The input values of the elements of \c I and \c J are not specified.

59	59	i.e., \f$ x \in {\bf R}^n \f$.
60	60
61	61	\param K
62		is the number of functions \f$ r_k ( u ) \f$ used for the representation of
	62	is the number of functions \f$ r_k ( u ) \f$ used for the representation of
63	63	\f$ f(x) \f$ and \f$ g(x) \f$.
64	64
65	65	\param L

83	83	\param pattern_jac_r
84	84	is a vector with size \c K.
85	85	For <tt>k = 0 , ... , K-1, pattern_jac_r[k]</tt>
86		is a CppAD sparsity pattern for the Jacobian of the function
	86	is a CppAD sparsity pattern for the Jacobian of the function
87	87	\f$ r_k : {\bf R}^{q(k)} \rightarrow {\bf R}^{p(k)} \f$.
88	88	As such, <tt>pattern_jac_r[k].size() == p[k] * q[k]</tt>.
89	89

99	99
100	100	\param index_jac_g:
101	101	On input, this is empty; i.e., <tt>index_jac_g.size() == 0</tt>.
102		On output, it is the index mapping from \f$ (i, j) \f$ in the Jacobian of
	102	On output, it is the index mapping from \f$ (i, j) \f$ in the Jacobian of
103	103	\f$ g(x) \f$ to the corresponding index value used by Ipopt to represent
104	104	the Jacobian.
105	105	Furthermore, if <tt>index_jac_g[i].find(j) == index_jac_g[i].end()</tt>,
106	106	then the \f$ (i, j)\f$ entry in the Jacobian of \f$ g(x) \f$ is always zero.
107	107	*/
108	108	void jac_g_map(
109		cppad_ipopt_fg_info* fg_info ,
	109	cppad_ipopt_fg_info* fg_info ,
110	110	size_t m ,
111	111	size_t n ,
112	112	size_t K ,

136	136	// (use standard set representation because can be huge).
137	137	CppAD::vector< std::set<size_t> > pattern_jac_g(m);
138	138	for(k = 0; k < K; k++) for(ell = 0; ell < L[k]; ell++)
139		{ fg_info->index(k, ell, I, J);
	139	{ fg_info->index(k, ell, I, J);
140	140	for(i = 0; i < p[k]; i++) if( I[i] != 0 )
141	141	{ for(j = 0; j < q[k]; j++)
142	142	{ ij = i * q[k] + j;

146	146	}
147	147	}
148	148
149		// Now compute the mapping from (i, j) in the Jacobian of g to the
	149	// Now compute the mapping from (i, j) in the Jacobian of g to the
150	150	// corresponding index value used by Ipopt to represent the Jacobian.
151	151	CPPAD_ASSERT_UNKNOWN( index_jac_g.size() == 0 );
152	152	index_jac_g.resize(m);
153	153	std::set<size_t>::const_iterator itr;
154	154	ell = 0;
155	155	for(i = 0; i < m; i++)
156		{ for( itr = pattern_jac_g[i].begin();
	156	{ for( itr = pattern_jac_g[i].begin();
157	157	itr != pattern_jac_g[i].end(); itr++)
158	158	{
159	159	index_jac_g[i][*itr] = ell++;

+5

-5

cppad_ipopt/src/makefile.am less more

0		# $Id: makefile.am 2683 2012-12-30 18:17:03Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

14	14	DEFS =
15	15	#
16	16	#
17		AM_CXXFLAGS = -g $(CXX_FLAGS)
	17	AM_CXXFLAGS = -g $(CXX_FLAGS)
18	18	#
19	19	AM_CPPFLAGS = \
20	20	-I. \

37	37	sparse_map2vec.cpp \
38	38	sparse_map2vec.hpp \
39	39	vec_fun_pattern.cpp \
40		vec_fun_pattern.hpp
	40	vec_fun_pattern.hpp
41	41	endif

+3

-3

cppad_ipopt/src/sparse_map2vec.cpp less more

0		/* $Id: sparse_map2vec.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
	0	// $Id: sparse_map2vec.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

+10

-10

cppad_ipopt/src/vec_fun_pattern.cpp less more

0		/* $Id: vec_fun_pattern.cpp 3223 2014-03-19 15:13:26Z bradbell $ */
	0	// $Id: vec_fun_pattern.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

66	66	On input, For <tt>k = 0 , ... , K-1, pattern_jac_r[k]</tt>
67	67	is a vector of length p[k] * q[k]
68	68	and the value of its elements does not matter.
69		On output it is a CppAD sparsity pattern for the Jacobian of
	69	On output it is a CppAD sparsity pattern for the Jacobian of
70	70	\f$ r_k (u) \f$.
71	71
72	72	\param pattern_hes_r

74	74	On input, For <tt>k = 0 , ... , K-1, pattern_hes_r[k]</tt>
75	75	is a vector of length q[k] * q[k]
76	76	and the value of its elements does not matter.
77		On output it is a CppAD sparsity pattern for the Hessian of
	77	On output it is a CppAD sparsity pattern for the Hessian of
78	78	\f$ R : {\bf R}^{q[k]} \rightarrow {\bf R} \f$ which is defined by
79	79	\f[
80	80	R(u) = \sum_{i=0}^{p[k]-1} r_k (u)_i

107	107	if( retape[k] )
108	108	{ for(i = 0; i < p[k]; i++)
109	109	{ for(j = 0; j < q[k]; j++)
110		pattern_jac_r[k][i*q[k] + j] = true;
	110	pattern_jac_r[k][i*q[k] + j] = true;
111	111	}
112	112	for(i = 0; i < q[k]; i++)
113	113	{ for(j = 0; j < q[k]; j++)
114		pattern_hes_r[k][i*q[k] + j] = true;
	114	pattern_hes_r[k][i*q[k] + j] = true;
115	115	}
116	116	}
117		else
	117	else
118	118	{ // check assumptions about r_k
119	119	CPPAD_ASSERT_UNKNOWN( r_fun[k].Range() == p[k] );
120	120	CPPAD_ASSERT_UNKNOWN( r_fun[k].Domain() == q[k] );

122	122	// pattern for the identity matrix
123	123	CppAD::vectorBool pattern_domain(q[k] * q[k]);
124	124	for(i = 0; i < q[k]; i++)
125		{ for(j = 0; j < q[k]; j++)
	125	{ for(j = 0; j < q[k]; j++)
126	126	pattern_domain[i*q[k] + j] = (i == j);
127	127	}
128	128	// use forward mode to compute Jacobian sparsity
129		pattern_jac_r[k] =
	129	pattern_jac_r[k] =
130	130	r_fun[k].ForSparseJac(q[k], pattern_domain);
131	131	// user reverse mode to compute Hessian sparsity
132	132	CppAD::vectorBool pattern_ones(p[k]);

+2

-2

cppad_ipopt/test/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3754 2015-11-26 22:23:05Z bradbell $
	0	# $Id: CMakeLists.txt 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

35	35	# List of libraries to be linked into the specified target
36	36	TARGET_LINK_LIBRARIES(cppad_ipopt_test
37	37	cppad_ipopt
38		cppad_lib
	38	${cppad_lib}
39	39	${ipopt_LIBRARIES}
40	40	${colpack_libs}
41	41	)

+5

-5

cppad_ipopt/test/makefile.am less more

0		# $Id: makefile.am 2506 2012-10-24 19:36:49Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

17	17	#
18	18	check_PROGRAMS = test_more
19	19	#
20		AM_CXXFLAGS = -g $(CXX_FLAGS)
	20	AM_CXXFLAGS = -g $(CXX_FLAGS)
21	21	#
22	22	AM_CPPFLAGS = -I. \
23	23	-I$(top_srcdir) \

32	32	$(FCLIBS) \
33	33	$(PTHREAD_LIB) \
34	34	$(DL_LIB)
35		AM_LDFLAGS = -L../src
	35	AM_LDFLAGS = -L../src
36	36	#
37	37	test_more_SOURCES = \
38	38	test_more.cpp \

+6

-6

cppad_ipopt/test/multiple_solution.cpp less more

0		/* $Id: multiple_solution.cpp 2896 2013-09-17 21:23:55Z bradbell $ */
	0	// $Id: multiple_solution.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

41	41	size_t domain_size(size_t k)
42	42	{ size_t q;
43	43	switch(k)
44		{ case 0: q = 1; break;
	44	{ case 0: q = 1; break;
45	45	default: assert(0);
46	46	}
47	47	return q;

80	80	{
81	81	assert( u.size() == 1 );
82	82	ADVector r(1);
83		r[0] = u[0] ;
	83	r[0] = u[0] ;
84	84	return r;
85	85	}
86	86	};

92	92	// number of independent variables (domain dimension for f and g)
93	93	size_t n = 2;
94	94	// number of constraints (range dimension for g)
95		size_t m = 2;
	95	size_t m = 2;
96	96	// initial value of the independent variables
97	97	NumberVector x_i(n);
98	98	NumberVector x_l(n);

+4

-4

cppad_ipopt/test/test_more.cpp less more

0		/* $Id: test_more.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: test_more.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

52	52	ok &= Run( multiple_solution, "multiple_solution" );
53	53	ok &= Run( retape_k1_l1, "retape_k1_l1" );
54	54	ok &= Run( retape_k1_l2, "retape_k1_l2" );
55
	55
56	56	// check for errors
57	57	using std::cout;
58	58	using std::endl;

+28

-5

cppad_lib/CMakeLists.txt less more

9	9	# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
10	10	# -----------------------------------------------------------------------------
11	11	# Build and install the cppad_lib shared library
12
	12	#
	13	# string(REGEX REPLACE <regular_expression>
	14	# <replace_expression> <output variable>
	15	# <input> [<input>...])
	16	#
	17	# (year - 2000) dot (remove leading 0 from mmdd) dot (release)
	18	# Note that the dot (release) is optional
	19	# Also name that when mmdd is 0000 get (year - 2000) dot dot (release)
	20	STRING(REGEX REPLACE
	21	"20([0-9][0-9])0([0-9])([.]?[0-9]*)"
	22	"\\1.\\2\\3"
	23	soversion
	24	${cppad_version}
	25	)
	26	# In case where mmdd is 0000, dot (release) is present. Convert to
	27	# (year - 2000) dot 0 dot (release)
	28	STRING(REGEX REPLACE
	29	"([.][.])"
	30	".0."
	31	soversion
	32	${soversion}
	33	)
	34	MESSAGE(STATUS "soversion=${soversion}")
	35	#
13	36	# add_library(<name> [STATIC \| SHARED \| MODULE] [EXCLUDE_FROM_ALL]
14	37	# source1 source2 ... sourceN)
15	38	# )
16	39	ADD_LIBRARY( cppad_lib SHARED
17	40	cppad_colpack.cpp
18	41	)
19
20		# Add extra compiler flags
21		add_cppad_cxx_flags( cppad_lib )
22
	42	# set_target_properties(target1 target2 ...
	43	# PROPERTIES prop1 value1 prop2 value2 ...)
	44	SET_TARGET_PROPERTIES( cppad_lib PROPERTIES SOVERSION ${soversion} )
	45	#
23	46	# install(TARGETS myExe mySharedLib myStaticLib
24	47	# RUNTIME DESTINATION bin
25	48	# LIBRARY DESTINATION lib

+2

-2

doc/_contents_xml.htm less more

63	63	onmouseover='MouseOver(1)'
64	64	onmouseout='MouseOut(1)'
65	65	><img src='_close.gif' name='folder1' align='middle' />
66		<u>cppad-20160000.0: A Package for Differentiation of C++ Algorithms</u></a>
	66	<u>cppad-20160000.1: A Package for Differentiation of C++ Algorithms</u></a>
67	67
68	68	<span id='children1'>
69		<br/><a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a>
	69	<br/><a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a>
70	70
71	71	<br/>    <a href="_contents_xml.htm" target="_top">Table of Contents</a>
72	72

+3

-3

doc/_external.xml less more

173	173
174	174	<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>
175	175
176		<tr valign="top"><td><a href="http://www.coin-or.org/download/source/CppAD/cppad-20160000.0.epl.tgz" target="_top">http://www.coin-or.org/download/source/CppAD/cppad-20160000.0.epl.tgz</a></td><td><a href="download.xml#Compressed Archives" target="_top">download#Compressed Archives</a></td></tr>
177
178		<tr valign="top"><td><a href="http://www.coin-or.org/download/source/CppAD/cppad-20160000.0.gpl.tgz" target="_top">http://www.coin-or.org/download/source/CppAD/cppad-20160000.0.gpl.tgz</a></td><td><a href="download.xml#Compressed Archives" target="_top">download#Compressed Archives</a></td></tr>
	176	<tr valign="top"><td><a href="http://www.coin-or.org/download/source/CppAD/cppad-20160000.1.epl.tgz" target="_top">http://www.coin-or.org/download/source/CppAD/cppad-20160000.1.epl.tgz</a></td><td><a href="download.xml#Compressed Archives" target="_top">download#Compressed Archives</a></td></tr>
	177
	178	<tr valign="top"><td><a href="http://www.coin-or.org/download/source/CppAD/cppad-20160000.1.gpl.tgz" target="_top">http://www.coin-or.org/download/source/CppAD/cppad-20160000.1.gpl.tgz</a></td><td><a href="download.xml#Compressed Archives" target="_top">download#Compressed Archives</a></td></tr>
179	179
180	180	<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>
181	181

+24

-835

doc/_index.xml less more

1121	1121	<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
1122	1122	<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
1123	1123	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
1124		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1124	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
1125	1125	ADFun <a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
1126	1126	<a href="compare_change.xml" target="_top">Comparison Changes Between Taping and Zero Order Forward</a><br/>
1127	1127	<a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
1128	1128	Adolc <a href="auto_tools.xml" target="_top">Auto Tools Unix Test and Installation</a><br/>
1129	1129	Automatic <a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
1130		a <a href="luratio.xml#LU.A" target="_top">LU Factorization of A Square Matrix and Stability Calculation: LU.A</a><br/>
1131		<a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
1132		<a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
1133		<a href="uniform_01_c.xml#a" target="_top">Simulate a [0,1] Uniform Random Variate: a</a><br/>
1134		<a href="uniform_01_c.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
1135		<a href="det_by_minor_c.xml#a" target="_top">Compute Determinant using Expansion by Minors: a</a><br/>
1136		<a href="det_of_minor_c.xml#a" target="_top">Determinant of a Minor: a</a><br/>
1137		<a href="det_of_minor_c.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
1138		<a href="det_of_minor_c.xml" target="_top">Determinant of a Minor</a><br/>
1139		<a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
1140		<a href="old_mat_mul.cpp.xml" target="_top">Old Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
1141		<a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
1142		<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
1143		<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
1144		<a href="omp_create_array.xml" target="_top">Allocate Memory and Create A Raw Array</a><br/>
1145		<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
1146		<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
1147		<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
1148		<a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
1149		<a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
1150		<a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
1151		<a href="fadbad_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
1152		<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
1153		<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
1154		<a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>
1155		<a href="double_poly.cpp.xml" target="_top">Double Speed: Evaluate a Polynomial</a><br/>
1156		<a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
1157		<a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
1158		<a href="sparse_hes_fun.xml" target="_top">Evaluate a Function That Has a Sparse Hessian</a><br/>
1159		<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
1160		<a href="sparse_jac_fun.xml" target="_top">Evaluate a Function That Has a Sparse Jacobian</a><br/>
1161		<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
1162		<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
1163		<a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
1164		<a href="det_by_minor.xml#det.a" target="_top">Determinant Using Expansion by Minors: det.a</a><br/>
1165		<a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
1166		<a href="det_of_minor.xml#a" target="_top">Determinant of a Minor: a</a><br/>
1167		<a href="det_of_minor.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
1168		<a href="det_of_minor.xml" target="_top">Determinant of a Minor</a><br/>
1169		<a href="det_by_lu.xml#det.a" target="_top">Determinant Using Expansion by Lu Factorization: det.a</a><br/>
1170		<a href="link_poly.xml#a" target="_top">Speed Testing Second Derivative of a Polynomial: a</a><br/>
1171		<a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
1172		<a href="stack_machine.cpp.xml" target="_top">Example Differentiating a Stack Machine Interpreter</a><br/>
1173		<a href="mul_level_adolc_ode.cpp.xml" target="_top">Taylor's Ode Solver: A Multi-Level Adolc Example and Test</a><br/>
1174		<a href="mul_level_ode.cpp.xml" target="_top">Taylor's Ode Solver: A Multi-Level AD Example and Test</a><br/>
1175		<a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
1176		<a href="change_param.cpp.xml" target="_top">Computing a Jacobian With Constants that Change</a><br/>
1177		<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
1178		<a href="to_string.xml" target="_top">Convert Certain Types to a String</a><br/>
1179		<a href="index_sort.xml" target="_top">Returns Indices that Sort a Vector</a><br/>
1180		<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
1181		<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
1182		<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
1183		<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
1184		<a href="thread_alloc.xml" target="_top">A Fast Multi-Threading Memory Allocator</a><br/>
1185		<a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
1186		<a href="rombergmul.xml#a" target="_top">Multi-dimensional Romberg Integration: a</a><br/>
1187		<a href="rombergone.xml#a" target="_top">One DimensionalRomberg Integration: a</a><br/>
1188		<a href="luinvert.xml#LU.A" target="_top">Invert an LU Factored Equation: LU.A</a><br/>
1189		<a href="lufactor.xml#LU.A" target="_top">LU Factorization of A Square Matrix: LU.A</a><br/>
1190		<a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
1191		<a href="lusolve.xml#A" target="_top">Compute Determinant and Solve Linear Equations: A</a><br/>
1192		<a href="poly.xml#a" target="_top">Evaluate a Polynomial or its Derivative: a</a><br/>
1193		<a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
1194		<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
1195		<a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
1196		<a href="numerictype.xml" target="_top">Definition of a Numeric Type</a><br/>
1197		<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
1198		<a href="nearequal.xml#a" target="_top">Determine if Two Values Are Nearly Equal: a</a><br/>
1199		<a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
1200		<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
1201		<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
1202		<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
1203		<a href="multi_newton.cpp.xml" target="_top">A Multi-Threaded Newton's Method</a><br/>
1204		<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
1205		<a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
1206		<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
1207		<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
1208		<a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
1209		<a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
1210		<a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
1211		<a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
1212		<a href="funcheck.xml#a" target="_top">Check an ADFun Sequence of Operations: a</a><br/>
1213		<a href="sub_sparse_hes.cpp.xml" target="_top">Computing Sparse Hessian for a Subset of Variables</a><br/>
1214		<a href="sparsity_sub.cpp.xml" target="_top">Sparsity Patterns For a Subset of Variables: Example and Test</a><br/>
1215		<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
1216		<a href="base_require.xml" target="_top">AD<Base> Requirements for a CppAD Base Type</a><br/>
1217		<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
1218		<a href="nearequalext.xml#a" target="_top">Compare AD and Base Objects for Nearly Equal: a</a><br/>
1219		<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/>
1220		<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/>
1221		<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
1222		<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
1223		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
1224	1130	a11c <a href="thread_test.cpp.xml#a11c" target="_top">Run Multi-Threading Examples and Speed Tests: a11c</a><br/>
1225	1131	abort <a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
1226	1132	<a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>

1463	1369	algorithm <a href="conj_grad.cpp.xml#Algorithm" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test: Algorithm</a><br/>
1464	1370	<a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
1465	1371	<a href="exp_2.xml" target="_top">Second Order Exponential Approximation</a><br/>
1466		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1372	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
1467	1373	algorithm<b>:</b> <a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
1468	1374	algorithmic <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
1469	1375	<a href="introduction.xml#Preface.Algorithmic Differentiation" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Algorithmic Differentiation</a><br/>
1470	1376	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
1471		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
1472		algorithms <a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1377	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
	1378	algorithms <a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
1473	1379	alignment <a href="ta_create_array.xml#Alignment" target="_top">Allocate An Array and Call Default Constructor for its Elements: Alignment</a><br/>
1474	1380	<a href="ta_get_memory.xml#Alignment" target="_top">Get At Least A Specified Amount of Memory: Alignment</a><br/>
1475	1381	all <a href="listallexamples.xml" target="_top">List of All the CppAD Examples</a><br/>

1527	1433	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
1528	1434	<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
1529	1435	<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
1530		an <a href="zdouble.xml" target="_top">zdouble: An AD Base Type With Absolute Zero</a><br/>
1531		<a href="ipopt_nlp_ode_problem.xml" target="_top">An ODE Inverse Problem Example</a><br/>
1532		<a href="reverse_identity.xml" target="_top">An Important Reverse Mode Identity</a><br/>
1533		<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
1534		<a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
1535		<a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
1536		<a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
1537		<a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
1538		<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
1539		<a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
1540		<a href="odegear.xml" target="_top">An Arbitrary Order Gear Method</a><br/>
1541		<a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
1542		<a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
1543		<a href="luinvert.xml" target="_top">Invert an LU Factored Equation</a><br/>
1544		<a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan Results</a><br/>
1545		<a href="optimize.xml" target="_top">Optimize an ADFun Object Tape</a><br/>
1546		<a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
1547		<a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
1548		<a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
1549		<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
1550		<a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a><br/>
1551		<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
1552		<a href="numeric_limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
1553		<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
1554		<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
1555		<a href="ad_to_string.xml" target="_top">Convert An AD or Base Type to String</a><br/>
1556		<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
1557		<a href="exp_eps.xml" target="_top">An Epsilon Accurate Exponential Approximation</a><br/>
1558		<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
1559	1436	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/>
1560	1437	<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/>
1561		and <a href="lu_ratio.cpp.xml" target="_top">LuRatio: Example and Test</a><br/>
1562		<a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
1563		<a href="opt_val_hes.cpp.xml" target="_top">opt_val_hes: Example and Test</a><br/>
1564		<a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
1565		<a href="bender_quad.cpp.xml" target="_top">BenderQuad: Example and Test</a><br/>
1566		<a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
1567		<a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
1568		<a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
1569		<a href="zdouble.cpp.xml" target="_top">zdouble: Example and Test</a><br/>
1570		<a href="zdouble.xml#Syntax.Constructor and Assignment" target="_top">zdouble: An AD Base Type With Absolute Zero: Syntax.Constructor and Assignment</a><br/>
1571		<a href="old_mat_mul.cpp.xml" target="_top">Old Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
1572		<a href="old_tan.cpp.xml" target="_top">Old Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
1573		<a href="old_tan.cpp.xml" target="_top">Old Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
1574		<a href="old_reciprocal.cpp.xml" target="_top">Old Atomic Operation Reciprocal: Example and Test</a><br/>
1575		<a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
1576		<a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
1577		<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
1578		<a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
1579		<a href="ipopt_nlp_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
1580		<a href="omp_alloc.cpp.xml" target="_top">OpenMP Memory Allocator: Example and Test</a><br/>
1581		<a href="omp_create_array.xml" target="_top">Allocate Memory and Create A Raw Array</a><br/>
1582		<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
1583		<a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
1584		<a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
1585		<a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
1586		<a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a><br/>
1587		<a href="whats_new_04.xml" target="_top">Changes and Additions to CppAD During 2004</a><br/>
1588		<a href="whats_new_05.xml" target="_top">Changes and Additions to CppAD During 2005</a><br/>
1589		<a href="whats_new_06.xml" target="_top">Changes and Additions to CppAD During 2006</a><br/>
1590		<a href="whats_new_07.xml" target="_top">Changes and Additions to CppAD During 2007</a><br/>
1591		<a href="whats_new_08.xml" target="_top">Changes and Additions to CppAD During 2008</a><br/>
1592		<a href="whats_new_09.xml" target="_top">Changes and Additions to CppAD During 2009</a><br/>
1593		<a href="whats_new_10.xml" target="_top">Changes and Additions to CppAD During 2010</a><br/>
1594		<a href="whats_new_11.xml" target="_top">Changes and Additions to CppAD During 2011</a><br/>
1595		<a href="whats_new_12.xml" target="_top">CppAD Changes and Additions During 2012</a><br/>
1596		<a href="whats_new_13.xml" target="_top">CppAD Changes and Additions During 2013</a><br/>
1597		<a href="whats_new_14.xml" target="_top">CppAD Changes and Additions During 2014</a><br/>
1598		<a href="whats_new_15.xml" target="_top">CppAD Changes and Additions During 2015</a><br/>
1599		<a href="whats_new.xml" target="_top">Changes and Additions to CppAD</a><br/>
1600		<a href="wish_list.xml#Comparison Changes and Optimization" target="_top">The CppAD Wish List: Comparison Changes and Optimization</a><br/>
1601		<a href="bib.xml#Abramowitz and Stegun" target="_top">Bibliography: Abramowitz and Stegun</a><br/>
1602		<a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
1603		<a href="acos_reverse.xml" target="_top">Inverse Cosine and Hyperbolic Cosine Reverse Mode Theory</a><br/>
1604		<a href="asin_reverse.xml" target="_top">Inverse Sine and Hyperbolic Sine Reverse Mode Theory</a><br/>
1605		<a href="atan_reverse.xml" target="_top">Inverse Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
1606		<a href="sin_cos_reverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
1607		<a href="sin_cos_reverse.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</a><br/>
1608		<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>
1609		<a href="acos_forward.xml" target="_top">Inverse Cosine and Hyperbolic Cosine Forward Mode Theory</a><br/>
1610		<a href="asin_forward.xml" target="_top">Inverse Sine and Hyperbolic Sine Forward Mode Theory</a><br/>
1611		<a href="atan_forward.xml" target="_top">Inverse Tangent and Hyperbolic Tangent Forward Mode Theory</a><br/>
1612		<a href="sin_cos_forward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
1613		<a href="sin_cos_forward.xml" target="_top">Trigonometric and Hyperbolic Sine and Cosine Forward Theory</a><br/>
1614		<a href="faq.xml#Assignment and Independent" target="_top">Frequently Asked Questions and Answers: Assignment and Independent</a><br/>
1615		<a href="faq.xml" target="_top">Frequently Asked Questions and Answers</a><br/>
1616		<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
1617		<a href="sparse_hes_fun.cpp.xml" target="_top">sparse_hes_fun: Example and test</a><br/>
1618		<a href="sparse_jac_fun.cpp.xml" target="_top">sparse_jac_fun: Example and test</a><br/>
1619		<a href="ode_evaluate.cpp.xml" target="_top">ode_evaluate: Example and test</a><br/>
1620		<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
1621		<a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
1622		<a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
1623		<a href="det_by_lu.cpp.xml" target="_top">Determinant Using Lu Factorization: Example and Test</a><br/>
1624		<a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
1625		<a href="lu_vec_ad_ok.cpp.xml" target="_top">Lu Factor and Solve With Recorded Pivoting: Example and Test</a><br/>
1626		<a href="lu_vec_ad.cpp.xml" target="_top">Lu Factor and Solve with Recorded Pivoting</a><br/>
1627		<a href="example.cpp.xml" target="_top">CppAD Examples and Tests</a><br/>
1628		<a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
1629		<a href="mul_level_adolc_ode.cpp.xml" target="_top">Taylor's Ode Solver: A Multi-Level Adolc Example and Test</a><br/>
1630		<a href="mul_level_ode.cpp.xml" target="_top">Taylor's Ode Solver: A Multi-Level AD Example and Test</a><br/>
1631		<a href="ode_stiff.cpp.xml" target="_top">A Stiff Ode: Example and Test</a><br/>
1632		<a href="mul_level.cpp.xml" target="_top">Multiple Level of AD: Example and Test</a><br/>
1633		<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
1634		<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
1635		<a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
1636		<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
1637		<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
1638		<a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
1639		<a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
1640		<a href="conj_grad.cpp.xml" target="_top">Differentiate Conjugate Gradient Algorithm: Example and Test</a><br/>
1641		<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
1642		<a href="ipopt_solve_retape.cpp.xml" target="_top">Nonlinear Programming Retaping: Example and Test</a><br/>
1643		<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
1644		<a href="ipopt_solve_get_started.cpp.xml" target="_top">Nonlinear Programming Using CppAD and Ipopt: Example and Test</a><br/>
1645		<a href="to_string.cpp.xml" target="_top">to_string: Example and Test</a><br/>
1646		<a href="index_sort.cpp.xml" target="_top">Index Sort: Example and Test</a><br/>
1647		<a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
1648		<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
1649		<a href="thread_alloc.cpp.xml" target="_top">Fast Multi-Threading Memory Allocator: Example and Test</a><br/>
1650		<a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
1651		<a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
1652		<a href="cppad_vector.xml#Memory and Parallel Mode" target="_top">The CppAD::vector Template Class: Memory and Parallel Mode</a><br/>
1653		<a href="ode_gear_control.cpp.xml" target="_top">OdeGearControl: Example and Test</a><br/>
1654		<a href="ode_gear.cpp.xml" target="_top">OdeGear: Example and Test</a><br/>
1655		<a href="ode_err_maxabs.cpp.xml" target="_top">OdeErrControl: Example and Test Using Maxabs Argument</a><br/>
1656		<a href="ode_err_control.cpp.xml" target="_top">OdeErrControl: Example and Test</a><br/>
1657		<a href="rosen_34.cpp.xml" target="_top">Rosen34: Example and Test</a><br/>
1658		<a href="rosen34.xml" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver</a><br/>
1659		<a href="runge45_2.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
1660		<a href="runge45_1.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
1661		<a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
1662		<a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
1663		<a href="romberg_one.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
1664		<a href="lu_invert.cpp.xml" target="_top">LuInvert: Example and Test</a><br/>
1665		<a href="lu_factor.cpp.xml" target="_top">LuFactor: Example and Test</a><br/>
1666		<a href="lu_solve.cpp.xml" target="_top">LuSolve With Complex Arguments: Example and Test</a><br/>
1667		<a href="lusolve.xml#Factor and Invert" target="_top">Compute Determinant and Solve Linear Equations: Factor and Invert</a><br/>
1668		<a href="lusolve.xml" target="_top">Compute Determinant and Solve Linear Equations</a><br/>
1669		<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
1670		<a href="poly.cpp.xml" target="_top">Polynomial Evaluation: Example and Test</a><br/>
1671		<a href="pow_int.cpp.xml" target="_top">The Pow Integer Exponent: Example and Test</a><br/>
1672		<a href="nan.cpp.xml" target="_top">nan: Example and Test</a><br/>
1673		<a href="check_simple_vector.cpp.xml" target="_top">The CheckSimpleVector Function: Example and Test</a><br/>
1674		<a href="simple_vector.cpp.xml" target="_top">Simple Vector Template Class: Example and Test</a><br/>
1675		<a href="simplevector.xml#Element Constructor and Destructor" target="_top">Definition of a Simple Vector: Element Constructor and Destructor</a><br/>
1676		<a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>
1677		<a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a><br/>
1678		<a href="time_test.cpp.xml" target="_top">time_test: Example and test</a><br/>
1679		<a href="elapsed_seconds.cpp.xml" target="_top">Elapsed Seconds: Example and Test</a><br/>
1680		<a href="speed_test.cpp.xml" target="_top">speed_test: Example and test</a><br/>
1681		<a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
1682		<a href="speed_test.xml" target="_top">Run One Speed Test and Return Results</a><br/>
1683		<a href="near_equal.cpp.xml" target="_top">NearEqual Function: Example and Test</a><br/>
1684		<a href="error_handler.cpp.xml" target="_top">Replacing The CppAD Error Handler: Example and Test</a><br/>
1685		<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
1686		<a href="simple_ad_pthread.cpp.xml" target="_top">A Simple pthread AD: Example and Test</a><br/>
1687		<a href="simple_ad_bthread.cpp.xml" target="_top">A Simple Boost Threading AD: Example and Test</a><br/>
1688		<a href="simple_ad_openmp.cpp.xml" target="_top">A Simple OpenMP AD: Example and Test</a><br/>
1689		<a href="a11c_pthread.cpp.xml" target="_top">A Simple Parallel Pthread Example and Test</a><br/>
1690		<a href="a11c_bthread.cpp.xml" target="_top">A Simple Boost Thread Example and Test</a><br/>
1691		<a href="a11c_openmp.cpp.xml" target="_top">A Simple OpenMP Example and Test</a><br/>
1692		<a href="thread_test.cpp.xml" target="_top">Run Multi-Threading Examples and Speed Tests</a><br/>
1693		<a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
1694		<a href="optimize.cpp.xml" target="_top">ADFun Operation Sequence Optimization: Example and Test</a><br/>
1695		<a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
1696		<a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
1697		<a href="sparse_sub_hes.cpp.xml" target="_top">Sparse Hessian on Subset of Variables: Example and Test</a><br/>
1698		<a href="sparse_hessian.cpp.xml" target="_top">Sparse Hessian: Example and Test</a><br/>
1699		<a href="sparse_jacobian.cpp.xml" target="_top">Sparse Jacobian: Example and Test</a><br/>
1700		<a href="rev_two.cpp.xml" target="_top">Second Partials Reverse Driver: Example and Test</a><br/>
1701		<a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
1702		<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
1703		<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
1704		<a href="hessian.cpp.xml" target="_top">Hessian: Example and Test</a><br/>
1705		<a href="rev_one.cpp.xml" target="_top">First Order Derivative Driver: Example and Test</a><br/>
1706		<a href="for_one.cpp.xml" target="_top">First Order Partial Driver: Example and Test</a><br/>
1707		<a href="jacobian.cpp.xml" target="_top">Jacobian: Example and Test</a><br/>
1708		<a href="drivers.xml" target="_top">First and Second Derivatives: Easy Drivers</a><br/>
1709		<a href="bool_sparsity.cpp.xml" target="_top">Using vectorBool Sparsity To Conserve Memory: Example and Test</a><br/>
1710		<a href="sparsity_sub.cpp.xml" target="_top">Sparsity Patterns For a Subset of Variables: Example and Test</a><br/>
1711		<a href="rev_sparse_hes.cpp.xml" target="_top">Reverse Mode Hessian Sparsity: Example and Test</a><br/>
1712		<a href="dependency.cpp.xml" target="_top">Computing Dependency: Example and Test</a><br/>
1713		<a href="rev_sparse_jac.cpp.xml" target="_top">Reverse Mode Jacobian Sparsity: Example and Test</a><br/>
1714		<a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
1715		<a href="reverse_any.cpp.xml" target="_top">Reverse Mode General Case: Example and Test</a><br/>
1716		<a href="reverse_three.cpp.xml" target="_top">Third Order Reverse Mode: Example and Test</a><br/>
1717		<a href="hes_times_dir.cpp.xml" target="_top">Hessian Times Direction: Example and Test</a><br/>
1718		<a href="reverse_two.cpp.xml" target="_top">Second Order Reverse ModeExample and Test</a><br/>
1719		<a href="reverse_one.cpp.xml" target="_top">First Order Reverse Mode: Example and Test</a><br/>
1720		<a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
1721		<a href="capacity_order.cpp.xml" target="_top">Controlling Taylor Coefficient Memory Allocation: Example and Test</a><br/>
1722		<a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
1723		<a href="compare_change.cpp.xml" target="_top">CompareChange and Re-Tape: Example and Test</a><br/>
1724		<a href="compare_change.xml" target="_top">Comparison Changes Between Taping and Zero Order Forward</a><br/>
1725		<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
1726		<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
1727		<a href="forward.cpp.xml" target="_top">Forward Mode: Example and Test</a><br/>
1728		<a href="funeval.xml" target="_top">Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</a><br/>
1729		<a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
1730		<a href="abort_recording.cpp.xml" target="_top">Abort Current Recording: Example and Test</a><br/>
1731		<a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
1732		<a href="fun_assign.cpp.xml" target="_top">ADFun Assignment: Example and Test</a><br/>
1733		<a href="funconstruct.xml" target="_top">Construct an ADFun Object and Stop Recording</a><br/>
1734		<a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a><br/>
1735		<a href="independent.cpp.xml" target="_top">Independent and ADFun Constructor: Example and Test</a><br/>
1736		<a href="independent.xml" target="_top">Declare Independent Variables and Start Recording</a><br/>
1737		<a href="complex_poly.cpp.xml" target="_top">Complex Polynomial: Example and Test</a><br/>
1738		<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
1739		<a href="base_require.cpp.xml" target="_top">Using a User Defined AD Base Type: Example and Test</a><br/>
1740		<a href="vec_ad.cpp.xml" target="_top">AD Vectors that Record Index Operations: Example and Test</a><br/>
1741		<a href="vecad.xml#Speed and Memory" target="_top">AD Vectors that Record Index Operations: Speed and Memory</a><br/>
1742		<a href="equal_op_seq.cpp.xml" target="_top">EqualOpSeq: Example and Test</a><br/>
1743		<a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
1744		<a href="par_var.cpp.xml" target="_top">AD Parameter and Variable Functions: Example and Test</a><br/>
1745		<a href="bool_fun.cpp.xml" target="_top">AD Boolean Functions: Example and Test</a><br/>
1746		<a href="near_equal_ext.cpp.xml" target="_top">Compare AD with Base Objects: Example and Test</a><br/>
1747		<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
1748		<a href="compare.cpp.xml" target="_top">AD Binary Comparison Operators: Example and Test</a><br/>
1749		<a href="boolvalued.xml" target="_top">Bool Valued Operations and Functions with AD Arguments</a><br/>
1750		<a href="atomic_mat_mul.cpp.xml" target="_top">User Atomic Matrix Multiply: Example and Test</a><br/>
1751		<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/>
1752		<a href="atomic_hes_sparse.cpp.xml" target="_top">Atomic Operation Hessian Sparsity: Example and Test</a><br/>
1753		<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
1754		<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
1755		<a href="atomic_sparsity.cpp.xml#Use Atomic Function.forsparse_jac and rev_sparse_jac" target="_top">Atomic Sparsity Patterns: Example and Test: Use Atomic Function.forsparse_jac and rev_sparse_jac</a><br/>
1756		<a href="atomic_sparsity.cpp.xml" target="_top">Atomic Sparsity Patterns: Example and Test</a><br/>
1757		<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
1758		<a href="atomic_norm_sq.cpp.xml" target="_top">Atomic Euclidean Norm Squared: Example and Test</a><br/>
1759		<a href="atomic_get_started.cpp.xml" target="_top">Getting Started with Atomic Operations: Example and Test</a><br/>
1760		<a href="checkpoint.cpp.xml" target="_top">Simple Checkpointing: Example and Test</a><br/>
1761		<a href="num_limits.cpp.xml" target="_top">Numeric Limits: Example and Test</a><br/>
1762		<a href="numeric_limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
1763		<a href="interp_retape.cpp.xml" target="_top">Interpolation With Retaping: Example and Test</a><br/>
1764		<a href="interp_onetape.cpp.xml" target="_top">Interpolation With Out Retaping: Example and Test</a><br/>
1765		<a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
1766		<a href="cond_exp.cpp.xml" target="_top">Conditional Expressions: Example and Test</a><br/>
1767		<a href="azmul.cpp.xml" target="_top">AD Absolute Zero Multiplication: Example and Test</a><br/>
1768		<a href="pow.cpp.xml" target="_top">The AD Power Function: Example and Test</a><br/>
1769		<a href="atan2.cpp.xml" target="_top">The AD atan2 Function: Example and Test</a><br/>
1770		<a href="sign.cpp.xml" target="_top">Sign Function: Example and Test</a><br/>
1771		<a href="log1p.cpp.xml" target="_top">The AD log1p Function: Example and Test</a><br/>
1772		<a href="expm1.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
1773		<a href="erf.cpp.xml" target="_top">The AD erf Function: Example and Test</a><br/>
1774		<a href="atanh.cpp.xml" target="_top">The AD atanh Function: Example and Test</a><br/>
1775		<a href="asinh.cpp.xml" target="_top">The AD asinh Function: Example and Test</a><br/>
1776		<a href="acosh.cpp.xml" target="_top">The AD acosh Function: Example and Test</a><br/>
1777		<a href="abs.cpp.xml" target="_top">AD Absolute Value Function: Example and Test</a><br/>
1778		<a href="tanh.cpp.xml" target="_top">The AD tanh Function: Example and Test</a><br/>
1779		<a href="tan.cpp.xml" target="_top">The AD tan Function: Example and Test</a><br/>
1780		<a href="sqrt.cpp.xml" target="_top">The AD sqrt Function: Example and Test</a><br/>
1781		<a href="sinh.cpp.xml" target="_top">The AD sinh Function: Example and Test</a><br/>
1782		<a href="sin.cpp.xml" target="_top">The AD sin Function: Example and Test</a><br/>
1783		<a href="log10.cpp.xml" target="_top">The AD log10 Function: Example and Test</a><br/>
1784		<a href="log.cpp.xml" target="_top">The AD log Function: Example and Test</a><br/>
1785		<a href="exp.cpp.xml" target="_top">The AD exp Function: Example and Test</a><br/>
1786		<a href="cosh.cpp.xml" target="_top">The AD cosh Function: Example and Test</a><br/>
1787		<a href="cos.cpp.xml" target="_top">The AD cos Function: Example and Test</a><br/>
1788		<a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
1789		<a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>
1790		<a href="acos.cpp.xml" target="_top">The AD acos Function: Example and Test</a><br/>
1791		<a href="div_eq.cpp.xml" target="_top">AD Computed Assignment Division: Example and Test</a><br/>
1792		<a href="mul_eq.cpp.xml" target="_top">AD Computed Assignment Multiplication: Example and Test</a><br/>
1793		<a href="sub_eq.cpp.xml" target="_top">AD Computed Assignment Subtraction: Example and Test</a><br/>
1794		<a href="addeq.cpp.xml" target="_top">AD Computed Assignment Addition: Example and Test</a><br/>
1795		<a href="div.cpp.xml" target="_top">AD Binary Division: Example and Test</a><br/>
1796		<a href="mul.cpp.xml" target="_top">AD Binary Multiplication: Example and Test</a><br/>
1797		<a href="sub.cpp.xml" target="_top">AD Binary Subtraction: Example and Test</a><br/>
1798		<a href="add.cpp.xml" target="_top">AD Binary Addition: Example and Test</a><br/>
1799		<a href="unary_minus.cpp.xml" target="_top">AD Unary Minus Operator: Example and Test</a><br/>
1800		<a href="unary_plus.cpp.xml" target="_top">AD Unary Plus Operator: Example and Test</a><br/>
1801		<a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
1802		<a href="advalued.xml" target="_top">AD Valued Operations and Functions</a><br/>
1803		<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
1804		<a href="print_for_string.cpp.xml" target="_top">Print During Zero Order Forward Mode: Example and Test</a><br/>
1805		<a href="print_for_cout.cpp.xml" target="_top">Printing During Forward Mode: Example and Test</a><br/>
1806		<a href="ad_output.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
1807		<a href="ad_input.cpp.xml" target="_top">AD Output Operator: Example and Test</a><br/>
1808		<a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
1809		<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
1810		<a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a><br/>
1811		<a href="ad_assign.cpp.xml" target="_top">AD Assignment: Example and Test</a><br/>
1812		<a href="ad_ctor.cpp.xml" target="_top">AD Constructors: Example and Test</a><br/>
1813		<a href="exp_eps_cppad.xml" target="_top">exp_eps: CppAD Forward and Reverse Sweeps</a><br/>
1814		<a href="exp_eps_for0.xml" target="_top">exp_eps: Operation Sequence and Zero Order Forward Sweep</a><br/>
1815		<a href="exp_2_cppad.xml" target="_top">exp_2: CppAD Forward and Reverse Sweeps</a><br/>
1816		<a href="exp_2_for0.xml" target="_top">exp_2: Operation Sequence and Zero Order Forward Mode</a><br/>
1817		<a href="auto_tools.xml#make.Examples and Tests" target="_top">Auto Tools Unix Test and Installation: make.Examples and Tests</a><br/>
1818		<a href="auto_tools.xml" target="_top">Auto Tools Unix Test and Installation</a><br/>
1819		<a href="cmake_check.xml" target="_top">Checking the CppAD Examples and Tests</a><br/>
1820		<a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
1821		<a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
1822		<a href="ipopt_prefix.xml#Examples and Tests" target="_top">Including the cppad_ipopt Library and Tests: Examples and Tests</a><br/>
1823		<a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>
1824		<a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
1825		<a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
1826		<a href="eigen_prefix.xml" target="_top">Including the Eigen Examples and Tests</a><br/>
1827		<a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
1828		<a href="colpack_hes.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
1829		<a href="colpack_jac.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
1830		<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
1831		<a href="adolc_prefix.xml" target="_top">Including the ADOL-C Examples and Tests</a><br/>
1832		<a href="cmake.xml#cppad_profile_flag.Eigen and Fadbad" target="_top">Using CMake to Configure CppAD: cppad_profile_flag.Eigen and Fadbad</a><br/>
1833		<a href="download.xml#Compressed Archives.Windows File Extraction and Testing" target="_top">Download The CppAD Source Code: Compressed Archives.Windows File Extraction and Testing</a><br/>
1834		<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
1835	1438	another <a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
1836	1439	<a href="base_to_string.xml" target="_top">Extending to_string To Another Floating Point Type</a><br/>
1837	1440	answers <a href="faq.xml" target="_top">Frequently Asked Questions and Answers</a><br/>

1874	1477	<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
1875	1478	<a href="tape_index.cpp.xml" target="_top">Taping Array Index Operation: Example and Test</a><br/>
1876	1479	arrays<b>:</b> <a href="eigen_array.cpp.xml" target="_top">Using Eigen Arrays: Example and Test</a><br/>
1877		as <a href="old_mat_mul.hpp.xml" target="_top">Define Matrix Multiply as a User Atomic Operation</a><br/>
1878		<a href="old_mat_mul.cpp.xml" target="_top">Old Matrix Multiply as a User Atomic Operation: Example and Test</a><br/>
1879		<a href="old_tan.cpp.xml" target="_top">Old Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
1880		<a href="atomic_matrix_mul.hpp.xml" target="_top">Matrix Multiply as an Atomic Operation</a><br/>
1881		<a href="atomic_tangent.cpp.xml" target="_top">Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
1882		<a href="atomic_reciprocal.cpp.xml" target="_top">Reciprocal as an Atomic Operation: Example and Test</a><br/>
1883	1480	asin <a href="asin_reverse.xml" target="_top">Inverse Sine and Hyperbolic Sine Reverse Mode Theory</a><br/>
1884	1481	<a href="asin_forward.xml" target="_top">Inverse Sine and Hyperbolic Sine Forward Mode Theory</a><br/>
1885	1482	<a href="asin.cpp.xml" target="_top">The AD asin Function: Example and Test</a><br/>

1924	1521	assignments <a href="arithmetic.xml" target="_top">AD Arithmetic Operators and Computed Assignments</a><br/>
1925	1522	assumption <a href="ad_output.xml#Assumption" target="_top">AD Output Stream Operator: Assumption</a><br/>
1926	1523	assumptions <a href="compare.xml#Assumptions" target="_top">AD Binary Comparison Operators: Assumptions</a><br/>
1927		at <a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
1928		<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
1929	1524	atan <a href="atan_forward.xml" target="_top">Inverse Tangent and Hyperbolic Tangent Forward Mode Theory</a><br/>
1930	1525	<a href="atan.cpp.xml" target="_top">The AD atan Function: Example and Test</a><br/>
1931	1526	<a href="atan.xml" target="_top">Inverse Tangent Function: atan</a><br/>

1995	1590	atomic<b>_</b>user <a href="atomic_ctor.xml#atomic_user" target="_top">Atomic Function Constructor: atomic_user</a><br/>
1996	1591	auto <a href="auto_tools.xml" target="_top">Auto Tools Unix Test and Installation</a><br/>
1997	1592	automatic <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
1998		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1593	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
1999	1594	available <a href="memory_leak.xml#available" target="_top">Memory Leak Detection: available</a><br/>
2000	1595	<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
2001	1596	<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>

2025	1620	<a href="ad_ctor.xml" target="_top">AD Constructors</a><br/>
2026	1621	BenderQuad <a href="bender_quad.cpp.xml" target="_top">BenderQuad: Example and Test</a><br/>
2027	1622	<a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
2028		b <a href="rombergmul.xml#b" target="_top">Multi-dimensional Romberg Integration: b</a><br/>
2029		<a href="rombergone.xml#b" target="_top">One DimensionalRomberg Integration: b</a><br/>
2030		<a href="lusolve.xml#B" target="_top">Compute Determinant and Solve Linear Equations: B</a><br/>
2031		<a href="nan.xml#hasnan.b" target="_top">Obtain Nan or Determine if a Value is Nan: hasnan.b</a><br/>
2032		<a href="nan.xml#isnan.b" target="_top">Obtain Nan or Determine if a Value is Nan: isnan.b</a><br/>
2033		<a href="nearequal.xml#b" target="_top">Determine if Two Values Are Nearly Equal: b</a><br/>
2034		<a href="check_for_nan.xml#b" target="_top">Check an ADFun Object For Nan Results: b</a><br/>
2035		<a href="vecad.xml#size_t Indexing.b" target="_top">AD Vectors that Record Index Operations: size_t Indexing.b</a><br/>
2036		<a href="equalopseq.xml#b" target="_top">Check if Two Value are Identically Equal: b</a><br/>
2037		<a href="parvar.xml#b" target="_top">Is an AD Object a Parameter or Variable: b</a><br/>
2038		<a href="boolfun.xml#b" target="_top">AD Boolean Functions: b</a><br/>
2039		<a href="nearequalext.xml#b" target="_top">Compare AD and Base Objects for Nearly Equal: b</a><br/>
2040		<a href="compare.xml#b" target="_top">AD Binary Comparison Operators: b</a><br/>
2041		<a href="value.xml#b" target="_top">Convert From an AD Type to its Base Type: b</a><br/>
2042	1623	background <a href="mul_level.xml#Background" target="_top">Using Multiple Levels of AD: Background</a><br/>
2043	1624	base <a href="zdouble.xml#Base Type Requirements" target="_top">zdouble: An AD Base Type With Absolute Zero: Base Type Requirements</a><br/>
2044	1625	<a href="zdouble.xml" target="_top">zdouble: An AD Base Type With Absolute Zero</a><br/>

2145	1726	<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
2146	1727	<a href="cmake.xml#CMake Command.Build Directory" target="_top">Using CMake to Configure CppAD: CMake Command.Build Directory</a><br/>
2147	1728	bvector <a href="ipopt_solve.xml#Bvector" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: Bvector</a><br/>
2148		by <a href="det_by_minor_c.xml" target="_top">Compute Determinant using Expansion by Minors</a><br/>
2149		<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
2150		<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
2151		<a href="omp_alloc.xml" target="_top">A Quick OpenMP Memory Allocator Used by CppAD</a><br/>
2152		<a href="sacado_det_minor.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant by Minor Expansion</a><br/>
2153		<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
2154		<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
2155		<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
2156		<a href="double_det_minor.cpp.xml" target="_top">Double Speed: Determinant by Minor Expansion</a><br/>
2157		<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
2158		<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
2159		<a href="det_by_minor.cpp.xml" target="_top">Determinant Using Expansion by Minors: Example and Test</a><br/>
2160		<a href="det_by_minor.xml" target="_top">Determinant Using Expansion by Minors</a><br/>
2161		<a href="det_by_lu.xml" target="_top">Determinant Using Expansion by Lu Factorization</a><br/>
2162		<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
2163		<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
2164		<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
2165		<a href="exampleutility.xml" target="_top">Utility Routines used by CppAD Examples</a><br/>
2166		<a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
2167		<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
2168		<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
2169		<a href="ludetandsolve.xml" target="_top">Compute Determinants and Solve Equations by LU Factorization</a><br/>
2170		<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
2171	1729
2172	1730	<b><big><a name="C">C</a></big></b>
2173	1731	<br/>
2174	1732	C <a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
2175	1733	<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
2176	1734	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/>
2177		C<b>++</b> <a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1735	C<b>++</b> <a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
2178	1736	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/>
2179	1737	CheckNumericType <a href="checknumerictype.xml" target="_top">Check NumericType Class Concept</a><br/>
2180	1738	CheckSimpleVector <a href="checksimplevector.xml" target="_top">Check Simple Vector Concept</a><br/>

2198	1756	CppAD <a href="vector_bool.cpp.xml" target="_top">CppAD::vectorBool Class: Example and Test</a><br/>
2199	1757	<a href="cppad_vector.cpp.xml" target="_top">CppAD::vector Template Class: Example and Test</a><br/>
2200	1758	<a href="cppad_vector.xml" target="_top">The CppAD::vector Template Class</a><br/>
2201		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1759	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
2202	1760	CppADTrackDelVec <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
2203	1761	CppADTrackExtend <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
2204	1762	CppADTrackNewVec <a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>

2213	1771	<a href="bib.xml#The C++ Programming Language" target="_top">Bibliography: The C++ Programming Language</a><br/>
2214	1772	<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
2215	1773	<a href="utility.xml#C++ Concepts" target="_top">Some General Purpose Utilities: C++ Concepts</a><br/>
2216		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	1774	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
2217	1775	c<b>++</b>11 <a href="cmake.xml#cppad_cxx_flags.C++11" target="_top">Using CMake to Configure CppAD: cppad_cxx_flags.C++11</a><br/>
2218	1776	c<b>:</b> <a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
2219	1777	calculating <a href="sparse.xml" target="_top">Calculating Sparsity Patterns</a><br/>

2653	2211	<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
2654	2212	<a href="download.xml" target="_top">Download The CppAD Source Code</a><br/>
2655	2213	<a href="install.xml" target="_top">CppAD Download, Test, and Install Instructions</a><br/>
2656		cppad<b>-</b>20160000<b>.</b>0<b>:</b> <a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
2657		cppad<b>.</b>hpp <a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	2214	cppad<b>-</b>20160000<b>.</b>1<b>:</b> <a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
	2215	cppad<b>.</b>hpp <a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
2658	2216	cppad<b>::</b>numeric<b>_</b>limits <a href="base_limits.xml#CppAD::numeric_limits" target="_top">Base Type Requirements for Numeric Limits: CppAD::numeric_limits</a><br/>
2659	2217	<a href="numeric_limits.xml#CppAD::numeric_limits" target="_top">Numeric Limits For an AD and Base Types: CppAD::numeric_limits</a><br/>
2660	2218	cppad<b>::</b>vector <a href="test_vector.xml#CppAD::vector" target="_top">Choosing The Vector Testing Template Class: CppAD::vector</a><br/>

2730	2288	Dependent <a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
2731	2289	<a href="dependent.xml" target="_top">Stop Recording and Store Operation Sequence</a><br/>
2732	2290	Domain <a href="seq_property.cpp.xml" target="_top">ADFun Sequence Properties: Example and Test</a><br/>
2733		d <a href="det_of_minor_c.xml#d" target="_top">Determinant of a Minor: d</a><br/>
2734		<a href="det_33.xml#d" target="_top">Check Determinant of 3 by 3 matrix: d</a><br/>
2735		<a href="det_by_minor.xml#det.d" target="_top">Determinant Using Expansion by Minors: det.d</a><br/>
2736		<a href="det_of_minor.xml#d" target="_top">Determinant of a Minor: d</a><br/>
2737		<a href="det_by_lu.xml#det.d" target="_top">Determinant Using Expansion by Lu Factorization: det.d</a><br/>
2738	2291	data <a href="cppad_vector.xml#vectorBool.data" target="_top">The CppAD::vector Template Class: vectorBool.data</a><br/>
2739	2292	<a href="cppad_vector.xml#data" target="_top">The CppAD::vector Template Class: data</a><br/>
2740	2293	datadir <a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>

2898	2451	<a href="exp_2_for2.xml#Operation Sequence.Derivative" target="_top">exp_2: Second Order Forward Mode: Operation Sequence.Derivative</a><br/>
2899	2452	<a href="exp_2_for1.xml#Operation Sequence.Derivative" target="_top">exp_2: First Order Forward Mode: Operation Sequence.Derivative</a><br/>
2900	2453	<a href="get_started.cpp.xml#Derivative" target="_top">Getting Started Using CppAD to Compute Derivatives: Derivative</a><br/>
2901		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	2454	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
2902	2455	derivative<b>:</b> <a href="revone.xml" target="_top">First Order Derivative: Driver Routine</a><br/>
2903	2456	<a href="forone.xml" target="_top">First Order Partial Derivative: Driver Routine</a><br/>
2904	2457	derivatives <a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>

3011	2564	differentiation <a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
3012	2565	<a href="introduction.xml#Preface.Algorithmic Differentiation" target="_top">An Introduction by Example to Algorithmic Differentiation: Preface.Algorithmic Differentiation</a><br/>
3013	2566	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
3014		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
3015		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	2567	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
	2568	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
3016	2569	dimension <a href="rombergmul.xml" target="_top">Multi-dimensional Romberg Integration</a><br/>
3017	2570	dimensional <a href="rombergmul.cpp.xml" target="_top">One Dimensional Romberg Integration: Example and Test</a><br/>
3018	2571	<a href="rombergmul.xml" target="_top">Multi-dimensional Romberg Integration</a><br/>

3644	3197	<a href="colpack_hes.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
3645	3198	<a href="colpack_jac.cpp.xml" target="_top">Using ColPack: Example and Test</a><br/>
3646	3199	<a href="colpack_prefix.xml#Example" target="_top">Including the ColPack Sparsity Calculations: Example</a><br/>
3647		<a href="cppad.xml#Example" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms: Example</a><br/>
	3200	<a href="cppad.xml#Example" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms: Example</a><br/>
3648	3201	examples <a href="wish_list.xml#Machine Epsilon in Examples" target="_top">The CppAD Wish List: Machine Epsilon in Examples</a><br/>
3649	3202	<a href="speed_example.cpp.xml" target="_top">Run the Speed Examples</a><br/>
3650	3203	<a href="example.cpp.xml" target="_top">CppAD Examples and Tests</a><br/>

3810	3363	ForSparseJac <a href="for_sparse_jac.cpp.xml" target="_top">Forward Mode Jacobian Sparsity: Example and Test</a><br/>
3811	3364	Forward <a href="capacity_order.xml" target="_top">Controlling Taylor Coefficients Memory Allocation</a><br/>
3812	3365	FunCheck <a href="fun_check.cpp.xml" target="_top">ADFun Check and Re-Tape: Example and Test</a><br/>
3813		f <a href="comparechange.xml#f" target="_top">Comparison Changes During Zero Order Forward Mode: f</a><br/>
3814		<a href="link_ode.xml#f" target="_top">Speed Testing the Jacobian of Ode Solution: f</a><br/>
3815		<a href="odegearcontrol.xml#Fun.f" target="_top">An Error Controller for Gear's Ode Solvers: Fun.f</a><br/>
3816		<a href="odegear.xml#Fun.f" target="_top">An Arbitrary Order Gear Method: Fun.f</a><br/>
3817		<a href="rosen34.xml#Fun.f" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.f</a><br/>
3818		<a href="runge45.xml#Fun.f" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Fun.f</a><br/>
3819		<a href="rombergmul.xml#F" target="_top">Multi-dimensional Romberg Integration: F</a><br/>
3820		<a href="rombergone.xml#F" target="_top">One DimensionalRomberg Integration: F</a><br/>
3821		<a href="check_for_nan.xml#f" target="_top">Check an ADFun Object For Nan Results: f</a><br/>
3822		<a href="optimize.xml#f" target="_top">Optimize an ADFun Object Tape: f</a><br/>
3823		<a href="funcheck.xml#f" target="_top">Check an ADFun Sequence of Operations: f</a><br/>
3824		<a href="sparse_hessian.xml#f" target="_top">Sparse Hessian: Easy Driver: f</a><br/>
3825		<a href="sparse_jacobian.xml#f" target="_top">Sparse Jacobian: Easy Driver: f</a><br/>
3826		<a href="revtwo.xml#f" target="_top">Reverse Mode Second Partial Derivative Driver: f</a><br/>
3827		<a href="fortwo.xml#f" target="_top">Forward Mode Second Partial Derivative Driver: f</a><br/>
3828		<a href="hessian.xml#f" target="_top">Hessian: Easy Driver: f</a><br/>
3829		<a href="revone.xml#f" target="_top">First Order Derivative: Driver Routine: f</a><br/>
3830		<a href="forone.xml#f" target="_top">First Order Partial Derivative: Driver Routine: f</a><br/>
3831		<a href="jacobian.xml#f" target="_top">Jacobian: Driver Routine: f</a><br/>
3832		<a href="revsparsehes.xml#f" target="_top">Hessian Sparsity Pattern: Reverse Mode: f</a><br/>
3833		<a href="revsparsejac.xml#f" target="_top">Jacobian Sparsity Pattern: Reverse Mode: f</a><br/>
3834		<a href="forsparsejac.xml#f" target="_top">Jacobian Sparsity Pattern: Forward Mode: f</a><br/>
3835		<a href="reverse_any.xml#f" target="_top">Any Order Reverse Mode: f</a><br/>
3836		<a href="reverse_two.xml#f" target="_top">Second Order Reverse Mode: f</a><br/>
3837		<a href="reverse_one.xml#f" target="_top">First Order Reverse Mode: f</a><br/>
3838		<a href="number_skip.xml#f" target="_top">Number of Variables that Can be Skipped: f</a><br/>
3839		<a href="capacity_order.xml#f" target="_top">Controlling Taylor Coefficients Memory Allocation: f</a><br/>
3840		<a href="compare_change.xml#f" target="_top">Comparison Changes Between Taping and Zero Order Forward: f</a><br/>
3841		<a href="size_order.xml#f" target="_top">Number Taylor Coefficient Orders Currently Stored: f</a><br/>
3842		<a href="forward_dir.xml#f" target="_top">Multiple Directions Forward Mode: f</a><br/>
3843		<a href="forward_order.xml#f" target="_top">Multiple Order Forward Mode: f</a><br/>
3844		<a href="forward_two.xml#f" target="_top">Second Order Forward Mode: Derivative Values: f</a><br/>
3845		<a href="forward_one.xml#f" target="_top">First Order Forward Mode: Derivative Values: f</a><br/>
3846		<a href="forward_zero.xml#f" target="_top">Zero Order Forward Mode: Function Values: f</a><br/>
3847		<a href="seq_property.xml#f" target="_top">ADFun Sequence Properties: f</a><br/>
3848		<a href="dependent.xml#f" target="_top">Stop Recording and Store Operation Sequence: f</a><br/>
3849		<a href="atomic_reverse.xml#F, G, H" target="_top">Atomic Reverse Mode: F, G, H</a><br/>
	3366	f <a href="atomic_reverse.xml#F, G, H" target="_top">Atomic Reverse Mode: F, G, H</a><br/>
3850	3367	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/>
3851	3368	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/>
3852	3369	<a href="exp_eps_rev1.xml#Index 2: f_1" target="_top">exp_eps: First Order Reverse Sweep: Index 2: f_1</a><br/>

3961	3478	<a href="base_alloc.hpp.xml#Include File" target="_top">Example AD<Base> Where Base Constructor Allocates Memory: Include File</a><br/>
3962	3479	<a href="download.xml#Compressed Archives.Windows File Extraction and Testing" target="_top">Download The CppAD Source Code: Compressed Archives.Windows File Extraction and Testing</a><br/>
3963	3480	<a href="download.xml#Compressed Archives.Unix File Extraction" target="_top">Download The CppAD Source Code: Compressed Archives.Unix File Extraction</a><br/>
3964		<a href="cppad.xml#Include File" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
	3481	<a href="cppad.xml#Include File" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
3965	3482	file<b>_</b>name <a href="check_for_nan.xml#Error Message.file_name" target="_top">Check an ADFun Object For Nan Results: Error Message.file_name</a><br/>
3966	3483	files <a href="addon.xml#Library Files" target="_top">CppAD Addons: Library Files</a><br/>
3967	3484	<a href="addon.xml#Include Files" target="_top">CppAD Addons: Include Files</a><br/>

4030	3547	<a href="rombergmul.xml#FloatVector" target="_top">Multi-dimensional Romberg Integration: FloatVector</a><br/>
4031	3548	<a href="lufactor.xml#FloatVector" target="_top">LU Factorization of A Square Matrix: FloatVector</a><br/>
4032	3549	<a href="lusolve.xml#FloatVector" target="_top">Compute Determinant and Solve Linear Equations: FloatVector</a><br/>
4033		for <a href="license.xml" target="_top">Your License for the CppAD Software</a><br/>
4034		<a href="main_compare_c.xml" target="_top">Main Program For Comparing C and C++ Speed</a><br/>
4035		<a href="ipopt_ode_speed.cpp.xml" target="_top">Speed Test for Both Simple and Fast Representations</a><br/>
4036		<a href="ipopt_nlp_ode_check.cpp.xml" target="_top">Correctness Check for Both Simple and Fast Representations</a><br/>
4037		<a href="ipopt_nlp_ode_run.hpp.xml" target="_top">Driver for Running the Ipopt ODE Example</a><br/>
4038		<a href="epsilon.xml" target="_top">Machine Epsilon For AD Types</a><br/>
4039		<a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
4040		<a href="omp_efficient.xml" target="_top">Check If A Memory Allocation is Efficient for Another Use</a><br/>
4041		<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
4042		<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
4043		<a href="omp_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
4044		<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
4045		<a href="adolc_alloc_mat.xml" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix</a><br/>
4046		<a href="eigen_plugin.hpp.xml" target="_top">Source Code for eigen_plugin.hpp</a><br/>
4047		<a href="ta_free_all.xml" target="_top">Free All Memory That Was Allocated for Use by thread_alloc</a><br/>
4048		<a href="ta_delete_array.xml" target="_top">Deallocate An Array and Call Destructor for its Elements</a><br/>
4049		<a href="ta_create_array.xml" target="_top">Allocate An Array and Call Default Constructor for its Elements</a><br/>
4050		<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
4051		<a href="ta_hold_memory.xml" target="_top">Control When Thread Alloc Retains Memory For Future Use</a><br/>
4052		<a href="ta_free_available.xml" target="_top">Free Memory Currently Available for Quick Use by a Thread</a><br/>
4053		<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
4054		<a href="odegearcontrol.xml" target="_top">An Error Controller for Gear's Ode Solvers</a><br/>
4055		<a href="odeerrcontrol.xml" target="_top">An Error Controller for ODE Solvers</a><br/>
4056		<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
4057		<a href="check_for_nan.cpp.xml" target="_top">ADFun Checking For Nan: Example and Test</a><br/>
4058		<a href="check_for_nan.xml" target="_top">Check an ADFun Object For Nan Results</a><br/>
4059		<a href="sub_sparse_hes.cpp.xml" target="_top">Computing Sparse Hessian for a Subset of Variables</a><br/>
4060		<a href="sparsity_sub.cpp.xml" target="_top">Sparsity Patterns For a Subset of Variables: Example and Test</a><br/>
4061		<a href="base_limits.xml" target="_top">Base Type Requirements for Numeric Limits</a><br/>
4062		<a href="base_std_math.xml" target="_top">Base Type Requirements for Standard Math Functions</a><br/>
4063		<a href="base_ordered.xml" target="_top">Base Type Requirements for Ordered Comparisons</a><br/>
4064		<a href="base_identical.xml" target="_top">Base Type Requirements for Identically Equal Comparisons</a><br/>
4065		<a href="base_cond_exp.xml" target="_top">Base Type Requirements for Conditional Expressions</a><br/>
4066		<a href="base_require.xml" target="_top">AD<Base> Requirements for a CppAD Base Type</a><br/>
4067		<a href="nearequalext.xml" target="_top">Compare AD and Base Objects for Nearly Equal</a><br/>
4068		<a href="numeric_limits.xml" target="_top">Numeric Limits For an AD and Base Types</a><br/>
4069		<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
4070		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
4071	3550	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/>
4072	3551	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/>
4073	3552	<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/>

4487	3966	<br/>
4488	3967	Integer <a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
4489	3968	Ipopt <a href="auto_tools.xml" target="_top">Auto Tools Unix Test and Installation</a><br/>
4490		i <a href="revtwo.xml#i" target="_top">Reverse Mode Second Partial Derivative Driver: i</a><br/>
4491		<a href="revone.xml#i" target="_top">First Order Derivative: Driver Routine: i</a><br/>
4492		<a href="vecad.xml#size_t Indexing.i" target="_top">AD Vectors that Record Index Operations: size_t Indexing.i</a><br/>
4493		<a href="integer.xml#i" target="_top">Convert From AD to Integer: i</a><br/>
4494	3969	i<b>(</b>k<br/>
4495	3970	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/>
4496	3971	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/>

4568	4043	<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
4569	4044	important <a href="reverse_identity.xml" target="_top">An Important Reverse Mode Identity</a><br/>
4570	4045	improvements <a href="optimize.xml#Improvements" target="_top">Optimize an ADFun Object Tape: Improvements</a><br/>
4571		in <a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
4572		<a href="wish_list.xml#Machine Epsilon in Examples" target="_top">The CppAD Wish List: Machine Epsilon in Examples</a><br/>
4573		<a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
4574		<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
4575		<a href="ta_in_parallel.xml" target="_top">Is The Current Execution in Parallel Mode</a><br/>
4576		<a href="ta_parallel_setup.xml" target="_top">Setup thread_alloc For Use in Multi-Threading Environment</a><br/>
4577		<a href="team_pthread.cpp.xml#Bug in Cygwin" target="_top">Pthread Implementation of a Team of AD Threads: Bug in Cygwin</a><br/>
4578		<a href="multi_thread.xml" target="_top">Using CppAD in a Multi-Threading Environment</a><br/>
4579		<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
4580		<a href="get_sacado.sh.xml" target="_top">Download and Install Sacado in Build Directory</a><br/>
4581		<a href="get_ipopt.sh.xml" target="_top">Download and Install Ipopt in Build Directory</a><br/>
4582		<a href="get_fadbad.sh.xml" target="_top">Download and Install Fadbad in Build Directory</a><br/>
4583		<a href="get_eigen.sh.xml" target="_top">Download and Install Eigen in Build Directory</a><br/>
4584		<a href="get_colpack.sh.xml" target="_top">Download and Install ColPack in Build Directory</a><br/>
4585		<a href="get_adolc.sh.xml" target="_top">Download and Install Adolc in Build Directory</a><br/>
4586	4046	in<b>_</b>parallel <a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>
4587	4047	<a href="ta_parallel_setup.xml#in_parallel" target="_top">Setup thread_alloc For Use in Multi-Threading Environment: in_parallel</a><br/>
4588	4048	inactive <a href="glossary.xml#Tape.Inactive" target="_top">Glossary: Tape.Inactive</a><br/>

4623	4083	<a href="exp_eps.xml#include" target="_top">An Epsilon Accurate Exponential Approximation: include</a><br/>
4624	4084	<a href="exp_2.xml#include" target="_top">Second Order Exponential Approximation: include</a><br/>
4625	4085	<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
4626		<a href="cppad.xml#Include File" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
	4086	<a href="cppad.xml#Include File" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms: Include File</a><br/>
4627	4087	including <a href="sacado_prefix.xml" target="_top">Including the Sacado Speed Tests</a><br/>
4628	4088	<a href="ipopt_prefix.xml" target="_top">Including the cppad_ipopt Library and Tests</a><br/>
4629	4089	<a href="fadbad_prefix.xml" target="_top">Including the FADBAD Speed Tests</a><br/>

4782	4242	<a href="example.xml#Introduction" target="_top">Examples: Introduction</a><br/>
4783	4243	<a href="exp_apx_main.cpp.xml" target="_top">Correctness Tests For Exponential Approximation in Introduction</a><br/>
4784	4244	<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
4785		<a href="cppad.xml#Introduction" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms: Introduction</a><br/>
	4245	<a href="cppad.xml#Introduction" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms: Introduction</a><br/>
4786	4246	inuse <a href="memory_leak.xml#inuse" target="_top">Memory Leak Detection: inuse</a><br/>
4787	4247	<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
4788	4248	<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>

5456	4916	NULL <a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a><br/>
5457	4917	NumericType <a href="check_numeric_type.cpp.xml" target="_top">The CheckNumericType Function: Example and Test</a><br/>
5458	4918	<a href="numeric_type.cpp.xml" target="_top">The NumericType: Example and Test</a><br/>
5459		n <a href="uniform_01_c.xml#n" target="_top">Simulate a [0,1] Uniform Random Variate: n</a><br/>
5460		<a href="det_of_minor_c.xml#n" target="_top">Determinant of a Minor: n</a><br/>
5461		<a href="old_atomic.xml#n" target="_top">User Defined Atomic AD Functions: n</a><br/>
5462		<a href="cppad_ipopt_nlp.xml#n" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: n</a><br/>
5463		<a href="adolc_alloc_mat.xml#n" target="_top">Adolc Test Utility: Allocate and Free Memory For a Matrix: n</a><br/>
5464		<a href="uniform_01.xml#n" target="_top">Simulate a [0,1] Uniform Random Variate: n</a><br/>
5465		<a href="sparse_hes_fun.xml#n" target="_top">Evaluate a Function That Has a Sparse Hessian: n</a><br/>
5466		<a href="sparse_jac_fun.xml#n" target="_top">Evaluate a Function That Has a Sparse Jacobian: n</a><br/>
5467		<a href="mat_sum_sq.xml#n" target="_top">Sum Elements of a Matrix Times Itself: n</a><br/>
5468		<a href="det_by_minor.xml#n" target="_top">Determinant Using Expansion by Minors: n</a><br/>
5469		<a href="det_of_minor.xml#n" target="_top">Determinant of a Minor: n</a><br/>
5470		<a href="det_by_lu.xml#n" target="_top">Determinant Using Expansion by Lu Factorization: n</a><br/>
5471		<a href="link_mat_mul.xml#n" target="_top">Speed Testing Derivative of Matrix Multiply: n</a><br/>
5472		<a href="lu_vec_ad.cpp.xml#n" target="_top">Lu Factor and Solve with Recorded Pivoting: n</a><br/>
5473		<a href="odegear.xml#n" target="_top">An Arbitrary Order Gear Method: n</a><br/>
5474		<a href="rombergmul.xml#n" target="_top">Multi-dimensional Romberg Integration: n</a><br/>
5475		<a href="rombergone.xml#n" target="_top">One DimensionalRomberg Integration: n</a><br/>
5476		<a href="lusolve.xml#n" target="_top">Compute Determinant and Solve Linear Equations: n</a><br/>
5477		<a href="number_skip.xml#n" target="_top">Number of Variables that Can be Skipped: n</a><br/>
5478		<a href="forward_dir.xml#Notation.n" target="_top">Multiple Directions Forward Mode: Notation.n</a><br/>
5479		<a href="forward_order.xml#Notation.n" target="_top">Multiple Order Forward Mode: Notation.n</a><br/>
5480		<a href="vecad.xml#n" target="_top">AD Vectors that Record Index Operations: n</a><br/>
5481	4919	n<b>_</b>sweep <a href="link_sparse_jacobian.xml#n_sweep" target="_top">Speed Testing Sparse Jacobian: n_sweep</a><br/>
5482	4920	<a href="link_sparse_hessian.xml#n_sweep" target="_top">Speed Testing Sparse Hessian: n_sweep</a><br/>
5483	4921	<a href="speed_main.xml#Speed Results.n_sweep" target="_top">Running the Speed Test Program: Speed Results.n_sweep</a><br/>

5493	4931	<a href="cppad_ipopt_nlp.xml#cppad_ipopt namespace" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt: cppad_ipopt namespace</a><br/>
5494	4932	<a href="faq.xml#Namespace" target="_top">Frequently Asked Questions and Answers: Namespace</a><br/>
5495	4933	<a href="cppad_eigen.hpp.xml#CppAD Namespace" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD: CppAD Namespace</a><br/>
5496		<a href="cppad.xml#Namespace" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms: Namespace</a><br/>
	4934	<a href="cppad.xml#Namespace" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms: Namespace</a><br/>
5497	4935	nan <a href="zdouble.xml#Syntax.Nan" target="_top">zdouble: An AD Base Type With Absolute Zero: Syntax.Nan</a><br/>
5498	4936	<a href="ode_err_control.cpp.xml#Nan" target="_top">OdeErrControl: Example and Test: Nan</a><br/>
5499	4937	<a href="odeerrcontrol.xml#Method.Nan" target="_top">An Error Controller for ODE Solvers: Method.Nan</a><br/>

5683	5121	<a href="ode_err_control.cpp.xml" target="_top">OdeErrControl: Example and Test</a><br/>
5684	5122	odegear<b>:</b> <a href="ode_gear.cpp.xml" target="_top">OdeGear: Example and Test</a><br/>
5685	5123	odegearcontrol<b>:</b> <a href="ode_gear_control.cpp.xml" target="_top">OdeGearControl: Example and Test</a><br/>
5686		of <a href="luratio.xml" target="_top">LU Factorization of A Square Matrix and Stability Calculation</a><br/>
5687		<a href="opt_val_hes.xml" target="_top">Jacobian and Hessian of Optimal Values</a><br/>
5688		<a href="benderquad.xml" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective</a><br/>
5689		<a href="time_det_by_minor_c.xml" target="_top">Determine Amount of Time to Execute det_by_minor</a><br/>
5690		<a href="elapsed_seconds_c.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
5691		<a href="repeat_det_by_minor_c.xml" target="_top">Repeat det_by_minor Routine A Specified Number of Times</a><br/>
5692		<a href="correct_det_by_minor_c.xml" target="_top">Correctness Test of det_by_minor Routine</a><br/>
5693		<a href="det_of_minor_c.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
5694		<a href="det_of_minor_c.xml" target="_top">Determinant of a Minor</a><br/>
5695		<a href="compare_c.xml" target="_top">Compare Speed of C and C++</a><br/>
5696		<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/>
5697		<a href="ipopt_nlp_ode.xml" target="_top">Example Simultaneous Solution of Forward and Inverse Problem</a><br/>
5698		<a href="old_max_num_threads.xml" target="_top">Set Maximum Number of Threads for omp_alloc Allocator</a><br/>
5699		<a href="omp_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
5700		<a href="omp_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
5701		<a href="omp_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
5702		<a href="omp_max_num_threads.xml" target="_top">Set and Get Maximum Number of Threads for omp_alloc Allocator</a><br/>
5703		<a href="tracknewdel.cpp.xml" target="_top">Tracking Use of New and Delete: Example and Test</a><br/>
5704		<a href="tracknewdel.xml" target="_top">Routines That Track Use of New and Delete</a><br/>
5705		<a href="glossary.xml#Sparsity Pattern.Vector of Sets" target="_top">Glossary: Sparsity Pattern.Vector of Sets</a><br/>
5706		<a href="glossary.xml#Sparsity Pattern.Vector of Boolean" target="_top">Glossary: Sparsity Pattern.Vector of Boolean</a><br/>
5707		<a href="glossary.xml#AD of Base" target="_top">Glossary: AD of Base</a><br/>
5708		<a href="reversetheory.xml" target="_top">The Theory of Reverse Mode</a><br/>
5709		<a href="forwardtheory.xml" target="_top">The Theory of Forward Mode</a><br/>
5710		<a href="theory.xml" target="_top">The Theory of Derivative Calculations</a><br/>
5711		<a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>
5712		<a href="sacado_ode.cpp.xml" target="_top">Sacado Speed: Gradient of Ode Solution</a><br/>
5713		<a href="sacado_det_lu.cpp.xml" target="_top">Sacado Speed: Gradient of Determinant Using Lu Factorization</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_poly.cpp.xml" target="_top">Fadbad Speed: Second Derivative of a Polynomial</a><br/>
5716		<a href="fadbad_det_lu.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant Using Lu Factorization</a><br/>
5717		<a href="fadbad_det_minor.cpp.xml" target="_top">Fadbad Speed: Gradient of Determinant by Minor Expansion</a><br/>
5718		<a href="cppad_poly.cpp.xml" target="_top">CppAD Speed: Second Derivative of a Polynomial</a><br/>
5719		<a href="cppad_ode.cpp.xml" target="_top">CppAD Speed: Gradient of Ode Solution</a><br/>
5720		<a href="cppad_det_lu.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant Using Lu Factorization</a><br/>
5721		<a href="cppad_det_minor.cpp.xml" target="_top">CppAD Speed: Gradient of Determinant by Minor Expansion</a><br/>
5722		<a href="adolc_poly.cpp.xml" target="_top">Adolc Speed: Second Derivative of a Polynomial</a><br/>
5723		<a href="adolc_det_lu.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant Using Lu Factorization</a><br/>
5724		<a href="adolc_det_minor.cpp.xml" target="_top">Adolc Speed: Gradient of Determinant by Minor Expansion</a><br/>
5725		<a href="speed_adolc.xml" target="_top">Speed Test of Derivatives Using Adolc</a><br/>
5726		<a href="speed_double.xml" target="_top">Speed Test of Functions in Double</a><br/>
5727		<a href="ode_evaluate.xml" target="_top">Evaluate a Function Defined in Terms of an ODE</a><br/>
5728		<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
5729		<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
5730		<a href="mat_sum_sq.cpp.xml" target="_top">Sum of the Elements of the Square of a Matrix: Example and Test</a><br/>
5731		<a href="mat_sum_sq.xml" target="_top">Sum Elements of a Matrix Times Itself</a><br/>
5732		<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
5733		<a href="det_grad_33.xml" target="_top">Check Gradient of Determinant of 3 by 3 matrix</a><br/>
5734		<a href="det_33.xml" target="_top">Check Determinant of 3 by 3 matrix</a><br/>
5735		<a href="det_of_minor.cpp.xml" target="_top">Determinant of a Minor: Example and Test</a><br/>
5736		<a href="det_of_minor.xml#Determinant of A" target="_top">Determinant of a Minor: Determinant of A</a><br/>
5737		<a href="det_of_minor.xml" target="_top">Determinant of a Minor</a><br/>
5738		<a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a><br/>
5739		<a href="microsoft_timer.xml" target="_top">Microsoft Version of Elapsed Number of Seconds</a><br/>
5740		<a href="link_poly.xml" target="_top">Speed Testing Second Derivative of a Polynomial</a><br/>
5741		<a href="link_ode.xml" target="_top">Speed Testing the Jacobian of Ode Solution</a><br/>
5742		<a href="link_mat_mul.xml" target="_top">Speed Testing Derivative of Matrix Multiply</a><br/>
5743		<a href="link_det_minor.xml" target="_top">Speed Testing Gradient of Determinant by Minor Expansion</a><br/>
5744		<a href="link_det_lu.xml" target="_top">Speed Testing Gradient of Determinant Using Lu Factorization</a><br/>
5745		<a href="mul_level_adolc_ode.cpp.xml#Derivative of ODE Solution" target="_top">Taylor's Ode Solver: A Multi-Level Adolc Example and Test: Derivative of ODE Solution</a><br/>
5746		<a href="mul_level_ode.cpp.xml#Derivative of ODE Solution" target="_top">Taylor's Ode Solver: A Multi-Level AD Example and Test: Derivative of ODE Solution</a><br/>
5747		<a href="mul_level.cpp.xml" target="_top">Multiple Level of AD: Example and Test</a><br/>
5748		<a href="mul_level.xml#Procedure.Derivatives of Outer Function" target="_top">Using Multiple Levels of AD: Procedure.Derivatives of Outer Function</a><br/>
5749		<a href="mul_level.xml" target="_top">Using Multiple Levels of AD</a><br/>
5750		<a href="jac_lu_det.cpp.xml" target="_top">Gradient of Determinant Using Lu Factorization: Example and Test</a><br/>
5751		<a href="jac_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
5752		<a href="hes_lu_det.cpp.xml" target="_top">Gradient of Determinant Using LU Factorization: Example and Test</a><br/>
5753		<a href="hes_minor_det.cpp.xml" target="_top">Gradient of Determinant Using Expansion by Minors: Example and Test</a><br/>
5754		<a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
5755		<a href="listallexamples.xml" target="_top">List of All the CppAD Examples</a><br/>
5756		<a href="ta_available.xml" target="_top">Amount of Memory Available for Quick Use by a Thread</a><br/>
5757		<a href="ta_inuse.xml" target="_top">Amount of Memory a Thread is Currently Using</a><br/>
5758		<a href="ta_get_memory.xml" target="_top">Get At Least A Specified Amount of Memory</a><br/>
5759		<a href="ta_num_threads.xml" target="_top">Get Number of Threads</a><br/>
5760		<a href="lufactor.xml" target="_top">LU Factorization of A Square Matrix</a><br/>
5761		<a href="simplevector.xml#Elements of Specified Type" target="_top">Definition of a Simple Vector: Elements of Specified Type</a><br/>
5762		<a href="simplevector.xml" target="_top">Definition of a Simple Vector</a><br/>
5763		<a href="numerictype.xml" target="_top">Definition of a Numeric Type</a><br/>
5764		<a href="elapsed_seconds.xml" target="_top">Returns Elapsed Number of Seconds</a><br/>
5765		<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
5766		<a href="speed_program.cpp.xml" target="_top">Example Use of SpeedTest</a><br/>
5767		<a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
5768		<a href="team_pthread.cpp.xml" target="_top">Pthread Implementation of a Team of AD Threads</a><br/>
5769		<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
5770		<a href="team_bthread.cpp.xml" target="_top">Boost Thread Implementation of a Team of AD Threads</a><br/>
5771		<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
5772		<a href="team_openmp.cpp.xml" target="_top">OpenMP Implementation of a Team of AD Threads</a><br/>
5773		<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/>
5774		<a href="team_thread.hpp.xml" target="_top">Specifications for A Team of AD Threads</a><br/>
5775		<a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
5776		<a href="harmonic_work.cpp.xml" target="_top">Multi-threading Sum of 1/i Utility Routines</a><br/>
5777		<a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
5778		<a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
5779		<a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
5780		<a href="harmonic.cpp.xml" target="_top">Multi-Threaded Implementation of Summation of 1/i</a><br/>
5781		<a href="team_example.cpp.xml" target="_top">Using a Team of AD Threads: Example and Test</a><br/>
5782		<a href="funcheck.xml" target="_top">Check an ADFun Sequence of Operations</a><br/>
5783		<a href="sparse_sub_hes.cpp.xml" target="_top">Sparse Hessian on Subset of Variables: Example and Test</a><br/>
5784		<a href="sub_sparse_hes.cpp.xml" target="_top">Computing Sparse Hessian for a Subset of Variables</a><br/>
5785		<a href="for_two.cpp.xml" target="_top">Subset of Second Order Partials: Example and Test</a><br/>
5786		<a href="hes_lagrangian.cpp.xml" target="_top">Hessian of Lagrangian and  ADFun Default Constructor: Example and Test</a><br/>
5787		<a href="sparsity_sub.cpp.xml" target="_top">Sparsity Patterns For a Subset of Variables: Example and Test</a><br/>
5788		<a href="number_skip.cpp.xml" target="_top">Number of Variables That Can be Skipped: Example and Test</a><br/>
5789		<a href="number_skip.xml" target="_top">Number of Variables that Can be Skipped</a><br/>
5790		<a href="forward_dir.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Directions</a><br/>
5791		<a href="forward_order.cpp.xml" target="_top">Forward Mode: Example and Test of Multiple Orders</a><br/>
5792		<a href="abort_recording.xml" target="_top">Abort Recording of an Operation Sequence</a><br/>
5793		<a href="base_complex.hpp.xml" target="_top">Enable use of AD<Base> where Base is std::complex<double></a><br/>
5794		<a href="base_double.hpp.xml" target="_top">Enable use of AD<Base> where Base is double</a><br/>
5795		<a href="base_float.hpp.xml" target="_top">Enable use of AD<Base> where Base is float</a><br/>
5796		<a href="mul_level_adolc.cpp.xml" target="_top">Using Adolc with Multiple Levels of Taping: Example and Test</a><br/>
5797		<a href="base_adolc.hpp.xml" target="_top">Enable use of AD<Base> where Base is Adolc's adouble Type</a><br/>
5798		<a href="atomic_afun.xml" target="_top">Using AD Version of Atomic Function</a><br/>
5799		<a href="log1p.xml" target="_top">The Logarithm of One Plus Argument: log1p</a><br/>
5800		<a href="convert.xml" target="_top">Conversion and I/O of AD Objects</a><br/>
5801		<a href="exp_eps.cpp.xml" target="_top">exp_eps: Test of exp_eps</a><br/>
5802		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
5803	5124	ok <a href="old_atomic.xml#ok" target="_top">User Defined Atomic AD Functions: ok</a><br/>
5804	5125	<a href="det_grad_33.xml#ok" target="_top">Check Gradient of Determinant of 3 by 3 matrix: ok</a><br/>
5805	5126	<a href="det_33.xml#ok" target="_top">Check Determinant of 3 by 3 matrix: ok</a><br/>

5973	5294	options <a href="speed_main.xml#Sparsity Options" target="_top">Running the Speed Test Program: Sparsity Options</a><br/>
5974	5295	<a href="ipopt_solve.xml#options" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem: options</a><br/>
5975	5296	<a href="atomic_option.xml" target="_top">Set Atomic Function Options</a><br/>
5976		or <a href="faq.xml#Tape Storage: Disk or Memory" target="_top">Frequently Asked Questions and Answers: Tape Storage: Disk or Memory</a><br/>
5977		<a href="faq.xml#Mode: Forward or Reverse" target="_top">Frequently Asked Questions and Answers: Mode: Forward or Reverse</a><br/>
5978		<a href="poly.xml" target="_top">Evaluate a Polynomial or its Derivative</a><br/>
5979		<a href="nan.xml" target="_top">Obtain Nan or Determine if a Value is Nan</a><br/>
5980		<a href="jacobian.xml#Forward or Reverse" target="_top">Jacobian: Driver Routine: Forward or Reverse</a><br/>
5981		<a href="parvar.xml" target="_top">Is an AD Object a Parameter or Variable</a><br/>
5982		<a href="ad_to_string.xml" target="_top">Convert An AD or Base Type to String</a><br/>
5983	5297	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/>
5984	5298	<a href="comparechange.xml" target="_top">Comparison Changes During Zero Order Forward Mode</a><br/>
5985	5299	<a href="fundeprecated.xml#Order" target="_top">ADFun Object Deprecated Member Functions: Order</a><br/>

6121	5435	<a href="speed.xml" target="_top">Speed Test an Operator Overloading AD Package</a><br/>
6122	5436	<a href="cppad_eigen.hpp.xml" target="_top">Enable Use of Eigen Linear Algebra Package with CppAD</a><br/>
6123	5437	<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
6124		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	5438	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
6125	5439	package<b>_</b>prefix <a href="cmake.xml#package_prefix" target="_top">Using CMake to Configure CppAD: package_prefix</a><br/>
6126	5440	parallel <a href="old_atomic.xml#afun.Parallel Mode" target="_top">User Defined Atomic AD Functions: afun.Parallel Mode</a><br/>
6127	5441	<a href="omp_in_parallel.xml" target="_top">Is The Current Execution in OpenMP Parallel Mode</a><br/>

6252	5566	preprocessor <a href="addon.xml#Preprocessor Symbols" target="_top">CppAD Addons: Preprocessor Symbols</a><br/>
6253	5567	<a href="faq.xml#Namespace.Test Vector Preprocessor Symbol" target="_top">Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol</a><br/>
6254	5568	<a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a><br/>
6255		<a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
	5569	<a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
6256	5570	previous <a href="whats_new.xml#Previous Years" target="_top">Changes and Additions to CppAD: Previous Years</a><br/>
6257	5571	previously <a href="tracknewdel.xml#TrackCount.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackCount.Previously Deprecated</a><br/>
6258	5572	<a href="tracknewdel.xml#TrackExtend.Previously Deprecated" target="_top">Routines That Track Use of New and Delete: TrackExtend.Previously Deprecated</a><br/>

6584	5898	Runge45 <a href="runge45_2.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
6585	5899	<a href="runge45_1.cpp.xml" target="_top">Runge45: Example and Test</a><br/>
6586	5900	<a href="runge45.xml" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver</a><br/>
6587		r <a href="det_of_minor_c.xml#r" target="_top">Determinant of a Minor: r</a><br/>
6588		<a href="old_atomic.xml#rev_hes_sparse.r" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.r</a><br/>
6589		<a href="old_atomic.xml#rev_jac_sparse.r" target="_top">User Defined Atomic AD Functions: rev_jac_sparse.r</a><br/>
6590		<a href="old_atomic.xml#for_jac_sparse.r" target="_top">User Defined Atomic AD Functions: for_jac_sparse.r</a><br/>
6591		<a href="det_of_minor.xml#r" target="_top">Determinant of a Minor: r</a><br/>
6592		<a href="rombergmul.xml#r" target="_top">Multi-dimensional Romberg Integration: r</a><br/>
6593		<a href="rombergone.xml#r" target="_top">One DimensionalRomberg Integration: r</a><br/>
6594		<a href="nearequal.xml#r" target="_top">Determine if Two Values Are Nearly Equal: r</a><br/>
6595		<a href="funcheck.xml#r" target="_top">Check an ADFun Sequence of Operations: r</a><br/>
6596		<a href="revsparsehes.xml#r" target="_top">Hessian Sparsity Pattern: Reverse Mode: r</a><br/>
6597		<a href="revsparsejac.xml#r" target="_top">Jacobian Sparsity Pattern: Reverse Mode: r</a><br/>
6598		<a href="forsparsejac.xml#r" target="_top">Jacobian Sparsity Pattern: Forward Mode: r</a><br/>
6599		<a href="forward_dir.xml#r" target="_top">Multiple Directions Forward Mode: r</a><br/>
6600		<a href="vecad.xml#AD Indexing.r" target="_top">AD Vectors that Record Index Operations: AD Indexing.r</a><br/>
6601		<a href="nearequalext.xml#r" target="_top">Compare AD and Base Objects for Nearly Equal: r</a><br/>
6602		<a href="atomic_rev_sparse_hes.xml#Implementation.r" target="_top">Atomic Reverse Hessian Sparsity Patterns: Implementation.r</a><br/>
6603		<a href="atomic_for_sparse_jac.xml#Implementation.r" target="_top">Atomic Forward Jacobian Sparsity Patterns: Implementation.r</a><br/>
6604	5901	random <a href="uniform_01_c.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
6605	5902	<a href="uniform_01.xml" target="_top">Simulate a [0,1] Uniform Random Variate</a><br/>
6606	5903	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/>

6927	6224	SparseHessian <a href="sparse_hessian.xml" target="_top">Sparse Hessian: Easy Driver</a><br/>
6928	6225	SparseJacobian <a href="sparse_jacobian.xml" target="_top">Sparse Jacobian: Easy Driver</a><br/>
6929	6226	SpeedTest <a href="speedtest.xml" target="_top">Run One Speed Test and Print Results</a><br/>
6930		s <a href="elapsed_seconds_c.xml#s" target="_top">Returns Elapsed Number of Seconds: s</a><br/>
6931		<a href="old_atomic.xml#rev_hes_sparse.s" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.s</a><br/>
6932		<a href="old_atomic.xml#rev_jac_sparse.s" target="_top">User Defined Atomic AD Functions: rev_jac_sparse.s</a><br/>
6933		<a href="old_atomic.xml#for_jac_sparse.s" target="_top">User Defined Atomic AD Functions: for_jac_sparse.s</a><br/>
6934		<a href="microsoft_timer.xml#s" target="_top">Microsoft Version of Elapsed Number of Seconds: s</a><br/>
6935		<a href="to_string.xml#s" target="_top">Convert Certain Types to a String: s</a><br/>
6936		<a href="nan.xml#nan(zero).s" target="_top">Obtain Nan or Determine if a Value is Nan: nan(zero).s</a><br/>
6937		<a href="nan.xml#isnan.s" target="_top">Obtain Nan or Determine if a Value is Nan: isnan.s</a><br/>
6938		<a href="elapsed_seconds.xml#s" target="_top">Returns Elapsed Number of Seconds: s</a><br/>
6939		<a href="revsparsehes.xml#s" target="_top">Hessian Sparsity Pattern: Reverse Mode: s</a><br/>
6940		<a href="revsparsejac.xml#s" target="_top">Jacobian Sparsity Pattern: Reverse Mode: s</a><br/>
6941		<a href="forsparsejac.xml#s" target="_top">Jacobian Sparsity Pattern: Forward Mode: s</a><br/>
6942		<a href="size_order.xml#s" target="_top">Number Taylor Coefficient Orders Currently Stored: s</a><br/>
6943		<a href="forward_order.xml#s" target="_top">Multiple Order Forward Mode: s</a><br/>
6944		<a href="forward_zero.xml#s" target="_top">Zero Order Forward Mode: Function Values: s</a><br/>
6945		<a href="atomic_rev_sparse_hes.xml#Implementation.s" target="_top">Atomic Reverse Hessian Sparsity Patterns: Implementation.s</a><br/>
6946		<a href="atomic_for_sparse_jac.xml#Implementation.s" target="_top">Atomic Forward Jacobian Sparsity Patterns: Implementation.s</a><br/>
6947		<a href="ad_to_string.xml#s" target="_top">Convert An AD or Base Type to String: s</a><br/>
6948	6227	sacado <a href="sacado_sparse_jacobian.cpp.xml" target="_top">sacado Speed: sparse_jacobian</a><br/>
6949	6228	<a href="sacado_sparse_hessian.cpp.xml" target="_top">Sacado Speed: Sparse Hessian</a><br/>
6950	6229	<a href="sacado_poly.cpp.xml" target="_top">Sacado Speed: Second Derivative of a Polynomial</a><br/>

7678	6957	symbol <a href="faq.xml#Namespace.Test Vector Preprocessor Symbol" target="_top">Frequently Asked Questions and Answers: Namespace.Test Vector Preprocessor Symbol</a><br/>
7679	6958	symbols <a href="addon.xml#Preprocessor Symbols" target="_top">CppAD Addons: Preprocessor Symbols</a><br/>
7680	6959	<a href="preprocessor.xml" target="_top">CppAD API Preprocessor Symbols</a><br/>
7681		<a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
	6960	<a href="cppad.xml#Preprocessor Symbols" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms: Preprocessor Symbols</a><br/>
7682	6961	syntax <a href="luratio.xml#Syntax" target="_top">LU Factorization of A Square Matrix and Stability Calculation: Syntax</a><br/>
7683	6962	<a href="opt_val_hes.xml#Syntax" target="_top">Jacobian and Hessian of Optimal Values: Syntax</a><br/>
7684	6963	<a href="benderquad.xml#Syntax" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: Syntax</a><br/>

7879	7158	<a href="get_eigen.sh.xml#Syntax" target="_top">Download and Install Eigen in Build Directory: Syntax</a><br/>
7880	7159	<a href="get_colpack.sh.xml#Syntax" target="_top">Download and Install ColPack in Build Directory: Syntax</a><br/>
7881	7160	<a href="get_adolc.sh.xml#Syntax" target="_top">Download and Install Adolc in Build Directory: Syntax</a><br/>
7882		<a href="cppad.xml#Syntax" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms: Syntax</a><br/>
	7161	<a href="cppad.xml#Syntax" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms: Syntax</a><br/>
7883	7162	systems <a href="elapsed_seconds.xml#Microsoft Systems" target="_top">Returns Elapsed Number of Seconds: Microsoft Systems</a><br/>
7884	7163
7885	7164	<b><big><a name="T">T</a></big></b>
7886	7165	<br/>
7887	7166	Taylor <a href="ode_taylor.cpp.xml" target="_top">Taylor's Ode Solver: An Example and Test</a><br/>
7888		t <a href="old_atomic.xml#rev_hes_sparse.t" target="_top">User Defined Atomic AD Functions: rev_hes_sparse.t</a><br/>
7889		<a href="odegearcontrol.xml#Fun.t" target="_top">An Error Controller for Gear's Ode Solvers: Fun.t</a><br/>
7890		<a href="odegear.xml#T" target="_top">An Arbitrary Order Gear Method: T</a><br/>
7891		<a href="odegear.xml#Fun.t" target="_top">An Arbitrary Order Gear Method: Fun.t</a><br/>
7892		<a href="rosen34.xml#Fun.t" target="_top">A 3rd and 4th Order Rosenbrock ODE Solver: Fun.t</a><br/>
7893		<a href="runge45.xml#Fun.t" target="_top">An Embedded 4th and 5th Order Runge-Kutta ODE Solver: Fun.t</a><br/>
7894		<a href="atomic_rev_sparse_hes.xml#Implementation.t" target="_top">Atomic Reverse Hessian Sparsity Patterns: Implementation.t</a><br/>
7895	7167	tan <a href="old_tan.cpp.xml" target="_top">Old Tan and Tanh as User Atomic Operations: Example and Test</a><br/>
7896	7168	<a href="tan_reverse.xml" target="_top">Tangent and Hyperbolic Tangent Reverse Mode Theory</a><br/>
7897	7169	<a href="tan_forward.xml" target="_top">Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</a><br/>

8459	7731	<a href="speed_test.xml#Timing" target="_top">Run One Speed Test and Return Results: Timing</a><br/>
8460	7732	<a href="multi_newton_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Newton Method</a><br/>
8461	7733	<a href="harmonic_time.cpp.xml" target="_top">Timing Test of Multi-Threaded Summation of 1/i</a><br/>
8462		to <a href="time_det_by_minor_c.xml" target="_top">Determine Amount of Time to Execute det_by_minor</a><br/>
8463		<a href="old_usead_2.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
8464		<a href="old_usead_1.cpp.xml" target="_top">Using AD to Compute Atomic Function Derivatives</a><br/>
8465		<a href="cppad_ipopt_nlp.xml" target="_top">Nonlinear Programming Using the CppAD Interface to Ipopt</a><br/>
8466		<a href="omp_delete_array.xml" target="_top">Return A Raw Array to The Available Memory for a Thread</a><br/>
8467		<a href="omp_return_memory.xml" target="_top">Return Memory to omp_alloc</a><br/>
8468		<a href="include_deprecated.xml#Linking New Files to Deprecated Commands" target="_top">Deprecated Include Files: Linking New Files to Deprecated Commands</a><br/>
8469		<a href="whats_new_03.xml" target="_top">Changes and Additions to CppAD During 2003</a><br/>
8470		<a href="whats_new_04.xml" target="_top">Changes and Additions to CppAD During 2004</a><br/>
8471		<a href="whats_new_05.xml" target="_top">Changes and Additions to CppAD During 2005</a><br/>
8472		<a href="whats_new_06.xml" target="_top">Changes and Additions to CppAD During 2006</a><br/>
8473		<a href="whats_new_07.xml" target="_top">Changes and Additions to CppAD During 2007</a><br/>
8474		<a href="whats_new_08.xml" target="_top">Changes and Additions to CppAD During 2008</a><br/>
8475		<a href="whats_new_09.xml" target="_top">Changes and Additions to CppAD During 2009</a><br/>
8476		<a href="whats_new_10.xml" target="_top">Changes and Additions to CppAD During 2010</a><br/>
8477		<a href="whats_new_11.xml" target="_top">Changes and Additions to CppAD During 2011</a><br/>
8478		<a href="whats_new.xml" target="_top">Changes and Additions to CppAD</a><br/>
8479		<a href="interface2c.cpp.xml" target="_top">Interfacing to C: Example and Test</a><br/>
8480		<a href="eigen_det.cpp.xml" target="_top">Using Eigen To Compute Determinant: Example and Test</a><br/>
8481		<a href="ad_in_c.cpp.xml" target="_top">Example and Test Linking CppAD to Languages Other than C++</a><br/>
8482		<a href="ad_fun.cpp.xml" target="_top">Creating Your Own Interface to an ADFun Object</a><br/>
8483		<a href="ipopt_solve.xml" target="_top">Use Ipopt to Solve a Nonlinear Programming Problem</a><br/>
8484		<a href="to_string.xml" target="_top">Convert Certain Types to a String</a><br/>
8485		<a href="ta_return_memory.xml" target="_top">Return Memory to thread_alloc</a><br/>
8486		<a href="time_test.xml" target="_top">Determine Amount of Time to Execute a Test</a><br/>
8487		<a href="bool_sparsity.cpp.xml" target="_top">Using vectorBool Sparsity To Conserve Memory: Example and Test</a><br/>
8488		<a href="base_to_string.xml" target="_top">Extending to_string To Another Floating Point Type</a><br/>
8489		<a href="var2par.cpp.xml" target="_top">Convert an AD Variable to a Parameter: Example and Test</a><br/>
8490		<a href="var2par.xml" target="_top">Convert an AD Variable to a Parameter</a><br/>
8491		<a href="ad_to_string.xml" target="_top">Convert An AD or Base Type to String</a><br/>
8492		<a href="integer.cpp.xml" target="_top">Convert From AD to Integer: Example and Test</a><br/>
8493		<a href="integer.xml" target="_top">Convert From AD to Integer</a><br/>
8494		<a href="value.cpp.xml" target="_top">Convert From AD to its Base Type: Example and Test</a><br/>
8495		<a href="value.xml" target="_top">Convert From an AD Type to its Base Type</a><br/>
8496		<a href="get_started.cpp.xml" target="_top">Getting Started Using CppAD to Compute Derivatives</a><br/>
8497		<a href="introduction.xml" target="_top">An Introduction by Example to Algorithmic Differentiation</a><br/>
8498		<a href="cmake.xml" target="_top">Using CMake to Configure CppAD</a><br/>
8499	7734	to<b>_</b>string <a href="utility.xml#Miscellaneous.to_string" target="_top">Some General Purpose Utilities: Miscellaneous.to_string</a><br/>
8500	7735	<a href="base_complex.hpp.xml#to_string" target="_top">Enable use of AD<Base> where Base is std::complex<double>: to_string</a><br/>
8501	7736	<a href="base_double.hpp.xml#to_string" target="_top">Enable use of AD<Base> where Base is double: to_string</a><br/>

8945	8180	<a href="discrete.xml#Create AD Version" target="_top">Discrete AD Functions: Create AD Version</a><br/>
8946	8181	<a href="download.xml#Subversion.Current Version" target="_top">Download The CppAD Source Code: Subversion.Current Version</a><br/>
8947	8182	<a href="download.xml#Compressed Archives.Current Version" target="_top">Download The CppAD Source Code: Compressed Archives.Current Version</a><br/>
8948		<a href="cppad.xml" target="_top">cppad-20160000.0: A Package for Differentiation of C++ Algorithms</a><br/>
	8183	<a href="cppad.xml" target="_top">cppad-20160000.1: A Package for Differentiation of C++ Algorithms</a><br/>
8949	8184	version<b>)</b> <a href="double_mat_mul.cpp.xml" target="_top">CppAD Speed: Matrix Multiplication (Double Version)</a><br/>
8950	8185	versions <a href="download.xml#Subversion.Release Versions" target="_top">Download The CppAD Source Code: Subversion.Release Versions</a><br/>
8951	8186	<a href="download.xml#Subversion.Stable Versions" target="_top">Download The CppAD Source Code: Subversion.Stable Versions</a><br/>

9133	8368
9134	8369	<b><big><a name="Y">Y</a></big></b>
9135	8370	<br/>
9136		y <a href="opt_val_hes.xml#y" target="_top">Jacobian and Hessian of Optimal Values: y</a><br/>
9137		<a href="benderquad.xml#y" target="_top">Computing Jacobian and Hessian of Bender's Reduced Objective: y</a><br/>
9138		<a href="mat_sum_sq.xml#y" target="_top">Sum Elements of a Matrix Times Itself: y</a><br/>
9139		<a href="pow_int.xml#y" target="_top">The Integer Power Function: y</a><br/>
9140		<a href="checksimplevector.xml#x, y" target="_top">Check Simple Vector Concept: x, y</a><br/>
9141		<a href="nearequal.xml#y" target="_top">Determine if Two Values Are Nearly Equal: y</a><br/>
9142		<a href="funcheck.xml#y" target="_top">Check an ADFun Sequence of Operations: y</a><br/>
9143		<a href="dependent.xml#y" target="_top">Stop Recording and Store Operation Sequence: y</a><br/>
9144		<a href="funconstruct.xml#y" target="_top">Construct an ADFun Object and Stop Recording: y</a><br/>
9145		<a href="equalopseq.xml#y" target="_top">Check if Two Value are Identically Equal: y</a><br/>
9146		<a href="boolfun.xml#y" target="_top">AD Boolean Functions: y</a><br/>
9147		<a href="nearequalext.xml#y" target="_top">Compare AD and Base Objects for Nearly Equal: y</a><br/>
9148		<a href="compare.xml#y" target="_top">AD Binary Comparison Operators: y</a><br/>
9149		<a href="discrete.xml#y" target="_top">Discrete AD Functions: y</a><br/>
9150		<a href="pow.xml#y" target="_top">The AD Power Function: y</a><br/>
9151		<a href="atan2.xml#y" target="_top">AD Two Argument Inverse Tangent Function: y</a><br/>
9152		<a href="sign.xml#x, y" target="_top">The Sign: sign: x, y</a><br/>
9153		<a href="log1p.xml#x, y" target="_top">The Logarithm of One Plus Argument: log1p: x, y</a><br/>
9154		<a href="expm1.xml#x, y" target="_top">The Exponential Function Minus One: expm1: x, y</a><br/>
9155		<a href="erf.xml#x, y" target="_top">The Error Function: x, y</a><br/>
9156		<a href="atanh.xml#x, y" target="_top">The Inverse Hyperbolic Tangent Function: atanh: x, y</a><br/>
9157		<a href="asinh.xml#x, y" target="_top">The Inverse Hyperbolic Sine Function: asinh: x, y</a><br/>
9158		<a href="acosh.xml#x, y" target="_top">The Inverse Hyperbolic Cosine Function: acosh: x, y</a><br/>
9159		<a href="abs.xml#x, y" target="_top">AD Absolute Value Functions: abs, fabs: x, y</a><br/>
9160		<a href="tanh.xml#x, y" target="_top">The Hyperbolic Tangent Function: tanh: x, y</a><br/>
9161		<a href="tan.xml#x, y" target="_top">The Tangent Function: tan: x, y</a><br/>
9162		<a href="sqrt.xml#x, y" target="_top">The Square Root Function: sqrt: x, y</a><br/>
9163		<a href="sinh.xml#x, y" target="_top">The Hyperbolic Sine Function: sinh: x, y</a><br/>
9164		<a href="sin.xml#x, y" target="_top">The Sine Function: sin: x, y</a><br/>
9165		<a href="log10.xml#x, y" target="_top">The Base 10 Logarithm Function: log10: x, y</a><br/>
9166		<a href="log.xml#x, y" target="_top">The Exponential Function: log: x, y</a><br/>
9167		<a href="exp.xml#x, y" target="_top">The Exponential Function: exp: x, y</a><br/>
9168		<a href="cosh.xml#x, y" target="_top">The Hyperbolic Cosine Function: cosh: x, y</a><br/>
9169		<a href="cos.xml#x, y" target="_top">The Cosine Function: cos: x, y</a><br/>
9170		<a href="atan.xml#x, y" target="_top">Inverse Tangent Function: atan: x, y</a><br/>
9171		<a href="asin.xml#x, y" target="_top">Inverse Sine Function: asin: x, y</a><br/>
9172		<a href="acos.xml#x, y" target="_top">Inverse Sine Function: acos: x, y</a><br/>
9173		<a href="compute_assign.xml#y" target="_top">AD Computed Assignment Operators: y</a><br/>
9174		<a href="ad_binary.xml#y" target="_top">AD Binary Arithmetic Operators: y</a><br/>
9175		<a href="unaryminus.xml#y" target="_top">AD Unary Minus Operator: y</a><br/>
9176		<a href="unaryplus.xml#y" target="_top">AD Unary Plus Operator: y</a><br/>
9177		<a href="var2par.xml#y" target="_top">Convert an AD Variable to a Parameter: y</a><br/>
9178		<a href="ad_assign.xml#y" target="_top">AD Assignment Operator: y</a><br/>
9179		<a href="ad_ctor.xml#y" target="_top">AD Constructors: y</a><br/>
9180		<a href="exp_eps.xml#y" target="_top">An Epsilon Accurate Exponential Approximation: y</a><br/>
9181		<a href="exp_2.xml#y" target="_top">Second Order Exponential Approximation: y</a><br/>
9182	8371	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/>
9183	8372	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/>
9184	8373	<a href="forward_dir.xml#Y(t)" target="_top">Multiple Directions Forward Mode: Y(t)</a><br/>

+1

-1

doc/_reference.xml less more

227	227	<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>
228	228	<a href="cosh.xml" target="_top">cosh</a><br/> </td><td> The Hyperbolic Cosine Function: cosh </td></tr><tr valign="top"><td>
229	229	<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>
230		<a href="cppad.xml" target="_top">CppAD</a><br/> </td><td> cppad-20160000.0: A Package for Differentiation of C++ Algorithms </td></tr><tr valign="top"><td>
	230	<a href="cppad.xml" target="_top">CppAD</a><br/> </td><td> cppad-20160000.1: A Package for Differentiation of C++ Algorithms </td></tr><tr valign="top"><td>
231	231	<a href="cppad_assert.xml" target="_top">cppad_assert</a><br/> </td><td> CppAD Assertions During Execution </td></tr><tr valign="top"><td>
232	232	<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>
233	233	<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>

+16

-16

doc/_search.xml.js less more

0		// -------------------------------------------------------
1		// Copyright (C) Bradley M. Bell 2003, All rights reserved
2		// -------------------------------------------------------
	0	// ------------------------------------------------------------
	1	// Copyright (C) Bradley M. Bell 1998-2015, All rights reserved
	2	// ------------------------------------------------------------
3	3	Keyword =
4	4	[
5		'CppAD cppad-20160000.0: A Package for Differentiation of C++ Algorithms ',' algorithmic automatic derivative version cppad.hpp syntax introduction example include file preprocessor symbols namespace ',
	5	'CppAD cppad-20160000.1: A Package for Differentiation of C++ Algorithms ',' algorithmic automatic derivative version cppad.hpp syntax introduction example include file preprocessor symbols namespace ',
6	6	'Install CppAD Download, Test, and Install Instructions ',' step 1: 2: cmake 3: check 4: installation ',
7		'download Download The CppAD Source Code ',' purpose distribution directory compressed archives current version release versions monthly unix file extraction windows and testing install instructions subversion limitations stable ',
	7	'download Download The CppAD Source Code ',' purpose distribution directory compressed archives current version release versions monthly unix file extraction windows testing install instructions subversion limitations stable ',
8	8	'cmake Using CMake to Configure CppAD ',' makefile install prefix postfix include directories lib datadir documentation package compile flags profile maximum number threads sparsity internal structure vector sets memory usage tape implicit explicit the program command build directory cmake_verbose_makefile generator cppad_prefix cppad_postfix cmake_install_includedirs cmake_install_libdirs cmake_install_datadir cmake_install_docdir package_prefix cppad_cxx_flags c++11 cppad_profile_flag eigen fadbad cppad_testvector cppad_max_num_threads cppad_sparse_list cppad_tape_id_type cstdint cppad_tape_addr_type cppad_deprecated ',
9	9	'adolc_prefix Including the ADOL-C Examples and Tests ',' get purpose speed unix cygwin get_adolc ',
10	10	'get_adolc.sh Download and Install Adolc in Build Directory ',' syntax purpose requirements distribution external prefix reuse ',

181	181	'par_var.cpp AD Parameter and Variable Functions: Example and Test ',' ',
182	182	'EqualOpSeq Check if Two Value are Identically Equal ',' operation sequence syntax purpose motivation b example ',
183	183	'equal_op_seq.cpp EqualOpSeq: Example and Test ',' ',
184		'VecAD AD Vectors that Record Index Operations ',' tape reference vecad<base> syntax purpose alternatives vecad<base>::reference exceptions constructor size size_t indexing example speed and memory ',
	184	'VecAD AD Vectors that Record Index Operations ',' tape reference vecad<base> syntax purpose alternatives vecad<base>::reference exceptions constructor size size_t indexing example speed memory ',
185	185	'vec_ad.cpp AD Vectors that Record Index Operations: Example and Test ',' vecad ',
186	186	'base_require AD<Base> Requirements for a CppAD Base Type ',' syntax purpose api warning standard types include order numeric output operator integer suggestion absolute zero azmul ',
187	187	'base_member Required Base Class Member Functions ',' notation default constructor double copy unary operators assignment binary bool example ',

292	292	'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 ',
293	293	'team_openmp.cpp OpenMP Implementation of a Team of AD Threads ',' ',
294	294	'team_bthread.cpp Boost Thread Implementation of a Team of AD Threads ',' ',
295		'team_pthread.cpp Pthread Implementation of a Team of AD Threads ',' pthread_exit bug in cygwin ',
	295	'team_pthread.cpp Pthread Implementation of a Team of AD Threads ',' pthread_exit bug cygwin ',
296	296	'utility Some General Purpose Utilities ',' testing c++ concepts numerical routines miscellaneous error handler simple vector template class multi-threading memory allocation sorting indices to_string ',
297	297	'ErrorHandler Replacing the CppAD Error Handler ',' replace assert exception syntax constructor parallel mode call info known line file exp msg example ',
298	298	'error_handler.cpp Replacing The CppAD Error Handler: Example and Test ',' ',

311	311	'numeric_type.cpp The NumericType: Example and Test ',' ',
312	312	'CheckNumericType Check NumericType Class Concept ',' syntax purpose include parallel mode example ',
313	313	'check_numeric_type.cpp The CheckNumericType Function: Example and Test ',' ',
314		'SimpleVector Definition of a Simple Vector ',' value_type [] ndebug template class requirements elements specified default constructor sizing copy and destructor assignment size resize access using example exercise ',
	314	'SimpleVector Definition of a Simple Vector ',' value_type [] ndebug template class requirements elements specified default constructor sizing copy destructor assignment size resize access using example exercise ',
315	315	'simple_vector.cpp Simple Vector Template Class: Example and Test ',' ',
316	316	'CheckSimpleVector Check Simple Vector Concept ',' syntax purpose restrictions include parallel mode example ',
317	317	'check_simple_vector.cpp The CheckSimpleVector Function: Example and Test ',' ',

348	348	'ode_gear.cpp OdeGear: Example and Test ',' ',
349	349	'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 ',
350	350	'ode_gear_control.cpp OdeGearControl: Example and Test ',' ',
351		'CppAD_vector The CppAD::vector Template Class ',' [] push thread_alloc syntax description include capacity assignment check size return reference move semantics element access push_back push_vector output resize clear data vectorbool memory bit_per_unit type and parallel mode example exercise ',
	351	'CppAD_vector The CppAD::vector Template Class ',' [] push thread_alloc syntax description include capacity assignment check size return reference move semantics element access push_back push_vector output resize clear data vectorbool memory bit_per_unit type parallel mode example exercise ',
352	352	'cppad_vector.cpp CppAD::vector Template Class: Example and Test ',' ',
353	353	'vector_bool.cpp CppAD::vectorBool Class: Example and Test ',' ',
354	354	'thread_alloc A Fast Multi-Threading Memory Allocator ',' allocation syntax purpose include ',

394	394	'mul_level.cpp Multiple Level of AD: Example and Test ',' purpose source ',
395	395	'change_param.cpp Computing a Jacobian With Constants that Change ',' multiple ad level purpose ',
396	396	'ode_stiff.cpp A Stiff Ode: Example and Test ',' ',
397		'mul_level_ode.cpp Taylor\'s Ode Solver: A Multi-Level AD Example and Test ',' purpose solution derivative of method using source ',
398		'mul_level_adolc_ode.cpp Taylor\'s Ode Solver: A Multi-Level Adolc Example and Test ',' purpose solution derivative of method using base_adolc.hpp memory management configuration requirement source ',
	397	'mul_level_ode.cpp Taylor\'s Ode Solver: A Multi-Level AD Example and Test ',' purpose solution derivative method using source ',
	398	'mul_level_adolc_ode.cpp Taylor\'s Ode Solver: A Multi-Level Adolc Example and Test ',' purpose solution derivative method using base_adolc.hpp memory management configuration requirement source ',
399	399	'ode_taylor.cpp Taylor\'s Ode Solver: An Example and Test ',' purpose solution forward mode ',
400	400	'stack_machine.cpp Example Differentiating a Stack Machine Interpreter ',' test ',
401	401	'example.cpp CppAD Examples and Tests ',' running ',

506	506	'tan_reverse Tangent and Hyperbolic Tangent Reverse Mode Theory ',' notation eliminating y(t) positive orders z(t) zero ',
507	507	'erf_reverse Error Function Reverse Mode Theory ',' notation positive orders z(t) zero ',
508	508	'reverse_identity An Important Reverse Mode Identity ',' notation sweep theorem proof ',
509		'glossary Glossary ',' efficient ad function of base type above elementary vector operation atomic sequence dependent independent parameter sparsity pattern boolean sets tape active inactive variable variables taylor coefficient ',
510		'Bib Bibliography ',' abramowitz and stegun the c++ programming language evaluating derivatives numerical recipes shampine l.f. ',
511		'wish_list The CppAD Wish List ',' base requirements printfor optimization checkpoint machine epsilon examples adolc optimizing nested conditional expressions forward mode recomputation iterator interface compilation speed operation sequence comparison changes and software guidelines tracing atan2 benderquad ',
	509	'glossary Glossary ',' efficient ad function base type above elementary vector operation atomic sequence dependent independent parameter sparsity pattern boolean sets tape active inactive variable variables taylor coefficient ',
	510	'Bib Bibliography ',' abramowitz stegun the c++ programming language evaluating derivatives numerical recipes shampine l.f. ',
	511	'wish_list The CppAD Wish List ',' base requirements printfor optimization checkpoint machine epsilon examples adolc optimizing nested conditional expressions forward mode recomputation iterator interface compilation speed operation sequence comparison changes software guidelines tracing atan2 benderquad ',
512	512	'whats_new Changes and Additions to CppAD ',' introduction this year previous years ',
513	513	'whats_new_15 CppAD Changes and Additions During 2015 ',' introduction 12-29 12-28 12-08 12-01 11-30 11-25 11-24 11-14 11-08 11-06 10-21 10-16 10-06 10-04 10-03 10-02 09-28 09-27 09-25 09-24 09-23 09-21 09-20 09-19 09-16 09-03 09-02 08-31 08-30 08-29 08-28 08-26 08-25 08-20 08-17 08-16 08-09 08-06 07-31 06-16 06-11 06-09 06-07 05-26 cond_exp_1 cond_exp_2 05-11 05-10 05-09 05-08 05-07 05-05 04-18 03-13 03-06 02-28 02-18 02-16 02-14 02-11 02-10 02-09 02-07 02-06 02-04 02-03 02-02 01-30 01-29 01-26 01-23 01-21 01-20 01-09 01-07 01-02 ',
514	514	'whats_new_14 CppAD Changes and Additions During 2014 ',' introduction 12-30 12-29 12-28 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 ',

550	550	'cppad_ipopt_nlp Nonlinear Programming Using the CppAD Interface to Ipopt ',' deprecated 2012-11-28 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 ',
551	551	'ipopt_nlp_get_started.cpp Nonlinear Programming Using CppAD and Ipopt: Example and Test ',' purpose configuration requirement ',
552	552	'ipopt_nlp_ode Example Simultaneous Solution of Forward and Inverse Problem ',' ',
553		'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 ',
	553	'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 iteration derivatives simultaneous source ',
554	554	'ipopt_nlp_ode_simple ODE Fitting Using Simple Representation ',' cppad_ipopt_nlp purpose argument vector objective function initial condition constraint trapezoidal approximation source ',
555	555	'ipopt_nlp_ode_fast ODE Fitting Using Fast Representation ',' purpose objective function range indices i(k0) domain j(k0) initial condition trapezoidal approximation source ',
556	556	'ipopt_nlp_ode_problem.hpp ODE Inverse Problem Definitions: Source Code ',' example ',

566	566	'old_tan.cpp Old Tan and Tanh as User Atomic Operations: Example and Test ',' deprecated 2013-05-27 theory ',
567	567	'old_mat_mul.cpp Old Matrix Multiply as a User Atomic Operation: Example and Test ',' deprecated 2013-05-27 include file ',
568	568	'old_mat_mul.hpp Define Matrix Multiply as a User Atomic Operation ',' old_atomic test syntax example begin source extra call information indexing one reverse partials order set union cppad callback functions declare ',
569		'zdouble zdouble: An AD Base Type With Absolute Zero ',' deprecated 2015-09-26 syntax constructor and assignment comparison operators arithmetic standard math nan motivation general cppad requirements example ',
	569	'zdouble zdouble: An AD Base Type With Absolute Zero ',' deprecated 2015-09-26 syntax constructor assignment comparison operators arithmetic standard math nan motivation general cppad requirements example ',
570	570	'zdouble.cpp zdouble: Example and Test ',' ',
571	571	'compare_c Compare Speed of C and C++ ',' with syntax purpose ',
572	572	'det_of_minor_c Determinant of a Minor ',' syntax purpose source code ',

+1

-1

doc/a11c_bthread.cpp.xml less more

5	5	<title>A Simple Boost Thread Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Simple Boost Thread Example and Test"/>
8		<meta name="keywords" id="keywords" content=" a simple boost thread example and test A.1.1c purpose source code "/>
	8	<meta name="keywords" id="keywords" content=" simple boost thread example test A.1.1c purpose source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/a11c_openmp.cpp.xml less more

5	5	<title>A Simple OpenMP Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Simple OpenMP Example and Test"/>
8		<meta name="keywords" id="keywords" content=" a simple openmp example and test A.1.1c thread purpose source code "/>
	8	<meta name="keywords" id="keywords" content=" simple openmp example test A.1.1c thread purpose source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/a11c_pthread.cpp.xml less more

5	5	<title>A Simple Parallel Pthread Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Simple Parallel Pthread Example and Test"/>
8		<meta name="keywords" id="keywords" content=" a simple parallel pthread example and test Openmp A.1.1c thread purpose source code "/>
	8	<meta name="keywords" id="keywords" content=" simple parallel pthread example test Openmp A.1.1c thread purpose source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/abort_recording.cpp.xml less more

5	5	<title>Abort Current Recording: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Abort Current Recording: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" abort current recording: example and test recording "/>
	8	<meta name="keywords" id="keywords" content=" abort current recording: example test recording "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/abort_recording.xml less more

5	5	<title>Abort Recording of an Operation Sequence</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Abort Recording of an Operation Sequence"/>
8		<meta name="keywords" id="keywords" content=" abort recording of an operation sequence tape syntax purpose example "/>
	8	<meta name="keywords" id="keywords" content=" abort recording operation sequence tape syntax purpose example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/abs.cpp.xml less more

5	5	<title>AD Absolute Value Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Absolute Value Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad absolute value function: example and test abs fabs "/>
	8	<meta name="keywords" id="keywords" content=" ad absolute value function: example test abs fabs "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/acos.cpp.xml less more

5	5	<title>The AD acos Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD acos Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad acos function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad acos function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/acos_forward.xml less more

5	5	<title>Inverse Cosine and Hyperbolic Cosine Forward Mode Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Inverse Cosine and Hyperbolic Cosine Forward Mode Theory"/>
8		<meta name="keywords" id="keywords" content=" inverse cosine and hyperbolic forward mode theory acos acosh derivatives taylor coefficients recursion "/>
	8	<meta name="keywords" id="keywords" content=" inverse cosine hyperbolic forward mode theory acos acosh derivatives taylor coefficients recursion "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/acos_reverse.xml less more

5	5	<title>Inverse Cosine and Hyperbolic Cosine Reverse Mode Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Inverse Cosine and Hyperbolic Cosine Reverse Mode Theory"/>
8		<meta name="keywords" id="keywords" content=" inverse cosine and hyperbolic reverse mode theory acos acosh "/>
	8	<meta name="keywords" id="keywords" content=" inverse cosine hyperbolic reverse mode theory acos acosh "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/acosh.cpp.xml less more

5	5	<title>The AD acosh Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD acosh Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad acosh function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad acosh function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ad_assign.cpp.xml less more

5	5	<title>AD Assignment: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Assignment: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad assignment: example and test assign object "/>
	8	<meta name="keywords" id="keywords" content=" ad assignment: example test assign object "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ad_ctor.cpp.xml less more

5	5	<title>AD Constructors: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Constructors: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad constructors: example and test constructor object "/>
	8	<meta name="keywords" id="keywords" content=" ad constructors: example test constructor object "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ad_fun.cpp.xml less more

5	5	<title>Creating Your Own Interface to an ADFun Object</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Creating Your Own Interface to an ADFun Object"/>
8		<meta name="keywords" id="keywords" content=" creating your own interface to an adfun object example test "/>
	8	<meta name="keywords" id="keywords" content=" creating your own interface to adfun object example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ad_in_c.cpp.xml less more

5	5	<title>Example and Test Linking CppAD to Languages Other than C++</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Example and Test Linking CppAD to Languages Other than C++"/>
8		<meta name="keywords" id="keywords" content=" example and test linking cppad to languages other than c++ C Ad algorithmic differentiation automatic link "/>
	8	<meta name="keywords" id="keywords" content=" example test linking cppad to languages other than c++ C Ad algorithmic differentiation automatic link "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ad_input.cpp.xml less more

5	5	<title>AD Output Operator: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Output Operator: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad output operator: example and test << input "/>
	8	<meta name="keywords" id="keywords" content=" ad output operator: example test << input "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ad_output.cpp.xml less more

5	5	<title>AD Output Operator: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Output Operator: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad output operator: example and test << "/>
	8	<meta name="keywords" id="keywords" content=" ad output operator: example test << "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ad_to_string.xml less more

5	5	<title>Convert An AD or Base Type to String</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Convert An AD or Base Type to String"/>
8		<meta name="keywords" id="keywords" content=" convert an ad or base type to string syntax see also value s example "/>
	8	<meta name="keywords" id="keywords" content=" convert ad base type to string syntax see also value s example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/add.cpp.xml less more

5	5	<title>AD Binary Addition: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Binary Addition: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad binary addition: example and test + add plus "/>
	8	<meta name="keywords" id="keywords" content=" ad binary addition: example test + add plus "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/addeq.cpp.xml less more

5	5	<title>AD Computed Assignment Addition: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Computed Assignment Addition: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad computed assignment addition: example and test += add assign plus "/>
	8	<meta name="keywords" id="keywords" content=" ad computed assignment addition: example test += add assign plus "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-4

doc/adolc_alloc_mat.xml less more

5	5	<title>Adolc Test Utility: Allocate and Free Memory For a Matrix</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Adolc Test Utility: Allocate and Free Memory For a 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	<meta name="keywords" id="keywords" content=" adolc test utility: allocate free memory matrix adolc_alloc_mat alloc syntax purpose m n mat "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

95	95	</select>
96	96	</td>
97	97	</tr></table><br/>
98
99
100
101	98	<center><b><big><big>Adolc Test Utility: Allocate and Free Memory For a Matrix</big></big></b></center>
102	99	<br/>
103	100	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

+82

-86

doc/adolc_det_lu.cpp.xml less more

5	5	<title>Adolc Speed: Gradient of Determinant Using Lu Factorization</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Adolc Speed: Gradient of Determinant Using Lu Factorization"/>
8		<meta name="keywords" id="keywords" content=" adolc speed: gradient of determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: gradient determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

92	92	</select>
93	93	</td>
94	94	</tr></table><br/>
95
96
97
98	95	<center><b><big><big>Adolc Speed: Gradient of Determinant Using Lu Factorization</big></big></b></center>
99	96	<br/>
100	97	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

117	114	extern bool global_memory, global_onetape, global_atomic, global_optimize;
118	115
119	116	bool link_det_lu(
120		size_t size ,
121		size_t repeat ,
122		CppAD::vector<double> &matrix ,
123		CppAD::vector<double> &gradient )
	117	size_t size ,
	118	size_t repeat ,
	119	CppAD::vector<double> &matrix ,
	120	CppAD::vector<double> &gradient )
124	121	{
125		// speed test global option values
126		if( global_onetape \|\| global_atomic )
127		return false;
128		if( global_memory \|\| global_optimize )
129		return false;
130		// -----------------------------------------------------
131		// setup
132		int tag = 0; // tape identifier
133		int keep = 1; // keep forward mode results in buffer
134		int m = 1; // number of dependent variables
135		int n = size*size; // number of independent variables
136		double f; // function value
137		int j; // temporary index
138
139		// set up for thread_alloc memory allocator (fast and checks for leaks)
140		using CppAD::thread_alloc; // the allocator
141		size_t size_min; // requested number of elements
142		size_t size_out; // capacity of an allocation
143
144		// object for computing determinant
145		typedef adouble ADScalar;
146		typedef ADScalar* ADVector;
147		CppAD::det_by_lu<ADScalar> Det(size);
148
149		// AD value of determinant
150		ADScalar detA;
151
152		// AD version of matrix
153		size_min = n;
154		ADVector A = thread_alloc::create_array<ADScalar>(size_min, size_out);
155
156		// vectors of reverse mode weights
157		size_min = m;
158		double* u = thread_alloc::create_array<double>(size_min, size_out);
159		u[0] = 1.;
160
161		// vector with matrix value
162		size_min = n;
163		double* mat = thread_alloc::create_array<double>(size_min, size_out);
164
165		// vector to receive gradient result
166		size_min = n;
167		double* grad = thread_alloc::create_array<double>(size_min, size_out);
168		// ------------------------------------------------------
169		while(repeat--)
170		{ // get the next matrix
171		CppAD::uniform_01(n, mat);
172
173		// declare independent variables
174		trace_on(tag, keep);
175		for(j = 0; j < n; j++)
176		A[j] <<= mat[j];
177
178		// AD computation of the determinant
179		detA = Det(A);
180
181		// create function object f : A -> detA
182		detA >>= f;
183		trace_off();
184
185		// evaluate and return gradient using reverse mode
186		fos_reverse(tag, m, n, u, grad);
187		}
188		// ------------------------------------------------------
189
190		// return matrix and gradient
191		for(j = 0; j < n; j++)
192		{ matrix[j] = mat[j];
193		gradient[j] = grad[j];
194		}
195		// tear down
196		thread_alloc::delete_array(grad);
197		thread_alloc::delete_array(mat);
198		thread_alloc::delete_array(u);
199		thread_alloc::delete_array(A);
200
201		return true;
	122	// speed test global option values
	123	if( global_onetape \|\| global_atomic )
	124	return false;
	125	if( global_memory \|\| global_optimize )
	126	return false;
	127	// -----------------------------------------------------
	128	// setup
	129	int tag = 0; // tape identifier
	130	int keep = 1; // keep forward mode results in buffer
	131	int m = 1; // number of dependent variables
	132	int n = size*size; // number of independent variables
	133	double f; // function value
	134	int j; // temporary index
	135
	136	// set up for thread_alloc memory allocator (fast and checks for leaks)
	137	using CppAD::thread_alloc; // the allocator
	138	size_t size_min; // requested number of elements
	139	size_t size_out; // capacity of an allocation
	140
	141	// object for computing determinant
	142	typedef adouble ADScalar;
	143	typedef ADScalar* ADVector;
	144	CppAD::det_by_lu<ADScalar> Det(size);
	145
	146	// AD value of determinant
	147	ADScalar detA;
	148
	149	// AD version of matrix
	150	size_min = n;
	151	ADVector A = thread_alloc::create_array<ADScalar>(size_min, size_out);
	152
	153	// vectors of reverse mode weights
	154	size_min = m;
	155	double* u = thread_alloc::create_array<double>(size_min, size_out);
	156	u[0] = 1.;
	157
	158	// vector with matrix value
	159	size_min = n;
	160	double* mat = thread_alloc::create_array<double>(size_min, size_out);
	161
	162	// vector to receive gradient result
	163	size_min = n;
	164	double* grad = thread_alloc::create_array<double>(size_min, size_out);
	165	// ------------------------------------------------------
	166	while(repeat--)
	167	{ // get the next matrix
	168	CppAD::uniform_01(n, mat);
	169
	170	// declare independent variables
	171	trace_on(tag, keep);
	172	for(j = 0; j < n; j++)
	173	A[j] <<= mat[j];
	174
	175	// AD computation of the determinant
	176	detA = Det(A);
	177
	178	// create function object f : A -> detA
	179	detA >>= f;
	180	trace_off();
	181
	182	// evaluate and return gradient using reverse mode
	183	fos_reverse(tag, m, n, u, grad);
	184	}
	185	// ------------------------------------------------------
	186
	187	// return matrix and gradient
	188	for(j = 0; j < n; j++)
	189	{ matrix[j] = mat[j];
	190	gradient[j] = grad[j];
	191	}
	192	// tear down
	193	thread_alloc::delete_array(grad);
	194	thread_alloc::delete_array(mat);
	195	thread_alloc::delete_array(u);
	196	thread_alloc::delete_array(A);
	197
	198	return true;
202	199	}
203	200	</pre></font></code>
204	201
205
206	202	<hr/>Input File: speed/adolc/det_lu.cpp
207	203
208	204	</body>

+109

-110

doc/adolc_det_minor.cpp.xml less more

5	5	<title>Adolc Speed: Gradient of Determinant by Minor Expansion</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Adolc Speed: Gradient of Determinant by Minor Expansion"/>
8		<meta name="keywords" id="keywords" content=" adolc speed: gradient of determinant by minor expansion link_det_minor speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: gradient determinant minor expansion link_det_minor speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

113	113	extern bool global_memory, global_onetape, global_atomic, global_optimize;
114	114
115	115	bool link_det_minor(
116		size_t size ,
117		size_t repeat ,
118		CppAD::vector<double> &matrix ,
119		CppAD::vector<double> &gradient )
	116	size_t size ,
	117	size_t repeat ,
	118	CppAD::vector<double> &matrix ,
	119	CppAD::vector<double> &gradient )
120	120	{
121		// speed test global option values
122		if( global_atomic )
123		return false;
124		if( global_memory \|\| global_optimize )
125		return false;
126		// -----------------------------------------------------
127		// setup
128		typedef adouble ADScalar;
129		typedef ADScalar* ADVector;
130
131		int tag = 0; // tape identifier
132		int m = 1; // number of dependent variables
133		int n = size*size; // number of independent variables
134		double f; // function value
135		int j; // temporary index
136
137		// set up for thread_alloc memory allocator (fast and checks for leaks)
138		using CppAD::thread_alloc; // the allocator
139		size_t capacity; // capacity of an allocation
140
141		// object for computing determinant
142		CppAD::det_by_minor<ADScalar> Det(size);
143
144		// AD value of determinant
145		ADScalar detA;
146
147		// AD version of matrix
148		ADVector A = thread_alloc::create_array<ADScalar>(size_t(n), capacity);
149
150		// vectors of reverse mode weights
151		double* u = thread_alloc::create_array<double>(size_t(m), capacity);
152		u[0] = 1.;
153
154		// vector with matrix value
155		double* mat = thread_alloc::create_array<double>(size_t(n), capacity);
156
157		// vector to receive gradient result
158		double* grad = thread_alloc::create_array<double>(size_t(n), capacity);
159
160		// ----------------------------------------------------------------------
161		if( ! global_onetape ) while(repeat--)
162		{ // choose a matrix
163		CppAD::uniform_01(n, mat);
164
165		// declare independent variables
166		int keep = 1; // keep forward mode results
167		trace_on(tag, keep);
168		for(j = 0; j < n; j++)
169		A[j] <<= mat[j];
170
171		// AD computation of the determinant
172		detA = Det(A);
173
174		// create function object f : A -> detA
175		detA >>= f;
176		trace_off();
177
178		// evaluate and return gradient using reverse mode
179		fos_reverse(tag, m, n, u, grad);
180		}
181		else
182		{
183		// choose a matrix
184		CppAD::uniform_01(n, mat);
185
186		// declare independent variables
187		int keep = 0; // do not keep forward mode results in buffer
188		trace_on(tag, keep);
189		for(j = 0; j < n; j++)
190		A[j] <<= mat[j];
191
192		// AD computation of the determinant
193		detA = Det(A);
194
195		// create function object f : A -> detA
196		detA >>= f;
197		trace_off();
198
199		while(repeat--)
200		{ // get the next matrix
201		CppAD::uniform_01(n, mat);
202
203		// evaluate the determinant at the new matrix value
204		keep = 1; // keep this forward mode result
205		zos_forward(tag, m, n, keep, mat, &f);
206
207		// evaluate and return gradient using reverse mode
208		fos_reverse(tag, m, n, u, grad);
209		}
210		}
211		// --------------------------------------------------------------------
212
213		// return matrix and gradient
214		for(j = 0; j < n; j++)
215		{ matrix[j] = mat[j];
216		gradient[j] = grad[j];
217		}
218
219		// tear down
220		thread_alloc::delete_array(grad);
221		thread_alloc::delete_array(mat);
222		thread_alloc::delete_array(u);
223		thread_alloc::delete_array(A);
224		return true;
	121	// speed test global option values
	122	if( global_atomic )
	123	return false;
	124	if( global_memory \|\| global_optimize )
	125	return false;
	126	// -----------------------------------------------------
	127	// setup
	128	typedef adouble ADScalar;
	129	typedef ADScalar* ADVector;
	130
	131	int tag = 0; // tape identifier
	132	int m = 1; // number of dependent variables
	133	int n = size*size; // number of independent variables
	134	double f; // function value
	135	int j; // temporary index
	136
	137	// set up for thread_alloc memory allocator (fast and checks for leaks)
	138	using CppAD::thread_alloc; // the allocator
	139	size_t capacity; // capacity of an allocation
	140
	141	// object for computing determinant
	142	CppAD::det_by_minor<ADScalar> Det(size);
	143
	144	// AD value of determinant
	145	ADScalar detA;
	146
	147	// AD version of matrix
	148	ADVector A = thread_alloc::create_array<ADScalar>(size_t(n), capacity);
	149
	150	// vectors of reverse mode weights
	151	double* u = thread_alloc::create_array<double>(size_t(m), capacity);
	152	u[0] = 1.;
	153
	154	// vector with matrix value
	155	double* mat = thread_alloc::create_array<double>(size_t(n), capacity);
	156
	157	// vector to receive gradient result
	158	double* grad = thread_alloc::create_array<double>(size_t(n), capacity);
	159
	160	// ----------------------------------------------------------------------
	161	if( ! global_onetape ) while(repeat--)
	162	{ // choose a matrix
	163	CppAD::uniform_01(n, mat);
	164
	165	// declare independent variables
	166	int keep = 1; // keep forward mode results
	167	trace_on(tag, keep);
	168	for(j = 0; j < n; j++)
	169	A[j] <<= mat[j];
	170
	171	// AD computation of the determinant
	172	detA = Det(A);
	173
	174	// create function object f : A -> detA
	175	detA >>= f;
	176	trace_off();
	177
	178	// evaluate and return gradient using reverse mode
	179	fos_reverse(tag, m, n, u, grad);
	180	}
	181	else
	182	{
	183	// choose a matrix
	184	CppAD::uniform_01(n, mat);
	185
	186	// declare independent variables
	187	int keep = 0; // do not keep forward mode results in buffer
	188	trace_on(tag, keep);
	189	for(j = 0; j < n; j++)
	190	A[j] <<= mat[j];
	191
	192	// AD computation of the determinant
	193	detA = Det(A);
	194
	195	// create function object f : A -> detA
	196	detA >>= f;
	197	trace_off();
	198
	199	while(repeat--)
	200	{ // get the next matrix
	201	CppAD::uniform_01(n, mat);
	202
	203	// evaluate the determinant at the new matrix value
	204	keep = 1; // keep this forward mode result
	205	zos_forward(tag, m, n, keep, mat, &f);
	206
	207	// evaluate and return gradient using reverse mode
	208	fos_reverse(tag, m, n, u, grad);
	209	}
	210	}
	211	// --------------------------------------------------------------------
	212
	213	// return matrix and gradient
	214	for(j = 0; j < n; j++)
	215	{ matrix[j] = mat[j];
	216	gradient[j] = grad[j];
	217	}
	218
	219	// tear down
	220	thread_alloc::delete_array(grad);
	221	thread_alloc::delete_array(mat);
	222	thread_alloc::delete_array(u);
	223	thread_alloc::delete_array(A);
	224	return true;
225	225	}
226	226	</pre></font></code>
227	227
228
229	228	<hr/>Input File: speed/adolc/det_minor.cpp
230	229
231	230	</body>

+108

-112

doc/adolc_mat_mul.cpp.xml less more

92	92	</select>
93	93	</td>
94	94	</tr></table><br/>
95
96
97
98	95	<center><b><big><big>Adolc Speed: Matrix Multiplication</big></big></b></center>
99	96	<br/>
100	97	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

118	115	extern bool global_memory, global_onetape, global_atomic, global_optimize;
119	116
120	117	bool link_mat_mul(
121		size_t size ,
122		size_t repeat ,
123		CppAD::vector<double>& x ,
124		CppAD::vector<double>& z ,
125		CppAD::vector<double>& dz )
	118	size_t size ,
	119	size_t repeat ,
	120	CppAD::vector<double>& x ,
	121	CppAD::vector<double>& z ,
	122	CppAD::vector<double>& dz )
126	123	{
127		// speed test global option values
128		if( global_memory \|\| global_atomic \|\| global_optimize )
129		return false;
130		// -----------------------------------------------------
131		// setup
132		typedef adouble ADScalar;
133		typedef ADScalar* ADVector;
134
135		int tag = 0; // tape identifier
136		int m = 1; // number of dependent variables
137		int n = size*size; // number of independent variables
138		double f; // function value
139		int j; // temporary index
140
141		// set up for thread_alloc memory allocator (fast and checks for leaks)
142		using CppAD::thread_alloc; // the allocator
143		size_t capacity; // capacity of an allocation
144
145		// AD domain space vector
146		ADVector X = thread_alloc::create_array<ADScalar>(size_t(n), capacity);
147
148		// Product matrix
149		ADVector Y = thread_alloc::create_array<ADScalar>(size_t(n), capacity);
150
151		// AD range space vector
152		ADVector Z = thread_alloc::create_array<ADScalar>(size_t(m), capacity);
153
154		// vector with matrix value
155		double* mat = thread_alloc::create_array<double>(size_t(n), capacity);
156
157		// vector of reverse mode weights
158		double* u = thread_alloc::create_array<double>(size_t(m), capacity);
159		u[0] = 1.;
160
161		// gradient
162		double* grad = thread_alloc::create_array<double>(size_t(n), capacity);
163
164		// ----------------------------------------------------------------------
165		if( ! global_onetape ) while(repeat--)
166		{ // choose a matrix
167		CppAD::uniform_01(n, mat);
168
169		// declare independent variables
170		int keep = 1; // keep forward mode results
171		trace_on(tag, keep);
172		for(j = 0; j < n; j++)
173		X[j] <<= mat[j];
174
175		// do computations
176		CppAD::mat_sum_sq(size, X, Y, Z);
177
178		// create function object f : X -> Z
179		Z[0] >>= f;
180		trace_off();
181
182		// evaluate and return gradient using reverse mode
183		fos_reverse(tag, m, n, u, grad);
184		}
185		else
186		{ // choose a matrix
187		CppAD::uniform_01(n, mat);
188
189		// declare independent variables
190		int keep = 0; // do not keep forward mode results
191		trace_on(tag, keep);
192		for(j = 0; j < n; j++)
193		X[j] <<= mat[j];
194
195		// do computations
196		CppAD::mat_sum_sq(size, X, Y, Z);
197
198		// create function object f : X -> Z
199		Z[0] >>= f;
200		trace_off();
201
202		while(repeat--)
203		{ // choose a matrix
204		CppAD::uniform_01(n, mat);
205
206		// evaluate the determinant at the new matrix value
207		keep = 1; // keep this forward mode result
208		zos_forward(tag, m, n, keep, mat, &f);
209
210		// evaluate and return gradient using reverse mode
211		fos_reverse(tag, m, n, u, grad);
212		}
213		}
214		// return function, matrix, and gradient
215		z[0] = f;
216		for(j = 0; j < n; j++)
217		{ x[j] = mat[j];
218		dz[j] = grad[j];
219		}
220
221		// tear down
222		thread_alloc::delete_array(X);
223		thread_alloc::delete_array(Y);
224		thread_alloc::delete_array(Z);
225		thread_alloc::delete_array(mat);
226		thread_alloc::delete_array(u);
227		thread_alloc::delete_array(grad);
228
229		return true;
	124	// speed test global option values
	125	if( global_memory \|\| global_atomic \|\| global_optimize )
	126	return false;
	127	// -----------------------------------------------------
	128	// setup
	129	typedef adouble ADScalar;
	130	typedef ADScalar* ADVector;
	131
	132	int tag = 0; // tape identifier
	133	int m = 1; // number of dependent variables
	134	int n = size*size; // number of independent variables
	135	double f; // function value
	136	int j; // temporary index
	137
	138	// set up for thread_alloc memory allocator (fast and checks for leaks)
	139	using CppAD::thread_alloc; // the allocator
	140	size_t capacity; // capacity of an allocation
	141
	142	// AD domain space vector
	143	ADVector X = thread_alloc::create_array<ADScalar>(size_t(n), capacity);
	144
	145	// Product matrix
	146	ADVector Y = thread_alloc::create_array<ADScalar>(size_t(n), capacity);
	147
	148	// AD range space vector
	149	ADVector Z = thread_alloc::create_array<ADScalar>(size_t(m), capacity);
	150
	151	// vector with matrix value
	152	double* mat = thread_alloc::create_array<double>(size_t(n), capacity);
	153
	154	// vector of reverse mode weights
	155	double* u = thread_alloc::create_array<double>(size_t(m), capacity);
	156	u[0] = 1.;
	157
	158	// gradient
	159	double* grad = thread_alloc::create_array<double>(size_t(n), capacity);
	160
	161	// ----------------------------------------------------------------------
	162	if( ! global_onetape ) while(repeat--)
	163	{ // choose a matrix
	164	CppAD::uniform_01(n, mat);
	165
	166	// declare independent variables
	167	int keep = 1; // keep forward mode results
	168	trace_on(tag, keep);
	169	for(j = 0; j < n; j++)
	170	X[j] <<= mat[j];
	171
	172	// do computations
	173	CppAD::mat_sum_sq(size, X, Y, Z);
	174
	175	// create function object f : X -> Z
	176	Z[0] >>= f;
	177	trace_off();
	178
	179	// evaluate and return gradient using reverse mode
	180	fos_reverse(tag, m, n, u, grad);
	181	}
	182	else
	183	{ // choose a matrix
	184	CppAD::uniform_01(n, mat);
	185
	186	// declare independent variables
	187	int keep = 0; // do not keep forward mode results
	188	trace_on(tag, keep);
	189	for(j = 0; j < n; j++)
	190	X[j] <<= mat[j];
	191
	192	// do computations
	193	CppAD::mat_sum_sq(size, X, Y, Z);
	194
	195	// create function object f : X -> Z
	196	Z[0] >>= f;
	197	trace_off();
	198
	199	while(repeat--)
	200	{ // choose a matrix
	201	CppAD::uniform_01(n, mat);
	202
	203	// evaluate the determinant at the new matrix value
	204	keep = 1; // keep this forward mode result
	205	zos_forward(tag, m, n, keep, mat, &f);
	206
	207	// evaluate and return gradient using reverse mode
	208	fos_reverse(tag, m, n, u, grad);
	209	}
	210	}
	211	// return function, matrix, and gradient
	212	z[0] = f;
	213	for(j = 0; j < n; j++)
	214	{ x[j] = mat[j];
	215	dz[j] = grad[j];
	216	}
	217
	218	// tear down
	219	thread_alloc::delete_array(X);
	220	thread_alloc::delete_array(Y);
	221	thread_alloc::delete_array(Z);
	222	thread_alloc::delete_array(mat);
	223	thread_alloc::delete_array(u);
	224	thread_alloc::delete_array(grad);
	225
	226	return true;
230	227	}
231	228
232	229
233	230	</pre></font></code>
234
235	231
236	232	<hr/>Input File: speed/adolc/mat_mul.cpp
237	233

+103

-107

doc/adolc_ode.cpp.xml less more

92	92	</select>
93	93	</td>
94	94	</tr></table><br/>
95
96
97
98	95	<center><b><big><big>Adolc Speed: Ode</big></big></b></center>
99	96	<br/>
100	97	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

118	115	extern bool global_memory, global_onetape, global_atomic, global_optimize;
119	116
120	117	bool link_ode(
121		size_t size ,
122		size_t repeat ,
123		CppAD::vector<double> &x ,
124		CppAD::vector<double> &jac
	118	size_t size ,
	119	size_t repeat ,
	120	CppAD::vector<double> &x ,
	121	CppAD::vector<double> &jac
125	122	)
126	123	{
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
134		assert( x.size() == size );
135		assert( jac.size() == size * size );
136
137		typedef CppAD::vector<adouble> ADVector;
138		typedef CppAD::vector<double> DblVector;
139
140		size_t i, j;
141		int tag = 0; // tape identifier
142		int keep = 0; // do not keep forward mode results
143		size_t p = 0; // use ode to calculate function values
144		size_t n = size; // number of independent variables
145		size_t m = n; // number of dependent variables
146		ADVector X(n), Y(m); // independent and dependent variables
147		DblVector f(m); // function value
148
149		// set up for thread_alloc memory allocator (fast and checks for leaks)
150		using CppAD::thread_alloc; // the allocator
151		size_t size_min; // requested number of elements
152		size_t size_out; // capacity of an allocation
153
154		// raw memory for use with adolc
155		size_min = n;
156		double *x_raw = thread_alloc::create_array<double>(size_min, size_out);
157		size_min = m * n;
158		double *jac_raw = thread_alloc::create_array<double>(size_min, size_out);
159		size_min = m;
160		double *jac_ptr = thread_alloc::create_array<double>(size_min, size_out);
161		for(i = 0; i < m; i++)
162		jac_ptr[i] = jac_raw + i * n;
163
164		// -------------------------------------------------------------
165		if( ! global_onetape ) while(repeat--)
166		{ // choose next x value
167		uniform_01(n, x);
168
169		// declare independent variables
170		trace_on(tag, keep);
171		for(j = 0; j < n; j++)
172		X[j] <<= x[j];
173
174		// evaluate function
175		CppAD::ode_evaluate(X, p, Y);
176
177		// create function object f : X -> Y
178		for(i = 0; i < m; i++)
179		Y[i] >>= f[i];
180		trace_off();
181
182		// evaluate the Jacobian
183		for(j = 0; j < n; j++)
184		x_raw[j] = x[j];
185		jacobian(tag, m, n, x_raw, jac_ptr);
186		}
187		else
188		{ // choose next x value
189		uniform_01(n, x);
190
191		// declare independent variables
192		trace_on(tag, keep);
193		for(j = 0; j < n; j++)
194		X[j] <<= x[j];
195
196		// evaluate function
197		CppAD::ode_evaluate(X, p, Y);
198
199		// create function object f : X -> Y
200		for(i = 0; i < m; i++)
201		Y[i] >>= f[i];
202		trace_off();
203
204		while(repeat--)
205		{ // get next argument value
206		uniform_01(n, x);
207		for(j = 0; j < n; j++)
208		x_raw[j] = x[j];
209
210		// evaluate jacobian
211		jacobian(tag, m, n, x_raw, jac_ptr);
212		}
213		}
214		// convert return value to a simple vector
215		for(i = 0; i < m; i++)
216		{ for(j = 0; j < n; j++)
217		jac[i * n + j] = jac_ptr[i][j];
218		}
219		// ----------------------------------------------------------------------
220		// tear down
221		thread_alloc::delete_array(x_raw);
222		thread_alloc::delete_array(jac_raw);
223		thread_alloc::delete_array(jac_ptr);
224
225		return true;
	124	// speed test global option values
	125	if( global_atomic )
	126	return false;
	127	if( global_memory \|\| global_optimize )
	128	return false;
	129	// -------------------------------------------------------------
	130	// setup
	131	assert( x.size() == size );
	132	assert( jac.size() == size * size );
	133
	134	typedef CppAD::vector<adouble> ADVector;
	135	typedef CppAD::vector<double> DblVector;
	136
	137	size_t i, j;
	138	int tag = 0; // tape identifier
	139	int keep = 0; // do not keep forward mode results
	140	size_t p = 0; // use ode to calculate function values
	141	size_t n = size; // number of independent variables
	142	size_t m = n; // number of dependent variables
	143	ADVector X(n), Y(m); // independent and dependent variables
	144	DblVector f(m); // function value
	145
	146	// set up for thread_alloc memory allocator (fast and checks for leaks)
	147	using CppAD::thread_alloc; // the allocator
	148	size_t size_min; // requested number of elements
	149	size_t size_out; // capacity of an allocation
	150
	151	// raw memory for use with adolc
	152	size_min = n;
	153	double *x_raw = thread_alloc::create_array<double>(size_min, size_out);
	154	size_min = m * n;
	155	double *jac_raw = thread_alloc::create_array<double>(size_min, size_out);
	156	size_min = m;
	157	double *jac_ptr = thread_alloc::create_array<double>(size_min, size_out);
	158	for(i = 0; i < m; i++)
	159	jac_ptr[i] = jac_raw + i * n;
	160
	161	// -------------------------------------------------------------
	162	if( ! global_onetape ) while(repeat--)
	163	{ // choose next x value
	164	uniform_01(n, x);
	165
	166	// declare independent variables
	167	trace_on(tag, keep);
	168	for(j = 0; j < n; j++)
	169	X[j] <<= x[j];
	170
	171	// evaluate function
	172	CppAD::ode_evaluate(X, p, Y);
	173
	174	// create function object f : X -> Y
	175	for(i = 0; i < m; i++)
	176	Y[i] >>= f[i];
	177	trace_off();
	178
	179	// evaluate the Jacobian
	180	for(j = 0; j < n; j++)
	181	x_raw[j] = x[j];
	182	jacobian(tag, m, n, x_raw, jac_ptr);
	183	}
	184	else
	185	{ // choose next x value
	186	uniform_01(n, x);
	187
	188	// declare independent variables
	189	trace_on(tag, keep);
	190	for(j = 0; j < n; j++)
	191	X[j] <<= x[j];
	192
	193	// evaluate function
	194	CppAD::ode_evaluate(X, p, Y);
	195
	196	// create function object f : X -> Y
	197	for(i = 0; i < m; i++)
	198	Y[i] >>= f[i];
	199	trace_off();
	200
	201	while(repeat--)
	202	{ // get next argument value
	203	uniform_01(n, x);
	204	for(j = 0; j < n; j++)
	205	x_raw[j] = x[j];
	206
	207	// evaluate jacobian
	208	jacobian(tag, m, n, x_raw, jac_ptr);
	209	}
	210	}
	211	// convert return value to a simple vector
	212	for(i = 0; i < m; i++)
	213	{ for(j = 0; j < n; j++)
	214	jac[i * n + j] = jac_ptr[i][j];
	215	}
	216	// ----------------------------------------------------------------------
	217	// tear down
	218	thread_alloc::delete_array(x_raw);
	219	thread_alloc::delete_array(jac_raw);
	220	thread_alloc::delete_array(jac_ptr);
	221
	222	return true;
226	223	}
227	224	</pre></font></code>
228	225
229
230	226	<hr/>Input File: speed/adolc/ode.cpp
231	227
232	228	</body>

+106

-110

doc/adolc_poly.cpp.xml less more

5	5	<title>Adolc Speed: Second Derivative of a Polynomial</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Adolc Speed: Second Derivative of a Polynomial"/>
8		<meta name="keywords" id="keywords" content=" adolc speed: second derivative of a polynomial link_poly speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" adolc speed: second derivative polynomial link_poly speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

92	92	</select>
93	93	</td>
94	94	</tr></table><br/>
95
96
97
98	95	<center><b><big><big>Adolc Speed: Second Derivative of a Polynomial</big></big></b></center>
99	96	<br/>
100	97	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

121	118	extern bool global_memory, global_onetape, global_atomic, global_optimize;
122	119
123	120	bool link_poly(
124		size_t size ,
125		size_t repeat ,
126		CppAD::vector<double> &a , // coefficients of polynomial
127		CppAD::vector<double> &z , // polynomial argument value
128		CppAD::vector<double> &ddp ) // second derivative w.r.t z
	121	size_t size ,
	122	size_t repeat ,
	123	CppAD::vector<double> &a , // coefficients of polynomial
	124	CppAD::vector<double> &z , // polynomial argument value
	125	CppAD::vector<double> &ddp ) // second derivative w.r.t z
129	126	{
130		if( global_atomic )
131		return false;
132		if( global_memory \|\| global_optimize )
133		return false;
134		// -----------------------------------------------------
135		// setup
136		size_t i;
137		int tag = 0; // tape identifier
138		int keep = 0; // do not keep forward mode results in buffer
139		int m = 1; // number of dependent variables
140		int n = 1; // number of independent variables
141		int d = 2; // highest derivative degree
142		double f; // function value
143
144		// set up for thread_alloc memory allocator (fast and checks for leaks)
145		using CppAD::thread_alloc; // the allocator
146		size_t capacity; // capacity of an allocation
147
148		// choose a vector of polynomial coefficients
149		CppAD::uniform_01(size, a);
150
151		// AD copy of the polynomial coefficients
152		std::vector<adouble> A(size);
153		for(i = 0; i < size; i++)
154		A[i] = a[i];
155
156		// domain and range space AD values
157		adouble Z, P;
158
159		// allocate arguments to hos_forward
160		double* x0 = thread_alloc::create_array<double>(size_t(n), capacity);
161		double* y0 = thread_alloc::create_array<double>(size_t(m), capacity);
162		double** x = adolc_alloc_mat(size_t(n), size_t(d));
163		double** y = adolc_alloc_mat(size_t(m), size_t(d));
164
165		// Taylor coefficient for argument
166		x[0][0] = 1.; // first order
167		x[0][1] = 0.; // second order
168
169		// ----------------------------------------------------------------------
170		if( ! global_onetape ) while(repeat--)
171		{ // choose an argument value
172		CppAD::uniform_01(1, z);
173
174		// declare independent variables
175		trace_on(tag, keep);
176		Z <<= z[0];
177
178		// AD computation of the function value
179		P = CppAD::Poly(0, A, Z);
180
181		// create function object f : Z -> P
182		P >>= f;
183		trace_off();
184
185		// set the argument value
186		x0[0] = z[0];
187
188		// evaluate the polynomial at the new argument value
189		hos_forward(tag, m, n, d, keep, x0, x, y0, y);
190
191		// second derivative is twice second order Taylor coef
192		ddp[0] = 2. * y[0][1];
193		}
194		else
195		{
196		// choose an argument value
197		CppAD::uniform_01(1, z);
198
199		// declare independent variables
200		trace_on(tag, keep);
201		Z <<= z[0];
202
203		// AD computation of the function value
204		P = CppAD::Poly(0, A, Z);
205
206		// create function object f : Z -> P
207		P >>= f;
208		trace_off();
209
210		while(repeat--)
211		{ // get the next argument value
212		CppAD::uniform_01(1, z);
213		x0[0] = z[0];
214
215		// evaluate the polynomial at the new argument value
216		hos_forward(tag, m, n, d, keep, x0, x, y0, y);
217
218		// second derivative is twice second order Taylor coef
219		ddp[0] = 2. * y[0][1];
220		}
221		}
222		// ------------------------------------------------------
223		// tear down
224		adolc_free_mat(x);
225		adolc_free_mat(y);
226		thread_alloc::delete_array(x0);
227		thread_alloc::delete_array(y0);
228
229		return true;
	127	if( global_atomic )
	128	return false;
	129	if( global_memory \|\| global_optimize )
	130	return false;
	131	// -----------------------------------------------------
	132	// setup
	133	size_t i;
	134	int tag = 0; // tape identifier
	135	int keep = 0; // do not keep forward mode results in buffer
	136	int m = 1; // number of dependent variables
	137	int n = 1; // number of independent variables
	138	int d = 2; // highest derivative degree
	139	double f; // function value
	140
	141	// set up for thread_alloc memory allocator (fast and checks for leaks)
	142	using CppAD::thread_alloc; // the allocator
	143	size_t capacity; // capacity of an allocation
	144
	145	// choose a vector of polynomial coefficients
	146	CppAD::uniform_01(size, a);
	147
	148	// AD copy of the polynomial coefficients
	149	std::vector<adouble> A(size);
	150	for(i = 0; i < size; i++)
	151	A[i] = a[i];
	152
	153	// domain and range space AD values
	154	adouble Z, P;
	155
	156	// allocate arguments to hos_forward
	157	double* x0 = thread_alloc::create_array<double>(size_t(n), capacity);
	158	double* y0 = thread_alloc::create_array<double>(size_t(m), capacity);
	159	double** x = adolc_alloc_mat(size_t(n), size_t(d));
	160	double** y = adolc_alloc_mat(size_t(m), size_t(d));
	161
	162	// Taylor coefficient for argument
	163	x[0][0] = 1.; // first order
	164	x[0][1] = 0.; // second order
	165
	166	// ----------------------------------------------------------------------
	167	if( ! global_onetape ) while(repeat--)
	168	{ // choose an argument value
	169	CppAD::uniform_01(1, z);
	170
	171	// declare independent variables
	172	trace_on(tag, keep);
	173	Z <<= z[0];
	174
	175	// AD computation of the function value
	176	P = CppAD::Poly(0, A, Z);
	177
	178	// create function object f : Z -> P
	179	P >>= f;
	180	trace_off();
	181
	182	// set the argument value
	183	x0[0] = z[0];
	184
	185	// evaluate the polynomial at the new argument value
	186	hos_forward(tag, m, n, d, keep, x0, x, y0, y);
	187
	188	// second derivative is twice second order Taylor coef
	189	ddp[0] = 2. * y[0][1];
	190	}
	191	else
	192	{
	193	// choose an argument value
	194	CppAD::uniform_01(1, z);
	195
	196	// declare independent variables
	197	trace_on(tag, keep);
	198	Z <<= z[0];
	199
	200	// AD computation of the function value
	201	P = CppAD::Poly(0, A, Z);
	202
	203	// create function object f : Z -> P
	204	P >>= f;
	205	trace_off();
	206
	207	while(repeat--)
	208	{ // get the next argument value
	209	CppAD::uniform_01(1, z);
	210	x0[0] = z[0];
	211
	212	// evaluate the polynomial at the new argument value
	213	hos_forward(tag, m, n, d, keep, x0, x, y0, y);
	214
	215	// second derivative is twice second order Taylor coef
	216	ddp[0] = 2. * y[0][1];
	217	}
	218	}
	219	// ------------------------------------------------------
	220	// tear down
	221	adolc_free_mat(x);
	222	adolc_free_mat(y);
	223	thread_alloc::delete_array(x0);
	224	thread_alloc::delete_array(y0);
	225
	226	return true;
230	227	}
231	228	</pre></font></code>
232	229
233
234	230	<hr/>Input File: speed/adolc/poly.cpp
235	231
236	232	</body>

+1

-1

doc/adolc_prefix.xml less more

5	5	<title>Including the ADOL-C Examples and Tests</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Including the ADOL-C Examples and Tests"/>
8		<meta name="keywords" id="keywords" content=" including the adol-c examples and tests adolc prefix get purpose adolc_prefix speed unix cygwin get_adolc "/>
	8	<meta name="keywords" id="keywords" content=" including the adol-c examples tests adolc prefix get purpose adolc_prefix speed unix cygwin get_adolc "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+153

-157

doc/adolc_sparse_hessian.cpp.xml less more

92	92	</select>
93	93	</td>
94	94	</tr></table><br/>
95
96
97
98	95	<center><b><big><big>Adolc Speed: Sparse Hessian</big></big></b></center>
99	96	<br/>
100	97	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

120	117	extern bool global_colpack, global_boolsparsity;
121	118
122	119	bool link_sparse_hessian(
123		size_t size ,
124		size_t repeat ,
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 ,
129		size_t& n_sweep )
	120	size_t size ,
	121	size_t repeat ,
	122	const CppAD::vector<size_t>& row ,
	123	const CppAD::vector<size_t>& col ,
	124	CppAD::vector<double>& x_return ,
	125	CppAD::vector<double>& hessian ,
	126	size_t& n_sweep )
130	127	{
131		if( global_atomic \|\| (! global_colpack) )
132		return false;
133		if( global_memory \|\| global_optimize \|\| global_boolsparsity )
134		return false;
135		// -----------------------------------------------------
136		// setup
137		typedef unsigned int* SizeVector;
138		typedef double* DblVector;
139		typedef adouble ADScalar;
140		typedef ADScalar* ADVector;
141
142
143		size_t i, j, k; // temporary indices
144		size_t order = 0; // derivative order corresponding to function
145		size_t m = 1; // number of dependent variables
146		size_t n = size; // number of independent variables
147
148		// setup for thread_alloc memory allocator (fast and checks for leaks)
149		using CppAD::thread_alloc; // the allocator
150		size_t capacity; // capacity of an allocation
151
152		// tape identifier
153		int tag = 0;
154		// AD domain space vector
155		ADVector a_x = thread_alloc::create_array<ADScalar>(n, capacity);
156		// AD range space vector
157		ADVector a_y = thread_alloc::create_array<ADScalar>(m, capacity);
158		// double argument value
159		DblVector x = thread_alloc::create_array<double>(n, capacity);
160		// double function value
161		double f;
162
163		// options that control sparse_hess
164		int options[2];
165		options[0] = 0; // safe mode
166		options[1] = 0; // indirect recovery
167
168		// structure that holds some of the work done by sparse_hess
169		int nnz; // number of non-zero values
170		SizeVector rind = CPPAD_NULL; // row indices
171		SizeVector cind = CPPAD_NULL; // column indices
172		DblVector values = CPPAD_NULL; // Hessian values
173
174		// ----------------------------------------------------------------------
175		if( ! global_onetape ) while(repeat--)
176		{ // choose a value for x
177		CppAD::uniform_01(n, x);
178
179		// declare independent variables
180		int keep = 0; // keep forward mode results
181		trace_on(tag, keep);
182		for(j = 0; j < n; j++)
183		a_x[j] <<= x[j];
184
185		// AD computation of f (x)
186		CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);
187
188		// create function object f : x -> y
189		a_y[0] >>= f;
190		trace_off();
191
192		// is this a repeat call with the same sparsity pattern
193		int same_pattern = 0;
194
195		// calculate the hessian at this x
196		rind = CPPAD_NULL;
197		cind = CPPAD_NULL;
198		values = CPPAD_NULL;
199		sparse_hess(tag, int(n),
200		same_pattern, x, &nnz, &rind, &cind, &values, options
201		);
202		// only needed last time through loop
203		if( repeat == 0 )
204		{ size_t K = row.size();
205		for(int ell = 0; ell < nnz; ell++)
206		{ i = size_t(rind[ell]);
207		j = size_t(cind[ell]);
208		for(k = 0; k < K; k++)
209		{ if( (row[k]==i && col[k]==j) \|\| (row[k]==j && col[k]==i) )
210		hessian[k] = values[ell];
211		}
212		}
213		}
214
215		// free raw memory allocated by sparse_hess
216		free(rind);
217		free(cind);
218		free(values);
219		}
220		else
221		{ // choose a value for x
222		CppAD::uniform_01(n, x);
223
224		// declare independent variables
225		int keep = 0; // keep forward mode results
226		trace_on(tag, keep);
227		for(j = 0; j < n; j++)
228		a_x[j] <<= x[j];
229
230		// AD computation of f (x)
231		CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);
232
233		// create function object f : x -> y
234		a_y[0] >>= f;
235		trace_off();
236
237		// is this a repeat call at the same argument
238		int same_pattern = 0;
239
240		while(repeat--)
241		{ // choose a value for x
242		CppAD::uniform_01(n, x);
243
244		// calculate the hessian at this x
245		sparse_hess(tag, int(n),
246		same_pattern, x, &nnz, &rind, &cind, &values, options
247		);
248		same_pattern = 1;
249		}
250		size_t K = row.size();
251		for(int ell = 0; ell < nnz; ell++)
252		{ i = size_t(rind[ell]);
253		j = size_t(cind[ell]);
254		for(k = 0; k < K; k++)
255		{ if( (row[k]==i && col[k]==j) \|\| (row[k]==j && col[k]==i) )
256		hessian[k] = values[ell];
257		}
258		}
259		// free raw memory allocated by sparse_hessian
260		free(rind);
261		free(cind);
262		free(values);
263		}
264		// --------------------------------------------------------------------
265		// return argument
266		for(j = 0; j < n; j++)
267		x_return[j] = x[j];
268
269		// do not know how to return number of sweeps used
270		n_sweep = 0;
271
272		// tear down
273		thread_alloc::delete_array(a_x);
274		thread_alloc::delete_array(a_y);
275		thread_alloc::delete_array(x);
276		return true;
	128	if( global_atomic \|\| (! global_colpack) )
	129	return false;
	130	if( global_memory \|\| global_optimize \|\| global_boolsparsity )
	131	return false;
	132	// -----------------------------------------------------
	133	// setup
	134	typedef unsigned int* SizeVector;
	135	typedef double* DblVector;
	136	typedef adouble ADScalar;
	137	typedef ADScalar* ADVector;
	138
	139
	140	size_t i, j, k; // temporary indices
	141	size_t order = 0; // derivative order corresponding to function
	142	size_t m = 1; // number of dependent variables
	143	size_t n = size; // number of independent variables
	144
	145	// setup for thread_alloc memory allocator (fast and checks for leaks)
	146	using CppAD::thread_alloc; // the allocator
	147	size_t capacity; // capacity of an allocation
	148
	149	// tape identifier
	150	int tag = 0;
	151	// AD domain space vector
	152	ADVector a_x = thread_alloc::create_array<ADScalar>(n, capacity);
	153	// AD range space vector
	154	ADVector a_y = thread_alloc::create_array<ADScalar>(m, capacity);
	155	// double argument value
	156	DblVector x = thread_alloc::create_array<double>(n, capacity);
	157	// double function value
	158	double f;
	159
	160	// options that control sparse_hess
	161	int options[2];
	162	options[0] = 0; // safe mode
	163	options[1] = 0; // indirect recovery
	164
	165	// structure that holds some of the work done by sparse_hess
	166	int nnz; // number of non-zero values
	167	SizeVector rind = CPPAD_NULL; // row indices
	168	SizeVector cind = CPPAD_NULL; // column indices
	169	DblVector values = CPPAD_NULL; // Hessian values
	170
	171	// ----------------------------------------------------------------------
	172	if( ! global_onetape ) while(repeat--)
	173	{ // choose a value for x
	174	CppAD::uniform_01(n, x);
	175
	176	// declare independent variables
	177	int keep = 0; // keep forward mode results
	178	trace_on(tag, keep);
	179	for(j = 0; j < n; j++)
	180	a_x[j] <<= x[j];
	181
	182	// AD computation of f (x)
	183	CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);
	184
	185	// create function object f : x -> y
	186	a_y[0] >>= f;
	187	trace_off();
	188
	189	// is this a repeat call with the same sparsity pattern
	190	int same_pattern = 0;
	191
	192	// calculate the hessian at this x
	193	rind = CPPAD_NULL;
	194	cind = CPPAD_NULL;
	195	values = CPPAD_NULL;
	196	sparse_hess(tag, int(n),
	197	same_pattern, x, &nnz, &rind, &cind, &values, options
	198	);
	199	// only needed last time through loop
	200	if( repeat == 0 )
	201	{ size_t K = row.size();
	202	for(int ell = 0; ell < nnz; ell++)
	203	{ i = size_t(rind[ell]);
	204	j = size_t(cind[ell]);
	205	for(k = 0; k < K; k++)
	206	{ if( (row[k]==i && col[k]==j) \|\| (row[k]==j && col[k]==i) )
	207	hessian[k] = values[ell];
	208	}
	209	}
	210	}
	211
	212	// free raw memory allocated by sparse_hess
	213	free(rind);
	214	free(cind);
	215	free(values);
	216	}
	217	else
	218	{ // choose a value for x
	219	CppAD::uniform_01(n, x);
	220
	221	// declare independent variables
	222	int keep = 0; // keep forward mode results
	223	trace_on(tag, keep);
	224	for(j = 0; j < n; j++)
	225	a_x[j] <<= x[j];
	226
	227	// AD computation of f (x)
	228	CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);
	229
	230	// create function object f : x -> y
	231	a_y[0] >>= f;
	232	trace_off();
	233
	234	// is this a repeat call at the same argument
	235	int same_pattern = 0;
	236
	237	while(repeat--)
	238	{ // choose a value for x
	239	CppAD::uniform_01(n, x);
	240
	241	// calculate the hessian at this x
	242	sparse_hess(tag, int(n),
	243	same_pattern, x, &nnz, &rind, &cind, &values, options
	244	);
	245	same_pattern = 1;
	246	}
	247	size_t K = row.size();
	248	for(int ell = 0; ell < nnz; ell++)
	249	{ i = size_t(rind[ell]);
	250	j = size_t(cind[ell]);
	251	for(k = 0; k < K; k++)
	252	{ if( (row[k]==i && col[k]==j) \|\| (row[k]==j && col[k]==i) )
	253	hessian[k] = values[ell];
	254	}
	255	}
	256	// free raw memory allocated by sparse_hessian
	257	free(rind);
	258	free(cind);
	259	free(values);
	260	}
	261	// --------------------------------------------------------------------
	262	// return argument
	263	for(j = 0; j < n; j++)
	264	x_return[j] = x[j];
	265
	266	// do not know how to return number of sweeps used
	267	n_sweep = 0;
	268
	269	// tear down
	270	thread_alloc::delete_array(a_x);
	271	thread_alloc::delete_array(a_y);
	272	thread_alloc::delete_array(x);
	273	return true;
277	274
278	275	}
279	276	</pre></font></code>
280	277
281
282	278	<hr/>Input File: speed/adolc/sparse_hessian.cpp
283	279
284	280	</body>

+163

-167

doc/adolc_sparse_jacobian.cpp.xml less more

92	92	</select>
93	93	</td>
94	94	</tr></table><br/>
95
96
97
98	95	<center><b><big><big>adolc Speed: Sparse Jacobian</big></big></b></center>
99	96	<br/>
100	97	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

119	116	extern bool global_colpack, global_boolsparsity;
120	117
121	118	bool link_sparse_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 )
	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_return ,
	125	CppAD::vector<double>& jacobian ,
	126	size_t& n_sweep )
130	127	{
131		if( global_atomic \|\| (! global_colpack) )
132		return false;
133		if( global_memory \|\| global_optimize )
134		return false;
135		// -----------------------------------------------------
136		// setup
137		typedef unsigned int* SizeVector;
138		typedef double* DblVector;
139		typedef adouble ADScalar;
140		typedef ADScalar* ADVector;
141
142		size_t i, j, k; // temporary indices
143		size_t n = size; // number of independent variables
144		size_t order = 0; // derivative order corresponding to function
145
146		// set up for thread_alloc memory allocator (fast and checks for leaks)
147		using CppAD::thread_alloc; // the allocator
148		size_t capacity; // capacity of an allocation
149
150		// tape identifier
151		int tag = 0;
152		// AD domain space vector
153		ADVector a_x = thread_alloc::create_array<ADScalar>(n, capacity);
154		// AD range space vector
155		ADVector a_y = thread_alloc::create_array<ADScalar>(m, capacity);
156		// argument value in double
157		DblVector x = thread_alloc::create_array<double>(n, capacity);
158		// function value in double
159		DblVector y = thread_alloc::create_array<double>(m, capacity);
160
161
162		// options that control sparse_jac
163		int options[4];
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)
172
173		// structure that holds some of the work done by sparse_jac
174		int nnz; // number of non-zero values
175		SizeVector rind = CPPAD_NULL; // row indices
176		SizeVector cind = CPPAD_NULL; // column indices
177		DblVector values = CPPAD_NULL; // Jacobian values
178
179		// choose a value for x
180		CppAD::uniform_01(n, x);
181
182		// declare independent variables
183		int keep = 0; // keep forward mode results
184		trace_on(tag, keep);
185		for(j = 0; j < n; j++)
186		a_x[j] <<= x[j];
187
188		// AD computation of f (x)
189		CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
190
191		// create function object f : x -> y
192		for(i = 0; i < m; i++)
193		a_y[i] >>= y[i];
194		trace_off();
195
196		// Retrieve n_sweep using undocumented feature of sparsedrivers.cpp
197		int same_pattern = 0;
198		options[2] = -1;
199		n_sweep = sparse_jac(tag, int(m), int(n),
200		same_pattern, x, &nnz, &rind, &cind, &values, options
201		);
202		options[2] = 0;
203		// ----------------------------------------------------------------------
204		if( ! global_onetape ) while(repeat--)
205		{ // choose a value for x
206		CppAD::uniform_01(n, x);
207
208		// declare independent variables
209		trace_on(tag, keep);
210		for(j = 0; j < n; j++)
211		a_x[j] <<= x[j];
212
213		// AD computation of f (x)
214		CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
215
216		// create function object f : x -> y
217		for(i = 0; i < m; i++)
218		a_y[i] >>= y[i];
219		trace_off();
220
221		// is this a repeat call with the same sparsity pattern
222		same_pattern = 0;
223
224		// calculate the jacobian at this x
225		rind = CPPAD_NULL;
226		cind = CPPAD_NULL;
227		values = CPPAD_NULL;
228		sparse_jac(tag, int(m), int(n),
229		same_pattern, x, &nnz, &rind, &cind, &values, options
230		);
231		// only needed last time through loop
232		if( repeat == 0 )
233		{ size_t K = row.size();
234		for(int ell = 0; ell < nnz; ell++)
235		{ i = size_t(rind[ell]);
236		j = size_t(cind[ell]);
237		for(k = 0; k < K; k++)
238		{ if( row[k]==i && col[k]==j )
239		jacobian[k] = values[ell];
240		}
241		}
242		}
243
244		// free raw memory allocated by sparse_jac
245		free(rind);
246		free(cind);
247		free(values);
248		}
249		else
250		{ while(repeat--)
251		{ // choose a value for x
252		CppAD::uniform_01(n, x);
253
254		// calculate the jacobian at this x
255		sparse_jac(tag, int(m), int(n),
256		same_pattern, x, &nnz, &rind, &cind, &values, options
257		);
258		same_pattern = 1;
259		}
260		size_t K = row.size();
261		for(int ell = 0; ell < nnz; ell++)
262		{ i = size_t(rind[ell]);
263		j = size_t(cind[ell]);
264		for(k = 0; k < K; k++)
265		{ if( row[k]==i && col[k]==j )
266		jacobian[k] = values[ell];
267		}
268		}
269
270		// free raw memory allocated by sparse_jac
271		free(rind);
272		free(cind);
273		free(values);
274		}
275		// --------------------------------------------------------------------
276		// return argument
277		for(j = 0; j < n; j++)
278		x_return[j] = x[j];
279
280		// tear down
281		thread_alloc::delete_array(a_x);
282		thread_alloc::delete_array(a_y);
283		thread_alloc::delete_array(x);
284		thread_alloc::delete_array(y);
285		return true;
	128	if( global_atomic \|\| (! global_colpack) )
	129	return false;
	130	if( global_memory \|\| global_optimize )
	131	return false;
	132	// -----------------------------------------------------
	133	// setup
	134	typedef unsigned int* SizeVector;
	135	typedef double* DblVector;
	136	typedef adouble ADScalar;
	137	typedef ADScalar* ADVector;
	138
	139	size_t i, j, k; // temporary indices
	140	size_t n = size; // number of independent variables
	141	size_t order = 0; // derivative order corresponding to function
	142
	143	// set up for thread_alloc memory allocator (fast and checks for leaks)
	144	using CppAD::thread_alloc; // the allocator
	145	size_t capacity; // capacity of an allocation
	146
	147	// tape identifier
	148	int tag = 0;
	149	// AD domain space vector
	150	ADVector a_x = thread_alloc::create_array<ADScalar>(n, capacity);
	151	// AD range space vector
	152	ADVector a_y = thread_alloc::create_array<ADScalar>(m, capacity);
	153	// argument value in double
	154	DblVector x = thread_alloc::create_array<double>(n, capacity);
	155	// function value in double
	156	DblVector y = thread_alloc::create_array<double>(m, capacity);
	157
	158
	159	// options that control sparse_jac
	160	int options[4];
	161	extern bool global_boolsparsity;
	162	if( global_boolsparsity )
	163	options[0] = 1; // sparsity by propagation of bit pattern
	164	else
	165	options[0] = 0; // sparsity pattern by index domains
	166	options[1] = 0; // (0 = safe mode, 1 = tight mode)
	167	options[2] = 0; // see changing to -1 and back to 0 below
	168	options[3] = 0; // (0 = column compression, 1 = row compression)
	169
	170	// structure that holds some of the work done by sparse_jac
	171	int nnz; // number of non-zero values
	172	SizeVector rind = CPPAD_NULL; // row indices
	173	SizeVector cind = CPPAD_NULL; // column indices
	174	DblVector values = CPPAD_NULL; // Jacobian values
	175
	176	// choose a value for x
	177	CppAD::uniform_01(n, x);
	178
	179	// declare independent variables
	180	int keep = 0; // keep forward mode results
	181	trace_on(tag, keep);
	182	for(j = 0; j < n; j++)
	183	a_x[j] <<= x[j];
	184
	185	// AD computation of f (x)
	186	CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
	187
	188	// create function object f : x -> y
	189	for(i = 0; i < m; i++)
	190	a_y[i] >>= y[i];
	191	trace_off();
	192
	193	// Retrieve n_sweep using undocumented feature of sparsedrivers.cpp
	194	int same_pattern = 0;
	195	options[2] = -1;
	196	n_sweep = sparse_jac(tag, int(m), int(n),
	197	same_pattern, x, &nnz, &rind, &cind, &values, options
	198	);
	199	options[2] = 0;
	200	// ----------------------------------------------------------------------
	201	if( ! global_onetape ) while(repeat--)
	202	{ // choose a value for x
	203	CppAD::uniform_01(n, x);
	204
	205	// declare independent variables
	206	trace_on(tag, keep);
	207	for(j = 0; j < n; j++)
	208	a_x[j] <<= x[j];
	209
	210	// AD computation of f (x)
	211	CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
	212
	213	// create function object f : x -> y
	214	for(i = 0; i < m; i++)
	215	a_y[i] >>= y[i];
	216	trace_off();
	217
	218	// is this a repeat call with the same sparsity pattern
	219	same_pattern = 0;
	220
	221	// calculate the jacobian at this x
	222	rind = CPPAD_NULL;
	223	cind = CPPAD_NULL;
	224	values = CPPAD_NULL;
	225	sparse_jac(tag, int(m), int(n),
	226	same_pattern, x, &nnz, &rind, &cind, &values, options
	227	);
	228	// only needed last time through loop
	229	if( repeat == 0 )
	230	{ size_t K = row.size();
	231	for(int ell = 0; ell < nnz; ell++)
	232	{ i = size_t(rind[ell]);
	233	j = size_t(cind[ell]);
	234	for(k = 0; k < K; k++)
	235	{ if( row[k]==i && col[k]==j )
	236	jacobian[k] = values[ell];
	237	}
	238	}
	239	}
	240
	241	// free raw memory allocated by sparse_jac
	242	free(rind);
	243	free(cind);
	244	free(values);
	245	}
	246	else
	247	{ while(repeat--)
	248	{ // choose a value for x
	249	CppAD::uniform_01(n, x);
	250
	251	// calculate the jacobian at this x
	252	sparse_jac(tag, int(m), int(n),
	253	same_pattern, x, &nnz, &rind, &cind, &values, options
	254	);
	255	same_pattern = 1;
	256	}
	257	size_t K = row.size();
	258	for(int ell = 0; ell < nnz; ell++)
	259	{ i = size_t(rind[ell]);
	260	j = size_t(cind[ell]);
	261	for(k = 0; k < K; k++)
	262	{ if( row[k]==i && col[k]==j )
	263	jacobian[k] = values[ell];
	264	}
	265	}
	266
	267	// free raw memory allocated by sparse_jac
	268	free(rind);
	269	free(cind);
	270	free(values);
	271	}
	272	// --------------------------------------------------------------------
	273	// return argument
	274	for(j = 0; j < n; j++)
	275	x_return[j] = x[j];
	276
	277	// tear down
	278	thread_alloc::delete_array(a_x);
	279	thread_alloc::delete_array(a_y);
	280	thread_alloc::delete_array(x);
	281	thread_alloc::delete_array(y);
	282	return true;
286	283	}
287	284	</pre></font></code>
288	285
289
290	286	<hr/>Input File: speed/adolc/sparse_jacobian.cpp
291	287
292	288	</body>

+1

-1

doc/advalued.xml less more

5	5	<title>AD Valued Operations and Functions</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Valued Operations and Functions"/>
8		<meta name="keywords" id="keywords" content=" ad valued operations and functions "/>
	8	<meta name="keywords" id="keywords" content=" ad valued operations functions "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+0

-3

doc/appendix.xml less more

79	79	</select>
80	80	</td>
81	81	</tr></table><br/>
82
83
84
85	82	<center><b><big><big>Appendix</big></big></b></center>
86	83	<br/>
87	84	<b><big><a name="Contents" id="Contents">Contents</a></big></b>

+1

-1

doc/arithmetic.xml less more

5	5	<title>AD Arithmetic Operators and Computed Assignments</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Arithmetic Operators and Computed Assignments"/>
8		<meta name="keywords" id="keywords" content=" ad arithmetic operators and computed assignments "/>
	8	<meta name="keywords" id="keywords" content=" ad arithmetic operators computed assignments "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/asin.cpp.xml less more

5	5	<title>The AD asin Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD asin Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad asin function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad asin function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/asin_forward.xml less more

5	5	<title>Inverse Sine and Hyperbolic Sine Forward Mode Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Inverse Sine and Hyperbolic Sine Forward Mode Theory"/>
8		<meta name="keywords" id="keywords" content=" inverse sine and hyperbolic forward mode theory asin asinh derivatives taylor coefficients recursion "/>
	8	<meta name="keywords" id="keywords" content=" inverse sine hyperbolic forward mode theory asin asinh derivatives taylor coefficients recursion "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/asin_reverse.xml less more

5	5	<title>Inverse Sine and Hyperbolic Sine Reverse Mode Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Inverse Sine and Hyperbolic Sine Reverse Mode Theory"/>
8		<meta name="keywords" id="keywords" content=" inverse sine and hyperbolic reverse mode theory asin asinh "/>
	8	<meta name="keywords" id="keywords" content=" inverse sine hyperbolic reverse mode theory asin asinh "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/asinh.cpp.xml less more

5	5	<title>The AD asinh Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD asinh Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad asinh function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad asinh function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/atan.cpp.xml less more

5	5	<title>The AD atan Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD atan Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad atan function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad atan function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/atan2.cpp.xml less more

5	5	<title>The AD atan2 Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD atan2 Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad atan2 function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad atan2 function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/atan_forward.xml less more

5	5	<title>Inverse Tangent and Hyperbolic Tangent Forward Mode Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Inverse Tangent and Hyperbolic Tangent Forward Mode Theory"/>
8		<meta name="keywords" id="keywords" content=" inverse tangent and hyperbolic forward mode theory atan atanh derivatives taylor coefficients recursion "/>
	8	<meta name="keywords" id="keywords" content=" inverse tangent hyperbolic forward mode theory atan atanh derivatives taylor coefficients recursion "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/atan_reverse.xml less more

5	5	<title>Inverse Tangent and Hyperbolic Tangent Reverse Mode Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Inverse Tangent and Hyperbolic Tangent Reverse Mode Theory"/>
8		<meta name="keywords" id="keywords" content=" inverse tangent and hyperbolic reverse mode theory "/>
	8	<meta name="keywords" id="keywords" content=" inverse tangent hyperbolic reverse mode theory "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/atanh.cpp.xml less more

5	5	<title>The AD atanh Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD atanh Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad atanh function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad atanh function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/atomic_afun.xml less more

5	5	<title>Using AD Version of Atomic Function</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using AD Version of Atomic Function"/>
8		<meta name="keywords" id="keywords" content=" using ad version of atomic function syntax purpose advector afun ax ay examples "/>
	8	<meta name="keywords" id="keywords" content=" using ad version atomic function syntax purpose advector afun ax ay examples "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+89

-107

doc/atomic_get_started.cpp.xml less more

5	5	<title>Getting Started with Atomic Operations: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Getting Started with Atomic Operations: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" getting started with atomic operations: example and test purpose start class definition constructor forward end use function recording "/>
	8	<meta name="keywords" id="keywords" content=" getting started with atomic operations: example test purpose start class definition constructor forward end use function recording "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

122	122	using CppAD::vector; // abbreviate as vector
123	123	class atomic_get_started : public CppAD::atomic_base<double> {
124	124	</pre></font></code>
125
126
127		<br/>
128	125	<br/>
129	126	<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
130	127
131	128	<code><font color='blue'><pre style='display:inline'>
132		public:
133		// constructor (could use const char* for name)
134		atomic_get_started(const std::string& name) :
135		// this example does not use any sparsity patterns
136		CppAD::atomic_base<double>(name)
137		{ }
138		private:
139		</pre></font></code>
140
141		<br/>
	129	public:
	130	// constructor (could use const char* for name)
	131	atomic_get_started(const std::string& name) :
	132	// this example does not use any sparsity patterns
	133	CppAD::atomic_base<double>(name)
	134	{ }
	135	private:
	136	</pre></font></code>
142	137	<br/>
143	138	<b><big><a name="forward" id="forward">forward</a></big></b>
144	139
145	140	<code><font color='blue'><pre style='display:inline'>
146		// forward mode routine called by CppAD
147		virtual bool forward(
148		size_t p ,
149		size_t q ,
150		const vector<bool>& vx ,
151		vector<bool>& vy ,
152		const vector<double>& tx ,
153		vector<double>& ty
154		)
155		{ size_t n = tx.size() / (q + 1);
156		size_t m = ty.size() / (q + 1);
157		assert( n == 1 );
158		assert( m == 1 );
159
160		// return flag
161		bool ok = q == 0;
162		if( ! ok )
163		return ok;
164
165		// check for defining variable information
166		// This case must always be implemented
167		if( vx.size() > 0 )
168		vy[0] = vx[0];
169
170		// Order zero forward mode.
171		// This case must always be implemented
172		// y^0 = f( x^0 ) = 1 / x^0
173		double f = 1. / tx[0];
174		if( p <= 0 )
175		ty[0] = f;
176		return ok;
177		}
178		</pre></font></code>
179
180		<br/>
	141	// forward mode routine called by CppAD
	142	virtual bool forward(
	143	size_t p ,
	144	size_t q ,
	145	const vector<bool>& vx ,
	146	vector<bool>& vy ,
	147	const vector<double>& tx ,
	148	vector<double>& ty
	149	)
	150	{ size_t n = tx.size() / (q + 1);
	151	size_t m = ty.size() / (q + 1);
	152	assert( n == 1 );
	153	assert( m == 1 );
	154
	155	// return flag
	156	bool ok = q == 0;
	157	if( ! ok )
	158	return ok;
	159
	160	// check for defining variable information
	161	// This case must always be implemented
	162	if( vx.size() > 0 )
	163	vy[0] = vx[0];
	164
	165	// Order zero forward mode.
	166	// This case must always be implemented
	167	// y^0 = f( x^0 ) = 1 / x^0
	168	double f = 1. / tx[0];
	169	if( p <= 0 )
	170	ty[0] = f;
	171	return ok;
	172	}
	173	</pre></font></code>
181	174	<br/>
182	175	<b><big><a name="End Class Definition" id="End Class Definition">End Class Definition</a></big></b>
183	176

186	179	} // End empty namespace
187	180
188	181	</pre></font></code>
189
190		<br/>
191		<br/>
192	182	<b><big><a name="Use Atomic Function" id="Use Atomic Function">Use Atomic Function</a></big></b>
193	183
194	184	<code><font color='blue'><pre style='display:inline'>
195	185	bool get_started(void)
196		{ bool ok = true;
197		using CppAD::AD;
198		using CppAD::NearEqual;
199		double eps = 10. * CppAD::numeric_limits<double>::epsilon();
200		</pre></font></code>
201
202		<br/>
	186	{ bool ok = true;
	187	using CppAD::AD;
	188	using CppAD::NearEqual;
	189	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	190	</pre></font></code>
203	191	<br/>
204	192	<b><a name="Use Atomic Function.Constructor" id="Use Atomic Function.Constructor">Constructor</a></b>
205	193
206	194	<code><font color='blue'><pre style='display:inline'>
207		// Create the atomic get_started object
208		atomic_get_started afun("atomic_get_started");
209		</pre></font></code>
210
211		<br/>
	195	// Create the atomic get_started object
	196	atomic_get_started afun("atomic_get_started");
	197	</pre></font></code>
212	198	<br/>
213	199	<b><a name="Use Atomic Function.Recording" id="Use Atomic Function.Recording">Recording</a></b>
214	200
215	201	<code><font color='blue'><pre style='display:inline'>
216		// Create the function f(x)
217		//
218		// domain space vector
219		size_t n = 1;
220		double x0 = 0.5;
221		vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
222		ax[0] = x0;
223
224		// declare independent variables and start tape recording
225		CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
226
227		// range space vector
228		size_t m = 1;
229		vector< <a href="ad.xml" target="_top">AD</a><double> > ay(m);
230
231		// call user function and store get_started(x) in au[0]
232		vector< <a href="ad.xml" target="_top">AD</a><double> > au(m);
233		afun(ax, au); // u = 1 / x
234
235		// now use AD division to invert to invert the operation
236		ay[0] = 1.0 / au[0]; // y = 1 / u = x
237
238		// create f: x -> y and stop tape recording
239		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
240		f.Dependent (ax, ay); // f(x) = x
241		</pre></font></code>
242
243		<br/>
	202	// Create the function f(x)
	203	//
	204	// domain space vector
	205	size_t n = 1;
	206	double x0 = 0.5;
	207	vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
	208	ax[0] = x0;
	209
	210	// declare independent variables and start tape recording
	211	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
	212
	213	// range space vector
	214	size_t m = 1;
	215	vector< <a href="ad.xml" target="_top">AD</a><double> > ay(m);
	216
	217	// call user function and store get_started(x) in au[0]
	218	vector< <a href="ad.xml" target="_top">AD</a><double> > au(m);
	219	afun(ax, au); // u = 1 / x
	220
	221	// now use AD division to invert to invert the operation
	222	ay[0] = 1.0 / au[0]; // y = 1 / u = x
	223
	224	// create f: x -> y and stop tape recording
	225	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
	226	f.Dependent (ax, ay); // f(x) = x
	227	</pre></font></code>
244	228	<br/>
245	229	<b><a name="Use Atomic Function.forward" id="Use Atomic Function.forward">forward</a></b>
246	230
247	231	<code><font color='blue'><pre style='display:inline'>
248		// check function value
249		double check = x0;
250		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
251
252		// check zero order forward mode
253		size_t q;
254		vector<double> x_q(n), y_q(m);
255		q = 0;
256		x_q[0] = x0;
257		y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
258		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
259
260		return ok;
	232	// check function value
	233	double check = x0;
	234	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
	235
	236	// check zero order forward mode
	237	size_t q;
	238	vector<double> x_q(n), y_q(m);
	239	q = 0;
	240	x_q[0] = x0;
	241	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	242	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
	243
	244	return ok;
261	245	}
262	246	</pre></font></code>
263
264
265	247
266	248	<hr/>Input File: example/atomic/get_started.cpp
267	249

+209

-226

doc/atomic_hes_sparse.cpp.xml less more

5	5	<title>Atomic Operation Hessian Sparsity: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	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 "/>
	8	<meta name="keywords" id="keywords" content=" atomic operation hessian sparsity: example test sparsity purpose start class definition constructor forward for_sparse_jac rev_sparse_hes use function with x_1 both variable parameter "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

99	99	</select>
100	100	</td>
101	101	</tr></table><br/>
102
103
104	102	<center><b><big><big>Atomic Operation Hessian Sparsity: Example and Test</big></big></b></center>
105	103	<br/>
106	104	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>

121	119	//
122	120	// a utility to compute the union of two sets.
123	121	void my_union(
124		std::set<size_t>& result ,
125		const std::set<size_t>& left ,
126		const std::set<size_t>& right )
127		{ std::set<size_t> temp;
128		std::set_union(
129		left.begin() ,
130		left.end() ,
131		right.begin() ,
132		right.end() ,
133		std::inserter(temp, temp.begin())
134		);
135		result.swap(temp);
	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);
136	134	}
137	135	//
138	136	class atomic_hes_sparse : public CppAD::atomic_base<double> {
139	137	</pre></font></code>
140
141		<br/>
142	138	<br/>
143	139	<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
144	140
145	141	<code><font color='blue'><pre style='display:inline'>
146		public:
147		// constructor (could use const char* for name)
148		atomic_hes_sparse(const std::string& name) :
149		CppAD::atomic_base<double>(name)
150		{ }
151		private:
152		</pre></font></code>
153
154		<br/>
	142	public:
	143	// constructor (could use const char* for name)
	144	atomic_hes_sparse(const std::string& name) :
	145	CppAD::atomic_base<double>(name)
	146	{ }
	147	private:
	148	</pre></font></code>
155	149	<br/>
156	150	<b><big><a name="forward" id="forward">forward</a></big></b>
157	151
158	152	<code><font color='blue'><pre style='display:inline'>
159		// forward mode routine called by CppAD
160		virtual bool forward(
161		size_t p ,
162		size_t q ,
163		const vector<bool>& vx ,
164		vector<bool>& vy ,
165		const vector<double>& tx ,
166		vector<double>& ty
167		)
168		{ size_t n = tx.size() / (q + 1);
169		size_t m = ty.size() / (q + 1);
170		assert( n == 2 );
171		assert( m == 2 );
172
173		// return flag
174		bool ok = q == 0;
175		if( ! ok )
176		return ok;
177
178		// check for defining variable information
179		// This case must always be implemented
180		if( vx.size() > 0 )
181		{ vy[0] = vx[0];
182		vy[1] = vx[0] \|\| vy[0];
183		}
184
185		// Order zero forward mode.
186		// This case must always be implemented
187		// y^0 = f( x^0 ) = [ x0_0 * x0_0 , x0_0 * x0_1 ]^T
188		assert( p <= 0 );
189		if( p <= 0 )
190		{ ty[0] = tx[0] * tx[0];
191		ty[1] = tx[0] * tx[1];
192		}
193		return ok;
194		}
195		</pre></font></code>
196
197		<br/>
	153	// forward mode routine called by CppAD
	154	virtual bool forward(
	155	size_t p ,
	156	size_t q ,
	157	const vector<bool>& vx ,
	158	vector<bool>& vy ,
	159	const vector<double>& tx ,
	160	vector<double>& ty
	161	)
	162	{ size_t n = tx.size() / (q + 1);
	163	size_t m = ty.size() / (q + 1);
	164	assert( n == 2 );
	165	assert( m == 2 );
	166
	167	// return flag
	168	bool ok = q == 0;
	169	if( ! ok )
	170	return ok;
	171
	172	// check for defining variable information
	173	// This case must always be implemented
	174	if( vx.size() > 0 )
	175	{ vy[0] = vx[0];
	176	vy[1] = vx[0] \|\| vy[0];
	177	}
	178
	179	// Order zero forward mode.
	180	// This case must always be implemented
	181	// y^0 = f( x^0 ) = [ x0_0 * x0_0 , x0_0 * x0_1 ]^T
	182	assert( p <= 0 );
	183	if( p <= 0 )
	184	{ ty[0] = tx[0] * tx[0];
	185	ty[1] = tx[0] * tx[1];
	186	}
	187	return ok;
	188	}
	189	</pre></font></code>
198	190	<br/>
199	191	<b><big><a name="for_sparse_jac" id="for_sparse_jac">for_sparse_jac</a></big></b>
200	192
201	193	<code><font color='blue'><pre style='display:inline'>
202		// forward Jacobian set sparsity routine called by CppAD
203		virtual bool for_sparse_jac(
204		size_t p ,
205		const vector< std::set<size_t> >& r ,
206		vector< std::set<size_t> >& s )
207		{ // This function needed if using f.ForSparseJac
208		// with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
209		size_t n = r.size();
210		size_t m = s.size();
211		assert( n == 2 );
212		assert( m == 2 );
213
214		// sparsity for S(x) = f'(x) * R is union of rows of R
215		s[0] = r[0];
216		my_union(s[1], r[0], r[1]);
217
218		return true;
219		}
220		</pre></font></code>
221
222		<br/>
	194	// forward Jacobian set sparsity routine called by CppAD
	195	virtual bool for_sparse_jac(
	196	size_t p ,
	197	const vector< std::set<size_t> >& r ,
	198	vector< std::set<size_t> >& s )
	199	{ // This function needed if using f.ForSparseJac
	200	// with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
	201	size_t n = r.size();
	202	size_t m = s.size();
	203	assert( n == 2 );
	204	assert( m == 2 );
	205
	206	// sparsity for S(x) = f'(x) * R is union of rows of R
	207	s[0] = r[0];
	208	my_union(s[1], r[0], r[1]);
	209
	210	return true;
	211	}
	212	</pre></font></code>
223	213	<br/>
224	214	<b><big><a name="rev_sparse_hes" id="rev_sparse_hes">rev_sparse_hes</a></big></b>
225	215
226	216	<code><font color='blue'><pre style='display:inline'>
227		// reverse Hessian set sparsity routine called by CppAD
228		virtual bool rev_sparse_hes(
229		const vector<bool>& vx,
230		const vector<bool>& s ,
231		vector<bool>& t ,
232		size_t p ,
233		const vector< std::set<size_t> >& r ,
234		const vector< std::set<size_t> >& u ,
235		vector< std::set<size_t> >& v )
236		{ // This function needed if using RevSparseHes
237		// with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
238		size_t n = vx.size();
239		size_t m = s.size();
240		assert( t.size() == n );
241		assert( r.size() == n );
242		assert( u.size() == m );
243		assert( v.size() == n );
244		assert( n == 2 );
245		assert( m == 2 );
246
247		// There are no cross term second derivatives for this case,
248		// so it is not necessary to vx.
249
250		// sparsity for T(x) = S(x) * f'(x)
251		t[0] = s[0];
252		t[1] = s[0] \|\| s[1];
253
254		// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
255		// U(x) = g''(y) * f'(x) * R
256		// S(x) = g'(y)
257
258		// back propagate the sparsity for U,
259		// note both components of f'(x) may be non-zero;
260		v[0] = u[0];
261		my_union(v[1], u[0], u[1]);
262
263		// include forward Jacobian sparsity in Hessian sparsity
264		// f_0''(x) * R
265		if( s[0] )
266		my_union(v[0], v[0], r[0] );
267		// f_1''(x) * R
268		if( s[1] )
269		{ my_union(v[1], v[1], r[0] );
270		my_union(v[0], v[0], r[1] );
271		}
272		return true;
273		}
	217	// reverse Hessian set sparsity routine called by CppAD
	218	virtual bool rev_sparse_hes(
	219	const vector<bool>& vx,
	220	const vector<bool>& s ,
	221	vector<bool>& t ,
	222	size_t p ,
	223	const vector< std::set<size_t> >& r ,
	224	const vector< std::set<size_t> >& u ,
	225	vector< std::set<size_t> >& v )
	226	{ // This function needed if using RevSparseHes
	227	// with afun.option( CppAD::atomic_base<double>::set_sparsity_enum )
	228	size_t n = vx.size();
	229	size_t m = s.size();
	230	assert( t.size() == n );
	231	assert( r.size() == n );
	232	assert( u.size() == m );
	233	assert( v.size() == n );
	234	assert( n == 2 );
	235	assert( m == 2 );
	236
	237	// There are no cross term second derivatives for this case,
	238	// so it is not necessary to vx.
	239
	240	// sparsity for T(x) = S(x) * f'(x)
	241	t[0] = s[0];
	242	t[1] = s[0] \|\| s[1];
	243
	244	// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
	245	// U(x) = g''(y) * f'(x) * R
	246	// S(x) = g'(y)
	247
	248	// back propagate the sparsity for U,
	249	// note both components of f'(x) may be non-zero;
	250	v[0] = u[0];
	251	my_union(v[1], u[0], u[1]);
	252
	253	// include forward Jacobian sparsity in Hessian sparsity
	254	// f_0''(x) * R
	255	if( s[0] )
	256	my_union(v[0], v[0], r[0] );
	257	// f_1''(x) * R
	258	if( s[1] )
	259	{ my_union(v[1], v[1], r[0] );
	260	my_union(v[0], v[0], r[1] );
	261	}
	262	return true;
	263	}
274	264	}; // End of atomic_hes_sparse class
275	265
276	266	</pre></font></code>
277
278		<br/>
279		<br/>
280	267	<b><big><a name="Use Atomic Function" id="Use Atomic Function">Use Atomic Function</a></big></b>
281	268
282	269	<code><font color='blue'><pre style='display:inline'>
283	270	bool use_atomic_hes_sparse(bool x_1_variable)
284		{ bool ok = true;
285		using CppAD::AD;
286		using CppAD::NearEqual;
287		double eps = 10. * CppAD::numeric_limits<double>::epsilon();
288		//
289		// Create the atomic hes_sparse object
290		atomic_hes_sparse afun("atomic_hes_sparse");
291		//
292		// Create the function f(u)
293		//
294		// domain space vector
295		size_t n = 2;
296		double x0_0 = 0.75, x0_1 = 2.00;
297		vector< <a href="ad.xml" target="_top">AD</a><double> > au(n);
298		au[0] = x0_0;
299		au[1] = x0_1;
300
301		// declare independent variables and start tape recording
302		CppAD::<a href="independent.xml" target="_top">Independent</a>(au);
303
304		// range space vector
305		size_t m = 2;
306		vector< <a href="ad.xml" target="_top">AD</a><double> > ay(m);
307
308		// call user function
309		vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
310		ax[0] = au[0];
311		if( x_1_variable )
312		ax[1] = au[1];
313		else
314		ax[1] = x0_1;
315		afun(ax, ay); // y = [ x[0] * x[0] , x[0] * x[1] ] ^T
316
317		// create f: u -> y and stop tape recording
318		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
319		f.Dependent (au, ay); // f(u) = y
320		//
321		// check function value
322		double check_y0_0 = x0_0 * x0_0;
323		double check_y0_1 = x0_0 * x0_1;
324		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check_y0_0, eps, eps);
325		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[1]) , check_y0_1, eps, eps);
326
327		// check zero order forward mode
328		size_t q;
329		vector<double> uq(n), yq(m);
330		q = 0;
331		uq[0] = x0_0;
332		uq[1] = x0_1;
333		yq = f.<a href="forward.xml" target="_top">Forward</a>(q, uq);
334		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(yq[0] , check_y0_0, eps, eps);
335		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(yq[1] , check_y0_1, eps, eps);
336
337		// forward sparse jacobian
338		afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
339		vector< std::set<size_t> > r(2), jac_s(2), check_s(2);
340		r[0].insert(0);
341		r[1].insert(1);
342		jac_s = f.ForSparseJac(n, r);
343		check_s[0].insert(0);
344		ok &= jac_s[0] == check_s[0];
345		check_s[1].insert(0);
346		if( x_1_variable )
347		check_s[1].insert(1);
348		ok &= jac_s[1] == check_s[1];
349
350		// reverse sparse Hessian
351		vector< std::set<size_t> > h(2), check_h(2), hes_s(1);
352		hes_s[0].insert(0);
353		hes_s[0].insert(1);
354		h = f.RevSparseHes(n, hes_s);
355		check_h[0].insert(0);
356		if( x_1_variable )
357		check_h[0].insert(1);
358		ok &= h[0] == check_h[0];
359		if( x_1_variable )
360		check_h[1].insert(0);
361		ok &= h[1] == check_h[1];
362
363		return ok;
	271	{ bool ok = true;
	272	using CppAD::AD;
	273	using CppAD::NearEqual;
	274	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	275	//
	276	// Create the atomic hes_sparse object
	277	atomic_hes_sparse afun("atomic_hes_sparse");
	278	//
	279	// Create the function f(u)
	280	//
	281	// domain space vector
	282	size_t n = 2;
	283	double x0_0 = 0.75, x0_1 = 2.00;
	284	vector< <a href="ad.xml" target="_top">AD</a><double> > au(n);
	285	au[0] = x0_0;
	286	au[1] = x0_1;
	287
	288	// declare independent variables and start tape recording
	289	CppAD::<a href="independent.xml" target="_top">Independent</a>(au);
	290
	291	// range space vector
	292	size_t m = 2;
	293	vector< <a href="ad.xml" target="_top">AD</a><double> > ay(m);
	294
	295	// call user function
	296	vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
	297	ax[0] = au[0];
	298	if( x_1_variable )
	299	ax[1] = au[1];
	300	else
	301	ax[1] = x0_1;
	302	afun(ax, ay); // y = [ x[0] * x[0] , x[0] * x[1] ] ^T
	303
	304	// create f: u -> y and stop tape recording
	305	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
	306	f.Dependent (au, ay); // f(u) = y
	307	//
	308	// check function value
	309	double check_y0_0 = x0_0 * x0_0;
	310	double check_y0_1 = x0_0 * x0_1;
	311	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check_y0_0, eps, eps);
	312	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[1]) , check_y0_1, eps, eps);
	313
	314	// check zero order forward mode
	315	size_t q;
	316	vector<double> uq(n), yq(m);
	317	q = 0;
	318	uq[0] = x0_0;
	319	uq[1] = x0_1;
	320	yq = f.<a href="forward.xml" target="_top">Forward</a>(q, uq);
	321	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(yq[0] , check_y0_0, eps, eps);
	322	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(yq[1] , check_y0_1, eps, eps);
	323
	324	// forward sparse jacobian
	325	afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
	326	vector< std::set<size_t> > r(2), jac_s(2), check_s(2);
	327	r[0].insert(0);
	328	r[1].insert(1);
	329	jac_s = f.ForSparseJac(n, r);
	330	check_s[0].insert(0);
	331	ok &= jac_s[0] == check_s[0];
	332	check_s[1].insert(0);
	333	if( x_1_variable )
	334	check_s[1].insert(1);
	335	ok &= jac_s[1] == check_s[1];
	336
	337	// reverse sparse Hessian
	338	vector< std::set<size_t> > h(2), check_h(2), hes_s(1);
	339	hes_s[0].insert(0);
	340	hes_s[0].insert(1);
	341	h = f.RevSparseHes(n, hes_s);
	342	check_h[0].insert(0);
	343	if( x_1_variable )
	344	check_h[0].insert(1);
	345	ok &= h[0] == check_h[0];
	346	if( x_1_variable )
	347	check_h[1].insert(0);
	348	ok &= h[1] == check_h[1];
	349
	350	return ok;
364	351	}
365	352	} // End empty namespace
366	353	</pre></font></code>
367
368		<br/>
369	354	<br/>
370	355	<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>
371	356
372	357	<code><font color='blue'><pre style='display:inline'>
373	358	bool hes_sparse(void)
374		{ bool ok = true;
375		// test with x_1 a variable
376		ok &= use_atomic_hes_sparse(true);
377		// test with x_1 a parameter
378		ok &= use_atomic_hes_sparse(false);
379		return ok;
	359	{ bool ok = true;
	360	// test with x_1 a variable
	361	ok &= use_atomic_hes_sparse(true);
	362	// test with x_1 a parameter
	363	ok &= use_atomic_hes_sparse(false);
	364	return ok;
380	365	}
381	366	</pre></font></code>
382
383
384	367
385	368	<hr/>Input File: example/atomic/hes_sparse.cpp
386	369

+215

-236

doc/atomic_mat_mul.cpp.xml less more

5	5	<title>User Atomic Matrix Multiply: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="User Atomic Matrix Multiply: Example and Test"/>
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	<meta name="keywords" id="keywords" content=" user atomic matrix multiply: example test multiply class definition use function constructor recording forward reverse option for_sparse_jac rev_sparse_jac rev_sparse_hes "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

106	106	</select>
107	107	</td>
108	108	</tr></table><br/>
109
110
111
112	109	<center><b><big><big>User Atomic Matrix Multiply: Example and Test</big></big></b></center>
113	110	<br/>
114	111	<b><big><a name="Class Definition" id="Class Definition">Class Definition</a></big></b>

129	126	# include <cppad/example/matrix_mul.hpp>
130	127
131	128	bool mat_mul(void)
132		{ bool ok = true;
133		using CppAD::AD;
134		using CppAD::vector;
135		size_t i, j;
136		</pre></font></code>
137
138		<br/>
	129	{ bool ok = true;
	130	using CppAD::AD;
	131	using CppAD::vector;
	132	size_t i, j;
	133	</pre></font></code>
139	134	<br/>
140	135	<b><a name="Use Atomic Function.Constructor" id="Use Atomic Function.Constructor">Constructor</a></b>
141	136
142	137	<code><font color='blue'><pre style='display:inline'>
143		// -------------------------------------------------------------------
144		// object that multiplies 2 x 2 matrices
145		size_t nr_result = 2;
146		size_t n_middle = 2;
147		size_t nc_result = 2;
148		matrix_mul afun(nr_result, n_middle, nc_result);
149		</pre></font></code>
150
151		<br/>
	138	// -------------------------------------------------------------------
	139	// object that multiplies 2 x 2 matrices
	140	size_t nr_result = 2;
	141	size_t n_middle = 2;
	142	size_t nc_result = 2;
	143	matrix_mul afun(nr_result, n_middle, nc_result);
	144	</pre></font></code>
152	145	<br/>
153	146	<b><a name="Use Atomic Function.Recording" id="Use Atomic Function.Recording">Recording</a></b>
154	147
155	148	<code><font color='blue'><pre style='display:inline'>
156		// start recording with four independent varables
157		size_t n = 4;
158		vector<double> x(n);
159		vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
160		for(j = 0; j < n; j++)
161		ax[j] = x[j] = j + 1;
162		CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
163
164		// ------------------------------------------------------------------
165		vector< <a href="ad.xml" target="_top">AD</a><double> > atom_x(nr_result * n_middle + n_middle * nc_result);
166
167		// left matrix
168		atom_x[0] = ax[0]; // left[0, 0] = x0
169		atom_x[1] = ax[1]; // left[0, 1] = x1
170		atom_x[2] = 5.; // left[1, 0] = 5
171		atom_x[3] = 6.; // left[1, 1] = 6
172
173		// right matix
174		atom_x[4] = ax[2]; // right[0, 0] = x2
175		atom_x[5] = 7.; // right[0, 1] = 7
176		atom_x[6] = ax[3]; // right[1, 0] = x3
177		atom_x[7] = 8.; // right[1, 1] = 8
178		// ------------------------------------------------------------------
179		/*
180		[ x0 , x1 ] * [ x2 , 7 ] = [ x0x2 + x1x3 , x07 + x18 ]
181		[ 5 , 6 ] [ x3 , 8 ] [ 5x2 + 6x3 , 57 + 68 ]
182		*/
183		vector< <a href="ad.xml" target="_top">AD</a><double> > atom_y(nr_result * nc_result);
184		afun(atom_x, atom_y);
185
186		ok &= (atom_y[0] == x[0]x[2] + x[1]x[3]) & Variable(atom_y[0]);
187		ok &= (atom_y[1] == x[0]7. + x[1]8. ) & Variable(atom_y[1]);
188		ok &= (atom_y[2] == 5.x[2] + 6.x[3]) & Variable(atom_y[2]);
189		ok &= (atom_y[3] == 5.7. + 6.8. ) & Parameter(atom_y[3]);
190
191		// ------------------------------------------------------------------
192		// define the function g : x -> atom_y
193		// g(x) = [ x0x2 + x1x3 , x07 + x18 , 5x2 + 6x3 , 57 + 68 ]^T
194		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> g(ax, atom_y);
195		</pre></font></code>
196
197		<br/>
	149	// start recording with four independent varables
	150	size_t n = 4;
	151	vector<double> x(n);
	152	vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
	153	for(j = 0; j < n; j++)
	154	ax[j] = x[j] = j + 1;
	155	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
	156
	157	// ------------------------------------------------------------------
	158	vector< <a href="ad.xml" target="_top">AD</a><double> > atom_x(nr_result * n_middle + n_middle * nc_result);
	159
	160	// left matrix
	161	atom_x[0] = ax[0]; // left[0, 0] = x0
	162	atom_x[1] = ax[1]; // left[0, 1] = x1
	163	atom_x[2] = 5.; // left[1, 0] = 5
	164	atom_x[3] = 6.; // left[1, 1] = 6
	165
	166	// right matix
	167	atom_x[4] = ax[2]; // right[0, 0] = x2
	168	atom_x[5] = 7.; // right[0, 1] = 7
	169	atom_x[6] = ax[3]; // right[1, 0] = x3
	170	atom_x[7] = 8.; // right[1, 1] = 8
	171	// ------------------------------------------------------------------
	172	/*
	173	[ x0 , x1 ] * [ x2 , 7 ] = [ x0x2 + x1x3 , x07 + x18 ]
	174	[ 5 , 6 ] [ x3 , 8 ] [ 5x2 + 6x3 , 57 + 68 ]
	175	*/
	176	vector< <a href="ad.xml" target="_top">AD</a><double> > atom_y(nr_result * nc_result);
	177	afun(atom_x, atom_y);
	178
	179	ok &= (atom_y[0] == x[0]x[2] + x[1]x[3]) & Variable(atom_y[0]);
	180	ok &= (atom_y[1] == x[0]7. + x[1]8. ) & Variable(atom_y[1]);
	181	ok &= (atom_y[2] == 5.x[2] + 6.x[3]) & Variable(atom_y[2]);
	182	ok &= (atom_y[3] == 5.7. + 6.8. ) & Parameter(atom_y[3]);
	183
	184	// ------------------------------------------------------------------
	185	// define the function g : x -> atom_y
	186	// g(x) = [ x0x2 + x1x3 , x07 + x18 , 5x2 + 6x3 , 57 + 68 ]^T
	187	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> g(ax, atom_y);
	188	</pre></font></code>
198	189	<br/>
199	190	<b><a name="Use Atomic Function.forward" id="Use Atomic Function.forward">forward</a></b>
200	191
201	192	<code><font color='blue'><pre style='display:inline'>
202		// Test zero order forward mode evaluation of g(x)
203		size_t m = atom_y.size();
204		vector<double> y(m);
205		for(j = 0; j < n; j++)
206		x[j] = j + 2;
207		y = g.<a href="forward.xml" target="_top">Forward</a>(0, x);
208		ok &= y[0] == x[0] * x[2] + x[1] * x[3];
209		ok &= y[1] == x[0] * 7. + x[1] * 8.;
210		ok &= y[2] == 5. * x[2] + 6. * x[3];
211		ok &= y[3] == 5. * 7. + 6. * 8.;
212
213		//----------------------------------------------------------------------
214		// Test first order forward mode evaluation of g'(x) * [1, 2, 3, 4]^T
215		// g'(x) = [ x2, x3, x0, x1 ]
216		// [ 7 , 8, 0, 0 ]
217		// [ 0 , 0, 5, 6 ]
218		// [ 0 , 0, 0, 0 ]
219		CppAD::vector<double> dx(n), dy(m);
220		for(j = 0; j < n; j++)
221		dx[j] = j + 1;
222		dy = g.<a href="forward.xml" target="_top">Forward</a>(1, dx);
223		ok &= dy[0] == 1. * x[2] + 2. * x[3] + 3. * x[0] + 4. * x[1];
224		ok &= dy[1] == 1. * 7. + 2. * 8. + 3. * 0. + 4. * 0.;
225		ok &= dy[2] == 1. * 0. + 2. * 0. + 3. * 5. + 4. * 6.;
226		ok &= dy[3] == 1. * 0. + 2. * 0. + 3. * 0. + 4. * 0.;
227
228		//----------------------------------------------------------------------
229		// Test second order forward mode
230		// g_0^2 (x) = [ 0, 0, 1, 0 ], g_0^2 (x) * [1] = [3]
231		// [ 0, 0, 0, 1 ] [2] [4]
232		// [ 1, 0, 0, 0 ] [3] [1]
233		// [ 0, 1, 0, 0 ] [4] [2]
234		CppAD::vector<double> ddx(n), ddy(m);
235		for(j = 0; j < n; j++)
236		ddx[j] = 0.;
237		ddy = g.<a href="forward.xml" target="_top">Forward</a>(2, ddx);
238
239		// [1, 2, 3, 4] * g_0^2 (x) * [1, 2, 3, 4]^T = 13 + 24 + 31 + 42
240		ok &= 2. * ddy[0] == 1. * 3. + 2. * 4. + 3. * 1. + 4. * 2.;
241
242		// for i > 0, [1, 2, 3, 4] * g_i^2 (x) * [1, 2, 3, 4]^T = 0
243		ok &= ddy[1] == 0.;
244		ok &= ddy[2] == 0.;
245		ok &= ddy[3] == 0.;
246		</pre></font></code>
247
248		<br/>
	193	// Test zero order forward mode evaluation of g(x)
	194	size_t m = atom_y.size();
	195	vector<double> y(m);
	196	for(j = 0; j < n; j++)
	197	x[j] = j + 2;
	198	y = g.<a href="forward.xml" target="_top">Forward</a>(0, x);
	199	ok &= y[0] == x[0] * x[2] + x[1] * x[3];
	200	ok &= y[1] == x[0] * 7. + x[1] * 8.;
	201	ok &= y[2] == 5. * x[2] + 6. * x[3];
	202	ok &= y[3] == 5. * 7. + 6. * 8.;
	203
	204	//----------------------------------------------------------------------
	205	// Test first order forward mode evaluation of g'(x) * [1, 2, 3, 4]^T
	206	// g'(x) = [ x2, x3, x0, x1 ]
	207	// [ 7 , 8, 0, 0 ]
	208	// [ 0 , 0, 5, 6 ]
	209	// [ 0 , 0, 0, 0 ]
	210	CppAD::vector<double> dx(n), dy(m);
	211	for(j = 0; j < n; j++)
	212	dx[j] = j + 1;
	213	dy = g.<a href="forward.xml" target="_top">Forward</a>(1, dx);
	214	ok &= dy[0] == 1. * x[2] + 2. * x[3] + 3. * x[0] + 4. * x[1];
	215	ok &= dy[1] == 1. * 7. + 2. * 8. + 3. * 0. + 4. * 0.;
	216	ok &= dy[2] == 1. * 0. + 2. * 0. + 3. * 5. + 4. * 6.;
	217	ok &= dy[3] == 1. * 0. + 2. * 0. + 3. * 0. + 4. * 0.;
	218
	219	//----------------------------------------------------------------------
	220	// Test second order forward mode
	221	// g_0^2 (x) = [ 0, 0, 1, 0 ], g_0^2 (x) * [1] = [3]
	222	// [ 0, 0, 0, 1 ] [2] [4]
	223	// [ 1, 0, 0, 0 ] [3] [1]
	224	// [ 0, 1, 0, 0 ] [4] [2]
	225	CppAD::vector<double> ddx(n), ddy(m);
	226	for(j = 0; j < n; j++)
	227	ddx[j] = 0.;
	228	ddy = g.<a href="forward.xml" target="_top">Forward</a>(2, ddx);
	229
	230	// [1, 2, 3, 4] * g_0^2 (x) * [1, 2, 3, 4]^T = 13 + 24 + 31 + 42
	231	ok &= 2. * ddy[0] == 1. * 3. + 2. * 4. + 3. * 1. + 4. * 2.;
	232
	233	// for i > 0, [1, 2, 3, 4] * g_i^2 (x) * [1, 2, 3, 4]^T = 0
	234	ok &= ddy[1] == 0.;
	235	ok &= ddy[2] == 0.;
	236	ok &= ddy[3] == 0.;
	237	</pre></font></code>
249	238	<br/>
250	239	<b><a name="Use Atomic Function.reverse" id="Use Atomic Function.reverse">reverse</a></b>
251	240
252	241	<code><font color='blue'><pre style='display:inline'>
253		// Test second order reverse mode
254		CppAD::vector<double> w(m), dw(2 * n);
255		for(i = 0; i < m; i++)
256		w[i] = 0.;
257		w[0] = 1.;
258		dw = g.<a href="reverse.xml" target="_top">Reverse</a>(2, w);
259
260		// g_0'(x) = [ x2, x3, x0, x1 ]
261		ok &= dw[0*2 + 0] == x[2];
262		ok &= dw[1*2 + 0] == x[3];
263		ok &= dw[2*2 + 0] == x[0];
264		ok &= dw[3*2 + 0] == x[1];
265
266		// g_0'(x) * [1, 2, 3, 4] = 1 * x2 + 2 * x3 + 3 * x0 + 4 * x1
267		// g_0^2 (x) * [1, 2, 3, 4] = [3, 4, 1, 2]
268		ok &= dw[0*2 + 1] == 3.;
269		ok &= dw[1*2 + 1] == 4.;
270		ok &= dw[2*2 + 1] == 1.;
271		ok &= dw[3*2 + 1] == 2.;
272		</pre></font></code>
273
274		<br/>
	242	// Test second order reverse mode
	243	CppAD::vector<double> w(m), dw(2 * n);
	244	for(i = 0; i < m; i++)
	245	w[i] = 0.;
	246	w[0] = 1.;
	247	dw = g.<a href="reverse.xml" target="_top">Reverse</a>(2, w);
	248
	249	// g_0'(x) = [ x2, x3, x0, x1 ]
	250	ok &= dw[0*2 + 0] == x[2];
	251	ok &= dw[1*2 + 0] == x[3];
	252	ok &= dw[2*2 + 0] == x[0];
	253	ok &= dw[3*2 + 0] == x[1];
	254
	255	// g_0'(x) * [1, 2, 3, 4] = 1 * x2 + 2 * x3 + 3 * x0 + 4 * x1
	256	// g_0^2 (x) * [1, 2, 3, 4] = [3, 4, 1, 2]
	257	ok &= dw[0*2 + 1] == 3.;
	258	ok &= dw[1*2 + 1] == 4.;
	259	ok &= dw[2*2 + 1] == 1.;
	260	ok &= dw[3*2 + 1] == 2.;
	261	</pre></font></code>
275	262	<br/>
276	263	<b><a name="Use Atomic Function.option" id="Use Atomic Function.option">option</a></b>
277	264
278	265	<code><font color='blue'><pre style='display:inline'>
279		//----------------------------------------------------------------------
280		// Test both the boolean and set sparsity at the atomic level
281		for(size_t sparse_index = 0; sparse_index < 2; sparse_index++)
282		{ if( sparse_index == 0 )
283		afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
284		else afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
285		</pre></font></code>
286
287		<br/>
	266	//----------------------------------------------------------------------
	267	// Test both the boolean and set sparsity at the atomic level
	268	for(size_t sparse_index = 0; sparse_index < 2; sparse_index++)
	269	{ if( sparse_index == 0 )
	270	afun.option( CppAD::atomic_base<double>::bool_sparsity_enum );
	271	else afun.option( CppAD::atomic_base<double>::set_sparsity_enum );
	272	</pre></font></code>
288	273	<br/>
289	274	<b><a name="Use Atomic Function.for_sparse_jac" id="Use Atomic Function.for_sparse_jac">for_sparse_jac</a></b>
290	275
291	276	<code><font color='blue'><pre style='display:inline'>
292		// Test forward Jacobian sparsity pattern
293		/*
294		g(x) = [ x0x2 + x1x3 , x07 + x18 , 5x2 + 6x3 , 57 + 68 ]^T
295		so the sparsity pattern should be
296		s[0] = {0, 1, 2, 3}
297		s[1] = {0, 1}
298		s[2] = {2, 3}
299		s[3] = {}
300		*/
301		CppAD::vector< std::set<size_t> > r(n), s(m);
302		for(j = 0; j < n; j++)
303		{ assert( r[j].empty() );
304		r[j].insert(j);
305		}
306		s = g.ForSparseJac(n, r);
307		for(j = 0; j < n; j++)
308		{ // s[0] = {0, 1, 2, 3}
309		ok &= s[0].find(j) != s[0].end();
310		// s[1] = {0, 1}
311		if( j == 0 \|\| j == 1 )
312		ok &= s[1].find(j) != s[1].end();
313		else ok &= s[1].find(j) == s[1].end();
314		// s[2] = {2, 3}
315		if( j == 2 \|\| j == 3 )
316		ok &= s[2].find(j) != s[2].end();
317		else ok &= s[2].find(j) == s[2].end();
318		}
319		// s[3] == {}
320		ok &= s[3].empty();
321		</pre></font></code>
322
323		<br/>
	277	// Test forward Jacobian sparsity pattern
	278	/*
	279	g(x) = [ x0x2 + x1x3 , x07 + x18 , 5x2 + 6x3 , 57 + 68 ]^T
	280	so the sparsity pattern should be
	281	s[0] = {0, 1, 2, 3}
	282	s[1] = {0, 1}
	283	s[2] = {2, 3}
	284	s[3] = {}
	285	*/
	286	CppAD::vector< std::set<size_t> > r(n), s(m);
	287	for(j = 0; j < n; j++)
	288	{ assert( r[j].empty() );
	289	r[j].insert(j);
	290	}
	291	s = g.ForSparseJac(n, r);
	292	for(j = 0; j < n; j++)
	293	{ // s[0] = {0, 1, 2, 3}
	294	ok &= s[0].find(j) != s[0].end();
	295	// s[1] = {0, 1}
	296	if( j == 0 \|\| j == 1 )
	297	ok &= s[1].find(j) != s[1].end();
	298	else ok &= s[1].find(j) == s[1].end();
	299	// s[2] = {2, 3}
	300	if( j == 2 \|\| j == 3 )
	301	ok &= s[2].find(j) != s[2].end();
	302	else ok &= s[2].find(j) == s[2].end();
	303	}
	304	// s[3] == {}
	305	ok &= s[3].empty();
	306	</pre></font></code>
324	307	<br/>
325	308	<b><a name="Use Atomic Function.rev_sparse_jac" id="Use Atomic Function.rev_sparse_jac">rev_sparse_jac</a></b>
326	309
327	310	<code><font color='blue'><pre style='display:inline'>
328		// Test reverse Jacobian sparsity pattern
329		for(i = 0; i < m; i++)
330		{ s[i].clear();
331		s[i].insert(i);
332		}
333		r = g.RevSparseJac(m, s);
334		for(j = 0; j < n ; j++)
335		{ // r[0] = {0, 1, 2, 3}
336		ok &= r[0].find(j) != r[0].end();
337		// r[1] = {0, 1}
338		if( j == 0 \|\| j == 1 )
339		ok &= r[1].find(j) != r[1].end();
340		else ok &= r[1].find(j) == r[1].end();
341		// r[2] = {2, 3}
342		if( j == 2 \|\| j == 3 )
343		ok &= r[2].find(j) != r[2].end();
344		else ok &= r[2].find(j) == r[2].end();
345		}
346		// r[3] == {}
347		ok &= r[3].empty();
348		</pre></font></code>
349
350		<br/>
	311	// Test reverse Jacobian sparsity pattern
	312	for(i = 0; i < m; i++)
	313	{ s[i].clear();
	314	s[i].insert(i);
	315	}
	316	r = g.RevSparseJac(m, s);
	317	for(j = 0; j < n ; j++)
	318	{ // r[0] = {0, 1, 2, 3}
	319	ok &= r[0].find(j) != r[0].end();
	320	// r[1] = {0, 1}
	321	if( j == 0 \|\| j == 1 )
	322	ok &= r[1].find(j) != r[1].end();
	323	else ok &= r[1].find(j) == r[1].end();
	324	// r[2] = {2, 3}
	325	if( j == 2 \|\| j == 3 )
	326	ok &= r[2].find(j) != r[2].end();
	327	else ok &= r[2].find(j) == r[2].end();
	328	}
	329	// r[3] == {}
	330	ok &= r[3].empty();
	331	</pre></font></code>
351	332	<br/>
352	333	<b><a name="Use Atomic Function.rev_sparse_hes" id="Use Atomic Function.rev_sparse_hes">rev_sparse_hes</a></b>
353	334
354	335	<code><font color='blue'><pre style='display:inline'>
355		/* Test reverse Hessian sparsity pattern
356		g_0^2 (x) = [ 0, 0, 1, 0 ] and for i > 0, g_i^2 = 0
357		[ 0, 0, 0, 1 ]
358		[ 1, 0, 0, 0 ]
359		[ 0, 1, 0, 0 ]
360		so for the sparsity pattern for the first component of g is
361		h[0] = {2}
362		h[1] = {3}
363		h[2] = {0}
364		h[3] = {1}
365		*/
366		CppAD::vector< std::set<size_t> > h(n), t(1);
367		t[0].clear();
368		t[0].insert(0);
369		h = g.RevSparseHes(n, t);
370		size_t check[] = {2, 3, 0, 1};
371		for(j = 0; j < n; j++)
372		{ // h[j] = { check[j] }
373		for(i = 0; i < n; i++)
374		{ if( i == check[j] )
375		ok &= h[j].find(i) != h[j].end();
376		else ok &= h[j].find(i) == h[j].end();
377		}
378		}
379		t[0].clear();
380		for( j = 1; j < n; j++)
381		t[0].insert(j);
382		h = g.RevSparseHes(n, t);
383		for(j = 0; j < n; j++)
384		{ // h[j] = { }
385		for(i = 0; i < n; i++)
386		ok &= h[j].find(i) == h[j].end();
387		}
388
389		//-----------------------------------------------------------------
390		} // end for(size_t sparse_index ...
391		//-----------------------------------------------------------------
392
393		return ok;
	336	/* Test reverse Hessian sparsity pattern
	337	g_0^2 (x) = [ 0, 0, 1, 0 ] and for i > 0, g_i^2 = 0
	338	[ 0, 0, 0, 1 ]
	339	[ 1, 0, 0, 0 ]
	340	[ 0, 1, 0, 0 ]
	341	so for the sparsity pattern for the first component of g is
	342	h[0] = {2}
	343	h[1] = {3}
	344	h[2] = {0}
	345	h[3] = {1}
	346	*/
	347	CppAD::vector< std::set<size_t> > h(n), t(1);
	348	t[0].clear();
	349	t[0].insert(0);
	350	h = g.RevSparseHes(n, t);
	351	size_t check[] = {2, 3, 0, 1};
	352	for(j = 0; j < n; j++)
	353	{ // h[j] = { check[j] }
	354	for(i = 0; i < n; i++)
	355	{ if( i == check[j] )
	356	ok &= h[j].find(i) != h[j].end();
	357	else ok &= h[j].find(i) == h[j].end();
	358	}
	359	}
	360	t[0].clear();
	361	for( j = 1; j < n; j++)
	362	t[0].insert(j);
	363	h = g.RevSparseHes(n, t);
	364	for(j = 0; j < n; j++)
	365	{ // h[j] = { }
	366	for(i = 0; i < n; i++)
	367	ok &= h[j].find(i) == h[j].end();
	368	}
	369
	370	//-----------------------------------------------------------------
	371	} // end for(size_t sparse_index ...
	372	//-----------------------------------------------------------------
	373
	374	return ok;
394	375	}
395	376	</pre></font></code>
396
397
398	377
399	378	<hr/>Input File: example/atomic/mat_mul.cpp
400	379

+453

-483

doc/atomic_matrix_mul.hpp.xml less more

5	5	<title>Matrix Multiply as an Atomic Operation</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Matrix Multiply as an 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	<meta name="keywords" id="keywords" content=" matrix multiply 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

99	99	</select>
100	100	</td>
101	101	</tr></table><br/>
102
103
104
105	102	<center><b><big><big>Matrix Multiply as an Atomic Operation</big></big></b></center>
106	103	<br/>
107	104	<b><big><a name="Start Class Definition" id="Start Class Definition">Start Class Definition</a></big></b>

112	109	using CppAD::vector;
113	110	//
114	111	void my_union(
115		std::set<size_t>& result ,
116		const std::set<size_t>& left ,
117		const std::set<size_t>& right )
118		{ std::set<size_t> temp;
119		std::set_union(
120		left.begin() ,
121		left.end() ,
122		right.begin() ,
123		right.end() ,
124		std::inserter(temp, temp.begin())
125		);
126		result.swap(temp);
	112	std::set<size_t>& result ,
	113	const std::set<size_t>& left ,
	114	const std::set<size_t>& right )
	115	{ std::set<size_t> temp;
	116	std::set_union(
	117	left.begin() ,
	118	left.end() ,
	119	right.begin() ,
	120	right.end() ,
	121	std::inserter(temp, temp.begin())
	122	);
	123	result.swap(temp);
127	124	}
128	125	//
129	126	// matrix result = left * right
130	127	class matrix_mul : public CppAD::atomic_base<double> {
131	128	</pre></font></code>
132
133		<br/>
134	129	<br/>
135	130	<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
136	131
137	132	<code><font color='blue'><pre style='display:inline'>
138		private:
139		// number of rows in left operand and in the result
140		const size_t nr_result_;
141		// number of columns in left operand and rows in right operand
142		const size_t n_middle_;
143		// number of columns in right operand and in the result
144		const size_t nc_result_;
145		// dimension of the domain space
146		const size_t n_;
147		// dimension of the range space
	133	private:
	134	// number of rows in left operand and in the result
	135	const size_t nr_result_;
	136	// number of columns in left operand and rows in right operand
	137	const size_t n_middle_;
	138	// number of columns in right operand and in the result
	139	const size_t nc_result_;
	140	// dimension of the domain space
	141	const size_t n_;
	142	// dimension of the range space
148	143	# ifndef NDEBUG
149		const size_t m_;
	144	const size_t m_;
150	145	# endif
151		public:
152		// ---------------------------------------------------------------------
153		// constructor
154		matrix_mul(size_t nr_result, size_t n_middle, size_t nc_result)
155		: CppAD::atomic_base<double>("matrix_mul"),
156		nr_result_(nr_result) ,
157		n_middle_(n_middle) ,
158		nc_result_(nc_result) ,
159		n_( nr_result * n_middle + n_middle * nc_result )
	146	public:
	147	// ---------------------------------------------------------------------
	148	// constructor
	149	matrix_mul(size_t nr_result, size_t n_middle, size_t nc_result)
	150	: CppAD::atomic_base<double>("matrix_mul"),
	151	nr_result_(nr_result) ,
	152	n_middle_(n_middle) ,
	153	nc_result_(nc_result) ,
	154	n_( nr_result * n_middle + n_middle * nc_result )
160	155	# ifndef NDEBUG
161		, m_( n_middle * nc_result )
	156	, m_( n_middle * nc_result )
162	157	# endif
163		{ }
164		private:
165		</pre></font></code>
166
167		<br/>
	158	{ }
	159	private:
	160	</pre></font></code>
168	161	<br/>
169	162	<b><big><a name="Left Operand Element Index" id="Left Operand Element Index">Left Operand Element Index</a></big></b>
170	163
171	164	<code><font color='blue'><pre style='display:inline'>
172		// left matrix element index in the taylor coefficient vector tx.
173		size_t left(
174		size_t i , // left matrix row index
175		size_t j , // left matrix column index
176		size_t k , // Taylor coeffocient order
177		size_t nk ) // number of Taylor coefficients in tx
178		{ assert( i < nr_result_ );
179		assert( j < n_middle_ );
180		return (i * n_middle_ + j) * nk + k;
181		}
182		</pre></font></code>
183
184		<br/>
	165	// left matrix element index in the taylor coefficient vector tx.
	166	size_t left(
	167	size_t i , // left matrix row index
	168	size_t j , // left matrix column index
	169	size_t k , // Taylor coeffocient order
	170	size_t nk ) // number of Taylor coefficients in tx
	171	{ assert( i < nr_result_ );
	172	assert( j < n_middle_ );
	173	return (i * n_middle_ + j) * nk + k;
	174	}
	175	</pre></font></code>
185	176	<br/>
186	177	<b><big><a name="Right Operand Element Index" id="Right Operand Element Index">Right Operand Element Index</a></big></b>
187	178
188	179	<code><font color='blue'><pre style='display:inline'>
189		// right matrix element index in the taylor coefficient vector tx.
190		size_t right(
191		size_t i , // right matrix row index
192		size_t j , // right matrix column index
193		size_t k , // Taylor coeffocient order
194		size_t nk ) // number of Taylor coefficients in tx
195		{ assert( i < n_middle_ );
196		assert( j < nc_result_ );
197		size_t offset = nr_result_ * n_middle_;
198		return (offset + i * nc_result_ + j) * nk + k;
199		}
200		</pre></font></code>
201
202		<br/>
	180	// right matrix element index in the taylor coefficient vector tx.
	181	size_t right(
	182	size_t i , // right matrix row index
	183	size_t j , // right matrix column index
	184	size_t k , // Taylor coeffocient order
	185	size_t nk ) // number of Taylor coefficients in tx
	186	{ assert( i < n_middle_ );
	187	assert( j < nc_result_ );
	188	size_t offset = nr_result_ * n_middle_;
	189	return (offset + i * nc_result_ + j) * nk + k;
	190	}
	191	</pre></font></code>
203	192	<br/>
204	193	<b><big><a name="Result Element Index" id="Result Element Index">Result Element Index</a></big></b>
205	194
206	195	<code><font color='blue'><pre style='display:inline'>
207		// result matrix element index in the taylor coefficient vector ty.
208		size_t result(
209		size_t i , // result matrix row index
210		size_t j , // result matrix column index
211		size_t k , // Taylor coeffocient order
212		size_t nk ) // number of Taylor coefficients in ty
213		{ assert( i < nr_result_ );
214		assert( j < nc_result_ );
215		return (i * nc_result_ + j) * nk + k;
216		}
217		</pre></font></code>
218
219		<br/>
	196	// result matrix element index in the taylor coefficient vector ty.
	197	size_t result(
	198	size_t i , // result matrix row index
	199	size_t j , // result matrix column index
	200	size_t k , // Taylor coeffocient order
	201	size_t nk ) // number of Taylor coefficients in ty
	202	{ assert( i < nr_result_ );
	203	assert( j < nc_result_ );
	204	return (i * nc_result_ + j) * nk + k;
	205	}
	206	</pre></font></code>
220	207	<br/>
221	208	<b><big><a name="Forward Matrix Multipliy" id="Forward Matrix Multipliy">Forward Matrix Multipliy</a></big></b>
222	209
223	210	<code><font color='blue'><pre style='display:inline'>
224		// Forward mode multiply Taylor coefficients in tx and sum into ty
225		// (for one pair of left and right orders)
226		void forward_multiply(
227		size_t k_left , // order for left coefficients
228		size_t k_right , // order for right coefficients
229		const vector<double>& tx , // domain space Taylor coefficients
230		vector<double>& ty ) // range space Taylor coefficients
231		{ size_t nk = tx.size() / n_;
232		assert( nk == ty.size() / m_ );
233		//
234		size_t k_result = k_left + k_right;
235		assert( k_result < nk );
236		//
237		for(size_t i = 0; i < nr_result_; i++)
238		{ for(size_t j = 0; j < nc_result_; j++)
239		{ double sum = 0.0;
240		for(size_t ell = 0; ell < n_middle_; ell++)
241		{ size_t i_left = left(i, ell, k_left, nk);
242		size_t i_right = right(ell, j, k_right, nk);
243		sum += tx[i_left] * tx[i_right];
244		}
245		size_t i_result = result(i, j, k_result, nk);
246		ty[i_result] += sum;
247		}
248		}
249		}
250		</pre></font></code>
251
252		<br/>
	211	// Forward mode multiply Taylor coefficients in tx and sum into ty
	212	// (for one pair of left and right orders)
	213	void forward_multiply(
	214	size_t k_left , // order for left coefficients
	215	size_t k_right , // order for right coefficients
	216	const vector<double>& tx , // domain space Taylor coefficients
	217	vector<double>& ty ) // range space Taylor coefficients
	218	{ size_t nk = tx.size() / n_;
	219	assert( nk == ty.size() / m_ );
	220	//
	221	size_t k_result = k_left + k_right;
	222	assert( k_result < nk );
	223	//
	224	for(size_t i = 0; i < nr_result_; i++)
	225	{ for(size_t j = 0; j < nc_result_; j++)
	226	{ double sum = 0.0;
	227	for(size_t ell = 0; ell < n_middle_; ell++)
	228	{ size_t i_left = left(i, ell, k_left, nk);
	229	size_t i_right = right(ell, j, k_right, nk);
	230	sum += tx[i_left] * tx[i_right];
	231	}
	232	size_t i_result = result(i, j, k_result, nk);
	233	ty[i_result] += sum;
	234	}
	235	}
	236	}
	237	</pre></font></code>
253	238	<br/>
254	239	<b><big><a name="Reverse Matrix Multipliy" id="Reverse Matrix Multipliy">Reverse Matrix Multipliy</a></big></b>
255	240
256	241	<code><font color='blue'><pre style='display:inline'>
257		// Reverse mode partials of Taylor coefficients and sum into px
258		// (for one pair of left and right orders)
259		void reverse_multiply(
260		size_t k_left , // order for left coefficients
261		size_t k_right , // order for right coefficients
262		const vector<double>& tx , // domain space Taylor coefficients
263		const vector<double>& ty , // range space Taylor coefficients
264		vector<double>& px , // partials w.r.t. tx
265		const vector<double>& py ) // partials w.r.t. ty
266		{ size_t nk = tx.size() / n_;
267		assert( nk == ty.size() / m_ );
268		assert( tx.size() == px.size() );
269		assert( ty.size() == py.size() );
270		//
271		size_t k_result = k_left + k_right;
272		assert( k_result < nk );
273		//
274		for(size_t i = 0; i < nr_result_; i++)
275		{ for(size_t j = 0; j < nc_result_; j++)
276		{ size_t i_result = result(i, j, k_result, nk);
277		for(size_t ell = 0; ell < n_middle_; ell++)
278		{ size_t i_left = left(i, ell, k_left, nk);
279		size_t i_right = right(ell, j, k_right, nk);
280		// sum += tx[i_left] * tx[i_right];
281		px[i_left] += tx[i_right] * py[i_result];
282		px[i_right] += tx[i_left] * py[i_result];
283		}
284		}
285		}
286		return;
287		}
288		</pre></font></code>
289
290		<br/>
	242	// Reverse mode partials of Taylor coefficients and sum into px
	243	// (for one pair of left and right orders)
	244	void reverse_multiply(
	245	size_t k_left , // order for left coefficients
	246	size_t k_right , // order for right coefficients
	247	const vector<double>& tx , // domain space Taylor coefficients
	248	const vector<double>& ty , // range space Taylor coefficients
	249	vector<double>& px , // partials w.r.t. tx
	250	const vector<double>& py ) // partials w.r.t. ty
	251	{ size_t nk = tx.size() / n_;
	252	assert( nk == ty.size() / m_ );
	253	assert( tx.size() == px.size() );
	254	assert( ty.size() == py.size() );
	255	//
	256	size_t k_result = k_left + k_right;
	257	assert( k_result < nk );
	258	//
	259	for(size_t i = 0; i < nr_result_; i++)
	260	{ for(size_t j = 0; j < nc_result_; j++)
	261	{ size_t i_result = result(i, j, k_result, nk);
	262	for(size_t ell = 0; ell < n_middle_; ell++)
	263	{ size_t i_left = left(i, ell, k_left, nk);
	264	size_t i_right = right(ell, j, k_right, nk);
	265	// sum += tx[i_left] * tx[i_right];
	266	px[i_left] += tx[i_right] * py[i_result];
	267	px[i_right] += tx[i_left] * py[i_result];
	268	}
	269	}
	270	}
	271	return;
	272	}
	273	</pre></font></code>
291	274	<br/>
292	275	<b><big><a name="forward" id="forward">forward</a></big></b>
293	276
294	277	<code><font color='blue'><pre style='display:inline'>
295		// forward mode routine called by CppAD
296		bool forward(
297		size_t q ,
298		size_t p ,
299		const vector<bool>& vx ,
300		vector<bool>& vy ,
301		const vector<double>& tx ,
302		vector<double>& ty
303		)
304		{ size_t p1 = p + 1;
305		assert( vx.size() == 0 \|\| n_ == vx.size() );
306		assert( vx.size() == 0 \|\| m_ == vy.size() );
307		assert( n_ * p1 == tx.size() );
308		assert( m_ * p1 == ty.size() );
309		size_t i, j, ell;
310
311		// check if we are computing vy information
312		if( vx.size() > 0 )
313		{ size_t nk = 1;
314		size_t k = 0;
315		for(i = 0; i < nr_result_; i++)
316		{ for(j = 0; j < nc_result_; j++)
317		{ bool var = false;
318		for(ell = 0; ell < n_middle_; ell++)
319		{ size_t i_left = left(i, ell, k, nk);
320		size_t i_right = right(ell, j, k, nk);
321		bool nz_left = vx[i_left] \|(tx[i_left] != 0.);
322		bool nz_right = vx[i_right]\|(tx[i_right] != 0.);
323		// if not multiplying by the constant zero
324		if( nz_left & nz_right )
325		var \|= bool(vx[i_left]) \| bool(vx[i_right]);
326		}
327		size_t i_result = result(i, j, k, nk);
328		vy[i_result] = var;
329		}
330		}
331		}
332
333		// initialize result as zero
334		size_t k;
335		for(i = 0; i < nr_result_; i++)
336		{ for(j = 0; j < nc_result_; j++)
337		{ for(k = q; k <= p; k++)
338		ty[ result(i, j, k, p1) ] = 0.0;
339		}
340		}
341		for(k = q; k <= p; k++)
342		{ // sum the produces that result in order k
343		for(ell = 0; ell <= k; ell++)
344		forward_multiply(ell, k - ell, tx, ty);
345		}
346
347		// all orders are implented, so always return true
348		return true;
349		}
350		</pre></font></code>
351
352		<br/>
	278	// forward mode routine called by CppAD
	279	bool forward(
	280	size_t q ,
	281	size_t p ,
	282	const vector<bool>& vx ,
	283	vector<bool>& vy ,
	284	const vector<double>& tx ,
	285	vector<double>& ty
	286	)
	287	{ size_t p1 = p + 1;
	288	assert( vx.size() == 0 \|\| n_ == vx.size() );
	289	assert( vx.size() == 0 \|\| m_ == vy.size() );
	290	assert( n_ * p1 == tx.size() );
	291	assert( m_ * p1 == ty.size() );
	292	size_t i, j, ell;
	293
	294	// check if we are computing vy information
	295	if( vx.size() > 0 )
	296	{ size_t nk = 1;
	297	size_t k = 0;
	298	for(i = 0; i < nr_result_; i++)
	299	{ for(j = 0; j < nc_result_; j++)
	300	{ bool var = false;
	301	for(ell = 0; ell < n_middle_; ell++)
	302	{ size_t i_left = left(i, ell, k, nk);
	303	size_t i_right = right(ell, j, k, nk);
	304	bool nz_left = vx[i_left] \|(tx[i_left] != 0.);
	305	bool nz_right = vx[i_right]\|(tx[i_right] != 0.);
	306	// if not multiplying by the constant zero
	307	if( nz_left & nz_right )
	308	var \|= bool(vx[i_left]) \| bool(vx[i_right]);
	309	}
	310	size_t i_result = result(i, j, k, nk);
	311	vy[i_result] = var;
	312	}
	313	}
	314	}
	315
	316	// initialize result as zero
	317	size_t k;
	318	for(i = 0; i < nr_result_; i++)
	319	{ for(j = 0; j < nc_result_; j++)
	320	{ for(k = q; k <= p; k++)
	321	ty[ result(i, j, k, p1) ] = 0.0;
	322	}
	323	}
	324	for(k = q; k <= p; k++)
	325	{ // sum the produces that result in order k
	326	for(ell = 0; ell <= k; ell++)
	327	forward_multiply(ell, k - ell, tx, ty);
	328	}
	329
	330	// all orders are implented, so always return true
	331	return true;
	332	}
	333	</pre></font></code>
353	334	<br/>
354	335	<b><big><a name="reverse" id="reverse">reverse</a></big></b>
355	336
356	337	<code><font color='blue'><pre style='display:inline'>
357		// reverse mode routine called by CppAD
358		virtual bool reverse(
359		size_t p ,
360		const vector<double>& tx ,
361		const vector<double>& ty ,
362		vector<double>& px ,
363		const vector<double>& py
364		)
365		{ size_t p1 = p + 1;
366		assert( n_ * p1 == tx.size() );
367		assert( m_ * p1 == ty.size() );
368		assert( px.size() == tx.size() );
369		assert( py.size() == ty.size() );
370
371		// initialize summation
372		for(size_t i = 0; i < px.size(); i++)
373		px[i] = 0.0;
374
375		// number of orders to differentiate
376		size_t k = p1;
377		while(k--)
378		{ // differentiate the produces that result in order k
379		for(size_t ell = 0; ell <= k; ell++)
380		reverse_multiply(ell, k - ell, tx, ty, px, py);
381		}
382
383		// all orders are implented, so always return true
384		return true;
385		}
386		</pre></font></code>
387
388		<br/>
	338	// reverse mode routine called by CppAD
	339	virtual bool reverse(
	340	size_t p ,
	341	const vector<double>& tx ,
	342	const vector<double>& ty ,
	343	vector<double>& px ,
	344	const vector<double>& py
	345	)
	346	{ size_t p1 = p + 1;
	347	assert( n_ * p1 == tx.size() );
	348	assert( m_ * p1 == ty.size() );
	349	assert( px.size() == tx.size() );
	350	assert( py.size() == ty.size() );
	351
	352	// initialize summation
	353	for(size_t i = 0; i < px.size(); i++)
	354	px[i] = 0.0;
	355
	356	// number of orders to differentiate
	357	size_t k = p1;
	358	while(k--)
	359	{ // differentiate the produces that result in order k
	360	for(size_t ell = 0; ell <= k; ell++)
	361	reverse_multiply(ell, k - ell, tx, ty, px, py);
	362	}
	363
	364	// all orders are implented, so always return true
	365	return true;
	366	}
	367	</pre></font></code>
389	368	<br/>
390	369	<b><big><a name="for_sparse_jac" id="for_sparse_jac">for_sparse_jac</a></big></b>
391	370
392	371	<code><font color='blue'><pre style='display:inline'>
393		// forward Jacobian sparsity routine called by CppAD
394		virtual bool for_sparse_jac(
395		size_t q ,
396		const vector<bool>& r ,
397		vector<bool>& s )
398		{ assert( n_ * q == r.size() );
399		assert( m_ * q == s.size() );
400		size_t p;
401
402		// sparsity for S(x) = f'(x) * R
403		size_t nk = 1;
404		size_t k = 0;
405		for(size_t i = 0; i < nr_result_; i++)
406		{ for(size_t j = 0; j < nc_result_; j++)
407		{ size_t i_result = result(i, j, k, nk);
408		for(p = 0; p < q; p++)
409		s[i_result * q + p] = false;
410		for(size_t ell = 0; ell < n_middle_; ell++)
411		{ size_t i_left = left(i, ell, k, nk);
412		size_t i_right = right(ell, j, k, nk);
413		for(p = 0; p < q; p++)
414		{ // cast avoids Microsoft warning (should not be needed)
415		s[i_result * q + p] \|= bool( r[i_left * q + p ] );
416		s[i_result * q + p] \|= bool( r[i_right * q + p ] );
417		}
418		}
419		}
420		}
421		return true;
422		}
423		virtual bool for_sparse_jac(
424		size_t q ,
425		const vector< std::set<size_t> >& r ,
426		vector< std::set<size_t> >& s )
427		{ assert( n_ == r.size() );
428		assert( m_ == s.size() );
429
430		// sparsity for S(x) = f'(x) * R
431		size_t nk = 1;
432		size_t k = 0;
433		for(size_t i = 0; i < nr_result_; i++)
434		{ for(size_t j = 0; j < nc_result_; j++)
435		{ size_t i_result = result(i, j, k, nk);
436		s[i_result].clear();
437		for(size_t ell = 0; ell < n_middle_; ell++)
438		{ size_t i_left = left(i, ell, k, nk);
439		size_t i_right = right(ell, j, k, nk);
440		//
441		my_union( s[i_result], s[i_result], r[i_left] );
442		my_union( s[i_result], s[i_result], r[i_right] );
443		}
444		}
445		}
446		return true;
447		}
448		</pre></font></code>
449
450		<br/>
	372	// forward Jacobian sparsity routine called by CppAD
	373	virtual bool for_sparse_jac(
	374	size_t q ,
	375	const vector<bool>& r ,
	376	vector<bool>& s )
	377	{ assert( n_ * q == r.size() );
	378	assert( m_ * q == s.size() );
	379	size_t p;
	380
	381	// sparsity for S(x) = f'(x) * R
	382	size_t nk = 1;
	383	size_t k = 0;
	384	for(size_t i = 0; i < nr_result_; i++)
	385	{ for(size_t j = 0; j < nc_result_; j++)
	386	{ size_t i_result = result(i, j, k, nk);
	387	for(p = 0; p < q; p++)
	388	s[i_result * q + p] = false;
	389	for(size_t ell = 0; ell < n_middle_; ell++)
	390	{ size_t i_left = left(i, ell, k, nk);
	391	size_t i_right = right(ell, j, k, nk);
	392	for(p = 0; p < q; p++)
	393	{ // cast avoids Microsoft warning (should not be needed)
	394	s[i_result * q + p] \|= bool( r[i_left * q + p ] );
	395	s[i_result * q + p] \|= bool( r[i_right * q + p ] );
	396	}
	397	}
	398	}
	399	}
	400	return true;
	401	}
	402	virtual bool for_sparse_jac(
	403	size_t q ,
	404	const vector< std::set<size_t> >& r ,
	405	vector< std::set<size_t> >& s )
	406	{ assert( n_ == r.size() );
	407	assert( m_ == s.size() );
	408
	409	// sparsity for S(x) = f'(x) * R
	410	size_t nk = 1;
	411	size_t k = 0;
	412	for(size_t i = 0; i < nr_result_; i++)
	413	{ for(size_t j = 0; j < nc_result_; j++)
	414	{ size_t i_result = result(i, j, k, nk);
	415	s[i_result].clear();
	416	for(size_t ell = 0; ell < n_middle_; ell++)
	417	{ size_t i_left = left(i, ell, k, nk);
	418	size_t i_right = right(ell, j, k, nk);
	419	//
	420	my_union( s[i_result], s[i_result], r[i_left] );
	421	my_union( s[i_result], s[i_result], r[i_right] );
	422	}
	423	}
	424	}
	425	return true;
	426	}
	427	</pre></font></code>
451	428	<br/>
452	429	<b><big><a name="rev_sparse_jac" id="rev_sparse_jac">rev_sparse_jac</a></big></b>
453	430
454	431	<code><font color='blue'><pre style='display:inline'>
455		// reverse Jacobian sparsity routine called by CppAD
456		virtual bool rev_sparse_jac(
457		size_t q ,
458		const vector<bool>& rt ,
459		vector<bool>& st )
460		{ assert( n_ * q == st.size() );
461		assert( m_ * q == rt.size() );
462		size_t i, j, p;
463
464		// initialize
465		for(i = 0; i < n_; i++)
466		{ for(p = 0; p < q; p++)
467		st[ i * q + p ] = false;
468		}
469
470		// sparsity for S(x)^T = f'(x)^T * R^T
471		size_t nk = 1;
472		size_t k = 0;
473		for(i = 0; i < nr_result_; i++)
474		{ for(j = 0; j < nc_result_; j++)
475		{ size_t i_result = result(i, j, k, nk);
476		for(size_t ell = 0; ell < n_middle_; ell++)
477		{ size_t i_left = left(i, ell, k, nk);
478		size_t i_right = right(ell, j, k, nk);
479		for(p = 0; p < q; p++)
480		{ st[i_left * q + p] \|= bool( rt[i_result * q + p] );
481		st[i_right* q + p] \|= bool( rt[i_result * q + p] );
482		}
483		}
484		}
485		}
486		return true;
487		}
488		virtual bool rev_sparse_jac(
489		size_t q ,
490		const vector< std::set<size_t> >& rt ,
491		vector< std::set<size_t> >& st )
492		{ assert( n_ == st.size() );
493		assert( m_ == rt.size() );
494		size_t i, j;
495
496		// initialize
497		for(i = 0; i < n_; i++)
498		st[i].clear();
499
500		// sparsity for S(x)^T = f'(x)^T * R^T
501		size_t nk = 1;
502		size_t k = 0;
503		for(i = 0; i < nr_result_; i++)
504		{ for(j = 0; j < nc_result_; j++)
505		{ size_t i_result = result(i, j, k, nk);
506		for(size_t ell = 0; ell < n_middle_; ell++)
507		{ size_t i_left = left(i, ell, k, nk);
508		size_t i_right = right(ell, j, k, nk);
509		//
510		my_union(st[i_left], st[i_left], rt[i_result]);
511		my_union(st[i_right], st[i_right], rt[i_result]);
512		}
513		}
514		}
515		return true;
516		}
517		</pre></font></code>
518
519		<br/>
	432	// reverse Jacobian sparsity routine called by CppAD
	433	virtual bool rev_sparse_jac(
	434	size_t q ,
	435	const vector<bool>& rt ,
	436	vector<bool>& st )
	437	{ assert( n_ * q == st.size() );
	438	assert( m_ * q == rt.size() );
	439	size_t i, j, p;
	440
	441	// initialize
	442	for(i = 0; i < n_; i++)
	443	{ for(p = 0; p < q; p++)
	444	st[ i * q + p ] = false;
	445	}
	446
	447	// sparsity for S(x)^T = f'(x)^T * R^T
	448	size_t nk = 1;
	449	size_t k = 0;
	450	for(i = 0; i < nr_result_; i++)
	451	{ for(j = 0; j < nc_result_; j++)
	452	{ size_t i_result = result(i, j, k, nk);
	453	for(size_t ell = 0; ell < n_middle_; ell++)
	454	{ size_t i_left = left(i, ell, k, nk);
	455	size_t i_right = right(ell, j, k, nk);
	456	for(p = 0; p < q; p++)
	457	{ st[i_left * q + p] \|= bool( rt[i_result * q + p] );
	458	st[i_right* q + p] \|= bool( rt[i_result * q + p] );
	459	}
	460	}
	461	}
	462	}
	463	return true;
	464	}
	465	virtual bool rev_sparse_jac(
	466	size_t q ,
	467	const vector< std::set<size_t> >& rt ,
	468	vector< std::set<size_t> >& st )
	469	{ assert( n_ == st.size() );
	470	assert( m_ == rt.size() );
	471	size_t i, j;
	472
	473	// initialize
	474	for(i = 0; i < n_; i++)
	475	st[i].clear();
	476
	477	// sparsity for S(x)^T = f'(x)^T * R^T
	478	size_t nk = 1;
	479	size_t k = 0;
	480	for(i = 0; i < nr_result_; i++)
	481	{ for(j = 0; j < nc_result_; j++)
	482	{ size_t i_result = result(i, j, k, nk);
	483	for(size_t ell = 0; ell < n_middle_; ell++)
	484	{ size_t i_left = left(i, ell, k, nk);
	485	size_t i_right = right(ell, j, k, nk);
	486	//
	487	my_union(st[i_left], st[i_left], rt[i_result]);
	488	my_union(st[i_right], st[i_right], rt[i_result]);
	489	}
	490	}
	491	}
	492	return true;
	493	}
	494	</pre></font></code>
520	495	<br/>
521	496	<b><big><a name="rev_sparse_hes" id="rev_sparse_hes">rev_sparse_hes</a></big></b>
522	497
523	498	<code><font color='blue'><pre style='display:inline'>
524		// reverse Hessian sparsity routine called by CppAD
525		virtual bool rev_sparse_hes(
526		const vector<bool>& vx,
527		const vector<bool>& s ,
528		vector<bool>& t ,
529		size_t q ,
530		const vector< std::set<size_t> >& r ,
531		const vector< std::set<size_t> >& u ,
532		vector< std::set<size_t> >& v )
533		{ size_t n = vx.size();
534		assert( t.size() == n );
535		assert( r.size() == n );
536		assert( v.size() == n );
	499	// reverse Hessian sparsity routine called by CppAD
	500	virtual bool rev_sparse_hes(
	501	const vector<bool>& vx,
	502	const vector<bool>& s ,
	503	vector<bool>& t ,
	504	size_t q ,
	505	const vector< std::set<size_t> >& r ,
	506	const vector< std::set<size_t> >& u ,
	507	vector< std::set<size_t> >& v )
	508	{ size_t n = vx.size();
	509	assert( t.size() == n );
	510	assert( r.size() == n );
	511	assert( v.size() == n );
537	512	# ifndef NDEBUG
538		size_t m = s.size();
539		assert( u.size() == m );
	513	size_t m = s.size();
	514	assert( u.size() == m );
540	515	# endif
541		size_t i, j;
542		//
543		// initilaize sparsity patterns as false
544		for(j = 0; j < n; j++)
545		{ t[j] = false;
546		v[j].clear();
547		}
548		size_t nk = 1;
549		size_t k = 0;
550		for(i = 0; i < nr_result_; i++)
551		{ for(j = 0; j < nc_result_; j++)
552		{ size_t i_result = result(i, j, k, nk);
553		for(size_t ell = 0; ell < n_middle_; ell++)
554		{ size_t i_left = left(i, ell, k, nk);
555		size_t i_right = right(ell, j, k, nk);
556		//
557		// Compute sparsity for T(x) = S(x) * f'(x).
558		// We need not use vx with f'(x) back propagation.
559		t[i_left] \|= bool( s[i_result] );
560		t[i_right] \|= bool( s[i_result] );
561
562		// V(x) = f'(x)^T * U(x) + S(x) * f''(x) * R
563		// U(x) = g''(y) * f'(x) * R
564		// S(x) = g'(y)
565
566		// back propagate f'(x)^T * U(x)
567		// (no need to use vx with f'(x) propogation)
568		my_union(v[i_left], v[i_left], u[i_result] );
569		my_union(v[i_right], v[i_right], u[i_result] );
570
571		// back propagate S(x) * f''(x) * R
572		// (here is where we must check for cross terms)
573		if( s[i_result] & vx[i_left] & vx[i_right] )
574		{ my_union(v[i_left], v[i_left], r[i_right] );
575		my_union(v[i_right], v[i_right], r[i_left] );
576		}
577		}
578		}
579		}
580		return true;
581		}
582		virtual bool rev_sparse_hes(
583		const vector<bool>& vx,
584		const vector<bool>& s ,
585		vector<bool>& t ,
586		size_t q ,
587		const vector<bool>& r ,
588		const vector<bool>& u ,
589		vector<bool>& v )
590		{ size_t n = vx.size();
591		assert( t.size() == n );
592		assert( r.size() == n * q );
593		assert( v.size() == n * q );
	516	size_t i, j;
	517	//
	518	// initilaize sparsity patterns as false
	519	for(j = 0; j < n; j++)
	520	{ t[j] = false;
	521	v[j].clear();
	522	}
	523	size_t nk = 1;
	524	size_t k = 0;
	525	for(i = 0; i < nr_result_; i++)
	526	{ for(j = 0; j < nc_result_; j++)
	527	{ size_t i_result = result(i, j, k, nk);
	528	for(size_t ell = 0; ell < n_middle_; ell++)
	529	{ size_t i_left = left(i, ell, k, nk);
	530	size_t i_right = right(ell, j, k, nk);
	531	//
	532	// Compute sparsity for T(x) = S(x) * f'(x).
	533	// We need not use vx with f'(x) back propagation.
	534	t[i_left] \|= bool( s[i_result] );
	535	t[i_right] \|= bool( s[i_result] );
	536
	537	// V(x) = f'(x)^T * U(x) + S(x) * f''(x) * R
	538	// U(x) = g''(y) * f'(x) * R
	539	// S(x) = g'(y)
	540
	541	// back propagate f'(x)^T * U(x)
	542	// (no need to use vx with f'(x) propogation)
	543	my_union(v[i_left], v[i_left], u[i_result] );
	544	my_union(v[i_right], v[i_right], u[i_result] );
	545
	546	// back propagate S(x) * f''(x) * R
	547	// (here is where we must check for cross terms)
	548	if( s[i_result] & vx[i_left] & vx[i_right] )
	549	{ my_union(v[i_left], v[i_left], r[i_right] );
	550	my_union(v[i_right], v[i_right], r[i_left] );
	551	}
	552	}
	553	}
	554	}
	555	return true;
	556	}
	557	virtual bool rev_sparse_hes(
	558	const vector<bool>& vx,
	559	const vector<bool>& s ,
	560	vector<bool>& t ,
	561	size_t q ,
	562	const vector<bool>& r ,
	563	const vector<bool>& u ,
	564	vector<bool>& v )
	565	{ size_t n = vx.size();
	566	assert( t.size() == n );
	567	assert( r.size() == n * q );
	568	assert( v.size() == n * q );
594	569	# ifndef NDEBUG
595		size_t m = s.size();
596		assert( u.size() == m * q );
	570	size_t m = s.size();
	571	assert( u.size() == m * q );
597	572	# endif
598		size_t i, j, p;
599		//
600		// initilaize sparsity patterns as false
601		for(j = 0; j < n; j++)
602		{ t[j] = false;
603		for(p = 0; p < q; p++)
604		v[j * q + p] = false;
605		}
606		size_t nk = 1;
607		size_t k = 0;
608		for(i = 0; i < nr_result_; i++)
609		{ for(j = 0; j < nc_result_; j++)
610		{ size_t i_result = result(i, j, k, nk);
611		for(size_t ell = 0; ell < n_middle_; ell++)
612		{ size_t i_left = left(i, ell, k, nk);
613		size_t i_right = right(ell, j, k, nk);
614		//
615		// Compute sparsity for T(x) = S(x) * f'(x).
616		// We so not need to use vx with f'(x) propagation.
617		t[i_left] \|= bool( s[i_result] );
618		t[i_right] \|= bool( s[i_result] );
619
620		// V(x) = f'(x)^T * U(x) + S(x) * f''(x) * R
621		// U(x) = g''(y) * f'(x) * R
622		// S(x) = g'(y)
623
624		// back propagate f'(x)^T * U(x)
625		// (no need to use vx with f'(x) propogation)
626		for(p = 0; p < q; p++)
627		{ v[ i_left * q + p] \|= bool( u[ i_result * q + p] );
628		v[ i_right * q + p] \|= bool( u[ i_result * q + p] );
629		}
630
631		// back propagate S(x) * f''(x) * R
632		// (here is where we must check for cross terms)
633		if( s[i_result] & vx[i_left] & vx[i_right] )
634		{ for(p = 0; p < q; p++)
635		{ v[i_left * q + p] \|= bool( r[i_right * q + p] );
636		v[i_right * q + p] \|= bool( r[i_left * q + p] );
637		}
638		}
639		}
640		}
641		}
642		return true;
643		}
644
645		</pre></font></code>
646
647		<br/>
648		<br/>
	573	size_t i, j, p;
	574	//
	575	// initilaize sparsity patterns as false
	576	for(j = 0; j < n; j++)
	577	{ t[j] = false;
	578	for(p = 0; p < q; p++)
	579	v[j * q + p] = false;
	580	}
	581	size_t nk = 1;
	582	size_t k = 0;
	583	for(i = 0; i < nr_result_; i++)
	584	{ for(j = 0; j < nc_result_; j++)
	585	{ size_t i_result = result(i, j, k, nk);
	586	for(size_t ell = 0; ell < n_middle_; ell++)
	587	{ size_t i_left = left(i, ell, k, nk);
	588	size_t i_right = right(ell, j, k, nk);
	589	//
	590	// Compute sparsity for T(x) = S(x) * f'(x).
	591	// We so not need to use vx with f'(x) propagation.
	592	t[i_left] \|= bool( s[i_result] );
	593	t[i_right] \|= bool( s[i_result] );
	594
	595	// V(x) = f'(x)^T * U(x) + S(x) * f''(x) * R
	596	// U(x) = g''(y) * f'(x) * R
	597	// S(x) = g'(y)
	598
	599	// back propagate f'(x)^T * U(x)
	600	// (no need to use vx with f'(x) propogation)
	601	for(p = 0; p < q; p++)
	602	{ v[ i_left * q + p] \|= bool( u[ i_result * q + p] );
	603	v[ i_right * q + p] \|= bool( u[ i_result * q + p] );
	604	}
	605
	606	// back propagate S(x) * f''(x) * R
	607	// (here is where we must check for cross terms)
	608	if( s[i_result] & vx[i_left] & vx[i_right] )
	609	{ for(p = 0; p < q; p++)
	610	{ v[i_left * q + p] \|= bool( r[i_right * q + p] );
	611	v[i_right * q + p] \|= bool( r[i_left * q + p] );
	612	}
	613	}
	614	}
	615	}
	616	}
	617	return true;
	618	}
	619
	620	</pre></font></code>
649	621	<b><big><a name="End Class Definition" id="End Class Definition">End Class Definition</a></big></b>
650	622
651	623	<code><font color='blue'><pre style='display:inline'>

653	625	} // End empty namespace
654	626	</pre></font></code>
655	627
656
657
658	628	<hr/>Input File: cppad/example/matrix_mul.hpp
659	629
660	630	</body>

+282

-319

doc/atomic_norm_sq.cpp.xml less more

5	5	<title>Atomic Euclidean Norm Squared: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Atomic Euclidean Norm Squared: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" atomic euclidean norm squared: example and test bool_sparsity_enum theory sparsity start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording "/>
	8	<meta name="keywords" id="keywords" content=" atomic euclidean norm squared: example test bool_sparsity_enum theory sparsity start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

109	109	</select>
110	110	</td>
111	111	</tr></table><br/>
112
113
114
115	112	<center><b><big><big>Atomic Euclidean Norm Squared: Example and Test</big></big></b></center>
116	113	<br/>
117	114	<b><big><a name="Theory" id="Theory">Theory</a></big></b>

186	183	//
187	184	class atomic_norm_sq : public CppAD::atomic_base<double> {
188	185	</pre></font></code>
189
190		<br/>
191	186	<br/>
192	187	<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
193	188
194	189	<code><font color='blue'><pre style='display:inline'>
195		public:
196		// constructor (could use const char* for name)
197		atomic_norm_sq(const std::string& name) :
198		// this example only uses boolean sparsity patterns
199		CppAD::atomic_base<double>(name, atomic_base<double>::bool_sparsity_enum)
200		{ }
201		private:
202		</pre></font></code>
203
204		<br/>
	190	public:
	191	// constructor (could use const char* for name)
	192	atomic_norm_sq(const std::string& name) :
	193	// this example only uses boolean sparsity patterns
	194	CppAD::atomic_base<double>(name, atomic_base<double>::bool_sparsity_enum)
	195	{ }
	196	private:
	197	</pre></font></code>
205	198	<br/>
206	199	<b><big><a name="forward" id="forward">forward</a></big></b>
207	200
208	201	<code><font color='blue'><pre style='display:inline'>
209		// forward mode routine called by CppAD
210		virtual bool forward(
211		size_t p ,
212		size_t q ,
213		const vector<bool>& vx ,
214		vector<bool>& vy ,
215		const vector<double>& tx ,
216		vector<double>& ty
217		)
218		{ size_t n = tx.size() / (q+1);
219		size_t m = ty.size() / (q+1);
220		assert( n == 2 );
221		assert( m == 1 );
222		assert( p <= q );
223
224		// return flag
225		bool ok = q <= 1;
226
227		// Variable information must always be implemented.
228		// y_0 is a variable if and only if x_0 or x_1 is a variable.
229		if( vx.size() > 0 )
230		vy[0] = vx[0] \| vx[1];
231
232		// Order zero forward mode must always be implemented.
233		// y^0 = f( x^0 )
234		double x_00 = tx[ 0*(q+1) + 0]; // x_0^0
235		double x_10 = tx[ 1*(q+1) + 0]; // x_10
236		double f = x_00 * x_00 + x_10 * x_10; // f( x^0 )
237		if( p <= 0 )
238		ty[0] = f; // y_0^0
239		if( q <= 0 )
240		return ok;
241		assert( vx.size() == 0 );
242
243		// Order one forward mode.
244		// This case needed if first order forward mode is used.
245		// y^1 = f'( x^0 ) x^1
246		double x_01 = tx[ 0*(q+1) + 1]; // x_0^1
247		double x_11 = tx[ 1*(q+1) + 1]; // x_1^1
248		double fp_0 = 2.0 * x_00; // partial f w.r.t x_0^0
249		double fp_1 = 2.0 * x_10; // partial f w.r.t x_1^0
250		if( p <= 1 )
251		ty[1] = fp_0 * x_01 + fp_1 * x_11; // f'( x^0 ) * x^1
252		if( q <= 1 )
253		return ok;
254
255		// Assume we are not using forward mode with order > 1
256		assert( ! ok );
257		return ok;
258		}
259		</pre></font></code>
260
261		<br/>
	202	// forward mode routine called by CppAD
	203	virtual bool forward(
	204	size_t p ,
	205	size_t q ,
	206	const vector<bool>& vx ,
	207	vector<bool>& vy ,
	208	const vector<double>& tx ,
	209	vector<double>& ty
	210	)
	211	{ size_t n = tx.size() / (q+1);
	212	size_t m = ty.size() / (q+1);
	213	assert( n == 2 );
	214	assert( m == 1 );
	215	assert( p <= q );
	216
	217	// return flag
	218	bool ok = q <= 1;
	219
	220	// Variable information must always be implemented.
	221	// y_0 is a variable if and only if x_0 or x_1 is a variable.
	222	if( vx.size() > 0 )
	223	vy[0] = vx[0] \| vx[1];
	224
	225	// Order zero forward mode must always be implemented.
	226	// y^0 = f( x^0 )
	227	double x_00 = tx[ 0*(q+1) + 0]; // x_0^0
	228	double x_10 = tx[ 1*(q+1) + 0]; // x_10
	229	double f = x_00 * x_00 + x_10 * x_10; // f( x^0 )
	230	if( p <= 0 )
	231	ty[0] = f; // y_0^0
	232	if( q <= 0 )
	233	return ok;
	234	assert( vx.size() == 0 );
	235
	236	// Order one forward mode.
	237	// This case needed if first order forward mode is used.
	238	// y^1 = f'( x^0 ) x^1
	239	double x_01 = tx[ 0*(q+1) + 1]; // x_0^1
	240	double x_11 = tx[ 1*(q+1) + 1]; // x_1^1
	241	double fp_0 = 2.0 * x_00; // partial f w.r.t x_0^0
	242	double fp_1 = 2.0 * x_10; // partial f w.r.t x_1^0
	243	if( p <= 1 )
	244	ty[1] = fp_0 * x_01 + fp_1 * x_11; // f'( x^0 ) * x^1
	245	if( q <= 1 )
	246	return ok;
	247
	248	// Assume we are not using forward mode with order > 1
	249	assert( ! ok );
	250	return ok;
	251	}
	252	</pre></font></code>
262	253	<br/>
263	254	<b><big><a name="reverse" id="reverse">reverse</a></big></b>
264	255
265	256	<code><font color='blue'><pre style='display:inline'>
266		// reverse mode routine called by CppAD
267		virtual bool reverse(
268		size_t q ,
269		const vector<double>& tx ,
270		const vector<double>& ty ,
271		vector<double>& px ,
272		const vector<double>& py
273		)
274		{ size_t n = tx.size() / (q+1);
275		size_t m = ty.size() / (q+1);
276		assert( px.size() == n * (q+1) );
277		assert( py.size() == m * (q+1) );
278		assert( n == 2 );
279		assert( m == 1 );
280		bool ok = q <= 1;
281
282		double fp_0, fp_1;
283		switch(q)
284		{ case 0:
285		// This case needed if first order reverse mode is used
286		// F ( {x} ) = f( x^0 ) = y^0
287		fp_0 = 2.0 * tx[0]; // partial F w.r.t. x_0^0
288		fp_1 = 2.0 * tx[1]; // partial F w.r.t. x_0^1
289		px[0] = py[0] * fp_0;; // partial G w.r.t. x_0^0
290		px[1] = py[0] * fp_1;; // partial G w.r.t. x_0^1
291		assert(ok);
292		break;
293
294		default:
295		// Assume we are not using reverse with order > 1 (q > 0)
296		assert(!ok);
297		}
298		return ok;
299		}
300		</pre></font></code>
301
302		<br/>
	257	// reverse mode routine called by CppAD
	258	virtual bool reverse(
	259	size_t q ,
	260	const vector<double>& tx ,
	261	const vector<double>& ty ,
	262	vector<double>& px ,
	263	const vector<double>& py
	264	)
	265	{ size_t n = tx.size() / (q+1);
	266	size_t m = ty.size() / (q+1);
	267	assert( px.size() == n * (q+1) );
	268	assert( py.size() == m * (q+1) );
	269	assert( n == 2 );
	270	assert( m == 1 );
	271	bool ok = q <= 1;
	272
	273	double fp_0, fp_1;
	274	switch(q)
	275	{ case 0:
	276	// This case needed if first order reverse mode is used
	277	// F ( {x} ) = f( x^0 ) = y^0
	278	fp_0 = 2.0 * tx[0]; // partial F w.r.t. x_0^0
	279	fp_1 = 2.0 * tx[1]; // partial F w.r.t. x_0^1
	280	px[0] = py[0] * fp_0;; // partial G w.r.t. x_0^0
	281	px[1] = py[0] * fp_1;; // partial G w.r.t. x_0^1
	282	assert(ok);
	283	break;
	284
	285	default:
	286	// Assume we are not using reverse with order > 1 (q > 0)
	287	assert(!ok);
	288	}
	289	return ok;
	290	}
	291	</pre></font></code>
303	292	<br/>
304	293	<b><big><a name="for_sparse_jac" id="for_sparse_jac">for_sparse_jac</a></big></b>
305	294
306	295	<code><font color='blue'><pre style='display:inline'>
307		// forward Jacobian bool sparsity routine called by CppAD
308		virtual bool for_sparse_jac(
309		size_t p ,
310		const vector<bool>& r ,
311		vector<bool>& s )
312		{ // This function needed if using f.ForSparseJac
313		size_t n = r.size() / p;
314		size_t m = s.size() / p;
315		assert( n == 2 );
316		assert( m == 1 );
317
318		// sparsity for S(x) = f'(x) * R
319		// where f'(x) = 2 * [ x_0, x_1 ]
320		for(size_t j = 0; j < p; j++)
321		{ s[j] = false;
322		for(size_t i = 0; i < n; i++)
323		{ // Visual Studio 2013 generates warning without bool below
324		s[j] \|= bool( r[i * p + j] );
325		}
326		}
327		return true;
328		}
329		</pre></font></code>
330
331		<br/>
	296	// forward Jacobian bool sparsity routine called by CppAD
	297	virtual bool for_sparse_jac(
	298	size_t p ,
	299	const vector<bool>& r ,
	300	vector<bool>& s )
	301	{ // This function needed if using f.ForSparseJac
	302	size_t n = r.size() / p;
	303	size_t m = s.size() / p;
	304	assert( n == 2 );
	305	assert( m == 1 );
	306
	307	// sparsity for S(x) = f'(x) * R
	308	// where f'(x) = 2 * [ x_0, x_1 ]
	309	for(size_t j = 0; j < p; j++)
	310	{ s[j] = false;
	311	for(size_t i = 0; i < n; i++)
	312	{ // Visual Studio 2013 generates warning without bool below
	313	s[j] \|= bool( r[i * p + j] );
	314	}
	315	}
	316	return true;
	317	}
	318	</pre></font></code>
332	319	<br/>
333	320	<b><big><a name="rev_sparse_jac" id="rev_sparse_jac">rev_sparse_jac</a></big></b>
334	321
335	322	<code><font color='blue'><pre style='display:inline'>
336		// reverse Jacobian bool sparsity routine called by CppAD
337		virtual bool rev_sparse_jac(
338		size_t p ,
339		const vector<bool>& rt ,
340		vector<bool>& st )
341		{ // This function needed if using RevSparseJac or optimize
342		size_t n = st.size() / p;
343		size_t m = rt.size() / p;
344		assert( n == 2 );
345		assert( m == 1 );
346
347		// sparsity for S(x)^T = f'(x)^T * R^T
348		// where f'(x)^T = 2 * [ x_0, x_1]^T
349		for(size_t j = 0; j < p; j++)
350		for(size_t i = 0; i < n; i++)
351		st[i * p + j] = rt[j];
352
353		return true;
354		}
355		</pre></font></code>
356
357		<br/>
	323	// reverse Jacobian bool sparsity routine called by CppAD
	324	virtual bool rev_sparse_jac(
	325	size_t p ,
	326	const vector<bool>& rt ,
	327	vector<bool>& st )
	328	{ // This function needed if using RevSparseJac or optimize
	329	size_t n = st.size() / p;
	330	size_t m = rt.size() / p;
	331	assert( n == 2 );
	332	assert( m == 1 );
	333
	334	// sparsity for S(x)^T = f'(x)^T * R^T
	335	// where f'(x)^T = 2 * [ x_0, x_1]^T
	336	for(size_t j = 0; j < p; j++)
	337	for(size_t i = 0; i < n; i++)
	338	st[i * p + j] = rt[j];
	339
	340	return true;
	341	}
	342	</pre></font></code>
358	343	<br/>
359	344	<b><big><a name="rev_sparse_hes" id="rev_sparse_hes">rev_sparse_hes</a></big></b>
360	345
361	346	<code><font color='blue'><pre style='display:inline'>
362		// reverse Hessian bool sparsity routine called by CppAD
363		virtual bool rev_sparse_hes(
364		const vector<bool>& vx,
365		const vector<bool>& s ,
366		vector<bool>& t ,
367		size_t p ,
368		const vector<bool>& r ,
369		const vector<bool>& u ,
370		vector<bool>& v )
371		{ // This function needed if using RevSparseHes
372		size_t m = s.size();
373		size_t n = t.size();
374		assert( r.size() == n * p );
375		assert( u.size() == m * p );
376		assert( v.size() == n * p );
377		assert( n == 2 );
378		assert( m == 1 );
379
380		// There are no cross term second derivatives for this case,
381		// so it is not necessary to use vx.
382
383		// sparsity for T(x) = S(x) * f'(x)
384		t[0] = s[0];
385		t[1] = s[0];
386
387		// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
388		// U(x) = g''(y) * f'(x) * R
389		// S(x) = g'(y)
390
391		// back propagate the sparsity for U
392		size_t j;
393		for(j = 0; j < p; j++)
394		for(size_t i = 0; i < n; i++)
395		v[ i * p + j] = u[j];
396
397		// include forward Jacobian sparsity in Hessian sparsity
398		// sparsity for g'(y) * f''(x) * R (Note f''(x) has same sparsity
399		// as the identity matrix)
400		if( s[0] )
401		{ for(j = 0; j < p; j++)
402		for(size_t i = 0; i < n; i++)
403		{ // Visual Studio 2013 generates warning without bool below
404		v[ i * p + j] \|= bool( r[ i * p + j] );
405		}
406		}
407
408		return true;
409		}
410		</pre></font></code>
411
412		<br/>
	347	// reverse Hessian bool sparsity routine called by CppAD
	348	virtual bool rev_sparse_hes(
	349	const vector<bool>& vx,
	350	const vector<bool>& s ,
	351	vector<bool>& t ,
	352	size_t p ,
	353	const vector<bool>& r ,
	354	const vector<bool>& u ,
	355	vector<bool>& v )
	356	{ // This function needed if using RevSparseHes
	357	size_t m = s.size();
	358	size_t n = t.size();
	359	assert( r.size() == n * p );
	360	assert( u.size() == m * p );
	361	assert( v.size() == n * p );
	362	assert( n == 2 );
	363	assert( m == 1 );
	364
	365	// There are no cross term second derivatives for this case,
	366	// so it is not necessary to use vx.
	367
	368	// sparsity for T(x) = S(x) * f'(x)
	369	t[0] = s[0];
	370	t[1] = s[0];
	371
	372	// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
	373	// U(x) = g''(y) * f'(x) * R
	374	// S(x) = g'(y)
	375
	376	// back propagate the sparsity for U
	377	size_t j;
	378	for(j = 0; j < p; j++)
	379	for(size_t i = 0; i < n; i++)
	380	v[ i * p + j] = u[j];
	381
	382	// include forward Jacobian sparsity in Hessian sparsity
	383	// sparsity for g'(y) * f''(x) * R (Note f''(x) has same sparsity
	384	// as the identity matrix)
	385	if( s[0] )
	386	{ for(j = 0; j < p; j++)
	387	for(size_t i = 0; i < n; i++)
	388	{ // Visual Studio 2013 generates warning without bool below
	389	v[ i * p + j] \|= bool( r[ i * p + j] );
	390	}
	391	}
	392
	393	return true;
	394	}
	395	</pre></font></code>
413	396	<br/>
414	397	<b><big><a name="End Class Definition" id="End Class Definition">End Class Definition</a></big></b>
415	398

418	401	} // End empty namespace
419	402
420	403	</pre></font></code>
421
422		<br/>
423		<br/>
424	404	<b><big><a name="Use Atomic Function" id="Use Atomic Function">Use Atomic Function</a></big></b>
425	405
426	406	<code><font color='blue'><pre style='display:inline'>
427	407	bool norm_sq(void)
428		{ bool ok = true;
429		using CppAD::AD;
430		using CppAD::NearEqual;
431		double eps = 10. * CppAD::numeric_limits<double>::epsilon();
432		</pre></font></code>
433
434		<br/>
	408	{ bool ok = true;
	409	using CppAD::AD;
	410	using CppAD::NearEqual;
	411	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	412	</pre></font></code>
435	413	<br/>
436	414	<b><a name="Use Atomic Function.Constructor" id="Use Atomic Function.Constructor">Constructor</a></b>
437	415
438	416	<code><font color='blue'><pre style='display:inline'>
439		// --------------------------------------------------------------------
440		// Create the atomic reciprocal object
441		atomic_norm_sq afun("atomic_norm_sq");
442		</pre></font></code>
443
444		<br/>
	417	// --------------------------------------------------------------------
	418	// Create the atomic reciprocal object
	419	atomic_norm_sq afun("atomic_norm_sq");
	420	</pre></font></code>
445	421	<br/>
446	422	<b><a name="Use Atomic Function.Recording" id="Use Atomic Function.Recording">Recording</a></b>
447	423
448	424	<code><font color='blue'><pre style='display:inline'>
449		// Create the function f(x)
450		//
451		// domain space vector
452		size_t n = 2;
453		double x0 = 0.25;
454		double x1 = 0.75;
455		vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
456		ax[0] = x0;
457		ax[1] = x1;
458
459		// declare independent variables and start tape recording
460		CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
461
462		// range space vector
463		size_t m = 1;
464		vector< <a href="ad.xml" target="_top">AD</a><double> > ay(m);
465
466		// call user function and store norm_sq(x) in au[0]
467		afun(ax, ay); // y_0 = x_0 * x_0 + x_1 * x_1
468
469		// create f: x -> y and stop tape recording
470		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
471		f.Dependent (ax, ay);
472		</pre></font></code>
473
474		<br/>
	425	// Create the function f(x)
	426	//
	427	// domain space vector
	428	size_t n = 2;
	429	double x0 = 0.25;
	430	double x1 = 0.75;
	431	vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
	432	ax[0] = x0;
	433	ax[1] = x1;
	434
	435	// declare independent variables and start tape recording
	436	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
	437
	438	// range space vector
	439	size_t m = 1;
	440	vector< <a href="ad.xml" target="_top">AD</a><double> > ay(m);
	441
	442	// call user function and store norm_sq(x) in au[0]
	443	afun(ax, ay); // y_0 = x_0 * x_0 + x_1 * x_1
	444
	445	// create f: x -> y and stop tape recording
	446	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
	447	f.Dependent (ax, ay);
	448	</pre></font></code>
475	449	<br/>
476	450	<b><a name="Use Atomic Function.forward" id="Use Atomic Function.forward">forward</a></b>
477	451
478	452	<code><font color='blue'><pre style='display:inline'>
479		// check function value
480		double check = x0 * x0 + x1 * x1;
481		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
482
483		// check zero order forward mode
484		size_t q;
485		vector<double> x_q(n), y_q(m);
486		q = 0;
487		x_q[0] = x0;
488		x_q[1] = x1;
489		y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
490		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
491
492		// check first order forward mode
493		q = 1;
494		x_q[0] = 0.3;
495		x_q[1] = 0.7;
496		y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
497		check = 2.0 * x0 * x_q[0] + 2.0 * x1 * x_q[1];
498		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
499
500		</pre></font></code>
501
502		<br/>
503		<br/>
	453	// check function value
	454	double check = x0 * x0 + x1 * x1;
	455	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
	456
	457	// check zero order forward mode
	458	size_t q;
	459	vector<double> x_q(n), y_q(m);
	460	q = 0;
	461	x_q[0] = x0;
	462	x_q[1] = x1;
	463	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	464	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
	465
	466	// check first order forward mode
	467	q = 1;
	468	x_q[0] = 0.3;
	469	x_q[1] = 0.7;
	470	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	471	check = 2.0 * x0 * x_q[0] + 2.0 * x1 * x_q[1];
	472	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
	473
	474	</pre></font></code>
504	475	<b><a name="Use Atomic Function.reverse" id="Use Atomic Function.reverse">reverse</a></b>
505	476
506	477	<code><font color='blue'><pre style='display:inline'>
507		// first order reverse mode
508		q = 1;
509		vector<double> w(m), dw(n * q);
510		w[0] = 1.;
511		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(q, w);
512		check = 2.0 * x0;
513		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0] , check, eps, eps);
514		check = 2.0 * x1;
515		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[1] , check, eps, eps);
516		</pre></font></code>
517
518		<br/>
	478	// first order reverse mode
	479	q = 1;
	480	vector<double> w(m), dw(n * q);
	481	w[0] = 1.;
	482	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(q, w);
	483	check = 2.0 * x0;
	484	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0] , check, eps, eps);
	485	check = 2.0 * x1;
	486	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[1] , check, eps, eps);
	487	</pre></font></code>
519	488	<br/>
520	489	<b><a name="Use Atomic Function.for_sparse_jac" id="Use Atomic Function.for_sparse_jac">for_sparse_jac</a></b>
521	490
522	491	<code><font color='blue'><pre style='display:inline'>
523		// forward mode sparstiy pattern
524		size_t p = n;
525		CppAD::vectorBool r1(n * p), s1(m * p);
526		r1[0] = true; r1[1] = false; // sparsity pattern identity
527		r1[2] = false; r1[3] = true;
528		//
529		s1 = f.ForSparseJac(p, r1);
530		ok &= s1[0] == true; // f[0] depends on x[0]
531		ok &= s1[1] == true; // f[0] depends on x[1]
532		</pre></font></code>
533
534		<br/>
	492	// forward mode sparstiy pattern
	493	size_t p = n;
	494	CppAD::vectorBool r1(n * p), s1(m * p);
	495	r1[0] = true; r1[1] = false; // sparsity pattern identity
	496	r1[2] = false; r1[3] = true;
	497	//
	498	s1 = f.ForSparseJac(p, r1);
	499	ok &= s1[0] == true; // f[0] depends on x[0]
	500	ok &= s1[1] == true; // f[0] depends on x[1]
	501	</pre></font></code>
535	502	<br/>
536	503	<b><a name="Use Atomic Function.rev_sparse_jac" id="Use Atomic Function.rev_sparse_jac">rev_sparse_jac</a></b>
537	504
538	505	<code><font color='blue'><pre style='display:inline'>
539		// reverse mode sparstiy pattern
540		q = m;
541		CppAD::vectorBool s2(q * m), r2(q * n);
542		s2[0] = true; // compute sparsity pattern for f[0]
543		//
544		r2 = f.RevSparseJac(q, s2);
545		ok &= r2[0] == true; // f[0] depends on x[0]
546		ok &= r2[1] == true; // f[0] depends on x[1]
547		</pre></font></code>
548
549		<br/>
	506	// reverse mode sparstiy pattern
	507	q = m;
	508	CppAD::vectorBool s2(q * m), r2(q * n);
	509	s2[0] = true; // compute sparsity pattern for f[0]
	510	//
	511	r2 = f.RevSparseJac(q, s2);
	512	ok &= r2[0] == true; // f[0] depends on x[0]
	513	ok &= r2[1] == true; // f[0] depends on x[1]
	514	</pre></font></code>
550	515	<br/>
551	516	<b><a name="Use Atomic Function.rev_sparse_hes" id="Use Atomic Function.rev_sparse_hes">rev_sparse_hes</a></b>
552	517
553	518	<code><font color='blue'><pre style='display:inline'>
554		// Hessian sparsity (using previous ForSparseJac call)
555		CppAD::vectorBool s3(m), h(p * n);
556		s3[0] = true; // compute sparsity pattern for f[0]
557		//
558		h = f.RevSparseHes(p, s3);
559		ok &= h[0] == true; // partial of f[0] w.r.t. x[0],x[0] is non-zero
560		ok &= h[1] == false; // partial of f[0] w.r.t. x[0],x[1] is zero
561		ok &= h[2] == false; // partial of f[0] w.r.t. x[1],x[0] is zero
562		ok &= h[3] == true; // partial of f[0] w.r.t. x[1],x[1] is non-zero
563		//
564		return ok;
	519	// Hessian sparsity (using previous ForSparseJac call)
	520	CppAD::vectorBool s3(m), h(p * n);
	521	s3[0] = true; // compute sparsity pattern for f[0]
	522	//
	523	h = f.RevSparseHes(p, s3);
	524	ok &= h[0] == true; // partial of f[0] w.r.t. x[0],x[0] is non-zero
	525	ok &= h[1] == false; // partial of f[0] w.r.t. x[0],x[1] is zero
	526	ok &= h[2] == false; // partial of f[0] w.r.t. x[1],x[0] is zero
	527	ok &= h[3] == true; // partial of f[0] w.r.t. x[1],x[1] is non-zero
	528	//
	529	return ok;
565	530	}
566	531	</pre></font></code>
567
568
569	532
570	533	<hr/>Input File: example/atomic/norm_sq.cpp
571	534

+312

-348

doc/atomic_reciprocal.cpp.xml less more

5	5	<title>Reciprocal as an Atomic Operation: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Reciprocal as an Atomic Operation: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" reciprocal as an atomic operation: example and test set_sparsity_enum theory sparsity start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording "/>
	8	<meta name="keywords" id="keywords" content=" reciprocal atomic operation: example test set_sparsity_enum theory sparsity start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

109	109	</select>
110	110	</td>
111	111	</tr></table><br/>
112
113
114
115	112	<center><b><big><big>Reciprocal as an Atomic Operation: Example and Test</big></big></b></center>
116	113	<br/>
117	114	<b><big><a name="Theory" id="Theory">Theory</a></big></b>

182	179	//
183	180	// a utility to compute the union of two sets.
184	181	void my_union(
185		std::set<size_t>& result ,
186		const std::set<size_t>& left ,
187		const std::set<size_t>& right )
188		{ std::set<size_t> temp;
189		std::set_union(
190		left.begin() ,
191		left.end() ,
192		right.begin() ,
193		right.end() ,
194		std::inserter(temp, temp.begin())
195		);
196		result.swap(temp);
	182	std::set<size_t>& result ,
	183	const std::set<size_t>& left ,
	184	const std::set<size_t>& right )
	185	{ std::set<size_t> temp;
	186	std::set_union(
	187	left.begin() ,
	188	left.end() ,
	189	right.begin() ,
	190	right.end() ,
	191	std::inserter(temp, temp.begin())
	192	);
	193	result.swap(temp);
197	194	}
198	195	//
199	196	class atomic_reciprocal : public CppAD::atomic_base<double> {
200	197	</pre></font></code>
201
202		<br/>
203	198	<br/>
204	199	<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
205	200
206	201	<code><font color='blue'><pre style='display:inline'>
207		public:
208		// constructor (could use const char* for name)
209		atomic_reciprocal(const std::string& name) :
210		// this exmaple only uses set sparsity patterns
211		CppAD::atomic_base<double>(name, atomic_base<double>::set_sparsity_enum)
212		{ }
213		private:
214		</pre></font></code>
215
216		<br/>
	202	public:
	203	// constructor (could use const char* for name)
	204	atomic_reciprocal(const std::string& name) :
	205	// this exmaple only uses set sparsity patterns
	206	CppAD::atomic_base<double>(name, atomic_base<double>::set_sparsity_enum)
	207	{ }
	208	private:
	209	</pre></font></code>
217	210	<br/>
218	211	<b><big><a name="forward" id="forward">forward</a></big></b>
219	212
220	213	<code><font color='blue'><pre style='display:inline'>
221		// forward mode routine called by CppAD
222		virtual bool forward(
223		size_t p ,
224		size_t q ,
225		const vector<bool>& vx ,
226		vector<bool>& vy ,
227		const vector<double>& tx ,
228		vector<double>& ty
229		)
230		{ size_t n = tx.size() / (q + 1);
231		size_t m = ty.size() / (q + 1);
232		assert( n == 1 );
233		assert( m == 1 );
234		assert( p <= q );
235
236		// return flag
237		bool ok = q <= 2;
238
239		// check for defining variable information
240		// This case must always be implemented
241		if( vx.size() > 0 )
242		vy[0] = vx[0];
243
244		// Order zero forward mode.
245		// This case must always be implemented
246		// y^0 = f( x^0 ) = 1 / x^0
247		double f = 1. / tx[0];
248		if( p <= 0 )
249		ty[0] = f;
250		if( q <= 0 )
251		return ok;
252		assert( vx.size() == 0 );
253
254		// Order one forward mode.
255		// This case needed if first order forward mode is used.
256		// y^1 = f'( x^0 ) x^1
257		double fp = - f / tx[0];
258		if( p <= 1 )
259		ty[1] = fp * tx[1];
260		if( q <= 1 )
261		return ok;
262
263		// Order two forward mode.
264		// This case needed if second order forward mode is used.
265		// Y''(t) = X'(t)^\R{T} f''[X(t)] X'(t) + f'[X(t)] X''(t)
266		// 2 y^2 = x^1 * f''( x^0 ) x^1 + 2 f'( x^0 ) x^2
267		double fpp = - 2.0 * fp / tx[0];
268		ty[2] = tx[1] * fpp * tx[1] / 2.0 + fp * tx[2];
269		if( q <= 2 )
270		return ok;
271
272		// Assume we are not using forward mode with order > 2
273		assert( ! ok );
274		return ok;
275		}
276		</pre></font></code>
277
278		<br/>
	214	// forward mode routine called by CppAD
	215	virtual bool forward(
	216	size_t p ,
	217	size_t q ,
	218	const vector<bool>& vx ,
	219	vector<bool>& vy ,
	220	const vector<double>& tx ,
	221	vector<double>& ty
	222	)
	223	{ size_t n = tx.size() / (q + 1);
	224	size_t m = ty.size() / (q + 1);
	225	assert( n == 1 );
	226	assert( m == 1 );
	227	assert( p <= q );
	228
	229	// return flag
	230	bool ok = q <= 2;
	231
	232	// check for defining variable information
	233	// This case must always be implemented
	234	if( vx.size() > 0 )
	235	vy[0] = vx[0];
	236
	237	// Order zero forward mode.
	238	// This case must always be implemented
	239	// y^0 = f( x^0 ) = 1 / x^0
	240	double f = 1. / tx[0];
	241	if( p <= 0 )
	242	ty[0] = f;
	243	if( q <= 0 )
	244	return ok;
	245	assert( vx.size() == 0 );
	246
	247	// Order one forward mode.
	248	// This case needed if first order forward mode is used.
	249	// y^1 = f'( x^0 ) x^1
	250	double fp = - f / tx[0];
	251	if( p <= 1 )
	252	ty[1] = fp * tx[1];
	253	if( q <= 1 )
	254	return ok;
	255
	256	// Order two forward mode.
	257	// This case needed if second order forward mode is used.
	258	// Y''(t) = X'(t)^\R{T} f''[X(t)] X'(t) + f'[X(t)] X''(t)
	259	// 2 y^2 = x^1 * f''( x^0 ) x^1 + 2 f'( x^0 ) x^2
	260	double fpp = - 2.0 * fp / tx[0];
	261	ty[2] = tx[1] * fpp * tx[1] / 2.0 + fp * tx[2];
	262	if( q <= 2 )
	263	return ok;
	264
	265	// Assume we are not using forward mode with order > 2
	266	assert( ! ok );
	267	return ok;
	268	}
	269	</pre></font></code>
279	270	<br/>
280	271	<b><big><a name="reverse" id="reverse">reverse</a></big></b>
281	272
282	273	<code><font color='blue'><pre style='display:inline'>
283		// reverse mode routine called by CppAD
284		virtual bool reverse(
285		size_t q ,
286		const vector<double>& tx ,
287		const vector<double>& ty ,
288		vector<double>& px ,
289		const vector<double>& py
290		)
291		{ size_t n = tx.size() / (q + 1);
292		size_t m = ty.size() / (q + 1);
293		assert( px.size() == n * (q + 1) );
294		assert( py.size() == m * (q + 1) );
295		assert( n == 1 );
296		assert( m == 1 );
297		bool ok = q <= 2;
298
299		double f, fp, fpp, fppp;
300		switch(q)
301		{ case 0:
302		// This case needed if first order reverse mode is used
303		// reverse: F^0 ( tx ) = y^0 = f( x^0 )
304		f = ty[0];
305		fp = - f / tx[0];
306		px[0] = py[0] * fp;;
307		assert(ok);
308		break;
309
310		case 1:
311		// This case needed if second order reverse mode is used
312		// reverse: F^1 ( tx ) = y^1 = f'( x^0 ) x^1
313		f = ty[0];
314		fp = - f / tx[0];
315		fpp = - 2.0 * fp / tx[0];
316		px[1] = py[1] * fp;
317		px[0] = py[1] * fpp * tx[1];
318		// reverse: F^0 ( tx ) = y^0 = f( x^0 );
319		px[0] += py[0] * fp;
320		assert(ok);
321		break;
322
323		case 2:
324		// This needed if third order reverse mode is used
325		// reverse: F^2 ( tx ) = y^2 =
326		// = x^1 * f''( x^0 ) x^1 / 2 + f'( x^0 ) x^2
327		f = ty[0];
328		fp = - f / tx[0];
329		fpp = - 2.0 * fp / tx[0];
330		fppp = - 3.0 * fpp / tx[0];
331		px[2] = py[2] * fp;
332		px[1] = py[2] * fpp * tx[1];
333		px[0] = py[2] * tx[1] * fppp * tx[1] / 2.0 + fpp * tx[2];
334		// reverse: F^1 ( tx ) = y^1 = f'( x^0 ) x^1
335		px[1] += py[1] * fp;
336		px[0] += py[1] * fpp * tx[1];
337		// reverse: F^0 ( tx ) = y^0 = f( x^0 );
338		px[0] += py[0] * fp;
339		assert(ok);
340		break;
341
342		default:
343		assert(!ok);
344		}
345		return ok;
346		}
347		</pre></font></code>
348
349		<br/>
	274	// reverse mode routine called by CppAD
	275	virtual bool reverse(
	276	size_t q ,
	277	const vector<double>& tx ,
	278	const vector<double>& ty ,
	279	vector<double>& px ,
	280	const vector<double>& py
	281	)
	282	{ size_t n = tx.size() / (q + 1);
	283	size_t m = ty.size() / (q + 1);
	284	assert( px.size() == n * (q + 1) );
	285	assert( py.size() == m * (q + 1) );
	286	assert( n == 1 );
	287	assert( m == 1 );
	288	bool ok = q <= 2;
	289
	290	double f, fp, fpp, fppp;
	291	switch(q)
	292	{ case 0:
	293	// This case needed if first order reverse mode is used
	294	// reverse: F^0 ( tx ) = y^0 = f( x^0 )
	295	f = ty[0];
	296	fp = - f / tx[0];
	297	px[0] = py[0] * fp;;
	298	assert(ok);
	299	break;
	300
	301	case 1:
	302	// This case needed if second order reverse mode is used
	303	// reverse: F^1 ( tx ) = y^1 = f'( x^0 ) x^1
	304	f = ty[0];
	305	fp = - f / tx[0];
	306	fpp = - 2.0 * fp / tx[0];
	307	px[1] = py[1] * fp;
	308	px[0] = py[1] * fpp * tx[1];
	309	// reverse: F^0 ( tx ) = y^0 = f( x^0 );
	310	px[0] += py[0] * fp;
	311	assert(ok);
	312	break;
	313
	314	case 2:
	315	// This needed if third order reverse mode is used
	316	// reverse: F^2 ( tx ) = y^2 =
	317	// = x^1 * f''( x^0 ) x^1 / 2 + f'( x^0 ) x^2
	318	f = ty[0];
	319	fp = - f / tx[0];
	320	fpp = - 2.0 * fp / tx[0];
	321	fppp = - 3.0 * fpp / tx[0];
	322	px[2] = py[2] * fp;
	323	px[1] = py[2] * fpp * tx[1];
	324	px[0] = py[2] * tx[1] * fppp * tx[1] / 2.0 + fpp * tx[2];
	325	// reverse: F^1 ( tx ) = y^1 = f'( x^0 ) x^1
	326	px[1] += py[1] * fp;
	327	px[0] += py[1] * fpp * tx[1];
	328	// reverse: F^0 ( tx ) = y^0 = f( x^0 );
	329	px[0] += py[0] * fp;
	330	assert(ok);
	331	break;
	332
	333	default:
	334	assert(!ok);
	335	}
	336	return ok;
	337	}
	338	</pre></font></code>
350	339	<br/>
351	340	<b><big><a name="for_sparse_jac" id="for_sparse_jac">for_sparse_jac</a></big></b>
352	341
353	342	<code><font color='blue'><pre style='display:inline'>
354		// forward Jacobian set sparsity routine called by CppAD
355		virtual bool for_sparse_jac(
356		size_t p ,
357		const vector< std::set<size_t> >& r ,
358		vector< std::set<size_t> >& s )
359		{ // This function needed if using f.ForSparseJac
360		size_t n = r.size();
361		size_t m = s.size();
362		assert( n == 1 );
363		assert( m == 1 );
364
365		// sparsity for S(x) = f'(x) * R is same as sparsity for R
366		s[0] = r[0];
367
368		return true;
369		}
370		</pre></font></code>
371
372		<br/>
	343	// forward Jacobian set sparsity routine called by CppAD
	344	virtual bool for_sparse_jac(
	345	size_t p ,
	346	const vector< std::set<size_t> >& r ,
	347	vector< std::set<size_t> >& s )
	348	{ // This function needed if using f.ForSparseJac
	349	size_t n = r.size();
	350	size_t m = s.size();
	351	assert( n == 1 );
	352	assert( m == 1 );
	353
	354	// sparsity for S(x) = f'(x) * R is same as sparsity for R
	355	s[0] = r[0];
	356
	357	return true;
	358	}
	359	</pre></font></code>
373	360	<br/>
374	361	<b><big><a name="rev_sparse_jac" id="rev_sparse_jac">rev_sparse_jac</a></big></b>
375	362
376	363	<code><font color='blue'><pre style='display:inline'>
377		// reverse Jacobian set sparsity routine called by CppAD
378		virtual bool rev_sparse_jac(
379		size_t p ,
380		const vector< std::set<size_t> >& rt ,
381		vector< std::set<size_t> >& st )
382		{ // This function needed if using RevSparseJac or optimize
383		size_t n = st.size();
384		size_t m = rt.size();
385		assert( n == 1 );
386		assert( m == 1 );
387
388		// sparsity for S(x)^T = f'(x)^T * R^T is same as sparsity for R^T
389		st[0] = rt[0];
390
391		return true;
392		}
393		</pre></font></code>
394
395		<br/>
	364	// reverse Jacobian set sparsity routine called by CppAD
	365	virtual bool rev_sparse_jac(
	366	size_t p ,
	367	const vector< std::set<size_t> >& rt ,
	368	vector< std::set<size_t> >& st )
	369	{ // This function needed if using RevSparseJac or optimize
	370	size_t n = st.size();
	371	size_t m = rt.size();
	372	assert( n == 1 );
	373	assert( m == 1 );
	374
	375	// sparsity for S(x)^T = f'(x)^T * R^T is same as sparsity for R^T
	376	st[0] = rt[0];
	377
	378	return true;
	379	}
	380	</pre></font></code>
396	381	<br/>
397	382	<b><big><a name="rev_sparse_hes" id="rev_sparse_hes">rev_sparse_hes</a></big></b>
398	383
399	384	<code><font color='blue'><pre style='display:inline'>
400		// reverse Hessian set sparsity routine called by CppAD
401		virtual bool rev_sparse_hes(
402		const vector<bool>& vx,
403		const vector<bool>& s ,
404		vector<bool>& t ,
405		size_t p ,
406		const vector< std::set<size_t> >& r ,
407		const vector< std::set<size_t> >& u ,
408		vector< std::set<size_t> >& v )
409		{ // This function needed if using RevSparseHes
410		size_t n = vx.size();
411		size_t m = s.size();
412		assert( t.size() == n );
413		assert( r.size() == n );
414		assert( u.size() == m );
415		assert( v.size() == n );
416		assert( n == 1 );
417		assert( m == 1 );
418
419		// There are no cross term second derivatives for this case,
420		// so it is not necessary to vx.
421
422		// sparsity for T(x) = S(x) * f'(x) is same as sparsity for S
423		t[0] = s[0];
424
425		// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
426		// U(x) = g''(y) * f'(x) * R
427		// S(x) = g'(y)
428
429		// back propagate the sparsity for U, note f'(x) may be non-zero;
430		v[0] = u[0];
431
432		// include forward Jacobian sparsity in Hessian sparsity
433		// (note sparsty for f''(x) * R same as for R)
434		if( s[0] )
435		my_union(v[0], v[0], r[0] );
436
437		return true;
438		}
439		</pre></font></code>
440
441		<br/>
	385	// reverse Hessian set sparsity routine called by CppAD
	386	virtual bool rev_sparse_hes(
	387	const vector<bool>& vx,
	388	const vector<bool>& s ,
	389	vector<bool>& t ,
	390	size_t p ,
	391	const vector< std::set<size_t> >& r ,
	392	const vector< std::set<size_t> >& u ,
	393	vector< std::set<size_t> >& v )
	394	{ // This function needed if using RevSparseHes
	395	size_t n = vx.size();
	396	size_t m = s.size();
	397	assert( t.size() == n );
	398	assert( r.size() == n );
	399	assert( u.size() == m );
	400	assert( v.size() == n );
	401	assert( n == 1 );
	402	assert( m == 1 );
	403
	404	// There are no cross term second derivatives for this case,
	405	// so it is not necessary to vx.
	406
	407	// sparsity for T(x) = S(x) * f'(x) is same as sparsity for S
	408	t[0] = s[0];
	409
	410	// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
	411	// U(x) = g''(y) * f'(x) * R
	412	// S(x) = g'(y)
	413
	414	// back propagate the sparsity for U, note f'(x) may be non-zero;
	415	v[0] = u[0];
	416
	417	// include forward Jacobian sparsity in Hessian sparsity
	418	// (note sparsty for f''(x) * R same as for R)
	419	if( s[0] )
	420	my_union(v[0], v[0], r[0] );
	421
	422	return true;
	423	}
	424	</pre></font></code>
442	425	<br/>
443	426	<b><big><a name="End Class Definition" id="End Class Definition">End Class Definition</a></big></b>
444	427

447	430	} // End empty namespace
448	431
449	432	</pre></font></code>
450
451		<br/>
452		<br/>
453	433	<b><big><a name="Use Atomic Function" id="Use Atomic Function">Use Atomic Function</a></big></b>
454	434
455	435	<code><font color='blue'><pre style='display:inline'>
456	436	bool reciprocal(void)
457		{ bool ok = true;
458		using CppAD::AD;
459		using CppAD::NearEqual;
460		double eps = 10. * CppAD::numeric_limits<double>::epsilon();
461		</pre></font></code>
462
463		<br/>
	437	{ bool ok = true;
	438	using CppAD::AD;
	439	using CppAD::NearEqual;
	440	double eps = 10. * CppAD::numeric_limits<double>::epsilon();
	441	</pre></font></code>
464	442	<br/>
465	443	<b><a name="Use Atomic Function.Constructor" id="Use Atomic Function.Constructor">Constructor</a></b>
466	444
467	445	<code><font color='blue'><pre style='display:inline'>
468		// --------------------------------------------------------------------
469		// Create the atomic reciprocal object
470		atomic_reciprocal afun("atomic_reciprocal");
471		</pre></font></code>
472
473		<br/>
	446	// --------------------------------------------------------------------
	447	// Create the atomic reciprocal object
	448	atomic_reciprocal afun("atomic_reciprocal");
	449	</pre></font></code>
474	450	<br/>
475	451	<b><a name="Use Atomic Function.Recording" id="Use Atomic Function.Recording">Recording</a></b>
476	452
477	453	<code><font color='blue'><pre style='display:inline'>
478		// Create the function f(x)
479		//
480		// domain space vector
481		size_t n = 1;
482		double x0 = 0.5;
483		vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
484		ax[0] = x0;
485
486		// declare independent variables and start tape recording
487		CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
488
489		// range space vector
490		size_t m = 1;
491		vector< <a href="ad.xml" target="_top">AD</a><double> > ay(m);
492
493		// call user function and store reciprocal(x) in au[0]
494		vector< <a href="ad.xml" target="_top">AD</a><double> > au(m);
495		afun(ax, au); // u = 1 / x
496
497		// now use AD division to invert to invert the operation
498		ay[0] = 1.0 / au[0]; // y = 1 / u = x
499
500		// create f: x -> y and stop tape recording
501		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
502		f.Dependent (ax, ay); // f(x) = x
503		</pre></font></code>
504
505		<br/>
	454	// Create the function f(x)
	455	//
	456	// domain space vector
	457	size_t n = 1;
	458	double x0 = 0.5;
	459	vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n);
	460	ax[0] = x0;
	461
	462	// declare independent variables and start tape recording
	463	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
	464
	465	// range space vector
	466	size_t m = 1;
	467	vector< <a href="ad.xml" target="_top">AD</a><double> > ay(m);
	468
	469	// call user function and store reciprocal(x) in au[0]
	470	vector< <a href="ad.xml" target="_top">AD</a><double> > au(m);
	471	afun(ax, au); // u = 1 / x
	472
	473	// now use AD division to invert to invert the operation
	474	ay[0] = 1.0 / au[0]; // y = 1 / u = x
	475
	476	// create f: x -> y and stop tape recording
	477	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
	478	f.Dependent (ax, ay); // f(x) = x
	479	</pre></font></code>
506	480	<br/>
507	481	<b><a name="Use Atomic Function.forward" id="Use Atomic Function.forward">forward</a></b>
508	482
509	483	<code><font color='blue'><pre style='display:inline'>
510		// check function value
511		double check = x0;
512		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
513
514		// check zero order forward mode
515		size_t q;
516		vector<double> x_q(n), y_q(m);
517		q = 0;
518		x_q[0] = x0;
519		y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
520		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
521
522		// check first order forward mode
523		q = 1;
524		x_q[0] = 1;
525		y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
526		check = 1.;
527		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
528
529		// check second order forward mode
530		q = 2;
531		x_q[0] = 0;
532		y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
533		check = 0.;
534		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
535		</pre></font></code>
536
537		<br/>
	484	// check function value
	485	double check = x0;
	486	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>( Value(ay[0]) , check, eps, eps);
	487
	488	// check zero order forward mode
	489	size_t q;
	490	vector<double> x_q(n), y_q(m);
	491	q = 0;
	492	x_q[0] = x0;
	493	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	494	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
	495
	496	// check first order forward mode
	497	q = 1;
	498	x_q[0] = 1;
	499	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	500	check = 1.;
	501	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
	502
	503	// check second order forward mode
	504	q = 2;
	505	x_q[0] = 0;
	506	y_q = f.<a href="forward.xml" target="_top">Forward</a>(q, x_q);
	507	check = 0.;
	508	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y_q[0] , check, eps, eps);
	509	</pre></font></code>
538	510	<br/>
539	511	<b><a name="Use Atomic Function.reverse" id="Use Atomic Function.reverse">reverse</a></b>
540	512
541	513	<code><font color='blue'><pre style='display:inline'>
542		// third order reverse mode
543		q = 3;
544		vector<double> w(m), dw(n * q);
545		w[0] = 1.;
546		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(q, w);
547		check = 1.;
548		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0] , check, eps, eps);
549		check = 0.;
550		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[1] , check, eps, eps);
551		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[2] , check, eps, eps);
552		</pre></font></code>
553
554		<br/>
	514	// third order reverse mode
	515	q = 3;
	516	vector<double> w(m), dw(n * q);
	517	w[0] = 1.;
	518	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(q, w);
	519	check = 1.;
	520	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0] , check, eps, eps);
	521	check = 0.;
	522	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[1] , check, eps, eps);
	523	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[2] , check, eps, eps);
	524	</pre></font></code>
555	525	<br/>
556	526	<b><a name="Use Atomic Function.for_sparse_jac" id="Use Atomic Function.for_sparse_jac">for_sparse_jac</a></b>
557	527
558	528	<code><font color='blue'><pre style='display:inline'>
559		// forward mode sparstiy pattern
560		size_t p = n;
561		CppAD::vectorBool r1(n * p), s1(m * p);
562		r1[0] = true; // compute sparsity pattern for x[0]
563		//
564		s1 = f.ForSparseJac(p, r1);
565		ok &= s1[0] == true; // f[0] depends on x[0]
566		</pre></font></code>
567
568		<br/>
	529	// forward mode sparstiy pattern
	530	size_t p = n;
	531	CppAD::vectorBool r1(n * p), s1(m * p);
	532	r1[0] = true; // compute sparsity pattern for x[0]
	533	//
	534	s1 = f.ForSparseJac(p, r1);
	535	ok &= s1[0] == true; // f[0] depends on x[0]
	536	</pre></font></code>
569	537	<br/>
570	538	<b><a name="Use Atomic Function.rev_sparse_jac" id="Use Atomic Function.rev_sparse_jac">rev_sparse_jac</a></b>
571	539
572	540	<code><font color='blue'><pre style='display:inline'>
573		// reverse mode sparstiy pattern
574		q = m;
575		CppAD::vectorBool s2(q * m), r2(q * n);
576		s2[0] = true; // compute sparsity pattern for f[0]
577		//
578		r2 = f.RevSparseJac(q, s2);
579		ok &= r2[0] == true; // f[0] depends on x[0]
580		</pre></font></code>
581
582		<br/>
	541	// reverse mode sparstiy pattern
	542	q = m;
	543	CppAD::vectorBool s2(q * m), r2(q * n);
	544	s2[0] = true; // compute sparsity pattern for f[0]
	545	//
	546	r2 = f.RevSparseJac(q, s2);
	547	ok &= r2[0] == true; // f[0] depends on x[0]
	548	</pre></font></code>
583	549	<br/>
584	550	<b><a name="Use Atomic Function.rev_sparse_hes" id="Use Atomic Function.rev_sparse_hes">rev_sparse_hes</a></b>
585	551
586	552	<code><font color='blue'><pre style='display:inline'>
587		// Hessian sparsity (using previous ForSparseJac call)
588		CppAD::vectorBool s3(m), h(p * n);
589		s3[0] = true; // compute sparsity pattern for f[0]
590		//
591		h = f.RevSparseHes(p, s3);
592		ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
593		//
594		return ok;
	553	// Hessian sparsity (using previous ForSparseJac call)
	554	CppAD::vectorBool s3(m), h(p * n);
	555	s3[0] = true; // compute sparsity pattern for f[0]
	556	//
	557	h = f.RevSparseHes(p, s3);
	558	ok &= h[0] == true; // second partial of f[0] w.r.t. x[0] may be non-zero
	559	//
	560	return ok;
595	561	}
596	562	</pre></font></code>
597
598
599	563
600	564	<hr/>Input File: example/atomic/reciprocal.cpp
601	565

+207

-236

doc/atomic_sparsity.cpp.xml less more

5	5	<title>Atomic Sparsity Patterns: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Atomic Sparsity Patterns: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" atomic sparsity patterns: example and test function pack_sparsity_enum start class definition constructor forward for_sparse_jac rev_sparse_jac rev_sparse_hes end use recording forsparse_jac "/>
	8	<meta name="keywords" id="keywords" content=" atomic sparsity patterns: example test function pack_sparsity_enum start class definition constructor forward for_sparse_jac rev_sparse_jac rev_sparse_hes end use recording forsparse_jac "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

105	105	</select>
106	106	</td>
107	107	</tr></table><br/>
108
109
110
111	108	<center><b><big><big>Atomic Sparsity Patterns: Example and Test</big></big></b></center>
112	109	<br/>
113	110	<b><big><a name="function" id="function">function</a></big></b>

181	178	//
182	179	class atomic_sparsity : public CppAD::atomic_base<double> {
183	180	</pre></font></code>
184
185		<br/>
186	181	<br/>
187	182	<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
188	183
189	184	<code><font color='blue'><pre style='display:inline'>
190		public:
191		// constructor
192		atomic_sparsity(const std::string& name) :
193		// this exampel only uses pack sparsity patterns
194		CppAD::atomic_base<double>(name, pack_sparsity_enum )
195		{ }
196		private:
197		</pre></font></code>
198
199		<br/>
	185	public:
	186	// constructor
	187	atomic_sparsity(const std::string& name) :
	188	// this exampel only uses pack sparsity patterns
	189	CppAD::atomic_base<double>(name, pack_sparsity_enum )
	190	{ }
	191	private:
	192	</pre></font></code>
200	193	<br/>
201	194	<b><big><a name="forward" id="forward">forward</a></big></b>
202	195
203	196	<code><font color='blue'><pre style='display:inline'>
204		// forward
205		virtual bool forward(
206		size_t p ,
207		size_t q ,
208		const vector<bool>& vx ,
209		vector<bool>& vy ,
210		const vector<double>& tx ,
211		vector<double>& ty
212		)
213		{ size_t n = tx.size() / (q + 1);
214		size_t m = ty.size() / (q + 1);
215		assert( n == 3 );
216		assert( m == 2 );
217
218		// only order zero
219		bool ok = q == 0;
220		if( ! ok )
221		return ok;
222
223		// check for defining variable information
224		if( vx.size() > 0 )
225		{ ok &= vx.size() == n;
226		vy[0] = vx[2];
227		vy[1] = vx[0] \|\| vx[1];
228		}
229
230		// Order zero forward mode.
231		// y[0] = x[2], y[1] = x[0] * x[1]
232		if( p <= 0 )
233		{ ty[0] = tx[2];
234		ty[1] = tx[0] * tx[1];
235		}
236		return ok;
237		}
238		</pre></font></code>
239
240		<br/>
	197	// forward
	198	virtual bool forward(
	199	size_t p ,
	200	size_t q ,
	201	const vector<bool>& vx ,
	202	vector<bool>& vy ,
	203	const vector<double>& tx ,
	204	vector<double>& ty
	205	)
	206	{ size_t n = tx.size() / (q + 1);
	207	size_t m = ty.size() / (q + 1);
	208	assert( n == 3 );
	209	assert( m == 2 );
	210
	211	// only order zero
	212	bool ok = q == 0;
	213	if( ! ok )
	214	return ok;
	215
	216	// check for defining variable information
	217	if( vx.size() > 0 )
	218	{ ok &= vx.size() == n;
	219	vy[0] = vx[2];
	220	vy[1] = vx[0] \|\| vx[1];
	221	}
	222
	223	// Order zero forward mode.
	224	// y[0] = x[2], y[1] = x[0] * x[1]
	225	if( p <= 0 )
	226	{ ty[0] = tx[2];
	227	ty[1] = tx[0] * tx[1];
	228	}
	229	return ok;
	230	}
	231	</pre></font></code>
241	232	<br/>
242	233	<b><big><a name="for_sparse_jac" id="for_sparse_jac">for_sparse_jac</a></big></b>
243	234
244	235	<code><font color='blue'><pre style='display:inline'>
245		// for_sparse_jac
246		virtual bool for_sparse_jac(
247		size_t p ,
248		const vectorBool& r ,
249		vectorBool& s )
250		{ // This function needed if using f.ForSparseJac
251		size_t n = r.size() / p;
252		size_t m = s.size() / p;
253		assert( n == 3 );
254		assert( m == 2 );
255
256		// sparsity for S(x) = f'(x) * R = [ 0, 0, 1 ] * R
257		// [ x1, x0, 0 ]
258		for(size_t j = 0; j < p; j++)
259		{ s[ 0 * p + j] = r[ 2 * p + j];
260		s[ 1 * p + j] = r[ 0 * p + j] \|\| r[ 1 * p + j];
261		}
262		return true;
263		}
264		</pre></font></code>
265
266		<br/>
	236	// for_sparse_jac
	237	virtual bool for_sparse_jac(
	238	size_t p ,
	239	const vectorBool& r ,
	240	vectorBool& s )
	241	{ // This function needed if using f.ForSparseJac
	242	size_t n = r.size() / p;
	243	size_t m = s.size() / p;
	244	assert( n == 3 );
	245	assert( m == 2 );
	246
	247	// sparsity for S(x) = f'(x) * R = [ 0, 0, 1 ] * R
	248	// [ x1, x0, 0 ]
	249	for(size_t j = 0; j < p; j++)
	250	{ s[ 0 * p + j] = r[ 2 * p + j];
	251	s[ 1 * p + j] = r[ 0 * p + j] \|\| r[ 1 * p + j];
	252	}
	253	return true;
	254	}
	255	</pre></font></code>
267	256	<br/>
268	257	<b><big><a name="rev_sparse_jac" id="rev_sparse_jac">rev_sparse_jac</a></big></b>
269	258
270	259	<code><font color='blue'><pre style='display:inline'>
271		virtual bool rev_sparse_jac(
272		size_t p ,
273		const vectorBool& rt ,
274		vectorBool& st )
275		{ // This function needed if using RevSparseJac or optimize
276		size_t n = st.size() / p;
277		size_t m = rt.size() / p;
278		assert( n == 3 );
279		assert( m == 2 );
280
281		// [ 0, x1 ]
282		// sparsity for S(x)^T = f'(x)^T * R^T = [ 0, x0 ] * R^T
283		// [ 1, 0 ]
284		for(size_t j = 0; j < p; j++)
285		{ st[ 0 * p + j ] = rt[ 1 * m + j ];
286		st[ 1 * p + j ] = rt[ 1 * m + j ];
287		st[ 2 * p + j ] = rt[ 0 * m + j ];
288		}
289		return true;
290		}
291		</pre></font></code>
292
293		<br/>
	260	virtual bool rev_sparse_jac(
	261	size_t p ,
	262	const vectorBool& rt ,
	263	vectorBool& st )
	264	{ // This function needed if using RevSparseJac or optimize
	265	size_t n = st.size() / p;
	266	size_t m = rt.size() / p;
	267	assert( n == 3 );
	268	assert( m == 2 );
	269
	270	// [ 0, x1 ]
	271	// sparsity for S(x)^T = f'(x)^T * R^T = [ 0, x0 ] * R^T
	272	// [ 1, 0 ]
	273	for(size_t j = 0; j < p; j++)
	274	{ st[ 0 * p + j ] = rt[ 1 * m + j ];
	275	st[ 1 * p + j ] = rt[ 1 * m + j ];
	276	st[ 2 * p + j ] = rt[ 0 * m + j ];
	277	}
	278	return true;
	279	}
	280	</pre></font></code>
294	281	<br/>
295	282	<b><big><a name="rev_sparse_hes" id="rev_sparse_hes">rev_sparse_hes</a></big></b>
296	283
297	284	<code><font color='blue'><pre style='display:inline'>
298		virtual bool rev_sparse_hes(
299		const vector<bool>& vx,
300		const vector<bool>& s ,
301		vector<bool>& t ,
302		size_t p ,
303		const vectorBool& r ,
304		const vectorBool& u ,
305		vectorBool& v )
306		{ // This function needed if using RevSparseHes
307		size_t m = s.size();
308		size_t n = t.size();
309		assert( r.size() == n * p );
310		assert( u.size() == m * p );
311		assert( v.size() == n * p );
312		assert( n == 3 );
313		assert( m == 2 );
314
315		// sparsity for T(x) = S(x) * f'(x) = S(x) * [ 0, 0, 1 ]
316		// [ x1, x0, 0 ]
317		t[0] = s[1];
318		t[1] = s[1];
319		t[2] = s[0];
320
321		// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
322		// U(x) = g''(y) * f'(x) * R
323		// S(x) = g'(y)
324
325		// [ 0, x1 ]
326		// sparsity for f'(x)^T * U(x) = [ 0, x0 ] * U(x)
327		// [ 1, 0 ]
328		size_t j;
329		for(j = 0; j < p; j++)
330		{ v[ 0 * p + j ] = u[ 1 * m + j ];
331		v[ 1 * p + j ] = u[ 1 * m + j ];
332		v[ 2 * p + j ] = u[ 0 * m + j ];
333		}
334
335		// include forward Jacobian sparsity in Hessian sparsity
336		// [ 0, 1, 0 ]
337		// sum_i S_i (x) g'(y) * f_i''(x) * R = S_1 (x) * [ 1, 0, 0 ] * R
338		// [ 0, 0, 0 ]
339		if( s[1] )
340		{ for(j = 0; j < p; j++)
341		{ v[ 0 * p + j ] = bool(v[0 * p + j]) \| bool(r[1 * p + j]);
342		v[ 1 * p + j ] = bool(v[1 * p + j]) \| bool(r[0 * p + j]);
343		}
344		}
345		return true;
346		}
347		</pre></font></code>
348
349		<br/>
	285	virtual bool rev_sparse_hes(
	286	const vector<bool>& vx,
	287	const vector<bool>& s ,
	288	vector<bool>& t ,
	289	size_t p ,
	290	const vectorBool& r ,
	291	const vectorBool& u ,
	292	vectorBool& v )
	293	{ // This function needed if using RevSparseHes
	294	size_t m = s.size();
	295	size_t n = t.size();
	296	assert( r.size() == n * p );
	297	assert( u.size() == m * p );
	298	assert( v.size() == n * p );
	299	assert( n == 3 );
	300	assert( m == 2 );
	301
	302	// sparsity for T(x) = S(x) * f'(x) = S(x) * [ 0, 0, 1 ]
	303	// [ x1, x0, 0 ]
	304	t[0] = s[1];
	305	t[1] = s[1];
	306	t[2] = s[0];
	307
	308	// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
	309	// U(x) = g''(y) * f'(x) * R
	310	// S(x) = g'(y)
	311
	312	// [ 0, x1 ]
	313	// sparsity for f'(x)^T * U(x) = [ 0, x0 ] * U(x)
	314	// [ 1, 0 ]
	315	size_t j;
	316	for(j = 0; j < p; j++)
	317	{ v[ 0 * p + j ] = u[ 1 * m + j ];
	318	v[ 1 * p + j ] = u[ 1 * m + j ];
	319	v[ 2 * p + j ] = u[ 0 * m + j ];
	320	}
	321
	322	// include forward Jacobian sparsity in Hessian sparsity
	323	// [ 0, 1, 0 ]
	324	// sum_i S_i (x) g'(y) * f_i''(x) * R = S_1 (x) * [ 1, 0, 0 ] * R
	325	// [ 0, 0, 0 ]
	326	if( s[1] )
	327	{ for(j = 0; j < p; j++)
	328	{ v[ 0 * p + j ] = bool(v[0 * p + j]) \| bool(r[1 * p + j]);
	329	v[ 1 * p + j ] = bool(v[1 * p + j]) \| bool(r[0 * p + j]);
	330	}
	331	}
	332	return true;
	333	}
	334	</pre></font></code>
350	335	<br/>
351	336	<b><big><a name="End Class Definition" id="End Class Definition">End Class Definition</a></big></b>
352	337

355	340	} // End empty namespace
356	341
357	342	</pre></font></code>
358
359		<br/>
360		<br/>
361	343	<b><big><a name="Use Atomic Function" id="Use Atomic Function">Use Atomic Function</a></big></b>
362	344
363	345	<code><font color='blue'><pre style='display:inline'>
364	346	bool sparsity(void)
365		{ bool ok = true;
366		using CppAD::AD;
367		using CppAD::NearEqual;
368		double eps = 10. * std::numeric_limits<double>::epsilon();
369		</pre></font></code>
370
371		<br/>
	347	{ bool ok = true;
	348	using CppAD::AD;
	349	using CppAD::NearEqual;
	350	double eps = 10. * std::numeric_limits<double>::epsilon();
	351	</pre></font></code>
372	352	<br/>
373	353	<b><a name="Use Atomic Function.Constructor" id="Use Atomic Function.Constructor">Constructor</a></b>
374	354
375	355	<code><font color='blue'><pre style='display:inline'>
376		// Create the atomic get_started object
377		atomic_sparsity afun("atomic_sparsity");
378		</pre></font></code>
379
380		<br/>
	356	// Create the atomic get_started object
	357	atomic_sparsity afun("atomic_sparsity");
	358	</pre></font></code>
381	359	<br/>
382	360	<b><a name="Use Atomic Function.Recording" id="Use Atomic Function.Recording">Recording</a></b>
383	361
384	362	<code><font color='blue'><pre style='display:inline'>
385		size_t n = 3;
386		size_t m = 2;
387		vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n), ay(m);
388		for(size_t j = 0; j < n; j++)
389		ax[j] = double(j + 1);
390
391		// declare independent variables and start tape recording
392		CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
393
394		// call user function
395		afun(ax, ay);
396
397		// create f: x -> y and stop tape recording
398		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
399		f.Dependent (ax, ay); // f(x) = x
400
401		// check function value
402		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ay[0] , ax[2], eps, eps);
403		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ay[1] , ax[0] * ax[1], eps, eps);
404
405		</pre></font></code>
406
407		<br/>
408		<br/>
	363	size_t n = 3;
	364	size_t m = 2;
	365	vector< <a href="ad.xml" target="_top">AD</a><double> > ax(n), ay(m);
	366	for(size_t j = 0; j < n; j++)
	367	ax[j] = double(j + 1);
	368
	369	// declare independent variables and start tape recording
	370	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
	371
	372	// call user function
	373	afun(ax, ay);
	374
	375	// create f: x -> y and stop tape recording
	376	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
	377	f.Dependent (ax, ay); // f(x) = x
	378
	379	// check function value
	380	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ay[0] , ax[2], eps, eps);
	381	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ay[1] , ax[0] * ax[1], eps, eps);
	382
	383	</pre></font></code>
409	384	<b><a name="Use Atomic Function.forsparse_jac and rev_sparse_jac" id="Use Atomic Function.forsparse_jac and rev_sparse_jac">forsparse_jac and rev_sparse_jac</a></b>
410	385
411	386	<code><font color='blue'><pre style='display:inline'>
412		for(size_t dir = 0; dir < 2; dir++)
413		{ size_t ell;
414		if( dir == 0 )
415		ell = n;
416		else
417		ell = m;
418
419		// identity martrix
420		vectorBool r(ell * ell);
421		for(size_t i = 0; i < ell; i++)
422		for(size_t j = 0; j < ell; j++)
423		r[i * ell + j] = (i == j);
424
425		vectorBool s;
426		if( dir == 0 )
427		s = f.ForSparseJac(n, r);
428		else
429		s = f.RevSparseJac(m, r);
430
431		// check Jacobian result
432		ok &= s.size() == m * n;
433		ok &= s[0 * n + 0] == false;
434		ok &= s[0 * n + 1] == false;
435		ok &= s[0 * n + 2] == true;
436		ok &= s[1 * n + 0] == true;
437		ok &= s[1 * n + 1] == true;
438		ok &= s[1 * n + 2] == false;
439		}
440		</pre></font></code>
441
442		<br/>
	387	for(size_t dir = 0; dir < 2; dir++)
	388	{ size_t ell;
	389	if( dir == 0 )
	390	ell = n;
	391	else
	392	ell = m;
	393
	394	// identity martrix
	395	vectorBool r(ell * ell);
	396	for(size_t i = 0; i < ell; i++)
	397	for(size_t j = 0; j < ell; j++)
	398	r[i * ell + j] = (i == j);
	399
	400	vectorBool s;
	401	if( dir == 0 )
	402	s = f.ForSparseJac(n, r);
	403	else
	404	s = f.RevSparseJac(m, r);
	405
	406	// check Jacobian result
	407	ok &= s.size() == m * n;
	408	ok &= s[0 * n + 0] == false;
	409	ok &= s[0 * n + 1] == false;
	410	ok &= s[0 * n + 2] == true;
	411	ok &= s[1 * n + 0] == true;
	412	ok &= s[1 * n + 1] == true;
	413	ok &= s[1 * n + 2] == false;
	414	}
	415	</pre></font></code>
443	416	<br/>
444	417	<b><a name="Use Atomic Function.rev_sparse_hes" id="Use Atomic Function.rev_sparse_hes">rev_sparse_hes</a></b>
445	418
446	419	<code><font color='blue'><pre style='display:inline'>
447		vectorBool s(m), h(n * n);
448		s[0] = true;
449		s[1] = true;
450		h = f.RevSparseHes(n, s);
451		for(size_t i = 0; i < n; i++)
452		{ for(size_t j = 0; j < n; j++)
453		{ bool check = false;
454		check \|= (i == 0) && (j == 1);
455		check \|= (j == 0) && (i == 1);
456		ok &= h[ i * n + j] == check;
457		}
458		}
459		//
460		return ok;
	420	vectorBool s(m), h(n * n);
	421	s[0] = true;
	422	s[1] = true;
	423	h = f.RevSparseHes(n, s);
	424	for(size_t i = 0; i < n; i++)
	425	{ for(size_t j = 0; j < n; j++)
	426	{ bool check = false;
	427	check \|= (i == 0) && (j == 1);
	428	check \|= (j == 0) && (i == 1);
	429	ok &= h[ i * n + j] == check;
	430	}
	431	}
	432	//
	433	return ok;
461	434	}
462	435	</pre></font></code>
463
464
465	436
466	437	<hr/>Input File: example/atomic/sparsity.cpp
467	438

+428

-466

doc/atomic_tangent.cpp.xml less more

5	5	<title>Tan and Tanh as User Atomic Operations: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Tan and Tanh as User Atomic Operations: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" tan and tanh as user atomic operations: example test tangent operation theory sparsity start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording large x values "/>
	8	<meta name="keywords" id="keywords" content=" tan tanh user atomic operations: example test tangent operation theory sparsity start class definition constructor forward reverse for_sparse_jac rev_sparse_jac rev_sparse_hes end use function recording large x values "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

110	110	</select>
111	111	</td>
112	112	</tr></table><br/>
113
114
115
116	113	<center><b><big><big>Tan and Tanh as User Atomic Operations: Example and Test</big></big></b></center>
117	114	<br/>
118	115	<b><big><a name="Theory" id="Theory">Theory</a></big></b>

142	139	//
143	140	// a utility to compute the union of two sets.
144	141	void my_union(
145		std::set<size_t>& result ,
146		const std::set<size_t>& left ,
147		const std::set<size_t>& right )
148		{ std::set<size_t> temp;
149		std::set_union(
150		left.begin() ,
151		left.end() ,
152		right.begin() ,
153		right.end() ,
154		std::inserter(temp, temp.begin())
155		);
156		result.swap(temp);
	142	std::set<size_t>& result ,
	143	const std::set<size_t>& left ,
	144	const std::set<size_t>& right )
	145	{ std::set<size_t> temp;
	146	std::set_union(
	147	left.begin() ,
	148	left.end() ,
	149	right.begin() ,
	150	right.end() ,
	151	std::inserter(temp, temp.begin())
	152	);
	153	result.swap(temp);
157	154	}
158	155	//
159	156	class atomic_tangent : public CppAD::atomic_base<float> {
160	157	</pre></font></code>
161
162		<br/>
163	158	<br/>
164	159	<b><big><a name="Constructor" id="Constructor">Constructor</a></big></b>
165	160
166	161	<code><font color='blue'><pre style='display:inline'>
167		private:
168		const bool hyperbolic_; // is this hyperbolic tangent
169		public:
170		// constructor
171		atomic_tangent(const char* name, bool hyperbolic)
172		: CppAD::atomic_base<float>(name),
173		hyperbolic_(hyperbolic)
174		{ }
175		private:
176		</pre></font></code>
177
178		<br/>
	162	private:
	163	const bool hyperbolic_; // is this hyperbolic tangent
	164	public:
	165	// constructor
	166	atomic_tangent(const char* name, bool hyperbolic)
	167	: CppAD::atomic_base<float>(name),
	168	hyperbolic_(hyperbolic)
	169	{ }
	170	private:
	171	</pre></font></code>
179	172	<br/>
180	173	<b><big><a name="forward" id="forward">forward</a></big></b>
181	174
182	175	<code><font color='blue'><pre style='display:inline'>
183		// forward mode routine called by CppAD
184		bool forward(
185		size_t p ,
186		size_t q ,
187		const vector<bool>& vx ,
188		vector<bool>& vzy ,
189		const vector<float>& tx ,
190		vector<float>& tzy
191		)
192		{ size_t q1 = q + 1;
193		size_t n = tx.size() / q1;
194		size_t m = tzy.size() / q1;
195		assert( n == 1 );
196		assert( m == 2 );
197		assert( p <= q );
198		size_t j, k;
199
200		// check if this is during the call to old_tan(id, ax, ay)
201		if( vx.size() > 0 )
202		{ // set variable flag for both y an z
203		vzy[0] = vx[0];
204		vzy[1] = vx[0];
205		}
206
207		if( p == 0 )
208		{ // z^{(0)} = tan( x^{(0)} ) or tanh( x^{(0)} )
209		if( hyperbolic_ )
210		tzy[0] = tanh( tx[0] );
211		else tzy[0] = tan( tx[0] );
212
213		// y^{(0)} = z^{(0)} * z^{(0)}
214		tzy[q1 + 0] = tzy[0] * tzy[0];
215
216		p++;
217		}
218		for(j = p; j <= q; j++)
219		{ float j_inv = 1.f / float(j);
220		if( hyperbolic_ )
221		j_inv = - j_inv;
222
223		// z^{(j)} = x^{(j)} +- sum_{k=1}^j k x^{(k)} y^{(j-k)} / j
224		tzy[j] = tx[j];
225		for(k = 1; k <= j; k++)
226		tzy[j] += tx[k] * tzy[q1 + j-k] * k * j_inv;
227
228		// y^{(j)} = sum_{k=0}^j z^{(k)} z^{(j-k)}
229		tzy[q1 + j] = 0.;
230		for(k = 0; k <= j; k++)
231		tzy[q1 + j] += tzy[k] * tzy[j-k];
232		}
233
234		// All orders are implemented and there are no possible errors
235		return true;
236		}
237		</pre></font></code>
238
239		<br/>
	176	// forward mode routine called by CppAD
	177	bool forward(
	178	size_t p ,
	179	size_t q ,
	180	const vector<bool>& vx ,
	181	vector<bool>& vzy ,
	182	const vector<float>& tx ,
	183	vector<float>& tzy
	184	)
	185	{ size_t q1 = q + 1;
	186	size_t n = tx.size() / q1;
	187	size_t m = tzy.size() / q1;
	188	assert( n == 1 );
	189	assert( m == 2 );
	190	assert( p <= q );
	191	size_t j, k;
	192
	193	// check if this is during the call to old_tan(id, ax, ay)
	194	if( vx.size() > 0 )
	195	{ // set variable flag for both y an z
	196	vzy[0] = vx[0];
	197	vzy[1] = vx[0];
	198	}
	199
	200	if( p == 0 )
	201	{ // z^{(0)} = tan( x^{(0)} ) or tanh( x^{(0)} )
	202	if( hyperbolic_ )
	203	tzy[0] = tanh( tx[0] );
	204	else tzy[0] = tan( tx[0] );
	205
	206	// y^{(0)} = z^{(0)} * z^{(0)}
	207	tzy[q1 + 0] = tzy[0] * tzy[0];
	208
	209	p++;
	210	}
	211	for(j = p; j <= q; j++)
	212	{ float j_inv = 1.f / float(j);
	213	if( hyperbolic_ )
	214	j_inv = - j_inv;
	215
	216	// z^{(j)} = x^{(j)} +- sum_{k=1}^j k x^{(k)} y^{(j-k)} / j
	217	tzy[j] = tx[j];
	218	for(k = 1; k <= j; k++)
	219	tzy[j] += tx[k] * tzy[q1 + j-k] * k * j_inv;
	220
	221	// y^{(j)} = sum_{k=0}^j z^{(k)} z^{(j-k)}
	222	tzy[q1 + j] = 0.;
	223	for(k = 0; k <= j; k++)
	224	tzy[q1 + j] += tzy[k] * tzy[j-k];
	225	}
	226
	227	// All orders are implemented and there are no possible errors
	228	return true;
	229	}
	230	</pre></font></code>
240	231	<br/>
241	232	<b><big><a name="reverse" id="reverse">reverse</a></big></b>
242	233
243	234	<code><font color='blue'><pre style='display:inline'>
244		// reverse mode routine called by CppAD
245		virtual bool reverse(
246		size_t q ,
247		const vector<float>& tx ,
248		const vector<float>& tzy ,
249		vector<float>& px ,
250		const vector<float>& pzy
251		)
252		{ size_t q1 = q + 1;
253		size_t n = tx.size() / q1;
254		size_t m = tzy.size() / q1;
255		assert( px.size() == n * q1 );
256		assert( pzy.size() == m * q1 );
257		assert( n == 1 );
258		assert( m == 2 );
259
260		size_t j, k;
261
262		// copy because partials w.r.t. y and z need to change
263		vector<float> qzy = pzy;
264
265		// initialize accumultion of reverse mode partials
266		for(k = 0; k < q1; k++)
267		px[k] = 0.;
268
269		// eliminate positive orders
270		for(j = q; j > 0; j--)
271		{ float j_inv = 1.f / float(j);
272		if( hyperbolic_ )
273		j_inv = - j_inv;
274
275		// H_{x^{(k)}} += delta(j-k) +- H_{z^{(j)} y^{(j-k)} * k / j
276		px[j] += qzy[j];
277		for(k = 1; k <= j; k++)
278		px[k] += qzy[j] * tzy[q1 + j-k] * k * j_inv;
279
280		// H_{y^{j-k)} += +- H_{z^{(j)} x^{(k)} * k / j
281		for(k = 1; k <= j; k++)
282		qzy[q1 + j-k] += qzy[j] * tx[k] * k * j_inv;
283
284		// H_{z^{(k)}} += H_{y^{(j-1)}} * z^{(j-k-1)} * 2.
285		for(k = 0; k < j; k++)
286		qzy[k] += qzy[q1 + j-1] * tzy[j-k-1] * 2.f;
287		}
288
289		// eliminate order zero
290		if( hyperbolic_ )
291		px[0] += qzy[0] * (1.f - tzy[q1 + 0]);
292		else
293		px[0] += qzy[0] * (1.f + tzy[q1 + 0]);
294
295		return true;
296		}
297		</pre></font></code>
298
299		<br/>
	235	// reverse mode routine called by CppAD
	236	virtual bool reverse(
	237	size_t q ,
	238	const vector<float>& tx ,
	239	const vector<float>& tzy ,
	240	vector<float>& px ,
	241	const vector<float>& pzy
	242	)
	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 );
	248	assert( n == 1 );
	249	assert( m == 2 );
	250
	251	size_t j, k;
	252
	253	// copy because partials w.r.t. y and z need to change
	254	vector<float> qzy = pzy;
	255
	256	// initialize accumultion of reverse mode partials
	257	for(k = 0; k < q1; k++)
	258	px[k] = 0.;
	259
	260	// eliminate positive orders
	261	for(j = q; j > 0; j--)
	262	{ float j_inv = 1.f / float(j);
	263	if( hyperbolic_ )
	264	j_inv = - j_inv;
	265
	266	// H_{x^{(k)}} += delta(j-k) +- H_{z^{(j)} y^{(j-k)} * k / j
	267	px[j] += qzy[j];
	268	for(k = 1; k <= j; k++)
	269	px[k] += qzy[j] * tzy[q1 + j-k] * k * j_inv;
	270
	271	// H_{y^{j-k)} += +- H_{z^{(j)} x^{(k)} * k / j
	272	for(k = 1; k <= j; k++)
	273	qzy[q1 + j-k] += qzy[j] * tx[k] * k * j_inv;
	274
	275	// H_{z^{(k)}} += H_{y^{(j-1)}} * z^{(j-k-1)} * 2.
	276	for(k = 0; k < j; k++)
	277	qzy[k] += qzy[q1 + j-1] * tzy[j-k-1] * 2.f;
	278	}
	279
	280	// eliminate order zero
	281	if( hyperbolic_ )
	282	px[0] += qzy[0] * (1.f - tzy[q1 + 0]);
	283	else
	284	px[0] += qzy[0] * (1.f + tzy[q1 + 0]);
	285
	286	return true;
	287	}
	288	</pre></font></code>
300	289	<br/>
301	290	<b><big><a name="for_sparse_jac" id="for_sparse_jac">for_sparse_jac</a></big></b>
302	291
303	292	<code><font color='blue'><pre style='display:inline'>
304		// forward Jacobian sparsity routine called by CppAD
305		virtual bool for_sparse_jac(
306		size_t p ,
307		const vector<bool>& r ,
308		vector<bool>& s )
309		{ size_t n = r.size() / p;
310		size_t m = s.size() / p;
311		assert( n == 1 );
312		assert( m == 2 );
313
314		// sparsity for S(x) = f'(x) * R
315		for(size_t j = 0; j < p; j++)
316		{ s[0 * p + j] = r[j];
317		s[1 * p + j] = r[j];
318		}
319
320		return true;
321		}
322		// forward Jacobian sparsity routine called by CppAD
323		virtual bool for_sparse_jac(
324		size_t p ,
325		const vector< std::set<size_t> >& r ,
326		vector< std::set<size_t> >& s )
327		{ size_t n = r.size();
328		size_t m = s.size();
329		assert( n == 1 );
330		assert( m == 2 );
331
332		// sparsity for S(x) = f'(x) * R
333		s[0] = r[0];
334		s[1] = r[0];
335
336		return true;
337		}
338		</pre></font></code>
339
340		<br/>
	293	// forward Jacobian sparsity routine called by CppAD
	294	virtual bool for_sparse_jac(
	295	size_t p ,
	296	const vector<bool>& r ,
	297	vector<bool>& s )
	298	{ size_t n = r.size() / p;
	299	size_t m = s.size() / p;
	300	assert( n == 1 );
	301	assert( m == 2 );
	302
	303	// sparsity for S(x) = f'(x) * R
	304	for(size_t j = 0; j < p; j++)
	305	{ s[0 * p + j] = r[j];
	306	s[1 * p + j] = r[j];
	307	}
	308
	309	return true;
	310	}
	311	// forward Jacobian sparsity routine called by CppAD
	312	virtual bool for_sparse_jac(
	313	size_t p ,
	314	const vector< std::set<size_t> >& r ,
	315	vector< std::set<size_t> >& s )
	316	{ size_t n = r.size();
	317	size_t m = s.size();
	318	assert( n == 1 );
	319	assert( m == 2 );
	320
	321	// sparsity for S(x) = f'(x) * R
	322	s[0] = r[0];
	323	s[1] = r[0];
	324
	325	return true;
	326	}
	327	</pre></font></code>
341	328	<br/>
342	329	<b><big><a name="rev_sparse_jac" id="rev_sparse_jac">rev_sparse_jac</a></big></b>
343	330
344	331	<code><font color='blue'><pre style='display:inline'>
345		// reverse Jacobian sparsity routine called by CppAD
346		virtual bool rev_sparse_jac(
347		size_t p ,
348		const vector<bool>& rt ,
349		vector<bool>& st )
350		{ size_t n = st.size() / p;
351		size_t m = rt.size() / p;
352		assert( n == 1 );
353		assert( m == 2 );
354
355		// sparsity for S(x)^T = f'(x)^T * R^T
356		for(size_t j = 0; j < p; j++)
357		st[j] = rt[0 * p + j] \| rt[1 * p + j];
358
359		return true;
360		}
361		// reverse Jacobian sparsity routine called by CppAD
362		virtual bool rev_sparse_jac(
363		size_t p ,
364		const vector< std::set<size_t> >& rt ,
365		vector< std::set<size_t> >& st )
366		{ size_t n = st.size();
367		size_t m = rt.size();
368		assert( n == 1 );
369		assert( m == 2 );
370
371		// sparsity for S(x)^T = f'(x)^T * R^T
372		my_union(st[0], rt[0], rt[1]);
373		return true;
374		}
375		</pre></font></code>
376
377		<br/>
	332	// reverse Jacobian sparsity routine called by CppAD
	333	virtual bool rev_sparse_jac(
	334	size_t p ,
	335	const vector<bool>& rt ,
	336	vector<bool>& st )
	337	{ size_t n = st.size() / p;
	338	size_t m = rt.size() / p;
	339	assert( n == 1 );
	340	assert( m == 2 );
	341
	342	// sparsity for S(x)^T = f'(x)^T * R^T
	343	for(size_t j = 0; j < p; j++)
	344	st[j] = rt[0 * p + j] \| rt[1 * p + j];
	345
	346	return true;
	347	}
	348	// reverse Jacobian sparsity routine called by CppAD
	349	virtual bool rev_sparse_jac(
	350	size_t p ,
	351	const vector< std::set<size_t> >& rt ,
	352	vector< std::set<size_t> >& st )
	353	{ size_t n = st.size();
	354	size_t m = rt.size();
	355	assert( n == 1 );
	356	assert( m == 2 );
	357
	358	// sparsity for S(x)^T = f'(x)^T * R^T
	359	my_union(st[0], rt[0], rt[1]);
	360	return true;
	361	}
	362	</pre></font></code>
378	363	<br/>
379	364	<b><big><a name="rev_sparse_hes" id="rev_sparse_hes">rev_sparse_hes</a></big></b>
380	365
381	366	<code><font color='blue'><pre style='display:inline'>
382		// reverse Hessian sparsity routine called by CppAD
383		virtual bool rev_sparse_hes(
384		const vector<bool>& vx,
385		const vector<bool>& s ,
386		vector<bool>& t ,
387		size_t p ,
388		const vector<bool>& r ,
389		const vector<bool>& u ,
390		vector<bool>& v )
391		{
392		size_t m = s.size();
393		size_t n = t.size();
394		assert( r.size() == n * p );
395		assert( u.size() == m * p );
396		assert( v.size() == n * p );
397		assert( n == 1 );
398		assert( m == 2 );
399
400		// There are no cross term second derivatives for this case,
401		// so it is not necessary to vx.
402
403		// sparsity for T(x) = S(x) * f'(x)
404		t[0] = s[0] \| s[1];
405
406		// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
407		// U(x) = g''(y) * f'(x) * R
408		// S(x) = g'(y)
409
410		// back propagate the sparsity for U, note both components
411		// of f'(x) may be non-zero;
412		size_t j;
413		for(j = 0; j < p; j++)
414		v[j] = u[ 0 * p + j ] \| u[ 1 * p + j ];
415
416		// include forward Jacobian sparsity in Hessian sparsity
417		// (note sparsty for f''(x) * R same as for R)
418		if( s[0] \| s[1] )
419		{ for(j = 0; j < p; j++)
420		{ // Visual Studio 2013 generates warning without bool below
421		v[j] \|= bool( r[j] );
422		}
423		}
424
425		return true;
426		}
427		// reverse Hessian sparsity routine called by CppAD
428		virtual bool rev_sparse_hes(
429		const vector<bool>& vx,
430		const vector<bool>& s ,
431		vector<bool>& t ,
432		size_t p ,
433		const vector< std::set<size_t> >& r ,
434		const vector< std::set<size_t> >& u ,
435		vector< std::set<size_t> >& v )
436		{ size_t m = s.size();
437		size_t n = t.size();
438		assert( r.size() == n );
439		assert( u.size() == m );
440		assert( v.size() == n );
441		assert( n == 1 );
442		assert( m == 2 );
443
444		// There are no cross term second derivatives for this case,
445		// so it is not necessary to vx.
446
447		// sparsity for T(x) = S(x) * f'(x)
448		t[0] = s[0] \| s[1];
449
450		// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
451		// U(x) = g''(y) * f'(x) * R
452		// S(x) = g'(y)
453
454		// back propagate the sparsity for U, note both components
455		// of f'(x) may be non-zero;
456		my_union(v[0], u[0], u[1]);
457
458		// include forward Jacobian sparsity in Hessian sparsity
459		// (note sparsty for f''(x) * R same as for R)
460		if( s[0] \| s[1] )
461		my_union(v[0], v[0], r[0]);
462
463		return true;
464		}
465		</pre></font></code>
466
467		<br/>
	367	// reverse Hessian sparsity routine called by CppAD
	368	virtual bool rev_sparse_hes(
	369	const vector<bool>& vx,
	370	const vector<bool>& s ,
	371	vector<bool>& t ,
	372	size_t p ,
	373	const vector<bool>& r ,
	374	const vector<bool>& u ,
	375	vector<bool>& v )
	376	{
	377	size_t m = s.size();
	378	size_t n = t.size();
	379	assert( r.size() == n * p );
	380	assert( u.size() == m * p );
	381	assert( v.size() == n * p );
	382	assert( n == 1 );
	383	assert( m == 2 );
	384
	385	// There are no cross term second derivatives for this case,
	386	// so it is not necessary to vx.
	387
	388	// sparsity for T(x) = S(x) * f'(x)
	389	t[0] = s[0] \| s[1];
	390
	391	// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
	392	// U(x) = g''(y) * f'(x) * R
	393	// S(x) = g'(y)
	394
	395	// back propagate the sparsity for U, note both components
	396	// of f'(x) may be non-zero;
	397	size_t j;
	398	for(j = 0; j < p; j++)
	399	v[j] = u[ 0 * p + j ] \| u[ 1 * p + j ];
	400
	401	// include forward Jacobian sparsity in Hessian sparsity
	402	// (note sparsty for f''(x) * R same as for R)
	403	if( s[0] \| s[1] )
	404	{ for(j = 0; j < p; j++)
	405	{ // Visual Studio 2013 generates warning without bool below
	406	v[j] \|= bool( r[j] );
	407	}
	408	}
	409
	410	return true;
	411	}
	412	// reverse Hessian sparsity routine called by CppAD
	413	virtual bool rev_sparse_hes(
	414	const vector<bool>& vx,
	415	const vector<bool>& s ,
	416	vector<bool>& t ,
	417	size_t p ,
	418	const vector< std::set<size_t> >& r ,
	419	const vector< std::set<size_t> >& u ,
	420	vector< std::set<size_t> >& v )
	421	{ size_t m = s.size();
	422	size_t n = t.size();
	423	assert( r.size() == n );
	424	assert( u.size() == m );
	425	assert( v.size() == n );
	426	assert( n == 1 );
	427	assert( m == 2 );
	428
	429	// There are no cross term second derivatives for this case,
	430	// so it is not necessary to vx.
	431
	432	// sparsity for T(x) = S(x) * f'(x)
	433	t[0] = s[0] \| s[1];
	434
	435	// V(x) = f'(x)^T * g''(y) * f'(x) * R + g'(y) * f''(x) * R
	436	// U(x) = g''(y) * f'(x) * R
	437	// S(x) = g'(y)
	438
	439	// back propagate the sparsity for U, note both components
	440	// of f'(x) may be non-zero;
	441	my_union(v[0], u[0], u[1]);
	442
	443	// include forward Jacobian sparsity in Hessian sparsity
	444	// (note sparsty for f''(x) * R same as for R)
	445	if( s[0] \| s[1] )
	446	my_union(v[0], v[0], r[0]);
	447
	448	return true;
	449	}
	450	</pre></font></code>
468	451	<br/>
469	452	<b><big><a name="End Class Definition" id="End Class Definition">End Class Definition</a></big></b>
470	453

473	456	} // End empty namespace
474	457
475	458	</pre></font></code>
476
477		<br/>
478		<br/>
479	459	<b><big><a name="Use Atomic Function" id="Use Atomic Function">Use Atomic Function</a></big></b>
480	460
481	461	<code><font color='blue'><pre style='display:inline'>
482	462	bool tangent(void)
483		{ bool ok = true;
484		using CppAD::AD;
485		using CppAD::NearEqual;
486		float eps = 10.f * CppAD::numeric_limits<float>::epsilon();
487		</pre></font></code>
488
489		<br/>
	463	{ bool ok = true;
	464	using CppAD::AD;
	465	using CppAD::NearEqual;
	466	float eps = 10.f * CppAD::numeric_limits<float>::epsilon();
	467	</pre></font></code>
490	468	<br/>
491	469	<b><a name="Use Atomic Function.Constructor" id="Use Atomic Function.Constructor">Constructor</a></b>
492	470
493	471	<code><font color='blue'><pre style='display:inline'>
494		// --------------------------------------------------------------------
495		// Creater a tan and tanh object
496		atomic_tangent my_tan("my_tan", false), my_tanh("my_tanh", true);
497		</pre></font></code>
498
499		<br/>
	472	// --------------------------------------------------------------------
	473	// Creater a tan and tanh object
	474	atomic_tangent my_tan("my_tan", false), my_tanh("my_tanh", true);
	475	</pre></font></code>
500	476	<br/>
501	477	<b><a name="Use Atomic Function.Recording" id="Use Atomic Function.Recording">Recording</a></b>
502	478
503	479	<code><font color='blue'><pre style='display:inline'>
504		// domain space vector
505		size_t n = 1;
506		float x0 = 0.5;
507		CppAD::vector< <a href="ad.xml" target="_top">AD</a><float> > ax(n);
508		ax[0] = x0;
509
510		// declare independent variables and start tape recording
511		CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
512
513		// range space vector
514		size_t m = 3;
515		CppAD::vector< <a href="ad.xml" target="_top">AD</a><float> > af(m);
516
517		// temporary vector for computations
518		// (my_tan and my_tanh computes tan or tanh and its square)
519		CppAD::vector< <a href="ad.xml" target="_top">AD</a><float> > az(2);
520
521		// call atomic tan function and store tan(x) in f[0] (ignore tan(x)^2)
522		my_tan(ax, az);
523		af[0] = az[0];
524
525		// call atomic tanh function and store tanh(x) in f[1] (ignore tanh(x)^2)
526		my_tanh(ax, az);
527		af[1] = az[0];
528
529		// put a constant in f[2] = tanh(1.) (for sparsity pattern testing)
530		CppAD::vector< <a href="ad.xml" target="_top">AD</a><float> > one(1);
531		one[0] = 1.;
532		my_tanh(one, az);
533		af[2] = az[0];
534
535		// create f: x -> f and stop tape recording
536		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><float> F;
537		F.Dependent(ax, af);
538		</pre></font></code>
539
540		<br/>
	480	// domain space vector
	481	size_t n = 1;
	482	float x0 = 0.5;
	483	CppAD::vector< <a href="ad.xml" target="_top">AD</a><float> > ax(n);
	484	ax[0] = x0;
	485
	486	// declare independent variables and start tape recording
	487	CppAD::<a href="independent.xml" target="_top">Independent</a>(ax);
	488
	489	// range space vector
	490	size_t m = 3;
	491	CppAD::vector< <a href="ad.xml" target="_top">AD</a><float> > af(m);
	492
	493	// temporary vector for computations
	494	// (my_tan and my_tanh computes tan or tanh and its square)
	495	CppAD::vector< <a href="ad.xml" target="_top">AD</a><float> > az(2);
	496
	497	// call atomic tan function and store tan(x) in f[0] (ignore tan(x)^2)
	498	my_tan(ax, az);
	499	af[0] = az[0];
	500
	501	// call atomic tanh function and store tanh(x) in f[1] (ignore tanh(x)^2)
	502	my_tanh(ax, az);
	503	af[1] = az[0];
	504
	505	// put a constant in f[2] = tanh(1.) (for sparsity pattern testing)
	506	CppAD::vector< <a href="ad.xml" target="_top">AD</a><float> > one(1);
	507	one[0] = 1.;
	508	my_tanh(one, az);
	509	af[2] = az[0];
	510
	511	// create f: x -> f and stop tape recording
	512	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><float> F;
	513	F.Dependent(ax, af);
	514	</pre></font></code>
541	515	<br/>
542	516	<b><a name="Use Atomic Function.forward" id="Use Atomic Function.forward">forward</a></b>
543	517
544	518	<code><font color='blue'><pre style='display:inline'>
545		// check function value
546		float tan = std::tan(x0);
547		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(af[0] , tan, eps, eps);
548		float tanh = std::tanh(x0);
549		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(af[1] , tanh, eps, eps);
550
551		// check zero order forward
552		CppAD::vector<float> x(n), f(m);
553		x[0] = x0;
554		f = F.<a href="forward.xml" target="_top">Forward</a>(0, x);
555		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(f[0] , tan, eps, eps);
556		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(f[1] , tanh, eps, eps);
557
558		// compute first partial of f w.r.t. x[0] using forward mode
559		CppAD::vector<float> dx(n), df(m);
560		dx[0] = 1.;
561		df = F.<a href="forward.xml" target="_top">Forward</a>(1, dx);
562		</pre></font></code>
563
564		<br/>
	519	// check function value
	520	float tan = std::tan(x0);
	521	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(af[0] , tan, eps, eps);
	522	float tanh = std::tanh(x0);
	523	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(af[1] , tanh, eps, eps);
	524
	525	// check zero order forward
	526	CppAD::vector<float> x(n), f(m);
	527	x[0] = x0;
	528	f = F.<a href="forward.xml" target="_top">Forward</a>(0, x);
	529	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(f[0] , tan, eps, eps);
	530	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(f[1] , tanh, eps, eps);
	531
	532	// compute first partial of f w.r.t. x[0] using forward mode
	533	CppAD::vector<float> dx(n), df(m);
	534	dx[0] = 1.;
	535	df = F.<a href="forward.xml" target="_top">Forward</a>(1, dx);
	536	</pre></font></code>
565	537	<br/>
566	538	<b><a name="Use Atomic Function.reverse" id="Use Atomic Function.reverse">reverse</a></b>
567	539
568	540	<code><font color='blue'><pre style='display:inline'>
569		// compute derivative of tan - tanh using reverse mode
570		CppAD::vector<float> w(m), dw(n);
571		w[0] = 1.;
572		w[1] = 1.;
573		w[2] = 0.;
574		dw = F.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
575
576		// tan'(x) = 1 + tan(x) * tan(x)
577		// tanh'(x) = 1 - tanh(x) * tanh(x)
578		float tanp = 1.f + tan * tan;
579		float tanhp = 1.f - tanh * tanh;
580		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(df[0], tanp, eps, eps);
581		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(df[1], tanhp, eps, eps);
582		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0], w[0]tanp + w[1]tanhp, eps, eps);
583
584		// compute second partial of f w.r.t. x[0] using forward mode
585		CppAD::vector<float> ddx(n), ddf(m);
586		ddx[0] = 0.;
587		ddf = F.<a href="forward.xml" target="_top">Forward</a>(2, ddx);
588
589		// compute second derivative of tan - tanh using reverse mode
590		CppAD::vector<float> ddw(2);
591		ddw = F.<a href="reverse.xml" target="_top">Reverse</a>(2, w);
592
593		// tan''(x) = 2 * tan(x) * tan'(x)
594		// tanh''(x) = - 2 * tanh(x) * tanh'(x)
595		// Note that second order Taylor coefficient for u half the
596		// corresponding second derivative.
597		float two = 2;
598		float tanpp = two * tan * tanp;
599		float tanhpp = - two * tanh * tanhp;
600		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(two * ddf[0], tanpp, eps, eps);
601		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(two * ddf[1], tanhpp, eps, eps);
602		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ddw[0], w[0]tanp + w[1]tanhp , eps, eps);
603		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ddw[1], w[0]tanpp + w[1]tanhpp, eps, eps);
604		</pre></font></code>
605
606		<br/>
	541	// compute derivative of tan - tanh using reverse mode
	542	CppAD::vector<float> w(m), dw(n);
	543	w[0] = 1.;
	544	w[1] = 1.;
	545	w[2] = 0.;
	546	dw = F.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
	547
	548	// tan'(x) = 1 + tan(x) * tan(x)
	549	// tanh'(x) = 1 - tanh(x) * tanh(x)
	550	float tanp = 1.f + tan * tan;
	551	float tanhp = 1.f - tanh * tanh;
	552	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(df[0], tanp, eps, eps);
	553	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(df[1], tanhp, eps, eps);
	554	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0], w[0]tanp + w[1]tanhp, eps, eps);
	555
	556	// compute second partial of f w.r.t. x[0] using forward mode
	557	CppAD::vector<float> ddx(n), ddf(m);
	558	ddx[0] = 0.;
	559	ddf = F.<a href="forward.xml" target="_top">Forward</a>(2, ddx);
	560
	561	// compute second derivative of tan - tanh using reverse mode
	562	CppAD::vector<float> ddw(2);
	563	ddw = F.<a href="reverse.xml" target="_top">Reverse</a>(2, w);
	564
	565	// tan''(x) = 2 * tan(x) * tan'(x)
	566	// tanh''(x) = - 2 * tanh(x) * tanh'(x)
	567	// Note that second order Taylor coefficient for u half the
	568	// corresponding second derivative.
	569	float two = 2;
	570	float tanpp = two * tan * tanp;
	571	float tanhpp = - two * tanh * tanhp;
	572	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(two * ddf[0], tanpp, eps, eps);
	573	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(two * ddf[1], tanhpp, eps, eps);
	574	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ddw[0], w[0]tanp + w[1]tanhp , eps, eps);
	575	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(ddw[1], w[0]tanpp + w[1]tanhpp, eps, eps);
	576	</pre></font></code>
607	577	<br/>
608	578	<b><a name="Use Atomic Function.for_sparse_jac" id="Use Atomic Function.for_sparse_jac">for_sparse_jac</a></b>
609	579
610	580	<code><font color='blue'><pre style='display:inline'>
611		// Forward mode computation of sparsity pattern for F.
612		size_t p = n;
613		// user vectorBool because m and n are small
614		CppAD::vectorBool r1(p), s1(m * p);
615		r1[0] = true; // propagate sparsity for x[0]
616		s1 = F.ForSparseJac(p, r1);
617		ok &= (s1[0] == true); // f[0] depends on x[0]
618		ok &= (s1[1] == true); // f[1] depends on x[0]
619		ok &= (s1[2] == false); // f[2] does not depend on x[0]
620		</pre></font></code>
621
622		<br/>
	581	// Forward mode computation of sparsity pattern for F.
	582	size_t p = n;
	583	// user vectorBool because m and n are small
	584	CppAD::vectorBool r1(p), s1(m * p);
	585	r1[0] = true; // propagate sparsity for x[0]
	586	s1 = F.ForSparseJac(p, r1);
	587	ok &= (s1[0] == true); // f[0] depends on x[0]
	588	ok &= (s1[1] == true); // f[1] depends on x[0]
	589	ok &= (s1[2] == false); // f[2] does not depend on x[0]
	590	</pre></font></code>
623	591	<br/>
624	592	<b><a name="Use Atomic Function.rev_sparse_jac" id="Use Atomic Function.rev_sparse_jac">rev_sparse_jac</a></b>
625	593
626	594	<code><font color='blue'><pre style='display:inline'>
627		// Reverse mode computation of sparsity pattern for F.
628		size_t q = m;
629		CppAD::vectorBool s2(q * m), r2(q * n);
630		// Sparsity pattern for identity matrix
631		size_t i, j;
632		for(i = 0; i < q; i++)
633		{ for(j = 0; j < m; j++)
634		s2[i * q + j] = (i == j);
635		}
636		r2 = F.RevSparseJac(q, s2);
637		ok &= (r2[0] == true); // f[0] depends on x[0]
638		ok &= (r2[1] == true); // f[1] depends on x[0]
639		ok &= (r2[2] == false); // f[2] does not depend on x[0]
640		</pre></font></code>
641
642		<br/>
	595	// Reverse mode computation of sparsity pattern for F.
	596	size_t q = m;
	597	CppAD::vectorBool s2(q * m), r2(q * n);
	598	// Sparsity pattern for identity matrix
	599	size_t i, j;
	600	for(i = 0; i < q; i++)
	601	{ for(j = 0; j < m; j++)
	602	s2[i * q + j] = (i == j);
	603	}
	604	r2 = F.RevSparseJac(q, s2);
	605	ok &= (r2[0] == true); // f[0] depends on x[0]
	606	ok &= (r2[1] == true); // f[1] depends on x[0]
	607	ok &= (r2[2] == false); // f[2] does not depend on x[0]
	608	</pre></font></code>
643	609	<br/>
644	610	<b><a name="Use Atomic Function.rev_sparse_hes" id="Use Atomic Function.rev_sparse_hes">rev_sparse_hes</a></b>
645	611
646	612	<code><font color='blue'><pre style='display:inline'>
647		// Hessian sparsity for f[0]
648		CppAD::vectorBool s3(m), h(p * n);
649		s3[0] = true;
650		s3[1] = false;
651		s3[2] = false;
652		h = F.RevSparseHes(p, s3);
653		ok &= (h[0] == true); // Hessian is non-zero
654
655		// Hessian sparsity for f[2]
656		s3[0] = false;
657		s3[2] = true;
658		h = F.RevSparseHes(p, s3);
659		ok &= (h[0] == false); // Hessian is zero
660		</pre></font></code>
661
662		<br/>
	613	// Hessian sparsity for f[0]
	614	CppAD::vectorBool s3(m), h(p * n);
	615	s3[0] = true;
	616	s3[1] = false;
	617	s3[2] = false;
	618	h = F.RevSparseHes(p, s3);
	619	ok &= (h[0] == true); // Hessian is non-zero
	620
	621	// Hessian sparsity for f[2]
	622	s3[0] = false;
	623	s3[2] = true;
	624	h = F.RevSparseHes(p, s3);
	625	ok &= (h[0] == false); // Hessian is zero
	626	</pre></font></code>
663	627	<br/>
664	628	<b><a name="Use Atomic Function.Large x Values" id="Use Atomic Function.Large x Values">Large x Values</a></b>
665	629
666	630	<code><font color='blue'><pre style='display:inline'>
667		// check tanh results for a large value of x
668		x[0] = std::numeric_limits<float>::max() / two;
669		f = F.<a href="forward.xml" target="_top">Forward</a>(0, x);
670		tanh = 1.;
671		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(f[1], tanh, eps, eps);
672		df = F.<a href="forward.xml" target="_top">Forward</a>(1, dx);
673		tanhp = 0.;
674		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(df[1], tanhp, eps, eps);
675
676		return ok;
	631	// check tanh results for a large value of x
	632	x[0] = std::numeric_limits<float>::max() / two;
	633	f = F.<a href="forward.xml" target="_top">Forward</a>(0, x);
	634	tanh = 1.;
	635	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(f[1], tanh, eps, eps);
	636	df = F.<a href="forward.xml" target="_top">Forward</a>(1, dx);
	637	tanhp = 0.;
	638	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(df[1], tanhp, eps, eps);
	639
	640	return ok;
677	641	}
678	642	</pre></font></code>
679
680
681	643
682	644	<hr/>Input File: example/atomic/tangent.cpp
683	645

+11

-21

doc/auto_tools.xml less more

5	5	<title>Auto Tools Unix Test and Installation</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Auto Tools Unix Test and Installation"/>
8		<meta name="keywords" id="keywords" content=" auto tools unix test and installation speed profile prefix std vector boost eigen sparse internal sets ctor implicit explicit compile flags Openmp postfix Adolc Fadbad Ipopt Sacado memory usage tape deprecated 2012-12-26 distribution directory work configure make examples tests profiling cppad prefix_dir --with-documentation --with-testvector --with-sparse_option --with-deprecated max_num_threads cxx_flags openmp_flags postfix_dir adolc_dir linux cygwin boost_dir eigen_dir fadbad_dir ipopt_dir sacado_dir tape_addr_type tape_id_type install "/>
	8	<meta name="keywords" id="keywords" content=" auto tools unix test installation speed profile prefix std vector boost eigen sparse internal sets ctor implicit explicit compile flags Openmp postfix Adolc Fadbad Ipopt Sacado memory usage tape deprecated 2012-12-26 distribution directory work configure make examples tests profiling cppad prefix_dir --with-documentation --with-testvector --with-sparse_option --with-deprecated max_num_threads cxx_flags openmp_flags postfix_dir adolc_dir linux cygwin boost_dir eigen_dir fadbad_dir ipopt_dir sacado_dir tape_addr_type tape_id_type install "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

186	186	</span></code>The following command will build all the correctness and speed tests.
187	187	In addition, it will run all the correctness tests:
188	188	<code><font color='blue'><pre style='display:inline'>
189		make test
	189	make test
190	190	</pre></font></code>
191
192	191	<code><span style='white-space: nowrap'><br/>
193	192	<br/>
194	193	</span></code>The following links describe how to build and run subsets of these tests:

291	290	you may have to replace <code><font color="blue">profile</font></code> by <code><font color="blue">profile.exe</font></code>
292	291	in the <code><font color="blue">gprof</font></code> command above; i.e.,
293	292	<code><font color='blue'><pre style='display:inline'>
294		gprof -b profile.exe
	293	gprof -b profile.exe
295	294	</pre></font></code>
296
297	295	In C++, template parameters and argument types become part of a
298	296	routines's name.
299	297	This can make the <code><font color="blue">gprof</font></code> output hard to read

301	299	You can remove the template parameters and argument types from the
302	300	routine names by executing the following command
303	301	<code><font color='blue'><pre style='display:inline'>
304		gprof -b profile \| sed -f gprof.sed
	302	gprof -b profile \| sed -f gprof.sed
305	303	</pre></font></code>
306
307	304	If you are using a windows operating system with Cygwin or MinGW,
308	305	you would need to use
309	306	<code><font color='blue'><pre style='display:inline'>
310		gprof -b profile.exe \| sed -f gprof.sed
	307	gprof -b profile.exe \| sed -f gprof.sed
311	308	</pre></font></code>
312
313
314		<br/>
315	309	<br/>
316	310	<b><big><a name="prefix_dir" id="prefix_dir">prefix_dir</a></big></b>
317	311	<br/>

325	319	option,
326	320	if you specify
327	321	<code><font color='blue'><pre style='display:inline'>
328		./configure --prefix=/usr/local
	322	./configure --prefix=/usr/local
329	323	</pre></font></code>
330
331	324	the CppAD include files will be installed in the directory
332	325
333	326	<code><font color="blue"><span style='white-space: nowrap'><br/>

374	367	.
375	368	If one, and only one, of the following command line arguments is specified:
376	369	<code><font color='blue'><pre style='display:inline'>
377		--with-stdvector
378		--with-boostvector
379		--with-eigenvector
	370	--with-stdvector
	371	--with-boostvector
	372	--with-eigenvector
380	373	</pre></font></code>
381
382	374	the corresponding of the following template classes is used
383	375
384	376	<code><font color="blue"><span style='white-space: nowrap'><br/>

486	478	option,
487	479	if you specify
488	480	<code><font color='blue'><pre style='display:inline'>
489		./configure --prefix=/usr/local POSTFIX_DIR=coin
	481	./configure --prefix=/usr/local POSTFIX_DIR=coin
490	482	</pre></font></code>
491
492	483	the CppAD include files will be
493	484	<a href="auto_tools.xml#make install" target="_top"><span style='white-space: nowrap'>installed</span></a>
494	485	in the directory

789	780	Once you are satisfied that the tests are giving correct results,
790	781	you can install CppAD into easy to use directories by executing the command
791	782	<code><font color='blue'><pre style='display:inline'>
792		make install
	783	make install
793	784	</pre></font></code>
794
795	785	This will install CppAD in the location specified by
796	786	<a href="auto_tools.xml#prefix_dir" target="_top"><span style='white-space: nowrap'>prefix_dir</span></a>
797	787	.

+1

-1

doc/azmul.cpp.xml less more

5	5	<title>AD Absolute Zero Multiplication: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Absolute Zero Multiplication: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad absolute zero multiplication: example and test "/>
	8	<meta name="keywords" id="keywords" content=" ad absolute zero multiplication: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+107

-141

doc/base_adolc.hpp.xml less more

5	5	<title>Enable use of AD<Base> where Base is Adolc's adouble Type</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Enable use of AD<Base> where Base is Adolc's adouble Type"/>
8		<meta name="keywords" id="keywords" content=" enable use of ad<base> where base is adolc's adouble type syntax example include files condexpop condexprel equalopseq identical integer azmul ordered unary standard math erf asinh acosh atanh expm1 log1p sign abs pow numeric_limits "/>
	8	<meta name="keywords" id="keywords" content=" enable use ad<base> where base is adolc's adouble type syntax example include files condexpop condexprel equalopseq identical integer azmul ordered unary standard math erf asinh acosh atanh expm1 log1p sign abs pow numeric_limits "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

144	144	# include <adolc/adolc.h>
145	145	# include <cppad/base_require.hpp>
146	146	</pre></font></code>
147
148
149		<br/>
150	147	<br/>
151	148	<b><big><a name="CondExpOp" id="CondExpOp">CondExpOp</a></big></b>
152	149	<br/>

168	165	function).
169	166	<code><font color='blue'><pre style='display:inline'>
170	167	namespace CppAD {
171		inline adouble CondExpOp(
172		enum CppAD::CompareOp cop ,
173		const adouble &left ,
174		const adouble &right ,
175		const adouble &trueCase ,
176		const adouble &falseCase )
177		{ adouble result;
178		switch( cop )
179		{
180		case CompareLt: // left < right
181		condassign(result, right - left, trueCase, falseCase);
182		break;
183
184		case CompareLe: // left <= right
185		condassign(result, left - right, falseCase, trueCase);
186		break;
187
188		case CompareEq: // left == right
189		condassign(result, left - right, falseCase, trueCase);
190		condassign(result, right - left, falseCase, result);
191		break;
192
193		case CompareGe: // left >= right
194		condassign(result, right - left, falseCase, trueCase);
195		break;
196
197		case CompareGt: // left > right
198		condassign(result, left - right, trueCase, falseCase);
199		break;
200		default:
201		CppAD::ErrorHandler::Call(
202		true , __LINE__ , __FILE__ ,
203		"CppAD::CondExp",
204		"Error: for unknown reason."
205		);
206		result = trueCase;
207		}
208		return result;
209		}
210		}
211		</pre></font></code>
212
213
214		<br/>
	168	inline adouble CondExpOp(
	169	enum CppAD::CompareOp cop ,
	170	const adouble &left ,
	171	const adouble &right ,
	172	const adouble &trueCase ,
	173	const adouble &falseCase )
	174	{ adouble result;
	175	switch( cop )
	176	{
	177	case CompareLt: // left < right
	178	condassign(result, right - left, trueCase, falseCase);
	179	break;
	180
	181	case CompareLe: // left <= right
	182	condassign(result, left - right, falseCase, trueCase);
	183	break;
	184
	185	case CompareEq: // left == right
	186	condassign(result, left - right, falseCase, trueCase);
	187	condassign(result, right - left, falseCase, result);
	188	break;
	189
	190	case CompareGe: // left >= right
	191	condassign(result, right - left, falseCase, trueCase);
	192	break;
	193
	194	case CompareGt: // left > right
	195	condassign(result, left - right, trueCase, falseCase);
	196	break;
	197	default:
	198	CppAD::ErrorHandler::Call(
	199	true , __LINE__ , __FILE__ ,
	200	"CppAD::CondExp",
	201	"Error: for unknown reason."
	202	);
	203	result = trueCase;
	204	}
	205	return result;
	206	}
	207	}
	208	</pre></font></code>
215	209	<br/>
216	210	<b><big><a name="CondExpRel" id="CondExpRel">CondExpRel</a></big></b>
217	211	<br/>

219	213	macro invocation
220	214	<code><font color='blue'><pre style='display:inline'>
221	215	namespace CppAD {
222		CPPAD_COND_EXP_REL(adouble)
223		}
224		</pre></font></code>
225
226
227		<br/>
	216	CPPAD_COND_EXP_REL(adouble)
	217	}
	218	</pre></font></code>
228	219	<br/>
229	220	<b><big><a name="EqualOpSeq" id="EqualOpSeq">EqualOpSeq</a></big></b>
230	221	<br/>

233	224	Make <code><font color="blue">EqualOpSeq</font></code> an error if it gets used:
234	225	<code><font color='blue'><pre style='display:inline'>
235	226	namespace CppAD {
236		inline bool EqualOpSeq(const adouble &x, const adouble &y)
237		{ CppAD::ErrorHandler::Call(
238		true , __LINE__ , __FILE__ ,
239		"CppAD::EqualOpSeq(x, y)",
240		"Error: adouble does not support EqualOpSeq."
241		);
242		return false;
243		}
244		}
245		</pre></font></code>
246
247
248		<br/>
	227	inline bool EqualOpSeq(const adouble &x, const adouble &y)
	228	{ CppAD::ErrorHandler::Call(
	229	true , __LINE__ , __FILE__ ,
	230	"CppAD::EqualOpSeq(x, y)",
	231	"Error: adouble does not support EqualOpSeq."
	232	);
	233	return false;
	234	}
	235	}
	236	</pre></font></code>
249	237	<br/>
250	238	<b><big><a name="Identical" id="Identical">Identical</a></big></b>
251	239	<br/>

254	242	To be safe (but slow) return <code><font color="blue">false</font></code> in all the cases below.
255	243	<code><font color='blue'><pre style='display:inline'>
256	244	namespace CppAD {
257		inline bool IdenticalPar(const adouble &x)
258		{ return false; }
259		inline bool IdenticalZero(const adouble &x)
260		{ return false; }
261		inline bool IdenticalOne(const adouble &x)
262		{ return false; }
263		inline bool IdenticalEqualPar(const adouble &x, const adouble &y)
264		{ return false; }
265		}
266		</pre></font></code>
267
268
269		<br/>
	245	inline bool IdenticalPar(const adouble &x)
	246	{ return false; }
	247	inline bool IdenticalZero(const adouble &x)
	248	{ return false; }
	249	inline bool IdenticalOne(const adouble &x)
	250	{ return false; }
	251	inline bool IdenticalEqualPar(const adouble &x, const adouble &y)
	252	{ return false; }
	253	}
	254	</pre></font></code>
270	255	<br/>
271	256	<b><big><a name="Integer" id="Integer">Integer</a></big></b>
272	257
273	258	<code><font color='blue'><pre style='display:inline'>
274		inline int Integer(const adouble &x)
275		{ return static_cast<int>( x.getValue() ); }
276		</pre></font></code>
277
278
279		<br/>
	259	inline int Integer(const adouble &x)
	260	{ return static_cast<int>( x.getValue() ); }
	261	</pre></font></code>
280	262	<br/>
281	263	<b><big><a name="azmul" id="azmul">azmul</a></big></b>
282	264
283	265	<code><font color='blue'><pre style='display:inline'>
284	266	namespace CppAD {
285		CPPAD_AZMUL( adouble )
286		}
287		</pre></font></code>
288
289
290		<br/>
	267	CPPAD_AZMUL( adouble )
	268	}
	269	</pre></font></code>
291	270	<br/>
292	271	<b><big><a name="Ordered" id="Ordered">Ordered</a></big></b>
293	272
294	273	<code><font color='blue'><pre style='display:inline'>
295	274	namespace CppAD {
296		inline bool GreaterThanZero(const adouble &x)
297		{ return (x > 0); }
298		inline bool GreaterThanOrZero(const adouble &x)
299		{ return (x >= 0); }
300		inline bool LessThanZero(const adouble &x)
301		{ return (x < 0); }
302		inline bool LessThanOrZero(const adouble &x)
303		{ return (x <= 0); }
304		inline bool abs_geq(const adouble& x, const adouble& y)
305		{ return fabs(x) >= fabs(y); }
306		}
307		</pre></font></code>
308
309
310		<br/>
	275	inline bool GreaterThanZero(const adouble &x)
	276	{ return (x > 0); }
	277	inline bool GreaterThanOrZero(const adouble &x)
	278	{ return (x >= 0); }
	279	inline bool LessThanZero(const adouble &x)
	280	{ return (x < 0); }
	281	inline bool LessThanOrZero(const adouble &x)
	282	{ return (x <= 0); }
	283	inline bool abs_geq(const adouble& x, const adouble& y)
	284	{ return fabs(x) >= fabs(y); }
	285	}
	286	</pre></font></code>
311	287	<br/>
312	288	<b><big><a name="Unary Standard Math" id="Unary Standard Math">Unary Standard Math</a></big></b>
313	289	<br/>

352	328	return 0.0; \
353	329	}
354	330	# if CPPAD_USE_CPLUSPLUS_2011
355		CPPAD_BASE_ADOLC_NO_SUPPORT(erf)
356		CPPAD_BASE_ADOLC_NO_SUPPORT(asinh)
357		CPPAD_BASE_ADOLC_NO_SUPPORT(acosh)
358		CPPAD_BASE_ADOLC_NO_SUPPORT(atanh)
359		CPPAD_BASE_ADOLC_NO_SUPPORT(expm1)
360		CPPAD_BASE_ADOLC_NO_SUPPORT(log1p)
	331	CPPAD_BASE_ADOLC_NO_SUPPORT(erf)
	332	CPPAD_BASE_ADOLC_NO_SUPPORT(asinh)
	333	CPPAD_BASE_ADOLC_NO_SUPPORT(acosh)
	334	CPPAD_BASE_ADOLC_NO_SUPPORT(atanh)
	335	CPPAD_BASE_ADOLC_NO_SUPPORT(expm1)
	336	CPPAD_BASE_ADOLC_NO_SUPPORT(log1p)
361	337	# endif
362	338	# undef CPPAD_BASE_ADOLC_NO_SUPPORT
363	339	}
364	340	</pre></font></code>
365
366
367		<br/>
368	341	<br/>
369	342	<b><big><a name="sign" id="sign">sign</a></big></b>
370	343	<br/>

376	349	.
377	350	<code><font color='blue'><pre style='display:inline'>
378	351	namespace CppAD {
379		inline adouble sign(const adouble& x)
380		{ adouble s_plus, s_minus, half(.5);
381		// set s_plus to sign(x)/2, except for case x == 0, s_plus = -.5
382		condassign(s_plus, +x, -half, +half);
383		// set s_minus to -sign(x)/2, except for case x == 0, s_minus = -.5
384		condassign(s_minus, -x, -half, +half);
385		// set s to sign(x)
386		return s_plus - s_minus;
387		}
388		}
389		</pre></font></code>
390
391
392		<br/>
	352	inline adouble sign(const adouble& x)
	353	{ adouble s_plus, s_minus, half(.5);
	354	// set s_plus to sign(x)/2, except for case x == 0, s_plus = -.5
	355	condassign(s_plus, +x, -half, +half);
	356	// set s_minus to -sign(x)/2, except for case x == 0, s_minus = -.5
	357	condassign(s_minus, -x, -half, +half);
	358	// set s to sign(x)
	359	return s_plus - s_minus;
	360	}
	361	}
	362	</pre></font></code>
393	363	<br/>
394	364	<b><big><a name="abs" id="abs">abs</a></big></b>
395	365	<br/>

398	368	function:
399	369	<code><font color='blue'><pre style='display:inline'>
400	370	namespace CppAD {
401		inline adouble abs(const adouble& x)
402		{ return fabs(x); }
403		}
404		</pre></font></code>
405
406
407		<br/>
	371	inline adouble abs(const adouble& x)
	372	{ return fabs(x); }
	373	}
	374	</pre></font></code>
408	375	<br/>
409	376	<b><big><a name="pow" id="pow">pow</a></big></b>
410	377	<br/>

421	388	for the type <code><font color="blue">adouble</font></code>:
422	389	<code><font color='blue'><pre style='display:inline'>
423	390	namespace CppAD {
424		CPPAD_NUMERIC_LIMITS(double, adouble)
425		}
426		</pre></font></code>
427
	391	CPPAD_NUMERIC_LIMITS(double, adouble)
	392	}
	393	</pre></font></code>
428	394
429	395	<hr/>Input File: cppad/example/base_adolc.hpp
430	396

+162

-215

doc/base_alloc.hpp.xml less more

133	133	# include <cppad/base_require.hpp>
134	134	# include <cppad/utility/thread_alloc.hpp>
135	135	</pre></font></code>
136
137
138		<br/>
139	136	<br/>
140	137	<b><big><a name="Computed Assignment Macro" id="Computed Assignment Macro">Computed Assignment Macro</a></big></b>
141	138	<br/>

150	147	<code><font color="blue">/=</font></code>.
151	148	<code><font color='blue'><pre style='display:inline'>
152	149	# define BASE_ALLOC_ASSIGN_OPERATOR(op) \
153		void operator op (const base_alloc& x) \
154		{ ptrdbl_ op x.ptrdbl_; }
155		</pre></font></code>
156
157
158		<br/>
	150	void operator op (const base_alloc& x) \
	151	{ ptrdbl_ op x.ptrdbl_; }
	152	</pre></font></code>
159	153	<br/>
160	154	<b><big><a name="Binary Operator Macro" id="Binary Operator Macro">Binary Operator Macro</a></big></b>
161	155	<br/>

170	164	<code><font color="blue">/</font></code>.
171	165	<code><font color='blue'><pre style='display:inline'>
172	166	# define BASE_ALLOC_BINARY_OPERATOR(op) const \
173		base_alloc operator op (const base_alloc& x) const \
174		{ base_alloc result; \
175		double dbl = *ptrdbl_; \
176		double x_dbl = *x.ptrdbl_; \
177		*result.ptrdbl_ = dbl op x_dbl; \
178		return result; \
179		}
180		</pre></font></code>
181
182
183		<br/>
	167	base_alloc operator op (const base_alloc& x) const \
	168	{ base_alloc result; \
	169	double dbl = *ptrdbl_; \
	170	double x_dbl = *x.ptrdbl_; \
	171	*result.ptrdbl_ = dbl op x_dbl; \
	172	return result; \
	173	}
	174	</pre></font></code>
184	175	<br/>
185	176	<b><big><a name="Boolean Operator Macro" id="Boolean Operator Macro">Boolean Operator Macro</a></big></b>
186	177	<br/>

198	189	<code><font color="blue">></font></code>,
199	190	<code><font color='blue'><pre style='display:inline'>
200	191	# define BASE_ALLOC_BOOL_OPERATOR(op) const \
201		bool operator op (const base_alloc& x) const \
202		{ double dbl = *ptrdbl_; \
203		double x_dbl = *x.ptrdbl_; \
204		return dbl op x_dbl; \
205		}
206		</pre></font></code>
207
208
209		<br/>
	192	bool operator op (const base_alloc& x) const \
	193	{ double dbl = *ptrdbl_; \
	194	double x_dbl = *x.ptrdbl_; \
	195	return dbl op x_dbl; \
	196	}
	197	</pre></font></code>
210	198	<br/>
211	199	<b><big><a name="Class Definition" id="Class Definition">Class Definition</a></big></b>
212	200	<br/>

219	207
220	208	class base_alloc {
221	209	public:
222		double* ptrdbl_;
223
224		base_alloc(void)
225		{ size_t cap;
226		void* v = CppAD::thread_alloc::get_memory(sizeof(double), cap);
227		ptrdbl_ = static_cast<double*>(v);
228		}
229		base_alloc(double dbl)
230		{ size_t cap;
231		void *v = CppAD::thread_alloc::get_memory(sizeof(double), cap);
232		ptrdbl_ = static_cast<double*>(v);
233		*ptrdbl_ = dbl;
234		}
235		base_alloc(const base_alloc& x)
236		{ size_t cap;
237		void *v = CppAD::thread_alloc::get_memory(sizeof(double), cap);
238		ptrdbl_ = static_cast<double*>(v);
239		ptrdbl_ = x.ptrdbl_;
240		}
241		~base_alloc(void)
242		{ void* v = static_cast<void*>(ptrdbl_);
243		CppAD::thread_alloc::return_memory(v);
244		}
245		base_alloc operator-(void) const
246		{ base_alloc result;
247		result.ptrdbl_ = - ptrdbl_;
248		return result;
249		}
250		base_alloc operator+(void) const
251		{ return *this; }
252		void operator=(const base_alloc& x)
253		{ ptrdbl_ = x.ptrdbl_; }
254		BASE_ALLOC_ASSIGN_OPERATOR(+=)
255		BASE_ALLOC_ASSIGN_OPERATOR(-=)
256		BASE_ALLOC_ASSIGN_OPERATOR(*=)
257		BASE_ALLOC_ASSIGN_OPERATOR(/=)
258		BASE_ALLOC_BINARY_OPERATOR(+)
259		BASE_ALLOC_BINARY_OPERATOR(-)
260		BASE_ALLOC_BINARY_OPERATOR(*)
261		BASE_ALLOC_BINARY_OPERATOR(/)
262		BASE_ALLOC_BOOL_OPERATOR(==)
263		BASE_ALLOC_BOOL_OPERATOR(!=)
264		// The <= operator is not necessary for the base type requirements
265		// (needed so we can use NearEqual with base_alloc arguments).
266		BASE_ALLOC_BOOL_OPERATOR(<=)
	210	double* ptrdbl_;
	211
	212	base_alloc(void)
	213	{ size_t cap;
	214	void* v = CppAD::thread_alloc::get_memory(sizeof(double), cap);
	215	ptrdbl_ = static_cast<double*>(v);
	216	}
	217	base_alloc(double dbl)
	218	{ size_t cap;
	219	void *v = CppAD::thread_alloc::get_memory(sizeof(double), cap);
	220	ptrdbl_ = static_cast<double*>(v);
	221	*ptrdbl_ = dbl;
	222	}
	223	base_alloc(const base_alloc& x)
	224	{ size_t cap;
	225	void *v = CppAD::thread_alloc::get_memory(sizeof(double), cap);
	226	ptrdbl_ = static_cast<double*>(v);
	227	ptrdbl_ = x.ptrdbl_;
	228	}
	229	~base_alloc(void)
	230	{ void* v = static_cast<void*>(ptrdbl_);
	231	CppAD::thread_alloc::return_memory(v);
	232	}
	233	base_alloc operator-(void) const
	234	{ base_alloc result;
	235	result.ptrdbl_ = - ptrdbl_;
	236	return result;
	237	}
	238	base_alloc operator+(void) const
	239	{ return *this; }
	240	void operator=(const base_alloc& x)
	241	{ ptrdbl_ = x.ptrdbl_; }
	242	BASE_ALLOC_ASSIGN_OPERATOR(+=)
	243	BASE_ALLOC_ASSIGN_OPERATOR(-=)
	244	BASE_ALLOC_ASSIGN_OPERATOR(*=)
	245	BASE_ALLOC_ASSIGN_OPERATOR(/=)
	246	BASE_ALLOC_BINARY_OPERATOR(+)
	247	BASE_ALLOC_BINARY_OPERATOR(-)
	248	BASE_ALLOC_BINARY_OPERATOR(*)
	249	BASE_ALLOC_BINARY_OPERATOR(/)
	250	BASE_ALLOC_BOOL_OPERATOR(==)
	251	BASE_ALLOC_BOOL_OPERATOR(!=)
	252	// The <= operator is not necessary for the base type requirements
	253	// (needed so we can use NearEqual with base_alloc arguments).
	254	BASE_ALLOC_BOOL_OPERATOR(<=)
267	255	};
268	256	</pre></font></code>
269
270
271		<br/>
272	257	<br/>
273	258	<b><big><a name="CondExpOp" id="CondExpOp">CondExpOp</a></big></b>
274	259	<br/>

277	262	Hence its <code><font color="blue">CondExpOp</font></code> function is defined by
278	263	<code><font color='blue'><pre style='display:inline'>
279	264	namespace CppAD {
280		inline base_alloc CondExpOp(
281		enum CompareOp cop ,
282		const base_alloc& left ,
283		const base_alloc& right ,
284		const base_alloc& exp_if_true ,
285		const base_alloc& exp_if_false )
286		{ // not used
287		assert(false);
288
289		// to void compiler error
290		return base_alloc();
291		}
292		}
293		</pre></font></code>
294
295
296		<br/>
	265	inline base_alloc CondExpOp(
	266	enum CompareOp cop ,
	267	const base_alloc& left ,
	268	const base_alloc& right ,
	269	const base_alloc& exp_if_true ,
	270	const base_alloc& exp_if_false )
	271	{ // not used
	272	assert(false);
	273
	274	// to void compiler error
	275	return base_alloc();
	276	}
	277	}
	278	</pre></font></code>
297	279	<br/>
298	280	<b><big><a name="CondExpRel" id="CondExpRel">CondExpRel</a></big></b>
299	281	<br/>

301	283	macro invocation
302	284	<code><font color='blue'><pre style='display:inline'>
303	285	namespace CppAD {
304		CPPAD_COND_EXP_REL(base_alloc)
305		}
306		</pre></font></code>
307
	286	CPPAD_COND_EXP_REL(base_alloc)
	287	}
	288	</pre></font></code>
308	289	uses <code><font color="blue">CondExpOp</font></code> above to
309	290	define
310	291	<code><font color="blue"><span style='white-space: nowrap'>CondExp</span></font><i><font color="black"><span style='white-space: nowrap'>Rel</span></font></i></code>

321	302	The type <code><font color="blue">base_alloc</font></code> is simple (in this respect) and so we define
322	303	<code><font color='blue'><pre style='display:inline'>
323	304	namespace CppAD {
324		inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
325		{ return x.ptrdbl_ == y.ptrdbl_; }
326		}
327		</pre></font></code>
328
329
330		<br/>
	305	inline bool EqualOpSeq(const base_alloc& x, const base_alloc& y)
	306	{ return x.ptrdbl_ == y.ptrdbl_; }
	307	}
	308	</pre></font></code>
331	309	<br/>
332	310	<b><big><a name="Identical" id="Identical">Identical</a></big></b>
333	311	<br/>
334	312	The type <code><font color="blue">base_alloc</font></code> is simple (in this respect) and so we define
335	313	<code><font color='blue'><pre style='display:inline'>
336	314	namespace CppAD {
337		inline bool IdenticalPar(const base_alloc& x)
338		{ return true; }
339		inline bool IdenticalZero(const base_alloc& x)
340		{ return (*x.ptrdbl_ == 0.0); }
341		inline bool IdenticalOne(const base_alloc& x)
342		{ return (*x.ptrdbl_ == 1.0); }
343		inline bool IdenticalEqualPar(const base_alloc& x, const base_alloc& y)
344		{ return (x.ptrdbl_ == y.ptrdbl_); }
345		}
346		</pre></font></code>
347
348
349		<br/>
	315	inline bool IdenticalPar(const base_alloc& x)
	316	{ return true; }
	317	inline bool IdenticalZero(const base_alloc& x)
	318	{ return (*x.ptrdbl_ == 0.0); }
	319	inline bool IdenticalOne(const base_alloc& x)
	320	{ return (*x.ptrdbl_ == 1.0); }
	321	inline bool IdenticalEqualPar(const base_alloc& x, const base_alloc& y)
	322	{ return (x.ptrdbl_ == y.ptrdbl_); }
	323	}
	324	</pre></font></code>
350	325	<br/>
351	326	<b><big><a name="Output Operator" id="Output Operator">Output Operator</a></big></b>
352	327
353	328	<code><font color='blue'><pre style='display:inline'>
354	329	namespace CppAD {
355		std::ostream& operator << (std::ostream &os, const base_alloc& x)
356		{ os << *x.ptrdbl_;
357		return os;
358		}
359		}
360		</pre></font></code>
361
362
363		<br/>
	330	std::ostream& operator << (std::ostream &os, const base_alloc& x)
	331	{ os << *x.ptrdbl_;
	332	return os;
	333	}
	334	}
	335	</pre></font></code>
364	336	<br/>
365	337	<b><big><a name="Integer" id="Integer">Integer</a></big></b>
366	338
367	339	<code><font color='blue'><pre style='display:inline'>
368	340	namespace CppAD {
369		inline int Integer(const base_alloc& x)
370		{ return static_cast<int>(*x.ptrdbl_); }
371		}
372		</pre></font></code>
373
374
375		<br/>
	341	inline int Integer(const base_alloc& x)
	342	{ return static_cast<int>(*x.ptrdbl_); }
	343	}
	344	</pre></font></code>
376	345	<br/>
377	346	<b><big><a name="azmul" id="azmul">azmul</a></big></b>
378	347
379	348	<code><font color='blue'><pre style='display:inline'>
380	349	namespace CppAD {
381		CPPAD_AZMUL( base_alloc )
382		}
383		</pre></font></code>
384
385
386		<br/>
	350	CPPAD_AZMUL( base_alloc )
	351	}
	352	</pre></font></code>
387	353	<br/>
388	354	<b><big><a name="Ordered" id="Ordered">Ordered</a></big></b>
389	355	<br/>
390	356	The <code><font color="blue">base_alloc</font></code> type supports ordered comparisons
391	357	<code><font color='blue'><pre style='display:inline'>
392	358	namespace CppAD {
393		inline bool GreaterThanZero(const base_alloc& x)
394		{ return *x.ptrdbl_ > 0.0; }
395		inline bool GreaterThanOrZero(const base_alloc& x)
396		{ return *x.ptrdbl_ >= 0.0; }
397		inline bool LessThanZero(const base_alloc& x)
398		{ return *x.ptrdbl_ < 0.0; }
399		inline bool LessThanOrZero(const base_alloc& x)
400		{ return *x.ptrdbl_ <= 0.f; }
401		inline bool abs_geq(const base_alloc& x, const base_alloc& y)
402		{ return std::fabs(x.ptrdbl_) >= std::fabs(y.ptrdbl_); }
403		}
404		</pre></font></code>
405
406
407		<br/>
	359	inline bool GreaterThanZero(const base_alloc& x)
	360	{ return *x.ptrdbl_ > 0.0; }
	361	inline bool GreaterThanOrZero(const base_alloc& x)
	362	{ return *x.ptrdbl_ >= 0.0; }
	363	inline bool LessThanZero(const base_alloc& x)
	364	{ return *x.ptrdbl_ < 0.0; }
	365	inline bool LessThanOrZero(const base_alloc& x)
	366	{ return *x.ptrdbl_ <= 0.f; }
	367	inline bool abs_geq(const base_alloc& x, const base_alloc& y)
	368	{ return std::fabs(x.ptrdbl_) >= std::fabs(y.ptrdbl_); }
	369	}
	370	</pre></font></code>
408	371	<br/>
409	372	<b><big><a name="Unary Standard Math" id="Unary Standard Math">Unary Standard Math</a></big></b>
410	373	<br/>

415	378	a special macro for this type:
416	379	<code><font color='blue'><pre style='display:inline'>
417	380	# define BASE_ALLOC_STD_MATH(fun) \
418		inline base_alloc fun (const base_alloc& x) \
419		{ return std::fun(*x.ptrdbl_); }
420		</pre></font></code>
421
	381	inline base_alloc fun (const base_alloc& x) \
	382	{ return std::fun(*x.ptrdbl_); }
	383	</pre></font></code>
422	384	The following invocations of the macro above define the
423	385	<a href="base_std_math.xml#Unary Standard Math" target="_top"><span style='white-space: nowrap'>unary standard math</span></a>
424	386	functions
425	387	(except for <code><font color="blue">abs</font></code>):
426	388	<code><font color='blue'><pre style='display:inline'>
427	389	namespace CppAD {
428		BASE_ALLOC_STD_MATH(acos)
429		BASE_ALLOC_STD_MATH(asin)
430		BASE_ALLOC_STD_MATH(atan)
431		BASE_ALLOC_STD_MATH(cos)
432		BASE_ALLOC_STD_MATH(cosh)
433		BASE_ALLOC_STD_MATH(exp)
434		BASE_ALLOC_STD_MATH(log)
435		BASE_ALLOC_STD_MATH(log10)
436		BASE_ALLOC_STD_MATH(sin)
437		BASE_ALLOC_STD_MATH(sinh)
438		BASE_ALLOC_STD_MATH(sqrt)
439		BASE_ALLOC_STD_MATH(tan)
440		BASE_ALLOC_STD_MATH(tanh)
441		}
442		</pre></font></code>
443
	390	BASE_ALLOC_STD_MATH(acos)
	391	BASE_ALLOC_STD_MATH(asin)
	392	BASE_ALLOC_STD_MATH(atan)
	393	BASE_ALLOC_STD_MATH(cos)
	394	BASE_ALLOC_STD_MATH(cosh)
	395	BASE_ALLOC_STD_MATH(exp)
	396	BASE_ALLOC_STD_MATH(log)
	397	BASE_ALLOC_STD_MATH(log10)
	398	BASE_ALLOC_STD_MATH(sin)
	399	BASE_ALLOC_STD_MATH(sinh)
	400	BASE_ALLOC_STD_MATH(sqrt)
	401	BASE_ALLOC_STD_MATH(tan)
	402	BASE_ALLOC_STD_MATH(tanh)
	403	}
	404	</pre></font></code>
444	405	The absolute value function is special because its <code><font color="blue">std</font></code> name is
445	406	<code><font color="blue">fabs</font></code>
446	407	<code><font color='blue'><pre style='display:inline'>
447	408	namespace CppAD {
448		inline base_alloc abs(const base_alloc& x)
449		{ return std::fabs(*x.ptrdbl_); }
450		}
451		</pre></font></code>
452
453
454		<br/>
	409	inline base_alloc abs(const base_alloc& x)
	410	{ return std::fabs(*x.ptrdbl_); }
	411	}
	412	</pre></font></code>
455	413	<br/>
456	414	<b><big><a name="erf, asinh, acosh, atanh, expm1, log1p" id="erf, asinh, acosh, atanh, expm1, log1p">erf, asinh, acosh, atanh, expm1, log1p</a></big></b>
457	415	<br/>

461	419	required by <code><font color="blue">AD<base_alloc></font></code>:
462	420	<code><font color='blue'><pre style='display:inline'>
463	421	# if CPPAD_USE_CPLUSPLUS_2011
464		BASE_ALLOC_STD_MATH(erf)
465		BASE_ALLOC_STD_MATH(asinh)
466		BASE_ALLOC_STD_MATH(acosh)
467		BASE_ALLOC_STD_MATH(atanh)
468		BASE_ALLOC_STD_MATH(expm1)
469		BASE_ALLOC_STD_MATH(log1p)
	422	BASE_ALLOC_STD_MATH(erf)
	423	BASE_ALLOC_STD_MATH(asinh)
	424	BASE_ALLOC_STD_MATH(acosh)
	425	BASE_ALLOC_STD_MATH(atanh)
	426	BASE_ALLOC_STD_MATH(expm1)
	427	BASE_ALLOC_STD_MATH(log1p)
470	428	# endif
471	429	</pre></font></code>
472
473
474		<br/>
475	430	<br/>
476	431	<b><big><a name="sign" id="sign">sign</a></big></b>
477	432	<br/>

479	434	is required to use <code><font color="blue">AD<base_alloc></font></code>:
480	435	<code><font color='blue'><pre style='display:inline'>
481	436	namespace CppAD {
482		inline base_alloc sign(const base_alloc& x)
483		{ if( *x.ptrdbl_ > 0.0 )
484		return 1.0;
485		if( *x.ptrdbl_ == 0.0 )
486		return 0.0;
487		return -1.0;
488		}
489		}
490		</pre></font></code>
491
492
493		<br/>
	437	inline base_alloc sign(const base_alloc& x)
	438	{ if( *x.ptrdbl_ > 0.0 )
	439	return 1.0;
	440	if( *x.ptrdbl_ == 0.0 )
	441	return 0.0;
	442	return -1.0;
	443	}
	444	}
	445	</pre></font></code>
494	446	<br/>
495	447	<b><big><a name="pow" id="pow">pow</a></big></b>
496	448	<br/>

498	450	is required to use <code><font color="blue">AD<base_alloc></font></code>:
499	451	<code><font color='blue'><pre style='display:inline'>
500	452	namespace CppAD {
501		inline base_alloc pow(const base_alloc& x, const base_alloc& y)
502		{ return std::pow(x.ptrdbl_, y.ptrdbl_); }
503		}
504		</pre></font></code>
505
506
507		<br/>
	453	inline base_alloc pow(const base_alloc& x, const base_alloc& y)
	454	{ return std::pow(x.ptrdbl_, y.ptrdbl_); }
	455	}
	456	</pre></font></code>
508	457	<br/>
509	458	<b><big><a name="numeric_limits" id="numeric_limits">numeric_limits</a></big></b>
510	459	<br/>

513	462	for the type <code><font color="blue">base_alloc</font></code>:
514	463	<code><font color='blue'><pre style='display:inline'>
515	464	namespace CppAD {
516		CPPAD_NUMERIC_LIMITS(double, base_alloc)
517		}
518		</pre></font></code>
519
520
	465	CPPAD_NUMERIC_LIMITS(double, base_alloc)
	466	}
	467	</pre></font></code>
521	468
522	469	<hr/>Input File: example/base_alloc.hpp
523	470

+91

-130

doc/base_complex.hpp.xml less more

5	5	<title>Enable use of AD<Base> where Base is std::complex<double></title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Enable use of AD<Base> where Base is std::complex<double>"/>
8		<meta name="keywords" id="keywords" content=" enable use of ad<base> where base is std::complex<double> example include order condexpop condexprel equalopseq identical ordered integer azmul isnan valid unary math invalid pow numeric_limits to_string "/>
	8	<meta name="keywords" id="keywords" content=" enable use ad<base> where base is std::complex<double> example include order condexpop condexprel equalopseq identical ordered integer azmul isnan valid unary math invalid pow numeric_limits to_string "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

137	137	# include <cppad/local/cppad_assert.hpp>
138	138
139	139	</pre></font></code>
140
141
142		<br/>
143		<br/>
144	140	<b><big><a name="CondExpOp" id="CondExpOp">CondExpOp</a></big></b>
145	141	<br/>
146	142	The type <code><font color="blue">std::complex<double></font></code> does not supports the

150	146	Hence its <code><font color="blue">CondExpOp</font></code> function is defined by
151	147	<code><font color='blue'><pre style='display:inline'>
152	148	namespace CppAD {
153		inline std::complex<double> CondExpOp(
154		enum CppAD::CompareOp cop ,
155		const std::complex<double> &left ,
156		const std::complex<double> &right ,
157		const std::complex<double> &trueCase ,
158		const std::complex<double> &falseCase )
159		{ CppAD::ErrorHandler::Call(
160		true , __LINE__ , __FILE__ ,
161		"std::complex<float> CondExpOp(...)",
162		"Error: cannot use CondExp with a complex type"
163		);
164		return std::complex<double>(0);
165		}
166		}
167		</pre></font></code>
168
169
170		<br/>
	149	inline std::complex<double> CondExpOp(
	150	enum CppAD::CompareOp cop ,
	151	const std::complex<double> &left ,
	152	const std::complex<double> &right ,
	153	const std::complex<double> &trueCase ,
	154	const std::complex<double> &falseCase )
	155	{ CppAD::ErrorHandler::Call(
	156	true , __LINE__ , __FILE__ ,
	157	"std::complex<float> CondExpOp(...)",
	158	"Error: cannot use CondExp with a complex type"
	159	);
	160	return std::complex<double>(0);
	161	}
	162	}
	163	</pre></font></code>
171	164	<br/>
172	165	<b><big><a name="CondExpRel" id="CondExpRel">CondExpRel</a></big></b>
173	166	<br/>

175	168	macro invocation
176	169	<code><font color='blue'><pre style='display:inline'>
177	170	namespace CppAD {
178		CPPAD_COND_EXP_REL( std::complex<double> )
179		}
180		</pre></font></code>
181
	171	CPPAD_COND_EXP_REL( std::complex<double> )
	172	}
	173	</pre></font></code>
182	174	used <code><font color="blue">CondExpOp</font></code> above to
183	175	define
184	176	<code><font color="blue"><span style='white-space: nowrap'>CondExp</span></font><i><font color="black"><span style='white-space: nowrap'>Rel</span></font></i></code>

196	188	Thus they are equal in this sense if and only if there values are equal.
197	189	<code><font color='blue'><pre style='display:inline'>
198	190	namespace CppAD {
199		inline bool EqualOpSeq(
200		const std::complex<double> &x ,
201		const std::complex<double> &y )
202		{ return x == y;
203		}
204		}
205		</pre></font></code>
206
207
208		<br/>
	191	inline bool EqualOpSeq(
	192	const std::complex<double> &x ,
	193	const std::complex<double> &y )
	194	{ return x == y;
	195	}
	196	}
	197	</pre></font></code>
209	198	<br/>
210	199	<b><big><a name="Identical" id="Identical">Identical</a></big></b>
211	200	<br/>

213	202	Thus they are all parameters so the identical functions just check values.
214	203	<code><font color='blue'><pre style='display:inline'>
215	204	namespace CppAD {
216		inline bool IdenticalPar(const std::complex<double> &x)
217		{ return true; }
218		inline bool IdenticalZero(const std::complex<double> &x)
219		{ return (x == std::complex<double>(0., 0.) ); }
220		inline bool IdenticalOne(const std::complex<double> &x)
221		{ return (x == std::complex<double>(1., 0.) ); }
222		inline bool IdenticalEqualPar(
223		const std::complex<double> &x, const std::complex<double> &y)
224		{ return (x == y); }
225		}
226		</pre></font></code>
227
228
229		<br/>
	205	inline bool IdenticalPar(const std::complex<double> &x)
	206	{ return true; }
	207	inline bool IdenticalZero(const std::complex<double> &x)
	208	{ return (x == std::complex<double>(0., 0.) ); }
	209	inline bool IdenticalOne(const std::complex<double> &x)
	210	{ return (x == std::complex<double>(1., 0.) ); }
	211	inline bool IdenticalEqualPar(
	212	const std::complex<double> &x, const std::complex<double> &y)
	213	{ return (x == y); }
	214	}
	215	</pre></font></code>
230	216	<br/>
231	217	<b><big><a name="Ordered" id="Ordered">Ordered</a></big></b>
232	218	<br/>

243	229	return false; \
244	230	}
245	231	namespace CppAD {
246		CPPAD_USER_MACRO(LessThanZero)
247		CPPAD_USER_MACRO(LessThanOrZero)
248		CPPAD_USER_MACRO(GreaterThanOrZero)
249		CPPAD_USER_MACRO(GreaterThanZero)
250		inline bool abs_geq(
251		const std::complex<double>& x ,
252		const std::complex<double>& y )
253		{ return std::abs(x) >= std::abs(y); }
254		}
255		</pre></font></code>
256
257
258		<br/>
	232	CPPAD_USER_MACRO(LessThanZero)
	233	CPPAD_USER_MACRO(LessThanOrZero)
	234	CPPAD_USER_MACRO(GreaterThanOrZero)
	235	CPPAD_USER_MACRO(GreaterThanZero)
	236	inline bool abs_geq(
	237	const std::complex<double>& x ,
	238	const std::complex<double>& y )
	239	{ return std::abs(x) >= std::abs(y); }
	240	}
	241	</pre></font></code>
259	242	<br/>
260	243	<b><big><a name="Integer" id="Integer">Integer</a></big></b>
261	244	<br/>

265	248	function:
266	249	<code><font color='blue'><pre style='display:inline'>
267	250	namespace CppAD {
268		inline int Integer(const std::complex<double> &x)
269		{ return static_cast<int>( x.real() ); }
270		}
271		</pre></font></code>
272
273
274		<br/>
	251	inline int Integer(const std::complex<double> &x)
	252	{ return static_cast<int>( x.real() ); }
	253	}
	254	</pre></font></code>
275	255	<br/>
276	256	<b><big><a name="azmul" id="azmul">azmul</a></big></b>
277	257
278	258	<code><font color='blue'><pre style='display:inline'>
279	259	namespace CppAD {
280		CPPAD_AZMUL( std::complex<double> )
281		}
282		</pre></font></code>
283
284
285		<br/>
	260	CPPAD_AZMUL( std::complex<double> )
	261	}
	262	</pre></font></code>
286	263	<br/>
287	264	<b><big><a name="isnan" id="isnan">isnan</a></big></b>
288	265	<br/>

299	276	this function in the CppAD namespace.
300	277	<code><font color='blue'><pre style='display:inline'>
301	278	namespace CppAD {
302		inline bool isnan(const std::complex<double>& z)
303		{ return (z != z);
304		}
305		}
306		</pre></font></code>
307
308
309		<br/>
	279	inline bool isnan(const std::complex<double>& z)
	280	{ return (z != z);
	281	}
	282	}
	283	</pre></font></code>
310	284	<br/>
311	285	<b><big><a name="Valid Unary Math" id="Valid Unary Math">Valid Unary Math</a></big></b>
312	286	<br/>

315	289	required to use <code><font color="blue">AD< std::complex<double> ></font></code>.
316	290	<code><font color='blue'><pre style='display:inline'>
317	291	namespace CppAD {
318		CPPAD_STANDARD_MATH_UNARY(std::complex<double>, cos)
319		CPPAD_STANDARD_MATH_UNARY(std::complex<double>, cosh)
320		CPPAD_STANDARD_MATH_UNARY(std::complex<double>, exp)
321		CPPAD_STANDARD_MATH_UNARY(std::complex<double>, log)
322		CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sin)
323		CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sinh)
324		CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sqrt)
325		}
326		</pre></font></code>
327
328
329		<br/>
	292	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, cos)
	293	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, cosh)
	294	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, exp)
	295	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, log)
	296	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sin)
	297	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sinh)
	298	CPPAD_STANDARD_MATH_UNARY(std::complex<double>, sqrt)
	299	}
	300	</pre></font></code>
330	301	<br/>
331	302	<b><big><a name="Invalid Unary Math" id="Invalid Unary Math">Invalid Unary Math</a></big></b>
332	303	<br/>

345	316	return std::complex<double>(0); \
346	317	}
347	318	namespace CppAD {
348		CPPAD_USER_MACRO(abs)
349		CPPAD_USER_MACRO(acos)
350		CPPAD_USER_MACRO(asin)
351		CPPAD_USER_MACRO(atan)
352		CPPAD_USER_MACRO(sign)
	319	CPPAD_USER_MACRO(abs)
	320	CPPAD_USER_MACRO(acos)
	321	CPPAD_USER_MACRO(asin)
	322	CPPAD_USER_MACRO(atan)
	323	CPPAD_USER_MACRO(sign)
353	324	# if CPPAD_USE_CPLUSPLUS_2011
354		CPPAD_USER_MACRO(erf)
355		CPPAD_USER_MACRO(asinh)
356		CPPAD_USER_MACRO(acosh)
357		CPPAD_USER_MACRO(atanh)
358		CPPAD_USER_MACRO(expm1)
359		CPPAD_USER_MACRO(log1p)
	325	CPPAD_USER_MACRO(erf)
	326	CPPAD_USER_MACRO(asinh)
	327	CPPAD_USER_MACRO(acosh)
	328	CPPAD_USER_MACRO(atanh)
	329	CPPAD_USER_MACRO(expm1)
	330	CPPAD_USER_MACRO(log1p)
360	331	# endif
361	332	}
362	333	</pre></font></code>
363
364
365		<br/>
366	334	<br/>
367	335	<b><big><a name="pow" id="pow">pow</a></big></b>
368	336	<br/>

370	338	is required to use <code><font color="blue">AD< std::complex<double> ></font></code>:
371	339	<code><font color='blue'><pre style='display:inline'>
372	340	namespace CppAD {
373		inline std::complex<double> pow(
374		const std::complex<double> &x ,
375		const std::complex<double> &y )
376		{ return std::pow(x, y); }
377		}
378		</pre></font></code>
379
380
381		<br/>
	341	inline std::complex<double> pow(
	342	const std::complex<double> &x ,
	343	const std::complex<double> &y )
	344	{ return std::pow(x, y); }
	345	}
	346	</pre></font></code>
382	347	<br/>
383	348	<b><big><a name="numeric_limits" id="numeric_limits">numeric_limits</a></big></b>
384	349	<br/>

387	352	for the type <code><font color="blue">std::complex<double></font></code>:
388	353	<code><font color='blue'><pre style='display:inline'>
389	354	namespace CppAD {
390		CPPAD_NUMERIC_LIMITS(double, std::complex<double>)
391		}
392		</pre></font></code>
393
394
395		<br/>
	355	CPPAD_NUMERIC_LIMITS(double, std::complex<double>)
	356	}
	357	</pre></font></code>
396	358	<br/>
397	359	<b><big><a name="to_string" id="to_string">to_string</a></big></b>
398	360	<br/>

401	363	for the type <code><font color="blue">std::complex<double></font></code>:
402	364	<code><font color='blue'><pre style='display:inline'>
403	365	namespace CppAD {
404		CPPAD_TO_STRING(std::complex<double>)
405		}
406		</pre></font></code>
407
	366	CPPAD_TO_STRING(std::complex<double>)
	367	}
	368	</pre></font></code>
408	369
409	370	<hr/>Input File: cppad/local/base_complex.hpp
410	371

+10

-13

doc/base_cond_exp.xml less more

5	5	<title>Base Type Requirements for Conditional Expressions</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Base Type Requirements for Conditional Expressions"/>
8		<meta name="keywords" id="keywords" content=" base type requirements for conditional expressions Condexp require Cppad_cond_exp_rel purpose compareop condexptemplate ordered not condexprel "/>
	8	<meta name="keywords" id="keywords" content=" base type requirements conditional expressions Condexp require Cppad_cond_exp_rel purpose compareop condexptemplate ordered not condexprel "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

116	116	The following <code><font color="blue">enum</font></code> type is used in the specifications below:
117	117	<code><font color='blue'><pre style='display:inline'>
118	118	namespace CppAD {
119		// The conditional expression operator enum type
120		enum CompareOp
121		{ CompareLt, // less than
122		CompareLe, // less than or equal
123		CompareEq, // equal
124		CompareGe, // greater than or equal
125		CompareGt, // greater than
126		CompareNe // not equal
127		};
	119	// The conditional expression operator enum type
	120	enum CompareOp
	121	{ CompareLt, // less than
	122	CompareLe, // less than or equal
	123	CompareEq, // equal
	124	CompareGe, // greater than or equal
	125	CompareGt, // greater than
	126	CompareNe // not equal
	127	};
128	128	}
129	129	</pre></font></code>
130
131
132		<br/>
133	130	<br/>
134	131	<b><big><a name="CondExpTemplate" id="CondExpTemplate">CondExpTemplate</a></big></b>
135	132	<br/>

+87

-119

doc/base_double.hpp.xml less more

5	5	<title>Enable use of AD<Base> where Base is double</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Enable use of AD<Base> where Base is double"/>
8		<meta name="keywords" id="keywords" content=" enable use of ad<base> where base is double condexpop condexprel equalopseq identical integer azmul ordered unary standard math sign pow numeric_limits to_string "/>
	8	<meta name="keywords" id="keywords" content=" enable use ad<base> where base is double condexpop condexprel equalopseq identical integer azmul ordered unary standard math sign pow numeric_limits to_string "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

113	113	Hence its <code><font color="blue">CondExpOp</font></code> function is defined by
114	114	<code><font color='blue'><pre style='display:inline'>
115	115	namespace CppAD {
116		inline double CondExpOp(
117		enum CompareOp cop ,
118		const double& left ,
119		const double& right ,
120		const double& exp_if_true ,
121		const double& exp_if_false )
122		{ return CondExpTemplate(cop, left, right, exp_if_true, exp_if_false);
123		}
124		}
125		</pre></font></code>
126
127
128		<br/>
	116	inline double CondExpOp(
	117	enum CompareOp cop ,
	118	const double& left ,
	119	const double& right ,
	120	const double& exp_if_true ,
	121	const double& exp_if_false )
	122	{ return CondExpTemplate(cop, left, right, exp_if_true, exp_if_false);
	123	}
	124	}
	125	</pre></font></code>
129	126	<br/>
130	127	<b><big><a name="CondExpRel" id="CondExpRel">CondExpRel</a></big></b>
131	128	<br/>

133	130	macro invocation
134	131	<code><font color='blue'><pre style='display:inline'>
135	132	namespace CppAD {
136		CPPAD_COND_EXP_REL(double)
137		}
138		</pre></font></code>
139
	133	CPPAD_COND_EXP_REL(double)
	134	}
	135	</pre></font></code>
140	136	uses <code><font color="blue">CondExpOp</font></code> above to
141	137	define
142	138	<code><font color="blue"><span style='white-space: nowrap'>CondExp</span></font><i><font color="black"><span style='white-space: nowrap'>Rel</span></font></i></code>

153	149	The type <code><font color="blue">double</font></code> is simple (in this respect) and so we define
154	150	<code><font color='blue'><pre style='display:inline'>
155	151	namespace CppAD {
156		inline bool EqualOpSeq(const double& x, const double& y)
157		{ return x == y; }
158		}
159		</pre></font></code>
160
161
162		<br/>
	152	inline bool EqualOpSeq(const double& x, const double& y)
	153	{ return x == y; }
	154	}
	155	</pre></font></code>
163	156	<br/>
164	157	<b><big><a name="Identical" id="Identical">Identical</a></big></b>
165	158	<br/>
166	159	The type <code><font color="blue">double</font></code> is simple (in this respect) and so we define
167	160	<code><font color='blue'><pre style='display:inline'>
168	161	namespace CppAD {
169		inline bool IdenticalPar(const double& x)
170		{ return true; }
171		inline bool IdenticalZero(const double& x)
172		{ return (x == 0.); }
173		inline bool IdenticalOne(const double& x)
174		{ return (x == 1.); }
175		inline bool IdenticalEqualPar(const double& x, const double& y)
176		{ return (x == y); }
177		}
178		</pre></font></code>
179
180
181		<br/>
	162	inline bool IdenticalPar(const double& x)
	163	{ return true; }
	164	inline bool IdenticalZero(const double& x)
	165	{ return (x == 0.); }
	166	inline bool IdenticalOne(const double& x)
	167	{ return (x == 1.); }
	168	inline bool IdenticalEqualPar(const double& x, const double& y)
	169	{ return (x == y); }
	170	}
	171	</pre></font></code>
182	172	<br/>
183	173	<b><big><a name="Integer" id="Integer">Integer</a></big></b>
184	174
185	175	<code><font color='blue'><pre style='display:inline'>
186	176	namespace CppAD {
187		inline int Integer(const double& x)
188		{ return static_cast<int>(x); }
189		}
190		</pre></font></code>
191
192
193		<br/>
	177	inline int Integer(const double& x)
	178	{ return static_cast<int>(x); }
	179	}
	180	</pre></font></code>
194	181	<br/>
195	182	<b><big><a name="azmul" id="azmul">azmul</a></big></b>
196	183
197	184	<code><font color='blue'><pre style='display:inline'>
198	185	namespace CppAD {
199		CPPAD_AZMUL( double )
200		}
201		</pre></font></code>
202
203
204		<br/>
	186	CPPAD_AZMUL( double )
	187	}
	188	</pre></font></code>
205	189	<br/>
206	190	<b><big><a name="Ordered" id="Ordered">Ordered</a></big></b>
207	191	<br/>
208	192	The <code><font color="blue">double</font></code> type supports ordered comparisons
209	193	<code><font color='blue'><pre style='display:inline'>
210	194	namespace CppAD {
211		inline bool GreaterThanZero(const double& x)
212		{ return x > 0.; }
213		inline bool GreaterThanOrZero(const double& x)
214		{ return x >= 0.; }
215		inline bool LessThanZero(const double& x)
216		{ return x < 0.; }
217		inline bool LessThanOrZero(const double& x)
218		{ return x <= 0.; }
219		inline bool abs_geq(const double& x, const double& y)
220		{ return std::fabs(x) >= std::fabs(y); }
221		}
222		</pre></font></code>
223
224
225		<br/>
	195	inline bool GreaterThanZero(const double& x)
	196	{ return x > 0.; }
	197	inline bool GreaterThanOrZero(const double& x)
	198	{ return x >= 0.; }
	199	inline bool LessThanZero(const double& x)
	200	{ return x < 0.; }
	201	inline bool LessThanOrZero(const double& x)
	202	{ return x <= 0.; }
	203	inline bool abs_geq(const double& x, const double& y)
	204	{ return std::fabs(x) >= std::fabs(y); }
	205	}
	206	</pre></font></code>
226	207	<br/>
227	208	<b><big><a name="Unary Standard Math" id="Unary Standard Math">Unary Standard Math</a></big></b>
228	209	<br/>

230	211	required to use <code><font color="blue">AD<double></font></code>:
231	212	<code><font color='blue'><pre style='display:inline'>
232	213	namespace CppAD {
233		CPPAD_STANDARD_MATH_UNARY(double, acos)
234		CPPAD_STANDARD_MATH_UNARY(double, asin)
235		CPPAD_STANDARD_MATH_UNARY(double, atan)
236		CPPAD_STANDARD_MATH_UNARY(double, cos)
237		CPPAD_STANDARD_MATH_UNARY(double, cosh)
238		CPPAD_STANDARD_MATH_UNARY(double, exp)
239		CPPAD_STANDARD_MATH_UNARY(double, fabs)
240		CPPAD_STANDARD_MATH_UNARY(double, log)
241		CPPAD_STANDARD_MATH_UNARY(double, log10)
242		CPPAD_STANDARD_MATH_UNARY(double, sin)
243		CPPAD_STANDARD_MATH_UNARY(double, sinh)
244		CPPAD_STANDARD_MATH_UNARY(double, sqrt)
245		CPPAD_STANDARD_MATH_UNARY(double, tan)
246		CPPAD_STANDARD_MATH_UNARY(double, tanh)
	214	CPPAD_STANDARD_MATH_UNARY(double, acos)
	215	CPPAD_STANDARD_MATH_UNARY(double, asin)
	216	CPPAD_STANDARD_MATH_UNARY(double, atan)
	217	CPPAD_STANDARD_MATH_UNARY(double, cos)
	218	CPPAD_STANDARD_MATH_UNARY(double, cosh)
	219	CPPAD_STANDARD_MATH_UNARY(double, exp)
	220	CPPAD_STANDARD_MATH_UNARY(double, fabs)
	221	CPPAD_STANDARD_MATH_UNARY(double, log)
	222	CPPAD_STANDARD_MATH_UNARY(double, log10)
	223	CPPAD_STANDARD_MATH_UNARY(double, sin)
	224	CPPAD_STANDARD_MATH_UNARY(double, sinh)
	225	CPPAD_STANDARD_MATH_UNARY(double, sqrt)
	226	CPPAD_STANDARD_MATH_UNARY(double, tan)
	227	CPPAD_STANDARD_MATH_UNARY(double, tanh)
247	228	# if CPPAD_USE_CPLUSPLUS_2011
248		CPPAD_STANDARD_MATH_UNARY(double, erf)
249		CPPAD_STANDARD_MATH_UNARY(double, asinh)
250		CPPAD_STANDARD_MATH_UNARY(double, acosh)
251		CPPAD_STANDARD_MATH_UNARY(double, atanh)
252		CPPAD_STANDARD_MATH_UNARY(double, expm1)
253		CPPAD_STANDARD_MATH_UNARY(double, log1p)
	229	CPPAD_STANDARD_MATH_UNARY(double, erf)
	230	CPPAD_STANDARD_MATH_UNARY(double, asinh)
	231	CPPAD_STANDARD_MATH_UNARY(double, acosh)
	232	CPPAD_STANDARD_MATH_UNARY(double, atanh)
	233	CPPAD_STANDARD_MATH_UNARY(double, expm1)
	234	CPPAD_STANDARD_MATH_UNARY(double, log1p)
254	235	# endif
255	236	}
256	237	</pre></font></code>
257
258	238	The absolute value function is special because its <code><font color="blue">std</font></code> name is
259	239	<code><font color="blue">fabs</font></code>
260	240	<code><font color='blue'><pre style='display:inline'>
261	241	namespace CppAD {
262		inline double abs(const double& x)
263		{ return std::fabs(x); }
264		}
265		</pre></font></code>
266
267
268		<br/>
	242	inline double abs(const double& x)
	243	{ return std::fabs(x); }
	244	}
	245	</pre></font></code>
269	246	<br/>
270	247	<b><big><a name="sign" id="sign">sign</a></big></b>
271	248	<br/>

273	250	is required to use <code><font color="blue">AD<double></font></code>:
274	251	<code><font color='blue'><pre style='display:inline'>
275	252	namespace CppAD {
276		inline double sign(const double& x)
277		{ if( x > 0. )
278		return 1.;
279		if( x == 0. )
280		return 0.;
281		return -1.;
282		}
283		}
284		</pre></font></code>
285
286
287		<br/>
	253	inline double sign(const double& x)
	254	{ if( x > 0. )
	255	return 1.;
	256	if( x == 0. )
	257	return 0.;
	258	return -1.;
	259	}
	260	}
	261	</pre></font></code>
288	262	<br/>
289	263	<b><big><a name="pow" id="pow">pow</a></big></b>
290	264	<br/>

292	266	is required to use <code><font color="blue">AD<double></font></code>:
293	267	<code><font color='blue'><pre style='display:inline'>
294	268	namespace CppAD {
295		inline double pow(const double& x, const double& y)
296		{ return std::pow(x, y); }
297		}
298		</pre></font></code>
299
300
301		<br/>
	269	inline double pow(const double& x, const double& y)
	270	{ return std::pow(x, y); }
	271	}
	272	</pre></font></code>
302	273	<br/>
303	274	<b><big><a name="numeric_limits" id="numeric_limits">numeric_limits</a></big></b>
304	275	<br/>

307	278	for the type <code><font color="blue">double</font></code>:
308	279	<code><font color='blue'><pre style='display:inline'>
309	280	namespace CppAD {
310		CPPAD_NUMERIC_LIMITS(double, double)
311		}
312		</pre></font></code>
313
314
315		<br/>
	281	CPPAD_NUMERIC_LIMITS(double, double)
	282	}
	283	</pre></font></code>
316	284	<br/>
317	285	<b><big><a name="to_string" id="to_string">to_string</a></big></b>
318	286	<br/>

+0

-2

doc/base_example.xml less more

101	101	</select>
102	102	</td>
103	103	</tr></table><br/>
104
105
106	104	<center><b><big><big>Example AD Base Types That are not AD<OtherBase></big></big></b></center>
107	105	<br/>
108	106	<b><big><a name="Contents" id="Contents">Contents</a></big></b>

+87

-119

doc/base_float.hpp.xml less more

5	5	<title>Enable use of AD<Base> where Base is float</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Enable use of AD<Base> where Base is float"/>
8		<meta name="keywords" id="keywords" content=" enable use of ad<base> where base is float condexpop condexprel equalopseq identical integer azmul ordered unary standard math sign pow numeric_limits to_string "/>
	8	<meta name="keywords" id="keywords" content=" enable use ad<base> where base is float condexpop condexprel equalopseq identical integer azmul ordered unary standard math sign pow numeric_limits to_string "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

113	113	Hence its <code><font color="blue">CondExpOp</font></code> function is defined by
114	114	<code><font color='blue'><pre style='display:inline'>
115	115	namespace CppAD {
116		inline float CondExpOp(
117		enum CompareOp cop ,
118		const float& left ,
119		const float& right ,
120		const float& exp_if_true ,
121		const float& exp_if_false )
122		{ return CondExpTemplate(cop, left, right, exp_if_true, exp_if_false);
123		}
124		}
125		</pre></font></code>
126
127
128		<br/>
	116	inline float CondExpOp(
	117	enum CompareOp cop ,
	118	const float& left ,
	119	const float& right ,
	120	const float& exp_if_true ,
	121	const float& exp_if_false )
	122	{ return CondExpTemplate(cop, left, right, exp_if_true, exp_if_false);
	123	}
	124	}
	125	</pre></font></code>
129	126	<br/>
130	127	<b><big><a name="CondExpRel" id="CondExpRel">CondExpRel</a></big></b>
131	128	<br/>

133	130	macro invocation
134	131	<code><font color='blue'><pre style='display:inline'>
135	132	namespace CppAD {
136		CPPAD_COND_EXP_REL(float)
137		}
138		</pre></font></code>
139
	133	CPPAD_COND_EXP_REL(float)
	134	}
	135	</pre></font></code>
140	136	uses <code><font color="blue">CondExpOp</font></code> above to
141	137	define
142	138	<code><font color="blue"><span style='white-space: nowrap'>CondExp</span></font><i><font color="black"><span style='white-space: nowrap'>Rel</span></font></i></code>

153	149	The type <code><font color="blue">float</font></code> is simple (in this respect) and so we define
154	150	<code><font color='blue'><pre style='display:inline'>
155	151	namespace CppAD {
156		inline bool EqualOpSeq(const float& x, const float& y)
157		{ return x == y; }
158		}
159		</pre></font></code>
160
161
162		<br/>
	152	inline bool EqualOpSeq(const float& x, const float& y)
	153	{ return x == y; }
	154	}
	155	</pre></font></code>
163	156	<br/>
164	157	<b><big><a name="Identical" id="Identical">Identical</a></big></b>
165	158	<br/>
166	159	The type <code><font color="blue">float</font></code> is simple (in this respect) and so we define
167	160	<code><font color='blue'><pre style='display:inline'>
168	161	namespace CppAD {
169		inline bool IdenticalPar(const float& x)
170		{ return true; }
171		inline bool IdenticalZero(const float& x)
172		{ return (x == 0.f); }
173		inline bool IdenticalOne(const float& x)
174		{ return (x == 1.f); }
175		inline bool IdenticalEqualPar(const float& x, const float& y)
176		{ return (x == y); }
177		}
178		</pre></font></code>
179
180
181		<br/>
	162	inline bool IdenticalPar(const float& x)
	163	{ return true; }
	164	inline bool IdenticalZero(const float& x)
	165	{ return (x == 0.f); }
	166	inline bool IdenticalOne(const float& x)
	167	{ return (x == 1.f); }
	168	inline bool IdenticalEqualPar(const float& x, const float& y)
	169	{ return (x == y); }
	170	}
	171	</pre></font></code>
182	172	<br/>
183	173	<b><big><a name="Integer" id="Integer">Integer</a></big></b>
184	174
185	175	<code><font color='blue'><pre style='display:inline'>
186	176	namespace CppAD {
187		inline int Integer(const float& x)
188		{ return static_cast<int>(x); }
189		}
190		</pre></font></code>
191
192
193		<br/>
	177	inline int Integer(const float& x)
	178	{ return static_cast<int>(x); }
	179	}
	180	</pre></font></code>
194	181	<br/>
195	182	<b><big><a name="azmul" id="azmul">azmul</a></big></b>
196	183
197	184	<code><font color='blue'><pre style='display:inline'>
198	185	namespace CppAD {
199		CPPAD_AZMUL( float )
200		}
201		</pre></font></code>
202
203
204		<br/>
	186	CPPAD_AZMUL( float )
	187	}
	188	</pre></font></code>
205	189	<br/>
206	190	<b><big><a name="Ordered" id="Ordered">Ordered</a></big></b>
207	191	<br/>
208	192	The <code><font color="blue">float</font></code> type supports ordered comparisons
209	193	<code><font color='blue'><pre style='display:inline'>
210	194	namespace CppAD {
211		inline bool GreaterThanZero(const float& x)
212		{ return x > 0.f; }
213		inline bool GreaterThanOrZero(const float& x)
214		{ return x >= 0.f; }
215		inline bool LessThanZero(const float& x)
216		{ return x < 0.f; }
217		inline bool LessThanOrZero(const float& x)
218		{ return x <= 0.f; }
219		inline bool abs_geq(const float& x, const float& y)
220		{ return std::fabs(x) >= std::fabs(y); }
221		}
222		</pre></font></code>
223
224
225		<br/>
	195	inline bool GreaterThanZero(const float& x)
	196	{ return x > 0.f; }
	197	inline bool GreaterThanOrZero(const float& x)
	198	{ return x >= 0.f; }
	199	inline bool LessThanZero(const float& x)
	200	{ return x < 0.f; }
	201	inline bool LessThanOrZero(const float& x)
	202	{ return x <= 0.f; }
	203	inline bool abs_geq(const float& x, const float& y)
	204	{ return std::fabs(x) >= std::fabs(y); }
	205	}
	206	</pre></font></code>
226	207	<br/>
227	208	<b><big><a name="Unary Standard Math" id="Unary Standard Math">Unary Standard Math</a></big></b>
228	209	<br/>

231	212	(in the CppAD namespace)
232	213	<code><font color='blue'><pre style='display:inline'>
233	214	namespace CppAD {
234		CPPAD_STANDARD_MATH_UNARY(float, acos)
235		CPPAD_STANDARD_MATH_UNARY(float, asin)
236		CPPAD_STANDARD_MATH_UNARY(float, atan)
237		CPPAD_STANDARD_MATH_UNARY(float, cos)
238		CPPAD_STANDARD_MATH_UNARY(float, cosh)
239		CPPAD_STANDARD_MATH_UNARY(float, exp)
240		CPPAD_STANDARD_MATH_UNARY(float, fabs)
241		CPPAD_STANDARD_MATH_UNARY(float, log)
242		CPPAD_STANDARD_MATH_UNARY(float, log10)
243		CPPAD_STANDARD_MATH_UNARY(float, sin)
244		CPPAD_STANDARD_MATH_UNARY(float, sinh)
245		CPPAD_STANDARD_MATH_UNARY(float, sqrt)
246		CPPAD_STANDARD_MATH_UNARY(float, tan)
247		CPPAD_STANDARD_MATH_UNARY(float, tanh)
	215	CPPAD_STANDARD_MATH_UNARY(float, acos)
	216	CPPAD_STANDARD_MATH_UNARY(float, asin)
	217	CPPAD_STANDARD_MATH_UNARY(float, atan)
	218	CPPAD_STANDARD_MATH_UNARY(float, cos)
	219	CPPAD_STANDARD_MATH_UNARY(float, cosh)
	220	CPPAD_STANDARD_MATH_UNARY(float, exp)
	221	CPPAD_STANDARD_MATH_UNARY(float, fabs)
	222	CPPAD_STANDARD_MATH_UNARY(float, log)
	223	CPPAD_STANDARD_MATH_UNARY(float, log10)
	224	CPPAD_STANDARD_MATH_UNARY(float, sin)
	225	CPPAD_STANDARD_MATH_UNARY(float, sinh)
	226	CPPAD_STANDARD_MATH_UNARY(float, sqrt)
	227	CPPAD_STANDARD_MATH_UNARY(float, tan)
	228	CPPAD_STANDARD_MATH_UNARY(float, tanh)
248	229	# if CPPAD_USE_CPLUSPLUS_2011
249		CPPAD_STANDARD_MATH_UNARY(float, erf)
250		CPPAD_STANDARD_MATH_UNARY(float, asinh)
251		CPPAD_STANDARD_MATH_UNARY(float, acosh)
252		CPPAD_STANDARD_MATH_UNARY(float, atanh)
253		CPPAD_STANDARD_MATH_UNARY(float, expm1)
254		CPPAD_STANDARD_MATH_UNARY(float, log1p)
	230	CPPAD_STANDARD_MATH_UNARY(float, erf)
	231	CPPAD_STANDARD_MATH_UNARY(float, asinh)
	232	CPPAD_STANDARD_MATH_UNARY(float, acosh)
	233	CPPAD_STANDARD_MATH_UNARY(float, atanh)
	234	CPPAD_STANDARD_MATH_UNARY(float, expm1)
	235	CPPAD_STANDARD_MATH_UNARY(float, log1p)
255	236	# endif
256	237	}
257	238	</pre></font></code>
258
259	239	The absolute value function is special because its <code><font color="blue">std</font></code> name is
260	240	<code><font color="blue">fabs</font></code>
261	241	<code><font color='blue'><pre style='display:inline'>
262	242	namespace CppAD {
263		inline float abs(const float& x)
264		{ return std::fabs(x); }
265		}
266		</pre></font></code>
267
268
269		<br/>
	243	inline float abs(const float& x)
	244	{ return std::fabs(x); }
	245	}
	246	</pre></font></code>
270	247	<br/>
271	248	<b><big><a name="sign" id="sign">sign</a></big></b>
272	249	<br/>

274	251	is required to use <code><font color="blue">AD<float></font></code>:
275	252	<code><font color='blue'><pre style='display:inline'>
276	253	namespace CppAD {
277		inline float sign(const float& x)
278		{ if( x > 0.f )
279		return 1.f;
280		if( x == 0.f )
281		return 0.f;
282		return -1.f;
283		}
284		}
285		</pre></font></code>
286
287
288		<br/>
	254	inline float sign(const float& x)
	255	{ if( x > 0.f )
	256	return 1.f;
	257	if( x == 0.f )
	258	return 0.f;
	259	return -1.f;
	260	}
	261	}
	262	</pre></font></code>
289	263	<br/>
290	264	<b><big><a name="pow" id="pow">pow</a></big></b>
291	265	<br/>

293	267	is required to use <code><font color="blue">AD<float></font></code>:
294	268	<code><font color='blue'><pre style='display:inline'>
295	269	namespace CppAD {
296		inline float pow(const float& x, const float& y)
297		{ return std::pow(x, y); }
298		}
299		</pre></font></code>
300
301
302		<br/>
	270	inline float pow(const float& x, const float& y)
	271	{ return std::pow(x, y); }
	272	}
	273	</pre></font></code>
303	274	<br/>
304	275	<b><big><a name="numeric_limits" id="numeric_limits">numeric_limits</a></big></b>
305	276	<br/>

308	279	for the type <code><font color="blue">float</font></code>:
309	280	<code><font color='blue'><pre style='display:inline'>
310	281	namespace CppAD {
311		CPPAD_NUMERIC_LIMITS(float, float)
312		}
313		</pre></font></code>
314
315
316		<br/>
	282	CPPAD_NUMERIC_LIMITS(float, float)
	283	}
	284	</pre></font></code>
317	285	<br/>
318	286	<b><big><a name="to_string" id="to_string">to_string</a></big></b>
319	287	<br/>

+1

-1

doc/base_identical.xml less more

5	5	<title>Base Type Requirements for Identically Equal Comparisons</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Base Type Requirements for Identically Equal Comparisons"/>
8		<meta name="keywords" id="keywords" content=" base type requirements for identically equal comparisons require equalopseq the simple case more complicated cases identical identicalpar prototypes functions examples "/>
	8	<meta name="keywords" id="keywords" content=" base type requirements identically equal comparisons require equalopseq the simple case more complicated cases identical identicalpar prototypes functions examples "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+10

-11

doc/base_limits.xml less more

5	5	<title>Base Type Requirements for Numeric Limits</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Base Type Requirements for Numeric Limits"/>
8		<meta name="keywords" id="keywords" content=" base type requirements for numeric limits cppad::numeric_limits cppad_numeric_limits "/>
	8	<meta name="keywords" id="keywords" content=" base type requirements numeric limits cppad::numeric_limits cppad_numeric_limits "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

146	146	# define CPPAD_NUMERIC_LIMITS(Other, Base) \
147	147	template <> class numeric_limits<Base>\
148	148	{\
149		public:\
150		static Base min(void) \
151		{ return static_cast<Base>( std::numeric_limits<Other>::min() ); }\
152		static Base max(void) \
153		{ return static_cast<Base>( std::numeric_limits<Other>::max() ); }\
154		static Base epsilon(void) \
155		{ return static_cast<Base>( std::numeric_limits<Other>::epsilon() ); }\
156		static Base quiet_NaN(void) \
157		{ return static_cast<Base>( std::numeric_limits<Other>::quiet_NaN() ); }\
	149	public:\
	150	static Base min(void) \
	151	{ return static_cast<Base>( std::numeric_limits<Other>::min() ); }\
	152	static Base max(void) \
	153	{ return static_cast<Base>( std::numeric_limits<Other>::max() ); }\
	154	static Base epsilon(void) \
	155	{ return static_cast<Base>( std::numeric_limits<Other>::epsilon() ); }\
	156	static Base quiet_NaN(void) \
	157	{ return static_cast<Base>( std::numeric_limits<Other>::quiet_NaN() ); }\
158	158	};
159	159	</pre></font></code>
160
161	160
162	161	<hr/>Input File: cppad/local/base_limits.hpp
163	162

+1

-1

doc/base_ordered.xml less more

5	5	<title>Base Type Requirements for Ordered Comparisons</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Base Type Requirements for Ordered Comparisons"/>
8		<meta name="keywords" id="keywords" content=" base type requirements for ordered comparisons purpose not "/>
	8	<meta name="keywords" id="keywords" content=" base type requirements ordered comparisons purpose not "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-4

doc/base_require.cpp.xml less more

5	5	<title>Using a User Defined AD Base Type: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using a User Defined AD Base Type: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" using a user defined ad base type: example and test type purpose "/>
	8	<meta name="keywords" id="keywords" content=" using user defined ad base type: example test type purpose "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

87	87	</select>
88	88	</td>
89	89	</tr></table><br/>
90
91
92
93	90	<center><b><big><big>Using a User Defined AD Base Type: Example and Test</big></big></b></center>
94	91	<code><font color="blue"><pre style='display:inline'>
95	92	# include "base_alloc.hpp"

+1

-4

doc/base_require.xml less more

5	5	<title>AD<Base> Requirements for a CppAD Base Type</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD<Base> Requirements for a CppAD Base Type"/>
8		<meta name="keywords" id="keywords" content=" ad<base> requirements for a cppad base type syntax purpose api warning standard types include order numeric output operator integer suggestion absolute zero azmul "/>
	8	<meta name="keywords" id="keywords" content=" ad<base> requirements cppad base type syntax purpose api warning standard types include order numeric output operator integer suggestion absolute zero azmul "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

271	271	return x * y; \
272	272	}
273	273	</pre></font></code>
274
275
276		<br/>
277	274	<br/>
278	275	<b><big><a name="Contents" id="Contents">Contents</a></big></b>
279	276	<br/>

+1

-1

doc/base_std_math.xml less more

5	5	<title>Base Type Requirements for Standard Math Functions</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Base Type Requirements for Standard Math Functions"/>
8		<meta name="keywords" id="keywords" content=" base type requirements for standard math functions purpose unary cppad_standard_math_unary erf asinh acosh atanh expm1 log1p sign pow isnan "/>
	8	<meta name="keywords" id="keywords" content=" base type requirements standard math functions purpose unary cppad_standard_math_unary erf asinh acosh atanh expm1 log1p sign pow isnan "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+9

-13

doc/base_to_string.xml less more

92	92	</select>
93	93	</td>
94	94	</tr></table><br/>
95
96
97
98	95	<center><b><big><big>Extending to_string To Another Floating Point Type</big></big></b></center>
99	96	<br/>
100	97	<b><big><a name="Base Requirement" id="Base Requirement">Base Requirement</a></big></b>

129	126	<code><font color='blue'><pre style='display:inline'>
130	127	# define CPPAD_TO_STRING(Base) \
131	128	template <> struct to_string_struct<Base>\
132		{ std::string operator()(const Base& value) \
133		{ std::stringstream os;\
134		Base epsilon = CppAD::numeric_limits<Base>::epsilon();\
135		Base log10 = CppAD::log( epsilon ) / CppAD::log(Base(10.));\
136		size_t n_digits = 1 - Integer( log10 );\
137		os << std::setprecision(n_digits);\
138		os << value;\
139		return os.str();\
140		}\
	129	{ std::string operator()(const Base& value) \
	130	{ std::stringstream os;\
	131	Base epsilon = CppAD::numeric_limits<Base>::epsilon();\
	132	Base log10 = CppAD::log( epsilon ) / CppAD::log(Base(10.));\
	133	size_t n_digits = 1 - Integer( log10 );\
	134	os << std::setprecision(n_digits);\
	135	os << value;\
	136	return os.str();\
	137	}\
141	138	};
142	139	</pre></font></code>
143
144	140
145	141	<hr/>Input File: cppad/local/base_to_string.hpp
146	142

+1

-1

doc/bender_quad.cpp.xml less more

5	5	<title>BenderQuad: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="BenderQuad: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" benderquad: example and test Benderquad "/>
	8	<meta name="keywords" id="keywords" content=" benderquad: example test Benderquad "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/benderquad.xml less more

5	5	<title>Computing Jacobian and Hessian of Bender's Reduced Objective</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Computing Jacobian and Hessian of Bender's Reduced Objective"/>
8		<meta name="keywords" id="keywords" content=" computing jacobian and hessian of bender's reduced objective Benderquad syntax see also problem purpose x y fun fun.f fun.h fun.dy g gx gxx bavector advector example "/>
	8	<meta name="keywords" id="keywords" content=" computing jacobian hessian bender's reduced objective Benderquad syntax see also problem purpose x y fun fun.f fun.h fun.dy g gx gxx bavector advector example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+3

-3

doc/bib.xml less more

5	5	<title>Bibliography</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Bibliography"/>
8		<meta name="keywords" id="keywords" content=" bibliography abramowitz and stegun the c++ programming language evaluating derivatives numerical recipes shampine l.f. "/>
	8	<meta name="keywords" id="keywords" content=" bibliography abramowitz stegun the c++ programming language evaluating derivatives numerical recipes shampine l.f. "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

110	110	<br/>
111	111	Evaluating Derivatives: Principles and Techniques of
112	112	Algorithmic Differentiation,
113		Andreas Griewank,
114		SIAM,
	113	Andreas Griewank,
	114	SIAM,
115	115	Philadelphia,
116	116	2000
117	117

+1

-1

doc/bool_fun.cpp.xml less more

5	5	<title>AD Boolean Functions: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Boolean Functions: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad boolean functions: example and test bool "/>
	8	<meta name="keywords" id="keywords" content=" ad boolean functions: example test bool "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/bool_sparsity.cpp.xml less more

5	5	<title>Using vectorBool Sparsity To Conserve Memory: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using vectorBool Sparsity To Conserve Memory: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" using vectorbool sparsity to conserve memory: example and test purpose "/>
	8	<meta name="keywords" id="keywords" content=" using vectorbool sparsity to conserve memory: example test purpose "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-5

doc/boolvalued.xml less more

5	5	<title>Bool Valued Operations and Functions with AD Arguments</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Bool Valued Operations and Functions with AD Arguments"/>
8		<meta name="keywords" id="keywords" content=" bool valued operations and functions with ad arguments "/>
	8	<meta name="keywords" id="keywords" content=" bool valued operations functions with ad arguments "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

81	81	</td>
82	82	<td>Headings</td>
83	83	</tr></table><br/>
84
85
86
87
88	84	<center><b><big><big>Bool Valued Operations and Functions with AD Arguments</big></big></b></center>
89	85	<table><tr><td align='left' valign='top'>
90	86	<a href="compare.xml" target="_top">Compare</a></td><td>

+1

-1

doc/capacity_order.cpp.xml less more

5	5	<title>Controlling Taylor Coefficient Memory Allocation: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	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 "/>
	8	<meta name="keywords" id="keywords" content=" controlling taylor coefficient memory allocation: example test capacity_order "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/change_param.cpp.xml less more

5	5	<title>Computing a Jacobian With Constants that Change</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Computing a Jacobian With Constants that Change"/>
8		<meta name="keywords" id="keywords" content=" computing a jacobian with constants that change multiple Ad level purpose "/>
	8	<meta name="keywords" id="keywords" content=" computing jacobian with constants that change multiple Ad level purpose "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/check_for_nan.cpp.xml less more

5	5	<title>ADFun Checking For Nan: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="ADFun Checking For Nan: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" adfun checking for nan: example and test "/>
	8	<meta name="keywords" id="keywords" content=" adfun checking nan: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/check_for_nan.xml less more

5	5	<title>Check an ADFun Object For Nan Results</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Check an ADFun Object For Nan Results"/>
8		<meta name="keywords" id="keywords" content=" check an adfun object for nan results syntax debugging f b default error message vector_size file_name index get_check_for_nan vec file example "/>
	8	<meta name="keywords" id="keywords" content=" check adfun object nan results syntax debugging f b default error message vector_size file_name index get_check_for_nan vec file example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/check_numeric_type.cpp.xml less more

5	5	<title>The CheckNumericType Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The CheckNumericType Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the checknumerictype function: example and test check Numerictype "/>
	8	<meta name="keywords" id="keywords" content=" the checknumerictype function: example test check Numerictype "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/check_simple_vector.cpp.xml less more

5	5	<title>The CheckSimpleVector Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The CheckSimpleVector Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the checksimplevector function: example and test check Simplevector "/>
	8	<meta name="keywords" id="keywords" content=" the checksimplevector function: example test check Simplevector "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/checkpoint.cpp.xml less more

5	5	<title>Simple Checkpointing: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Simple Checkpointing: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" simple checkpointing: example and test purpose "/>
	8	<meta name="keywords" id="keywords" content=" simple checkpointing: example test purpose "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+2

-4

doc/cmake.xml less more

5	5	<title>Using CMake to Configure CppAD</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using CMake to Configure CppAD"/>
8		<meta name="keywords" id="keywords" content=" using cmake to configure cppad makefile install prefix postfix include directories lib datadir documentation package compile flags profile maximum number threads sparsity internal structure vector sets memory usage tape ctor implicit explicit the program command build directory cmake_verbose_makefile generator cppad_prefix cppad_postfix cmake_install_includedirs cmake_install_libdirs cmake_install_datadir cmake_install_docdir package_prefix cppad_cxx_flags c++11 cppad_profile_flag eigen and fadbad cppad_testvector cppad_max_num_threads cppad_sparse_list cppad_tape_id_type cstdint cppad_tape_addr_type cppad_deprecated "/>
	8	<meta name="keywords" id="keywords" content=" using cmake to configure cppad makefile install prefix postfix include directories lib datadir documentation package compile flags profile maximum number threads sparsity internal structure vector sets memory usage tape ctor implicit explicit the program command build directory cmake_verbose_makefile generator cppad_prefix cppad_postfix cmake_install_includedirs cmake_install_libdirs cmake_install_datadir cmake_install_docdir package_prefix cppad_cxx_flags c++11 cppad_profile_flag eigen fadbad cppad_testvector cppad_max_num_threads cppad_sparse_list cppad_tape_id_type cstdint cppad_tape_addr_type cppad_deprecated "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

425	425	on your system.
426	426	For example, if you are using <code><font color="blue">g++</font></code> you could specify
427	427	<code><font color='blue'><pre style='display:inline'>
428		-D cppad_cxx_flags="-Wall -ansi -pedantic-errors -std=c++11 -Wshadow"
	428	-D cppad_cxx_flags="-Wall -ansi -pedantic-errors -std=c++11 -Wshadow"
429	429	</pre></font></code>
430
431		<br/>
432	430	<br/>
433	431	<b><a name="cppad_cxx_flags.C++11" id="cppad_cxx_flags.C++11">C++11</a></b>
434	432	<br/>

+2

-3

doc/cmake_check.xml less more

5	5	<title>Checking the CppAD Examples and Tests</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	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 windows subsets "/>
	8	<meta name="keywords" id="keywords" content=" checking the cppad examples tests purpose check all windows subsets "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

101	101
102	102	execute the command
103	103	<code><font color='blue'><pre style='display:inline'>
104		make check
	104	make check
105	105	</pre></font></code>
106
107	106	This will build and run all of the tests that are support
108	107	by your system and the <a href="cmake.xml" target="_top"><span style='white-space: nowrap'>cmake</span></a>
109	108	command options.

+1

-1

doc/colpack_hes.cpp.xml less more

5	5	<title>Using ColPack: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	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 hessian sparse "/>
	8	<meta name="keywords" id="keywords" content=" using colpack: example test colpack hessian sparse "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/colpack_jac.cpp.xml less more

5	5	<title>Using ColPack: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	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 jacobian sparse "/>
	8	<meta name="keywords" id="keywords" content=" using colpack: example test colpack jacobian sparse "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/compare.cpp.xml less more

5	5	<title>AD Binary Comparison Operators: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Binary Comparison Operators: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad binary comparison operators: example and test compare < <= > >= == != "/>
	8	<meta name="keywords" id="keywords" content=" ad binary comparison operators: example test compare < <= > >= == != "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/compare_c.xml less more

5	5	<title>Compare Speed of C and C++</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Compare Speed of C and C++"/>
8		<meta name="keywords" id="keywords" content=" compare speed of c and c++ C C++ with syntax purpose "/>
	8	<meta name="keywords" id="keywords" content=" compare speed c c++ C and C++ with syntax purpose "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/compare_change.cpp.xml less more

5	5	<title>CompareChange and Re-Tape: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CompareChange and Re-Tape: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" comparechange and re-tape: example test compare change re-tape "/>
	8	<meta name="keywords" id="keywords" content=" comparechange re-tape: example test compare change re-tape "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/compare_change.xml less more

5	5	<title>Comparison Changes Between Taping and Zero Order Forward</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Comparison Changes Between Taping and Zero Order Forward"/>
8		<meta name="keywords" id="keywords" content=" comparison changes between taping and zero order forward Adfun compare_change syntax purpose f count speed number discussion op_index example "/>
	8	<meta name="keywords" id="keywords" content=" comparison changes between taping zero order forward Adfun compare_change syntax purpose f count speed number discussion op_index example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-4

doc/complex_poly.cpp.xml less more

5	5	<title>Complex Polynomial: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Complex Polynomial: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" complex polynomial: example and test polynomial poly "/>
	8	<meta name="keywords" id="keywords" content=" complex polynomial: example test polynomial poly "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

82	82	</select>
83	83	</td>
84	84	</tr></table><br/>
85
86
87
88	85	<center><b><big><big>Complex Polynomial: Example and Test</big></big></b></center>
89	86	<br/>
90	87	<b><big><a name="Poly" id="Poly">Poly</a></big></b>

+1

-1

doc/cond_exp.cpp.xml less more

5	5	<title>Conditional Expressions: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Conditional Expressions: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" conditional expressions: example and test Condexp description "/>
	8	<meta name="keywords" id="keywords" content=" conditional expressions: example test Condexp description "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/conj_grad.cpp.xml less more

5	5	<title>Differentiate Conjugate Gradient Algorithm: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Differentiate Conjugate Gradient Algorithm: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" differentiate conjugate gradient algorithm: example and test purpose algorithm "/>
	8	<meta name="keywords" id="keywords" content=" differentiate conjugate gradient algorithm: example test purpose algorithm "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/convert.xml less more

5	5	<title>Conversion and I/O of AD Objects</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Conversion and I/O of AD Objects"/>
8		<meta name="keywords" id="keywords" content=" conversion and i/o of ad objects convert from "/>
	8	<meta name="keywords" id="keywords" content=" conversion i/o ad objects convert from "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+15

-19

doc/correct_det_by_minor_c.xml less more

5	5	<title>Correctness Test of det_by_minor Routine</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Correctness Test of det_by_minor Routine"/>
8		<meta name="keywords" id="keywords" content=" correctness test of det_by_minor routine syntax flag source code "/>
	8	<meta name="keywords" id="keywords" content=" correctness test det_by_minor routine syntax flag source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

97	97	</select>
98	98	</td>
99	99	</tr></table><br/>
100
101
102
103	100	<center><b><big><big>Correctness Test of det_by_minor Routine</big></big></b></center>
104	101	<br/>
105	102	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

129	126
130	127	<code><font color='blue'><pre style='display:inline'>
131	128	bool correct_det_by_minor(void)
132		{ double a[9], det, check;
	129	{ double a[9], det, check;
133	130
134		<a href="uniform_01_c.xml" target="_top">random_seed</a>(123);
135		<a href="uniform_01_c.xml" target="_top">uniform_01</a>(9, a);
	131	<a href="uniform_01_c.xml" target="_top">random_seed</a>(123);
	132	<a href="uniform_01_c.xml" target="_top">uniform_01</a>(9, a);
136	133
137		/* compute determinant using expansion by minors */
138		det = det_by_minor(a, 3);
139
140		/* use expansion by minors to hand code the determinant */
141		check = 0.;
142		check += a[0] * ( a[4] * a[8] - a[5] * a[7] );
143		check -= a[1] * ( a[3] * a[8] - a[5] * a[6] );
144		check += a[2] * ( a[3] * a[7] - a[4] * a[6] );
	134	/* compute determinant using expansion by minors */
	135	det = det_by_minor(a, 3);
	136
	137	/* use expansion by minors to hand code the determinant */
	138	check = 0.;
	139	check += a[0] * ( a[4] * a[8] - a[5] * a[7] );
	140	check -= a[1] * ( a[3] * a[8] - a[5] * a[6] );
	141	check += a[2] * ( a[3] * a[7] - a[4] * a[6] );
145	142
146		if( fabs(det / check - 1.0) < 1e-10 )
147		return true;
148		return false;
	143	if( fabs(det / check - 1.0) < 1e-10 )
	144	return true;
	145	return false;
149	146	}
150	147	</pre></font></code>
151
152	148
153	149	<hr/>Input File: compare_c/det_by_minor.c
154	150

+1

-1

doc/cos.cpp.xml less more

5	5	<title>The AD cos Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD cos Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad cos function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad cos function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/cosh.cpp.xml less more

5	5	<title>The AD cosh Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD cosh Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad cosh function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad cosh function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+4

-4

doc/cppad.xml less more

2	2	xmlns:math='http://www.w3.org/1998/Math/MathML'
3	3	>
4	4	<head>
5		<title>cppad-20160000.0: A Package for Differentiation of C++ Algorithms</title>
	5	<title>cppad-20160000.1: A Package for Differentiation of C++ Algorithms</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7		<meta name="description" id="description" content="cppad-20160000.0: A Package for Differentiation of C++ Algorithms"/>
8		<meta name="keywords" id="keywords" content=" cppad-20160000.0: a package for differentiation of c++ algorithms Ad algorithmic automatic C++ algorithm derivative Cppad version cppad.hpp syntax introduction example include file preprocessor symbols namespace "/>
	7	<meta name="description" id="description" content="cppad-20160000.1: A Package for Differentiation of C++ Algorithms"/>
	8	<meta name="keywords" id="keywords" content=" cppad-20160000.1: package differentiation c++ algorithms Ad algorithmic automatic C++ algorithm derivative Cppad version cppad.hpp syntax introduction example include file preprocessor symbols namespace "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

70	70	,
71	71
72	72
73		<center><b><big><big>cppad-20160000.0: A Package for Differentiation of C++ Algorithms</big></big></b></center>
	73	<center><b><big><big>cppad-20160000.1: A Package for Differentiation of C++ Algorithms</big></big></b></center>
74	74	<br/>
75	75	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>
76	76

+44

-48

doc/cppad_det_lu.cpp.xml less more

5	5	<title>CppAD Speed: Gradient of Determinant Using Lu Factorization</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD Speed: Gradient of Determinant Using Lu Factorization"/>
8		<meta name="keywords" id="keywords" content=" cppad speed: gradient of determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: gradient determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>CppAD Speed: Gradient of Determinant Using Lu Factorization</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

112	109
113	110	// Note that CppAD uses global_memory at the main program level
114	111	extern bool
115		global_onetape, global_atomic, global_optimize;
	112	global_onetape, global_atomic, global_optimize;
116	113
117	114	bool link_det_lu(
118		size_t size ,
119		size_t repeat ,
120		CppAD::vector<double> &matrix ,
121		CppAD::vector<double> &gradient )
	115	size_t size ,
	116	size_t repeat ,
	117	CppAD::vector<double> &matrix ,
	118	CppAD::vector<double> &gradient )
122	119	{
123		// speed test global option values
124		if( global_onetape \|\| global_atomic )
125		return false;
	120	// speed test global option values
	121	if( global_onetape \|\| global_atomic )
	122	return false;
126	123
127		// -----------------------------------------------------
128		// setup
129		typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
130		typedef CppAD::vector<ADScalar> ADVector;
131		CppAD::det_by_lu<ADScalar> Det(size);
	124	// -----------------------------------------------------
	125	// setup
	126	typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
	127	typedef CppAD::vector<ADScalar> ADVector;
	128	CppAD::det_by_lu<ADScalar> Det(size);
132	129
133		size_t i; // temporary index
134		size_t m = 1; // number of dependent variables
135		size_t n = size * size; // number of independent variables
136		ADVector A(n); // AD domain space vector
137		ADVector detA(m); // AD range space vector
138		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function object
	130	size_t i; // temporary index
	131	size_t m = 1; // number of dependent variables
	132	size_t n = size * size; // number of independent variables
	133	ADVector A(n); // AD domain space vector
	134	ADVector detA(m); // AD range space vector
	135	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function object
139	136
140		// vectors of reverse mode weights
141		CppAD::vector<double> w(1);
142		w[0] = 1.;
	137	// vectors of reverse mode weights
	138	CppAD::vector<double> w(1);
	139	w[0] = 1.;
143	140
144		// ------------------------------------------------------
145		while(repeat--)
146		{ // get the next matrix
147		CppAD::uniform_01(n, matrix);
148		for( i = 0; i < n; i++)
149		A[i] = matrix[i];
	141	// ------------------------------------------------------
	142	while(repeat--)
	143	{ // get the next matrix
	144	CppAD::uniform_01(n, matrix);
	145	for( i = 0; i < n; i++)
	146	A[i] = matrix[i];
150	147
151		// declare independent variables
152		<a href="independent.xml" target="_top">Independent</a>(A);
	148	// declare independent variables
	149	<a href="independent.xml" target="_top">Independent</a>(A);
153	150
154		// AD computation of the determinant
155		detA[0] = Det(A);
	151	// AD computation of the determinant
	152	detA[0] = Det(A);
156	153
157		// create function object f : A -> detA
158		f.Dependent(A, detA);
159		if( global_optimize )
160		f.optimize();
	154	// create function object f : A -> detA
	155	f.Dependent(A, detA);
	156	if( global_optimize )
	157	f.optimize();
161	158
162		// skip comparison operators
163		f.compare_change_count(0);
	159	// skip comparison operators
	160	f.compare_change_count(0);
164	161
165		// evaluate and return gradient using reverse mode
166		f.<a href="forward.xml" target="_top">Forward</a>(0, matrix);
167		gradient = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
168		}
169		return true;
	162	// evaluate and return gradient using reverse mode
	163	f.<a href="forward.xml" target="_top">Forward</a>(0, matrix);
	164	gradient = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
	165	}
	166	return true;
170	167	}
171	168	</pre></font></code>
172
173	169
174	170	<hr/>Input File: speed/cppad/det_lu.cpp
175	171

+95

-96

doc/cppad_det_minor.cpp.xml less more

5	5	<title>CppAD Speed: Gradient of Determinant by Minor Expansion</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD Speed: Gradient of Determinant by Minor Expansion"/>
8		<meta name="keywords" id="keywords" content=" cppad speed: gradient of determinant by minor expansion link_det_minor speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: gradient determinant minor expansion link_det_minor speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

109	109
110	110	// Note that CppAD uses global_memory at the main program level
111	111	extern bool
112		global_onetape, global_atomic, global_optimize;
	112	global_onetape, global_atomic, global_optimize;
113	113
114	114	bool link_det_minor(
115		size_t size ,
116		size_t repeat ,
117		CppAD::vector<double> &matrix ,
118		CppAD::vector<double> &gradient )
	115	size_t size ,
	116	size_t repeat ,
	117	CppAD::vector<double> &matrix ,
	118	CppAD::vector<double> &gradient )
119	119	{
120		// speed test global option values
121		if( global_atomic )
122		return false;
123
124		// -----------------------------------------------------
125		// setup
126
127		// object for computing determinant
128		typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
129		typedef CppAD::vector<ADScalar> ADVector;
130		CppAD::det_by_minor<ADScalar> Det(size);
131
132		size_t i; // temporary index
133		size_t m = 1; // number of dependent variables
134		size_t n = size * size; // number of independent variables
135		ADVector A(n); // AD domain space vector
136		ADVector detA(m); // AD range space vector
137
138		// vectors of reverse mode weights
139		CppAD::vector<double> w(1);
140		w[0] = 1.;
141
142		// the AD function object
143		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
144
145		// ---------------------------------------------------------------------
146		if( ! global_onetape ) while(repeat--)
147		{
148		// choose a matrix
149		CppAD::uniform_01(n, matrix);
150		for( i = 0; i < size * size; i++)
151		A[i] = matrix[i];
152
153		// declare independent variables
154		<a href="independent.xml" target="_top">Independent</a>(A);
155
156		// AD computation of the determinant
157		detA[0] = Det(A);
158
159		// create function object f : A -> detA
160		f.Dependent(A, detA);
161
162		if( global_optimize )
163		f.optimize();
164
165		// skip comparison operators
166		f.compare_change_count(0);
167
168		// evaluate the determinant at the new matrix value
169		f.<a href="forward.xml" target="_top">Forward</a>(0, matrix);
170
171		// evaluate and return gradient using reverse mode
172		gradient = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
173		}
174		else
175		{
176		// choose a matrix
177		CppAD::uniform_01(n, matrix);
178		for( i = 0; i < size * size; i++)
179		A[i] = matrix[i];
180
181		// declare independent variables
182		<a href="independent.xml" target="_top">Independent</a>(A);
183
184		// AD computation of the determinant
185		detA[0] = Det(A);
186
187		// create function object f : A -> detA
188		f.Dependent(A, detA);
189
190		if( global_optimize )
191		f.optimize();
192
193		// skip comparison operators
194		f.compare_change_count(0);
195
196		// ------------------------------------------------------
197		while(repeat--)
198		{ // get the next matrix
199		CppAD::uniform_01(n, matrix);
200
201		// evaluate the determinant at the new matrix value
202		f.<a href="forward.xml" target="_top">Forward</a>(0, matrix);
203
204		// evaluate and return gradient using reverse mode
205		gradient = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
206		}
207		}
208		return true;
	120	// speed test global option values
	121	if( global_atomic )
	122	return false;
	123
	124	// -----------------------------------------------------
	125	// setup
	126
	127	// object for computing determinant
	128	typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
	129	typedef CppAD::vector<ADScalar> ADVector;
	130	CppAD::det_by_minor<ADScalar> Det(size);
	131
	132	size_t i; // temporary index
	133	size_t m = 1; // number of dependent variables
	134	size_t n = size * size; // number of independent variables
	135	ADVector A(n); // AD domain space vector
	136	ADVector detA(m); // AD range space vector
	137
	138	// vectors of reverse mode weights
	139	CppAD::vector<double> w(1);
	140	w[0] = 1.;
	141
	142	// the AD function object
	143	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
	144
	145	// ---------------------------------------------------------------------
	146	if( ! global_onetape ) while(repeat--)
	147	{
	148	// choose a matrix
	149	CppAD::uniform_01(n, matrix);
	150	for( i = 0; i < size * size; i++)
	151	A[i] = matrix[i];
	152
	153	// declare independent variables
	154	<a href="independent.xml" target="_top">Independent</a>(A);
	155
	156	// AD computation of the determinant
	157	detA[0] = Det(A);
	158
	159	// create function object f : A -> detA
	160	f.Dependent(A, detA);
	161
	162	if( global_optimize )
	163	f.optimize();
	164
	165	// skip comparison operators
	166	f.compare_change_count(0);
	167
	168	// evaluate the determinant at the new matrix value
	169	f.<a href="forward.xml" target="_top">Forward</a>(0, matrix);
	170
	171	// evaluate and return gradient using reverse mode
	172	gradient = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
	173	}
	174	else
	175	{
	176	// choose a matrix
	177	CppAD::uniform_01(n, matrix);
	178	for( i = 0; i < size * size; i++)
	179	A[i] = matrix[i];
	180
	181	// declare independent variables
	182	<a href="independent.xml" target="_top">Independent</a>(A);
	183
	184	// AD computation of the determinant
	185	detA[0] = Det(A);
	186
	187	// create function object f : A -> detA
	188	f.Dependent(A, detA);
	189
	190	if( global_optimize )
	191	f.optimize();
	192
	193	// skip comparison operators
	194	f.compare_change_count(0);
	195
	196	// ------------------------------------------------------
	197	while(repeat--)
	198	{ // get the next matrix
	199	CppAD::uniform_01(n, matrix);
	200
	201	// evaluate the determinant at the new matrix value
	202	f.<a href="forward.xml" target="_top">Forward</a>(0, matrix);
	203
	204	// evaluate and return gradient using reverse mode
	205	gradient = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
	206	}
	207	}
	208	return true;
209	209	}
210	210	</pre></font></code>
211	211
212
213	212	<hr/>Input File: speed/cppad/det_minor.cpp
214	213
215	214	</body>

+74

-79

doc/cppad_eigen.hpp.xml less more

5	5	<title>Enable Use of Eigen Linear Algebra Package with CppAD</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Enable Use of Eigen Linear Algebra Package with CppAD"/>
8		<meta name="keywords" id="keywords" content=" enable use of eigen linear algebra package with cppad syntax purpose example include files numtraits namespace "/>
	8	<meta name="keywords" id="keywords" content=" enable use eigen linear algebra package with cppad syntax purpose example include files numtraits namespace "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

158	158	# include <Eigen/Core>
159	159	# include <cppad/cppad.hpp>
160	160	</pre></font></code>
161
162		<br/>
163	161	<br/>
164	162	<b><big><a name="Eigen NumTraits" id="Eigen NumTraits">Eigen NumTraits</a></big></b>
165	163	<br/>

169	167	scalars:
170	168	<code><font color='blue'><pre style='display:inline'>
171	169	namespace Eigen {
172		template <class Base> struct NumTraits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >
173		{ // type that corresponds to the real part of an <a href="ad.xml" target="_top">AD</a><Base> value
174		typedef CppAD::<a href="ad.xml" target="_top">AD</a><Base> Real;
175		// type for <a href="ad.xml" target="_top">AD</a><Base> operations that result in non-integer values
176		typedef CppAD::<a href="ad.xml" target="_top">AD</a><Base> NonInteger;
177		// type for nested value inside an <a href="ad.xml" target="_top">AD</a><Base> expression tree
178		typedef CppAD::<a href="ad.xml" target="_top">AD</a><Base> Nested;
179
180		enum {
181		// does not support complex Base types
182		IsComplex = 0 ,
183		// does not support integer Base types
184		IsInteger = 0 ,
185		// only support signed Base types
186		IsSigned = 1 ,
187		// must initialize an <a href="ad.xml" target="_top">AD</a><Base> object
188		RequireInitialization = 1 ,
189		// computational cost of the corresponding operations
190		ReadCost = 1 ,
191		AddCost = 2 ,
192		MulCost = 2
193		};
194
195		// machine epsilon with type of real part of x
196		// (use assumption that Base is not complex)
197		static CppAD::<a href="ad.xml" target="_top">AD</a><Base> epsilon(void)
198		{ return CppAD::numeric_limits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >::epsilon(); }
199
200		// relaxed version of machine epsilon for comparison of different
201		// operations that should result in the same value
202		static CppAD::<a href="ad.xml" target="_top">AD</a><Base> dummy_precision(void)
203		{ return 100. *
204		CppAD::numeric_limits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >::epsilon();
205		}
206
207		// minimum normalized positive value
208		static CppAD::<a href="ad.xml" target="_top">AD</a><Base> lowest(void)
209		{ return CppAD::numeric_limits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >::min(); }
210
211		// maximum finite value
212		static CppAD::<a href="ad.xml" target="_top">AD</a><Base> highest(void)
213		{ return CppAD::numeric_limits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >::max(); }
214
215		};
	170	template <class Base> struct NumTraits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >
	171	{ // type that corresponds to the real part of an <a href="ad.xml" target="_top">AD</a><Base> value
	172	typedef CppAD::<a href="ad.xml" target="_top">AD</a><Base> Real;
	173	// type for <a href="ad.xml" target="_top">AD</a><Base> operations that result in non-integer values
	174	typedef CppAD::<a href="ad.xml" target="_top">AD</a><Base> NonInteger;
	175	// type for nested value inside an <a href="ad.xml" target="_top">AD</a><Base> expression tree
	176	typedef CppAD::<a href="ad.xml" target="_top">AD</a><Base> Nested;
	177
	178	enum {
	179	// does not support complex Base types
	180	IsComplex = 0 ,
	181	// does not support integer Base types
	182	IsInteger = 0 ,
	183	// only support signed Base types
	184	IsSigned = 1 ,
	185	// must initialize an <a href="ad.xml" target="_top">AD</a><Base> object
	186	RequireInitialization = 1 ,
	187	// computational cost of the corresponding operations
	188	ReadCost = 1 ,
	189	AddCost = 2 ,
	190	MulCost = 2
	191	};
	192
	193	// machine epsilon with type of real part of x
	194	// (use assumption that Base is not complex)
	195	static CppAD::<a href="ad.xml" target="_top">AD</a><Base> epsilon(void)
	196	{ return CppAD::numeric_limits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >::epsilon(); }
	197
	198	// relaxed version of machine epsilon for comparison of different
	199	// operations that should result in the same value
	200	static CppAD::<a href="ad.xml" target="_top">AD</a><Base> dummy_precision(void)
	201	{ return 100. *
	202	CppAD::numeric_limits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >::epsilon();
	203	}
	204
	205	// minimum normalized positive value
	206	static CppAD::<a href="ad.xml" target="_top">AD</a><Base> lowest(void)
	207	{ return CppAD::numeric_limits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >::min(); }
	208
	209	// maximum finite value
	210	static CppAD::<a href="ad.xml" target="_top">AD</a><Base> highest(void)
	211	{ return CppAD::numeric_limits< CppAD::<a href="ad.xml" target="_top">AD</a><Base> >::max(); }
	212
	213	};
216	214	}
217	215	</pre></font></code>
218
219		<br/>
220	216	<br/>
221	217	<b><big><a name="CppAD Namespace" id="CppAD Namespace">CppAD Namespace</a></big></b>
222	218	<br/>

226	222	scalars:
227	223	<code><font color='blue'><pre style='display:inline'>
228	224	namespace CppAD {
229		// functions that return references
230		template <class Base> const <a href="ad.xml" target="_top">AD</a><Base>& conj(const <a href="ad.xml" target="_top">AD</a><Base>& x)
231		{ return x; }
232		template <class Base> const <a href="ad.xml" target="_top">AD</a><Base>& real(const <a href="ad.xml" target="_top">AD</a><Base>& x)
233		{ return x; }
234
235		// functions that return values (note abs is defined by cppad.hpp)
236		template <class Base> <a href="ad.xml" target="_top">AD</a><Base> imag(const <a href="ad.xml" target="_top">AD</a><Base>& x)
237		{ return CppAD::<a href="ad.xml" target="_top">AD</a><Base>(0.); }
238		template <class Base> <a href="ad.xml" target="_top">AD</a><Base> abs2(const <a href="ad.xml" target="_top">AD</a><Base>& x)
239		{ return x * x; }
	225	// functions that return references
	226	template <class Base> const <a href="ad.xml" target="_top">AD</a><Base>& conj(const <a href="ad.xml" target="_top">AD</a><Base>& x)
	227	{ return x; }
	228	template <class Base> const <a href="ad.xml" target="_top">AD</a><Base>& real(const <a href="ad.xml" target="_top">AD</a><Base>& x)
	229	{ return x; }
	230
	231	// functions that return values (note abs is defined by cppad.hpp)
	232	template <class Base> <a href="ad.xml" target="_top">AD</a><Base> imag(const <a href="ad.xml" target="_top">AD</a><Base>& x)
	233	{ return CppAD::<a href="ad.xml" target="_top">AD</a><Base>(0.); }
	234	template <class Base> <a href="ad.xml" target="_top">AD</a><Base> abs2(const <a href="ad.xml" target="_top">AD</a><Base>& x)
	235	{ return x * x; }
240	236	}
241	237
242	238	namespace Eigen {
243		namespace internal {
244
245		template<class Base>
246		struct significant_decimals_default_impl< CppAD::<a href="ad.xml" target="_top">AD</a><Base>, false>
247		{ typedef CppAD::<a href="ad.xml" target="_top">AD</a><Base> Scalar;
248
249		typedef typename NumTraits<Scalar>::Real RealScalar;
250		static inline int run()
251		{ Scalar neg_log_eps = - log(
252		NumTraits<RealScalar>::epsilon()
253		);
254		int ceil_neg_log_eps = Integer( neg_log_eps );
255		if( Scalar(ceil_neg_log_eps) < neg_log_eps )
256		ceil_neg_log_eps++;
257		return ceil_neg_log_eps;
258		}
259		};
260		}
	239	namespace internal {
	240
	241	template<class Base>
	242	struct significant_decimals_default_impl< CppAD::<a href="ad.xml" target="_top">AD</a><Base>, false>
	243	{ typedef CppAD::<a href="ad.xml" target="_top">AD</a><Base> Scalar;
	244
	245	typedef typename NumTraits<Scalar>::Real RealScalar;
	246	static inline int run()
	247	{ Scalar neg_log_eps = - log(
	248	NumTraits<RealScalar>::epsilon()
	249	);
	250	int ceil_neg_log_eps = Integer( neg_log_eps );
	251	if( Scalar(ceil_neg_log_eps) < neg_log_eps )
	252	ceil_neg_log_eps++;
	253	return ceil_neg_log_eps;
	254	}
	255	};
	256	}
261	257	}
262	258	</pre></font></code>
263	259
264
265	260	<hr/>Input File: cppad/example/cppad_eigen.hpp
266	261
267	262	</body>

+0

-3

doc/cppad_ipopt_nlp.xml less more

145	145	</select>
146	146	</td>
147	147	</tr></table><br/>
148
149
150
151	148	<center><b><big><big>Nonlinear Programming Using the CppAD Interface to Ipopt</big></big></b></center>
152	149	<br/>
153	150	<b><big><a name="Deprecated 2012-11-28" id="Deprecated 2012-11-28">Deprecated 2012-11-28</a></big></b>

+119

-123

doc/cppad_mat_mul.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>CppAD Speed, Matrix Multiplication</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

114	111
115	112	// Note that CppAD uses global_memory at the main program level
116	113	extern bool
117		global_onetape, global_atomic, global_optimize, global_boolsparsity;
	114	global_onetape, global_atomic, global_optimize, global_boolsparsity;
118	115
119	116	bool link_mat_mul(
120		size_t size ,
121		size_t repeat ,
122		CppAD::vector<double>& x ,
123		CppAD::vector<double>& z ,
124		CppAD::vector<double>& dz
	117	size_t size ,
	118	size_t repeat ,
	119	CppAD::vector<double>& x ,
	120	CppAD::vector<double>& z ,
	121	CppAD::vector<double>& dz
125	122	)
126	123	{
127		// -----------------------------------------------------
128		// setup
129		typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
130		typedef CppAD::vector<ADScalar> ADVector;
131
132		size_t j; // temporary index
133		size_t m = 1; // number of dependent variables
134		size_t n = size * size; // number of independent variables
135		ADVector X(n); // AD domain space vector
136		ADVector Y(n); // Store product matrix
137		ADVector Z(m); // AD range space vector
138		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function object
139
140		// vectors of reverse mode weights
141		CppAD::vector<double> w(1);
142		w[0] = 1.;
143
144		// user atomic information
145		CppAD::vector<ADScalar> ax(2 * n), ay(n);
146		size_t nr_result = size;
147		size_t n_middle = size;
148		size_t nc_result = size;
149		matrix_mul atom_mul(nr_result, n_middle, nc_result);
150		//
151		if( global_boolsparsity )
152		atom_mul.option( CppAD::atomic_base<double>::pack_sparsity_enum );
153		else
154		atom_mul.option( CppAD::atomic_base<double>::set_sparsity_enum );
155		// ------------------------------------------------------
156		if( ! global_onetape ) while(repeat--)
157		{ // get the next matrix
158		CppAD::uniform_01(n, x);
159		for( j = 0; j < n; j++)
160		X[j] = x[j];
161
162		// declare independent variables
163		<a href="independent.xml" target="_top">Independent</a>(X);
164
165		// do computations
166		if( ! global_atomic )
167		mat_sum_sq(size, X, Y, Z);
168		else
169		{ for(j = 0; j < n; j++)
170		{ ax[j] = X[j];
171		ax[j+n] = X[j];
172		}
173		// Y = X * X
174		atom_mul(ax, ay);
175		Z[0] = 0.;
176		for(j = 0; j < n; j++)
177		Z[0] += ay[j];
178		}
179		// create function object f : X -> Z
180		f.Dependent(X, Z);
181
182		if( global_optimize )
183		f.optimize();
184
185		// skip comparison operators
186		f.compare_change_count(0);
187
188		// evaluate and return gradient using reverse mode
189		z = f.<a href="forward.xml" target="_top">Forward</a>(0, x);
190		dz = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
191		}
192		else
193		{ // get a next matrix
194		CppAD::uniform_01(n, x);
195		for(j = 0; j < n; j++)
196		X[j] = x[j];
197
198		// declare independent variables
199		<a href="independent.xml" target="_top">Independent</a>(X);
200
201		// do computations
202		if( ! global_atomic )
203		mat_sum_sq(size, X, Y, Z);
204		else
205		{ for(j = 0; j < n; j++)
206		{ ax[j] = X[j];
207		ax[j+n] = X[j];
208		}
209		// Y = X * X
210		atom_mul(ax, ay);
211		Z[0] = 0.;
212		for(j = 0; j < n; j++)
213		Z[0] += ay[j];
214		}
215
216		// create function object f : X -> Z
217		f.Dependent(X, Z);
218
219		if( global_optimize )
220		f.optimize();
221
222		// skip comparison operators
223		f.compare_change_count(0);
224
225		while(repeat--)
226		{ // get a next matrix
227		CppAD::uniform_01(n, x);
228
229		// evaluate and return gradient using reverse mode
230		z = f.<a href="forward.xml" target="_top">Forward</a>(0, x);
231		dz = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
232		}
233		}
234		// --------------------------------------------------------------------
235		// Free temporary work space. (If there are future calls to
236		// mat_mul they would create new temporary work space.)
237		CppAD::user_atomic<double>::clear();
238
239		return true;
	124	// -----------------------------------------------------
	125	// setup
	126	typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
	127	typedef CppAD::vector<ADScalar> ADVector;
	128
	129	size_t j; // temporary index
	130	size_t m = 1; // number of dependent variables
	131	size_t n = size * size; // number of independent variables
	132	ADVector X(n); // AD domain space vector
	133	ADVector Y(n); // Store product matrix
	134	ADVector Z(m); // AD range space vector
	135	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function object
	136
	137	// vectors of reverse mode weights
	138	CppAD::vector<double> w(1);
	139	w[0] = 1.;
	140
	141	// user atomic information
	142	CppAD::vector<ADScalar> ax(2 * n), ay(n);
	143	size_t nr_result = size;
	144	size_t n_middle = size;
	145	size_t nc_result = size;
	146	matrix_mul atom_mul(nr_result, n_middle, nc_result);
	147	//
	148	if( global_boolsparsity )
	149	atom_mul.option( CppAD::atomic_base<double>::pack_sparsity_enum );
	150	else
	151	atom_mul.option( CppAD::atomic_base<double>::set_sparsity_enum );
	152	// ------------------------------------------------------
	153	if( ! global_onetape ) while(repeat--)
	154	{ // get the next matrix
	155	CppAD::uniform_01(n, x);
	156	for( j = 0; j < n; j++)
	157	X[j] = x[j];
	158
	159	// declare independent variables
	160	<a href="independent.xml" target="_top">Independent</a>(X);
	161
	162	// do computations
	163	if( ! global_atomic )
	164	mat_sum_sq(size, X, Y, Z);
	165	else
	166	{ for(j = 0; j < n; j++)
	167	{ ax[j] = X[j];
	168	ax[j+n] = X[j];
	169	}
	170	// Y = X * X
	171	atom_mul(ax, ay);
	172	Z[0] = 0.;
	173	for(j = 0; j < n; j++)
	174	Z[0] += ay[j];
	175	}
	176	// create function object f : X -> Z
	177	f.Dependent(X, Z);
	178
	179	if( global_optimize )
	180	f.optimize();
	181
	182	// skip comparison operators
	183	f.compare_change_count(0);
	184
	185	// evaluate and return gradient using reverse mode
	186	z = f.<a href="forward.xml" target="_top">Forward</a>(0, x);
	187	dz = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
	188	}
	189	else
	190	{ // get a next matrix
	191	CppAD::uniform_01(n, x);
	192	for(j = 0; j < n; j++)
	193	X[j] = x[j];
	194
	195	// declare independent variables
	196	<a href="independent.xml" target="_top">Independent</a>(X);
	197
	198	// do computations
	199	if( ! global_atomic )
	200	mat_sum_sq(size, X, Y, Z);
	201	else
	202	{ for(j = 0; j < n; j++)
	203	{ ax[j] = X[j];
	204	ax[j+n] = X[j];
	205	}
	206	// Y = X * X
	207	atom_mul(ax, ay);
	208	Z[0] = 0.;
	209	for(j = 0; j < n; j++)
	210	Z[0] += ay[j];
	211	}
	212
	213	// create function object f : X -> Z
	214	f.Dependent(X, Z);
	215
	216	if( global_optimize )
	217	f.optimize();
	218
	219	// skip comparison operators
	220	f.compare_change_count(0);
	221
	222	while(repeat--)
	223	{ // get a next matrix
	224	CppAD::uniform_01(n, x);
	225
	226	// evaluate and return gradient using reverse mode
	227	z = f.<a href="forward.xml" target="_top">Forward</a>(0, x);
	228	dz = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
	229	}
	230	}
	231	// --------------------------------------------------------------------
	232	// Free temporary work space. (If there are future calls to
	233	// mat_mul they would create new temporary work space.)
	234	CppAD::user_atomic<double>::clear();
	235
	236	return true;
240	237	}
241	238	</pre></font></code>
242	239
243
244	240	<hr/>Input File: speed/cppad/mat_mul.cpp
245	241
246	242	</body>

+79

-83

doc/cppad_ode.cpp.xml less more

5	5	<title>CppAD Speed: Gradient of Ode Solution</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD Speed: Gradient of Ode Solution"/>
8		<meta name="keywords" id="keywords" content=" cppad speed: gradient of ode solution link_ode speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: gradient ode solution link_ode speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>CppAD Speed: Gradient of Ode Solution</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

114	111
115	112	// Note that CppAD uses global_memory at the main program level
116	113	extern bool
117		global_onetape, global_atomic, global_optimize;
	114	global_onetape, global_atomic, global_optimize;
118	115
119	116	bool link_ode(
120		size_t size ,
121		size_t repeat ,
122		CppAD::vector<double> &x ,
123		CppAD::vector<double> &jacobian
	117	size_t size ,
	118	size_t repeat ,
	119	CppAD::vector<double> &x ,
	120	CppAD::vector<double> &jacobian
124	121	)
125	122	{
126		// speed test global option values
127		if( global_atomic )
128		return false;
129
130		// --------------------------------------------------------------------
131		// setup
132		assert( x.size() == size );
133		assert( jacobian.size() == size * size );
134
135		typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
136		typedef CppAD::vector<ADScalar> ADVector;
137
138		size_t j;
139		size_t p = 0; // use ode to calculate function values
140		size_t n = size; // number of independent variables
141		size_t m = n; // number of dependent variables
142		ADVector X(n), Y(m); // independent and dependent variables
143		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function
144
145		// -------------------------------------------------------------
146		if( ! global_onetape ) while(repeat--)
147		{ // choose next x value
148		uniform_01(n, x);
149		for(j = 0; j < n; j++)
150		X[j] = x[j];
151
152		// declare the independent variable vector
153		<a href="independent.xml" target="_top">Independent</a>(X);
154
155		// evaluate function
156		CppAD::ode_evaluate(X, p, Y);
157
158		// create function object f : X -> Y
159		f.Dependent(X, Y);
160
161		if( global_optimize )
162		f.optimize();
163
164		// skip comparison operators
165		f.compare_change_count(0);
166
167		jacobian = f.<a href="jacobian.xml" target="_top">Jacobian</a>(x);
168		}
169		else
170		{ // an x value
171		uniform_01(n, x);
172		for(j = 0; j < n; j++)
173		X[j] = x[j];
174
175		// declare the independent variable vector
176		<a href="independent.xml" target="_top">Independent</a>(X);
177
178		// evaluate function
179		CppAD::ode_evaluate(X, p, Y);
180
181		// create function object f : X -> Y
182		f.Dependent(X, Y);
183
184		if( global_optimize )
185		f.optimize();
186
187		// skip comparison operators
188		f.compare_change_count(0);
189
190		while(repeat--)
191		{ // get next argument value
192		uniform_01(n, x);
193
194		// evaluate jacobian
195		jacobian = f.<a href="jacobian.xml" target="_top">Jacobian</a>(x);
196		}
197		}
198		return true;
	123	// speed test global option values
	124	if( global_atomic )
	125	return false;
	126
	127	// --------------------------------------------------------------------
	128	// setup
	129	assert( x.size() == size );
	130	assert( jacobian.size() == size * size );
	131
	132	typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
	133	typedef CppAD::vector<ADScalar> ADVector;
	134
	135	size_t j;
	136	size_t p = 0; // use ode to calculate function values
	137	size_t n = size; // number of independent variables
	138	size_t m = n; // number of dependent variables
	139	ADVector X(n), Y(m); // independent and dependent variables
	140	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function
	141
	142	// -------------------------------------------------------------
	143	if( ! global_onetape ) while(repeat--)
	144	{ // choose next x value
	145	uniform_01(n, x);
	146	for(j = 0; j < n; j++)
	147	X[j] = x[j];
	148
	149	// declare the independent variable vector
	150	<a href="independent.xml" target="_top">Independent</a>(X);
	151
	152	// evaluate function
	153	CppAD::ode_evaluate(X, p, Y);
	154
	155	// create function object f : X -> Y
	156	f.Dependent(X, Y);
	157
	158	if( global_optimize )
	159	f.optimize();
	160
	161	// skip comparison operators
	162	f.compare_change_count(0);
	163
	164	jacobian = f.<a href="jacobian.xml" target="_top">Jacobian</a>(x);
	165	}
	166	else
	167	{ // an x value
	168	uniform_01(n, x);
	169	for(j = 0; j < n; j++)
	170	X[j] = x[j];
	171
	172	// declare the independent variable vector
	173	<a href="independent.xml" target="_top">Independent</a>(X);
	174
	175	// evaluate function
	176	CppAD::ode_evaluate(X, p, Y);
	177
	178	// create function object f : X -> Y
	179	f.Dependent(X, Y);
	180
	181	if( global_optimize )
	182	f.optimize();
	183
	184	// skip comparison operators
	185	f.compare_change_count(0);
	186
	187	while(repeat--)
	188	{ // get next argument value
	189	uniform_01(n, x);
	190
	191	// evaluate jacobian
	192	jacobian = f.<a href="jacobian.xml" target="_top">Jacobian</a>(x);
	193	}
	194	}
	195	return true;
199	196	}
200	197	</pre></font></code>
201	198
202
203	199	<hr/>Input File: speed/cppad/ode.cpp
204	200
205	201	</body>

+112

-116

doc/cppad_poly.cpp.xml less more

5	5	<title>CppAD Speed: Second Derivative of a Polynomial</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD Speed: Second Derivative of a Polynomial"/>
8		<meta name="keywords" id="keywords" content=" cppad speed: second derivative of a polynomial link_poly speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" cppad speed: second derivative polynomial link_poly speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>CppAD Speed: Second Derivative of a Polynomial</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

112	109
113	110	// Note that CppAD uses global_memory at the main program level
114	111	extern bool
115		global_onetape, global_atomic, global_optimize;
	112	global_onetape, global_atomic, global_optimize;
116	113
117	114	bool link_poly(
118		size_t size ,
119		size_t repeat ,
120		CppAD::vector<double> &a , // coefficients of polynomial
121		CppAD::vector<double> &z , // polynomial argument value
122		CppAD::vector<double> &ddp ) // second derivative w.r.t z
	115	size_t size ,
	116	size_t repeat ,
	117	CppAD::vector<double> &a , // coefficients of polynomial
	118	CppAD::vector<double> &z , // polynomial argument value
	119	CppAD::vector<double> &ddp ) // second derivative w.r.t z
123	120	{
124		// speed test global option values
125		if( global_atomic )
126		return false;
127
128		// -----------------------------------------------------
129		// setup
130		typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
131		typedef CppAD::vector<ADScalar> ADVector;
132
133		size_t i; // temporary index
134		size_t m = 1; // number of dependent variables
135		size_t n = 1; // number of independent variables
136		ADVector Z(n); // AD domain space vector
137		ADVector P(m); // AD range space vector
138
139		// choose the polynomial coefficients
140		CppAD::uniform_01(size, a);
141
142		// AD copy of the polynomial coefficients
143		ADVector A(size);
144		for(i = 0; i < size; i++)
145		A[i] = a[i];
146
147		// forward mode first and second differentials
148		CppAD::vector<double> p(1), dp(1), dz(1), ddz(1);
149		dz[0] = 1.;
150		ddz[0] = 0.;
151
152		// AD function object
153		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
154
155		// --------------------------------------------------------------------
156		if( ! global_onetape ) while(repeat--)
157		{
158		// choose an argument value
159		CppAD::uniform_01(1, z);
160		Z[0] = z[0];
161
162		// declare independent variables
163		<a href="independent.xml" target="_top">Independent</a>(Z);
164
165		// AD computation of the function value
166		P[0] = CppAD::Poly(0, A, Z[0]);
167
168		// create function object f : A -> detA
169		f.Dependent(Z, P);
170
171		if( global_optimize )
172		f.optimize();
173
174		// skip comparison operators
175		f.compare_change_count(0);
176
177		// pre-allocate memory for three forward mode calculations
178		f.capacity_order(3);
179
180		// evaluate the polynomial
181		p = f.<a href="forward.xml" target="_top">Forward</a>(0, z);
182
183		// evaluate first order Taylor coefficient
184		dp = f.<a href="forward.xml" target="_top">Forward</a>(1, dz);
185
186		// second derivative is twice second order Taylor coef
187		ddp = f.<a href="forward.xml" target="_top">Forward</a>(2, ddz);
188		ddp[0] *= 2.;
189		}
190		else
191		{
192		// choose an argument value
193		CppAD::uniform_01(1, z);
194		Z[0] = z[0];
195
196		// declare independent variables
197		<a href="independent.xml" target="_top">Independent</a>(Z);
198
199		// AD computation of the function value
200		P[0] = CppAD::Poly(0, A, Z[0]);
201
202		// create function object f : A -> detA
203		f.Dependent(Z, P);
204
205		if( global_optimize )
206		f.optimize();
207
208		// skip comparison operators
209		f.compare_change_count(0);
210
211		while(repeat--)
212		{ // sufficient memory is allocated by second repetition
213
214		// get the next argument value
215		CppAD::uniform_01(1, z);
216
217		// evaluate the polynomial at the new argument value
218		p = f.<a href="forward.xml" target="_top">Forward</a>(0, z);
219
220		// evaluate first order Taylor coefficient
221		dp = f.<a href="forward.xml" target="_top">Forward</a>(1, dz);
222
223		// second derivative is twice second order Taylor coef
224		ddp = f.<a href="forward.xml" target="_top">Forward</a>(2, ddz);
225		ddp[0] *= 2.;
226		}
227		}
228		return true;
	121	// speed test global option values
	122	if( global_atomic )
	123	return false;
	124
	125	// -----------------------------------------------------
	126	// setup
	127	typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
	128	typedef CppAD::vector<ADScalar> ADVector;
	129
	130	size_t i; // temporary index
	131	size_t m = 1; // number of dependent variables
	132	size_t n = 1; // number of independent variables
	133	ADVector Z(n); // AD domain space vector
	134	ADVector P(m); // AD range space vector
	135
	136	// choose the polynomial coefficients
	137	CppAD::uniform_01(size, a);
	138
	139	// AD copy of the polynomial coefficients
	140	ADVector A(size);
	141	for(i = 0; i < size; i++)
	142	A[i] = a[i];
	143
	144	// forward mode first and second differentials
	145	CppAD::vector<double> p(1), dp(1), dz(1), ddz(1);
	146	dz[0] = 1.;
	147	ddz[0] = 0.;
	148
	149	// AD function object
	150	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f;
	151
	152	// --------------------------------------------------------------------
	153	if( ! global_onetape ) while(repeat--)
	154	{
	155	// choose an argument value
	156	CppAD::uniform_01(1, z);
	157	Z[0] = z[0];
	158
	159	// declare independent variables
	160	<a href="independent.xml" target="_top">Independent</a>(Z);
	161
	162	// AD computation of the function value
	163	P[0] = CppAD::Poly(0, A, Z[0]);
	164
	165	// create function object f : A -> detA
	166	f.Dependent(Z, P);
	167
	168	if( global_optimize )
	169	f.optimize();
	170
	171	// skip comparison operators
	172	f.compare_change_count(0);
	173
	174	// pre-allocate memory for three forward mode calculations
	175	f.capacity_order(3);
	176
	177	// evaluate the polynomial
	178	p = f.<a href="forward.xml" target="_top">Forward</a>(0, z);
	179
	180	// evaluate first order Taylor coefficient
	181	dp = f.<a href="forward.xml" target="_top">Forward</a>(1, dz);
	182
	183	// second derivative is twice second order Taylor coef
	184	ddp = f.<a href="forward.xml" target="_top">Forward</a>(2, ddz);
	185	ddp[0] *= 2.;
	186	}
	187	else
	188	{
	189	// choose an argument value
	190	CppAD::uniform_01(1, z);
	191	Z[0] = z[0];
	192
	193	// declare independent variables
	194	<a href="independent.xml" target="_top">Independent</a>(Z);
	195
	196	// AD computation of the function value
	197	P[0] = CppAD::Poly(0, A, Z[0]);
	198
	199	// create function object f : A -> detA
	200	f.Dependent(Z, P);
	201
	202	if( global_optimize )
	203	f.optimize();
	204
	205	// skip comparison operators
	206	f.compare_change_count(0);
	207
	208	while(repeat--)
	209	{ // sufficient memory is allocated by second repetition
	210
	211	// get the next argument value
	212	CppAD::uniform_01(1, z);
	213
	214	// evaluate the polynomial at the new argument value
	215	p = f.<a href="forward.xml" target="_top">Forward</a>(0, z);
	216
	217	// evaluate first order Taylor coefficient
	218	dp = f.<a href="forward.xml" target="_top">Forward</a>(1, dz);
	219
	220	// second derivative is twice second order Taylor coef
	221	ddp = f.<a href="forward.xml" target="_top">Forward</a>(2, ddz);
	222	ddp[0] *= 2.;
	223	}
	224	}
	225	return true;
229	226	}
230	227	</pre></font></code>
231	228
232
233	229	<hr/>Input File: speed/cppad/poly.cpp
234	230
235	231	</body>

+157

-161

doc/cppad_sparse_hessian.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>CppAD Speed: Sparse Hessian</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

113	110
114	111	// Note that CppAD uses global_memory at the main program level
115	112	extern bool
116		global_onetape, global_colpack,
117		global_atomic, global_optimize, global_boolsparsity;
	113	global_onetape, global_colpack,
	114	global_atomic, global_optimize, global_boolsparsity;
118	115
119	116	namespace {
120		using CppAD::vector;
121		typedef vector< std::set<size_t> > SetVector;
122		typedef vector<bool> BoolVector;
123
124		void calc_sparsity(SetVector& sparsity_set, CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double>& f)
125		{ size_t n = f.Domain();
126		size_t m = f.Range();
127		CPPAD_ASSERT_UNKNOWN( m == 1 );
128		SetVector r_set(n);
129		for(size_t i = 0; i < n; i++)
130		r_set[i].insert(i);
131		f.ForSparseJac(n, r_set);
132		//
133		SetVector s_set(m);
134		s_set[0].insert(0);
135		//
136		sparsity_set = f.RevSparseHes(n, s_set);
137		}
138		void calc_sparsity(BoolVector& sparsity_bool, CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double>& f)
139		{ size_t n = f.Domain();
140		size_t m = f.Range();
141		CPPAD_ASSERT_UNKNOWN( m == 1 );
142		BoolVector r_bool(n * n);
143		size_t i, j;
144		for(i = 0; i < n; i++)
145		{ for(j = 0; j < n; j++)
146		r_bool[ i * n + j] = false;
147		r_bool[ i * n + i] = true;
148		}
149		f.ForSparseJac(n, r_bool);
150		//
151		BoolVector s_bool(m);
152		s_bool[0] = true;
153		//
154		sparsity_bool = f.RevSparseHes(n, s_bool);
155		}
	117	using CppAD::vector;
	118	typedef vector< std::set<size_t> > SetVector;
	119	typedef vector<bool> BoolVector;
	120
	121	void calc_sparsity(SetVector& sparsity_set, CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double>& f)
	122	{ size_t n = f.Domain();
	123	size_t m = f.Range();
	124	CPPAD_ASSERT_UNKNOWN( m == 1 );
	125	SetVector r_set(n);
	126	for(size_t i = 0; i < n; i++)
	127	r_set[i].insert(i);
	128	f.ForSparseJac(n, r_set);
	129	//
	130	SetVector s_set(m);
	131	s_set[0].insert(0);
	132	//
	133	sparsity_set = f.RevSparseHes(n, s_set);
	134	}
	135	void calc_sparsity(BoolVector& sparsity_bool, CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double>& f)
	136	{ size_t n = f.Domain();
	137	size_t m = f.Range();
	138	CPPAD_ASSERT_UNKNOWN( m == 1 );
	139	BoolVector r_bool(n * n);
	140	size_t i, j;
	141	for(i = 0; i < n; i++)
	142	{ for(j = 0; j < n; j++)
	143	r_bool[ i * n + j] = false;
	144	r_bool[ i * n + i] = true;
	145	}
	146	f.ForSparseJac(n, r_bool);
	147	//
	148	BoolVector s_bool(m);
	149	s_bool[0] = true;
	150	//
	151	sparsity_bool = f.RevSparseHes(n, s_bool);
	152	}
156	153
157	154	}
158	155
159	156	bool link_sparse_hessian(
160		size_t size ,
161		size_t repeat ,
162		const CppAD::vector<size_t>& row ,
163		const CppAD::vector<size_t>& col ,
164		CppAD::vector<double>& x ,
165		CppAD::vector<double>& hessian ,
166		size_t& n_sweep )
	157	size_t size ,
	158	size_t repeat ,
	159	const CppAD::vector<size_t>& row ,
	160	const CppAD::vector<size_t>& col ,
	161	CppAD::vector<double>& x ,
	162	CppAD::vector<double>& hessian ,
	163	size_t& n_sweep )
167	164	{
168		if( global_atomic )
169		return false;
	165	if( global_atomic )
	166	return false;
170	167	# ifndef CPPAD_COLPACK_SPEED
171		if( global_colpack )
172		return false;
	168	if( global_colpack )
	169	return false;
173	170	# endif
174		// -----------------------------------------------------
175		// setup
176		typedef vector<double> DblVector;
177		typedef vector< std::set<size_t> > SetVector;
178		typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
179		typedef vector<ADScalar> ADVector;
180
181		size_t j;
182		size_t order = 0; // derivative order corresponding to function
183		size_t m = 1; // number of dependent variables
184		size_t n = size; // number of independent variables
185		ADVector a_x(n); // AD domain space vector
186		ADVector a_y(m); // AD range space vector
187		DblVector w(m); // double range space vector
188		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function object
189
190		// weights for hessian calculation (only one component of f)
191		w[0] = 1.;
192
193		// declare sparsity pattern
194		SetVector set_sparsity(n);
195		BoolVector bool_sparsity(n * n);
196
197		// ------------------------------------------------------
198		if( ! global_onetape ) while(repeat--)
199		{ // choose a value for x
200		CppAD::uniform_01(n, x);
201		for(j = 0; j < n; j++)
202		a_x[j] = x[j];
203
204		// declare independent variables
205		<a href="independent.xml" target="_top">Independent</a>(a_x);
206
207		// AD computation of f(x)
208		CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);
209
210		// create function object f : X -> Y
211		f.Dependent(a_x, a_y);
212
213		if( global_optimize )
214		f.optimize();
215
216		// skip comparison operators
217		f.compare_change_count(0);
218
219		// calculate the Hessian sparsity pattern for this function
220		if( global_boolsparsity )
221		calc_sparsity(bool_sparsity, f);
222		else
223		calc_sparsity(set_sparsity, f);
224
225		// structure that holds some of work done by SparseHessian
226		CppAD::sparse_hessian_work work;
	171	// -----------------------------------------------------
	172	// setup
	173	typedef vector<double> DblVector;
	174	typedef vector< std::set<size_t> > SetVector;
	175	typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
	176	typedef vector<ADScalar> ADVector;
	177
	178	size_t j;
	179	size_t order = 0; // derivative order corresponding to function
	180	size_t m = 1; // number of dependent variables
	181	size_t n = size; // number of independent variables
	182	ADVector a_x(n); // AD domain space vector
	183	ADVector a_y(m); // AD range space vector
	184	DblVector w(m); // double range space vector
	185	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function object
	186
	187	// weights for hessian calculation (only one component of f)
	188	w[0] = 1.;
	189
	190	// declare sparsity pattern
	191	SetVector set_sparsity(n);
	192	BoolVector bool_sparsity(n * n);
	193
	194	// ------------------------------------------------------
	195	if( ! global_onetape ) while(repeat--)
	196	{ // choose a value for x
	197	CppAD::uniform_01(n, x);
	198	for(j = 0; j < n; j++)
	199	a_x[j] = x[j];
	200
	201	// declare independent variables
	202	<a href="independent.xml" target="_top">Independent</a>(a_x);
	203
	204	// AD computation of f(x)
	205	CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);
	206
	207	// create function object f : X -> Y
	208	f.Dependent(a_x, a_y);
	209
	210	if( global_optimize )
	211	f.optimize();
	212
	213	// skip comparison operators
	214	f.compare_change_count(0);
	215
	216	// calculate the Hessian sparsity pattern for this function
	217	if( global_boolsparsity )
	218	calc_sparsity(bool_sparsity, f);
	219	else
	220	calc_sparsity(set_sparsity, f);
	221
	222	// structure that holds some of work done by SparseHessian
	223	CppAD::sparse_hessian_work work;
227	224	# ifdef CPPAD_COLPACK_SPEED
228		if( global_colpack )
229		work.color_method = "colpack.star";
	225	if( global_colpack )
	226	work.color_method = "colpack.star";
230	227	# endif
231		// calculate this Hessian at this x
232		if( global_boolsparsity) n_sweep = f.SparseHessian(
233		x, w, bool_sparsity, row, col, hessian, work
234		);
235		else n_sweep = f.SparseHessian(
236		x, w, set_sparsity, row, col, hessian, work
237		);
238		}
239		else
240		{ // choose a value for x
241		CppAD::uniform_01(n, x);
242		for(j = 0; j < n; j++)
243		a_x[j] = x[j];
244
245		// declare independent variables
246		<a href="independent.xml" target="_top">Independent</a>(a_x);
247
248		// AD computation of f(x)
249		CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);
250
251		// create function object f : X -> Y
252		f.Dependent(a_x, a_y);
253
254		if( global_optimize )
255		f.optimize();
256
257		// skip comparison operators
258		f.compare_change_count(0);
259
260		// calculate the Hessian sparsity pattern for this function
261		if( global_boolsparsity)
262		calc_sparsity(bool_sparsity, f);
263		else
264		calc_sparsity(set_sparsity, f);
265
266		// declare structure that holds some of work done by SparseHessian
267		CppAD::sparse_hessian_work work;
	228	// calculate this Hessian at this x
	229	if( global_boolsparsity) n_sweep = f.SparseHessian(
	230	x, w, bool_sparsity, row, col, hessian, work
	231	);
	232	else n_sweep = f.SparseHessian(
	233	x, w, set_sparsity, row, col, hessian, work
	234	);
	235	}
	236	else
	237	{ // choose a value for x
	238	CppAD::uniform_01(n, x);
	239	for(j = 0; j < n; j++)
	240	a_x[j] = x[j];
	241
	242	// declare independent variables
	243	<a href="independent.xml" target="_top">Independent</a>(a_x);
	244
	245	// AD computation of f(x)
	246	CppAD::sparse_hes_fun<ADScalar>(n, a_x, row, col, order, a_y);
	247
	248	// create function object f : X -> Y
	249	f.Dependent(a_x, a_y);
	250
	251	if( global_optimize )
	252	f.optimize();
	253
	254	// skip comparison operators
	255	f.compare_change_count(0);
	256
	257	// calculate the Hessian sparsity pattern for this function
	258	if( global_boolsparsity)
	259	calc_sparsity(bool_sparsity, f);
	260	else
	261	calc_sparsity(set_sparsity, f);
	262
	263	// declare structure that holds some of work done by SparseHessian
	264	CppAD::sparse_hessian_work work;
268	265	# ifdef CPPAD_COLPACK_SPEED
269		if( global_colpack )
270		work.color_method = "colpack.star";
	266	if( global_colpack )
	267	work.color_method = "colpack.star";
271	268	# endif
272		while(repeat--)
273		{ // choose a value for x
274		CppAD::uniform_01(n, x);
275
276		// calculate hessian at this x
277		if( global_boolsparsity ) n_sweep = f.SparseHessian(
278		x, w, bool_sparsity, row, col, hessian, work
279		);
280		else n_sweep = f.SparseHessian(
281		x, w, set_sparsity, row, col, hessian, work
282		);
283		}
284		}
285		return true;
	269	while(repeat--)
	270	{ // choose a value for x
	271	CppAD::uniform_01(n, x);
	272
	273	// calculate hessian at this x
	274	if( global_boolsparsity ) n_sweep = f.SparseHessian(
	275	x, w, bool_sparsity, row, col, hessian, work
	276	);
	277	else n_sweep = f.SparseHessian(
	278	x, w, set_sparsity, row, col, hessian, work
	279	);
	280	}
	281	}
	282	return true;
286	283	}
287	284	</pre></font></code>
288	285
289
290	286	<hr/>Input File: speed/cppad/sparse_hessian.cpp
291	287
292	288	</body>

+140

-144

doc/cppad_sparse_jacobian.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>CppAD Speed: Sparse Jacobian</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

113	110
114	111	// Note that CppAD uses global_memory at the main program level
115	112	extern bool
116		global_onetape, global_colpack,
117		global_atomic, global_optimize, global_boolsparsity;
	113	global_onetape, global_colpack,
	114	global_atomic, global_optimize, global_boolsparsity;
118	115
119	116	namespace {
120		using CppAD::vector;
121		typedef vector< std::set<size_t> > SetVector;
122		typedef vector<bool> BoolVector;
123
124		void calc_sparsity(SetVector& sparsity_set, CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double>& f)
125		{ size_t n = f.Domain();
126		SetVector r_set(n);
127		for(size_t j = 0; j < n; j++)
128		r_set[j].insert(j);
129		sparsity_set = f.ForSparseJac(n, r_set);
130		}
131		void calc_sparsity(BoolVector& sparsity_bool, CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double>& f)
132		{ size_t n = f.Domain();
133		BoolVector r_bool(n * n);
134		size_t i, j;
135		for(i = 0; i < n; i++)
136		{ for(j = 0; j < n; j++)
137		r_bool[ i * n + j] = false;
138		r_bool[ i * n + i] = true;
139		}
140		sparsity_bool = f.ForSparseJac(n, r_bool);
141		}
	117	using CppAD::vector;
	118	typedef vector< std::set<size_t> > SetVector;
	119	typedef vector<bool> BoolVector;
	120
	121	void calc_sparsity(SetVector& sparsity_set, CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double>& f)
	122	{ size_t n = f.Domain();
	123	SetVector r_set(n);
	124	for(size_t j = 0; j < n; j++)
	125	r_set[j].insert(j);
	126	sparsity_set = f.ForSparseJac(n, r_set);
	127	}
	128	void calc_sparsity(BoolVector& sparsity_bool, CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double>& f)
	129	{ size_t n = f.Domain();
	130	BoolVector r_bool(n * n);
	131	size_t i, j;
	132	for(i = 0; i < n; i++)
	133	{ for(j = 0; j < n; j++)
	134	r_bool[ i * n + j] = false;
	135	r_bool[ i * n + i] = true;
	136	}
	137	sparsity_bool = f.ForSparseJac(n, r_bool);
	138	}
142	139
143	140	}
144	141
145	142	bool link_sparse_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 )
	143	size_t size ,
	144	size_t repeat ,
	145	size_t m ,
	146	const CppAD::vector<size_t>& row ,
	147	const CppAD::vector<size_t>& col ,
	148	CppAD::vector<double>& x ,
	149	CppAD::vector<double>& jacobian ,
	150	size_t& n_sweep )
154	151	{
155		if( global_atomic )
156		return false;
	152	if( global_atomic )
	153	return false;
157	154	# ifndef CPPAD_COLPACK_SPEED
158		if( global_colpack )
159		return false;
	155	if( global_colpack )
	156	return false;
160	157	# endif
161		// -----------------------------------------------------
162		// setup
163		typedef vector< std::set<size_t> > SetVector;
164		typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
165		typedef CppAD::vector<ADScalar> ADVector;
166
167		size_t j;
168		size_t order = 0; // derivative order corresponding to function
169		size_t n = size; // number of independent variables
170		ADVector a_x(n); // AD domain space vector
171		ADVector a_y(m); // AD range space vector y = g(x)
172		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function object
173
174		// declare sparsity pattern
175		SetVector set_sparsity(m);
176		BoolVector bool_sparsity(m * n);
177
178		// ------------------------------------------------------
179		if( ! global_onetape ) while(repeat--)
180		{ // choose a value for x
181		CppAD::uniform_01(n, x);
182		for(j = 0; j < n; j++)
183		a_x[j] = x[j];
184
185		// declare independent variables
186		<a href="independent.xml" target="_top">Independent</a>(a_x);
187
188		// AD computation of f (x)
189		CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
190
191		// create function object f : X -> Y
192		f.Dependent(a_x, a_y);
193
194		if( global_optimize )
195		f.optimize();
196
197		// skip comparison operators
198		f.compare_change_count(0);
199
200		// calculate the Jacobian sparsity pattern for this function
201		if( global_boolsparsity )
202		calc_sparsity(bool_sparsity, f);
203		else
204		calc_sparsity(set_sparsity, f);
205
206		// structure that holds some of the work done by SparseJacobian
207		CppAD::sparse_jacobian_work work;
	158	// -----------------------------------------------------
	159	// setup
	160	typedef vector< std::set<size_t> > SetVector;
	161	typedef CppAD::<a href="ad.xml" target="_top">AD</a><double> ADScalar;
	162	typedef CppAD::vector<ADScalar> ADVector;
	163
	164	size_t j;
	165	size_t order = 0; // derivative order corresponding to function
	166	size_t n = size; // number of independent variables
	167	ADVector a_x(n); // AD domain space vector
	168	ADVector a_y(m); // AD range space vector y = g(x)
	169	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f; // AD function object
	170
	171	// declare sparsity pattern
	172	SetVector set_sparsity(m);
	173	BoolVector bool_sparsity(m * n);
	174
	175	// ------------------------------------------------------
	176	if( ! global_onetape ) while(repeat--)
	177	{ // choose a value for x
	178	CppAD::uniform_01(n, x);
	179	for(j = 0; j < n; j++)
	180	a_x[j] = x[j];
	181
	182	// declare independent variables
	183	<a href="independent.xml" target="_top">Independent</a>(a_x);
	184
	185	// AD computation of f (x)
	186	CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
	187
	188	// create function object f : X -> Y
	189	f.Dependent(a_x, a_y);
	190
	191	if( global_optimize )
	192	f.optimize();
	193
	194	// skip comparison operators
	195	f.compare_change_count(0);
	196
	197	// calculate the Jacobian sparsity pattern for this function
	198	if( global_boolsparsity )
	199	calc_sparsity(bool_sparsity, f);
	200	else
	201	calc_sparsity(set_sparsity, f);
	202
	203	// structure that holds some of the work done by SparseJacobian
	204	CppAD::sparse_jacobian_work work;
208	205	# ifdef CPPAD_COLPACK_SPEED
209		if( global_colpack )
210		work.color_method = "colpack";
	206	if( global_colpack )
	207	work.color_method = "colpack";
211	208	# endif
212		// calculate the Jacobian at this x
213		// (use forward mode because m > n ?)
214		if( global_boolsparsity) n_sweep = f.SparseJacobianForward(
215		x, bool_sparsity, row, col, jacobian, work
216		);
217		else n_sweep = f.SparseJacobianForward(
218		x, set_sparsity, row, col, jacobian, work
219		);
220		}
221		else
222		{ // choose a value for x
223		CppAD::uniform_01(n, x);
224		for(j = 0; j < n; j++)
225		a_x[j] = x[j];
226
227		// declare independent variables
228		<a href="independent.xml" target="_top">Independent</a>(a_x);
229
230		// AD computation of f (x)
231		CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
232
233		// create function object f : X -> Y
234		f.Dependent(a_x, a_y);
235
236		if( global_optimize )
237		f.optimize();
238
239		// skip comparison operators
240		f.compare_change_count(0);
241
242		// calculate the Jacobian sparsity pattern for this function
243		if( global_boolsparsity )
244		calc_sparsity(bool_sparsity, f);
245		else
246		calc_sparsity(set_sparsity, f);
247
248		// structure that holds some of the work done by SparseJacobian
249		CppAD::sparse_jacobian_work work;
	209	// calculate the Jacobian at this x
	210	// (use forward mode because m > n ?)
	211	if( global_boolsparsity) n_sweep = f.SparseJacobianForward(
	212	x, bool_sparsity, row, col, jacobian, work
	213	);
	214	else n_sweep = f.SparseJacobianForward(
	215	x, set_sparsity, row, col, jacobian, work
	216	);
	217	}
	218	else
	219	{ // choose a value for x
	220	CppAD::uniform_01(n, x);
	221	for(j = 0; j < n; j++)
	222	a_x[j] = x[j];
	223
	224	// declare independent variables
	225	<a href="independent.xml" target="_top">Independent</a>(a_x);
	226
	227	// AD computation of f (x)
	228	CppAD::sparse_jac_fun<ADScalar>(m, n, a_x, row, col, order, a_y);
	229
	230	// create function object f : X -> Y
	231	f.Dependent(a_x, a_y);
	232
	233	if( global_optimize )
	234	f.optimize();
	235
	236	// skip comparison operators
	237	f.compare_change_count(0);
	238
	239	// calculate the Jacobian sparsity pattern for this function
	240	if( global_boolsparsity )
	241	calc_sparsity(bool_sparsity, f);
	242	else
	243	calc_sparsity(set_sparsity, f);
	244
	245	// structure that holds some of the work done by SparseJacobian
	246	CppAD::sparse_jacobian_work work;
250	247	# ifdef CPPAD_COLPACK_SPEED
251		if( global_colpack )
252		work.color_method = "colpack";
	248	if( global_colpack )
	249	work.color_method = "colpack";
253	250	# endif
254		while(repeat--)
255		{ // choose a value for x
256		CppAD::uniform_01(n, x);
257
258		// calculate the Jacobian at this x
259		// (use forward mode because m > n ?)
260		if( global_boolsparsity ) n_sweep = f.SparseJacobianForward(
261		x, bool_sparsity, row, col, jacobian, work
262		);
263		else n_sweep = f.SparseJacobianForward(
264		x, set_sparsity, row, col, jacobian, work
265		);
266		}
267		}
268		return true;
	251	while(repeat--)
	252	{ // choose a value for x
	253	CppAD::uniform_01(n, x);
	254
	255	// calculate the Jacobian at this x
	256	// (use forward mode because m > n ?)
	257	if( global_boolsparsity ) n_sweep = f.SparseJacobianForward(
	258	x, bool_sparsity, row, col, jacobian, work
	259	);
	260	else n_sweep = f.SparseJacobianForward(
	261	x, set_sparsity, row, col, jacobian, work
	262	);
	263	}
	264	}
	265	return true;
269	266	}
270	267	</pre></font></code>
271	268
272
273	269	<hr/>Input File: speed/cppad/sparse_jacobian.cpp
274	270
275	271	</body>

+1

-4

doc/cppad_vector.cpp.xml less more

5	5	<title>CppAD::vector Template Class: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD::vector Template Class: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" cppad::vector template class: example and test vector Cppad "/>
	8	<meta name="keywords" id="keywords" content=" cppad::vector template class: example test vector Cppad "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

97	97	<td>cppad_vector.cpp</td>
98	98	<td>Headings</td>
99	99	</tr></table><br/>
100
101
102
103	100	<center><b><big><big>CppAD::vector Template Class: Example and Test</big></big></b></center>
104	101	<code><font color="blue"><pre style='display:inline'>
105	102

+6

-8

doc/cppad_vector.xml less more

5	5	<title>The CppAD::vector Template Class</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The CppAD::vector Template Class"/>
8		<meta name="keywords" id="keywords" content=" the cppad::vector template class vector Cppad [] push thread_alloc syntax description include capacity assignment check size return reference move semantics element access push_back push_vector output resize clear data vectorbool memory bit_per_unit type and parallel mode example exercise "/>
	8	<meta name="keywords" id="keywords" content=" the cppad::vector template class vector Cppad [] push thread_alloc syntax description include capacity assignment check size return reference move semantics element access push_back push_vector output resize clear data vectorbool memory bit_per_unit type parallel mode example exercise "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

653	653	<br/>
654	654	Create and run a program that contains the following code:
655	655	<code><font color='blue'><pre style='display:inline'>
656		CppAD::vector<double> x(3);
657		size_t i;
658		for(i = 0; i < 3; i++)
659		x[i] = 4. - i;
660		std::cout << "x = " << x << std::endl;
	656	CppAD::vector<double> x(3);
	657	size_t i;
	658	for(i = 0; i < 3; i++)
	659	x[i] = 4. - i;
	660	std::cout << "x = " << x << std::endl;
661	661	</pre></font></code>
662
663
664	662
665	663	<hr/>Input File: cppad/utility/vector.hpp
666	664

+1

-1

doc/dependency.cpp.xml less more

5	5	<title>Computing Dependency: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Computing Dependency: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" computing dependency: example and test discussion dependency pattern "/>
	8	<meta name="keywords" id="keywords" content=" computing dependency: example test discussion dependency pattern "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/dependent.xml less more

5	5	<title>Stop Recording and Store Operation Sequence</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Stop Recording and Store Operation Sequence"/>
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	<meta name="keywords" id="keywords" content=" stop recording store operation sequence Adfun tape Dependent syntax purpose f x y advector taping forward parallel mode example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/det_33.xml less more

5	5	<title>Check Determinant of 3 by 3 matrix</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Check Determinant of 3 by 3 matrix"/>
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	<meta name="keywords" id="keywords" content=" check determinant 3 matrix det_33 correct syntax purpose inclusion x d vector ok source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/det_by_lu.cpp.xml less more

5	5	<title>Determinant Using Lu Factorization: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determinant Using Lu Factorization: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" determinant using lu factorization: example and test minors "/>
	8	<meta name="keywords" id="keywords" content=" determinant using lu factorization: example test minors "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/det_by_lu.xml less more

5	5	<title>Determinant Using Expansion by Lu Factorization</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determinant Using Expansion by Lu Factorization"/>
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	<meta name="keywords" id="keywords" content=" determinant using expansion lu factorization det_by_lu factor syntax inclusion constructor scalar n det d vector example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/det_by_minor.cpp.xml less more

5	5	<title>Determinant Using Expansion by Minors: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determinant Using Expansion by Minors: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" determinant using expansion by minors: example and test minors "/>
	8	<meta name="keywords" id="keywords" content=" determinant using expansion minors: example test minors "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/det_by_minor.xml less more

5	5	<title>Determinant Using Expansion by Minors</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determinant Using Expansion by Minors"/>
8		<meta name="keywords" id="keywords" content=" determinant using expansion by minors syntax inclusion constructor scalar n det a d vector example source code "/>
	8	<meta name="keywords" id="keywords" content=" determinant using expansion minors syntax inclusion constructor scalar n det d vector example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+20

-24

doc/det_by_minor_c.xml less more

5	5	<title>Compute Determinant using Expansion by Minors</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Compute Determinant using Expansion by Minors"/>
8		<meta name="keywords" id="keywords" content=" compute determinant using expansion by minors syntax purpose a m source code "/>
	8	<meta name="keywords" id="keywords" content=" compute determinant using expansion minors syntax purpose m source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

99	99	</select>
100	100	</td>
101	101	</tr></table><br/>
102
103
104
105	102	<center><b><big><big>Compute Determinant using Expansion by Minors</big></big></b></center>
106	103	<br/>
107	104	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

284	281
285	282	<code><font color='blue'><pre style='display:inline'>
286	283	double det_by_minor(double* a, size_t m)
287		{ size_t r, c, i;
288		double value;
289
290		r = (size_t) malloc( (m+1) sizeof(size_t) );
291		c = (size_t) malloc( (m+1) sizeof(size_t) );
292
293		assert(m <= 100);
294		for(i = 0; i < m; i++)
295		{ r[i] = i+1;
296		c[i] = i+1;
297		}
298		r[m] = 0;
299		c[m] = 0;
300
301		value = <a href="det_of_minor_c.xml" target="_top">det_of_minor</a>(a, m, m, r, c);
302
303		free(r);
304		free(c);
305		return value;
	284	{ size_t r, c, i;
	285	double value;
	286
	287	r = (size_t) malloc( (m+1) sizeof(size_t) );
	288	c = (size_t) malloc( (m+1) sizeof(size_t) );
	289
	290	assert(m <= 100);
	291	for(i = 0; i < m; i++)
	292	{ r[i] = i+1;
	293	c[i] = i+1;
	294	}
	295	r[m] = 0;
	296	c[m] = 0;
	297
	298	value = <a href="det_of_minor_c.xml" target="_top">det_of_minor</a>(a, m, m, r, c);
	299
	300	free(r);
	301	free(c);
	302	return value;
306	303	}
307	304	</pre></font></code>
308
309	305
310	306	<hr/>Input File: compare_c/det_by_minor.c
311	307

+1

-1

doc/det_grad_33.xml less more

5	5	<title>Check Gradient of Determinant of 3 by 3 matrix</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Check Gradient of Determinant of 3 by 3 matrix"/>
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	<meta name="keywords" id="keywords" content=" check gradient determinant 3 matrix det_grad_33 correct syntax purpose inclusion x g vector ok source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/det_of_minor.cpp.xml less more

5	5	<title>Determinant of a Minor: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determinant of a Minor: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" determinant of a minor: example and test det_of_minor "/>
	8	<meta name="keywords" id="keywords" content=" determinant minor: example test det_of_minor "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/det_of_minor.xml less more

5	5	<title>Determinant of a Minor</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determinant of a Minor"/>
8		<meta name="keywords" id="keywords" content=" determinant of a minor det_of_minor matrix syntax inclusion purpose m n r c d scalar example source code "/>
	8	<meta name="keywords" id="keywords" content=" determinant minor det_of_minor matrix syntax inclusion purpose m n r c d scalar example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+56

-57

doc/det_of_minor_c.xml less more

5	5	<title>Determinant of a Minor</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determinant of a Minor"/>
8		<meta name="keywords" id="keywords" content=" determinant of a minor syntax purpose m n r c d source code "/>
	8	<meta name="keywords" id="keywords" content=" determinant minor syntax purpose m n r c d source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

671	671
672	672	<code><font color='blue'><pre style='display:inline'>
673	673	double det_of_minor(
674		const double* a ,
675		size_t m ,
676		size_t n ,
677		size_t* r ,
678		size_t* c )
679		{ size_t R0, Cj, Cj1, j;
680		double detM, M0j, detS;
681		int s;
682
683		R0 = r[m]; /* R(0) */
684		Cj = c[m]; /* C(j) (case j = 0) */
685		Cj1 = m; /* C(j-1) (case j = 0) */
686
687		/* check for 1 by 1 case */
688		if( n == 1 ) return a[ R0 * m + Cj ];
689
690		/* initialize determinant of the minor M */
691		detM = 0.;
692
693		/* initialize sign of factor for neat sub-minor */
694		s = 1;
695
696		/* remove row with index 0 in M from all the sub-minors of M */
697		r[m] = r[R0];
698
699		/* for each column of M */
700		for(j = 0; j < n; j++)
701		{ /* element with index (0,j) in the minor M */
702		M0j = a[ R0 * m + Cj ];
703
704		/* remove column with index j in M to form next sub-minor S of M */
705		c[Cj1] = c[Cj];
706
707		/* compute determinant of the current sub-minor S */
708		detS = det_of_minor(a, m, n - 1, r, c);
709
710		/* restore column Cj to representation of M as a minor of A */
711		c[Cj1] = Cj;
712
713		/* include this sub-minor term in the summation */
714		if( s > 0 )
715		detM = detM + M0j * detS;
716		else detM = detM - M0j * detS;
717
718		/* advance to neat column of M */
719		Cj1 = Cj;
720		Cj = c[Cj];
721		s = - s;
722		}
723
724		/* restore row zero to the minor representation for M */
725		r[m] = R0;
726
727		/* return the determinant of the minor M */
728		return detM;
	674	const double* a ,
	675	size_t m ,
	676	size_t n ,
	677	size_t* r ,
	678	size_t* c )
	679	{ size_t R0, Cj, Cj1, j;
	680	double detM, M0j, detS;
	681	int s;
	682
	683	R0 = r[m]; /* R(0) */
	684	Cj = c[m]; /* C(j) (case j = 0) */
	685	Cj1 = m; /* C(j-1) (case j = 0) */
	686
	687	/* check for 1 by 1 case */
	688	if( n == 1 ) return a[ R0 * m + Cj ];
	689
	690	/* initialize determinant of the minor M */
	691	detM = 0.;
	692
	693	/* initialize sign of factor for neat sub-minor */
	694	s = 1;
	695
	696	/* remove row with index 0 in M from all the sub-minors of M */
	697	r[m] = r[R0];
	698
	699	/* for each column of M */
	700	for(j = 0; j < n; j++)
	701	{ /* element with index (0,j) in the minor M */
	702	M0j = a[ R0 * m + Cj ];
	703
	704	/* remove column with index j in M to form next sub-minor S of M */
	705	c[Cj1] = c[Cj];
	706
	707	/* compute determinant of the current sub-minor S */
	708	detS = det_of_minor(a, m, n - 1, r, c);
	709
	710	/* restore column Cj to representation of M as a minor of A */
	711	c[Cj1] = Cj;
	712
	713	/* include this sub-minor term in the summation */
	714	if( s > 0 )
	715	detM = detM + M0j * detS;
	716	else detM = detM - M0j * detS;
	717
	718	/* advance to neat column of M */
	719	Cj1 = Cj;
	720	Cj = c[Cj];
	721	s = - s;
	722	}
	723
	724	/* restore row zero to the minor representation for M */
	725	r[m] = R0;
	726
	727	/* return the determinant of the minor M */
	728	return detM;
729	729	}
730	730	</pre></font></code>
731	731
732
733	732	<hr/>Input File: compare_c/det_by_minor.c
734	733
735	734	</body>

+1

-1

doc/div.cpp.xml less more

5	5	<title>AD Binary Division: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Binary Division: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad binary division: example and test / divide quotient "/>
	8	<meta name="keywords" id="keywords" content=" ad binary division: example test / divide quotient "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/div_eq.cpp.xml less more

5	5	<title>AD Computed Assignment Division: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Computed Assignment Division: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad computed assignment division: example and test /= divide assign plus add "/>
	8	<meta name="keywords" id="keywords" content=" ad computed assignment division: example test /= divide assign plus add "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+19

-23

doc/double_det_lu.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Double Speed: Determinant Using Lu Factorization</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

112	109
113	110	// Note that CppAD uses global_memory at the main program level
114	111	extern bool
115		global_onetape, global_atomic, global_optimize;
	112	global_onetape, global_atomic, global_optimize;
116	113
117	114	bool link_det_lu(
118		size_t size ,
119		size_t repeat ,
120		CppAD::vector<double> &matrix ,
121		CppAD::vector<double> &det )
	115	size_t size ,
	116	size_t repeat ,
	117	CppAD::vector<double> &matrix ,
	118	CppAD::vector<double> &det )
122	119	{
123		if(global_onetape\|\|global_atomic\|\|global_optimize)
124		return false;
125		// -----------------------------------------------------
126		// setup
127		CppAD::det_by_lu<double> Det(size);
128		size_t n = size * size; // number of independent variables
	120	if(global_onetape\|\|global_atomic\|\|global_optimize)
	121	return false;
	122	// -----------------------------------------------------
	123	// setup
	124	CppAD::det_by_lu<double> Det(size);
	125	size_t n = size * size; // number of independent variables
129	126
130		// ------------------------------------------------------
	127	// ------------------------------------------------------
131	128
132		while(repeat--)
133		{ // get the next matrix
134		CppAD::uniform_01(n, matrix);
	129	while(repeat--)
	130	{ // get the next matrix
	131	CppAD::uniform_01(n, matrix);
135	132
136		// computation of the determinant
137		det[0] = Det(matrix);
138		}
139		return true;
	133	// computation of the determinant
	134	det[0] = Det(matrix);
	135	}
	136	return true;
140	137	}
141	138	</pre></font></code>
142
143	139
144	140	<hr/>Input File: speed/double/det_lu.cpp
145	141

+20

-21

doc/double_det_minor.cpp.xml less more

5	5	<title>Double Speed: Determinant by Minor Expansion</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Double Speed: Determinant by Minor Expansion"/>
8		<meta name="keywords" id="keywords" content=" double speed: determinant by minor expansion link_det_minor speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" double speed: determinant minor expansion link_det_minor speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

110	110
111	111	// Note that CppAD uses global_memory at the main program level
112	112	extern bool
113		global_onetape, global_atomic, global_optimize;
	113	global_onetape, global_atomic, global_optimize;
114	114
115	115	bool link_det_minor(
116		size_t size ,
117		size_t repeat ,
118		CppAD::vector<double> &matrix ,
119		CppAD::vector<double> &det )
	116	size_t size ,
	117	size_t repeat ,
	118	CppAD::vector<double> &matrix ,
	119	CppAD::vector<double> &det )
120	120	{
121		if(global_onetape\|\|global_atomic\|\|global_optimize)
122		return false;
123		// -----------------------------------------------------
124		// setup
125		CppAD::det_by_minor<double> Det(size);
126		size_t n = size * size; // number of independent variables
	121	if(global_onetape\|\|global_atomic\|\|global_optimize)
	122	return false;
	123	// -----------------------------------------------------
	124	// setup
	125	CppAD::det_by_minor<double> Det(size);
	126	size_t n = size * size; // number of independent variables
127	127
128		// ------------------------------------------------------
129		while(repeat--)
130		{ // get the next matrix
131		CppAD::uniform_01(n, matrix);
	128	// ------------------------------------------------------
	129	while(repeat--)
	130	{ // get the next matrix
	131	CppAD::uniform_01(n, matrix);
132	132
133		// computation of the determinant
134		det[0] = Det(matrix);
135		}
136		return true;
	133	// computation of the determinant
	134	det[0] = Det(matrix);
	135	}
	136	return true;
137	137	}
138	138	</pre></font></code>
139
140	139
141	140	<hr/>Input File: speed/double/det_minor.cpp
142	141

+18

-22

doc/double_mat_mul.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>CppAD Speed: Matrix Multiplication (Double Version)</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

112	109
113	110	// Note that CppAD uses global_memory at the main program level
114	111	extern bool
115		global_onetape, global_atomic, global_optimize;
	112	global_onetape, global_atomic, global_optimize;
116	113
117	114	bool link_mat_mul(
118		size_t size ,
119		size_t repeat ,
120		CppAD::vector<double>& x ,
121		CppAD::vector<double>& z ,
122		CppAD::vector<double>& dz
	115	size_t size ,
	116	size_t repeat ,
	117	CppAD::vector<double>& x ,
	118	CppAD::vector<double>& z ,
	119	CppAD::vector<double>& dz
123	120	)
124	121	{
125		if(global_onetape\|\|global_atomic\|\|global_optimize)
126		return false;
127		// -----------------------------------------------------
128		size_t n = size * size; // number of independent variables
129		CppAD::vector<double> y(n);
	122	if(global_onetape\|\|global_atomic\|\|global_optimize)
	123	return false;
	124	// -----------------------------------------------------
	125	size_t n = size * size; // number of independent variables
	126	CppAD::vector<double> y(n);
130	127
131		while(repeat--)
132		{ // get the next matrix
133		CppAD::uniform_01(n, x);
	128	while(repeat--)
	129	{ // get the next matrix
	130	CppAD::uniform_01(n, x);
134	131
135		// do computation
136		mat_sum_sq(size, x, y, z);
	132	// do computation
	133	mat_sum_sq(size, x, y, z);
137	134
138		}
139		return true;
	135	}
	136	return true;
140	137	}
141	138	</pre></font></code>
142
143	139
144	140	<hr/>Input File: speed/double/mat_mul.cpp
145	141

+23

-27

doc/double_ode.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Double Speed: Ode Solution</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

114	111
115	112	// Note that CppAD uses global_memory at the main program level
116	113	extern bool
117		global_onetape, global_atomic, global_optimize;
	114	global_onetape, global_atomic, global_optimize;
118	115
119	116	bool link_ode(
120		size_t size ,
121		size_t repeat ,
122		CppAD::vector<double> &x ,
123		CppAD::vector<double> &jacobian
	117	size_t size ,
	118	size_t repeat ,
	119	CppAD::vector<double> &x ,
	120	CppAD::vector<double> &jacobian
124	121	)
125	122	{
126		if(global_onetape\|\|global_atomic\|\|global_optimize)
127		return false;
128		// -------------------------------------------------------------
129		// setup
130		assert( x.size() == size );
	123	if(global_onetape\|\|global_atomic\|\|global_optimize)
	124	return false;
	125	// -------------------------------------------------------------
	126	// setup
	127	assert( x.size() == size );
131	128
132		size_t n = size;
	129	size_t n = size;
133	130
134		size_t m = 0;
135		CppAD::vector<double> f(n);
	131	size_t m = 0;
	132	CppAD::vector<double> f(n);
136	133
137		while(repeat--)
138		{ // choose next x value
139		uniform_01(n, x);
	134	while(repeat--)
	135	{ // choose next x value
	136	uniform_01(n, x);
140	137
141		// evaluate function
142		CppAD::ode_evaluate(x, m, f);
	138	// evaluate function
	139	CppAD::ode_evaluate(x, m, f);
143	140
144		}
145		size_t i;
146		for(i = 0; i < n; i++)
147		jacobian[i] = f[i];
148		return true;
	141	}
	142	size_t i;
	143	for(i = 0; i < n; i++)
	144	jacobian[i] = f[i];
	145	return true;
149	146	}
150	147	</pre></font></code>
151
152	148
153	149	<hr/>Input File: speed/double/ode.cpp
154	150

+19

-23

doc/double_poly.cpp.xml less more

5	5	<title>Double Speed: Evaluate a Polynomial</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Double Speed: Evaluate a Polynomial"/>
8		<meta name="keywords" id="keywords" content=" double speed: evaluate a polynomial link_poly speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" double speed: evaluate polynomial link_poly speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Double Speed: Evaluate a Polynomial</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

112	109
113	110	// Note that CppAD uses global_memory at the main program level
114	111	extern bool
115		global_onetape, global_atomic, global_optimize;
	112	global_onetape, global_atomic, global_optimize;
116	113
117	114	bool link_poly(
118		size_t size ,
119		size_t repeat ,
120		CppAD::vector<double> &a , // coefficients of polynomial
121		CppAD::vector<double> &z , // polynomial argument value
122		CppAD::vector<double> &p ) // second derivative w.r.t z
	115	size_t size ,
	116	size_t repeat ,
	117	CppAD::vector<double> &a , // coefficients of polynomial
	118	CppAD::vector<double> &z , // polynomial argument value
	119	CppAD::vector<double> &p ) // second derivative w.r.t z
123	120	{
124		if(global_onetape\|\|global_atomic\|\|global_optimize)
125		return false;
126		// -----------------------------------------------------
127		// setup
	121	if(global_onetape\|\|global_atomic\|\|global_optimize)
	122	return false;
	123	// -----------------------------------------------------
	124	// setup
128	125
129		// ------------------------------------------------------
130		while(repeat--)
131		{ // get the next argument value
132		CppAD::uniform_01(1, z);
	126	// ------------------------------------------------------
	127	while(repeat--)
	128	{ // get the next argument value
	129	CppAD::uniform_01(1, z);
133	130
134		// evaluate the polynomial at the new argument value
135		p[0] = CppAD::Poly(0, a, z[0]);
136		}
137		return true;
	131	// evaluate the polynomial at the new argument value
	132	p[0] = CppAD::Poly(0, a, z[0]);
	133	}
	134	return true;
138	135	}
139	136	</pre></font></code>
140
141	137
142	138	<hr/>Input File: speed/double/poly.cpp
143	139

+27

-31

doc/double_sparse_hessian.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Double Speed: Sparse Hessian</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

113	110
114	111	// Note that CppAD uses global_memory at the main program level
115	112	extern bool
116		global_onetape, global_atomic, global_optimize, global_boolsparsity;
	113	global_onetape, global_atomic, global_optimize, global_boolsparsity;
117	114
118	115	bool link_sparse_hessian(
119		size_t size ,
120		size_t repeat ,
121		const CppAD::vector<size_t>& row ,
122		const CppAD::vector<size_t>& col ,
123		CppAD::vector<double>& x ,
124		CppAD::vector<double>& hessian ,
125		size_t& n_sweep )
	116	size_t size ,
	117	size_t repeat ,
	118	const CppAD::vector<size_t>& row ,
	119	const CppAD::vector<size_t>& col ,
	120	CppAD::vector<double>& x ,
	121	CppAD::vector<double>& hessian ,
	122	size_t& n_sweep )
126	123	{
127		if(global_onetape\|\|global_atomic\|\|global_optimize\|\|global_boolsparsity)
128		return false;
129		// -----------------------------------------------------
130		// setup
131		using CppAD::vector;
132		size_t order = 0; // derivative order corresponding to function
133		size_t n = size; // argument space dimension
134		size_t m = 1; // range space dimension
135		vector<double> y(m); // function value
	124	if(global_onetape\|\|global_atomic\|\|global_optimize\|\|global_boolsparsity)
	125	return false;
	126	// -----------------------------------------------------
	127	// setup
	128	using CppAD::vector;
	129	size_t order = 0; // derivative order corresponding to function
	130	size_t n = size; // argument space dimension
	131	size_t m = 1; // range space dimension
	132	vector<double> y(m); // function value
136	133
137		// choose a value for x
138		CppAD::uniform_01(n, x);
	134	// choose a value for x
	135	CppAD::uniform_01(n, x);
139	136
140		// ------------------------------------------------------
	137	// ------------------------------------------------------
141	138
142		while(repeat--)
143		{
144		// computation of the function
145		CppAD::sparse_hes_fun<double>(n, x, row, col, order, y);
146		}
147		hessian[0] = y[0];
	139	while(repeat--)
	140	{
	141	// computation of the function
	142	CppAD::sparse_hes_fun<double>(n, x, row, col, order, y);
	143	}
	144	hessian[0] = y[0];
148	145
149		return true;
	146	return true;
150	147	}
151	148	</pre></font></code>
152
153	149
154	150	<hr/>Input File: speed/double/sparse_hessian.cpp
155	151

+28

-32

doc/double_sparse_jacobian.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Double Speed: Sparse Jacobian</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

113	110
114	111	// Note that CppAD uses global_memory at the main program level
115	112	extern bool
116		global_onetape, global_atomic, global_optimize, global_boolsparsity;
	113	global_onetape, global_atomic, global_optimize, global_boolsparsity;
117	114
118	115	bool link_sparse_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 )
	116	size_t size ,
	117	size_t repeat ,
	118	size_t m ,
	119	const CppAD::vector<size_t>& row ,
	120	const CppAD::vector<size_t>& col ,
	121	CppAD::vector<double>& x ,
	122	CppAD::vector<double>& jacobian ,
	123	size_t& n_sweep )
127	124	{
128		if(global_onetape\|\|global_atomic\|\|global_optimize\|\|global_boolsparsity)
129		return false;
130		// -----------------------------------------------------
131		// setup
132		using CppAD::vector;
133		size_t i;
134		size_t order = 0; // order for computing function value
135		size_t n = size; // argument space dimension
136		vector<double> yp(m); // function value yp = f(x)
	125	if(global_onetape\|\|global_atomic\|\|global_optimize\|\|global_boolsparsity)
	126	return false;
	127	// -----------------------------------------------------
	128	// setup
	129	using CppAD::vector;
	130	size_t i;
	131	size_t order = 0; // order for computing function value
	132	size_t n = size; // argument space dimension
	133	vector<double> yp(m); // function value yp = f(x)
137	134
138		// ------------------------------------------------------
139		while(repeat--)
140		{ // choose a value for x
141		CppAD::uniform_01(n, x);
	135	// ------------------------------------------------------
	136	while(repeat--)
	137	{ // choose a value for x
	138	CppAD::uniform_01(n, x);
142	139
143		// computation of the function
144		CppAD::sparse_jac_fun<double>(m, n, x, row, col, order, yp);
145		}
146		for(i = 0; i < m; i++)
147		jacobian[i] = yp[i];
	140	// computation of the function
	141	CppAD::sparse_jac_fun<double>(m, n, x, row, col, order, yp);
	142	}
	143	for(i = 0; i < m; i++)
	144	jacobian[i] = yp[i];
148	145
149		return true;
	146	return true;
150	147	}
151	148	</pre></font></code>
152
153	149
154	150	<hr/>Input File: speed/double/sparse_jacobian.cpp
155	151

+4

-5

doc/download.xml less more

5	5	<title>Download The CppAD Source Code</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Download The CppAD Source Code"/>
8		<meta name="keywords" id="keywords" content=" download the cppad source code purpose distribution directory compressed archives current version release versions monthly unix file extraction windows and testing install instructions subversion limitations stable "/>
	8	<meta name="keywords" id="keywords" content=" download the cppad source code purpose distribution directory compressed archives current version release versions monthly unix file extraction windows testing install instructions subversion limitations stable "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

121	121
122	122	current </td><td align='left' valign='top'>
123	123	EPL </td><td align='left' valign='top'>
124		<a href="http://www.coin-or.org/download/source/CppAD/cppad-20160000.0.epl.tgz" target="_top"><span style='white-space: nowrap'>cppad-20160000.0.epl.tgz</span></a>
	124	<a href="http://www.coin-or.org/download/source/CppAD/cppad-20160000.1.epl.tgz" target="_top"><span style='white-space: nowrap'>cppad-20160000.1.epl.tgz</span></a>
125	125
126	126	</td></tr><tr><td align='left' valign='top'>
127	127
128	128	current </td><td align='left' valign='top'>
129	129	GPL </td><td align='left' valign='top'>
130		<a href="http://www.coin-or.org/download/source/CppAD/cppad-20160000.0.gpl.tgz" target="_top"><span style='white-space: nowrap'>cppad-20160000.0.gpl.tgz</span></a>
	130	<a href="http://www.coin-or.org/download/source/CppAD/cppad-20160000.1.gpl.tgz" target="_top"><span style='white-space: nowrap'>cppad-20160000.1.gpl.tgz</span></a>
131	131
132	132	</td></tr><tr><td align='left' valign='top'>
133	133

412	412	.
413	413	You will need to install the <code><font color="blue">omhelp</font></code> command so that
414	414	<code><font color='blue'><pre style='display:inline'>
415		which omhelp
	415	which omhelp
416	416	</pre></font></code>
417
418	417	shows it is in your path.
419	418	Once you have done this,
420	419	in the distribution directory execute the following command:

+1

-1

doc/drivers.xml less more

5	5	<title>First and Second Derivatives: Easy Drivers</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="First and Second Derivatives: Easy Drivers"/>
8		<meta name="keywords" id="keywords" content=" first and second derivatives: easy drivers forward reverse "/>
	8	<meta name="keywords" id="keywords" content=" first second derivatives: easy drivers forward reverse "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-4

doc/eigen_array.cpp.xml less more

5	5	<title>Using Eigen Arrays: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using Eigen Arrays: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" using eigen arrays: example and test array "/>
	8	<meta name="keywords" id="keywords" content=" using eigen arrays: example test array "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

83	83	<td>eigen_array.cpp</td>
84	84	<td>Headings</td>
85	85	</tr></table><br/>
86
87
88
89	86	<center><b><big><big>Using Eigen Arrays: Example and Test</big></big></b></center>
90	87	<code><font color="blue"><pre style='display:inline'>
91	88	# include <cppad/example/cppad_eigen.hpp>

+1

-1

doc/eigen_det.cpp.xml less more

5	5	<title>Using Eigen To Compute Determinant: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using Eigen To Compute Determinant: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" using eigen to compute determinant: example and test determinant "/>
	8	<meta name="keywords" id="keywords" content=" using eigen to compute determinant: example test determinant "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+3

-6

doc/eigen_plugin.hpp.xml less more

5	5	<title>Source Code for eigen_plugin.hpp</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Source Code for eigen_plugin.hpp"/>
8		<meta name="keywords" id="keywords" content=" source code for eigen_plugin.hpp "/>
	8	<meta name="keywords" id="keywords" content=" source code eigen_plugin.hpp "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

83	83	<td>eigen_plugin.hpp</td>
84	84	<td>Headings</td>
85	85	</tr></table><br/>
86
87
88
89	86	<center><b><big><big>Source Code for eigen_plugin.hpp</big></big></b></center>
90		<code><font color='blue'><pre style='display:inline'> // Declaration needed so an Eigen vector is a simple vector
	87	<code><font color='blue'><pre style='display:inline'>
	88	// Declaration needed so an Eigen vector is a simple vector
91	89	typedef Scalar value_type;
92	90	</pre></font></code>
93
94	91
95	92	<hr/>Input File: cppad/example/eigen_plugin.hpp
96	93

+1

-1

doc/eigen_prefix.xml less more

5	5	<title>Including the Eigen Examples and Tests</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Including the Eigen Examples and Tests"/>
8		<meta name="keywords" id="keywords" content=" including the eigen examples and tests prefix get purpose eigen_prefix test vector get_eigen "/>
	8	<meta name="keywords" id="keywords" content=" including the eigen examples tests prefix get purpose eigen_prefix test vector get_eigen "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/elapsed_seconds.cpp.xml less more

5	5	<title>Elapsed Seconds: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Elapsed Seconds: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" elapsed seconds: example and test seconds timer "/>
	8	<meta name="keywords" id="keywords" content=" elapsed seconds: example test seconds timer "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/elapsed_seconds.xml less more

5	5	<title>Returns Elapsed Number of Seconds</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Returns Elapsed Number of Seconds"/>
8		<meta name="keywords" id="keywords" content=" returns elapsed number of seconds elapsed_seconds time syntax purpose s microsoft systems example "/>
	8	<meta name="keywords" id="keywords" content=" returns elapsed number seconds elapsed_seconds time syntax purpose s microsoft systems example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+35

-39

doc/elapsed_seconds_c.xml less more

5	5	<title>Returns Elapsed Number of Seconds</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Returns Elapsed Number of Seconds"/>
8		<meta name="keywords" id="keywords" content=" returns elapsed number of seconds syntax purpose s source code "/>
	8	<meta name="keywords" id="keywords" content=" returns elapsed number seconds syntax purpose s source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

98	98	</select>
99	99	</td>
100	100	</tr></table><br/>
101
102
103
104	101	<center><b><big><big>Returns Elapsed Number of Seconds</big></big></b></center>
105	102	<br/>
106	103	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

136	133	# include <windows.h>
137	134	# include <cassert>
138	135	double elapsed_seconds(void)
139		{ static bool first_ = true;
140		static SYSTEMTIME st_;
141		double hour, minute, second, milli, diff;
142		SYSTEMTIME st;
	136	{ static bool first_ = true;
	137	static SYSTEMTIME st_;
	138	double hour, minute, second, milli, diff;
	139	SYSTEMTIME st;
143	140
144		if( first_ )
145		{ GetSystemTime(&st_);
146		first_ = false;
147		return 0.;
148		}
149		GetSystemTime(&st);
	141	if( first_ )
	142	{ GetSystemTime(&st_);
	143	first_ = false;
	144	return 0.;
	145	}
	146	GetSystemTime(&st);
150	147
151		hour = (double) st.wHour - (double) st_.wHour;
152		minute = (double) st.wMinute - (double) st_.wMinute;
153		second = (double) st.wSecond - (double) st_.wSecond;
154		milli = (double) st.wMilliseconds - (double) st_.wMilliseconds;
	148	hour = (double) st.wHour - (double) st_.wHour;
	149	minute = (double) st.wMinute - (double) st_.wMinute;
	150	second = (double) st.wSecond - (double) st_.wSecond;
	151	milli = (double) st.wMilliseconds - (double) st_.wMilliseconds;
155	152
156		diff = 1e-3milli + second + 60.minute + 3600.*hour;
157		if( diff < 0. )
158		diff += 3600.*24.;
159		assert( 0 <= diff && diff < 3600.*24. );
	153	diff = 1e-3milli + second + 60.minute + 3600.*hour;
	154	if( diff < 0. )
	155	diff += 3600.*24.;
	156	assert( 0 <= diff && diff < 3600.*24. );
160	157
161		return diff;
	158	return diff;
162	159	}
163	160	# else
164	161	// ---------------------------------------------------------------------------
165	162	// Unix version of timer
166	163	# include <sys/time.h>
167	164	double elapsed_seconds(void)
168		{ double sec, usec, diff;
	165	{ double sec, usec, diff;
169	166
170		static bool first_ = true;
171		static struct timeval tv_first;
172		struct timeval tv;
173		if( first_ )
174		{ gettimeofday(&tv_first, NULL);
175		first_ = false;
176		return 0.;
177		}
178		gettimeofday(&tv, NULL);
179		assert( tv.tv_sec >= tv_first.tv_sec );
	167	static bool first_ = true;
	168	static struct timeval tv_first;
	169	struct timeval tv;
	170	if( first_ )
	171	{ gettimeofday(&tv_first, NULL);
	172	first_ = false;
	173	return 0.;
	174	}
	175	gettimeofday(&tv, NULL);
	176	assert( tv.tv_sec >= tv_first.tv_sec );
180	177
181		sec = (double)(tv.tv_sec - tv_first.tv_sec);
182		usec = (double)tv.tv_usec - (double)tv_first.tv_usec;
183		diff = sec + 1e-6*usec;
	178	sec = (double)(tv.tv_sec - tv_first.tv_sec);
	179	usec = (double)tv.tv_usec - (double)tv_first.tv_usec;
	180	diff = sec + 1e-6*usec;
184	181
185		return diff;
	182	return diff;
186	183	}
187	184	# endif
188	185	</pre></font></code>
189
190	186
191	187	<hr/>Input File: compare_c/det_by_minor.c
192	188

+1

-1

doc/epsilon.xml less more

5	5	<title>Machine Epsilon For AD Types</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Machine Epsilon For AD Types"/>
8		<meta name="keywords" id="keywords" content=" machine epsilon for ad types deprecated 2012-06-17 syntax purpose float eps "/>
	8	<meta name="keywords" id="keywords" content=" machine epsilon ad types deprecated 2012-06-17 syntax purpose float eps "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/equal_op_seq.cpp.xml less more

5	5	<title>EqualOpSeq: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="EqualOpSeq: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" equalopseq: example and test Equalopseq "/>
	8	<meta name="keywords" id="keywords" content=" equalopseq: example test Equalopseq "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/erf.cpp.xml less more

5	5	<title>The AD erf Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD erf Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad erf function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad erf function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/error_handler.cpp.xml less more

5	5	<title>Replacing The CppAD Error Handler: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Replacing The CppAD Error Handler: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" replacing the cppad error handler: example and test handler "/>
	8	<meta name="keywords" id="keywords" content=" replacing the cppad error handler: example test handler "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/example.cpp.xml less more

5	5	<title>CppAD Examples and Tests</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD Examples and Tests"/>
8		<meta name="keywords" id="keywords" content=" cppad examples and tests running "/>
	8	<meta name="keywords" id="keywords" content=" cppad examples tests running "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/exampleutility.xml less more

5	5	<title>Utility Routines used by CppAD Examples</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Utility Routines used by CppAD Examples"/>
8		<meta name="keywords" id="keywords" content=" utility routines used by cppad examples "/>
	8	<meta name="keywords" id="keywords" content=" utility routines used cppad examples "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/exp.cpp.xml less more

5	5	<title>The AD exp Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD exp Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad exp function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad exp function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+2

-2

doc/exp_2.cpp.xml less more

92	92	# include "exp_2.hpp" // definition of exp_2 algorithm
93	93	bool exp_2(void)
94	94	{ double x = .5;
95		double check = 1 + x + x * x / 2.;
96		bool ok = std::fabs( exp_2(x) - check ) <= 1e-10;
	95	double check = 1 + x + x * x / 2.;
	96	bool ok = std::fabs( exp_2(x) - check ) <= 1e-10;
97	97	return ok;
98	98	}
99	99	</pre>

+4

-6

doc/exp_2.xml less more

353	353	<ol type="1"><li>
354	354	Suppose that we make the call
355	355	<code><font color='blue'><pre style='display:inline'>
356		double x = .1;
357		double y = exp_2(x);
	356	double x = .1;
	357	double y = exp_2(x);
358	358	</pre></font></code>
359
360	359	What is the value assigned to
361	360	<code><font color="blue">v1</font></code>, <code><font color="blue">v2</font></code>, ... ,<code><font color="blue">v5</font></code> in <a href="exp_2.hpp.xml" target="_top"><span style='white-space: nowrap'>exp_2.hpp</span></a>
362	361	?

389	388
390	389	Suppose that we make the call
391	390	<code><font color='blue'><pre style='display:inline'>
392		double x = .5;
393		double y = exp_3(x);
	391	double x = .5;
	392	double y = exp_3(x);
394	393	</pre></font></code>
395
396	394	using <code><font color="blue">exp_3</font></code> created in the previous problem.
397	395	What is the value assigned to the new variables in <code><font color="blue">exp_3</font></code>
398	396	(variables that are in <code><font color="blue">exp_3</font></code> and not in <code><font color="blue">exp_2</font></code>) ?

+66

-70

doc/exp_2_cppad.xml less more

5	5	<title>exp_2: CppAD Forward and Reverse Sweeps</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="exp_2: CppAD Forward and Reverse Sweeps"/>
8		<meta name="keywords" id="keywords" content=" exp_2: cppad forward and reverse sweeps purpose exercises "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: cppad forward reverse sweeps purpose exercises "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

89	89	</select>
90	90	</td>
91	91	</tr></table><br/>
92
93
94
95	92	<center><b><big><big>exp_2: CppAD Forward and Reverse Sweeps</big></big></b></center>
96	93	.
97	94

114	111	</mrow></math>
115	112
116	113	,
117		of the function
	114	of the function
118	115
119	116	<code><font color="blue"><span style='white-space: nowrap'><br/>
120	117	exp_2(</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>

141	138	<mn>.1</mn>
142	139	</mrow></math>
143	140
144
145		of the function
	141
	142	of the function
146	143
147	144	<code><font color="blue"><span style='white-space: nowrap'><br/>
148	145	exp_2(</span></font><i><font color="black"><span style='white-space: nowrap'>x</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>

198	195
199	196	<code><font color='blue'><pre style='display:inline'>
200	197
201		# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
	198	# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
202	199	# include "exp_2.hpp" // second order exponential approximation
203	200	bool exp_2_cppad(void)
204		{ bool ok = true;
205		using CppAD::AD;
206		using CppAD::vector; // can use any simple vector template class
207		using CppAD::NearEqual; // checks if values are nearly equal
208
209		// domain space vector
210		size_t n = 1; // dimension of the domain space
211		vector< <a href="ad.xml" target="_top">AD</a><double> > X(n);
212		X[0] = .5; // value of x for this operation sequence
213
214		// declare independent variables and start recording operation sequence
215		CppAD::<a href="independent.xml" target="_top">Independent</a>(X);
216
217		// evaluate our exponential approximation
218		<a href="ad.xml" target="_top">AD</a><double> x = X[0];
219		<a href="ad.xml" target="_top">AD</a><double> apx = exp_2(x);
220
221		// range space vector
222		size_t m = 1; // dimension of the range space
223		vector< <a href="ad.xml" target="_top">AD</a><double> > Y(m);
224		Y[0] = apx; // variable that represents only range space component
225
226		// Create f: X -> Y corresponding to this operation sequence
227		// and stop recording. This also executes a zero order forward
228		// sweep using values in X for x.
229		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(X, Y);
230
231		// first order forward sweep that computes
232		// partial of exp_2(x) with respect to x
233		vector<double> dx(n); // differential in domain space
234		vector<double> dy(m); // differential in range space
235		dx[0] = 1.; // direction for partial derivative
236		dy = f.<a href="forward.xml" target="_top">Forward</a>(1, dx);
237		double check = 1.5;
238		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0], check, 1e-10, 1e-10);
239
240		// first order reverse sweep that computes the derivative
241		vector<double> w(m); // weights for components of the range
242		vector<double> dw(n); // derivative of the weighted function
243		w[0] = 1.; // there is only one weight
244		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w); // derivative of w[0] * exp_2(x)
245		check = 1.5; // partial of exp_2(x) with respect to x
246		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0], check, 1e-10, 1e-10);
247
248		// second order forward sweep that computes
249		// second partial of exp_2(x) with respect to x
250		vector<double> x2(n); // second order Taylor coefficients
251		vector<double> y2(m);
252		x2[0] = 0.; // evaluate second partial .w.r.t. x
253		y2 = f.<a href="forward.xml" target="_top">Forward</a>(2, x2);
254		check = 0.5 * 1.; // Taylor coef is 1/2 second derivative
255		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y2[0], check, 1e-10, 1e-10);
256
257		// second order reverse sweep that computes
258		// derivative of partial of exp_2(x) w.r.t. x
259		dw.resize(2 * n); // space for first and second derivatives
260		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(2, w);
261		check = 1.; // result should be second derivative
262		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0*2+1], check, 1e-10, 1e-10);
263
264		return ok;
	201	{ bool ok = true;
	202	using CppAD::AD;
	203	using CppAD::vector; // can use any simple vector template class
	204	using CppAD::NearEqual; // checks if values are nearly equal
	205
	206	// domain space vector
	207	size_t n = 1; // dimension of the domain space
	208	vector< <a href="ad.xml" target="_top">AD</a><double> > X(n);
	209	X[0] = .5; // value of x for this operation sequence
	210
	211	// declare independent variables and start recording operation sequence
	212	CppAD::<a href="independent.xml" target="_top">Independent</a>(X);
	213
	214	// evaluate our exponential approximation
	215	<a href="ad.xml" target="_top">AD</a><double> x = X[0];
	216	<a href="ad.xml" target="_top">AD</a><double> apx = exp_2(x);
	217
	218	// range space vector
	219	size_t m = 1; // dimension of the range space
	220	vector< <a href="ad.xml" target="_top">AD</a><double> > Y(m);
	221	Y[0] = apx; // variable that represents only range space component
	222
	223	// Create f: X -> Y corresponding to this operation sequence
	224	// and stop recording. This also executes a zero order forward
	225	// sweep using values in X for x.
	226	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(X, Y);
	227
	228	// first order forward sweep that computes
	229	// partial of exp_2(x) with respect to x
	230	vector<double> dx(n); // differential in domain space
	231	vector<double> dy(m); // differential in range space
	232	dx[0] = 1.; // direction for partial derivative
	233	dy = f.<a href="forward.xml" target="_top">Forward</a>(1, dx);
	234	double check = 1.5;
	235	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0], check, 1e-10, 1e-10);
	236
	237	// first order reverse sweep that computes the derivative
	238	vector<double> w(m); // weights for components of the range
	239	vector<double> dw(n); // derivative of the weighted function
	240	w[0] = 1.; // there is only one weight
	241	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w); // derivative of w[0] * exp_2(x)
	242	check = 1.5; // partial of exp_2(x) with respect to x
	243	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0], check, 1e-10, 1e-10);
	244
	245	// second order forward sweep that computes
	246	// second partial of exp_2(x) with respect to x
	247	vector<double> x2(n); // second order Taylor coefficients
	248	vector<double> y2(m);
	249	x2[0] = 0.; // evaluate second partial .w.r.t. x
	250	y2 = f.<a href="forward.xml" target="_top">Forward</a>(2, x2);
	251	check = 0.5 * 1.; // Taylor coef is 1/2 second derivative
	252	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y2[0], check, 1e-10, 1e-10);
	253
	254	// second order reverse sweep that computes
	255	// derivative of partial of exp_2(x) w.r.t. x
	256	dw.resize(2 * n); // space for first and second derivatives
	257	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(2, w);
	258	check = 1.; // result should be second derivative
	259	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0*2+1], check, 1e-10, 1e-10);
	260
	261	return ok;
265	262	}
266	263
267	264	</pre></font></code>
268
269	265
270	266	<hr/>Input File: introduction/exp_apx/exp_2_cppad.cpp
271	267

+17

-17

doc/exp_2_for0.cpp.xml less more

78	78
79	79
80	80	<center><b><big><big>exp_2: Verify Zero Order Forward Sweep</big></big></b></center>
81		<code><font color='blue'><pre style='display:inline'> # include <cmath> // for fabs function
	81	<code><font color='blue'><pre style='display:inline'>
	82	# include <cmath> // for fabs function
82	83	bool exp_2_for0(double *v0) // double v0[6]
83		{ bool ok = true;
84		double x = .5;
	84	{ bool ok = true;
	85	double x = .5;
85	86
86		v0[1] = x; // v1 = x
87		ok &= std::fabs( v0[1] - 0.5) < 1e-10;
	87	v0[1] = x; // v1 = x
	88	ok &= std::fabs( v0[1] - 0.5) < 1e-10;
88	89
89		v0[2] = 1. + v0[1]; // v2 = 1 + v1
90		ok &= std::fabs( v0[2] - 1.5) < 1e-10;
	90	v0[2] = 1. + v0[1]; // v2 = 1 + v1
	91	ok &= std::fabs( v0[2] - 1.5) < 1e-10;
91	92
92		v0[3] = v0[1] * v0[1]; // v3 = v1 * v1
93		ok &= std::fabs( v0[3] - 0.25) < 1e-10;
	93	v0[3] = v0[1] * v0[1]; // v3 = v1 * v1
	94	ok &= std::fabs( v0[3] - 0.25) < 1e-10;
94	95
95		v0[4] = v0[3] / 2.; // v4 = v3 / 2
96		ok &= std::fabs( v0[4] - 0.125) < 1e-10;
	96	v0[4] = v0[3] / 2.; // v4 = v3 / 2
	97	ok &= std::fabs( v0[4] - 0.125) < 1e-10;
97	98
98		v0[5] = v0[2] + v0[4]; // v5 = v2 + v4
99		ok &= std::fabs( v0[5] - 1.625) < 1e-10;
	99	v0[5] = v0[2] + v0[4]; // v5 = v2 + v4
	100	ok &= std::fabs( v0[5] - 1.625) < 1e-10;
100	101
101		return ok;
	102	return ok;
102	103	}
103	104	bool exp_2_for0(void)
104		{ double v0[6];
105		return exp_2_for0(v0);
	105	{ double v0[6];
	106	return exp_2_for0(v0);
106	107	}
107	108	</pre></font></code>
108
109	109
110	110	<hr/>Input File: introduction/exp_apx/exp_2_for0.cpp
111	111

+1

-1

doc/exp_2_for0.xml less more

5	5	<title>exp_2: Operation Sequence and Zero Order Forward Mode</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="exp_2: Operation Sequence and Zero Order Forward Mode"/>
8		<meta name="keywords" id="keywords" content=" exp_2: operation sequence and zero order forward mode example mathematical form expansion index code sweep return value verification exercises "/>
	8	<meta name="keywords" id="keywords" content=" exp_2: operation sequence zero order forward mode example mathematical form expansion index code sweep return value verification exercises "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+19

-22

doc/exp_2_for1.cpp.xml less more

74	74	<td>exp_2_for1.cpp</td>
75	75	<td>Headings</td>
76	76	</tr></table><br/>
77
78
79
80	77	<center><b><big><big>exp_2: Verify First Order Forward Sweep</big></big></b></center>
81		<code><font color='blue'><pre style='display:inline'> # include <cmath> // prototype for fabs
	78	<code><font color='blue'><pre style='display:inline'>
	79	# include <cmath> // prototype for fabs
82	80	extern bool exp_2_for0(double *v0); // computes zero order forward sweep
83	81	bool exp_2_for1(double *v1) // double v1[6]
84		{ bool ok = true;
85		double v0[6];
	82	{ bool ok = true;
	83	double v0[6];
86	84
87		// set the value of v0[j] for j = 1 , ... , 5
88		ok &= exp_2_for0(v0);
	85	// set the value of v0[j] for j = 1 , ... , 5
	86	ok &= exp_2_for0(v0);
89	87
90		v1[1] = 1.; // v1 = x
91		ok &= std::fabs( v1[1] - 1. ) <= 1e-10;
	88	v1[1] = 1.; // v1 = x
	89	ok &= std::fabs( v1[1] - 1. ) <= 1e-10;
92	90
93		v1[2] = v1[1]; // v2 = 1 + v1
94		ok &= std::fabs( v1[2] - 1. ) <= 1e-10;
	91	v1[2] = v1[1]; // v2 = 1 + v1
	92	ok &= std::fabs( v1[2] - 1. ) <= 1e-10;
95	93
96		v1[3] = v1[1] * v0[1] + v0[1] * v1[1]; // v3 = v1 * v1
97		ok &= std::fabs( v1[3] - 1. ) <= 1e-10;
	94	v1[3] = v1[1] * v0[1] + v0[1] * v1[1]; // v3 = v1 * v1
	95	ok &= std::fabs( v1[3] - 1. ) <= 1e-10;
98	96
99		v1[4] = v1[3] / 2.; // v4 = v3 / 2
100		ok &= std::fabs( v1[4] - 0.5) <= 1e-10;
	97	v1[4] = v1[3] / 2.; // v4 = v3 / 2
	98	ok &= std::fabs( v1[4] - 0.5) <= 1e-10;
101	99
102		v1[5] = v1[2] + v1[4]; // v5 = v2 + v4
103		ok &= std::fabs( v1[5] - 1.5) <= 1e-10;
	100	v1[5] = v1[2] + v1[4]; // v5 = v2 + v4
	101	ok &= std::fabs( v1[5] - 1.5) <= 1e-10;
104	102
105		return ok;
	103	return ok;
106	104	}
107	105	bool exp_2_for1(void)
108		{ double v1[6];
109		return exp_2_for1(v1);
	106	{ double v1[6];
	107	return exp_2_for1(v1);
110	108	}
111	109	</pre></font></code>
112
113	110
114	111	<hr/>Input File: introduction/exp_apx/exp_2_for1.cpp
115	112

+18

-21

doc/exp_2_for2.cpp.xml less more

74	74	<td>exp_2_for2.cpp</td>
75	75	<td>Headings</td>
76	76	</tr></table><br/>
77
78
79
80	77	<center><b><big><big>exp_2: Verify Second Order Forward Sweep</big></big></b></center>
81		<code><font color='blue'><pre style='display:inline'> # include <cmath> // prototype for fabs
	78	<code><font color='blue'><pre style='display:inline'>
	79	# include <cmath> // prototype for fabs
82	80	extern bool exp_2_for0(double *v0); // computes zero order forward sweep
83	81	extern bool exp_2_for1(double *v1); // computes first order forward sweep
84	82	bool exp_2_for2(void)
85		{ bool ok = true;
86		double v0[6], v1[6], v2[6];
	83	{ bool ok = true;
	84	double v0[6], v1[6], v2[6];
87	85
88		// set the value of v0[j], v1[j], for j = 1 , ... , 5
89		ok &= exp_2_for0(v0);
90		ok &= exp_2_for1(v1);
	86	// set the value of v0[j], v1[j], for j = 1 , ... , 5
	87	ok &= exp_2_for0(v0);
	88	ok &= exp_2_for1(v1);
91	89
92		v2[1] = 0.; // v1 = x
93		ok &= std::fabs( v2[1] - 0. ) <= 1e-10;
	90	v2[1] = 0.; // v1 = x
	91	ok &= std::fabs( v2[1] - 0. ) <= 1e-10;
94	92
95		v2[2] = v2[1]; // v2 = 1 + v1
96		ok &= std::fabs( v2[2] - 0. ) <= 1e-10;
	93	v2[2] = v2[1]; // v2 = 1 + v1
	94	ok &= std::fabs( v2[2] - 0. ) <= 1e-10;
97	95
98		v2[3] = 2.(v0[1]v2[1] + v1[1]v1[1]); // v3 = v1 v1
99		ok &= std::fabs( v2[3] - 2. ) <= 1e-10;
	96	v2[3] = 2.(v0[1]v2[1] + v1[1]v1[1]); // v3 = v1 v1
	97	ok &= std::fabs( v2[3] - 2. ) <= 1e-10;
100	98
101		v2[4] = v2[3] / 2.; // v4 = v3 / 2
102		ok &= std::fabs( v2[4] - 1. ) <= 1e-10;
	99	v2[4] = v2[3] / 2.; // v4 = v3 / 2
	100	ok &= std::fabs( v2[4] - 1. ) <= 1e-10;
103	101
104		v2[5] = v2[2] + v2[4]; // v5 = v2 + v4
105		ok &= std::fabs( v2[5] - 1. ) <= 1e-10;
	102	v2[5] = v2[2] + v2[4]; // v5 = v2 + v4
	103	ok &= std::fabs( v2[5] - 1. ) <= 1e-10;
106	104
107		return ok;
	105	return ok;
108	106	}
109	107	</pre></font></code>
110
111	108
112	109	<hr/>Input File: introduction/exp_apx/exp_2_for2.cpp
113	110

+29

-32

doc/exp_2_rev1.cpp.xml less more

74	74	<td>exp_2_rev1.cpp</td>
75	75	<td>Headings</td>
76	76	</tr></table><br/>
77
78
79
80	77	<center><b><big><big>exp_2: Verify First Order Reverse Sweep</big></big></b></center>
81		<code><font color='blue'><pre style='display:inline'> # include <cstddef> // define size_t
	78	<code><font color='blue'><pre style='display:inline'>
	79	# include <cstddef> // define size_t
82	80	# include <cmath> // prototype for fabs
83	81	extern bool exp_2_for0(double *v0); // computes zero order forward sweep
84	82	bool exp_2_rev1(void)
85		{ bool ok = true;
	83	{ bool ok = true;
86	84
87		// set the value of v0[j] for j = 1 , ... , 5
88		double v0[6];
89		ok &= exp_2_for0(v0);
	85	// set the value of v0[j] for j = 1 , ... , 5
	86	double v0[6];
	87	ok &= exp_2_for0(v0);
90	88
91		// initial all partial derivatives as zero
92		double f_v[6];
93		size_t j;
94		for(j = 0; j < 6; j++)
95		f_v[j] = 0.;
	89	// initial all partial derivatives as zero
	90	double f_v[6];
	91	size_t j;
	92	for(j = 0; j < 6; j++)
	93	f_v[j] = 0.;
96	94
97		// set partial derivative for f5
98		f_v[5] = 1.;
99		ok &= std::fabs( f_v[5] - 1. ) <= 1e-10; // f5_v5
	95	// set partial derivative for f5
	96	f_v[5] = 1.;
	97	ok &= std::fabs( f_v[5] - 1. ) <= 1e-10; // f5_v5
100	98
101		// f4 = f5( v1 , v2 , v3 , v4 , v2 + v4 )
102		f_v[2] += f_v[5] * 1.;
103		f_v[4] += f_v[5] * 1.;
104		ok &= std::fabs( f_v[2] - 1. ) <= 1e-10; // f4_v2
105		ok &= std::fabs( f_v[4] - 1. ) <= 1e-10; // f4_v4
	99	// f4 = f5( v1 , v2 , v3 , v4 , v2 + v4 )
	100	f_v[2] += f_v[5] * 1.;
	101	f_v[4] += f_v[5] * 1.;
	102	ok &= std::fabs( f_v[2] - 1. ) <= 1e-10; // f4_v2
	103	ok &= std::fabs( f_v[4] - 1. ) <= 1e-10; // f4_v4
106	104
107		// f3 = f4( v1 , v2 , v3 , v3 / 2 )
108		f_v[3] += f_v[4] / 2.;
109		ok &= std::fabs( f_v[3] - 0.5) <= 1e-10; // f3_v3
	105	// f3 = f4( v1 , v2 , v3 , v3 / 2 )
	106	f_v[3] += f_v[4] / 2.;
	107	ok &= std::fabs( f_v[3] - 0.5) <= 1e-10; // f3_v3
110	108
111		// f2 = f3( v1 , v2 , v1 * v1 )
112		f_v[1] += f_v[3] * 2. * v0[1];
113		ok &= std::fabs( f_v[1] - 0.5) <= 1e-10; // f2_v1
	109	// f2 = f3( v1 , v2 , v1 * v1 )
	110	f_v[1] += f_v[3] * 2. * v0[1];
	111	ok &= std::fabs( f_v[1] - 0.5) <= 1e-10; // f2_v1
114	112
115		// f1 = f2( v1 , 1 + v1 )
116		f_v[1] += f_v[2] * 1.;
117		ok &= std::fabs( f_v[1] - 1.5) <= 1e-10; // f1_v1
	113	// f1 = f2( v1 , 1 + v1 )
	114	f_v[1] += f_v[2] * 1.;
	115	ok &= std::fabs( f_v[1] - 1.5) <= 1e-10; // f1_v1
118	116
119		return ok;
	117	return ok;
120	118	}
121	119	</pre></font></code>
122
123	120
124	121	<hr/>Input File: introduction/exp_apx/exp_2_rev1.cpp
125	122

+43

-46

doc/exp_2_rev2.cpp.xml less more

74	74	<td>exp_2_rev2.cpp</td>
75	75	<td>Headings</td>
76	76	</tr></table><br/>
77
78
79
80	77	<center><b><big><big>exp_2: Verify Second Order Reverse Sweep</big></big></b></center>
81		<code><font color='blue'><pre style='display:inline'> # include <cstddef> // define size_t
	78	<code><font color='blue'><pre style='display:inline'>
	79	# include <cstddef> // define size_t
82	80	# include <cmath> // prototype for fabs
83	81	extern bool exp_2_for0(double *v0); // computes zero order forward sweep
84	82	extern bool exp_2_for1(double *v1); // computes first order forward sweep
85	83	bool exp_2_rev2(void)
86		{ bool ok = true;
	84	{ bool ok = true;
87	85
88		// set the value of v0[j], v1[j] for j = 1 , ... , 5
89		double v0[6], v1[6];
90		ok &= exp_2_for0(v0);
91		ok &= exp_2_for1(v1);
	86	// set the value of v0[j], v1[j] for j = 1 , ... , 5
	87	double v0[6], v1[6];
	88	ok &= exp_2_for0(v0);
	89	ok &= exp_2_for1(v1);
92	90
93		// initial all partial derivatives as zero
94		double f_v0[6], f_v1[6];
95		size_t j;
96		for(j = 0; j < 6; j++)
97		{ f_v0[j] = 0.;
98		f_v1[j] = 0.;
99		}
	91	// initial all partial derivatives as zero
	92	double f_v0[6], f_v1[6];
	93	size_t j;
	94	for(j = 0; j < 6; j++)
	95	{ f_v0[j] = 0.;
	96	f_v1[j] = 0.;
	97	}
100	98
101		// set partial derivative for f_5
102		f_v1[5] = 1.;
103		ok &= std::fabs( f_v1[5] - 1. ) <= 1e-10; // partial f_5 w.r.t v_5^1
	99	// set partial derivative for f_5
	100	f_v1[5] = 1.;
	101	ok &= std::fabs( f_v1[5] - 1. ) <= 1e-10; // partial f_5 w.r.t v_5^1
104	102
105		// f_4 = f_5( v_1^0 , ... , v_4^1 , v_2^0 + v_4^0 , v_2^1 + v_4^1 )
106		f_v0[2] += f_v0[5] * 1.;
107		f_v0[4] += f_v0[5] * 1.;
108		f_v1[2] += f_v1[5] * 1.;
109		f_v1[4] += f_v1[5] * 1.;
110		ok &= std::fabs( f_v0[2] - 0. ) <= 1e-10; // partial f_4 w.r.t. v_2^0
111		ok &= std::fabs( f_v0[4] - 0. ) <= 1e-10; // partial f_4 w.r.t. v_4^0
112		ok &= std::fabs( f_v1[2] - 1. ) <= 1e-10; // partial f_4 w.r.t. v_2^1
113		ok &= std::fabs( f_v1[4] - 1. ) <= 1e-10; // partial f_4 w.r.t. v_4^1
	103	// f_4 = f_5( v_1^0 , ... , v_4^1 , v_2^0 + v_4^0 , v_2^1 + v_4^1 )
	104	f_v0[2] += f_v0[5] * 1.;
	105	f_v0[4] += f_v0[5] * 1.;
	106	f_v1[2] += f_v1[5] * 1.;
	107	f_v1[4] += f_v1[5] * 1.;
	108	ok &= std::fabs( f_v0[2] - 0. ) <= 1e-10; // partial f_4 w.r.t. v_2^0
	109	ok &= std::fabs( f_v0[4] - 0. ) <= 1e-10; // partial f_4 w.r.t. v_4^0
	110	ok &= std::fabs( f_v1[2] - 1. ) <= 1e-10; // partial f_4 w.r.t. v_2^1
	111	ok &= std::fabs( f_v1[4] - 1. ) <= 1e-10; // partial f_4 w.r.t. v_4^1
114	112
115		// f_3 = f_4( v_1^0 , ... , v_3^1, v_3^0 / 2 , v_3^1 / 2 )
116		f_v0[3] += f_v0[4] / 2.;
117		f_v1[3] += f_v1[4] / 2.;
118		ok &= std::fabs( f_v0[3] - 0. ) <= 1e-10; // partial f_3 w.r.t. v_3^0
119		ok &= std::fabs( f_v1[3] - 0.5 ) <= 1e-10; // partial f_3 w.r.t. v_3^1
	113	// f_3 = f_4( v_1^0 , ... , v_3^1, v_3^0 / 2 , v_3^1 / 2 )
	114	f_v0[3] += f_v0[4] / 2.;
	115	f_v1[3] += f_v1[4] / 2.;
	116	ok &= std::fabs( f_v0[3] - 0. ) <= 1e-10; // partial f_3 w.r.t. v_3^0
	117	ok &= std::fabs( f_v1[3] - 0.5 ) <= 1e-10; // partial f_3 w.r.t. v_3^1
120	118
121		// f_2 = f_3( v_1^0 , ... , v_2^1, v_1^0 * v_1^0 , 2 * v_1^0 * v_1^1 )
122		f_v0[1] += f_v0[3] * 2. * v0[1];
123		f_v0[1] += f_v1[3] * 2. * v1[1];
124		f_v1[1] += f_v1[3] * 2. * v0[1];
125		ok &= std::fabs( f_v0[1] - 1. ) <= 1e-10; // partial f_2 w.r.t. v_1^0
126		ok &= std::fabs( f_v1[1] - 0.5 ) <= 1e-10; // partial f_2 w.r.t. v_1^1
	119	// f_2 = f_3( v_1^0 , ... , v_2^1, v_1^0 * v_1^0 , 2 * v_1^0 * v_1^1 )
	120	f_v0[1] += f_v0[3] * 2. * v0[1];
	121	f_v0[1] += f_v1[3] * 2. * v1[1];
	122	f_v1[1] += f_v1[3] * 2. * v0[1];
	123	ok &= std::fabs( f_v0[1] - 1. ) <= 1e-10; // partial f_2 w.r.t. v_1^0
	124	ok &= std::fabs( f_v1[1] - 0.5 ) <= 1e-10; // partial f_2 w.r.t. v_1^1
127	125
128		// f_1 = f_2( v_1^0 , v_1^1 , 1 + v_1^0 , v_1^1 )
129		f_v0[1] += f_v0[2] * 1.;
130		f_v1[1] += f_v1[2] * 1.;
131		ok &= std::fabs( f_v0[1] - 1. ) <= 1e-10; // partial f_1 w.r.t. v_1^0
132		ok &= std::fabs( f_v1[1] - 1.5) <= 1e-10; // partial f_1 w.r.t. v_1^1
	126	// f_1 = f_2( v_1^0 , v_1^1 , 1 + v_1^0 , v_1^1 )
	127	f_v0[1] += f_v0[2] * 1.;
	128	f_v1[1] += f_v1[2] * 1.;
	129	ok &= std::fabs( f_v0[1] - 1. ) <= 1e-10; // partial f_1 w.r.t. v_1^0
	130	ok &= std::fabs( f_v1[1] - 1.5) <= 1e-10; // partial f_1 w.r.t. v_1^1
133	131
134		return ok;
	132	return ok;
135	133	}
136	134	</pre></font></code>
137
138	135
139	136	<hr/>Input File: introduction/exp_apx/exp_2_rev2.cpp
140	137

+1

-4

doc/exp_apx_main.cpp.xml less more

5	5	<title>Correctness Tests For Exponential Approximation in Introduction</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Correctness Tests For Exponential Approximation in Introduction"/>
8		<meta name="keywords" id="keywords" content=" correctness tests for exponential approximation in introduction exp_apx main run running main.cpp "/>
	8	<meta name="keywords" id="keywords" content=" correctness tests exponential approximation introduction exp_apx main run running main.cpp "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

75	75	</select>
76	76	</td>
77	77	</tr></table><br/>
78
79
80
81	78	<center><b><big><big>Correctness Tests For Exponential Approximation in Introduction</big></big></b></center>
82	79	<br/>
83	80	<b><big><a name="Running Tests" id="Running Tests">Running Tests</a></big></b>

+2

-2

doc/exp_eps.cpp.xml less more

5	5	<title>exp_eps: Test of exp_eps</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="exp_eps: Test of exp_eps"/>
8		<meta name="keywords" id="keywords" content=" exp_eps: test of exp_eps "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: test exp_eps "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

94	94	{ double x = .5;
95	95	double epsilon = .2;
96	96	double check = 1 + .5 + .125; // include 1 term less than epsilon
97		bool ok = std::fabs( exp_eps(x, epsilon) - check ) <= 1e-10;
	97	bool ok = std::fabs( exp_eps(x, epsilon) - check ) <= 1e-10;
98	98	return ok;
99	99	}
100	100	</pre>

+4

-8

doc/exp_eps.xml less more

5	5	<title>An Epsilon Accurate Exponential Approximation</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="An Epsilon Accurate Exponential Approximation"/>
8		<meta name="keywords" id="keywords" content=" an epsilon accurate exponential approximation exp_eps example algorithm syntax purpose mathematical function include x y type implementation test exercises "/>
	8	<meta name="keywords" id="keywords" content=" epsilon accurate exponential approximation exp_eps example algorithm syntax purpose mathematical function include x y type implementation test exercises "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

96	96	</select>
97	97	</td>
98	98	</tr></table><br/>
99
100
101
102	99	<center><b><big><big>An Epsilon Accurate Exponential Approximation</big></big></b></center>
103	100	<br/>
104	101	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

570	567
571	568	Suppose that we make the following call to <code><font color="blue">exp_eps</font></code>:
572	569	<code><font color='blue'><pre style='display:inline'>
573		double x = 1.;
574		double epsilon = .01;
575		double y = exp_eps(x, epsilon);
	570	double x = 1.;
	571	double epsilon = .01;
	572	double y = exp_eps(x, epsilon);
576	573	</pre></font></code>
577
578	574	What is the value assigned to
579	575	<code><font color="blue">k</font></code>, <code><font color="blue">temp</font></code>, <code><font color="blue">term</font></code>, and <code><font color="blue">sum</font></code>
580	576	the first time through the <code><font color="blue">while</font></code> loop in <a href="exp_eps.hpp.xml" target="_top"><span style='white-space: nowrap'>exp_eps.hpp</span></a>

+71

-75

doc/exp_eps_cppad.xml less more

5	5	<title>exp_eps: CppAD Forward and Reverse Sweeps</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="exp_eps: CppAD Forward and Reverse Sweeps"/>
8		<meta name="keywords" id="keywords" content=" exp_eps: cppad forward and reverse sweeps purpose exercises "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: cppad forward reverse sweeps purpose exercises "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

89	89	</select>
90	90	</td>
91	91	</tr></table><br/>
92
93
94
95	92	<center><b><big><big>exp_eps: CppAD Forward and Reverse Sweeps</big></big></b></center>
96	93	.
97	94

121	118	</mrow></math>
122	119
123	120	,
124		of the function
	121	of the function
125	122
126	123	<code><font color="blue"><span style='white-space: nowrap'><br/>
127	124	exp_eps(</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'>epsilon</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>

156	153	</mrow></math>
157	154
158	155	,
159		of the function
	156	of the function
160	157
161	158	<code><font color="blue"><span style='white-space: nowrap'><br/>
162	159	exp_eps(</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'>epsilon</span></font></i><font color="blue"><span style='white-space: nowrap'>)<br/>

184	181	</mrow></math>
185	182
186	183	,
187		of the function corresponding to the operation sequence
	184	of the function corresponding to the operation sequence
188	185	for
189	186	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
190	187	<mi mathvariant='italic'>x</mi>

213	210	</li></ol>
214	211
215	212	<code><font color='blue'><pre style='display:inline'>
216		# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
	213	# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
217	214	# include "exp_eps.hpp" // our example exponential function approximation
218	215	bool exp_eps_cppad(void)
219		{ bool ok = true;
220		using CppAD::AD;
221		using CppAD::vector; // can use any simple vector template class
222		using CppAD::NearEqual; // checks if values are nearly equal
223
224		// domain space vector
225		size_t n = 2; // dimension of the domain space
226		vector< <a href="ad.xml" target="_top">AD</a><double> > U(n);
227		U[0] = .5; // value of x for this operation sequence
228		U[1] = .2; // value of e for this operation sequence
229
230		// declare independent variables and start recording operation sequence
231		CppAD::<a href="independent.xml" target="_top">Independent</a>(U);
232
233		// evaluate our exponential approximation
234		<a href="ad.xml" target="_top">AD</a><double> x = U[0];
235		<a href="ad.xml" target="_top">AD</a><double> epsilon = U[1];
236		<a href="ad.xml" target="_top">AD</a><double> apx = exp_eps(x, epsilon);
237
238		// range space vector
239		size_t m = 1; // dimension of the range space
240		vector< <a href="ad.xml" target="_top">AD</a><double> > Y(m);
241		Y[0] = apx; // variable that represents only range space component
242
243		// Create f: U -> Y corresponding to this operation sequence
244		// and stop recording. This also executes a zero order forward
245		// mode sweep using values in U for x and e.
246		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(U, Y);
247
248		// first order forward mode sweep that computes partial w.r.t x
249		vector<double> du(n); // differential in domain space
250		vector<double> dy(m); // differential in range space
251		du[0] = 1.; // x direction in domain space
252		du[1] = 0.;
253		dy = f.<a href="forward.xml" target="_top">Forward</a>(1, du); // partial w.r.t. x
254		double check = 1.5;
255		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0], check, 1e-10, 1e-10);
256
257		// first order reverse mode sweep that computes the derivative
258		vector<double> w(m); // weights for components of the range
259		vector<double> dw(n); // derivative of the weighted function
260		w[0] = 1.; // there is only one weight
261		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w); // derivative of w[0] * exp_eps(x, epsilon)
262		check = 1.5; // partial w.r.t. x
263		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0], check, 1e-10, 1e-10);
264		check = 0.; // partial w.r.t. epsilon
265		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[1], check, 1e-10, 1e-10);
266
267		// second order forward sweep that computes
268		// second partial of exp_eps(x, epsilon) w.r.t. x
269		vector<double> x2(n); // second order Taylor coefficients
270		vector<double> y2(m);
271		x2[0] = 0.; // evaluate partial w.r.t x
272		x2[1] = 0.;
273		y2 = f.<a href="forward.xml" target="_top">Forward</a>(2, x2);
274		check = 0.5 * 1.; // Taylor coef is 1/2 second derivative
275		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y2[0], check, 1e-10, 1e-10);
276
277		// second order reverse sweep that computes
278		// derivative of partial of exp_eps(x, epsilon) w.r.t. x
279		dw.resize(2 * n); // space for first and second derivative
280		dw = f.<a href="reverse.xml" target="_top">Reverse</a>(2, w);
281		check = 1.; // result should be second derivative
282		ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0*2+1], check, 1e-10, 1e-10);
283
284		return ok;
	216	{ bool ok = true;
	217	using CppAD::AD;
	218	using CppAD::vector; // can use any simple vector template class
	219	using CppAD::NearEqual; // checks if values are nearly equal
	220
	221	// domain space vector
	222	size_t n = 2; // dimension of the domain space
	223	vector< <a href="ad.xml" target="_top">AD</a><double> > U(n);
	224	U[0] = .5; // value of x for this operation sequence
	225	U[1] = .2; // value of e for this operation sequence
	226
	227	// declare independent variables and start recording operation sequence
	228	CppAD::<a href="independent.xml" target="_top">Independent</a>(U);
	229
	230	// evaluate our exponential approximation
	231	<a href="ad.xml" target="_top">AD</a><double> x = U[0];
	232	<a href="ad.xml" target="_top">AD</a><double> epsilon = U[1];
	233	<a href="ad.xml" target="_top">AD</a><double> apx = exp_eps(x, epsilon);
	234
	235	// range space vector
	236	size_t m = 1; // dimension of the range space
	237	vector< <a href="ad.xml" target="_top">AD</a><double> > Y(m);
	238	Y[0] = apx; // variable that represents only range space component
	239
	240	// Create f: U -> Y corresponding to this operation sequence
	241	// and stop recording. This also executes a zero order forward
	242	// mode sweep using values in U for x and e.
	243	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(U, Y);
	244
	245	// first order forward mode sweep that computes partial w.r.t x
	246	vector<double> du(n); // differential in domain space
	247	vector<double> dy(m); // differential in range space
	248	du[0] = 1.; // x direction in domain space
	249	du[1] = 0.;
	250	dy = f.<a href="forward.xml" target="_top">Forward</a>(1, du); // partial w.r.t. x
	251	double check = 1.5;
	252	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dy[0], check, 1e-10, 1e-10);
	253
	254	// first order reverse mode sweep that computes the derivative
	255	vector<double> w(m); // weights for components of the range
	256	vector<double> dw(n); // derivative of the weighted function
	257	w[0] = 1.; // there is only one weight
	258	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(1, w); // derivative of w[0] * exp_eps(x, epsilon)
	259	check = 1.5; // partial w.r.t. x
	260	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0], check, 1e-10, 1e-10);
	261	check = 0.; // partial w.r.t. epsilon
	262	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[1], check, 1e-10, 1e-10);
	263
	264	// second order forward sweep that computes
	265	// second partial of exp_eps(x, epsilon) w.r.t. x
	266	vector<double> x2(n); // second order Taylor coefficients
	267	vector<double> y2(m);
	268	x2[0] = 0.; // evaluate partial w.r.t x
	269	x2[1] = 0.;
	270	y2 = f.<a href="forward.xml" target="_top">Forward</a>(2, x2);
	271	check = 0.5 * 1.; // Taylor coef is 1/2 second derivative
	272	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(y2[0], check, 1e-10, 1e-10);
	273
	274	// second order reverse sweep that computes
	275	// derivative of partial of exp_eps(x, epsilon) w.r.t. x
	276	dw.resize(2 * n); // space for first and second derivative
	277	dw = f.<a href="reverse.xml" target="_top">Reverse</a>(2, w);
	278	check = 1.; // result should be second derivative
	279	ok &= <a href="nearequal.xml" target="_top">NearEqual</a>(dw[0*2+1], check, 1e-10, 1e-10);
	280
	281	return ok;
285	282	}
286	283	</pre></font></code>
287	284
288
289	285	<hr/>Input File: introduction/exp_apx/exp_eps_cppad.cpp
290	286
291	287	</body>

+21

-21

doc/exp_eps_for0.cpp.xml less more

79	79
80	80
81	81	<center><b><big><big>exp_eps: Verify Zero Order Forward Sweep</big></big></b></center>
82		<code><font color='blue'><pre style='display:inline'> # include <cmath> // for fabs function
	82	<code><font color='blue'><pre style='display:inline'>
	83	# include <cmath> // for fabs function
83	84	bool exp_eps_for0(double *v0) // double v0[8]
84		{ bool ok = true;
85		double x = .5;
	85	{ bool ok = true;
	86	double x = .5;
86	87
87		v0[1] = x; // abs_x = x;
88		ok &= std::fabs( v0[1] - 0.5) < 1e-10;
	88	v0[1] = x; // abs_x = x;
	89	ok &= std::fabs( v0[1] - 0.5) < 1e-10;
89	90
90		v0[2] = 1. * v0[1]; // temp = term * abs_x;
91		ok &= std::fabs( v0[2] - 0.5) < 1e-10;
	91	v0[2] = 1. * v0[1]; // temp = term * abs_x;
	92	ok &= std::fabs( v0[2] - 0.5) < 1e-10;
92	93
93		v0[3] = v0[2] / 1.; // term = temp / Type(k);
94		ok &= std::fabs( v0[3] - 0.5) < 1e-10;
	94	v0[3] = v0[2] / 1.; // term = temp / Type(k);
	95	ok &= std::fabs( v0[3] - 0.5) < 1e-10;
95	96
96		v0[4] = 1. + v0[3]; // sum = sum + term;
97		ok &= std::fabs( v0[4] - 1.5) < 1e-10;
	97	v0[4] = 1. + v0[3]; // sum = sum + term;
	98	ok &= std::fabs( v0[4] - 1.5) < 1e-10;
98	99
99		v0[5] = v0[3] * v0[1]; // temp = term * abs_x;
100		ok &= std::fabs( v0[5] - 0.25) < 1e-10;
	100	v0[5] = v0[3] * v0[1]; // temp = term * abs_x;
	101	ok &= std::fabs( v0[5] - 0.25) < 1e-10;
101	102
102		v0[6] = v0[5] / 2.; // term = temp / Type(k);
103		ok &= std::fabs( v0[6] - 0.125) < 1e-10;
	103	v0[6] = v0[5] / 2.; // term = temp / Type(k);
	104	ok &= std::fabs( v0[6] - 0.125) < 1e-10;
104	105
105		v0[7] = v0[4] + v0[6]; // sum = sum + term;
106		ok &= std::fabs( v0[7] - 1.625) < 1e-10;
	106	v0[7] = v0[4] + v0[6]; // sum = sum + term;
	107	ok &= std::fabs( v0[7] - 1.625) < 1e-10;
107	108
108		return ok;
	109	return ok;
109	110	}
110	111	bool exp_eps_for0(void)
111		{ double v0[8];
112		return exp_eps_for0(v0);
	112	{ double v0[8];
	113	return exp_eps_for0(v0);
113	114	}
114	115	</pre></font></code>
115
116	116
117	117	<hr/>Input File: introduction/exp_apx/exp_eps_for0.cpp
118	118

+3

-4

doc/exp_eps_for0.xml less more

5	5	<title>exp_eps: Operation Sequence and Zero Order Forward Sweep</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="exp_eps: Operation Sequence and Zero Order Forward Sweep"/>
8		<meta name="keywords" id="keywords" content=" exp_eps: operation sequence and zero order forward sweep example mathematical form variable parameter index code return value comparisons verification exercises "/>
	8	<meta name="keywords" id="keywords" content=" exp_eps: operation sequence zero order forward sweep example mathematical form variable parameter index code return value comparisons verification exercises "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

562	562	were a much smaller or much larger value,
563	563	the results of the following comparisons could be different:
564	564	<code><font color='blue'><pre style='display:inline'>
565		if( Type(0) > x )
566		while(term > epsilon)
	565	if( Type(0) > x )
	566	while(term > epsilon)
567	567	</pre></font></code>
568
569	568	This in turn would result in a different operation sequence.
570	569	Thus the operation sequence above only corresponds to
571	570	<a href="exp_eps.hpp.xml" target="_top"><span style='white-space: nowrap'>exp_eps.hpp</span></a>

+23

-26

doc/exp_eps_for1.cpp.xml less more

74	74	<td>exp_eps_for1.cpp</td>
75	75	<td>Headings</td>
76	76	</tr></table><br/>
77
78
79
80	77	<center><b><big><big>exp_eps: Verify First Order Forward Sweep</big></big></b></center>
81		<code><font color='blue'><pre style='display:inline'> # include <cmath> // for fabs function
	78	<code><font color='blue'><pre style='display:inline'>
	79	# include <cmath> // for fabs function
82	80	extern bool exp_eps_for0(double *v0); // computes zero order forward sweep
83	81	bool exp_eps_for1(double *v1) // double v[8]
84		{ bool ok = true;
85		double v0[8];
	82	{ bool ok = true;
	83	double v0[8];
86	84
87		// set the value of v0[j] for j = 1 , ... , 7
88		ok &= exp_eps_for0(v0);
	85	// set the value of v0[j] for j = 1 , ... , 7
	86	ok &= exp_eps_for0(v0);
89	87
90		v1[1] = 1.; // v1 = x
91		ok &= std::fabs( v1[1] - 1. ) <= 1e-10;
	88	v1[1] = 1.; // v1 = x
	89	ok &= std::fabs( v1[1] - 1. ) <= 1e-10;
92	90
93		v1[2] = 1. * v1[1]; // v2 = 1 * v1
94		ok &= std::fabs( v1[2] - 1. ) <= 1e-10;
	91	v1[2] = 1. * v1[1]; // v2 = 1 * v1
	92	ok &= std::fabs( v1[2] - 1. ) <= 1e-10;
95	93
96		v1[3] = v1[2] / 1.; // v3 = v2 / 1
97		ok &= std::fabs( v1[3] - 1. ) <= 1e-10;
	94	v1[3] = v1[2] / 1.; // v3 = v2 / 1
	95	ok &= std::fabs( v1[3] - 1. ) <= 1e-10;
98	96
99		v1[4] = v1[3]; // v4 = 1 + v3
100		ok &= std::fabs( v1[4] - 1. ) <= 1e-10;
	97	v1[4] = v1[3]; // v4 = 1 + v3
	98	ok &= std::fabs( v1[4] - 1. ) <= 1e-10;
101	99
102		v1[5] = v1[3] * v0[1] + v0[3] * v1[1]; // v5 = v3 * v1
103		ok &= std::fabs( v1[5] - 1. ) <= 1e-10;
	100	v1[5] = v1[3] * v0[1] + v0[3] * v1[1]; // v5 = v3 * v1
	101	ok &= std::fabs( v1[5] - 1. ) <= 1e-10;
104	102
105		v1[6] = v1[5] / 2.; // v6 = v5 / 2
106		ok &= std::fabs( v1[6] - 0.5 ) <= 1e-10;
	103	v1[6] = v1[5] / 2.; // v6 = v5 / 2
	104	ok &= std::fabs( v1[6] - 0.5 ) <= 1e-10;
107	105
108		v1[7] = v1[4] + v1[6]; // v7 = v4 + v6
109		ok &= std::fabs( v1[7] - 1.5 ) <= 1e-10;
	106	v1[7] = v1[4] + v1[6]; // v7 = v4 + v6
	107	ok &= std::fabs( v1[7] - 1.5 ) <= 1e-10;
110	108
111		return ok;
	109	return ok;
112	110	}
113	111	bool exp_eps_for1(void)
114		{ double v1[8];
115		return exp_eps_for1(v1);
	112	{ double v1[8];
	113	return exp_eps_for1(v1);
116	114	}
117	115	</pre></font></code>
118
119	116
120	117	<hr/>Input File: introduction/exp_apx/exp_eps_for1.cpp
121	118

+23

-26

doc/exp_eps_for2.cpp.xml less more

74	74	<td>exp_eps_for2.cpp</td>
75	75	<td>Headings</td>
76	76	</tr></table><br/>
77
78
79
80	77	<center><b><big><big>exp_eps: Verify Second Order Forward Sweep</big></big></b></center>
81		<code><font color='blue'><pre style='display:inline'> # include <cmath> // for fabs function
	78	<code><font color='blue'><pre style='display:inline'>
	79	# include <cmath> // for fabs function
82	80	extern bool exp_eps_for0(double *v0); // computes zero order forward sweep
83	81	extern bool exp_eps_for1(double *v1); // computes first order forward sweep
84	82	bool exp_eps_for2(void)
85		{ bool ok = true;
86		double v0[8], v1[8], v2[8];
	83	{ bool ok = true;
	84	double v0[8], v1[8], v2[8];
87	85
88		// set the value of v0[j], v1[j] for j = 1 , ... , 7
89		ok &= exp_eps_for0(v0);
90		ok &= exp_eps_for1(v1);
	86	// set the value of v0[j], v1[j] for j = 1 , ... , 7
	87	ok &= exp_eps_for0(v0);
	88	ok &= exp_eps_for1(v1);
91	89
92		v2[1] = 0.; // v1 = x
93		ok &= std::fabs( v2[1] - 0. ) <= 1e-10;
	90	v2[1] = 0.; // v1 = x
	91	ok &= std::fabs( v2[1] - 0. ) <= 1e-10;
94	92
95		v2[2] = 1. * v2[1]; // v2 = 1 * v1
96		ok &= std::fabs( v2[2] - 0. ) <= 1e-10;
	93	v2[2] = 1. * v2[1]; // v2 = 1 * v1
	94	ok &= std::fabs( v2[2] - 0. ) <= 1e-10;
97	95
98		v2[3] = v2[2] / 1.; // v3 = v2 / 1
99		ok &= std::fabs( v2[3] - 0. ) <= 1e-10;
	96	v2[3] = v2[2] / 1.; // v3 = v2 / 1
	97	ok &= std::fabs( v2[3] - 0. ) <= 1e-10;
100	98
101		v2[4] = v2[3]; // v4 = 1 + v3
102		ok &= std::fabs( v2[4] - 0. ) <= 1e-10;
	99	v2[4] = v2[3]; // v4 = 1 + v3
	100	ok &= std::fabs( v2[4] - 0. ) <= 1e-10;
103	101
104		v2[5] = v2[3] * v0[1] + 2. * v1[3] * v1[1] // v5 = v3 * v1
105		+ v0[3] * v2[1];
106		ok &= std::fabs( v2[5] - 2. ) <= 1e-10;
	102	v2[5] = v2[3] * v0[1] + 2. * v1[3] * v1[1] // v5 = v3 * v1
	103	+ v0[3] * v2[1];
	104	ok &= std::fabs( v2[5] - 2. ) <= 1e-10;
107	105
108		v2[6] = v2[5] / 2.; // v6 = v5 / 2
109		ok &= std::fabs( v2[6] - 1. ) <= 1e-10;
	106	v2[6] = v2[5] / 2.; // v6 = v5 / 2
	107	ok &= std::fabs( v2[6] - 1. ) <= 1e-10;
110	108
111		v2[7] = v2[4] + v2[6]; // v7 = v4 + v6
112		ok &= std::fabs( v2[7] - 1. ) <= 1e-10;
	109	v2[7] = v2[4] + v2[6]; // v7 = v4 + v6
	110	ok &= std::fabs( v2[7] - 1. ) <= 1e-10;
113	111
114		return ok;
	112	return ok;
115	113	}
116	114	</pre></font></code>
117
118	115
119	116	<hr/>Input File: introduction/exp_apx/exp_eps_for2.cpp
120	117

+37

-40

doc/exp_eps_rev1.cpp.xml less more

74	74	<td>exp_eps_rev1.cpp</td>
75	75	<td>Headings</td>
76	76	</tr></table><br/>
77
78
79
80	77	<center><b><big><big>exp_eps: Verify First Order Reverse Sweep</big></big></b></center>
81		<code><font color='blue'><pre style='display:inline'> # include <cstddef> // define size_t
	78	<code><font color='blue'><pre style='display:inline'>
	79	# include <cstddef> // define size_t
82	80	# include <cmath> // for fabs function
83	81	extern bool exp_eps_for0(double *v0); // computes zero order forward sweep
84	82	bool exp_eps_rev1(void)
85		{ bool ok = true;
	83	{ bool ok = true;
86	84
87		// set the value of v0[j] for j = 1 , ... , 7
88		double v0[8];
89		ok &= exp_eps_for0(v0);
	85	// set the value of v0[j] for j = 1 , ... , 7
	86	double v0[8];
	87	ok &= exp_eps_for0(v0);
90	88
91		// initial all partial derivatives as zero
92		double f_v[8];
93		size_t j;
94		for(j = 0; j < 8; j++)
95		f_v[j] = 0.;
	89	// initial all partial derivatives as zero
	90	double f_v[8];
	91	size_t j;
	92	for(j = 0; j < 8; j++)
	93	f_v[j] = 0.;
96	94
97		// set partial derivative for f7
98		f_v[7] = 1.;
99		ok &= std::fabs( f_v[7] - 1. ) <= 1e-10; // f7_v7
	95	// set partial derivative for f7
	96	f_v[7] = 1.;
	97	ok &= std::fabs( f_v[7] - 1. ) <= 1e-10; // f7_v7
100	98
101		// f6( v1 , v2 , v3 , v4 , v5 , v6 )
102		f_v[4] += f_v[7] * 1.;
103		f_v[6] += f_v[7] * 1.;
104		ok &= std::fabs( f_v[4] - 1. ) <= 1e-10; // f6_v4
105		ok &= std::fabs( f_v[6] - 1. ) <= 1e-10; // f6_v6
	99	// f6( v1 , v2 , v3 , v4 , v5 , v6 )
	100	f_v[4] += f_v[7] * 1.;
	101	f_v[6] += f_v[7] * 1.;
	102	ok &= std::fabs( f_v[4] - 1. ) <= 1e-10; // f6_v4
	103	ok &= std::fabs( f_v[6] - 1. ) <= 1e-10; // f6_v6
106	104
107		// f5( v1 , v2 , v3 , v4 , v5 )
108		f_v[5] += f_v[6] / 2.;
109		ok &= std::fabs( f_v[5] - 0.5 ) <= 1e-10; // f5_v5
	105	// f5( v1 , v2 , v3 , v4 , v5 )
	106	f_v[5] += f_v[6] / 2.;
	107	ok &= std::fabs( f_v[5] - 0.5 ) <= 1e-10; // f5_v5
110	108
111		// f4( v1 , v2 , v3 , v4 )
112		f_v[1] += f_v[5] * v0[3];
113		f_v[3] += f_v[5] * v0[1];
114		ok &= std::fabs( f_v[1] - 0.25) <= 1e-10; // f4_v1
115		ok &= std::fabs( f_v[3] - 0.25) <= 1e-10; // f4_v3
	109	// f4( v1 , v2 , v3 , v4 )
	110	f_v[1] += f_v[5] * v0[3];
	111	f_v[3] += f_v[5] * v0[1];
	112	ok &= std::fabs( f_v[1] - 0.25) <= 1e-10; // f4_v1
	113	ok &= std::fabs( f_v[3] - 0.25) <= 1e-10; // f4_v3
116	114
117		// f3( v1 , v2 , v3 )
118		f_v[3] += f_v[4] * 1.;
119		ok &= std::fabs( f_v[3] - 1.25) <= 1e-10; // f3_v3
	115	// f3( v1 , v2 , v3 )
	116	f_v[3] += f_v[4] * 1.;
	117	ok &= std::fabs( f_v[3] - 1.25) <= 1e-10; // f3_v3
120	118
121		// f2( v1 , v2 )
122		f_v[2] += f_v[3] / 1.;
123		ok &= std::fabs( f_v[2] - 1.25) <= 1e-10; // f2_v2
	119	// f2( v1 , v2 )
	120	f_v[2] += f_v[3] / 1.;
	121	ok &= std::fabs( f_v[2] - 1.25) <= 1e-10; // f2_v2
124	122
125		// f1( v1 )
126		f_v[1] += f_v[2] * 1.;
127		ok &= std::fabs( f_v[1] - 1.5 ) <= 1e-10; // f1_v2
	123	// f1( v1 )
	124	f_v[1] += f_v[2] * 1.;
	125	ok &= std::fabs( f_v[1] - 1.5 ) <= 1e-10; // f1_v2
128	126
129		return ok;
	127	return ok;
130	128	}
131	129	</pre></font></code>
132
133	130
134	131	<hr/>Input File: introduction/exp_apx/exp_eps_rev1.cpp
135	132

+57

-60

doc/exp_eps_rev2.cpp.xml less more

74	74	<td>exp_eps_rev2.cpp</td>
75	75	<td>Headings</td>
76	76	</tr></table><br/>
77
78
79
80	77	<center><b><big><big>exp_eps: Verify Second Order Reverse Sweep</big></big></b></center>
81		<code><font color='blue'><pre style='display:inline'> # include <cstddef> // define size_t
	78	<code><font color='blue'><pre style='display:inline'>
	79	# include <cstddef> // define size_t
82	80	# include <cmath> // for fabs function
83	81	extern bool exp_eps_for0(double *v0); // computes zero order forward sweep
84	82	extern bool exp_eps_for1(double *v1); // computes first order forward sweep
85	83	bool exp_eps_rev2(void)
86		{ bool ok = true;
	84	{ bool ok = true;
87	85
88		// set the value of v0[j], v1[j] for j = 1 , ... , 7
89		double v0[8], v1[8];
90		ok &= exp_eps_for0(v0);
91		ok &= exp_eps_for1(v1);
	86	// set the value of v0[j], v1[j] for j = 1 , ... , 7
	87	double v0[8], v1[8];
	88	ok &= exp_eps_for0(v0);
	89	ok &= exp_eps_for1(v1);
92	90
93		// initial all partial derivatives as zero
94		double f_v0[8], f_v1[8];
95		size_t j;
96		for(j = 0; j < 8; j++)
97		{ f_v0[j] = 0.;
98		f_v1[j] = 0.;
99		}
	91	// initial all partial derivatives as zero
	92	double f_v0[8], f_v1[8];
	93	size_t j;
	94	for(j = 0; j < 8; j++)
	95	{ f_v0[j] = 0.;
	96	f_v1[j] = 0.;
	97	}
100	98
101		// set partial derivative for f_7
102		f_v1[7] = 1.;
103		ok &= std::fabs( f_v1[7] - 1. ) <= 1e-10; // partial f_7 w.r.t. v_7^1
	99	// set partial derivative for f_7
	100	f_v1[7] = 1.;
	101	ok &= std::fabs( f_v1[7] - 1. ) <= 1e-10; // partial f_7 w.r.t. v_7^1
104	102
105		// f_6 = f_7( v_1^0 , ... , v_6^1 , v_4^0 + v_6^0, v_4^1 , v_6^1 )
106		f_v0[4] += f_v0[7];
107		f_v0[6] += f_v0[7];
108		f_v1[4] += f_v1[7];
109		f_v1[6] += f_v1[7];
110		ok &= std::fabs( f_v0[4] - 0. ) <= 1e-10; // partial f_6 w.r.t. v_4^0
111		ok &= std::fabs( f_v0[6] - 0. ) <= 1e-10; // partial f_6 w.r.t. v_6^0
112		ok &= std::fabs( f_v1[4] - 1. ) <= 1e-10; // partial f_6 w.r.t. v_4^1
113		ok &= std::fabs( f_v1[6] - 1. ) <= 1e-10; // partial f_6 w.r.t. v_6^1
	103	// f_6 = f_7( v_1^0 , ... , v_6^1 , v_4^0 + v_6^0, v_4^1 , v_6^1 )
	104	f_v0[4] += f_v0[7];
	105	f_v0[6] += f_v0[7];
	106	f_v1[4] += f_v1[7];
	107	f_v1[6] += f_v1[7];
	108	ok &= std::fabs( f_v0[4] - 0. ) <= 1e-10; // partial f_6 w.r.t. v_4^0
	109	ok &= std::fabs( f_v0[6] - 0. ) <= 1e-10; // partial f_6 w.r.t. v_6^0
	110	ok &= std::fabs( f_v1[4] - 1. ) <= 1e-10; // partial f_6 w.r.t. v_4^1
	111	ok &= std::fabs( f_v1[6] - 1. ) <= 1e-10; // partial f_6 w.r.t. v_6^1
114	112
115		// f_5 = f_6( v_1^0 , ... , v_5^1 , v_5^0 / 2 , v_5^1 / 2 )
116		f_v0[5] += f_v0[6] / 2.;
117		f_v1[5] += f_v1[6] / 2.;
118		ok &= std::fabs( f_v0[5] - 0. ) <= 1e-10; // partial f_5 w.r.t. v_5^0
119		ok &= std::fabs( f_v1[5] - 0.5 ) <= 1e-10; // partial f_5 w.r.t. v_5^1
	113	// f_5 = f_6( v_1^0 , ... , v_5^1 , v_5^0 / 2 , v_5^1 / 2 )
	114	f_v0[5] += f_v0[6] / 2.;
	115	f_v1[5] += f_v1[6] / 2.;
	116	ok &= std::fabs( f_v0[5] - 0. ) <= 1e-10; // partial f_5 w.r.t. v_5^0
	117	ok &= std::fabs( f_v1[5] - 0.5 ) <= 1e-10; // partial f_5 w.r.t. v_5^1
120	118
121		// f_4 = f_5( v_1^0 , ... , v_4^1 , v_3^0 * v_1^0 ,
122		// v_3^1 * v_1^0 + v_3^0 * v_1^1 )
123		f_v0[1] += f_v0[5] * v0[3] + f_v1[5] * v1[3];
124		f_v0[3] += f_v0[5] * v0[1] + f_v1[5] * v1[1];
125		f_v1[1] += f_v1[5] * v0[3];
126		f_v1[3] += f_v1[5] * v0[1];
127		ok &= std::fabs( f_v0[1] - 0.5 ) <= 1e-10; // partial f_4 w.r.t. v_1^0
128		ok &= std::fabs( f_v0[3] - 0.5 ) <= 1e-10; // partial f_4 w.r.t. v_3^0
129		ok &= std::fabs( f_v1[1] - 0.25 ) <= 1e-10; // partial f_4 w.r.t. v_1^1
130		ok &= std::fabs( f_v1[3] - 0.25 ) <= 1e-10; // partial f_4 w.r.t. v_3^1
	119	// f_4 = f_5( v_1^0 , ... , v_4^1 , v_3^0 * v_1^0 ,
	120	// v_3^1 * v_1^0 + v_3^0 * v_1^1 )
	121	f_v0[1] += f_v0[5] * v0[3] + f_v1[5] * v1[3];
	122	f_v0[3] += f_v0[5] * v0[1] + f_v1[5] * v1[1];
	123	f_v1[1] += f_v1[5] * v0[3];
	124	f_v1[3] += f_v1[5] * v0[1];
	125	ok &= std::fabs( f_v0[1] - 0.5 ) <= 1e-10; // partial f_4 w.r.t. v_1^0
	126	ok &= std::fabs( f_v0[3] - 0.5 ) <= 1e-10; // partial f_4 w.r.t. v_3^0
	127	ok &= std::fabs( f_v1[1] - 0.25 ) <= 1e-10; // partial f_4 w.r.t. v_1^1
	128	ok &= std::fabs( f_v1[3] - 0.25 ) <= 1e-10; // partial f_4 w.r.t. v_3^1
131	129
132		// f_3 = f_4( v_1^0 , ... , v_3^1 , 1 + v_3^0 , v_3^1 )
133		f_v0[3] += f_v0[4];
134		f_v1[3] += f_v1[4];
135		ok &= std::fabs( f_v0[3] - 0.5 ) <= 1e-10; // partial f_3 w.r.t. v_3^0
136		ok &= std::fabs( f_v1[3] - 1.25) <= 1e-10; // partial f_3 w.r.t. v_3^1
	130	// f_3 = f_4( v_1^0 , ... , v_3^1 , 1 + v_3^0 , v_3^1 )
	131	f_v0[3] += f_v0[4];
	132	f_v1[3] += f_v1[4];
	133	ok &= std::fabs( f_v0[3] - 0.5 ) <= 1e-10; // partial f_3 w.r.t. v_3^0
	134	ok &= std::fabs( f_v1[3] - 1.25) <= 1e-10; // partial f_3 w.r.t. v_3^1
137	135
138		// f_2 = f_3( v_1^0 , ... , v_2^1 , v_2^0 , v_2^1 )
139		f_v0[2] += f_v0[3];
140		f_v1[2] += f_v1[3];
141		ok &= std::fabs( f_v0[2] - 0.5 ) <= 1e-10; // partial f_2 w.r.t. v_2^0
142		ok &= std::fabs( f_v1[2] - 1.25) <= 1e-10; // partial f_2 w.r.t. v_2^1
	136	// f_2 = f_3( v_1^0 , ... , v_2^1 , v_2^0 , v_2^1 )
	137	f_v0[2] += f_v0[3];
	138	f_v1[2] += f_v1[3];
	139	ok &= std::fabs( f_v0[2] - 0.5 ) <= 1e-10; // partial f_2 w.r.t. v_2^0
	140	ok &= std::fabs( f_v1[2] - 1.25) <= 1e-10; // partial f_2 w.r.t. v_2^1
143	141
144		// f_1 = f_2 ( v_1^0 , v_2^0 , v_1^0 , v_2^0 )
145		f_v0[1] += f_v0[2];
146		f_v1[1] += f_v1[2];
147		ok &= std::fabs( f_v0[1] - 1. ) <= 1e-10; // partial f_1 w.r.t. v_1^0
148		ok &= std::fabs( f_v1[1] - 1.5 ) <= 1e-10; // partial f_1 w.r.t. v_1^1
	142	// f_1 = f_2 ( v_1^0 , v_2^0 , v_1^0 , v_2^0 )
	143	f_v0[1] += f_v0[2];
	144	f_v1[1] += f_v1[2];
	145	ok &= std::fabs( f_v0[1] - 1. ) <= 1e-10; // partial f_1 w.r.t. v_1^0
	146	ok &= std::fabs( f_v1[1] - 1.5 ) <= 1e-10; // partial f_1 w.r.t. v_1^1
149	147
150		return ok;
	148	return ok;
151	149	}
152	150	</pre></font></code>
153
154	151
155	152	<hr/>Input File: introduction/exp_apx/exp_eps_rev2.cpp
156	153

+1

-1

doc/expm1.cpp.xml less more

5	5	<title>The AD exp Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD exp Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad exp function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad exp function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+39

-43

doc/fadbad_det_lu.cpp.xml less more

5	5	<title>Fadbad Speed: Gradient of Determinant Using Lu Factorization</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Fadbad Speed: Gradient of Determinant Using Lu Factorization"/>
8		<meta name="keywords" id="keywords" content=" fadbad speed: gradient of determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: gradient determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Fadbad Speed: Gradient of Determinant Using Lu Factorization</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

115	112	extern bool global_memory, global_onetape, global_atomic, global_optimize;
116	113
117	114	bool link_det_lu(
118		size_t size ,
119		size_t repeat ,
120		CppAD::vector<double> &matrix ,
121		CppAD::vector<double> &gradient )
	115	size_t size ,
	116	size_t repeat ,
	117	CppAD::vector<double> &matrix ,
	118	CppAD::vector<double> &gradient )
122	119	{
123		// speed test global option values
124		if( global_onetape \|\| global_atomic )
125		return false;
126		if( global_memory \|\| global_optimize )
127		return false;
128		// -----------------------------------------------------
129		// setup
130		//
131		// object for computing determinant
132		typedef fadbad::B<double> ADScalar;
133		typedef CppAD::vector<ADScalar> ADVector;
134		CppAD::det_by_lu<ADScalar> Det(size);
	120	// speed test global option values
	121	if( global_onetape \|\| global_atomic )
	122	return false;
	123	if( global_memory \|\| global_optimize )
	124	return false;
	125	// -----------------------------------------------------
	126	// setup
	127	//
	128	// object for computing determinant
	129	typedef fadbad::B<double> ADScalar;
	130	typedef CppAD::vector<ADScalar> ADVector;
	131	CppAD::det_by_lu<ADScalar> Det(size);
135	132
136		size_t i; // temporary index
137		size_t m = 1; // number of dependent variables
138		size_t n = size * size; // number of independent variables
139		ADScalar detA; // AD value of the determinant
140		ADVector A(n); // AD version of matrix
	133	size_t i; // temporary index
	134	size_t m = 1; // number of dependent variables
	135	size_t n = size * size; // number of independent variables
	136	ADScalar detA; // AD value of the determinant
	137	ADVector A(n); // AD version of matrix
141	138
142		// ------------------------------------------------------
143		while(repeat--)
144		{ // get the next matrix
145		CppAD::uniform_01(n, matrix);
	139	// ------------------------------------------------------
	140	while(repeat--)
	141	{ // get the next matrix
	142	CppAD::uniform_01(n, matrix);
146	143
147		// set independent variable values
148		for(i = 0; i < n; i++)
149		A[i] = matrix[i];
	144	// set independent variable values
	145	for(i = 0; i < n; i++)
	146	A[i] = matrix[i];
150	147
151		// compute the determinant
152		detA = Det(A);
	148	// compute the determinant
	149	detA = Det(A);
153	150
154		// create function object f : A -> detA
155		detA.diff(0, m); // index 0 of m dependent variables
	151	// create function object f : A -> detA
	152	detA.diff(0, m); // index 0 of m dependent variables
156	153
157		// evaluate and return gradient using reverse mode
158		for(i =0; i < n; i++)
159		gradient[i] = A[i].d(0); // partial detA w.r.t A[i]
160		}
161		// ---------------------------------------------------------
162		return true;
	154	// evaluate and return gradient using reverse mode
	155	for(i =0; i < n; i++)
	156	gradient[i] = A[i].d(0); // partial detA w.r.t A[i]
	157	}
	158	// ---------------------------------------------------------
	159	return true;
163	160	}
164	161	</pre></font></code>
165
166	162
167	163	<hr/>Input File: speed/fadbad/det_lu.cpp
168	164

+38

-39

doc/fadbad_det_minor.cpp.xml less more

5	5	<title>Fadbad Speed: Gradient of Determinant by Minor Expansion</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Fadbad Speed: Gradient of Determinant by Minor Expansion"/>
8		<meta name="keywords" id="keywords" content=" fadbad speed: gradient of determinant by minor expansion link_det_minor speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: gradient determinant minor expansion link_det_minor speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

113	113	extern bool global_memory, global_onetape, global_atomic, global_optimize;
114	114
115	115	bool link_det_minor(
116		size_t size ,
117		size_t repeat ,
118		CppAD::vector<double> &matrix ,
119		CppAD::vector<double> &gradient )
	116	size_t size ,
	117	size_t repeat ,
	118	CppAD::vector<double> &matrix ,
	119	CppAD::vector<double> &gradient )
120	120	{
121		// speed test global option values
122		if( global_atomic )
123		return false;
124		if( global_memory \|\| global_onetape \|\| global_optimize )
125		return false;
126		// -----------------------------------------------------
127		// setup
	121	// speed test global option values
	122	if( global_atomic )
	123	return false;
	124	if( global_memory \|\| global_onetape \|\| global_optimize )
	125	return false;
	126	// -----------------------------------------------------
	127	// setup
128	128
129		// object for computing determinant
130		typedef fadbad::B<double> ADScalar;
131		typedef CppAD::vector<ADScalar> ADVector;
132		CppAD::det_by_minor<ADScalar> Det(size);
	129	// object for computing determinant
	130	typedef fadbad::B<double> ADScalar;
	131	typedef CppAD::vector<ADScalar> ADVector;
	132	CppAD::det_by_minor<ADScalar> Det(size);
133	133
134		size_t i; // temporary index
135		size_t m = 1; // number of dependent variables
136		size_t n = size * size; // number of independent variables
137		ADScalar detA; // AD value of the determinant
138		ADVector A(n); // AD version of matrix
	134	size_t i; // temporary index
	135	size_t m = 1; // number of dependent variables
	136	size_t n = size * size; // number of independent variables
	137	ADScalar detA; // AD value of the determinant
	138	ADVector A(n); // AD version of matrix
139	139
140		// ------------------------------------------------------
141		while(repeat--)
142		{ // get the next matrix
143		CppAD::uniform_01(n, matrix);
	140	// ------------------------------------------------------
	141	while(repeat--)
	142	{ // get the next matrix
	143	CppAD::uniform_01(n, matrix);
144	144
145		// set independent variable values
146		for(i = 0; i < n; i++)
147		A[i] = matrix[i];
	145	// set independent variable values
	146	for(i = 0; i < n; i++)
	147	A[i] = matrix[i];
148	148
149		// compute the determinant
150		detA = Det(A);
	149	// compute the determinant
	150	detA = Det(A);
151	151
152		// create function object f : A -> detA
153		detA.diff(0, m); // index 0 of m dependent variables
	152	// create function object f : A -> detA
	153	detA.diff(0, m); // index 0 of m dependent variables
154	154
155		// evaluate and return gradient using reverse mode
156		for(i =0; i < n; i++)
157		gradient[i] = A[i].d(0); // partial detA w.r.t A[i]
158		}
159		// ---------------------------------------------------------
160		return true;
	155	// evaluate and return gradient using reverse mode
	156	for(i =0; i < n; i++)
	157	gradient[i] = A[i].d(0); // partial detA w.r.t A[i]
	158	}
	159	// ---------------------------------------------------------
	160	return true;
161	161	}
162	162	</pre></font></code>
163
164	163
165	164	<hr/>Input File: speed/fadbad/det_minor.cpp
166	165

+40

-44

doc/fadbad_mat_mul.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Fadbad Speed: Matrix Multiplication</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

116	113	extern bool global_memory, global_onetape, global_atomic, global_optimize;
117	114
118	115	bool link_mat_mul(
119		size_t size ,
120		size_t repeat ,
121		CppAD::vector<double>& x ,
122		CppAD::vector<double>& z ,
123		CppAD::vector<double>& dz )
	116	size_t size ,
	117	size_t repeat ,
	118	CppAD::vector<double>& x ,
	119	CppAD::vector<double>& z ,
	120	CppAD::vector<double>& dz )
124	121	{
125		// speed test global option values
126		if( global_memory \|\| global_onetape \|\| global_atomic \|\| global_optimize )
127		return false;
128		// The correctness check for this test is failing, so abort (for now).
129		return false;
	122	// speed test global option values
	123	if( global_memory \|\| global_onetape \|\| global_atomic \|\| global_optimize )
	124	return false;
	125	// The correctness check for this test is failing, so abort (for now).
	126	return false;
130	127
131		// -----------------------------------------------------
132		// setup
	128	// -----------------------------------------------------
	129	// setup
133	130
134		// object for computing determinant
135		typedef fadbad::B<double> ADScalar;
136		typedef CppAD::vector<ADScalar> ADVector;
	131	// object for computing determinant
	132	typedef fadbad::B<double> ADScalar;
	133	typedef CppAD::vector<ADScalar> ADVector;
137	134
138		size_t j; // temporary index
139		size_t m = 1; // number of dependent variables
140		size_t n = size * size; // number of independent variables
141		ADVector X(n); // AD domain space vector
142		ADVector Y(n); // Store product matrix
143		ADVector Z(m); // AD range space vector
	135	size_t j; // temporary index
	136	size_t m = 1; // number of dependent variables
	137	size_t n = size * size; // number of independent variables
	138	ADVector X(n); // AD domain space vector
	139	ADVector Y(n); // Store product matrix
	140	ADVector Z(m); // AD range space vector
144	141
145		// ------------------------------------------------------
146		while(repeat--)
147		{ // get the next matrix
148		CppAD::uniform_01(n, x);
	142	// ------------------------------------------------------
	143	while(repeat--)
	144	{ // get the next matrix
	145	CppAD::uniform_01(n, x);
149	146
150		// set independent variable values
151		for(j = 0; j < n; j++)
152		X[j] = x[j];
	147	// set independent variable values
	148	for(j = 0; j < n; j++)
	149	X[j] = x[j];
153	150
154		// do the computation
155		mat_sum_sq(size, X, Y, Z);
	151	// do the computation
	152	mat_sum_sq(size, X, Y, Z);
156	153
157		// create function object f : X -> Z
158		Z[0].diff(0, m); // index 0 of m dependent variables
	154	// create function object f : X -> Z
	155	Z[0].diff(0, m); // index 0 of m dependent variables
159	156
160		// evaluate and return gradient using reverse mode
161		for(j = 0; j < n; j++)
162		dz[j] = X[j].d(0); // partial Z[0] w.r.t X[j]
163		}
164		// return function value
165		z[0] = Z[0].x();
	157	// evaluate and return gradient using reverse mode
	158	for(j = 0; j < n; j++)
	159	dz[j] = X[j].d(0); // partial Z[0] w.r.t X[j]
	160	}
	161	// return function value
	162	z[0] = Z[0].x();
166	163
167		// ---------------------------------------------------------
168		return true;
	164	// ---------------------------------------------------------
	165	return true;
169	166	}
170	167	</pre></font></code>
171
172	168
173	169	<hr/>Input File: speed/fadbad/mat_mul.cpp
174	170

+42

-46

doc/fadbad_ode.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Fadbad Speed: Ode</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

118	115	extern bool global_memory, global_onetape, global_atomic, global_optimize;
119	116
120	117	namespace fadbad {
121		// define fabs for use by ode_evaluate
122		fadbad::F<double> fabs(const fadbad::F<double>& x)
123		{ return std::max(-x, x); }
	118	// define fabs for use by ode_evaluate
	119	fadbad::F<double> fabs(const fadbad::F<double>& x)
	120	{ return std::max(-x, x); }
124	121	}
125	122
126	123	bool link_ode(
127		size_t size ,
128		size_t repeat ,
129		CppAD::vector<double> &x ,
130		CppAD::vector<double> &jacobian
	124	size_t size ,
	125	size_t repeat ,
	126	CppAD::vector<double> &x ,
	127	CppAD::vector<double> &jacobian
131	128	)
132	129	{
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
140		assert( x.size() == size );
141		assert( jacobian.size() == size * size );
	130	// speed test global option values
	131	if( global_atomic )
	132	return false;
	133	if( global_memory \|\| global_onetape \|\| global_optimize )
	134	return false;
	135	// -------------------------------------------------------------
	136	// setup
	137	assert( x.size() == size );
	138	assert( jacobian.size() == size * size );
142	139
143		typedef fadbad::F<double> ADScalar;
144		typedef CppAD::vector<ADScalar> ADVector;
	140	typedef fadbad::F<double> ADScalar;
	141	typedef CppAD::vector<ADScalar> ADVector;
145	142
146		size_t i, j;
147		size_t p = 0; // use ode to calculate function values
148		size_t n = size; // number of independent variables
149		size_t m = n; // number of dependent variables
150		ADVector X(n), Y(m); // independent and dependent variables
	143	size_t i, j;
	144	size_t p = 0; // use ode to calculate function values
	145	size_t n = size; // number of independent variables
	146	size_t m = n; // number of dependent variables
	147	ADVector X(n), Y(m); // independent and dependent variables
151	148
152		// -------------------------------------------------------------
153		while(repeat--)
154		{ // choose next x value
155		CppAD::uniform_01(n, x);
156		for(j = 0; j < n; j++)
157		{ // set value of x[j]
158		X[j] = x[j];
159		// set up for X as the independent variable vector
160		X[j].diff(j, n);
161		}
	149	// -------------------------------------------------------------
	150	while(repeat--)
	151	{ // choose next x value
	152	CppAD::uniform_01(n, x);
	153	for(j = 0; j < n; j++)
	154	{ // set value of x[j]
	155	X[j] = x[j];
	156	// set up for X as the independent variable vector
	157	X[j].diff(j, n);
	158	}
162	159
163		// evaluate function
164		CppAD::ode_evaluate(X, p, Y);
	160	// evaluate function
	161	CppAD::ode_evaluate(X, p, Y);
165	162
166		// return values with Y as the dependent variable vector
167		for(i = 0; i < m; i++)
168		{ for(j = 0; j < n; j++)
169		jacobian[ i * n + j ] = Y[i].d(j);
170		}
171		}
172		return true;
	163	// return values with Y as the dependent variable vector
	164	for(i = 0; i < m; i++)
	165	{ for(j = 0; j < n; j++)
	166	jacobian[ i * n + j ] = Y[i].d(j);
	167	}
	168	}
	169	return true;
173	170	}
174	171	</pre></font></code>
175
176	172
177	173	<hr/>Input File: speed/fadbad/ode.cpp
178	174

+40

-44

doc/fadbad_poly.cpp.xml less more

5	5	<title>Fadbad Speed: Second Derivative of a Polynomial</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Fadbad Speed: Second Derivative of a Polynomial"/>
8		<meta name="keywords" id="keywords" content=" fadbad speed: second derivative of a polynomial link_poly speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" fadbad speed: second derivative polynomial link_poly speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Fadbad Speed: Second Derivative of a Polynomial</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

116	113	extern bool global_memory, global_onetape, global_atomic, global_optimize;
117	114
118	115	bool link_poly(
119		size_t size ,
120		size_t repeat ,
121		CppAD::vector<double> &a , // coefficients of polynomial
122		CppAD::vector<double> &z , // polynomial argument value
123		CppAD::vector<double> &ddp ) // second derivative w.r.t z
	116	size_t size ,
	117	size_t repeat ,
	118	CppAD::vector<double> &a , // coefficients of polynomial
	119	CppAD::vector<double> &z , // polynomial argument value
	120	CppAD::vector<double> &ddp ) // second derivative w.r.t z
124	121	{
125		if( global_atomic )
126		return false;
127		if( global_memory \|\| global_onetape \|\| global_optimize )
128		return false;
129		// -----------------------------------------------------
130		// setup
131		size_t i; // temporary index
132		fadbad::T<double> Z; // domain space AD value
133		fadbad::T<double> P; // range space AD value
	122	if( global_atomic )
	123	return false;
	124	if( global_memory \|\| global_onetape \|\| global_optimize )
	125	return false;
	126	// -----------------------------------------------------
	127	// setup
	128	size_t i; // temporary index
	129	fadbad::T<double> Z; // domain space AD value
	130	fadbad::T<double> P; // range space AD value
134	131
135		// choose the polynomial coefficients
136		CppAD::uniform_01(size, a);
	132	// choose the polynomial coefficients
	133	CppAD::uniform_01(size, a);
137	134
138		// AD copy of the polynomial coefficients
139		CppAD::vector< fadbad::T<double> > A(size);
140		for(i = 0; i < size; i++)
141		A[i] = a[i];
	135	// AD copy of the polynomial coefficients
	136	CppAD::vector< fadbad::T<double> > A(size);
	137	for(i = 0; i < size; i++)
	138	A[i] = a[i];
142	139
143		// ------------------------------------------------------
144		while(repeat--)
145		{ // get the next argument value
146		CppAD::uniform_01(1, z);
	140	// ------------------------------------------------------
	141	while(repeat--)
	142	{ // get the next argument value
	143	CppAD::uniform_01(1, z);
147	144
148		// independent variable value
149		Z = z[0]; // argument value
150		Z[1] = 1; // argument first order Taylor coefficient
	145	// independent variable value
	146	Z = z[0]; // argument value
	147	Z[1] = 1; // argument first order Taylor coefficient
151	148
152		// AD computation of the dependent variable
153		P = CppAD::Poly(0, A, Z);
	149	// AD computation of the dependent variable
	150	P = CppAD::Poly(0, A, Z);
154	151
155		// Taylor-expand P to degree one
156		P.eval(2);
	152	// Taylor-expand P to degree one
	153	P.eval(2);
157	154
158		// second derivative is twice second order Taylor coefficient
159		ddp[0] = 2. * P[2];
	155	// second derivative is twice second order Taylor coefficient
	156	ddp[0] = 2. * P[2];
160	157
161		// Free DAG corresponding to P does not seem to improve speed.
162		// Probably because it gets freed the next time P is assigned.
163		// P.reset();
164		}
165		// ------------------------------------------------------
166		return true;
	158	// Free DAG corresponding to P does not seem to improve speed.
	159	// Probably because it gets freed the next time P is assigned.
	160	// P.reset();
	161	}
	162	// ------------------------------------------------------
	163	return true;
167	164	}
168	165	</pre></font></code>
169
170	166
171	167	<hr/>Input File: speed/fadbad/poly.cpp
172	168

+3

-6

doc/fadbad_sparse_hessian.cpp.xml less more

85	85	<td>fadbad_sparse_hessian.cpp</td>
86	86	<td>Headings</td>
87	87	</tr></table><br/>
88
89
90
91	88	<center><b><big><big>Fadbad Speed: Sparse Hessian</big></big></b></center>
92		<code><font color='blue'><pre style='display:inline'> // A fadbad version of this test is not yet available
	89	<code><font color='blue'><pre style='display:inline'>
	90	// A fadbad version of this test is not yet available
93	91	bool link_sparse_hessian(
94	92	size_t size ,
95	93	size_t repeat ,

100	98	size_t& n_sweep
101	99	)
102	100	{
103		return false;
	101	return false;
104	102	}
105	103	</pre></font></code>
106
107	104
108	105	<hr/>Input File: speed/fadbad/sparse_hessian.cpp
109	106

+11

-14

doc/fadbad_sparse_jacobian.cpp.xml less more

85	85	<td>fadbad_sparse_jacobian.cpp</td>
86	86	<td>Headings</td>
87	87	</tr></table><br/>
88
89
90
91	88	<center><b><big><big>fadbad Speed: sparse_jacobian</big></big></b></center>
92		<code><font color='blue'><pre style='display:inline'> // A fadbad version of this test is not yet available
	89	<code><font color='blue'><pre style='display:inline'>
	90	// A fadbad version of this test is not yet available
93	91	bool link_sparse_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 )
	92	size_t size ,
	93	size_t repeat ,
	94	size_t m ,
	95	const CppAD::vector<size_t>& row ,
	96	const CppAD::vector<size_t>& col ,
	97	CppAD::vector<double>& x ,
	98	CppAD::vector<double>& jacobian ,
	99	size_t& n_sweep )
102	100	{
103		return false;
	101	return false;
104	102	}
105	103	</pre></font></code>
106
107	104
108	105	<hr/>Input File: speed/fadbad/sparse_jacobian.cpp
109	106

+2

-3

doc/faq.xml less more

5	5	<title>Frequently Asked Questions and Answers</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Frequently Asked Questions and Answers"/>
8		<meta name="keywords" id="keywords" content=" frequently asked questions and answers Faq operator reporting Errorhandler avoid record taping mode Cppad_testvector standard math function storage assignment independent bugs comparechange complex types exceptions variables matrix inverse mode: forward or reverse namespace test vector preprocessor symbol using speed ndebug optimize memory allocation tape storage: disk "/>
	8	<meta name="keywords" id="keywords" content=" frequently asked questions answers Faq operator reporting Errorhandler avoid record taping mode Cppad_testvector standard math function storage assignment independent bugs comparechange complex types exceptions variables matrix inverse mode: forward reverse namespace test vector preprocessor symbol using speed ndebug optimize memory allocation tape storage: disk "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

313	313	<br/>
314	314	Why do I have trouble when the following command
315	315	<code><font color='blue'><pre style='display:inline'>
316		using namespace CppAD
	316	using namespace CppAD
317	317	</pre></font></code>
318
319	318	is at the global level
320	319	(not within a function or some other limited scope).
321	320	<code><span style='white-space: nowrap'><br/>

+1

-1

doc/for_one.cpp.xml less more

5	5	<title>First Order Partial Driver: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="First Order Partial Driver: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" first order partial driver: example and test "/>
	8	<meta name="keywords" id="keywords" content=" first order partial driver: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/for_sparse_jac.cpp.xml less more

5	5	<title>Forward Mode Jacobian Sparsity: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Forward Mode Jacobian Sparsity: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" forward mode jacobian sparsity: example and test Forsparsejac sparsity "/>
	8	<meta name="keywords" id="keywords" content=" forward mode jacobian sparsity: example test Forsparsejac sparsity "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/for_two.cpp.xml less more

5	5	<title>Subset of Second Order Partials: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Subset of Second Order Partials: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" subset of second order partials: example and test partial "/>
	8	<meta name="keywords" id="keywords" content=" subset second order partials: example test partial "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/forward.cpp.xml less more

5	5	<title>Forward Mode: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Forward Mode: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" forward mode: example and test "/>
	8	<meta name="keywords" id="keywords" content=" forward mode: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/forward_dir.cpp.xml less more

5	5	<title>Forward Mode: Example and Test of Multiple Directions</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	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 "/>
	8	<meta name="keywords" id="keywords" content=" forward mode: example test multiple directions orders order "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/forward_order.cpp.xml less more

5	5	<title>Forward Mode: Example and Test of Multiple Orders</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	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 "/>
	8	<meta name="keywords" id="keywords" content=" forward mode: example test multiple orders "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/forwardtheory.xml less more

5	5	<title>The Theory of Forward Mode</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The Theory of Forward Mode"/>
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	<meta name="keywords" id="keywords" content=" the theory forward mode taylor notation binary operators addition subtraction multiplication division standard math functions differential equation coefficients recursion formula cases that apply above special "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/fun_assign.cpp.xml less more

5	5	<title>ADFun Assignment: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="ADFun Assignment: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" adfun assignment: example and test assignment "/>
	8	<meta name="keywords" id="keywords" content=" adfun assignment: example test assignment "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/fun_check.cpp.xml less more

5	5	<title>ADFun Check and Re-Tape: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="ADFun Check and Re-Tape: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" adfun check and re-tape: example test Funcheck Dependent "/>
	8	<meta name="keywords" id="keywords" content=" adfun check re-tape: example test Funcheck Dependent "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/funcheck.xml less more

5	5	<title>Check an ADFun Sequence of Operations</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Check an ADFun Sequence of Operations"/>
8		<meta name="keywords" id="keywords" content=" check an adfun sequence of operations syntax purpose f g x y r a ok vector funcheck uses forward discussion example "/>
	8	<meta name="keywords" id="keywords" content=" check adfun sequence operations syntax purpose f g x y r ok vector funcheck uses forward discussion example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/funconstruct.xml less more

5	5	<title>Construct an ADFun Object and Stop Recording</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Construct an ADFun Object and Stop Recording"/>
8		<meta name="keywords" id="keywords" content=" construct an adfun object and stop recording tape syntax purpose x y vectorad default constructor sequence copy assignment operator taylor coefficients sparsity patterns parallel mode example "/>
	8	<meta name="keywords" id="keywords" content=" construct adfun object stop recording tape syntax purpose x y vectorad default constructor sequence copy assignment operator taylor coefficients sparsity patterns parallel mode example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/funeval.xml less more

5	5	<title>Evaluate ADFun Functions, Derivatives, and Sparsity Patterns</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Evaluate ADFun Functions, Derivatives, and Sparsity Patterns"/>
8		<meta name="keywords" id="keywords" content=" evaluate adfun functions derivatives and sparsity patterns "/>
	8	<meta name="keywords" id="keywords" content=" evaluate adfun functions derivatives sparsity patterns "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/get_adolc.sh.xml less more

5	5	<title>Download and Install Adolc in Build Directory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Download and Install Adolc in Build Directory"/>
8		<meta name="keywords" id="keywords" content=" download and install adolc in build directory syntax purpose requirements distribution external prefix reuse "/>
	8	<meta name="keywords" id="keywords" content=" download install adolc build directory syntax purpose requirements distribution external prefix reuse "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/get_colpack.sh.xml less more

5	5	<title>Download and Install ColPack in Build Directory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Download and Install ColPack in Build Directory"/>
8		<meta name="keywords" id="keywords" content=" download and install colpack in build directory syntax purpose distribution external prefix reuse "/>
	8	<meta name="keywords" id="keywords" content=" download install colpack build directory syntax purpose distribution external prefix reuse "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/get_eigen.sh.xml less more

5	5	<title>Download and Install Eigen in Build Directory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Download and Install Eigen in Build Directory"/>
8		<meta name="keywords" id="keywords" content=" download and install eigen in build directory syntax purpose distribution external prefix reuse "/>
	8	<meta name="keywords" id="keywords" content=" download install eigen build directory and syntax purpose distribution external prefix reuse "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/get_fadbad.sh.xml less more

5	5	<title>Download and Install Fadbad in Build Directory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Download and Install Fadbad in Build Directory"/>
8		<meta name="keywords" id="keywords" content=" download and install fadbad in build directory syntax purpose distribution external prefix "/>
	8	<meta name="keywords" id="keywords" content=" download install fadbad build directory and syntax purpose distribution external prefix "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/get_ipopt.sh.xml less more

5	5	<title>Download and Install Ipopt in Build Directory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Download and Install Ipopt in Build Directory"/>
8		<meta name="keywords" id="keywords" content=" download and install ipopt in build directory syntax purpose distribution external prefix reuse "/>
	8	<meta name="keywords" id="keywords" content=" download install ipopt build directory and syntax purpose distribution external prefix reuse "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/get_sacado.sh.xml less more

5	5	<title>Download and Install Sacado in Build Directory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Download and Install Sacado in Build Directory"/>
8		<meta name="keywords" id="keywords" content=" download and install sacado in build directory syntax purpose distribution external prefix reuse "/>
	8	<meta name="keywords" id="keywords" content=" download install sacado build directory and syntax purpose distribution external prefix reuse "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-6

doc/get_started.cpp.xml less more

449	449	return error_code;
450	450	}
451	451	</pre></font></code>
452
453		<br/>
454	452	<br/>
455	453	<b><big><a name="Output" id="Output">Output</a></big></b>
456	454	<br/>
457	455	Executing the program above will generate the following output:
458	456	<code><font color='blue'><pre style='display:inline'>
459		f'(3) computed by CppAD = 142
	457	f'(3) computed by CppAD = 142
460	458	</pre></font></code>
461
462
463		<br/>
464	459	<br/>
465	460	<b><big><a name="Running" id="Running">Running</a></big></b>
466	461	<br/>

+1

-1

doc/glossary.xml less more

5	5	<title>Glossary</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Glossary"/>
8		<meta name="keywords" id="keywords" content=" efficient ad function of base type above elementary vector operation atomic sequence dependent independent parameter sparsity pattern boolean sets tape active inactive variable variables taylor coefficient "/>
	8	<meta name="keywords" id="keywords" content=" efficient ad function base type above elementary vector operation atomic sequence dependent independent parameter sparsity pattern boolean sets tape active inactive variable variables taylor coefficient "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/harmonic.cpp.xml less more

5	5	<title>Multi-Threaded Implementation of Summation of 1/i</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Multi-Threaded Implementation of Summation of 1/i"/>
8		<meta name="keywords" id="keywords" content=" multi-threaded implementation of summation 1/i harmonic multi_thread syntax ok sum num_sum num_threads source "/>
	8	<meta name="keywords" id="keywords" content=" multi-threaded implementation summation 1/i harmonic multi_thread syntax ok sum num_sum num_threads source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/harmonic_time.cpp.xml less more

5	5	<title>Timing Test of Multi-Threaded Summation of 1/i</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Timing Test of Multi-Threaded Summation of 1/i"/>
8		<meta name="keywords" id="keywords" content=" timing test of multi-threaded summation 1/i harmonic_time multi_thread speed syntax purpose ok time_out test_time num_threads mega_sum source "/>
	8	<meta name="keywords" id="keywords" content=" timing test multi-threaded summation 1/i harmonic_time multi_thread speed syntax purpose ok time_out test_time num_threads mega_sum source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/harmonic_work.cpp.xml less more

5	5	<title>Multi-threading Sum of 1/i Utility Routines</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Multi-threading Sum of 1/i Utility Routines"/>
8		<meta name="keywords" id="keywords" content=" multi-threading sum of 1/i utility routines harmonic_work setup worker combine syntax purpose harmonic_setup num_sum num_threads harmonic_worker harmonic_combine source "/>
	8	<meta name="keywords" id="keywords" content=" multi-threading sum 1/i utility routines harmonic_work setup worker combine syntax purpose harmonic_setup num_sum num_threads harmonic_worker harmonic_combine source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/hes_lagrangian.cpp.xml less more

5	5	<title>Hessian of Lagrangian and ADFun Default Constructor: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Hessian of Lagrangian and ADFun Default Constructor: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" hessian of lagrangian and adfun default constructor: example test Heslagrangian constructor "/>
	8	<meta name="keywords" id="keywords" content=" hessian lagrangian adfun default constructor: example test Heslagrangian constructor "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/hes_lu_det.cpp.xml less more

5	5	<title>Gradient of Determinant Using LU Factorization: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Gradient of Determinant Using LU Factorization: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" gradient of determinant using lu factorization: example and test "/>
	8	<meta name="keywords" id="keywords" content=" gradient determinant using lu factorization: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/hes_minor_det.cpp.xml less more

5	5	<title>Gradient of Determinant Using Expansion by Minors: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Gradient of Determinant Using Expansion by Minors: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" gradient of determinant using expansion by minors: example and test minors "/>
	8	<meta name="keywords" id="keywords" content=" gradient determinant using expansion minors: example test minors "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/hes_times_dir.cpp.xml less more

5	5	<title>Hessian Times Direction: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Hessian Times Direction: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" hessian times direction: example and test direction "/>
	8	<meta name="keywords" id="keywords" content=" hessian times direction: example test direction "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/hessian.cpp.xml less more

5	5	<title>Hessian: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Hessian: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" hessian: example and test Hessian "/>
	8	<meta name="keywords" id="keywords" content=" hessian: example test Hessian "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+4

-13

doc/include_deprecated.xml less more

108	108	The <a href="utility.xml" target="_top"><span style='white-space: nowrap'>utility</span></a>
109	109	individual include files have been deprecated; e.g.,
110	110	<code><font color='blue'><pre style='display:inline'>
111		# include <cppad/runge_45.hpp>
	111	# include <cppad/runge_45.hpp>
112	112	</pre></font></code>
113
114	113	You should instead use
115	114	<code><font color='blue'><pre style='display:inline'>
116		# include <cppad/utility.hpp>
	115	# include <cppad/utility.hpp>
117	116	</pre></font></code>
118
119
120		<br/>
121	117	<br/>
122	118	<b><big><a name="Deprecated 2006-12-17" id="Deprecated 2006-12-17">Deprecated 2006-12-17</a></big></b>
123	119	<br/>

125	121	and the corresponding names that should be used.
126	122	For example, if your program uses the deprecated preprocessor command
127	123	<code><font color='blue'><pre style='display:inline'>
128		# include <CppAD/CppAD.h>
	124	# include <CppAD/CppAD.h>
129	125	</pre></font></code>
130
131	126	you should change it to the command
132	127	<code><font color='blue'><pre style='display:inline'>
133		# include <cppad/cppad.hpp>
	128	# include <cppad/cppad.hpp>
134	129	</pre></font></code>
135
136
137
138		<br/>
139	130	<br/>
140	131	<b><big><a name="Linking New Files to Deprecated Commands" id="Linking New Files to Deprecated Commands">Linking New Files to Deprecated Commands</a></big></b>
141	132	<br/>

+1

-1

doc/independent.cpp.xml less more

5	5	<title>Independent and ADFun Constructor: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Independent and ADFun Constructor: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" independent and adfun constructor: example test "/>
	8	<meta name="keywords" id="keywords" content=" independent adfun constructor: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/independent.xml less more

5	5	<title>Declare Independent Variables and Start Recording</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Declare Independent Variables and Start Recording"/>
8		<meta name="keywords" id="keywords" content=" declare independent variables and start recording syntax purpose stop x abort_op_index vectorad parallel mode example "/>
	8	<meta name="keywords" id="keywords" content=" declare independent variables start recording syntax purpose stop x abort_op_index vectorad parallel mode example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/index_sort.cpp.xml less more

5	5	<title>Index Sort: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Index Sort: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" index sort: example and test index_sort "/>
	8	<meta name="keywords" id="keywords" content=" index sort: example test index_sort "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/index_sort.xml less more

5	5	<title>Returns Indices that Sort a Vector</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Returns Indices that Sort a Vector"/>
8		<meta name="keywords" id="keywords" content=" returns indices that sort a vector index_sort syntax keys ind input return example "/>
	8	<meta name="keywords" id="keywords" content=" returns indices that sort vector index_sort syntax keys ind input return example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+3

-5

doc/install.xml less more

5	5	<title>CppAD Download, Test, and Install Instructions</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD Download, Test, and Install Instructions"/>
8		<meta name="keywords" id="keywords" content=" cppad download test and install instructions step 1: 2: cmake 3: check 4: installation "/>
	8	<meta name="keywords" id="keywords" content=" cppad download test install instructions step 1: 2: cmake 3: check 4: installation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

111	111	<br/>
112	112	Use the command
113	113	<code><font color='blue'><pre style='display:inline'>
114		make install
	114	make install
115	115	</pre></font></code>
116
117	116	to install CppAD.
118	117	If you created <code><font color="blue">nmake</font></code> makefiles, you will have
119	118	to use
120	119	<code><font color='blue'><pre style='display:inline'>
121		nmake install
	120	nmake install
122	121	</pre></font></code>
123
124	122	see the
125	123	<a href="cmake.xml#generator" target="_top"><span style='white-space: nowrap'>generator</span></a>
126	124	option for the <code><font color="blue">cmake</font></code> command.

+1

-1

doc/integer.cpp.xml less more

5	5	<title>Convert From AD to Integer: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Convert From AD to Integer: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" convert from ad to integer: example and test Integer "/>
	8	<meta name="keywords" id="keywords" content=" convert from ad to integer: example test Integer "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/interface2c.cpp.xml less more

5	5	<title>Interfacing to C: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Interfacing to C: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" interfacing to c: example and test C interface difference central "/>
	8	<meta name="keywords" id="keywords" content=" interfacing to c: example test C interface difference central "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/interp_onetape.cpp.xml less more

5	5	<title>Interpolation With Out Retaping: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Interpolation With Out Retaping: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" interpolation with out retaping: example and test interpolate tape retape see also "/>
	8	<meta name="keywords" id="keywords" content=" interpolation with out retaping: example test interpolate tape retape see also "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/interp_retape.cpp.xml less more

5	5	<title>Interpolation With Retaping: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Interpolation With Retaping: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" interpolation with retaping: example and test interpolate tape retape see also "/>
	8	<meta name="keywords" id="keywords" content=" interpolation with retaping: example test interpolate tape retape see also "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/introduction.xml less more

5	5	<title>An Introduction by Example to Algorithmic Differentiation</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="An Introduction by Example to Algorithmic Differentiation"/>
8		<meta name="keywords" id="keywords" content=" an introduction by example to algorithmic differentiation Ad Automatic purpose preface forward mode reverse operation count efficiency outline reference "/>
	8	<meta name="keywords" id="keywords" content=" introduction example to algorithmic differentiation Ad Automatic purpose preface forward mode reverse operation count efficiency outline reference "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ipopt_nlp_get_started.cpp.xml less more

5	5	<title>Nonlinear Programming Using CppAD and Ipopt: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Nonlinear Programming Using CppAD and Ipopt: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" nonlinear programming using cppad and ipopt: example test ipopt Ad purpose configuration requirement "/>
	8	<meta name="keywords" id="keywords" content=" nonlinear programming using cppad ipopt: example test ipopt Ad purpose configuration requirement "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ipopt_nlp_ode.xml less more

5	5	<title>Example Simultaneous Solution of Forward and Inverse Problem</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Example Simultaneous Solution of Forward and Inverse Problem"/>
8		<meta name="keywords" id="keywords" content=" example simultaneous solution of forward and inverse problem "/>
	8	<meta name="keywords" id="keywords" content=" example simultaneous solution forward inverse problem "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+3

-3

doc/ipopt_nlp_ode_check.cpp.xml less more

5	5	<title>Correctness Check for Both Simple and Fast Representations</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Correctness Check for Both Simple and Fast Representations"/>
8		<meta name="keywords" id="keywords" content=" correctness check for both simple and fast representations "/>
	8	<meta name="keywords" id="keywords" content=" correctness check both simple fast representations "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

113	113	{ y_0[j] = x[j];
114	114	y_1[j] = x[Ny + j];
115	115	y_2[j] = x[2 * Ny + j];
116		}
	116	}
117	117
118	118	// Check some of the optimal a value
119	119	Number rel_tol = max_step * max_step;

121	121	Number check_a[] = {a0, a1, a2}; // see the y_one function
122	122	for(j = 0; j < Na; j++)
123	123	{
124		ok &= CppAD::<a href="nearequal.xml" target="_top">NearEqual</a>(
	124	ok &= CppAD::<a href="nearequal.xml" target="_top">NearEqual</a>(
125	125	check_a[j], a[j], rel_tol, abs_tol
126	126	);
127	127	}

+1

-1

doc/ipopt_nlp_ode_problem.xml less more

5	5	<title>An ODE Inverse Problem Example</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="An ODE Inverse Problem 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	<meta name="keywords" id="keywords" content=" ode inverse problem example notation forward measurements simulation analytic solution parameter values simulated measurement trapezoidal approximation time grid black box method two levels iteration derivatives simultaneous source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ipopt_nlp_ode_run.hpp.xml less more

5	5	<title>Driver for Running the Ipopt ODE Example</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Driver for Running the Ipopt ODE Example"/>
8		<meta name="keywords" id="keywords" content=" driver for running the ipopt ode example "/>
	8	<meta name="keywords" id="keywords" content=" driver running the ipopt ode example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ipopt_ode_speed.cpp.xml less more

5	5	<title>Speed Test for Both Simple and Fast Representations</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Speed Test for Both Simple and Fast Representations"/>
8		<meta name="keywords" id="keywords" content=" speed test for both simple and fast representations "/>
	8	<meta name="keywords" id="keywords" content=" speed test both simple fast representations "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ipopt_prefix.xml less more

5	5	<title>Including the cppad_ipopt Library and Tests</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Including the cppad_ipopt Library and Tests"/>
8		<meta name="keywords" id="keywords" content=" including the cppad_ipopt library and tests ipopt cppad prefix get purpose ipopt_prefix examples get_ipopt "/>
	8	<meta name="keywords" id="keywords" content=" including the cppad_ipopt library tests ipopt cppad prefix get purpose ipopt_prefix examples get_ipopt "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ipopt_solve.xml less more

5	5	<title>Use Ipopt to Solve a Nonlinear Programming Problem</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Use Ipopt to Solve a Nonlinear Programming Problem"/>
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	<meta name="keywords" id="keywords" content=" use ipopt to solve 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ipopt_solve_get_started.cpp.xml less more

5	5	<title>Nonlinear Programming Using CppAD and Ipopt: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Nonlinear Programming Using CppAD and Ipopt: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" nonlinear programming using cppad and ipopt: example test ipopt Ad purpose configuration requirement "/>
	8	<meta name="keywords" id="keywords" content=" nonlinear programming using cppad ipopt: example test ipopt Ad purpose configuration requirement "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ipopt_solve_retape.cpp.xml less more

5	5	<title>Nonlinear Programming Retaping: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Nonlinear Programming Retaping: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" nonlinear programming retaping: example and test retape ipopt_solve purpose "/>
	8	<meta name="keywords" id="keywords" content=" nonlinear programming retaping: example test retape ipopt_solve purpose "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/jac_lu_det.cpp.xml less more

5	5	<title>Gradient of Determinant Using Lu Factorization: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Gradient of Determinant Using Lu Factorization: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" gradient of determinant using lu factorization: example and test "/>
	8	<meta name="keywords" id="keywords" content=" gradient determinant using lu factorization: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/jac_minor_det.cpp.xml less more

5	5	<title>Gradient of Determinant Using Expansion by Minors: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Gradient of Determinant Using Expansion by Minors: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" gradient of determinant using expansion by minors: example and test minors "/>
	8	<meta name="keywords" id="keywords" content=" gradient determinant using expansion minors: example test minors "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/jacobian.cpp.xml less more

5	5	<title>Jacobian: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Jacobian: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" jacobian: example and test Jacobian "/>
	8	<meta name="keywords" id="keywords" content=" jacobian: example test Jacobian "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/jacobian.xml less more

5	5	<title>Jacobian: Driver Routine</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Jacobian: Driver Routine"/>
8		<meta name="keywords" id="keywords" content=" jacobian: driver routine Jacobian first derivative syntax purpose f x jac vector forward or reverse example "/>
	8	<meta name="keywords" id="keywords" content=" jacobian: driver routine Jacobian first derivative syntax purpose f x jac vector forward reverse example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/license.xml less more

5	5	<title>Your License for the CppAD Software</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Your License for the CppAD Software"/>
8		<meta name="keywords" id="keywords" content=" your license for the cppad software "/>
	8	<meta name="keywords" id="keywords" content=" your license the cppad software "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/link_det_lu.xml less more

5	5	<title>Speed Testing Gradient of Determinant Using Lu Factorization</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Speed Testing Gradient of Determinant Using Lu Factorization"/>
8		<meta name="keywords" id="keywords" content=" speed testing gradient of determinant using lu factorization link_det_lu test prototype purpose method return value size repeat matrix double "/>
	8	<meta name="keywords" id="keywords" content=" speed testing gradient determinant using lu factorization link_det_lu test prototype purpose method return value size repeat matrix double "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/link_det_minor.xml less more

5	5	<title>Speed Testing Gradient of Determinant by Minor Expansion</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Speed Testing Gradient of Determinant by Minor Expansion"/>
8		<meta name="keywords" id="keywords" content=" speed testing gradient of determinant by minor expansion link_det_minor test prototype purpose method return value size repeat matrix double "/>
	8	<meta name="keywords" id="keywords" content=" speed testing gradient determinant minor expansion link_det_minor test prototype purpose method return value size repeat matrix double "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/link_mat_mul.xml less more

5	5	<title>Speed Testing Derivative of Matrix Multiply</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Speed Testing Derivative of Matrix Multiply"/>
8		<meta name="keywords" id="keywords" content=" speed testing derivative of matrix multiply link_mat_mul test multiple prototype purpose return value n repeat x z dz "/>
	8	<meta name="keywords" id="keywords" content=" speed testing derivative matrix multiply link_mat_mul test multiple prototype purpose return value n repeat x z dz "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/link_ode.xml less more

5	5	<title>Speed Testing the Jacobian of Ode Solution</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Speed Testing the Jacobian of Ode Solution"/>
8		<meta name="keywords" id="keywords" content=" speed testing the jacobian of ode solution link_ode test prototype purpose method f return value size repeat x double "/>
	8	<meta name="keywords" id="keywords" content=" speed testing the jacobian ode solution link_ode test prototype purpose method f return value size repeat x double "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/link_poly.xml less more

5	5	<title>Speed Testing Second Derivative of a Polynomial</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Speed Testing Second Derivative of a Polynomial"/>
8		<meta name="keywords" id="keywords" content=" speed testing second derivative of a polynomial link_poly test prototype purpose method return value size repeat z ddp double "/>
	8	<meta name="keywords" id="keywords" content=" speed testing second derivative polynomial link_poly test prototype purpose method return value size repeat z ddp double "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/listallexamples.xml less more

5	5	<title>List of All the CppAD Examples</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="List of All the CppAD Examples"/>
8		<meta name="keywords" id="keywords" content=" list of all the cppad examples "/>
	8	<meta name="keywords" id="keywords" content=" list all the cppad examples "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/log.cpp.xml less more

5	5	<title>The AD log Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD log Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad log function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad log function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/log10.cpp.xml less more

5	5	<title>The AD log10 Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD log10 Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad log10 function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad log10 function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/log1p.cpp.xml less more

5	5	<title>The AD log1p Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD log1p Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad log1p function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad log1p function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/log1p.xml less more

5	5	<title>The Logarithm of One Plus Argument: log1p</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The Logarithm of One Plus Argument: log1p"/>
8		<meta name="keywords" id="keywords" content=" the logarithm of one plus argument: log1p syntax description x y cppad_use_cplusplus_2011 true false example "/>
	8	<meta name="keywords" id="keywords" content=" the logarithm one plus argument: log1p syntax description x y cppad_use_cplusplus_2011 true false example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/lu_factor.cpp.xml less more

5	5	<title>LuFactor: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="LuFactor: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" lufactor: example and test Lufactor "/>
	8	<meta name="keywords" id="keywords" content=" lufactor: example test Lufactor "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/lu_invert.cpp.xml less more

5	5	<title>LuInvert: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="LuInvert: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" luinvert: example and test Luinvert "/>
	8	<meta name="keywords" id="keywords" content=" luinvert: example test Luinvert "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/lu_ratio.cpp.xml less more

5	5	<title>LuRatio: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="LuRatio: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" luratio: example and test Luratio "/>
	8	<meta name="keywords" id="keywords" content=" luratio: example test Luratio "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/lu_solve.cpp.xml less more

5	5	<title>LuSolve With Complex Arguments: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="LuSolve With Complex Arguments: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" lusolve with complex arguments: example and test "/>
	8	<meta name="keywords" id="keywords" content=" lusolve with complex arguments: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/lu_vec_ad.cpp.xml less more

5	5	<title>Lu Factor and Solve with Recorded Pivoting</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Lu Factor and Solve with Recorded Pivoting"/>
8		<meta name="keywords" id="keywords" content=" lu factor and solve with recorded pivoting Luvecad linear equation determinant syntax purpose storage convention n m matrix rhs result logdet example "/>
	8	<meta name="keywords" id="keywords" content=" lu factor solve with recorded pivoting Luvecad linear equation determinant syntax purpose storage convention n m matrix rhs result logdet example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/lu_vec_ad_ok.cpp.xml less more

5	5	<title>Lu Factor and Solve With Recorded Pivoting: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Lu Factor and Solve With Recorded Pivoting: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" lu factor and solve with recorded pivoting: example test record pivot "/>
	8	<meta name="keywords" id="keywords" content=" lu factor solve with recorded pivoting: example test record pivot "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ludetandsolve.xml less more

5	5	<title>Compute Determinants and Solve Equations by LU Factorization</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Compute Determinants and Solve Equations by LU Factorization"/>
8		<meta name="keywords" id="keywords" content=" compute determinants and solve equations by lu factorization matrix factor linear "/>
	8	<meta name="keywords" id="keywords" content=" compute determinants solve equations lu factorization matrix factor linear "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/lufactor.xml less more

5	5	<title>LU Factorization of A Square Matrix</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="LU Factorization of A Square Matrix"/>
8		<meta name="keywords" id="keywords" content=" lu factorization of a square matrix Lufactor linear equation solve syntax description include storage sign ip jp p l u factor determinant sizevector floatvector float absgeq example source "/>
	8	<meta name="keywords" id="keywords" content=" lu factorization square matrix Lufactor linear equation solve syntax description include storage sign ip jp p l u factor determinant sizevector floatvector float absgeq example source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/luinvert.xml less more

5	5	<title>Invert an LU Factored Equation</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Invert an LU Factored Equation"/>
8		<meta name="keywords" id="keywords" content=" invert an lu factored equation Luinvert linear syntax description include matrix storage ip jp l u p a x example source "/>
	8	<meta name="keywords" id="keywords" content=" invert lu factored equation Luinvert linear syntax description include matrix storage ip jp l u p x example source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/luratio.xml less more

5	5	<title>LU Factorization of A Square Matrix and Stability Calculation</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="LU Factorization of A Square Matrix and Stability Calculation"/>
8		<meta name="keywords" id="keywords" content=" lu factorization of a square matrix and stability calculation Luratio linear equation solve syntax description include storage sign ip jp p l u factor determinant ratio purpose sizevector advector example "/>
	8	<meta name="keywords" id="keywords" content=" lu factorization square matrix stability calculation Luratio linear equation solve syntax description include storage sign ip jp p l u factor determinant ratio purpose sizevector advector example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/lusolve.xml less more

5	5	<title>Compute Determinant and Solve Linear Equations</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Compute Determinant and Solve Linear Equations"/>
8		<meta name="keywords" id="keywords" content=" compute determinant and solve linear equations Lusolve Lu syntax description include factor invert matrix storage signdet n m a b x logdet float floatvector leqzero absgeq example source "/>
	8	<meta name="keywords" id="keywords" content=" compute determinant solve linear equations Lusolve Lu syntax description include factor invert matrix storage signdet n m b x logdet float floatvector leqzero absgeq example source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+19

-22

doc/main_compare_c.xml less more

5	5	<title>Main Program For Comparing C and C++ Speed</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Main Program For Comparing C and C++ Speed"/>
8		<meta name="keywords" id="keywords" content=" main program for comparing c and c++ speed source code "/>
	8	<meta name="keywords" id="keywords" content=" main program comparing c c++ speed source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

95	95	</select>
96	96	</td>
97	97	</tr></table><br/>
98
99
100	98	<center><b><big><big>Main Program For Comparing C and C++ Speed</big></big></b></center>
101	99	<br/>
102	100	<b><big><a name="Source Code" id="Source Code">Source Code</a></big></b>
103	101
104	102	<code><font color='blue'><pre style='display:inline'>
105	103	int main(void)
106		{ bool flag;
107		size_t i;
	104	{ bool flag;
	105	size_t i;
108	106
109		<a href="uniform_01_c.xml" target="_top">random_seed</a>(123);
	107	<a href="uniform_01_c.xml" target="_top">random_seed</a>(123);
110	108
111		printf("correct_det_by_minor: ");
112		flag = <a href="correct_det_by_minor_c.xml" target="_top">correct_det_by_minor</a>();
113		if( flag )
114		printf("OK\n");
115		else printf("Error\n");
	109	printf("correct_det_by_minor: ");
	110	flag = <a href="correct_det_by_minor_c.xml" target="_top">correct_det_by_minor</a>();
	111	if( flag )
	112	printf("OK\n");
	113	else printf("Error\n");
116	114
117		for(i = 0; i < 5; i++)
118		{ double time_min = 1.0;
119		size_t size = 2 + i * 2;
120		int i_size = (int) size;
121		printf("time_det_minor for %d x %d matrix = ", i_size, i_size);
122		printf("%g\n", time_det_by_minor(size, time_min) );
123		}
	115	for(i = 0; i < 5; i++)
	116	{ double time_min = 1.0;
	117	size_t size = 2 + i * 2;
	118	int i_size = (int) size;
	119	printf("time_det_minor for %d x %d matrix = ", i_size, i_size);
	120	printf("%g\n", time_det_by_minor(size, time_min) );
	121	}
124	122
125		if( flag )
126		return 0;
127		return 1;
	123	if( flag )
	124	return 0;
	125	return 1;
128	126	}
129	127	</pre></font></code>
130
131	128
132	129	<hr/>Input File: compare_c/det_by_minor.c
133	130

+1

-1

doc/mat_sum_sq.cpp.xml less more

5	5	<title>Sum of the Elements of the Square of a Matrix: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sum of the Elements of the Square of a Matrix: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" sum of the elements square a matrix: example and test mat_sum_sq "/>
	8	<meta name="keywords" id="keywords" content=" sum the elements square matrix: example test mat_sum_sq "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/mat_sum_sq.xml less more

5	5	<title>Sum Elements of a Matrix Times Itself</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sum Elements of a Matrix Times Itself"/>
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	<meta name="keywords" id="keywords" content=" sum elements matrix times itself mat_sum_sq multiply speed test syntax purpose inclusion n x y z vector example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/microsoft_timer.xml less more

5	5	<title>Microsoft Version of Elapsed Number of Seconds</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Microsoft Version of Elapsed Number of Seconds"/>
8		<meta name="keywords" id="keywords" content=" microsoft version of elapsed number seconds syntax purpose s linking "/>
	8	<meta name="keywords" id="keywords" content=" microsoft version elapsed number seconds syntax purpose s linking "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/mul.cpp.xml less more

5	5	<title>AD Binary Multiplication: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Binary Multiplication: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad binary multiplication: example and test * multiply times "/>
	8	<meta name="keywords" id="keywords" content=" ad binary multiplication: example test * multiply times "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/mul_eq.cpp.xml less more

5	5	<title>AD Computed Assignment Multiplication: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Computed Assignment Multiplication: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad computed assignment multiplication: example and test *= multiply assign plus add "/>
	8	<meta name="keywords" id="keywords" content=" ad computed assignment multiplication: example test *= multiply assign plus add "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/mul_level.cpp.xml less more

5	5	<title>Multiple Level of AD: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Multiple Level of AD: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" multiple level of ad: example and test purpose source "/>
	8	<meta name="keywords" id="keywords" content=" multiple level ad: example test purpose source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/mul_level.xml less more

5	5	<title>Using Multiple Levels of AD</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using Multiple Levels of AD"/>
8		<meta name="keywords" id="keywords" content=" using multiple levels of ad background motivation procedure first start ad<double> ad< > recording inner function second outer derivatives example "/>
	8	<meta name="keywords" id="keywords" content=" using multiple levels ad background motivation procedure first start ad<double> ad< > recording inner function second outer derivatives example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-4

doc/mul_level_adolc.cpp.xml less more

5	5	<title>Using Adolc with Multiple Levels of Taping: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using Adolc with Multiple Levels of Taping: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" using adolc with multiple levels of taping: example and test purpose memory management configuration requirement source "/>
	8	<meta name="keywords" id="keywords" content=" using adolc with multiple levels taping: example test purpose memory management configuration requirement source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

85	85	</select>
86	86	</td>
87	87	</tr></table><br/>
88
89
90
91	88	<center><b><big><big>Using Adolc with Multiple Levels of Taping: Example and Test</big></big></b></center>
92	89	<br/>
93	90	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>

+1

-1

doc/mul_level_adolc_ode.cpp.xml less more

5	5	<title>Taylor's Ode Solver: A Multi-Level Adolc Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Taylor's Ode Solver: A Multi-Level Adolc Example and Test"/>
8		<meta name="keywords" id="keywords" content=" taylor's ode solver: a multi-level adolc example and test purpose solution derivative of method using ad base_adolc.hpp memory management configuration requirement source "/>
	8	<meta name="keywords" id="keywords" content=" taylor's ode solver: multi-level adolc example test purpose solution derivative method using ad base_adolc.hpp memory management configuration requirement source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/mul_level_ode.cpp.xml less more

5	5	<title>Taylor's Ode Solver: A Multi-Level AD Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Taylor's Ode Solver: A Multi-Level AD Example and Test"/>
8		<meta name="keywords" id="keywords" content=" taylor's ode solver: a multi-level ad example and test purpose solution derivative of method using source "/>
	8	<meta name="keywords" id="keywords" content=" taylor's ode solver: multi-level ad example test purpose solution derivative method using source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/multi_newton.cpp.xml less more

5	5	<title>A Multi-Threaded Newton's Method</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Multi-Threaded Newton's Method"/>
8		<meta name="keywords" id="keywords" content=" a multi-threaded newton's method multi_newton threading thread multi-threading syntax purpose ok xout fun num_sub xlow xup epsilon max_itr num_threads source "/>
	8	<meta name="keywords" id="keywords" content=" multi-threaded newton's method multi_newton threading thread multi-threading syntax purpose ok xout fun num_sub xlow xup epsilon max_itr num_threads source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/multi_newton_time.cpp.xml less more

5	5	<title>Timing Test of Multi-Threaded Newton Method</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Timing Test of Multi-Threaded Newton Method"/>
8		<meta name="keywords" id="keywords" content=" timing test of multi-threaded newton method multi_newton_time multi_thread Ad speed syntax purpose ok time_out test_time num_threads num_zero num_sub num_sum use_ad source "/>
	8	<meta name="keywords" id="keywords" content=" timing test multi-threaded newton method multi_newton_time multi_thread Ad speed syntax purpose ok time_out test_time num_threads num_zero num_sub num_sum use_ad source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/multi_thread.xml less more

5	5	<title>Using CppAD in a Multi-Threading Environment</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using CppAD in a Multi-Threading Environment"/>
8		<meta name="keywords" id="keywords" content=" using cppad in a multi-threading environment mode execution maximum number purpose cppad_max_num_threads parallel_setup hold_memory parallel ad initialization same thread prohibited "/>
	8	<meta name="keywords" id="keywords" content=" using cppad multi-threading environment mode execution maximum number purpose cppad_max_num_threads parallel_setup hold_memory parallel ad initialization same thread prohibited "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/nan.cpp.xml less more

5	5	<title>nan: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="nan: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" nan: example and test "/>
	8	<meta name="keywords" id="keywords" content=" nan: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/nan.xml less more

5	5	<title>Obtain Nan or Determine if a Value is Nan</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Obtain Nan or Determine if a Value is Nan"/>
8		<meta name="keywords" id="keywords" content=" obtain nan or determine if a value is syntax purpose include macros isnan s b hasnan v nan(zero) deprecated 2015-10-04 z scalar vector example "/>
	8	<meta name="keywords" id="keywords" content=" obtain nan determine if value is syntax purpose include macros isnan s b hasnan v nan(zero) deprecated 2015-10-04 z scalar vector example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-4

doc/near_equal.cpp.xml less more

5	5	<title>NearEqual Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="NearEqual Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" nearequal function: example and test file name "/>
	8	<meta name="keywords" id="keywords" content=" nearequal function: example test file name "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

101	101	</select>
102	102	</td>
103	103	</tr></table><br/>
104
105
106
107	104	<center><b><big><big>NearEqual Function: Example and Test</big></big></b></center>
108	105	<br/>
109	106	<b><big><a name="File Name" id="File Name">File Name</a></big></b>

+1

-1

doc/near_equal_ext.cpp.xml less more

5	5	<title>Compare AD with Base Objects: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Compare AD with Base Objects: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" compare ad with base objects: example and test Nearequalext "/>
	8	<meta name="keywords" id="keywords" content=" compare ad with base objects: example test Nearequalext "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+14

-16

doc/nearequal.xml less more

5	5	<title>Determine if Two Values Are Nearly Equal</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determine if Two Values Are Nearly Equal"/>
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	<meta name="keywords" id="keywords" content=" determine if two values are nearly equal Nearequal near absolute difference relative syntax purpose x y r b type include files example exercise "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

294	294	<br/>
295	295	Create and run a program that contains the following code:
296	296	<code><font color='blue'><pre style='display:inline'>
297		using std::complex;
298		using std::cout;
299		using std::endl;
300
301		complex<double> one(1., 0), i(0., 1);
302		complex<double> x = one / i;
303		complex<double> y = - i;
304		double r = 1e-12;
305		double a = 0;
306		bool ok = CppAD::<a href="nearequal.xml" target="_top">NearEqual</a>(x, y, r, a);
307		if( ok )
308		cout << "Ok" << endl;
309		else cout << "Error" << endl;
	297	using std::complex;
	298	using std::cout;
	299	using std::endl;
	300
	301	complex<double> one(1., 0), i(0., 1);
	302	complex<double> x = one / i;
	303	complex<double> y = - i;
	304	double r = 1e-12;
	305	double a = 0;
	306	bool ok = CppAD::<a href="nearequal.xml" target="_top">NearEqual</a>(x, y, r, a);
	307	if( ok )
	308	cout << "Ok" << endl;
	309	else cout << "Error" << endl;
310	310	</pre></font></code>
311
312
313	311
314	312	<hr/>Input File: cppad/utility/near_equal.hpp
315	313

+1

-1

doc/nearequalext.xml less more

5	5	<title>Compare AD and Base Objects for Nearly Equal</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Compare AD and Base Objects for Nearly Equal"/>
8		<meta name="keywords" id="keywords" content=" compare ad and base objects for nearly equal Nearequal with syntax purpose x y r a b type operation sequence example "/>
	8	<meta name="keywords" id="keywords" content=" compare ad base objects nearly equal Nearequal with syntax purpose x y r b type operation sequence example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/num_limits.cpp.xml less more

5	5	<title>Numeric Limits: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Numeric Limits: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" numeric limits: example and test "/>
	8	<meta name="keywords" id="keywords" content=" numeric limits: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/number_skip.cpp.xml less more

5	5	<title>Number of Variables That Can be Skipped: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Number of Variables That Can be Skipped: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" number of variables that can be skipped: example and test number_skip optimize conditional expression condition "/>
	8	<meta name="keywords" id="keywords" content=" number variables that can be skipped: example test number_skip optimize conditional expression condition "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/number_skip.xml less more

5	5	<title>Number of Variables that Can be Skipped</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Number of Variables that Can be Skipped"/>
8		<meta name="keywords" id="keywords" content=" number of variables that can be skipped number_skip syntax see also purpose n f example "/>
	8	<meta name="keywords" id="keywords" content=" number variables that can be skipped number_skip syntax see also purpose n f example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+0

-4

doc/numeric_ad.xml less more

88	88	</select>
89	89	</td>
90	90	</tr></table><br/>
91
92
93
94
95	91	<center><b><big><big>Some Numerical AD Utilities</big></big></b></center>
96	92	The routines listed below are numerical utilities that are
97	93	designed to work with CppAD in particular.

+1

-1

doc/numeric_limits.xml less more

5	5	<title>Numeric Limits For an AD and Base Types</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Numeric Limits For an AD and Base Types"/>
8		<meta name="keywords" id="keywords" content=" numeric limits for an ad and base types syntax cppad::numeric_limits std::numeric_limits float epsilon min max quiet_nan example "/>
	8	<meta name="keywords" id="keywords" content=" numeric limits ad base types syntax cppad::numeric_limits std::numeric_limits float epsilon min max quiet_nan example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/numeric_type.cpp.xml less more

5	5	<title>The NumericType: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The NumericType: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the numerictype: example and test Numerictype "/>
	8	<meta name="keywords" id="keywords" content=" the numerictype: example test Numerictype "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/numerictype.xml less more

5	5	<title>Definition of a Numeric Type</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Definition of a Numeric Type"/>
8		<meta name="keywords" id="keywords" content=" definition of a numeric type int requirements default constructor from integer copy assignment operators example exercise "/>
	8	<meta name="keywords" id="keywords" content=" definition numeric type int requirements default constructor from integer copy assignment operators example exercise "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ode_err_control.cpp.xml less more

5	5	<title>OdeErrControl: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="OdeErrControl: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" odeerrcontrol: example and test nan "/>
	8	<meta name="keywords" id="keywords" content=" odeerrcontrol: example test nan "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ode_err_maxabs.cpp.xml less more

5	5	<title>OdeErrControl: Example and Test Using Maxabs Argument</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="OdeErrControl: Example and Test Using Maxabs Argument"/>
8		<meta name="keywords" id="keywords" content=" odeerrcontrol: example and test using maxabs argument Odeerrcontrol "/>
	8	<meta name="keywords" id="keywords" content=" odeerrcontrol: example test using maxabs argument Odeerrcontrol "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ode_evaluate.cpp.xml less more

5	5	<title>ode_evaluate: Example and test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="ode_evaluate: Example and test"/>
8		<meta name="keywords" id="keywords" content=" ode_evaluate: example and test ode_evaluate "/>
	8	<meta name="keywords" id="keywords" content=" ode_evaluate: example test ode_evaluate "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ode_evaluate.xml less more

5	5	<title>Evaluate a Function Defined in Terms of an ODE</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Evaluate a Function Defined in Terms of an ODE"/>
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	<meta name="keywords" id="keywords" content=" evaluate function defined terms ode ode_evaluate syntax purpose inclusion float operation sequence fabs x p == 0 = 1 fp gradient example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ode_gear.cpp.xml less more

5	5	<title>OdeGear: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="OdeGear: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" odegear: example and test Odegear "/>
	8	<meta name="keywords" id="keywords" content=" odegear: example test Odegear "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ode_gear_control.cpp.xml less more

5	5	<title>OdeGearControl: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="OdeGearControl: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" odegearcontrol: example and test Odegearcontrol "/>
	8	<meta name="keywords" id="keywords" content=" odegearcontrol: example test Odegearcontrol "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ode_stiff.cpp.xml less more

5	5	<title>A Stiff Ode: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Stiff Ode: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" a stiff ode: example and test ode "/>
	8	<meta name="keywords" id="keywords" content=" stiff ode: example test ode "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ode_taylor.cpp.xml less more

5	5	<title>Taylor's Ode Solver: An Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Taylor's Ode Solver: An Example and Test"/>
8		<meta name="keywords" id="keywords" content=" taylor's ode solver: an example and test Taylor purpose solution forward mode "/>
	8	<meta name="keywords" id="keywords" content=" taylor's ode solver: example test Taylor purpose solution forward mode "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/odeerrcontrol.xml less more

5	5	<title>An Error Controller for ODE Solvers</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="An Error Controller for ODE Solvers"/>
8		<meta name="keywords" id="keywords" content=" an error controller for ode solvers Odeerrcontrol differential equation 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	<meta name="keywords" id="keywords" content=" error controller ode solvers Odeerrcontrol differential equation 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/odegear.xml less more

5	5	<title>An Arbitrary Order Gear Method</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="An Arbitrary Order Gear Method"/>
8		<meta name="keywords" id="keywords" content=" an arbitrary order gear method Odegear Ode stiff differential equation syntax purpose include fun t x f f_x warning m n e scalar vector example source code theory gear's "/>
	8	<meta name="keywords" id="keywords" content=" arbitrary order gear method Odegear Ode stiff differential equation syntax purpose include fun t x f f_x warning m n e scalar vector example source code theory gear's "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/odegearcontrol.xml less more

5	5	<title>An Error Controller for Gear's Ode Solvers</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="An Error Controller for Gear's Ode Solvers"/>
8		<meta name="keywords" id="keywords" content=" an error controller for gear's ode solvers Odegearcontrol Gear differential equation 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	<meta name="keywords" id="keywords" content=" error controller gear's ode solvers Odegearcontrol Gear differential equation 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/old_mat_mul.cpp.xml less more

5	5	<title>Old Matrix Multiply as a User Atomic Operation: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Old Matrix Multiply as a User Atomic Operation: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" old matrix multiply as a user atomic operation: example and test deprecated 2013-05-27 include file "/>
	8	<meta name="keywords" id="keywords" content=" old matrix multiply user atomic operation: example test deprecated 2013-05-27 include file "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+342

-363

doc/old_mat_mul.hpp.xml less more

5	5	<title>Define Matrix Multiply as a User Atomic Operation</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Define Matrix Multiply as a User Atomic Operation"/>
8		<meta name="keywords" id="keywords" content=" define matrix multiply as a user atomic operation old_mat_mul old_atomic test syntax example begin source extra call information indexing one reverse partials order set union cppad callback functions declare mat_mul function "/>
	8	<meta name="keywords" id="keywords" content=" define matrix multiply user atomic operation old_mat_mul old_atomic test syntax example begin source extra call information indexing one reverse partials order set union cppad callback functions declare mat_mul function "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

124	124	<code><font color='blue'><pre style='display:inline'>
125	125	# include <cppad/cppad.hpp> // Include CppAD definitions
126	126	namespace { // Begin empty namespace
127		using CppAD::vector; // Let vector denote CppAD::vector
128		</pre></font></code>
129
130
131		<br/>
	127	using CppAD::vector; // Let vector denote CppAD::vector
	128	</pre></font></code>
132	129	<br/>
133	130	<b><big><a name="Extra Call Information" id="Extra Call Information">Extra Call Information</a></big></b>
134	131
135	132	<code><font color='blue'><pre style='display:inline'>
136		// Information we will attach to each mat_mul call
137		struct call_info {
138		size_t nr_result;
139		size_t n_middle;
140		size_t nc_result;
141		vector<bool> vx;
142		};
143		vector<call_info> info_; // vector of call information
144
145		// number of orders for this operation (k + 1)
146		size_t n_order_ = 0;
147		// number of rows in the result matrix
148		size_t nr_result_ = 0;
149		// number of columns in left matrix and number of rows in right matrix
150		size_t n_middle_ = 0;
151		// number of columns in the result matrix
152		size_t nc_result_ = 0;
153		// which components of x are variables
154		vector<bool>* vx_ = CPPAD_NULL;
155
156		// get the information corresponding to this call
157		void get_info(size_t id, size_t k, size_t n, size_t m)
158		{ n_order_ = k + 1;
159		nr_result_ = info_[id].nr_result;
160		n_middle_ = info_[id].n_middle;
161		nc_result_ = info_[id].nc_result;
162		vx_ = &(info_[id].vx);
163
164		assert(n == nr_result_ * n_middle_ + n_middle_ * nc_result_);
165		assert(m == nr_result_ * nc_result_);
166		}
167
168		</pre></font></code>
169
170		<br/>
171		<br/>
	133	// Information we will attach to each mat_mul call
	134	struct call_info {
	135	size_t nr_result;
	136	size_t n_middle;
	137	size_t nc_result;
	138	vector<bool> vx;
	139	};
	140	vector<call_info> info_; // vector of call information
	141
	142	// number of orders for this operation (k + 1)
	143	size_t n_order_ = 0;
	144	// number of rows in the result matrix
	145	size_t nr_result_ = 0;
	146	// number of columns in left matrix and number of rows in right matrix
	147	size_t n_middle_ = 0;
	148	// number of columns in the result matrix
	149	size_t nc_result_ = 0;
	150	// which components of x are variables
	151	vector<bool>* vx_ = CPPAD_NULL;
	152
	153	// get the information corresponding to this call
	154	void get_info(size_t id, size_t k, size_t n, size_t m)
	155	{ n_order_ = k + 1;
	156	nr_result_ = info_[id].nr_result;
	157	n_middle_ = info_[id].n_middle;
	158	nc_result_ = info_[id].nc_result;
	159	vx_ = &(info_[id].vx);
	160
	161	assert(n == nr_result_ * n_middle_ + n_middle_ * nc_result_);
	162	assert(m == nr_result_ * nc_result_);
	163	}
	164
	165	</pre></font></code>
172	166	<b><big><a name="Matrix Indexing" id="Matrix Indexing">Matrix Indexing</a></big></b>
173	167
174	168	<code><font color='blue'><pre style='display:inline'>
175		// Convert left matrix index pair and order to a single argument index
176		size_t left(size_t i, size_t j, size_t ell)
177		{ assert( i < nr_result_ );
178		assert( j < n_middle_ );
179		return (i * n_middle_ + j) * n_order_ + ell;
180		}
181		// Convert right matrix index pair and order to a single argument index
182		size_t right(size_t i, size_t j, size_t ell)
183		{ assert( i < n_middle_ );
184		assert( j < nc_result_ );
185		size_t offset = nr_result_ * n_middle_;
186		return (offset + i * nc_result_ + j) * n_order_ + ell;
187		}
188		// Convert result matrix index pair and order to a single result index
189		size_t result(size_t i, size_t j, size_t ell)
190		{ assert( i < nr_result_ );
191		assert( j < nc_result_ );
192		return (i * nc_result_ + j) * n_order_ + ell;
193		}
194		</pre></font></code>
195
196
197		<br/>
	169	// Convert left matrix index pair and order to a single argument index
	170	size_t left(size_t i, size_t j, size_t ell)
	171	{ assert( i < nr_result_ );
	172	assert( j < n_middle_ );
	173	return (i * n_middle_ + j) * n_order_ + ell;
	174	}
	175	// Convert right matrix index pair and order to a single argument index
	176	size_t right(size_t i, size_t j, size_t ell)
	177	{ assert( i < n_middle_ );
	178	assert( j < nc_result_ );
	179	size_t offset = nr_result_ * n_middle_;
	180	return (offset + i * nc_result_ + j) * n_order_ + ell;
	181	}
	182	// Convert result matrix index pair and order to a single result index
	183	size_t result(size_t i, size_t j, size_t ell)
	184	{ assert( i < nr_result_ );
	185	assert( j < nc_result_ );
	186	return (i * nc_result_ + j) * n_order_ + ell;
	187	}
	188	</pre></font></code>
198	189	<br/>
199	190	<b><big><a name="One Matrix Multiply" id="One Matrix Multiply">One Matrix Multiply</a></big></b>
200	191	<br/>
201	192	Forward mode matrix multiply left times right and sum into result:
202	193	<code><font color='blue'><pre style='display:inline'>
203		void multiply_and_sum(
204		size_t order_left ,
205		size_t order_right,
206		const vector<double>& tx ,
207		vector<double>& ty )
208		{ size_t i, j;
209		size_t order_result = order_left + order_right;
210		for(i = 0; i < nr_result_; i++)
211		{ for(j = 0; j < nc_result_; j++)
212		{ double sum = 0.;
213		size_t middle, im_left, mj_right, ij_result;
214		for(middle = 0; middle < n_middle_; middle++)
215		{ im_left = left(i, middle, order_left);
216		mj_right = right(middle, j, order_right);
217		sum += tx[im_left] * tx[mj_right];
218		}
219		ij_result = result(i, j, order_result);
220		ty[ ij_result ] += sum;
221		}
222		}
223		return;
224		}
225		</pre></font></code>
226
227
228		<br/>
	194	void multiply_and_sum(
	195	size_t order_left ,
	196	size_t order_right,
	197	const vector<double>& tx ,
	198	vector<double>& ty )
	199	{ size_t i, j;
	200	size_t order_result = order_left + order_right;
	201	for(i = 0; i < nr_result_; i++)
	202	{ for(j = 0; j < nc_result_; j++)
	203	{ double sum = 0.;
	204	size_t middle, im_left, mj_right, ij_result;
	205	for(middle = 0; middle < n_middle_; middle++)
	206	{ im_left = left(i, middle, order_left);
	207	mj_right = right(middle, j, order_right);
	208	sum += tx[im_left] * tx[mj_right];
	209	}
	210	ij_result = result(i, j, order_result);
	211	ty[ ij_result ] += sum;
	212	}
	213	}
	214	return;
	215	}
	216	</pre></font></code>
229	217	<br/>
230	218	<b><big><a name="Reverse Partials One Order" id="Reverse Partials One Order">Reverse Partials One Order</a></big></b>
231	219	<br/>
232	220	Compute reverse mode partials for one order and sum into px:
233	221	<code><font color='blue'><pre style='display:inline'>
234		void reverse_multiply(
235		size_t order_left ,
236		size_t order_right,
237		const vector<double>& tx ,
238		const vector<double>& ty ,
239		vector<double>& px ,
240		const vector<double>& py )
241		{ size_t i, j;
242		size_t order_result = order_left + order_right;
243		for(i = 0; i < nr_result_; i++)
244		{ for(j = 0; j < nc_result_; j++)
245		{ size_t middle, im_left, mj_right, ij_result;
246		for(middle = 0; middle < n_middle_; middle++)
247		{ ij_result = result(i, j, order_result);
248		im_left = left(i, middle, order_left);
249		mj_right = right(middle, j, order_right);
250		// sum += tx[im_left] * tx[mj_right];
251		px[im_left] += tx[mj_right] * py[ij_result];
252		px[mj_right] += tx[im_left] * py[ij_result];
253		}
254		}
255		}
256		return;
257		}
258		</pre></font></code>
259
260		<br/>
	222	void reverse_multiply(
	223	size_t order_left ,
	224	size_t order_right,
	225	const vector<double>& tx ,
	226	const vector<double>& ty ,
	227	vector<double>& px ,
	228	const vector<double>& py )
	229	{ size_t i, j;
	230	size_t order_result = order_left + order_right;
	231	for(i = 0; i < nr_result_; i++)
	232	{ for(j = 0; j < nc_result_; j++)
	233	{ size_t middle, im_left, mj_right, ij_result;
	234	for(middle = 0; middle < n_middle_; middle++)
	235	{ ij_result = result(i, j, order_result);
	236	im_left = left(i, middle, order_left);
	237	mj_right = right(middle, j, order_right);
	238	// sum += tx[im_left] * tx[mj_right];
	239	px[im_left] += tx[mj_right] * py[ij_result];
	240	px[mj_right] += tx[im_left] * py[ij_result];
	241	}
	242	}
	243	}
	244	return;
	245	}
	246	</pre></font></code>
261	247	<br/>
262	248	<b><big><a name="Set Union" id="Set Union">Set Union</a></big></b>
263	249
264	250	<code><font color='blue'><pre style='display:inline'>
265		void my_union(
266		std::set<size_t>& result ,
267		const std::set<size_t>& left ,
268		const std::set<size_t>& right )
269		{ std::set<size_t> temp;
270		std::set_union(
271		left.begin() ,
272		left.end() ,
273		right.begin() ,
274		right.end() ,
275		std::inserter(temp, temp.begin())
276		);
277		result.swap(temp);
278		}
279		</pre></font></code>
280
281
282		<br/>
	251	void my_union(
	252	std::set<size_t>& result ,
	253	const std::set<size_t>& left ,
	254	const std::set<size_t>& right )
	255	{ std::set<size_t> temp;
	256	std::set_union(
	257	left.begin() ,
	258	left.end() ,
	259	right.begin() ,
	260	right.end() ,
	261	std::inserter(temp, temp.begin())
	262	);
	263	result.swap(temp);
	264	}
	265	</pre></font></code>
283	266	<br/>
284	267	<b><big><a name="CppAD User Atomic Callback Functions" id="CppAD User Atomic Callback Functions">CppAD User Atomic Callback Functions</a></big></b>
285	268
286	269	<code><font color='blue'><pre style='display:inline'>
287		// ----------------------------------------------------------------------
288		// forward mode routine called by CppAD
289		bool mat_mul_forward(
290		size_t id ,
291		size_t k ,
292		size_t n ,
293		size_t m ,
294		const vector<bool>& vx ,
295		vector<bool>& vy ,
296		const vector<double>& tx ,
297		vector<double>& ty
298		)
299		{ size_t i, j, ell;
300		get_info(id, k, n, m);
301
302		// check if this is during the call to mat_mul(id, ax, ay)
303		if( vx.size() > 0 )
304		{ assert( k == 0 && vx.size() > 0 );
305
306		// store the vx information in info_
307		assert( vx_->size() == 0 );
308		info_[id].vx.resize(n);
309		for(j = 0; j < n; j++)
310		info_[id].vx[j] = vx[j];
311		assert( vx_->size() == n );
312
313		// now compute vy
314		for(i = 0; i < nr_result_; i++)
315		{ for(j = 0; j < nc_result_; j++)
316		{ // compute vy[ result(i, j, 0) ]
317		bool var = false;
318		bool nz_left, nz_right;
319		size_t middle, im_left, mj_right, ij_result;
320		for(middle = 0; middle < n_middle_; middle++)
321		{ im_left = left(i, middle, k);
322		mj_right = right(middle, j, k);
323		nz_left = vx[im_left] \| (tx[im_left] != 0.);
324		nz_right = vx[mj_right] \| (tx[mj_right]!= 0.);
325		// if not multiplying by the constant zero
326		if( nz_left & nz_right )
327		var \|= (vx[im_left] \| vx[mj_right]);
328		}
329		ij_result = result(i, j, k);
330		vy[ij_result] = var;
331		}
332		}
333		}
334
335		// initialize result as zero
336		for(i = 0; i < nr_result_; i++)
337		{ for(j = 0; j < nc_result_; j++)
338		ty[ result(i, j, k) ] = 0.;
339		}
340		// sum the product of proper orders
341		for(ell = 0; ell <=k; ell++)
342		multiply_and_sum(ell, k-ell, tx, ty);
343
344		// All orders are implemented and there are no possible error
345		// conditions, so always return true.
346		return true;
347		}
348		// ----------------------------------------------------------------------
349		// reverse mode routine called by CppAD
350		bool mat_mul_reverse(
351		size_t id ,
352		size_t k ,
353		size_t n ,
354		size_t m ,
355		const vector<double>& tx ,
356		const vector<double>& ty ,
357		vector<double>& px ,
358		const vector<double>& py
359		)
360		{ get_info(id, k, n, m);
361
362		size_t ell = n * n_order_;
363		while(ell--)
364		px[ell] = 0.;
365
366		size_t order = n_order_;
367		while(order--)
368		{ // reverse sum the products for specified order
369		for(ell = 0; ell <=order; ell++)
370		reverse_multiply(ell, order-ell, tx, ty, px, py);
371		}
372
373		// All orders are implemented and there are no possible error
374		// conditions, so always return true.
375		return true;
376		}
377
378		// ----------------------------------------------------------------------
379		// forward Jacobian sparsity routine called by CppAD
380		bool mat_mul_for_jac_sparse(
381		size_t id ,
382		size_t n ,
383		size_t m ,
384		size_t p ,
385		const vector< std::set<size_t> >& r ,
386		vector< std::set<size_t> >& s )
387		{ size_t i, j, k, im_left, middle, mj_right, ij_result;
388		k = 0;
389		get_info(id, k, n, m);
390
391		for(i = 0; i < nr_result_; i++)
392		{ for(j = 0; j < nc_result_; j++)
393		{ ij_result = result(i, j, k);
394		s[ij_result].clear();
395		for(middle = 0; middle < n_middle_; middle++)
396		{ im_left = left(i, middle, k);
397		mj_right = right(middle, j, k);
398
399		// s[ij_result] = union( s[ij_result], r[im_left] )
400		my_union(s[ij_result], s[ij_result], r[im_left]);
401
402		// s[ij_result] = union( s[ij_result], r[mj_right] )
403		my_union(s[ij_result], s[ij_result], r[mj_right]);
404		}
405		}
406		}
407		return true;
408		}
409		// ----------------------------------------------------------------------
410		// reverse Jacobian sparsity routine called by CppAD
411		bool mat_mul_rev_jac_sparse(
412		size_t id ,
413		size_t n ,
414		size_t m ,
415		size_t p ,
416		vector< std::set<size_t> >& r ,
417		const vector< std::set<size_t> >& s )
418		{ size_t i, j, k, im_left, middle, mj_right, ij_result;
419		k = 0;
420		get_info(id, k, n, m);
421
422		for(j = 0; j < n; j++)
423		r[j].clear();
424
425		for(i = 0; i < nr_result_; i++)
426		{ for(j = 0; j < nc_result_; j++)
427		{ ij_result = result(i, j, k);
428		for(middle = 0; middle < n_middle_; middle++)
429		{ im_left = left(i, middle, k);
430		mj_right = right(middle, j, k);
431
432		// r[im_left] = union( r[im_left], s[ij_result] )
433		my_union(r[im_left], r[im_left], s[ij_result]);
434
435		// r[mj_right] = union( r[mj_right], s[ij_result] )
436		my_union(r[mj_right], r[mj_right], s[ij_result]);
437		}
438		}
439		}
440		return true;
441		}
442		// ----------------------------------------------------------------------
443		// reverse Hessian sparsity routine called by CppAD
444		bool mat_mul_rev_hes_sparse(
445		size_t id ,
446		size_t n ,
447		size_t m ,
448		size_t p ,
449		const vector< std::set<size_t> >& r ,
450		const vector<bool>& s ,
451		vector<bool>& t ,
452		const vector< std::set<size_t> >& u ,
453		vector< std::set<size_t> >& v )
454		{ size_t i, j, k, im_left, middle, mj_right, ij_result;
455		k = 0;
456		get_info(id, k, n, m);
457
458		for(j = 0; j < n; j++)
459		{ t[j] = false;
460		v[j].clear();
461		}
462
463		assert( vx_->size() == n );
464		for(i = 0; i < nr_result_; i++)
465		{ for(j = 0; j < nc_result_; j++)
466		{ ij_result = result(i, j, k);
467		for(middle = 0; middle < n_middle_; middle++)
468		{ im_left = left(i, middle, k);
469		mj_right = right(middle, j, k);
470
471		// back propagate Jacobian sparsity
472		t[im_left] = (t[im_left] \| s[ij_result]);
473		t[mj_right] = (t[mj_right] \| s[ij_result]);
474		// Visual Studio C++ 2008 warns unsafe mix of int and
475		// bool if we use the following code directly above:
476		// t[im_left] \|= s[ij_result];
477		// t[mj_right] \|= s[ij_result];
478
479		// back propagate Hessian sparsity
480		// v[im_left] = union( v[im_left], u[ij_result] )
481		// v[mj_right] = union( v[mj_right], u[ij_result] )
482		my_union(v[im_left], v[im_left], u[ij_result] );
483		my_union(v[mj_right], v[mj_right], u[ij_result] );
484
485		// Check for case where the (i,j) result element
486		// is in reverse Jacobian and both left and right
487		// operands in multiplication are variables
488		if(s[ij_result] & (vx_)[im_left] & (vx_)[mj_right])
489		{ // v[im_left] = union( v[im_left], r[mj_right] )
490		my_union(v[im_left], v[im_left], r[mj_right] );
491		// v[mj_right] = union( v[mj_right], r[im_left] )
492		my_union(v[mj_right], v[mj_right], r[im_left] );
493		}
494		}
495		}
496		}
497		return true;
498		}
499		</pre></font></code>
500
501
502		<br/>
	270	// ----------------------------------------------------------------------
	271	// forward mode routine called by CppAD
	272	bool mat_mul_forward(
	273	size_t id ,
	274	size_t k ,
	275	size_t n ,
	276	size_t m ,
	277	const vector<bool>& vx ,
	278	vector<bool>& vy ,
	279	const vector<double>& tx ,
	280	vector<double>& ty
	281	)
	282	{ size_t i, j, ell;
	283	get_info(id, k, n, m);
	284
	285	// check if this is during the call to mat_mul(id, ax, ay)
	286	if( vx.size() > 0 )
	287	{ assert( k == 0 && vx.size() > 0 );
	288
	289	// store the vx information in info_
	290	assert( vx_->size() == 0 );
	291	info_[id].vx.resize(n);
	292	for(j = 0; j < n; j++)
	293	info_[id].vx[j] = vx[j];
	294	assert( vx_->size() == n );
	295
	296	// now compute vy
	297	for(i = 0; i < nr_result_; i++)
	298	{ for(j = 0; j < nc_result_; j++)
	299	{ // compute vy[ result(i, j, 0) ]
	300	bool var = false;
	301	bool nz_left, nz_right;
	302	size_t middle, im_left, mj_right, ij_result;
	303	for(middle = 0; middle < n_middle_; middle++)
	304	{ im_left = left(i, middle, k);
	305	mj_right = right(middle, j, k);
	306	nz_left = vx[im_left] \| (tx[im_left] != 0.);
	307	nz_right = vx[mj_right] \| (tx[mj_right]!= 0.);
	308	// if not multiplying by the constant zero
	309	if( nz_left & nz_right )
	310	var \|= (vx[im_left] \| vx[mj_right]);
	311	}
	312	ij_result = result(i, j, k);
	313	vy[ij_result] = var;
	314	}
	315	}
	316	}
	317
	318	// initialize result as zero
	319	for(i = 0; i < nr_result_; i++)
	320	{ for(j = 0; j < nc_result_; j++)
	321	ty[ result(i, j, k) ] = 0.;
	322	}
	323	// sum the product of proper orders
	324	for(ell = 0; ell <=k; ell++)
	325	multiply_and_sum(ell, k-ell, tx, ty);
	326
	327	// All orders are implemented and there are no possible error
	328	// conditions, so always return true.
	329	return true;
	330	}
	331	// ----------------------------------------------------------------------
	332	// reverse mode routine called by CppAD
	333	bool mat_mul_reverse(
	334	size_t id ,
	335	size_t k ,
	336	size_t n ,
	337	size_t m ,
	338	const vector<double>& tx ,
	339	const vector<double>& ty ,
	340	vector<double>& px ,
	341	const vector<double>& py
	342	)
	343	{ get_info(id, k, n, m);
	344
	345	size_t ell = n * n_order_;
	346	while(ell--)
	347	px[ell] = 0.;
	348
	349	size_t order = n_order_;
	350	while(order--)
	351	{ // reverse sum the products for specified order
	352	for(ell = 0; ell <=order; ell++)
	353	reverse_multiply(ell, order-ell, tx, ty, px, py);
	354	}
	355
	356	// All orders are implemented and there are no possible error
	357	// conditions, so always return true.
	358	return true;
	359	}
	360
	361	// ----------------------------------------------------------------------
	362	// forward Jacobian sparsity routine called by CppAD
	363	bool mat_mul_for_jac_sparse(
	364	size_t id ,
	365	size_t n ,
	366	size_t m ,
	367	size_t p ,
	368	const vector< std::set<size_t> >& r ,
	369	vector< std::set<size_t> >& s )
	370	{ size_t i, j, k, im_left, middle, mj_right, ij_result;
	371	k = 0;
	372	get_info(id, k, n, m);
	373
	374	for(i = 0; i < nr_result_; i++)
	375	{ for(j = 0; j < nc_result_; j++)
	376	{ ij_result = result(i, j, k);
	377	s[ij_result].clear();
	378	for(middle = 0; middle < n_middle_; middle++)
	379	{ im_left = left(i, middle, k);
	380	mj_right = right(middle, j, k);
	381
	382	// s[ij_result] = union( s[ij_result], r[im_left] )
	383	my_union(s[ij_result], s[ij_result], r[im_left]);
	384
	385	// s[ij_result] = union( s[ij_result], r[mj_right] )
	386	my_union(s[ij_result], s[ij_result], r[mj_right]);
	387	}
	388	}
	389	}
	390	return true;
	391	}
	392	// ----------------------------------------------------------------------
	393	// reverse Jacobian sparsity routine called by CppAD
	394	bool mat_mul_rev_jac_sparse(
	395	size_t id ,
	396	size_t n ,
	397	size_t m ,
	398	size_t p ,
	399	vector< std::set<size_t> >& r ,
	400	const vector< std::set<size_t> >& s )
	401	{ size_t i, j, k, im_left, middle, mj_right, ij_result;
	402	k = 0;
	403	get_info(id, k, n, m);
	404
	405	for(j = 0; j < n; j++)
	406	r[j].clear();
	407
	408	for(i = 0; i < nr_result_; i++)
	409	{ for(j = 0; j < nc_result_; j++)
	410	{ ij_result = result(i, j, k);
	411	for(middle = 0; middle < n_middle_; middle++)
	412	{ im_left = left(i, middle, k);
	413	mj_right = right(middle, j, k);
	414
	415	// r[im_left] = union( r[im_left], s[ij_result] )
	416	my_union(r[im_left], r[im_left], s[ij_result]);
	417
	418	// r[mj_right] = union( r[mj_right], s[ij_result] )
	419	my_union(r[mj_right], r[mj_right], s[ij_result]);
	420	}
	421	}
	422	}
	423	return true;
	424	}
	425	// ----------------------------------------------------------------------
	426	// reverse Hessian sparsity routine called by CppAD
	427	bool mat_mul_rev_hes_sparse(
	428	size_t id ,
	429	size_t n ,
	430	size_t m ,
	431	size_t p ,
	432	const vector< std::set<size_t> >& r ,
	433	const vector<bool>& s ,
	434	vector<bool>& t ,
	435	const vector< std::set<size_t> >& u ,
	436	vector< std::set<size_t> >& v )
	437	{ size_t i, j, k, im_left, middle, mj_right, ij_result;
	438	k = 0;
	439	get_info(id, k, n, m);
	440
	441	for(j = 0; j < n; j++)
	442	{ t[j] = false;
	443	v[j].clear();
	444	}
	445
	446	assert( vx_->size() == n );
	447	for(i = 0; i < nr_result_; i++)
	448	{ for(j = 0; j < nc_result_; j++)
	449	{ ij_result = result(i, j, k);
	450	for(middle = 0; middle < n_middle_; middle++)
	451	{ im_left = left(i, middle, k);
	452	mj_right = right(middle, j, k);
	453
	454	// back propagate Jacobian sparsity
	455	t[im_left] = (t[im_left] \| s[ij_result]);
	456	t[mj_right] = (t[mj_right] \| s[ij_result]);
	457	// Visual Studio C++ 2008 warns unsafe mix of int and
	458	// bool if we use the following code directly above:
	459	// t[im_left] \|= s[ij_result];
	460	// t[mj_right] \|= s[ij_result];
	461
	462	// back propagate Hessian sparsity
	463	// v[im_left] = union( v[im_left], u[ij_result] )
	464	// v[mj_right] = union( v[mj_right], u[ij_result] )
	465	my_union(v[im_left], v[im_left], u[ij_result] );
	466	my_union(v[mj_right], v[mj_right], u[ij_result] );
	467
	468	// Check for case where the (i,j) result element
	469	// is in reverse Jacobian and both left and right
	470	// operands in multiplication are variables
	471	if(s[ij_result] & (vx_)[im_left] & (vx_)[mj_right])
	472	{ // v[im_left] = union( v[im_left], r[mj_right] )
	473	my_union(v[im_left], v[im_left], r[mj_right] );
	474	// v[mj_right] = union( v[mj_right], r[im_left] )
	475	my_union(v[mj_right], v[mj_right], r[im_left] );
	476	}
	477	}
	478	}
	479	}
	480	return true;
	481	}
	482	</pre></font></code>
503	483	<br/>
504	484	<b><big><a name="Declare mat_mul Function" id="Declare mat_mul Function">Declare mat_mul Function</a></big></b>
505	485	<br/>

511	491
512	492	instead of <code><font color="blue">CppAD::vector</font></code>):
513	493	<code><font color='blue'><pre style='display:inline'>
514		CPPAD_USER_ATOMIC(
515		mat_mul ,
516		CppAD::vector ,
517		double ,
518		mat_mul_forward ,
519		mat_mul_reverse ,
520		mat_mul_for_jac_sparse ,
521		mat_mul_rev_jac_sparse ,
522		mat_mul_rev_hes_sparse
523		)
	494	CPPAD_USER_ATOMIC(
	495	mat_mul ,
	496	CppAD::vector ,
	497	double ,
	498	mat_mul_forward ,
	499	mat_mul_reverse ,
	500	mat_mul_for_jac_sparse ,
	501	mat_mul_rev_jac_sparse ,
	502	mat_mul_rev_hes_sparse
	503	)
524	504	} // End empty namespace
525	505	</pre></font></code>
526
527	506
528	507	<hr/>Input File: test_more/old_mat_mul.hpp
529	508

+1

-1

doc/old_max_num_threads.xml less more

5	5	<title>Set Maximum Number of Threads for omp_alloc Allocator</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Set Maximum Number of Threads for omp_alloc Allocator"/>
8		<meta name="keywords" id="keywords" content=" set maximum number of threads for omp_alloc allocator max_num_threads removed syntax purpose restrictions "/>
	8	<meta name="keywords" id="keywords" content=" set maximum number threads omp_alloc allocator max_num_threads removed syntax purpose restrictions "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/old_reciprocal.cpp.xml less more

5	5	<title>Old Atomic Operation Reciprocal: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Old Atomic Operation Reciprocal: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" old atomic operation reciprocal: example and test deprecated 2013-05-27 theory "/>
	8	<meta name="keywords" id="keywords" content=" old atomic operation reciprocal: example test deprecated 2013-05-27 theory "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/old_tan.cpp.xml less more

5	5	<title>Old Tan and Tanh as User Atomic Operations: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Old Tan and Tanh as User Atomic Operations: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" old tan and tanh as user atomic operations: example test deprecated 2013-05-27 theory "/>
	8	<meta name="keywords" id="keywords" content=" old tan tanh user atomic operations: example test deprecated 2013-05-27 theory "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_alloc.cpp.xml less more

5	5	<title>OpenMP Memory Allocator: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="OpenMP Memory Allocator: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" openmp memory allocator: example and test allocation multi thread deprecated 2011-08-31 "/>
	8	<meta name="keywords" id="keywords" content=" openmp memory allocator: example test allocation multi thread deprecated 2011-08-31 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_alloc.xml less more

5	5	<title>A Quick OpenMP Memory Allocator Used by CppAD</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Quick OpenMP Memory Allocator Used by CppAD"/>
8		<meta name="keywords" id="keywords" content=" a quick openmp memory allocator used by cppad multi-threading allocation syntax purpose include deprecated 2011-08-23 "/>
	8	<meta name="keywords" id="keywords" content=" quick openmp memory allocator used cppad multi-threading allocation syntax purpose include deprecated 2011-08-23 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_available.xml less more

5	5	<title>Amount of Memory Available for Quick Use by a Thread</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Amount of Memory Available for Quick Use by a Thread"/>
8		<meta name="keywords" id="keywords" content=" amount of memory available for quick use by a thread deprecated 2011-08-31 syntax purpose num_bytes example "/>
	8	<meta name="keywords" id="keywords" content=" amount memory available quick use thread deprecated 2011-08-31 syntax purpose num_bytes example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_create_array.xml less more

5	5	<title>Allocate Memory and Create A Raw Array</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Allocate Memory and Create A Raw Array"/>
8		<meta name="keywords" id="keywords" content=" allocate memory and create a raw array create_array deprecated 2011-08-31 syntax purpose type size_min size_out delta example "/>
	8	<meta name="keywords" id="keywords" content=" allocate memory create raw array create_array deprecated 2011-08-31 syntax purpose type size_min size_out delta example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_delete_array.xml less more

5	5	<title>Return A Raw Array to The Available Memory for a Thread</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Return A Raw Array to The Available Memory for a Thread"/>
8		<meta name="keywords" id="keywords" content=" return a raw array to the available memory for thread delete_array deprecated 2011-08-31 syntax purpose type delta example "/>
	8	<meta name="keywords" id="keywords" content=" return raw array to the available memory thread delete_array deprecated 2011-08-31 syntax purpose type delta example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_efficient.xml less more

5	5	<title>Check If A Memory Allocation is Efficient for Another Use</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Check If A Memory Allocation is Efficient for Another Use"/>
8		<meta name="keywords" id="keywords" content=" check if a memory allocation is efficient for another use removed syntax purpose v_ptr num_bytes flag thread ndebug "/>
	8	<meta name="keywords" id="keywords" content=" check if memory allocation is efficient another use removed syntax purpose v_ptr num_bytes flag thread ndebug "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_free_available.xml less more

5	5	<title>Free Memory Currently Available for Quick Use by a Thread</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Free Memory Currently Available for Quick Use by a Thread"/>
8		<meta name="keywords" id="keywords" content=" free memory currently available for quick use by a thread free_available deprecated 2011-08-31 syntax purpose example "/>
	8	<meta name="keywords" id="keywords" content=" free memory currently available quick use thread free_available deprecated 2011-08-31 syntax purpose example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_get_memory.xml less more

5	5	<title>Get At Least A Specified Amount of Memory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Get At Least A Specified Amount of Memory"/>
8		<meta name="keywords" id="keywords" content=" get at least a specified amount of memory deprecated 2011-08-31 syntax purpose min_bytes cap_bytes v_ptr allocation speed example "/>
	8	<meta name="keywords" id="keywords" content=" get least specified amount memory deprecated 2011-08-31 syntax purpose min_bytes cap_bytes v_ptr allocation speed example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_in_parallel.xml less more

5	5	<title>Is The Current Execution in OpenMP Parallel Mode</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Is The Current Execution in OpenMP Parallel Mode"/>
8		<meta name="keywords" id="keywords" content=" is the current execution in openmp parallel mode in_parallel deprecated 2011-08-31 syntax purpose flag example "/>
	8	<meta name="keywords" id="keywords" content=" is the current execution openmp parallel mode in_parallel deprecated 2011-08-31 syntax purpose flag example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_inuse.xml less more

5	5	<title>Amount of Memory a Thread is Currently Using</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Amount of Memory a Thread is Currently Using"/>
8		<meta name="keywords" id="keywords" content=" amount of memory a thread is currently using inuse deprecated 2011-08-31 syntax purpose num_bytes example "/>
	8	<meta name="keywords" id="keywords" content=" amount memory thread is currently using inuse deprecated 2011-08-31 syntax purpose num_bytes example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/omp_max_num_threads.xml less more

5	5	<title>Set and Get Maximum Number of Threads for omp_alloc Allocator</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Set and Get Maximum Number of Threads for omp_alloc Allocator"/>
8		<meta name="keywords" id="keywords" content=" set and get maximum number of threads for omp_alloc allocator deprecated 2011-08-31 syntax purpose set_max_num_threads get_max_num_threads restrictions "/>
	8	<meta name="keywords" id="keywords" content=" set get maximum number threads omp_alloc allocator deprecated 2011-08-31 syntax purpose set_max_num_threads get_max_num_threads restrictions "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/opt_val_hes.cpp.xml less more

5	5	<title>opt_val_hes: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="opt_val_hes: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" opt_val_hes: example and test opt_val_hes "/>
	8	<meta name="keywords" id="keywords" content=" opt_val_hes: example test opt_val_hes "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/opt_val_hes.xml less more

5	5	<title>Jacobian and Hessian of Optimal Values</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Jacobian and Hessian of Optimal Values"/>
8		<meta name="keywords" id="keywords" content=" jacobian and hessian of optimal values opt_val_hes syntax see also reference purpose basevector x y fun fun::ad_vector fun.ell fun.s fun.sy jac hes signdet example "/>
	8	<meta name="keywords" id="keywords" content=" jacobian hessian optimal values opt_val_hes syntax see also reference purpose basevector x y fun fun::ad_vector fun.ell fun.s fun.sy jac hes signdet example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/optimize.cpp.xml less more

5	5	<title>ADFun Operation Sequence Optimization: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="ADFun Operation Sequence Optimization: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" adfun operation sequence optimization: example and test optimize "/>
	8	<meta name="keywords" id="keywords" content=" adfun operation sequence optimization: example test optimize "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/optimize.xml less more

5	5	<title>Optimize an ADFun Object Tape</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Optimize an ADFun Object Tape"/>
8		<meta name="keywords" id="keywords" content=" optimize an adfun object tape sequence operations speed memory Ndebug syntax purpose f improvements testing efficiency atomic functions rev_sparse_jac nan checking optimization example "/>
	8	<meta name="keywords" id="keywords" content=" optimize adfun object tape sequence operations speed memory Ndebug syntax purpose f improvements testing efficiency atomic functions rev_sparse_jac nan checking optimization example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/par_var.cpp.xml less more

5	5	<title>AD Parameter and Variable Functions: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Parameter and Variable Functions: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad parameter and variable functions: example test "/>
	8	<meta name="keywords" id="keywords" content=" ad parameter variable functions: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/parvar.xml less more

5	5	<title>Is an AD Object a Parameter or Variable</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Is an AD Object a Parameter or Variable"/>
8		<meta name="keywords" id="keywords" content=" is an ad object a parameter or variable syntax purpose x b operation sequence example "/>
	8	<meta name="keywords" id="keywords" content=" is ad object parameter variable syntax purpose x b operation sequence example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+2

-4

doc/pkgconfig.xml less more

95	95	The necessary flags for compiling code that includes CppAD can
96	96	be obtained with the command
97	97	<code><font color='blue'><pre style='display:inline'>
98		pkg-config --cflags cppad
	98	pkg-config --cflags cppad
99	99	</pre></font></code>
100
101	100	Note that this command assumes <a href="pkgconfig.xml" target="_top"><span style='white-space: nowrap'>cppad.pc</span></a>
102	101	is in
103	102	the search path <code><font color="blue">PKG_CONFIG_PATH</font></code>.

107	106
108	107	can be obtained with the commands
109	108	<code><font color='blue'><pre style='display:inline'>
110		pkg-config --libs cppad
	109	pkg-config --libs cppad
111	110	</pre></font></code>
112
113	111	Note that this command assumes <code><font color="blue">ipopt.pc</font></code> is in
114	112	the search path <code><font color="blue">PKG_CONFIG_PATH</font></code>.
115	113

+1

-1

doc/poly.cpp.xml less more

5	5	<title>Polynomial Evaluation: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Polynomial Evaluation: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" polynomial evaluation: example and test "/>
	8	<meta name="keywords" id="keywords" content=" polynomial evaluation: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/poly.xml less more

5	5	<title>Evaluate a Polynomial or its Derivative</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Evaluate a Polynomial or its Derivative"/>
8		<meta name="keywords" id="keywords" content=" evaluate a polynomial or its derivative Poly template syntax description include k z p type operations vector operation sequence example source "/>
	8	<meta name="keywords" id="keywords" content=" evaluate polynomial its derivative Poly template syntax description include k z p type operations vector operation sequence example source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/pow.cpp.xml less more

5	5	<title>The AD Power Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD Power Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad power function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad power function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/pow_int.cpp.xml less more

5	5	<title>The Pow Integer Exponent: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The Pow Integer Exponent: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the pow integer exponent: example and test int "/>
	8	<meta name="keywords" id="keywords" content=" the pow integer exponent: example test int "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+81

-85

doc/print_for_cout.cpp.xml less more

5	5	<title>Printing During Forward Mode: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Printing During Forward Mode: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" printing during forward mode: example and test mode print running source code output "/>
	8	<meta name="keywords" id="keywords" content=" printing during forward mode: example test mode print running source code output "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

102	102	# include <cppad/cppad.hpp>
103	103
104	104	namespace {
105		using std::cout;
106		using std::endl;
107		using CppAD::AD;
108
109		// use of PrintFor to check for invalid function arguments
110		<a href="ad.xml" target="_top">AD</a><double> check_log(const <a href="ad.xml" target="_top">AD</a><double>& y)
111		{ // check during recording
112		if( y <= 0. )
113		cout << "check_log: y = " << y << " is <= 0" << endl;
114
115		// check during zero order forward calculation
116		PrintFor(y, "check_log: y == ", y , " which is <= 0\n");
117
118		return log(y);
119		}
	105	using std::cout;
	106	using std::endl;
	107	using CppAD::AD;
	108
	109	// use of PrintFor to check for invalid function arguments
	110	<a href="ad.xml" target="_top">AD</a><double> check_log(const <a href="ad.xml" target="_top">AD</a><double>& y)
	111	{ // check during recording
	112	if( y <= 0. )
	113	cout << "check_log: y = " << y << " is <= 0" << endl;
	114
	115	// check during zero order forward calculation
	116	PrintFor(y, "check_log: y == ", y , " which is <= 0\n");
	117
	118	return log(y);
	119	}
120	120	}
121	121
122	122	void print_for(void)
123		{ using CppAD::PrintFor;
124
125		// independent variable vector
126		size_t n = 1;
127		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ax(n);
128		ax[0] = 1.;
129		<a href="independent.xml" target="_top">Independent</a>(ax);
130
131		// print a VecAD<double>::reference object that is a parameter
132		CppAD::VecAD<double> av(1);
133		<a href="ad.xml" target="_top">AD</a><double> Zero(0);
134		av[Zero] = 0.;
135		PrintFor("v[0] = ", av[Zero]);
136
137		// Print a newline to separate this from previous output,
138		// then print an <a href="ad.xml" target="_top">AD</a><double> object that is a variable.
139		PrintFor("\nv[0] + x[0] = ", av[0] + ax[0]);
140
141		// A conditional print that will not generate output when x[0] = 2.
142		PrintFor(ax[0], "\n 2. + x[0] = ", 2. + ax[0], "\n");
143
144		// A conditional print that will generate output when x[0] = 2.
145		PrintFor(ax[0] - 2., "\n 3. + x[0] = ", 3. + ax[0], "\n");
146
147		// A log evaluations that will result in an error message when x[0] = 2.
148		<a href="ad.xml" target="_top">AD</a><double> var = 2. - ax[0];
149		<a href="ad.xml" target="_top">AD</a><double> log_var = check_log(var);
150
151		// dependent variable vector
152		size_t m = 2;
153		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ay(m);
154		ay[0] = av[Zero] + ax[0];
155
156		// define f: x -> y and stop tape recording
157		CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(ax, ay);
158
159		// zero order forward with x[0] = 2
160		<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x(n);
161		x[0] = 2.;
162
163		cout << "v[0] = 0" << endl;
164		cout << "v[0] + x[0] = 2" << endl;
165		cout << " 3. + x[0] = 5" << endl;
166		cout << "check_log: y == 0 which is <= 0" << endl;
167		// ./makefile.am expects "Test passes" at beginning of next output line
168		cout << "Test passes if four lines above repeat below:" << endl;
169		f.<a href="forward.xml" target="_top">Forward</a>(0, x);
170
171		return;
	123	{ using CppAD::PrintFor;
	124
	125	// independent variable vector
	126	size_t n = 1;
	127	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ax(n);
	128	ax[0] = 1.;
	129	<a href="independent.xml" target="_top">Independent</a>(ax);
	130
	131	// print a VecAD<double>::reference object that is a parameter
	132	CppAD::VecAD<double> av(1);
	133	<a href="ad.xml" target="_top">AD</a><double> Zero(0);
	134	av[Zero] = 0.;
	135	PrintFor("v[0] = ", av[Zero]);
	136
	137	// Print a newline to separate this from previous output,
	138	// then print an <a href="ad.xml" target="_top">AD</a><double> object that is a variable.
	139	PrintFor("\nv[0] + x[0] = ", av[0] + ax[0]);
	140
	141	// A conditional print that will not generate output when x[0] = 2.
	142	PrintFor(ax[0], "\n 2. + x[0] = ", 2. + ax[0], "\n");
	143
	144	// A conditional print that will generate output when x[0] = 2.
	145	PrintFor(ax[0] - 2., "\n 3. + x[0] = ", 3. + ax[0], "\n");
	146
	147	// A log evaluations that will result in an error message when x[0] = 2.
	148	<a href="ad.xml" target="_top">AD</a><double> var = 2. - ax[0];
	149	<a href="ad.xml" target="_top">AD</a><double> log_var = check_log(var);
	150
	151	// dependent variable vector
	152	size_t m = 2;
	153	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(AD<double>) ay(m);
	154	ay[0] = av[Zero] + ax[0];
	155
	156	// define f: x -> y and stop tape recording
	157	CppAD::<a href="funconstruct.xml" target="_top">ADFun</a><double> f(ax, ay);
	158
	159	// zero order forward with x[0] = 2
	160	<a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(double) x(n);
	161	x[0] = 2.;
	162
	163	cout << "v[0] = 0" << endl;
	164	cout << "v[0] + x[0] = 2" << endl;
	165	cout << " 3. + x[0] = 5" << endl;
	166	cout << "check_log: y == 0 which is <= 0" << endl;
	167	// ./makefile.am expects "Test passes" at beginning of next output line
	168	cout << "Test passes if four lines above repeat below:" << endl;
	169	f.<a href="forward.xml" target="_top">Forward</a>(0, x);
	170
	171	return;
172	172	}
173	173	int main(void)
174		{ bool ok = true;
175		print_for();
176
177		size_t thread;
178		for(thread = 0; thread < 2; thread++)
179		{ ok &= CppAD::omp_alloc::inuse(thread) == 0;
180		ok &= CppAD::omp_alloc::available(thread) == 0;
181		}
182		if( ! ok )
183		return 1;
184		return 0;
	174	{ bool ok = true;
	175	print_for();
	176
	177	size_t thread;
	178	for(thread = 0; thread < 2; thread++)
	179	{ ok &= CppAD::omp_alloc::inuse(thread) == 0;
	180	ok &= CppAD::omp_alloc::available(thread) == 0;
	181	}
	182	if( ! ok )
	183	return 1;
	184	return 0;
185	185	}
186	186	</pre></font></code>
187
188
189		<br/>
190	187	<br/>
191	188	<b><big><a name="Output" id="Output">Output</a></big></b>
192	189	<br/>
193	190	Executing the program above generates the following output:
194	191	<code><font color='blue'><pre style='display:inline'>
195		v[0] = 0
196		v[0] + x[0] = 2
197		Test passes if two lines above repeat below:
198		v[0] = 0
199		v[0] + x[0] = 2
	192	v[0] = 0
	193	v[0] + x[0] = 2
	194	Test passes if two lines above repeat below:
	195	v[0] = 0
	196	v[0] + x[0] = 2
200	197	</pre></font></code>
201
202	198
203	199	<hr/>Input File: print_for/print_for.cpp
204	200

+1

-4

doc/print_for_string.cpp.xml less more

5	5	<title>Print During Zero Order Forward Mode: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Print During Zero Order Forward Mode: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" print during zero order forward mode: example and test "/>
	8	<meta name="keywords" id="keywords" content=" print during zero order forward mode: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

77	77	<td>print_for_string.cpp</td>
78	78	<td>Headings</td>
79	79	</tr></table><br/>
80
81
82
83	80	<center><b><big><big>Print During Zero Order Forward Mode: Example and Test</big></big></b></center>
84	81	<code><font color="blue"><pre style='display:inline'>
85	82	# include <cppad/cppad.hpp>

+10

-14

doc/repeat_det_by_minor_c.xml less more

5	5	<title>Repeat det_by_minor Routine A Specified Number of Times</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Repeat det_by_minor Routine A Specified Number of Times"/>
8		<meta name="keywords" id="keywords" content=" repeat det_by_minor routine a specified number of times syntax size source code "/>
	8	<meta name="keywords" id="keywords" content=" repeat det_by_minor routine specified number times syntax size source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

98	98	</select>
99	99	</td>
100	100	</tr></table><br/>
101
102
103
104	101	<center><b><big><big>Repeat det_by_minor Routine A Specified Number of Times</big></big></b></center>
105	102	<br/>
106	103	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

142	139
143	140	<code><font color='blue'><pre style='display:inline'>
144	141	void repeat_det_by_minor(size_t repeat, size_t size)
145		{ double *a;
146		a = (double) malloc( (size size) * sizeof(double) );
	142	{ double *a;
	143	a = (double) malloc( (size size) * sizeof(double) );
147	144
148		while(repeat--)
149		{ <a href="uniform_01_c.xml" target="_top">uniform_01</a>(size * size, a);
150		<a href="det_by_minor_c.xml" target="_top">det_by_minor</a>(a, size);
151		}
152
153		free(a);
154		return;
	145	while(repeat--)
	146	{ <a href="uniform_01_c.xml" target="_top">uniform_01</a>(size * size, a);
	147	<a href="det_by_minor_c.xml" target="_top">det_by_minor</a>(a, size);
	148	}
	149
	150	free(a);
	151	return;
155	152	}
156	153	</pre></font></code>
157
158	154
159	155	<hr/>Input File: compare_c/det_by_minor.c
160	156

+1

-1

doc/rev_one.cpp.xml less more

5	5	<title>First Order Derivative Driver: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="First Order Derivative Driver: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" first order derivative driver: example and test "/>
	8	<meta name="keywords" id="keywords" content=" first order derivative driver: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/rev_sparse_hes.cpp.xml less more

5	5	<title>Reverse Mode Hessian Sparsity: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Reverse Mode Hessian Sparsity: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" reverse mode hessian sparsity: example and test Revsparsehes sparsity "/>
	8	<meta name="keywords" id="keywords" content=" reverse mode hessian sparsity: example test Revsparsehes sparsity "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/rev_sparse_jac.cpp.xml less more

5	5	<title>Reverse Mode Jacobian Sparsity: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Reverse Mode Jacobian Sparsity: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" reverse mode jacobian sparsity: example and test Revsparsejac sparsity "/>
	8	<meta name="keywords" id="keywords" content=" reverse mode jacobian sparsity: example test Revsparsejac sparsity "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/rev_two.cpp.xml less more

5	5	<title>Second Partials Reverse Driver: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Second Partials Reverse Driver: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" second partials reverse driver: example and test "/>
	8	<meta name="keywords" id="keywords" content=" second partials reverse driver: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/reverse_any.cpp.xml less more

5	5	<title>Reverse Mode General Case: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Reverse Mode General Case: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" reverse mode general case: example and test purpose processing steps "/>
	8	<meta name="keywords" id="keywords" content=" reverse mode general case: example test purpose processing steps "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+4

-4

doc/reverse_identity.xml less more

5	5	<title>An Important Reverse Mode Identity</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="An Important Reverse Mode Identity"/>
8		<meta name="keywords" id="keywords" content=" an important reverse mode identity notation sweep theorem proof "/>
	8	<meta name="keywords" id="keywords" content=" important reverse mode identity notation sweep theorem proof "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

551	551
552	552	times
553	553	continuously differentiable function.
554		Define the functions
	554	Define the functions
555	555
556	556	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
557	557	<mi mathvariant='italic'>Z</mi>

724	724	</msup>
725	725	</mrow></math>
726	726
727		denotes the <code><i>j</i></code>-th column of
	727	denotes the <code><i>j</i></code>-th column of
728	728
729	729	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
730	730	<mi mathvariant='italic'>x</mi>

991	991	<mi mathvariant='italic'>i</mi>
992	992	</mrow></math>
993	993
994		, the <code><i>k</i></code>-th
	994	, the <code><i>k</i></code>-th
995	995	partial of
996	996	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
997	997	<msup><mi mathvariant='italic'>t</mi>

+1

-1

doc/reverse_one.cpp.xml less more

5	5	<title>First Order Reverse Mode: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="First Order Reverse Mode: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" first order reverse mode: example and test "/>
	8	<meta name="keywords" id="keywords" content=" first order reverse mode: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/reverse_three.cpp.xml less more

5	5	<title>Third Order Reverse Mode: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Third Order Reverse Mode: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" third order reverse mode: example and test taylor coefficients "/>
	8	<meta name="keywords" id="keywords" content=" third order reverse mode: example test taylor coefficients "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/reverse_two.cpp.xml less more

5	5	<title>Second Order Reverse ModeExample and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Second Order Reverse ModeExample and Test"/>
8		<meta name="keywords" id="keywords" content=" second order reverse modeexample and test example "/>
	8	<meta name="keywords" id="keywords" content=" second order reverse modeexample test example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+7

-7

doc/reversetheory.xml less more

5	5	<title>The Theory of Reverse Mode</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The Theory of Reverse Mode"/>
8		<meta name="keywords" id="keywords" content=" the theory of reverse mode taylor notation binary operators addition subtraction multiplication division standard math functions "/>
	8	<meta name="keywords" id="keywords" content=" the theory reverse mode taylor notation binary operators addition subtraction multiplication division standard math functions "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

114	114	<br/>
115	115	<b><big><a name="Taylor Notation" id="Taylor Notation">Taylor Notation</a></big></b>
116	116	<br/>
117		In Taylor notation, each variable corresponds to
	117	In Taylor notation, each variable corresponds to
118	118	a function of a single argument which we denote by
119	119	<code><i><font color="black"><span style='white-space: nowrap'>t</span></font></i></code>
120	120

140	140
141	141	, and
142	142	<code><i><font color="black"><span style='white-space: nowrap'>Z(t)</span></font></i></code>
143		are scalar valued functions
	143	are scalar valued functions
144	144	and the corresponding <code><i>p</i></code>-th order Taylor coefficients row vectors are
145	145
146	146	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

319	319	</mrow></math>
320	320
321	321	.
322		In addition, we are given the partial derivatives of a scalar valued function
	322	In addition, we are given the partial derivatives of a scalar valued function
323	323
324	324	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
325	325	<mi mathvariant='italic'>G</mi>

415	415	</msup>
416	416	</mrow></math>
417	417
418		is expressed as a function of the
	418	is expressed as a function of the
419	419	<code><i>j-1</i></code>-th order Taylor coefficient row
420	420	vector for
421	421	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

1363	1363	<b><big><a name="Standard Math Functions" id="Standard Math Functions">Standard Math Functions</a></big></b>
1364	1364	<br/>
1365	1365	The standard math functions have only one argument.
1366		Hence we are given the partial derivatives of a scalar valued function
	1366	Hence we are given the partial derivatives of a scalar valued function
1367	1367
1368	1368	<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mrow>
1369	1369	<mi mathvariant='italic'>G</mi>

1453	1453	</msup>
1454	1454	</mrow></math>
1455	1455
1456		is expressed as a function of the
	1456	is expressed as a function of the
1457	1457	<code><i>j-1</i></code>-th order Taylor coefficient row
1458	1458	vector for
1459	1459	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>

+1

-1

doc/romberg_one.cpp.xml less more

5	5	<title>One Dimensional Romberg Integration: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="One Dimensional Romberg Integration: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" one dimensional romberg integration: example and test "/>
	8	<meta name="keywords" id="keywords" content=" one dimensional romberg integration: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/rombergmul.cpp.xml less more

5	5	<title>One Dimensional Romberg Integration: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="One Dimensional Romberg Integration: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" one dimensional romberg integration: example and test "/>
	8	<meta name="keywords" id="keywords" content=" one dimensional romberg integration: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/rombergmul.xml less more

5	5	<title>Multi-dimensional Romberg Integration</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Multi-dimensional Romberg Integration"/>
8		<meta name="keywords" id="keywords" content=" multi-dimensional romberg integration integrate multi dimensional dimension syntax description include m r f a b n p e float floatvector example source code "/>
	8	<meta name="keywords" id="keywords" content=" multi-dimensional romberg integration integrate multi dimensional dimension syntax description include m r f b n p e float floatvector example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/rombergone.xml less more

5	5	<title>One DimensionalRomberg Integration</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="One DimensionalRomberg Integration"/>
8		<meta name="keywords" id="keywords" content=" one dimensionalromberg integration integrate Romberg syntax description include r f a b n p e float example source code "/>
	8	<meta name="keywords" id="keywords" content=" one dimensionalromberg integration integrate Romberg syntax description include r f b n p e float example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/rosen34.xml less more

5	5	<title>A 3rd and 4th Order Rosenbrock ODE Solver</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A 3rd and 4th Order Rosenbrock ODE Solver"/>
8		<meta name="keywords" id="keywords" content=" a 3rd and 4th order rosenbrock ode solver Rosen34 solve stiff differential equation 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	<meta name="keywords" id="keywords" content=" 3rd 4th order rosenbrock ode solver Rosen34 solve stiff differential equation 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/rosen_34.cpp.xml less more

5	5	<title>Rosen34: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Rosen34: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" rosen34: example and test Rosen34 "/>
	8	<meta name="keywords" id="keywords" content=" rosen34: example test Rosen34 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/runge45.xml less more

5	5	<title>An Embedded 4th and 5th Order Runge-Kutta ODE Solver</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="An Embedded 4th and 5th Order Runge-Kutta ODE Solver"/>
8		<meta name="keywords" id="keywords" content=" an embedded 4th and 5th order runge-kutta ode solver Runge45 Runge Kutta solve differential equation 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	<meta name="keywords" id="keywords" content=" embedded 4th 5th order runge-kutta ode solver Runge45 Runge Kutta solve differential equation syntax purpose operation sequence include xf fun t x f warning m ti tf xi e scalar fabs vector parallel mode example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/runge45_1.cpp.xml less more

5	5	<title>Runge45: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Runge45: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" runge45: example and test Runge45 "/>
	8	<meta name="keywords" id="keywords" content=" runge45: example test Runge45 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/runge45_2.cpp.xml less more

5	5	<title>Runge45: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Runge45: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" runge45: example and test Runge45 "/>
	8	<meta name="keywords" id="keywords" content=" runge45: example test Runge45 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+38

-42

doc/sacado_det_lu.cpp.xml less more

5	5	<title>Sacado Speed: Gradient of Determinant Using Lu Factorization</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sacado Speed: Gradient of Determinant Using Lu Factorization"/>
8		<meta name="keywords" id="keywords" content=" sacado speed: gradient of determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: gradient determinant using lu factorization link_det_lu speed matrix factor specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Sacado Speed: Gradient of Determinant Using Lu Factorization</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

115	112	extern bool global_memory, global_onetape, global_atomic, global_optimize;
116	113
117	114	bool link_det_lu(
118		size_t size ,
119		size_t repeat ,
120		CppAD::vector<double> &matrix ,
121		CppAD::vector<double> &gradient )
	115	size_t size ,
	116	size_t repeat ,
	117	CppAD::vector<double> &matrix ,
	118	CppAD::vector<double> &gradient )
122	119	{
123		// speed test global option values
124		if( global_onetape \|\| global_atomic )
125		return false;
126		if( global_memory \|\| global_optimize )
127		return false;
128		// -----------------------------------------------------
129		// setup
130		//
131		// object for computing determinant
132		typedef Sacado::Rad::ADvar<double> ADScalar;
133		typedef CppAD::vector<ADScalar> ADVector;
134		CppAD::det_by_lu<ADScalar> Det(size);
	120	// speed test global option values
	121	if( global_onetape \|\| global_atomic )
	122	return false;
	123	if( global_memory \|\| global_optimize )
	124	return false;
	125	// -----------------------------------------------------
	126	// setup
	127	//
	128	// object for computing determinant
	129	typedef Sacado::Rad::ADvar<double> ADScalar;
	130	typedef CppAD::vector<ADScalar> ADVector;
	131	CppAD::det_by_lu<ADScalar> Det(size);
135	132
136		size_t i; // temporary index
137		size_t n = size * size; // number of independent variables
138		ADScalar detA; // AD value of the determinant
139		ADVector A(n); // AD version of matrix
	133	size_t i; // temporary index
	134	size_t n = size * size; // number of independent variables
	135	ADScalar detA; // AD value of the determinant
	136	ADVector A(n); // AD version of matrix
140	137
141		// ------------------------------------------------------
142		while(repeat--)
143		{ // get the next matrix
144		CppAD::uniform_01(n, matrix);
	138	// ------------------------------------------------------
	139	while(repeat--)
	140	{ // get the next matrix
	141	CppAD::uniform_01(n, matrix);
145	142
146		// set independent variable values
147		for(i = 0; i < n; i++)
148		A[i] = matrix[i];
	143	// set independent variable values
	144	for(i = 0; i < n; i++)
	145	A[i] = matrix[i];
149	146
150		// compute the determinant
151		detA = Det(A);
	147	// compute the determinant
	148	detA = Det(A);
152	149
153		// compute the gradient of detA
154		ADScalar::Gradcomp();
	150	// compute the gradient of detA
	151	ADScalar::Gradcomp();
155	152
156		// evaluate and return gradient using reverse mode
157		for(i =0; i < n; i++)
158		gradient[i] = A[i].adj(); // partial detA w.r.t A[i]
159		}
160		// ---------------------------------------------------------
161		return true;
	153	// evaluate and return gradient using reverse mode
	154	for(i =0; i < n; i++)
	155	gradient[i] = A[i].adj(); // partial detA w.r.t A[i]
	156	}
	157	// ---------------------------------------------------------
	158	return true;
162	159	}
163	160	</pre></font></code>
164
165	161
166	162	<hr/>Input File: speed/sacado/det_lu.cpp
167	163

+37

-38

doc/sacado_det_minor.cpp.xml less more

5	5	<title>Sacado Speed: Gradient of Determinant by Minor Expansion</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sacado Speed: Gradient of Determinant by Minor Expansion"/>
8		<meta name="keywords" id="keywords" content=" sacado speed: gradient of determinant by minor expansion link_det_minor speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: gradient determinant minor expansion link_det_minor speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

113	113	extern bool global_memory, global_onetape, global_atomic, global_optimize;
114	114
115	115	bool link_det_minor(
116		size_t size ,
117		size_t repeat ,
118		CppAD::vector<double> &matrix ,
119		CppAD::vector<double> &gradient )
	116	size_t size ,
	117	size_t repeat ,
	118	CppAD::vector<double> &matrix ,
	119	CppAD::vector<double> &gradient )
120	120	{
121		// speed test global option values
122		if( global_atomic )
123		return false;
124		if( global_memory \|\| global_onetape \|\| global_optimize )
125		return false;
126		// -----------------------------------------------------
127		// setup
	121	// speed test global option values
	122	if( global_atomic )
	123	return false;
	124	if( global_memory \|\| global_onetape \|\| global_optimize )
	125	return false;
	126	// -----------------------------------------------------
	127	// setup
128	128
129		// object for computing determinant
130		typedef Sacado::Rad::ADvar<double> ADScalar;
131		typedef CppAD::vector<ADScalar> ADVector;
132		CppAD::det_by_minor<ADScalar> Det(size);
	129	// object for computing determinant
	130	typedef Sacado::Rad::ADvar<double> ADScalar;
	131	typedef CppAD::vector<ADScalar> ADVector;
	132	CppAD::det_by_minor<ADScalar> Det(size);
133	133
134		size_t i; // temporary index
135		size_t n = size * size; // number of independent variables
136		ADScalar detA; // AD value of the determinant
137		ADVector A(n); // AD version of matrix
	134	size_t i; // temporary index
	135	size_t n = size * size; // number of independent variables
	136	ADScalar detA; // AD value of the determinant
	137	ADVector A(n); // AD version of matrix
138	138
139		// ------------------------------------------------------
140		while(repeat--)
141		{ // get the next matrix
142		CppAD::uniform_01(n, matrix);
	139	// ------------------------------------------------------
	140	while(repeat--)
	141	{ // get the next matrix
	142	CppAD::uniform_01(n, matrix);
143	143
144		// set independent variable values
145		for(i = 0; i < n; i++)
146		A[i] = matrix[i];
	144	// set independent variable values
	145	for(i = 0; i < n; i++)
	146	A[i] = matrix[i];
147	147
148		// compute the determinant
149		detA = Det(A);
	148	// compute the determinant
	149	detA = Det(A);
150	150
151		// reverse mode compute gradient of last computed value; i.e., detA
152		ADScalar::Gradcomp();
	151	// reverse mode compute gradient of last computed value; i.e., detA
	152	ADScalar::Gradcomp();
153	153
154		// return gradient
155		for(i =0; i < n; i++)
156		gradient[i] = A[i].adj(); // partial detA w.r.t A[i]
157		}
158		// ---------------------------------------------------------
159		return true;
	154	// return gradient
	155	for(i =0; i < n; i++)
	156	gradient[i] = A[i].adj(); // partial detA w.r.t A[i]
	157	}
	158	// ---------------------------------------------------------
	159	return true;
160	160	}
161	161	</pre></font></code>
162
163	162
164	163	<hr/>Input File: speed/sacado/det_minor.cpp
165	164

+41

-45

doc/sacado_mat_mul.cpp.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Sacado Speed: Matrix Multiplication</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

116	113	extern bool global_memory, global_onetape, global_atomic, global_optimize;
117	114
118	115	bool link_mat_mul(
119		size_t size ,
120		size_t repeat ,
121		CppAD::vector<double>& x ,
122		CppAD::vector<double>& z ,
123		CppAD::vector<double>& dz )
	116	size_t size ,
	117	size_t repeat ,
	118	CppAD::vector<double>& x ,
	119	CppAD::vector<double>& z ,
	120	CppAD::vector<double>& dz )
124	121	{
125		// speed test global option values
126		if( global_memory \|\| global_onetape \|\| global_atomic \|\| global_optimize )
127		return false;
128		// -----------------------------------------------------
129		// setup
	122	// speed test global option values
	123	if( global_memory \|\| global_onetape \|\| global_atomic \|\| global_optimize )
	124	return false;
	125	// -----------------------------------------------------
	126	// setup
130	127
131		// object for computing determinant
132		typedef Sacado::Rad::ADvar<double> ADScalar;
133		typedef CppAD::vector<ADScalar> ADVector;
	128	// object for computing determinant
	129	typedef Sacado::Rad::ADvar<double> ADScalar;
	130	typedef CppAD::vector<ADScalar> ADVector;
134	131
135		size_t j; // temporary index
136		size_t m = 1; // number of dependent variables
137		size_t n = size * size; // number of independent variables
138		ADVector X(n); // AD domain space vector
139		ADVector Y(n); // Store product matrix
140		ADVector Z(m); // AD range space vector
141		ADScalar f;
	132	size_t j; // temporary index
	133	size_t m = 1; // number of dependent variables
	134	size_t n = size * size; // number of independent variables
	135	ADVector X(n); // AD domain space vector
	136	ADVector Y(n); // Store product matrix
	137	ADVector Z(m); // AD range space vector
	138	ADScalar f;
142	139
143		// ------------------------------------------------------
144		while(repeat--)
145		{ // get the next matrix
146		CppAD::uniform_01(n, x);
	140	// ------------------------------------------------------
	141	while(repeat--)
	142	{ // get the next matrix
	143	CppAD::uniform_01(n, x);
147	144
148		// set independent variable values
149		for(j = 0; j < n; j++)
150		X[j] = x[j];
	145	// set independent variable values
	146	for(j = 0; j < n; j++)
	147	X[j] = x[j];
151	148
152		// do the computation
153		mat_sum_sq(size, X, Y, Z);
	149	// do the computation
	150	mat_sum_sq(size, X, Y, Z);
154	151
155		// create function object f : X -> Z
156		f = Z[0];
	152	// create function object f : X -> Z
	153	f = Z[0];
157	154
158		// reverse mode gradient of last ADvar computed value; i.e., f
159		ADScalar::Gradcomp();
	155	// reverse mode gradient of last ADvar computed value; i.e., f
	156	ADScalar::Gradcomp();
160	157
161		// return gradient
162		for(j = 0; j < n; j++)
163		dz[j] = X[j].adj(); // partial f w.r.t X[j]
164		}
165		// return function value
166		z[0] = f.val();
	158	// return gradient
	159	for(j = 0; j < n; j++)
	160	dz[j] = X[j].adj(); // partial f w.r.t X[j]
	161	}
	162	// return function value
	163	z[0] = f.val();
167	164
168		// ---------------------------------------------------------
169		return true;
	165	// ---------------------------------------------------------
	166	return true;
170	167	}
171	168	</pre></font></code>
172
173	169
174	170	<hr/>Input File: speed/sacado/mat_mul.cpp
175	171

+38

-42

doc/sacado_ode.cpp.xml less more

5	5	<title>Sacado Speed: Gradient of Ode Solution</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sacado Speed: Gradient of Ode Solution"/>
8		<meta name="keywords" id="keywords" content=" sacado speed: gradient of ode solution link_ode speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: gradient ode solution link_ode speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Sacado Speed: Gradient of Ode Solution</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

118	115	extern bool global_memory, global_onetape, global_atomic, global_optimize;
119	116
120	117	bool link_ode(
121		size_t size ,
122		size_t repeat ,
123		CppAD::vector<double> &x ,
124		CppAD::vector<double> &jacobian
	118	size_t size ,
	119	size_t repeat ,
	120	CppAD::vector<double> &x ,
	121	CppAD::vector<double> &jacobian
125	122	)
126	123	{
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
134		assert( x.size() == size );
135		assert( jacobian.size() == size * size );
	124	// speed test global option values
	125	if( global_atomic )
	126	return false;
	127	if( global_memory \|\| global_onetape \|\| global_optimize )
	128	return false;
	129	// -------------------------------------------------------------
	130	// setup
	131	assert( x.size() == size );
	132	assert( jacobian.size() == size * size );
136	133
137		typedef Sacado::Fad::DFad<double> ADScalar;
138		typedef CppAD::vector<ADScalar> ADVector;
	134	typedef Sacado::Fad::DFad<double> ADScalar;
	135	typedef CppAD::vector<ADScalar> ADVector;
139	136
140		size_t i, j;
141		size_t p = 0; // use ode to calculate function values
142		size_t n = size; // number of independent variables
143		size_t m = n; // number of dependent variables
144		ADVector X(n), Y(m); // independent and dependent variables
	137	size_t i, j;
	138	size_t p = 0; // use ode to calculate function values
	139	size_t n = size; // number of independent variables
	140	size_t m = n; // number of dependent variables
	141	ADVector X(n), Y(m); // independent and dependent variables
145	142
146		// -------------------------------------------------------------
147		while(repeat--)
148		{ // choose next x value
149		CppAD::uniform_01(n, x);
150		for(j = 0; j < n; j++)
151		{ // set up for X as the independent variable vector
152		X[j] = ADScalar(int(n), int(j), x[j]);
153		}
	143	// -------------------------------------------------------------
	144	while(repeat--)
	145	{ // choose next x value
	146	CppAD::uniform_01(n, x);
	147	for(j = 0; j < n; j++)
	148	{ // set up for X as the independent variable vector
	149	X[j] = ADScalar(int(n), int(j), x[j]);
	150	}
154	151
155		// evaluate function
156		CppAD::ode_evaluate(X, p, Y);
	152	// evaluate function
	153	CppAD::ode_evaluate(X, p, Y);
157	154
158		// return values with Y as the dependent variable vector
159		for(i = 0; i < m; i++)
160		{ for(j = 0; j < n; j++)
161		jacobian[ i * n + j ] = Y[i].dx(j);
162		}
163		}
164		return true;
	155	// return values with Y as the dependent variable vector
	156	for(i = 0; i < m; i++)
	157	{ for(j = 0; j < n; j++)
	158	jacobian[ i * n + j ] = Y[i].dx(j);
	159	}
	160	}
	161	return true;
165	162	}
166	163	</pre></font></code>
167
168	164
169	165	<hr/>Input File: speed/sacado/ode.cpp
170	166

+40

-44

doc/sacado_poly.cpp.xml less more

5	5	<title>Sacado Speed: Second Derivative of a Polynomial</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sacado Speed: Second Derivative of a Polynomial"/>
8		<meta name="keywords" id="keywords" content=" sacado speed: second derivative of a polynomial link_poly speed specifications implementation "/>
	8	<meta name="keywords" id="keywords" content=" sacado speed: second derivative polynomial link_poly speed specifications implementation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97	94	<center><b><big><big>Sacado Speed: Second Derivative of a Polynomial</big></big></b></center>
98	95	<br/>
99	96	<b><big><a name="Specifications" id="Specifications">Specifications</a></big></b>

117	114	extern bool global_memory, global_onetape, global_atomic, global_optimize;
118	115
119	116	bool link_poly(
120		size_t size ,
121		size_t repeat ,
122		CppAD::vector<double> &a , // coefficients of polynomial
123		CppAD::vector<double> &z , // polynomial argument value
124		CppAD::vector<double> &ddp ) // second derivative w.r.t z
	117	size_t size ,
	118	size_t repeat ,
	119	CppAD::vector<double> &a , // coefficients of polynomial
	120	CppAD::vector<double> &z , // polynomial argument value
	121	CppAD::vector<double> &ddp ) // second derivative w.r.t z
125	122	{
126		if( global_atomic )
127		return false;
128		if( global_memory \|\| global_onetape \|\| global_optimize )
129		return false;
130		// -----------------------------------------------------
131		// setup
132		typedef Sacado::Tay::Taylor<double> ADScalar;
133		CppAD::vector<ADScalar> A(size);
	123	if( global_atomic )
	124	return false;
	125	if( global_memory \|\| global_onetape \|\| global_optimize )
	126	return false;
	127	// -----------------------------------------------------
	128	// setup
	129	typedef Sacado::Tay::Taylor<double> ADScalar;
	130	CppAD::vector<ADScalar> A(size);
134	131
135		size_t i; // temporary index
136		ADScalar Z; // domain space AD value
137		ADScalar P; // range space AD value
138		unsigned int order = 2; // order of Taylor coefficients
139		Z.resize(order+1, false);
140		P.resize(order+1, false);
	132	size_t i; // temporary index
	133	ADScalar Z; // domain space AD value
	134	ADScalar P; // range space AD value
	135	unsigned int order = 2; // order of Taylor coefficients
	136	Z.resize(order+1, false);
	137	P.resize(order+1, false);
141	138
142		// choose the polynomial coefficients
143		CppAD::uniform_01(size, a);
	139	// choose the polynomial coefficients
	140	CppAD::uniform_01(size, a);
144	141
145		// AD copy of the polynomial coefficients
146		for(i = 0; i < size; i++)
147		A[i] = a[i];
	142	// AD copy of the polynomial coefficients
	143	for(i = 0; i < size; i++)
	144	A[i] = a[i];
148	145
149		// ------------------------------------------------------
150		while(repeat--)
151		{ // get the next argument value
152		CppAD::uniform_01(1, z);
	146	// ------------------------------------------------------
	147	while(repeat--)
	148	{ // get the next argument value
	149	CppAD::uniform_01(1, z);
153	150
154		// independent variable value
155		Z.fastAccessCoeff(0) = z[0]; // argument value
156		Z.fastAccessCoeff(1) = 1.; // first order coefficient
157		Z.fastAccessCoeff(2) = 0.; // second order coefficient
	151	// independent variable value
	152	Z.fastAccessCoeff(0) = z[0]; // argument value
	153	Z.fastAccessCoeff(1) = 1.; // first order coefficient
	154	Z.fastAccessCoeff(2) = 0.; // second order coefficient
158	155
159		// AD computation of the dependent variable
160		P = CppAD::Poly(0, A, Z);
	156	// AD computation of the dependent variable
	157	P = CppAD::Poly(0, A, Z);
161	158
162		// second derivative is twice second order Taylor coefficient
163		ddp[0] = 2. * P.fastAccessCoeff(2);
164		}
165		// ------------------------------------------------------
166		return true;
	159	// second derivative is twice second order Taylor coefficient
	160	ddp[0] = 2. * P.fastAccessCoeff(2);
	161	}
	162	// ------------------------------------------------------
	163	return true;
167	164	}
168	165	</pre></font></code>
169
170	166
171	167	<hr/>Input File: speed/sacado/poly.cpp
172	168

+3

-6

doc/sacado_sparse_hessian.cpp.xml less more

85	85	<td>sacado_sparse_hessian.cpp</td>
86	86	<td>Headings</td>
87	87	</tr></table><br/>
88
89
90
91	88	<center><b><big><big>Sacado Speed: Sparse Hessian</big></big></b></center>
92		<code><font color='blue'><pre style='display:inline'> // A sacado version of this test is not yet implemented
	89	<code><font color='blue'><pre style='display:inline'>
	90	// A sacado version of this test is not yet implemented
93	91	extern bool link_sparse_hessian(
94	92	size_t size ,
95	93	size_t repeat ,

100	98	size_t& n_sweep
101	99	)
102	100	{
103		return false;
	101	return false;
104	102	}
105	103	</pre></font></code>
106
107	104
108	105	<hr/>Input File: speed/sacado/sparse_hessian.cpp
109	106

+11

-14

doc/sacado_sparse_jacobian.cpp.xml less more

85	85	<td>sacado_sparse_jacobian.cpp</td>
86	86	<td>Headings</td>
87	87	</tr></table><br/>
88
89
90
91	88	<center><b><big><big>sacado Speed: sparse_jacobian</big></big></b></center>
92		<code><font color='blue'><pre style='display:inline'> // A sacado version of this test is not yet available
	89	<code><font color='blue'><pre style='display:inline'>
	90	// A sacado version of this test is not yet available
93	91	bool link_sparse_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 )
	92	size_t size ,
	93	size_t repeat ,
	94	size_t m ,
	95	const CppAD::vector<size_t>& row ,
	96	const CppAD::vector<size_t>& col ,
	97	CppAD::vector<double>& x ,
	98	CppAD::vector<double>& jacobian ,
	99	size_t& n_sweep )
102	100	{
103		return false;
	101	return false;
104	102	}
105	103	</pre></font></code>
106
107	104
108	105	<hr/>Input File: speed/sacado/sparse_jacobian.cpp
109	106

+1

-1

doc/seq_property.cpp.xml less more

5	5	<title>ADFun Sequence Properties: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="ADFun Sequence Properties: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" adfun sequence properties: example and test Domain Range Parameter size_var size_par size_op_arg size_vecad "/>
	8	<meta name="keywords" id="keywords" content=" adfun sequence properties: example test Domain Range Parameter size_var size_par size_op_arg size_vecad "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sign.cpp.xml less more

5	5	<title>Sign Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sign Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" sign function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" sign function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/simple_ad_bthread.cpp.xml less more

5	5	<title>A Simple Boost Threading AD: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Simple Boost Threading AD: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" a simple boost threading ad: example and test thread Ad purpose source code "/>
	8	<meta name="keywords" id="keywords" content=" simple boost threading ad: example test thread Ad purpose source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/simple_ad_openmp.cpp.xml less more

5	5	<title>A Simple OpenMP AD: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Simple OpenMP AD: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" a simple openmp ad: example and test Ad purpose source code "/>
	8	<meta name="keywords" id="keywords" content=" simple openmp ad: example test Ad purpose source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/simple_ad_pthread.cpp.xml less more

5	5	<title>A Simple pthread AD: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Simple pthread AD: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" a simple pthread ad: example and test Ad purpose source code "/>
	8	<meta name="keywords" id="keywords" content=" simple pthread ad: example test Ad purpose source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/simple_vector.cpp.xml less more

5	5	<title>Simple Vector Template Class: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Simple Vector Template Class: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" simple vector template class: example and test "/>
	8	<meta name="keywords" id="keywords" content=" simple vector template class: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/simplevector.xml less more

5	5	<title>Definition of a Simple Vector</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Definition of a Simple Vector"/>
8		<meta name="keywords" id="keywords" content=" definition of a simple vector value_type [] Ndebug template class requirements elements specified type default constructor sizing copy element and destructor assignment size resize value access using example exercise "/>
	8	<meta name="keywords" id="keywords" content=" definition simple vector value_type [] Ndebug template class requirements elements specified type default constructor sizing copy element destructor assignment size resize value access using example exercise "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sin.cpp.xml less more

5	5	<title>The AD sin Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD sin Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad sin function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad sin function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sin_cos_forward.xml less more

5	5	<title>Trigonometric and Hyperbolic Sine and Cosine Forward Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Trigonometric and Hyperbolic Sine and Cosine Forward Theory"/>
8		<meta name="keywords" id="keywords" content=" trigonometric and hyperbolic sine cosine forward theory sin sinh cos cosh differential equation "/>
	8	<meta name="keywords" id="keywords" content=" trigonometric hyperbolic sine cosine forward theory sin sinh cos cosh differential equation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sin_cos_reverse.xml less more

5	5	<title>Trigonometric and Hyperbolic Sine and Cosine Reverse Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Trigonometric and Hyperbolic Sine and Cosine Reverse Theory"/>
8		<meta name="keywords" id="keywords" content=" trigonometric and hyperbolic sine cosine reverse theory sin sinh cos cosh "/>
	8	<meta name="keywords" id="keywords" content=" trigonometric hyperbolic sine cosine reverse theory sin sinh cos cosh "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sinh.cpp.xml less more

5	5	<title>The AD sinh Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD sinh Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad sinh function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad sinh function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+7

-7

doc/size_order.xml less more

123	123	Determine the number of Taylor coefficient orders, per variable,direction,
124	124	currently calculated and stored in the ADFun object
125	125	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
126		.
127		See the discussion under
	126	.
	127	See the discussion under
128	128	<a href="size_order.xml#Constructor" target="_top"><span style='white-space: nowrap'>Constructor</span></a>
129	129	,
130	130	<a href="size_order.xml#Forward" target="_top"><span style='white-space: nowrap'>Forward</span></a>

155	155	<code><font color="blue"><span style='white-space: nowrap'><br/>
156	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	157	</span></font></code>
158		and is the number of Taylor coefficient orders,
	158	and is the number of Taylor coefficient orders,
159	159	per variable,direction in the AD operation sequence,
160	160	currently calculated and stored in the ADFun object
161	161	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>

190	190	</span></font></code>
191	191	the value of
192	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>
	193	returned by <code><font color="blue">size_order</font></code>
194	194	would be
195	195	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
196	196	<mi mathvariant='italic'>q</mi>

200	200
201	201	.
202	202	The call to <code><font color="blue">Forward</font></code> above
203		uses the lower order Taylor coefficients to compute and store
	203	uses the lower order Taylor coefficients to compute and store
204	204	the <code><i>q</i></code>-th order Taylor coefficients for all
205	205	the variables in the operation sequence corresponding to
206	206	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>

229	229	<code><i><font color="black"><span style='white-space: nowrap'>f</span></font></i></code>
230	230	is less than or equal
231	231	<code><i><font color="black"><span style='white-space: nowrap'>c</span></font></i></code>
232		,
	232	,
233	233	a call to <a href="capacity_order.xml" target="_top"><span style='white-space: nowrap'>capacity_order</span></a>
234	234	with the syntax
235	235

252	252	<mn>-1</mn>
253	253	</mrow></math>
254	254
255
	255
256	256	have been retained).
257	257
258	258	<br/>

+1

-1

doc/sparse_hes_fun.cpp.xml less more

5	5	<title>sparse_hes_fun: Example and test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="sparse_hes_fun: Example and test"/>
8		<meta name="keywords" id="keywords" content=" sparse_hes_fun: example and test sparse_hes_fun "/>
	8	<meta name="keywords" id="keywords" content=" sparse_hes_fun: example test sparse_hes_fun "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sparse_hes_fun.xml less more

5	5	<title>Evaluate a Function That Has a Sparse Hessian</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Evaluate a Function That Has a Sparse Hessian"/>
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 example source code "/>
	8	<meta name="keywords" id="keywords" content=" evaluate function that has sparse hessian sparse_hes_fun syntax purpose inclusion float floatvector n x row col p fp example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sparse_hessian.cpp.xml less more

5	5	<title>Sparse Hessian: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sparse Hessian: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" sparse hessian: example and test Hessian spare "/>
	8	<meta name="keywords" id="keywords" content=" sparse hessian: example test Hessian spare "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sparse_jac_fun.cpp.xml less more

5	5	<title>sparse_jac_fun: Example and test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="sparse_jac_fun: Example and test"/>
8		<meta name="keywords" id="keywords" content=" sparse_jac_fun: example and test sparse_jac_fun "/>
	8	<meta name="keywords" id="keywords" content=" sparse_jac_fun: example test sparse_jac_fun "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sparse_jac_fun.xml less more

5	5	<title>Evaluate a Function That Has a Sparse Jacobian</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Evaluate a Function That Has a Sparse Jacobian"/>
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	<meta name="keywords" id="keywords" content=" evaluate function that has sparse jacobian sparse_jac_fun syntax purpose inclusion float floatvector n m x row col p fp example source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sparse_jacobian.cpp.xml less more

5	5	<title>Sparse Jacobian: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sparse Jacobian: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" sparse jacobian: example and test Jacobian spare "/>
	8	<meta name="keywords" id="keywords" content=" sparse jacobian: example test Jacobian spare "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-2

doc/sparse_jacobian.xml less more

628	628	or rows (reverse mode) can be computed during the same sweep.
629	629	This field has prototype
630	630	<code><font color='blue'><pre style='display:inline'>
631		std::string %work%.color_method
	631	std::string %work%.color_method
632	632	</pre></font></code>
633
634	633	and its default value (after a constructor or <code><font color="blue">clear()</font></code>)
635	634	is <code><font color="blue">"cppad"</font></code>.
636	635	If <a href="colpack_prefix.xml" target="_top"><span style='white-space: nowrap'>colpack_prefix</span></a>

+1

-1

doc/sparse_sub_hes.cpp.xml less more

5	5	<title>Sparse Hessian on Subset of Variables: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sparse Hessian on Subset of Variables: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" sparse hessian on subset of variables: example and test purpose see also "/>
	8	<meta name="keywords" id="keywords" content=" sparse hessian on subset variables: example test purpose see also "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sparsity_sub.cpp.xml less more

5	5	<title>Sparsity Patterns For a Subset of Variables: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Sparsity Patterns For a Subset of Variables: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" sparsity patterns for a subset of variables: example and test see also forsparsejac revsparsehes "/>
	8	<meta name="keywords" id="keywords" content=" sparsity patterns subset variables: example test see also forsparsejac revsparsehes "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/speed.xml less more

5	5	<title>Speed Test an Operator Overloading AD Package</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	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	<meta name="keywords" id="keywords" content=" speed test operator overloading ad package purpose "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-5

doc/speed_adolc.xml less more

5	5	<title>Speed Test of Derivatives Using Adolc</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Speed Test of Derivatives Using Adolc"/>
8		<meta name="keywords" id="keywords" content=" speed test of derivatives using adolc purpose adolc_prefix running tests "/>
	8	<meta name="keywords" id="keywords" content=" speed test derivatives using adolc purpose adolc_prefix running tests "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

92	92	</select>
93	93	</td>
94	94	</tr></table><br/>
95
96
97
98
99	95	<center><b><big><big>Speed Test of Derivatives Using Adolc</big></big></b></center>
100	96	<br/>
101	97	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>

+1

-1

doc/speed_double.xml less more

5	5	<title>Speed Test of Functions in Double</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Speed Test of Functions in Double"/>
8		<meta name="keywords" id="keywords" content=" speed test of functions in double purpose running tests "/>
	8	<meta name="keywords" id="keywords" content=" speed test functions double purpose running tests "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+0

-4

doc/speed_fadbad.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97
98	94	<center><b><big><big>Speed Test Derivatives Using Fadbad</big></big></b></center>
99	95	<br/>
100	96	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>

+6

-12

doc/speed_main.xml less more

270	270	<br/>
271	271	If the option <code><font color="blue">onetape</font></code> is present, the symbol
272	272	<code><font color='blue'><pre style='display:inline'>
273		extern bool global_onetape
	273	extern bool global_onetape
274	274	</pre></font></code>
275
276	275	is true and otherwise it is false.
277	276	If this external symbol is true,
278	277	CppAD will use one taping of the operation

301	300	<br/>
302	301	If the option <code><font color="blue">optimize</font></code> is present, the symbol
303	302	<code><font color='blue'><pre style='display:inline'>
304		extern bool global_optimize
	303	extern bool global_optimize
305	304	</pre></font></code>
306
307	305	is true and otherwise it is false.
308	306	If this external symbol is true,
309	307	CppAD will optimize the operation sequence before doing computations.

315	313	<br/>
316	314	If the option <code><font color="blue">atomic</font></code> is present, the symbol
317	315	<code><font color='blue'><pre style='display:inline'>
318		extern bool global_atomic
	316	extern bool global_atomic
319	317	</pre></font></code>
320
321	318	is true and otherwise it is false.
322	319	If this external symbol is true, CppAD will use its user defined
323	320	<a href="atomic_base.xml" target="_top"><span style='white-space: nowrap'>atomic</span></a>

331	328	<br/>
332	329	If the option <code><font color="blue">memory</font></code> is present, the symbol
333	330	<code><font color='blue'><pre style='display:inline'>
334		extern bool global_memory
	331	extern bool global_memory
335	332	</pre></font></code>
336
337	333	is true and otherwise it is false.
338	334	If it is true, the CppAD
339	335	<a href="ta_hold_memory.xml" target="_top"><span style='white-space: nowrap'>hold_memory</span></a>

359	355	<br/>
360	356	If the option <code><font color="blue">boolsparsity</font></code> is present, the symbol
361	357	<code><font color='blue'><pre style='display:inline'>
362		extern bool global_boolsparsity
	358	extern bool global_boolsparsity
363	359	</pre></font></code>
364
365	360	is true and otherwise it is false.
366	361	If it is true, CppAD will use a
367	362	<a href="glossary.xml#Sparsity Pattern.Vector of Boolean" target="_top"><span style='white-space: nowrap'>vector of bool</span></a>

377	372	<br/>
378	373	If the option <code><font color="blue">colpack</font></code> is present, the symbol
379	374	<code><font color='blue'><pre style='display:inline'>
380		extern bool global_colpack
	375	extern bool global_colpack
381	376	</pre></font></code>
382
383	377	is true and otherwise it is false.
384	378	If this external symbol is true,
385	379	CppAD will use <a href="colpack_prefix.xml" target="_top"><span style='white-space: nowrap'>colpack</span></a>

+40

-49

doc/speed_program.cpp.xml less more

5	5	<title>Example Use of SpeedTest</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Example Use of SpeedTest"/>
8		<meta name="keywords" id="keywords" content=" example use of speedtest test speed running this program output "/>
	8	<meta name="keywords" id="keywords" content=" example use speedtest test speed running this program output "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

115	115	you can compile and run this program by changing into the
116	116	<code><font color="blue">speed/example</font></code> directory and executing the following commands
117	117	<code><font color='blue'><pre style='display:inline'>
118		g++ -I../.. speed_program.cpp -o speed_program.exe
119		./speed_program.exe
	118	g++ -I../.. speed_program.cpp -o speed_program.exe
	119	./speed_program.exe
120	120	</pre></font></code>
121
122
123		<br/>
124	121	<br/>
125	122	<b><big><a name="Program" id="Program">Program</a></big></b>
126	123

128	125	# include <cppad/utility/speed_test.hpp>
129	126
130	127	std::string Test(size_t size, size_t repeat)
131		{ // setup
132		double *a = new double[size];
133		double *b = new double[size];
134		double *c = new double[size];
135		size_t i = size;;
136		while(i)
137		{ --i;
138		a[i] = i;
139		b[i] = 2 * i;
140		}
141		// operations we are timing
142		while(repeat--)
143		{ i = size;;
144		while(i)
145		{ --i;
146		c[i] = a[i] + b[i];
147		}
148		}
149		// teardown
150		delete [] a;
151		delete [] b;
152		delete [] c;
	128	{ // setup
	129	double *a = new double[size];
	130	double *b = new double[size];
	131	double *c = new double[size];
	132	size_t i = size;;
	133	while(i)
	134	{ --i;
	135	a[i] = i;
	136	b[i] = 2 * i;
	137	}
	138	// operations we are timing
	139	while(repeat--)
	140	{ i = size;;
	141	while(i)
	142	{ --i;
	143	c[i] = a[i] + b[i];
	144	}
	145	}
	146	// teardown
	147	delete [] a;
	148	delete [] b;
	149	delete [] c;
153	150
154		// return a test name that is valid for all sizes and repeats
155		return "double: c[] = a[] + b[*]";
	151	// return a test name that is valid for all sizes and repeats
	152	return "double: c[] = a[] + b[*]";
156	153	}
157	154	int main(void)
158	155	{
159		CppAD::SpeedTest(Test, 10, 10, 100);
160		return 0;
	156	CppAD::SpeedTest(Test, 10, 10, 100);
	157	return 0;
161	158	}
162	159
163	160	</pre></font></code>
164
165
166		<br/>
167		<br/>
168	161	<b><big><a name="Output" id="Output">Output</a></big></b>
169	162	<br/>
170	163	Executing of the program above generated the following output
171	164	(the rates will be different for each particular system):
172	165	<code><font color='blue'><pre style='display:inline'>
173		double: c[] = a[] + b[*]
174		size = 10 rate = 14,122,236
175		size = 20 rate = 7,157,515
176		size = 30 rate = 4,972,500
177		size = 40 rate = 3,887,214
178		size = 50 rate = 3,123,086
179		size = 60 rate = 2,685,214
180		size = 70 rate = 2,314,737
181		size = 80 rate = 2,032,124
182		size = 90 rate = 1,814,145
183		size = 100 rate = 1,657,828
	166	double: c[] = a[] + b[*]
	167	size = 10 rate = 14,122,236
	168	size = 20 rate = 7,157,515
	169	size = 30 rate = 4,972,500
	170	size = 40 rate = 3,887,214
	171	size = 50 rate = 3,123,086
	172	size = 60 rate = 2,685,214
	173	size = 70 rate = 2,314,737
	174	size = 80 rate = 2,032,124
	175	size = 90 rate = 1,814,145
	176	size = 100 rate = 1,657,828
184	177	</pre></font></code>
185
186
187	178
188	179	<hr/>Input File: speed/example/speed_program.cpp
189	180

+0

-4

doc/speed_sacado.xml less more

91	91	</select>
92	92	</td>
93	93	</tr></table><br/>
94
95
96
97
98	94	<center><b><big><big>Speed Test Derivatives Using Sacado</big></big></b></center>
99	95	<br/>
100	96	<b><big><a name="Purpose" id="Purpose">Purpose</a></big></b>

+1

-1

doc/speed_test.cpp.xml less more

5	5	<title>speed_test: Example and test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="speed_test: Example and test"/>
8		<meta name="keywords" id="keywords" content=" speed_test: example and test speed_test "/>
	8	<meta name="keywords" id="keywords" content=" speed_test: example test speed_test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+2

-3

doc/speed_test.xml less more

5	5	<title>Run One Speed Test and Return Results</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Run One Speed Test and Return Results"/>
8		<meta name="keywords" id="keywords" content=" run one speed test and return results speed_test syntax purpose motivation include vector size repeat size_vec time_min rate_vec timing example "/>
	8	<meta name="keywords" id="keywords" content=" run one speed test return results speed_test syntax purpose motivation include vector size repeat size_vec time_min rate_vec timing example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

305	305	Otherwise,
306	306	time is measured by the difference in
307	307	<code><font color='blue'><pre style='display:inline'>
308		(double) clock() / (double) CLOCKS_PER_SEC
	308	(double) clock() / (double) CLOCKS_PER_SEC
309	309	</pre></font></code>
310
311	310	in the context of the standard <code><font color="blue"><ctime></font></code> definitions.
312	311
313	312

+2

-3

doc/speedtest.xml less more

5	5	<title>Run One Speed Test and Print Results</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Run One Speed Test and Print Results"/>
8		<meta name="keywords" id="keywords" content=" run one speed test and print results Speedtest syntax purpose motivation include size repeat name first last inc rate errors example "/>
	8	<meta name="keywords" id="keywords" content=" run one speed test print results Speedtest syntax purpose motivation include size repeat name first last inc rate errors example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

326	326	corresponding elapsed execution time in seconds.
327	327	The elapsed execution time is measured by the difference in
328	328	<code><font color='blue'><pre style='display:inline'>
329		(double) clock() / (double) CLOCKS_PER_SEC
	329	(double) clock() / (double) CLOCKS_PER_SEC
330	330	</pre></font></code>
331
332	331	in the context of the standard <code><font color="blue"><ctime></font></code> definitions.
333	332
334	333

+1

-1

doc/sqrt.cpp.xml less more

5	5	<title>The AD sqrt Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD sqrt Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad sqrt function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad sqrt function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/stack_machine.cpp.xml less more

5	5	<title>Example Differentiating a Stack Machine Interpreter</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Example Differentiating a Stack Machine Interpreter"/>
8		<meta name="keywords" id="keywords" content=" example differentiating a stack machine interpreter test "/>
	8	<meta name="keywords" id="keywords" content=" example differentiating stack machine interpreter test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sub.cpp.xml less more

5	5	<title>AD Binary Subtraction: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Binary Subtraction: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad binary subtraction: example and test - subtract minus "/>
	8	<meta name="keywords" id="keywords" content=" ad binary subtraction: example test - subtract minus "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sub_eq.cpp.xml less more

5	5	<title>AD Computed Assignment Subtraction: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Computed Assignment Subtraction: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad computed assignment subtraction: example and test -= subtract assign plus add "/>
	8	<meta name="keywords" id="keywords" content=" ad computed assignment subtraction: example test -= subtract assign plus add "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/sub_sparse_hes.cpp.xml less more

5	5	<title>Computing Sparse Hessian for a Subset of Variables</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Computing Sparse Hessian for a Subset of Variables"/>
8		<meta name="keywords" id="keywords" content=" computing sparse hessian for a subset of variables purpose see also function example "/>
	8	<meta name="keywords" id="keywords" content=" computing sparse hessian subset variables purpose see also function example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ta_available.xml less more

5	5	<title>Amount of Memory Available for Quick Use by a Thread</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Amount of Memory Available for Quick Use by a Thread"/>
8		<meta name="keywords" id="keywords" content=" amount of memory available for quick use by a thread syntax purpose num_bytes example "/>
	8	<meta name="keywords" id="keywords" content=" amount memory available quick use thread syntax purpose num_bytes example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ta_create_array.xml less more

5	5	<title>Allocate An Array and Call Default Constructor for its Elements</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Allocate An Array and Call Default Constructor for its Elements"/>
8		<meta name="keywords" id="keywords" content=" allocate an array and call default constructor for its elements create_array syntax purpose type size_min size_out delta alignment example "/>
	8	<meta name="keywords" id="keywords" content=" allocate array call default constructor its elements create_array syntax purpose type size_min size_out delta alignment example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ta_delete_array.xml less more

5	5	<title>Deallocate An Array and Call Destructor for its Elements</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Deallocate An Array and Call Destructor for its Elements"/>
8		<meta name="keywords" id="keywords" content=" deallocate an array and call destructor for its elements delete_array syntax purpose type thread delta example "/>
	8	<meta name="keywords" id="keywords" content=" deallocate array call destructor its elements delete_array syntax purpose type thread delta example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ta_free_all.xml less more

5	5	<title>Free All Memory That Was Allocated for Use by thread_alloc</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Free All Memory That Was Allocated for Use by 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	<meta name="keywords" id="keywords" content=" free all memory that was allocated use thread_alloc syntax purpose ok restrictions example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ta_free_available.xml less more

5	5	<title>Free Memory Currently Available for Quick Use by a Thread</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Free Memory Currently Available for Quick Use by a Thread"/>
8		<meta name="keywords" id="keywords" content=" free memory currently available for quick use by a thread free_available syntax purpose extra example "/>
	8	<meta name="keywords" id="keywords" content=" free memory currently available quick use thread free_available syntax purpose extra example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+2

-5

doc/ta_get_memory.xml less more

5	5	<title>Get At Least A Specified Amount of Memory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Get At Least A Specified Amount of Memory"/>
8		<meta name="keywords" id="keywords" content=" get at least a specified amount of memory allocate syntax purpose min_bytes cap_bytes v_ptr allocation speed alignment example "/>
	8	<meta name="keywords" id="keywords" content=" get least specified amount memory allocate syntax purpose min_bytes cap_bytes v_ptr allocation speed alignment example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

154	154	It specifies the minimum number of bytes to allocate.
155	155	This value must be less than
156	156	<code><font color='blue'><pre style='display:inline'>
157		std::numeric_limits<size_t>::max() / 2
	157	std::numeric_limits<size_t>::max() / 2
158	158	</pre></font></code>
159
160
161		<br/>
162	159	<br/>
163	160	<b><big><a name="cap_bytes" id="cap_bytes">cap_bytes</a></big></b>
164	161	<br/>

+1

-1

doc/ta_hold_memory.xml less more

5	5	<title>Control When Thread Alloc Retains Memory For Future Use</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Control When Thread Alloc Retains Memory For Future Use"/>
8		<meta name="keywords" id="keywords" content=" control when thread alloc retains memory for future use hold syntax purpose value free_available "/>
	8	<meta name="keywords" id="keywords" content=" control when thread alloc retains memory future use hold syntax purpose value free_available "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ta_in_parallel.xml less more

5	5	<title>Is The Current Execution in Parallel Mode</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Is The Current Execution in Parallel Mode"/>
8		<meta name="keywords" id="keywords" content=" is the current execution in parallel mode sequential syntax purpose flag example "/>
	8	<meta name="keywords" id="keywords" content=" is the current execution parallel mode sequential syntax purpose flag example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ta_inuse.xml less more

5	5	<title>Amount of Memory a Thread is Currently Using</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Amount of Memory a Thread is Currently Using"/>
8		<meta name="keywords" id="keywords" content=" amount of memory a thread is currently using inuse syntax purpose num_bytes example "/>
	8	<meta name="keywords" id="keywords" content=" amount memory thread is currently using inuse syntax purpose num_bytes example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ta_num_threads.xml less more

5	5	<title>Get Number of Threads</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Get Number of Threads"/>
8		<meta name="keywords" id="keywords" content=" get number of threads syntax purpose example "/>
	8	<meta name="keywords" id="keywords" content=" get number threads syntax purpose example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/ta_parallel_setup.xml less more

5	5	<title>Setup thread_alloc For Use in Multi-Threading Environment</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Setup thread_alloc For Use in Multi-Threading Environment"/>
8		<meta name="keywords" id="keywords" content=" setup thread_alloc for use in multi-threading environment parallel initialize syntax purpose speed num_threads in_parallel thread_num restrictions example "/>
	8	<meta name="keywords" id="keywords" content=" setup thread_alloc use multi-threading environment parallel initialize syntax purpose speed num_threads in_parallel thread_num restrictions example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/tan.cpp.xml less more

5	5	<title>The AD tan Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD tan Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad tan function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad tan function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/tan_forward.xml less more

5	5	<title>Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Tangent and Hyperbolic Tangent Forward Taylor Polynomial Theory"/>
8		<meta name="keywords" id="keywords" content=" tangent and hyperbolic forward taylor polynomial theory tan derivatives coefficients recursion "/>
	8	<meta name="keywords" id="keywords" content=" tangent hyperbolic forward taylor polynomial theory tan derivatives coefficients recursion "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/tan_reverse.xml less more

5	5	<title>Tangent and Hyperbolic Tangent Reverse Mode Theory</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Tangent and Hyperbolic Tangent Reverse Mode Theory"/>
8		<meta name="keywords" id="keywords" content=" tangent and hyperbolic reverse mode theory tan notation eliminating y(t) positive orders z(t) order zero "/>
	8	<meta name="keywords" id="keywords" content=" tangent hyperbolic reverse mode theory tan notation eliminating y(t) positive orders z(t) order zero "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/tanh.cpp.xml less more

5	5	<title>The AD tanh Function: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The AD tanh Function: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" the ad tanh function: example and test "/>
	8	<meta name="keywords" id="keywords" content=" the ad tanh function: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/tape_index.cpp.xml less more

5	5	<title>Taping Array Index Operation: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Taping Array Index Operation: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" taping array index operation: example and test tape operation "/>
	8	<meta name="keywords" id="keywords" content=" taping array index operation: example test tape operation "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/team_bthread.cpp.xml less more

5	5	<title>Boost Thread Implementation of a Team of AD Threads</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Boost Thread Implementation of a Team of AD Threads"/>
8		<meta name="keywords" id="keywords" content=" boost thread implementation of a team ad threads bthread "/>
	8	<meta name="keywords" id="keywords" content=" boost thread implementation team ad threads bthread "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/team_example.cpp.xml less more

5	5	<title>Using a Team of AD Threads: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Using a Team of AD Threads: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" using a team of ad threads: example and test thread purpose thread_team source code "/>
	8	<meta name="keywords" id="keywords" content=" using team ad threads: example test thread purpose thread_team source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-5

doc/team_openmp.cpp.xml less more

5	5	<title>OpenMP Implementation of a Team of AD Threads</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="OpenMP Implementation of a Team of AD Threads"/>
8		<meta name="keywords" id="keywords" content=" openmp implementation of a team ad threads "/>
	8	<meta name="keywords" id="keywords" content=" openmp implementation team ad threads "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

76	76	<td>team_openmp.cpp</td>
77	77	<td>Headings</td>
78	78	</tr></table><br/>
79
80
81
82
83	79	<center><b><big><big>OpenMP Implementation of a Team of AD Threads</big></big></b></center>
84	80	See <a href="team_thread.hpp.xml" target="_top"><span style='white-space: nowrap'>team_thread.hpp</span></a>
85	81	for this routines specifications.

+2

-4

doc/team_pthread.cpp.xml less more

5	5	<title>Pthread Implementation of a Team of AD Threads</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Pthread Implementation of a Team of AD Threads"/>
8		<meta name="keywords" id="keywords" content=" pthread implementation of a team ad threads pthread_exit bug in cygwin "/>
	8	<meta name="keywords" id="keywords" content=" pthread implementation team ad threads pthread_exit bug cygwin "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

103	103	<code><font color='blue'><pre style='display:inline'>
104	104	# define DEMONSTRATE_BUG_IN_CYGWIN 0
105	105	</pre></font></code>
106
107		<code><font color="blue">
108		<pre style='display:inline'>
	106	<code><font color="blue"><pre style='display:inline'>
109	107	# include <pthread.h>
110	108	# include <cppad/cppad.hpp>
111	109	# include "../team_thread.hpp"

+1

-2

doc/team_thread.hpp.xml less more

5	5	<title>Specifications for A Team of AD Threads</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Specifications for A Team of AD Threads"/>
8		<meta name="keywords" id="keywords" content=" 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 "/>
	8	<meta name="keywords" id="keywords" content=" specifications team ad threads syntax purpose restrictions team_create team_work team_destroy team_name ok example use implementation speed test source "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

281	281	extern const char* team_name(void);
282	282	</pre></font></code>
283	283
284
285	284	<hr/>Input File: multi_thread/team_thread.hpp
286	285
287	286	</body>

+0

-11

doc/test_vector.xml less more

150	150	# endif
151	151	# endif
152	152	</pre></font></code>
153
154
155		<br/>
156	153	<br/>
157	154	<b><big><a name="CppAD::vector" id="CppAD::vector">CppAD::vector</a></big></b>
158	155	<br/>

164	161	# define CPPAD_TEST_VECTOR CppAD::vector
165	162	# endif
166	163	</pre></font></code>
167
168	164	If you specify <code><font color="blue">--with-eigenvector</font></code> on the
169	165	<a href="auto_tools.xml#Configure" target="_top"><span style='white-space: nowrap'>configure</span></a>
170	166	command line,

179	175	# define CPPAD_TEST_VECTOR CppAD::vector
180	176	# endif
181	177	</pre></font></code>
182
183
184
185		<br/>
186	178	<br/>
187	179	<b><big><a name="std::vector" id="std::vector">std::vector</a></big></b>
188	180	<br/>

199	191	# define CPPAD_TEST_VECTOR std::vector
200	192	# endif
201	193	</pre></font></code>
202
203	194	In this case CppAD will use <code><font color="blue">std::vector</font></code> for its examples and tests.
204	195	Use of <code><font color="blue">CppAD::vector</font></code>, <code><font color="blue">std::vector</font></code>,
205	196	and <code><font color="blue">std::valarray</font></code> with CppAD is always tested to some degree.

223	214	# define CPPAD_TEST_VECTOR boost::numeric::ublas::vector
224	215	# endif
225	216	</pre></font></code>
226
227	217	In this case CppAD will use Ublas vectors for its examples and tests.
228	218	Use of <code><font color="blue">CppAD::vector</font></code>, <code><font color="blue">std::vector</font></code>,
229	219	and <code><font color="blue">std::valarray</font></code> with CppAD is always tested to some degree.

242	232	# define CppADvector CPPAD_TEST_VECTOR
243	233	</pre></font></code>
244	234
245
246	235	<hr/>Input File: cppad/local/test_vector.hpp
247	236
248	237	</body>

+0

-4

doc/testvector.xml less more

126	126	# define <a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(Scalar) CppAD::vector< Scalar >
127	127	# endif
128	128	</pre></font></code>
129
130	129	In this case CppAD will use its own vector for
131	130	many of its examples and tests.
132	131

147	146	# define <a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(Scalar) std::vector< Scalar >
148	147	# endif
149	148	</pre></font></code>
150
151	149	In this case CppAD will use standard vector for
152	150	many of its examples and tests.
153	151

168	166	# define <a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(Scalar) boost::numeric::ublas::vector< Scalar >
169	167	# endif
170	168	</pre></font></code>
171
172	169	In this case CppAD will use this boost vector for
173	170	many of its examples and tests.
174	171

189	186	# define <a href="testvector.xml" target="_top">CPPAD_TESTVECTOR</a>(Scalar) Eigen::Matrix< Scalar , Eigen::Dynamic, 1>
190	187	# endif
191	188	</pre></font></code>
192
193	189	In this case CppAD will use the Eigen vector
194	190	for many of its examples and tests.
195	191

+1

-1

doc/theory.xml less more

5	5	<title>The Theory of Derivative Calculations</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The Theory of Derivative Calculations"/>
8		<meta name="keywords" id="keywords" content=" the theory of derivative calculations "/>
	8	<meta name="keywords" id="keywords" content=" the theory derivative calculations "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/thread_alloc.cpp.xml less more

5	5	<title>Fast Multi-Threading Memory Allocator: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Fast Multi-Threading Memory Allocator: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" fast multi-threading memory allocator: example and test openmp allocation pthread boost multi-thread "/>
	8	<meta name="keywords" id="keywords" content=" fast multi-threading memory allocator: example test openmp allocation pthread boost multi-thread "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/thread_alloc.xml less more

5	5	<title>A Fast Multi-Threading Memory Allocator</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="A Fast Multi-Threading Memory Allocator"/>
8		<meta name="keywords" id="keywords" content=" a fast multi-threading memory allocator allocation syntax purpose include "/>
	8	<meta name="keywords" id="keywords" content=" fast multi-threading memory allocator allocation syntax purpose include "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/thread_test.cpp.xml less more

5	5	<title>Run Multi-Threading Examples and Speed Tests</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Run Multi-Threading Examples and Speed Tests"/>
8		<meta name="keywords" id="keywords" content=" run multi-threading examples and speed tests thread_test multi openmp pthread bthread syntax running threading 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	<meta name="keywords" id="keywords" content=" run multi-threading examples speed tests thread_test multi openmp pthread bthread syntax running threading 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+16

-20

doc/time_det_by_minor_c.xml less more

5	5	<title>Determine Amount of Time to Execute det_by_minor</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determine Amount of Time to Execute det_by_minor"/>
8		<meta name="keywords" id="keywords" content=" determine amount of time to execute det_by_minor syntax purpose time_min source code "/>
	8	<meta name="keywords" id="keywords" content=" determine amount time to execute det_by_minor syntax purpose time_min source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

99	99	</select>
100	100	</td>
101	101	</tr></table><br/>
102
103
104
105	102	<center><b><big><big>Determine Amount of Time to Execute det_by_minor</big></big></b></center>
106	103	<br/>
107	104	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

170	167
171	168	<code><font color='blue'><pre style='display:inline'>
172	169	double time_det_by_minor(size_t size, double time_min)
173		{ size_t repeat;
174		double s0, s1, time;
175		repeat = 0;
176		s0 = <a href="elapsed_seconds_c.xml" target="_top">elapsed_seconds</a>();
177		s1 = s0;
178		while( s1 - s0 < time_min )
179		{ if( repeat == 0 )
180		repeat = 1;
181		else repeat = 2 * repeat;
182		s0 = <a href="elapsed_seconds_c.xml" target="_top">elapsed_seconds</a>();
183		<a href="elapsed_seconds_c.xml" target="_top">repeat_det_by_minor</a>(repeat, size);
184		s1 = <a href="elapsed_seconds_c.xml" target="_top">elapsed_seconds</a>();
185		}
186		time = (s1 - s0) / (double) repeat;
187		return time;
	170	{ size_t repeat;
	171	double s0, s1, time;
	172	repeat = 0;
	173	s0 = <a href="elapsed_seconds_c.xml" target="_top">elapsed_seconds</a>();
	174	s1 = s0;
	175	while( s1 - s0 < time_min )
	176	{ if( repeat == 0 )
	177	repeat = 1;
	178	else repeat = 2 * repeat;
	179	s0 = <a href="elapsed_seconds_c.xml" target="_top">elapsed_seconds</a>();
	180	<a href="elapsed_seconds_c.xml" target="_top">repeat_det_by_minor</a>(repeat, size);
	181	s1 = <a href="elapsed_seconds_c.xml" target="_top">elapsed_seconds</a>();
	182	}
	183	time = (s1 - s0) / (double) repeat;
	184	return time;
188	185	}
189	186	</pre></font></code>
190
191	187
192	188	<hr/>Input File: compare_c/det_by_minor.c
193	189

+1

-1

doc/time_test.cpp.xml less more

5	5	<title>time_test: Example and test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="time_test: Example and test"/>
8		<meta name="keywords" id="keywords" content=" time_test: example and test time_test "/>
	8	<meta name="keywords" id="keywords" content=" time_test: example test time_test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-5

doc/time_test.xml less more

5	5	<title>Determine Amount of Time to Execute a Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Determine Amount of Time to Execute a Test"/>
8		<meta name="keywords" id="keywords" content=" determine amount of time to execute a test time_test speed syntax purpose motivation include size repeat time_min test_size timing example "/>
	8	<meta name="keywords" id="keywords" content=" determine amount time to execute test time_test speed syntax purpose motivation include size repeat time_min test_size timing example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

111	111	</select>
112	112	</td>
113	113	</tr></table><br/>
114
115
116
117
118	114	<center><b><big><big>Determine Amount of Time to Execute a Test</big></big></b></center>
119	115	<br/>
120	116	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

+1

-1

doc/to_string.cpp.xml less more

5	5	<title>to_string: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="to_string: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" to_string: example and test "/>
	8	<meta name="keywords" id="keywords" content=" to_string: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/to_string.xml less more

5	5	<title>Convert Certain Types to a String</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Convert Certain Types to a String"/>
8		<meta name="keywords" id="keywords" content=" convert certain types to a string syntax see also purpose value integer float s example "/>
	8	<meta name="keywords" id="keywords" content=" convert certain types to string syntax see also purpose value integer float s example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/tracknewdel.cpp.xml less more

5	5	<title>Tracking Use of New and Delete: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Tracking Use of New and Delete: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" tracking use of new and delete: example test delete "/>
	8	<meta name="keywords" id="keywords" content=" tracking use new delete: example test delete "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/tracknewdel.xml less more

5	5	<title>Routines That Track Use of New and Delete</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Routines That Track Use of New and Delete"/>
8		<meta name="keywords" id="keywords" content=" routines that track use of new and delete memory Ndebug Cppad_track_new_vec Cppadtracknewvec Cppad_track_del_vec Cppadtrackdelvec Cppad_track_extend Cppadtrackextend Cppad_track_count thread multi deprecated 2007-07-23 syntax purpose include file line oldptr newlen head newptr ncopy tracknewvec macro previously trackdelvec trackextend trackcount multi-threading example "/>
	8	<meta name="keywords" id="keywords" content=" routines that track use new delete memory Ndebug Cppad_track_new_vec Cppadtracknewvec Cppad_track_del_vec Cppadtrackdelvec Cppad_track_extend Cppadtrackextend Cppad_track_count thread multi deprecated 2007-07-23 syntax purpose include file line oldptr newlen head newptr ncopy tracknewvec macro previously trackdelvec trackextend trackcount multi-threading example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/unary_minus.cpp.xml less more

5	5	<title>AD Unary Minus Operator: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Unary Minus Operator: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad unary minus operator: example and test "/>
	8	<meta name="keywords" id="keywords" content=" ad unary minus operator: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/unary_plus.cpp.xml less more

5	5	<title>AD Unary Plus Operator: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Unary Plus Operator: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad unary plus operator: example and test "/>
	8	<meta name="keywords" id="keywords" content=" ad unary plus operator: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/uniform_01.xml less more

5	5	<title>Simulate a [0,1] Uniform Random Variate</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Simulate a [0,1] Uniform Random Variate"/>
8		<meta name="keywords" id="keywords" content=" simulate a [01] uniform random variate uniform_01 syntax purpose inclusion seed n x vector source code "/>
	8	<meta name="keywords" id="keywords" content=" simulate [01] uniform random variate uniform_01 syntax purpose inclusion seed n x vector source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+5

-8

doc/uniform_01_c.xml less more

5	5	<title>Simulate a [0,1] Uniform Random Variate</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Simulate a [0,1] Uniform Random Variate"/>
8		<meta name="keywords" id="keywords" content=" simulate a [01] uniform random variate syntax purpose seed n source code "/>
	8	<meta name="keywords" id="keywords" content=" simulate [01] uniform random variate syntax purpose seed n source code "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

100	100	</select>
101	101	</td>
102	102	</tr></table><br/>
103
104
105	103	<center><b><big><big>Simulate a [0,1] Uniform Random Variate</big></big></b></center>
106	104	<br/>
107	105	<b><big><a name="Syntax" id="Syntax">Syntax</a></big></b>

178	176
179	177	<code><font color='blue'><pre style='display:inline'>
180	178	void random_seed(size_t seed)
181		{ srand(seed); }
	179	{ srand(seed); }
182	180	void uniform_01(unsigned n, double* a)
183		{ static double factor = 1. / (double) RAND_MAX;
184		while(n--)
185		a[n] = rand() * factor;
	181	{ static double factor = 1. / (double) RAND_MAX;
	182	while(n--)
	183	a[n] = rand() * factor;
186	184	}
187	185	</pre></font></code>
188
189	186
190	187	<hr/>Input File: compare_c/det_by_minor.c
191	188

+3

-10

doc/utility.xml less more

107	107	<center><b><big><big>Some General Purpose Utilities</big></big></b></center>
108	108	These routines can be include individually; for example,
109	109	<code><font color='blue'><pre style='display:inline'>
110		# include <cppad/utility/vector.hpp>
	110	# include <cppad/utility/vector.hpp>
111	111	</pre></font></code>
112
113	112	only includes the definitions necessary for the <code><font color="blue">CppAD::vector</font></code> class.
114	113	They can also be included as a group, separate from the rest of CppAD, using
115	114	<code><font color='blue'><pre style='display:inline'>
116		# include <cppad/utility.hpp>
	115	# include <cppad/utility.hpp>
117	116	</pre></font></code>
118
119	117	They will also be included, along with the rest of CppAD, using
120	118	<code><font color='blue'><pre style='display:inline'>
121		# include <cppad/cppad.hpp>
	119	# include <cppad/cppad.hpp>
122	120	</pre></font></code>
123
124
125
126
127		<br/>
128	121	<br/>
129	122	<b><big><a name="Testing" id="Testing">Testing</a></big></b>
130	123	<br/>

+1

-1

doc/value.cpp.xml less more

5	5	<title>Convert From AD to its Base Type: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Convert From AD to its Base Type: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" convert from ad to its base type: example and test Value record "/>
	8	<meta name="keywords" id="keywords" content=" convert from ad to its base type: example test Value record "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/value.xml less more

5	5	<title>Convert From an AD Type to its Base Type</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Convert From an AD Type to its Base Type"/>
8		<meta name="keywords" id="keywords" content=" convert from an ad type to its base Value syntax see also purpose x b operation sequence restriction example "/>
	8	<meta name="keywords" id="keywords" content=" convert from ad type to its base Value syntax see also purpose x b operation sequence restriction example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/var2par.cpp.xml less more

5	5	<title>Convert an AD Variable to a Parameter: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Convert an AD Variable to a Parameter: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" convert an ad variable to a parameter: example and test Var2par Value during taping "/>
	8	<meta name="keywords" id="keywords" content=" convert ad variable to parameter: example test Var2par Value during taping "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/var2par.xml less more

5	5	<title>Convert an AD Variable to a Parameter</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Convert an AD Variable to a Parameter"/>
8		<meta name="keywords" id="keywords" content=" convert an ad variable to a parameter Var2par from value_ obtain during taping syntax see also purpose x y example "/>
	8	<meta name="keywords" id="keywords" content=" convert ad variable to parameter Var2par from value_ obtain during taping syntax see also purpose x y example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-1

doc/vec_ad.cpp.xml less more

5	5	<title>AD Vectors that Record Index Operations: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Vectors that Record Index Operations: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" ad vectors that record index operations: example and test Vecad vec_ad.cpp "/>
	8	<meta name="keywords" id="keywords" content=" ad vectors that record index operations: example test Vecad vec_ad.cpp "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+7

-11

doc/vecad.xml less more

5	5	<title>AD Vectors that Record Index Operations</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="AD Vectors that Record Index Operations"/>
8		<meta name="keywords" id="keywords" content=" ad vectors that record index operations Vecad tape reference Vecad<base> syntax purpose alternatives vecad<base>::reference exceptions constructor v n size size_t indexing i b x r example speed and memory "/>
	8	<meta name="keywords" id="keywords" content=" ad vectors that record index operations Vecad tape reference Vecad<base> syntax purpose alternatives vecad<base>::reference exceptions constructor v n size size_t indexing i b x r example speed memory "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

585	585	In the file <code><font color="blue">cppad/local/forward1sweep.h</font></code>,
586	586	change the definition of <code><font color="blue">CPPAD_FORWARD1SWEEP_TRACE</font></code> to
587	587	<code><font color='blue'><pre style='display:inline'>
588		# define CPPAD_FORWARD1SWEEP_TRACE 1
	588	# define CPPAD_FORWARD1SWEEP_TRACE 1
589	589	</pre></font></code>
590
591		</li><li>
592
	590	</li><li>
593	591	In the <code><font color="blue">Example</font></code> directory, execute the command
594	592	<code><font color='blue'><pre style='display:inline'>
595		./test_one.sh lu_vec_ad_ok.cpp lu_vec_ad.cpp -DNDEBUG > lu_vec_ad_ok.log
	593	./test_one.sh lu_vec_ad_ok.cpp lu_vec_ad.cpp -DNDEBUG > lu_vec_ad_ok.log
596	594	</pre></font></code>
597
598	595	This will write a trace of all the forward tape operations,
599	596	for the test case <a href="lu_vec_ad_ok.cpp.xml" target="_top"><span style='white-space: nowrap'>lu_vec_ad_ok.cpp</span></a>
600	597	,

603	600
604	601	In the <code><font color="blue">Example</font></code> directory execute the commands
605	602	<code><font color='blue'><pre style='display:inline'>
606		grep "op=" lu_vec_ad_ok.log \| wc -l
607		grep "op=Ld[vp]" lu_vec_ad_ok.log \| wc -l
608		grep "op=St[vp][vp]" lu_vec_ad_ok.log \| wc -l
	603	grep "op=" lu_vec_ad_ok.log \| wc -l
	604	grep "op=Ld[vp]" lu_vec_ad_ok.log \| wc -l
	605	grep "op=St[vp][vp]" lu_vec_ad_ok.log \| wc -l
609	606	</pre></font></code>
610
611	607	The first command counts the number of operators in the tracing,
612	608	the second counts the number of VecAD load operations,
613	609	and the third counts the number of VecAD store operations.

+1

-1

doc/vector_bool.cpp.xml less more

5	5	<title>CppAD::vectorBool Class: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD::vectorBool Class: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" cppad::vectorbool class: example and test bool vectorbool Cppad "/>
	8	<meta name="keywords" id="keywords" content=" cppad::vectorbool class: example test bool vectorbool Cppad "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+2

-2

doc/whats_new.xml less more

5	5	<title>Changes and Additions to CppAD</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD"/>
8		<meta name="keywords" id="keywords" content=" changes and additions to cppad introduction this year previous years "/>
	8	<meta name="keywords" id="keywords" content=" changes additions to cppad introduction this year previous years "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

107	107	<br/>
108	108	<b><big><a name="Introduction" id="Introduction">Introduction</a></big></b>
109	109	<br/>
110		The sections listed below contain a list of the changes to CppAD
	110	The sections listed below contain a list of the changes to CppAD
111	111	in reverse order by date.
112	112	The purpose of these sections is to
113	113	assist you in learning about changes between various versions of CppAD.

+2

-3

doc/whats_new_03.xml less more

5	5	<title>Changes and Additions to CppAD During 2003</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2003"/>
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	<meta name="keywords" id="keywords" content=" changes 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

1034	1034	<br/>
1035	1035	Added a the compiler flag
1036	1036	<code><font color='blue'><pre style='display:inline'>
1037		AbsOfDoubleNotDefined
	1037	AbsOfDoubleNotDefined
1038	1038	</pre></font></code>
1039
1040	1039	to the make files so that it could be removed on systems where the
1041	1040	function
1042	1041

+3

-4

doc/whats_new_04.xml less more

5	5	<title>Changes and Additions to CppAD During 2004</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2004"/>
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	<meta name="keywords" id="keywords" content=" changes 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

1014	1014	Note that if <code><font color="blue">/usr/local/cppad/</font></code> is no longer searched,
1015	1015	you will have to change
1016	1016	<code><font color='blue'><pre style='display:inline'>
1017		# include "cppad.hpp"
	1017	# include "cppad.hpp"
1018	1018	</pre></font></code>
1019
1020	1019	to
1021	1020	<code><font color='blue'><pre style='display:inline'>
1022		# include "cppad/cppad.hpp"
	1021	# include "cppad/cppad.hpp"
1023	1022	</pre></font></code>
1024	1023	.
1025	1024	<code><span style='white-space: nowrap'><br/>

+24

-30

doc/whats_new_05.xml less more

5	5	<title>Changes and Additions to CppAD During 2005</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2005"/>
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	<meta name="keywords" id="keywords" content=" changes 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

250	250	resurfaced
251	251	and the corresponding routine was changed as follows:
252	252	<code><font color='blue'><pre style='display:inline'>
253		static ADTape<Base> *Tape(void)
254		{ // If we return &tape, instead of creating and returning ptr,
255		// there seems to be a bug in g++ with -O2 option.
256		static ADTape<Base> tape;
257		static ADTape<Base> *ptr = &tape;
258		return ptr;
259		}
	253	static ADTape<Base> *Tape(void)
	254	{ // If we return &tape, instead of creating and returning ptr,
	255	// there seems to be a bug in g++ with -O2 option.
	256	static ADTape<Base> tape;
	257	static ADTape<Base> *ptr = &tape;
	258	return ptr;
	259	}
260	260	</pre></font></code>
261
262
263		<br/>
264	261	<br/>
265	262	<b><big><a name="12-16" id="12-16">12-16</a></big></b>
266	263	<br/>

471	468	It appears that there is some sort of bug in the gcc compiler with
472	469	the -O2 option whereby the following member function
473	470	<code><font color='blue'><pre style='display:inline'>
474		static ADTape<Base> *Tape(void)
475		{ static ADTape<Base> tape;
476		return &tape;
477		}
	471	static ADTape<Base> *Tape(void)
	472	{ static ADTape<Base> tape;
	473	return &tape;
	474	}
478	475	</pre></font></code>
479
480	476	(in <code><font color="blue">cppad/local/AD.h</font></code>)
481	477	would sometimes return a null value (during <a href="vecad.xml" target="_top"><span style='white-space: nowrap'>VecAD</span></a>
482	478	operations).

1250	1246	For example,
1251	1247	here is part of the speed test output before this change:
1252	1248	<code><font color='blue'><pre style='display:inline'>
1253		Tape of Expansion by Minors Determinant: Length = 350, Memory = 6792
1254		size = 5 rate = 230
1255		size = 4 rate = 1,055
1256		size = 3 rate = 3,408
1257		size = 2 rate = 7,571
1258		size = 1 rate = 13,642
	1249	Tape of Expansion by Minors Determinant: Length = 350, Memory = 6792
	1250	size = 5 rate = 230
	1251	size = 4 rate = 1,055
	1252	size = 3 rate = 3,408
	1253	size = 2 rate = 7,571
	1254	size = 1 rate = 13,642
1259	1255	</pre></font></code>
1260
1261	1256	and here is the same output after this change:
1262	1257	<code><font color='blue'><pre style='display:inline'>
1263		Tape of Expansion by Minors Determinant: Length = 350, Memory = 6792
1264		size = 5 rate = 448
1265		size = 4 rate = 2,004
1266		size = 3 rate = 5,761
1267		size = 2 rate = 10,221
1268		size = 1 rate = 14,734
	1258	Tape of Expansion by Minors Determinant: Length = 350, Memory = 6792
	1259	size = 5 rate = 448
	1260	size = 4 rate = 2,004
	1261	size = 3 rate = 5,761
	1262	size = 2 rate = 10,221
	1263	size = 1 rate = 14,734
1269	1264	</pre></font></code>
1270
1271	1265	Note that your results will vary depending on operating system and machine.
1272	1266
1273	1267	<br/>

+7

-15

doc/whats_new_06.xml less more

5	5	<title>Changes and Additions to CppAD During 2006</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2006"/>
8		<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2006 aclocal 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 01-07 01-02 01-05 "/>
	8	<meta name="keywords" id="keywords" content=" changes additions to cppad during 2006 aclocal 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 01-07 01-02 01-05 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

908	908	<br/>
909	909	Some error message occurred while executing
910	910	<code><font color='blue'><pre style='display:inline'>
911		valgrind --tool=memcheck example/example
912		valgrind --tool=memcheck TestMore/TestMore
	911	valgrind --tool=memcheck example/example
	912	valgrind --tool=memcheck TestMore/TestMore
913	913
914	914	</pre></font></code>
915
916	915	These were not really bugs, but they have been fixed to avoid
917	916	this conflict between CppAD and <a href="http://valgrind.org/" target="_top"><span style='white-space: nowrap'>valgrind</span></a>
918	917	.

1339	1338	gave a compile error (this has been fixed).
1340	1339	Code example for this fix
1341	1340	<code><font color='blue'><pre style='display:inline'>
1342		VecAD<double> V(1);
1343		<a href="ad.xml" target="_top">AD</a><double> zero = 0;
1344		V[zero] = 1.;
1345		static_cast< <a href="ad.xml" target="_top">AD</a><double> > ( V[zero] );
	1341	VecAD<double> V(1);
	1342	<a href="ad.xml" target="_top">AD</a><double> zero = 0;
	1343	V[zero] = 1.;
	1344	static_cast< <a href="ad.xml" target="_top">AD</a><double> > ( V[zero] );
1346	1345	</pre></font></code>
1347
1348
1349
1350
1351
1352
1353		<br/>
1354	1346	<br/>
1355	1347	<b><big><a name="04-06" id="04-06">04-06</a></big></b>
1356	1348	<br/>

+7

-12

doc/whats_new_07.xml less more

5	5	<title>Changes and Additions to CppAD During 2007</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2007"/>
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	<meta name="keywords" id="keywords" content=" changes 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

396	396	have changed.
397	397	The user should now directly edit the file
398	398	<code><font color='blue'><pre style='display:inline'>
399		trunk/configure
	399	trunk/configure
400	400	</pre></font></code>
401
402	401	in order to set the correct date for the installation
403	402	and to build the corresponding documentation.
404	403	<code><span style='white-space: nowrap'><br/>

420	419	have changed.
421	420	The user must now execute the command
422	421	<code><font color='blue'><pre style='display:inline'>
423		./build.sh version
	422	./build.sh version
424	423	</pre></font></code>
425
426	424	in order to set the correct version number for her (or his) installation.
427	425	<code><span style='white-space: nowrap'><br/>
428	426	<br/>

1376	1374	The conditional include commands were missing on some include files;
1377	1375	for example
1378	1376	<code><font color='blue'><pre style='display:inline'>
1379		# ifndef CPPAD_BENDER_QUAD_HPP
1380		# define CPPAD_BENDER_QUAD_HPP
	1377	# ifndef CPPAD_BENDER_QUAD_HPP
	1378	# define CPPAD_BENDER_QUAD_HPP
1381	1379	</pre></font></code>
1382
1383	1380	was missing at the beginning of the <a href="benderquad.xml" target="_top"><span style='white-space: nowrap'>BenderQuad</span></a>
1384	1381	include file.
1385	1382	This has been fixed.

1434	1431	The include command in the <a href="speed_test.xml" target="_top"><span style='white-space: nowrap'>speed_test</span></a>
1435	1432	documentation was
1436	1433	<code><font color='blue'><pre style='display:inline'>
1437		# include <speed/speed_test.hpp>
	1434	# include <speed/speed_test.hpp>
1438	1435	</pre></font></code>
1439
1440	1436	but it should have been
1441	1437	<code><font color='blue'><pre style='display:inline'>
1442		# include <cppad/speed_test.hpp>
	1438	# include <cppad/speed_test.hpp>
1443	1439	</pre></font></code>
1444
1445	1440	This has been fixed.
1446	1441
1447	1442	<br/>

+4

-5

doc/whats_new_08.xml less more

5	5	<title>Changes and Additions to CppAD During 2008</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2008"/>
8		<meta name="keywords" id="keywords" content=" changes and additions to cppad during 2008 erf ipopt_cppad_nlp introduction 12-19 12-14 12-04 11-22 11-21 11-20 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 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	<meta name="keywords" id="keywords" content=" changes additions to cppad during 2008 erf ipopt_cppad_nlp introduction 12-19 12-14 12-04 11-22 11-21 11-20 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 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

462	462	at the proper location. Here is the difference that occurred
463	463	multiple places in the <code><font color="blue">ipopt_cppad/ipopt_cppad_nlp.cpp</font></code> source:
464	464	<code><font color='blue'><pre style='display:inline'>
465		for(j = 0; j < n_; j++)
466		- x_ad_vec[0] = x[j];
467		+ x_ad_vec[j] = x[j];
	465	for(j = 0; j < n_; j++)
	466	- x_ad_vec[0] = x[j];
	467	+ x_ad_vec[j] = x[j];
468	468	</pre></font></code>
469
470	469	This did not show up in testing because there currently is no test of
471	470	<code><font color="blue">ipopt_cppad_nlp</font></code> where the operation sequence depends
472	471	on the value of

+61

-61

doc/whats_new_09.xml less more

5	5	<title>Changes and Additions to CppAD During 2009</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2009"/>
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	<meta name="keywords" id="keywords" content=" changes 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

181	181	<br/>
182	182	<b><big><a name="12-23" id="12-23">12-23</a></big></b>
183	183	<br/>
184		The
	184	The
185	185	<code><font color="blue">ADFun</font></code> <a href="funconstruct.xml#Assignment Operator" target="_top"><span style='white-space: nowrap'>assignment operator</span></a>
186	186
187	187	was changed so that it now copies forward mode

203	203	<br/>
204	204	<b><big><a name="12-22" id="12-22">12-22</a></big></b>
205	205	<br/>
206		Convert the optimization of a sequence of additions from multiple operators
207		to one operator with a varying number of arguments. This improved the speed
	206	Convert the optimization of a sequence of additions from multiple operators
	207	to one operator with a varying number of arguments. This improved the speed
208	208	for forward and reverse mode computations of an optimized tape.
209	209
210	210	<br/>

241	241	<br/>
242	242	Fix minor grammatical error in the Purpose heading
243	243	for <a href="condexp.xml#Purpose" target="_top"><span style='white-space: nowrap'>conditional expressions</span></a>
244		.
245		<code><span style='white-space: nowrap'><br/>
246		<br/>
247		</span></code>Add the following functions:
	244	.
	245	<code><span style='white-space: nowrap'><br/>
	246	<br/>
	247	</span></code>Add the following functions:
248	248	<a href="seq_property.xml#size_op" target="_top"><span style='white-space: nowrap'>size_op</span></a>
249	249	,
250	250	<a href="seq_property.xml#size_op_arg" target="_top"><span style='white-space: nowrap'>size_op_arg</span></a>

252	252	and
253	253	<a href="seq_property.xml#size_op_seq" target="_top"><span style='white-space: nowrap'>size_op_seq</span></a>
254	254	.
255		In addition, improve and extend the
	255	In addition, improve and extend the
256	256	<a href="seq_property.cpp.xml" target="_top"><span style='white-space: nowrap'>seq_property.cpp</span></a>
257		example.
	257	example.
258	258
259	259	<br/>
260	260	<br/>

293	293	<br/>
294	294	<b><big><a name="10-29" id="10-29">10-29</a></big></b>
295	295	<br/>
296		Split out the
	296	Split out the
297	297	<a href="ipopt_nlp_ode_problem.xml" target="_top"><span style='white-space: nowrap'>ode inverse problem</span></a>
298	298	,
299	299	<a href="ipopt_nlp_ode_simple.xml" target="_top"><span style='white-space: nowrap'>its simple representation</span></a>

308	308	,
309	309	<a href="ipopt_nlp_ode_fast.hpp.xml" target="_top"><span style='white-space: nowrap'>ipopt_nlp_ode_fast.hpp</span></a>
310	310	,
311		and
	311	and
312	312	<a href="ipopt_nlp_ode_check.cpp.xml" target="_top"><span style='white-space: nowrap'>ipopt_nlp_ode_check.cpp</span></a>
313	313	.
314	314

317	317	<b><big><a name="10-28" id="10-28">10-28</a></big></b>
318	318	<br/>
319	319	Improve the documentation for <a href="ipopt_nlp_ode_simple.xml" target="_top"><span style='white-space: nowrap'>ipopt_nlp_ode_simple</span></a>
320		and
	320	and
321	321	<a href="ipopt_nlp_ode_fast.xml" target="_top"><span style='white-space: nowrap'>ipopt_nlp_ode_fast</span></a>
322	322	.
323	323

329	329	,
330	330	created the example <a href="ipopt_nlp_ode_simple.hpp.xml" target="_top"><span style='white-space: nowrap'>ipopt_nlp_ode_simple.hpp</span></a>
331	331	,
332		and split and <code><font color="blue">ipopt_cppad_ode.cpp</font></code>
	332	and split and <code><font color="blue">ipopt_cppad_ode.cpp</font></code>
333	333	into <a href="ipopt_nlp_ode_fast.hpp.xml" target="_top"><span style='white-space: nowrap'>ipopt_nlp_ode_fast.hpp</span></a>
334	334	and <a href="ipopt_nlp_ode_check.cpp.xml" target="_top"><span style='white-space: nowrap'>ipopt_nlp_ode_check.cpp</span></a>
335	335	.

341	341	Added the <a href="funconstruct.xml#Assignment Operator" target="_top"><span style='white-space: nowrap'>assignment operator</span></a>
342	342
343	343	to the <code><font color="blue">ADFun</font></code> object class.
344		This makes a copy of the entire operation sequence in another
	344	This makes a copy of the entire operation sequence in another
345	345	function object.
346	346	The intention is that the two functions objects can do calculations in
347	347	parallel.
348	348	In addition,
349		CppAD now check for the <code><font color="blue">ADFun</font></code>
	349	CppAD now check for the <code><font color="blue">ADFun</font></code>
350	350	<a href="funconstruct.xml#Copy Constructor" target="_top"><span style='white-space: nowrap'>copy constructor</span></a>
351	351
352	352	and generates an error message if it is used.

408	408	<br/>
409	409	<b><big><a name="10-03" id="10-03">10-03</a></big></b>
410	410	<br/>
411		The Microsoft Visual Studio project files for
	411	The Microsoft Visual Studio project files for
412	412	examples and testing
413	413	and for
414	414	more correctness testing

456	456	<br/>
457	457	Changed <a href="revsparsehes.xml" target="_top"><span style='white-space: nowrap'>RevSparseHes</span></a>
458	458	so that it uses a sparse
459		representation when the corresponding call to
	459	representation when the corresponding call to
460	460	<a href="forsparsejac.xml" target="_top"><span style='white-space: nowrap'>ForSparseJac</span></a>
461	461	used a sparse representation.
462		This should have been included with the change on 09-26
	462	This should have been included with the change on 09-26
463	463	because Hessian sparsity patters after <code><font color="blue">ForSparseJac</font></code>
464	464	with
465	465	<code><i><font color="black"><span style='white-space: nowrap'>packed</span></font></i></code>

477	477	If
478	478	<code><i><font color="black"><span style='white-space: nowrap'>packed</span></font></i></code>
479	479	is false,
480		a sparse instead of packed representation is used
	480	a sparse instead of packed representation is used
481	481	during the calculations of sparsity patterns.
482	482	The sparse representation
483	483	should be faster, and use less memory, for very large sparse Jacobians.

499	499	<br/>
500	500	<b><big><a name="09-19" id="09-19">09-19</a></big></b>
501	501	<br/>
502		Some more memory allocation improvements (related to those
503		on 09-18) were made.
	502	Some more memory allocation improvements (related to those
	503	on 09-18) were made.
504	504
505	505	<br/>
506	506	<br/>

537	537	an operation sequence.
538	538	<code><span style='white-space: nowrap'><br/>
539	539	<br/>
540		</span></code><b>Begin Merge</b>
541		<code><span style='white-space: nowrap'><br/>
542		</span></code>of changes from the directory <code><font color="blue">branches/optimize</font></code>
	540	</span></code><b>Begin Merge</b>
	541	<code><span style='white-space: nowrap'><br/>
	542	</span></code>of changes from the directory <code><font color="blue">branches/optimize</font></code>
543	543	in the CppAD subversion repository.
544		The subheading dates below represent when the correspond change was made in
	544	The subheading dates below represent when the correspond change was made in
545	545	<code><font color="blue">branches/optimize</font></code>.
546	546
547	547	<br/>

553	553	after each call to <a href="optimize.xml" target="_top"><span style='white-space: nowrap'>f.optimize()</span></a>
554	554
555	555	(this <a href="optimize.xml#Checking Optimization" target="_top"><span style='white-space: nowrap'>check</span></a>
556
	556
557	557	is skipped when <code><font color="blue">NDEBUG</font></code> is defined).
558	558	In addition, all of the
559	559	<code><font color="blue"><span style='white-space: nowrap'>speed/cppad/</span></font><i><font color="black"><span style='white-space: nowrap'>*</span></font></i><font color="blue"><span style='white-space: nowrap'>.cpp</span></font></code>

585	585	now be trusted to work correctly.
586	586	<code><span style='white-space: nowrap'><br/>
587	587	<br/>
588		</span></code>The function
	588	</span></code>The function
589	589	<a href="seq_property.xml#size_VecAD" target="_top"><span style='white-space: nowrap'>size_VecAD</span></a>
590	590	function was added
591		so that the user could see the <code><font color="blue">VecAD</font></code> vectors
	591	so that the user could see the <code><font color="blue">VecAD</font></code> vectors
592	592	and elements corresponding to an operation sequence.
593	593
594	594	<br/>

610	610	<br/>
611	611	Add hash table coding to reduce the number of copies of the same
612	612	parameter value necessary in a tape recording.
613		In addition, add the function
	613	In addition, add the function
614	614	<a href="seq_property.xml#size_par" target="_top"><span style='white-space: nowrap'>size_par</span></a>
615	615	was added
616	616	so that the user could see the number of parameters

626	626	objects.
627	627	<code><span style='white-space: nowrap'><br/>
628	628	<br/>
629		</span></code>Fix bug in overnight build where HTML version and entire documentation
	629	</span></code>Fix bug in overnight build where HTML version and entire documentation
630	630	as one page versions of documentation were not being built.
631	631	<code><span style='white-space: nowrap'><br/>
632	632	<br/>
633		</span></code>Fix missing new line under
	633	</span></code>Fix missing new line under
634	634	<a href="simplevector.xml#Element Access.Using Value" target="_top"><span style='white-space: nowrap'>Using Value</span></a>
635	635
636	636	heading for simple vector documentation.

642	642	Fix bug in reverse mode Jacobian <a href="revsparsejac.xml" target="_top"><span style='white-space: nowrap'>sparsity</span></a>
643	643
644	644	for <a href="vecad.xml" target="_top"><span style='white-space: nowrap'>VecAD</span></a>
645		objects.
	645	objects.
646	646
647	647	<br/>
648	648	<br/>

688	688	<code><span style='white-space: nowrap'><br/>
689	689	<br/>
690	690	</span></code>Improve the <a href="vec_ad.cpp.xml" target="_top"><span style='white-space: nowrap'>vec_ad.cpp</span></a>
691		user example.
	691	user example.
692	692
693	693	<br/>
694	694	<br/>

702	702	<code><span style='white-space: nowrap'><br/>
703	703	<br/>
704	704	</span></code>Add developer documentation for tape evaluation of the
705		VecAD load operations
	705	VecAD load operations
706	706	(a load operation accesses an element of the vector but
707	707	does not change it.)
708	708	<code><span style='white-space: nowrap'><br/>
709	709	<br/>
710		</span></code>Fix <code><font color="blue">isnan</font></code> undefined in <code><font color="blue">example/cond_exp.cpp</font></code> error
	710	</span></code>Fix <code><font color="blue">isnan</font></code> undefined in <code><font color="blue">example/cond_exp.cpp</font></code> error
711	711	introduced on 07-04 change.
712	712
713	713	<br/>

719	719	operations during tape evaluation.
720	720	<code><span style='white-space: nowrap'><br/>
721	721	<br/>
722		</span></code><b>Begin Merge</b>
723		<code><span style='white-space: nowrap'><br/>
724		</span></code>of changes from the directory <code><font color="blue">branches/sweep</font></code>
	722	</span></code><b>Begin Merge</b>
	723	<code><span style='white-space: nowrap'><br/>
	724	</span></code>of changes from the directory <code><font color="blue">branches/sweep</font></code>
725	725	in the CppAD subversion repository.
726		The subheading dates below represent when the correspond change was made in
	726	The subheading dates below represent when the correspond change was made in
727	727	<code><font color="blue">branches/sweep</font></code>.
728	728
729	729	<br/>

739	739	<br/>
740	740	</span></code>A simpler and useful example was provided for
741	741	<a href="condexp.xml" target="_top"><span style='white-space: nowrap'>conditional expressions</span></a>
742		;
	742	;
743	743	see <a href="cond_exp.cpp.xml" target="_top"><span style='white-space: nowrap'>cond_exp.cpp</span></a>
744	744	.
745	745

748	748	<br/>
749	749	<b><a name="07-04.07-03" id="07-04.07-03">07-03</a></b>
750	750	<br/>
751		Some minor improvements were made to the documentation for
	751	Some minor improvements were made to the documentation for
752	752	<a href="condexp.xml" target="_top"><span style='white-space: nowrap'>CondExp</span></a>
753	753	.
754	754	To be specific, a newer OMhelp option was used to change the formatting

758	758	<br/>
759	759	<b><a name="07-04.07-02" id="07-04.07-02">07-02</a></b>
760	760	<br/>
761		Add developer doxygen documentation of
	761	Add developer doxygen documentation of
762	762	tape evaluation for power (exponentiation) operators.
763	763
764	764	<br/>
765	765	<br/>
766	766	<b><a name="07-04.07-01" id="07-04.07-01">07-01</a></b>
767	767	<br/>
768		Fix an example indexing error in
	768	Fix an example indexing error in
769	769	<code><font color="blue">introduction/exp_apx/exp_eps_for2.cpp</font></code> (found by valgrind).
770	770	<code><span style='white-space: nowrap'><br/>
771	771	<br/>
772		</span></code>Add developer doxygen documentation of
	772	</span></code>Add developer doxygen documentation of
773	773	tape evaluation for multiplication and division operators.
774	774
775	775	<br/>
776	776	<br/>
777	777	<b><a name="07-04.06-30" id="07-04.06-30">06-30</a></b>
778	778	<br/>
779		Add developer doxygen documentation of
	779	Add developer doxygen documentation of
780	780	tape evaluation for addition and subtraction operators.
781	781
782	782	<br/>
783	783	<br/>
784	784	<b><a name="07-04.06-29" id="07-04.06-29">06-29</a></b>
785	785	<br/>
786		Add developer doxygen documentation of
	786	Add developer doxygen documentation of
787	787	tape evaluation for sin, sinh, cos, and cosh.
788	788
789	789	<br/>
790	790	<br/>
791	791	<b><a name="07-04.06-28" id="07-04.06-28">06-28</a></b>
792	792	<br/>
793		Add developer doxygen documentation of
	793	Add developer doxygen documentation of
794	794	tape evaluation for atan, asin, acos, sqrt, log.
795	795	<code><span style='white-space: nowrap'><br/>
796	796	</span></code><b>End Merge</b>

799	799	<br/>
800	800	<b><big><a name="06-25" id="06-25">06-25</a></big></b>
801	801	<br/>
802		The tarball for most recent release (of the subversion trunk for CppAD)
803		was not being placed in the
	802	The tarball for most recent release (of the subversion trunk for CppAD)
	803	was not being placed in the
804	804	<a href="http://www.coin-or.org/download/source/CppAD/" target="_top"><span style='white-space: nowrap'>download</span></a>
805
806		directory.
	805
	806	directory.
807	807	This has been fixed.
808	808
809	809	<br/>

837	837	<code><span style='white-space: nowrap'><br/>
838	838	<br/>
839	839	</span></code>Fix conflict between CppAD's use of config.h preprocessor symbols
840		and other packages use of the same symbol names.
	840	and other packages use of the same symbol names.
841	841
842	842	<br/>
843	843	<br/>

845	845
846	846	<ol type="1"><li>
847	847	Using complex of an AD type (instead of AD of complex) was not working
848		correctly in <code><font color="blue">not_complex_ad.cpp</font></code> because the
	848	correctly in <code><font color="blue">not_complex_ad.cpp</font></code> because the
849	849	<a href="ad_ctor.xml" target="_top"><span style='white-space: nowrap'>default constructor</span></a>
850	850	for an AD object has an unspecified value.
851	851	This has been fixed for the complex type by changing the default constructor
852		to use value zero.
853		(The <code><font color="blue">not_complex_ad.cpp</font></code> example has been removed;
	852	to use value zero.
	853	(The <code><font color="blue">not_complex_ad.cpp</font></code> example has been removed;
854	854	see <a href="faq.xml#Complex Types" target="_top"><span style='white-space: nowrap'>complex FAQ</span></a>
855	855	.)
856	856	</li><li>

861	861	Now <code><font color="blue">valgrind</font></code> runs the CppAD <code><font color="blue">example/example</font></code> program
862	862	with out any warning or error messages.
863	863	In addition, a minor initialization error was fixed in the
864		<code><font color="blue">test_more/jacobian.cpp</font></code> routine so now
	864	<code><font color="blue">test_more/jacobian.cpp</font></code> routine so now
865	865	<code><font color="blue">valgrind</font></code> also runs the CppAD <code><font color="blue">test_more/test_more</font></code> program
866	866	with out any warnings or error messages.
867	867	</li></ol>

880	880	<br/>
881	881	<b><big><a name="03-24" id="03-24">03-24</a></big></b>
882	882	<br/>
883		Added cross references in
	883	Added cross references in
884	884	the <a href="listallexamples.xml" target="_top"><span style='white-space: nowrap'>examples</span></a>
885	885	to occurrence of the following tokens:
886	886	<a href="ad.xml" target="_top"><span style='white-space: nowrap'>AD</span></a>

942	942	<br/>
943	943	Sometimes an error occurs while taping AD operations.
944	944	The <a href="abort_recording.xml" target="_top"><span style='white-space: nowrap'>abort_recording</span></a>
945		function has been added
	945	function has been added
946	946	to make it easier to recover in such cases.
947	947	<code><span style='white-space: nowrap'><br/>
948	948	<br/>

953	953	<code><span style='white-space: nowrap'><br/>
954	954	<br/>
955	955	</span></code>A discussion has been added to the documentation for <a href="jacobian.xml" target="_top"><span style='white-space: nowrap'>Jacobian</span></a>
956
	956
957	957	about its use of
958	958	<a href="jacobian.xml#Forward or Reverse" target="_top"><span style='white-space: nowrap'>forward or reverse</span></a>
959	959

963	963	</span></code>A minor typo has been fixed in the description of
964	964	<code><font color="blue">W(t, u)</font></code> in <a href="reverse_any.xml" target="_top"><span style='white-space: nowrap'>reverse_any</span></a>
965	965	.
966		To be specific,
	966	To be specific,
967	967
968	968	<math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mrow>
969	969	<mi mathvariant='italic'>o</mi>

+1

-1

doc/whats_new_10.xml less more

5	5	<title>Changes and Additions to CppAD During 2010</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2010"/>
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	<meta name="keywords" id="keywords" content=" changes 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+7

-17

doc/whats_new_11.xml less more

5	5	<title>Changes and Additions to CppAD During 2011</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="Changes and Additions to CppAD During 2011"/>
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	<meta name="keywords" id="keywords" content=" changes 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

248	248	code work with this
249	249	change is to use the command
250	250	<code><font color='blue'><pre style='display:inline'>
251		using namespace cppad_ipopt;
	251	using namespace cppad_ipopt;
252	252	</pre></font></code>
253
254
255		<br/>
256	253	<br/>
257	254	<b><big><a name="12-20" id="12-20">12-20</a></big></b>
258	255

501	498
502	499	All of the make files were modified so that the command
503	500	<code><font color='blue'><pre style='display:inline'>
504		make test
	501	make test
505	502	</pre></font></code>
506
507	503	would run the tests for the current directory.
508	504	</li><li>
509	505

633	629	Modify the CppAD trunk using the
634	630	changes from svn revision 2060 to revision 2081 in the branch
635	631	<code><font color='blue'><pre style='display:inline'>
636		https://projects.coin-or.org/svn/CppAD/branches/pthread
	632	https://projects.coin-or.org/svn/CppAD/branches/pthread
637	633	</pre></font></code>
638
639	634	These changes are described below under the headings
640	635	<a href="whats_new_11.xml#09-01.08-21" target="_top"><span style='white-space: nowrap'>08-21</span></a>
641	636	through

789	784	Modify the CppAD trunk using the
790	785	changes from svn revision 2044 to revision 2056 in the branch
791	786	<code><font color='blue'><pre style='display:inline'>
792		https://projects.coin-or.org/svn/CppAD/branches/base_require
	787	https://projects.coin-or.org/svn/CppAD/branches/base_require
793	788	</pre></font></code>
794
795	789	These changes are described below under the headings
796	790	<a href="whats_new_11.xml#08-11.08-04" target="_top"><span style='white-space: nowrap'>08-04</span></a>
797	791	through

1360	1354	In addition, in the file <code><font color="blue">cppad/omp_alloc.hpp</font></code>,
1361	1355	suppress the following Microsoft Visual Studio warning
1362	1356	<code><font color='blue'><pre style='display:inline'>
1363		warning C4345: behavior change: an object of POD type constructed with
1364		an initializer of the form () will be default-initialized
	1357	warning C4345: behavior change: an object of POD type constructed with
	1358	an initializer of the form () will be default-initialized
1365	1359	</pre></font></code>
1366
1367
1368
1369		<br/>
1370	1360	<br/>
1371	1361	<b><big><a name="05-22" id="05-22">05-22</a></big></b>
1372	1362

+12

-26

doc/whats_new_12.xml less more

5	5	<title>CppAD Changes and Additions During 2012</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD Changes and Additions During 2012"/>
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	<meta name="keywords" id="keywords" content=" cppad changes 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

820	820	<a href="optimize.cpp.xml" target="_top"><span style='white-space: nowrap'>optimize.cpp</span></a>
821	821	example:
822	822	<code><font color='blue'><pre style='display:inline'>
823		==6344== Conditional jump or move depends on uninitialised value(s)
	823	==6344== Conditional jump or move depends on uninitialised value(s)
824	824	</pre></font></code>
825
826		</li><li>
827
	825	</li><li>
828	826	Fix mistake in <a href="old_tan.cpp.xml" target="_top"><span style='white-space: nowrap'>old_tan.cpp</span></a>
829	827	where <code><font color="blue">w[2] = 0</font></code>
830	828	was missing before the call
831	829	<code><font color='blue'><pre style='display:inline'>
832		dw = F.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
	830	dw = F.<a href="reverse.xml" target="_top">Reverse</a>(1, w);
833	831	</pre></font></code>
834
835		</li></ol>
836
837
838		<br/>
	832	</li></ol>
839	833	<br/>
840	834	<b><big><a name="07-08" id="07-08">07-08</a></big></b>
841	835

902	896	y_taddr > 0
903	897	at line 262 in the file cppad/local/dependent.hpp
904	898	</pre></font></code>
905
906
907		<br/>
908	899	<br/>
909	900	<b><big><a name="07-02" id="07-02">07-02</a></big></b>
910	901	<br/>

1389	1380	If you then edited the file <code><font color="blue">work/multi_thread/makefile</font></code>
1390	1381	and changed
1391	1382	<code><font color='blue'><pre style='display:inline'>
1392		# AM_CXXFLAGS = -g $(CXX_FLAGS)
1393		AM_CXXFLAGS = -DNDEBUG -O2 $(CXX_FLAGS)
	1383	# AM_CXXFLAGS = -g $(CXX_FLAGS)
	1384	AM_CXXFLAGS = -DNDEBUG -O2 $(CXX_FLAGS)
1394	1385	</pre></font></code>
1395
1396	1386	to
1397	1387	<code><font color='blue'><pre style='display:inline'>
1398		AM_CXXFLAGS = -g $(CXX_FLAGS)
1399		# AM_CXXFLAGS = -DNDEBUG -O2 $(CXX_FLAGS)
	1388	AM_CXXFLAGS = -g $(CXX_FLAGS)
	1389	# AM_CXXFLAGS = -DNDEBUG -O2 $(CXX_FLAGS)
1400	1390	</pre></font></code>
1401
1402	1391	and then executed the commands
1403	1392	<code><font color='blue'><pre style='display:inline'>
1404		make clean
1405		make pthread_test
1406		valgrind --tool=helgrind ./pthread_test simple_ad
	1393	make clean
	1394	make pthread_test
	1395	valgrind --tool=helgrind ./pthread_test simple_ad
1407	1396	</pre></font></code>
1408
1409	1397	The following error message would result:
1410	1398
1411	1399	<code><i><font color="black"><span style='white-space: nowrap'><br/>

1802	1790	<code><font color='blue'><pre style='display:inline'>
1803	1791	if( fabs( fcur ) <= epsilon_ )
1804	1792	</pre></font></code>
1805
1806	1793	was removed from the routine <code><font color="blue">multi_newton_worker</font></code>, in the file
1807	1794	<a href="multi_newton_work.cpp.xml" target="_top"><span style='white-space: nowrap'>multi_newton_work.cpp</span></a>
1808	1795	.

1860	1847	<code><font color='blue'><pre style='display:inline'>
1861	1848	./openmp_test multi_newton 1 32 1000 4800 10 true
1862	1849	</pre></font></code>
1863
1864	1850	improved from 0.0302 seconds to 0.0135 seconds.
1865	1851
1866	1852	</li><li>

+9

-16

doc/whats_new_13.xml less more

5	5	<title>CppAD Changes and Additions During 2013</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD Changes and Additions During 2013"/>
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	<meta name="keywords" id="keywords" content=" cppad changes 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 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

286	286	now handles nested conditional expressions.
287	287	For example, give the code
288	288	<code><font color='blue'><pre style='display:inline'>
289		x = CondExpLt(left_x, right_x, true_x, false_x)
290		y = CondExpGt(left_y, right_y, true_y, false_y)
291		z = CondExpEq(left_z, right_z, x, y)
	289	x = CondExpLt(left_x, right_x, true_x, false_x)
	290	y = CondExpGt(left_y, right_y, true_y, false_y)
	291	z = CondExpEq(left_z, right_z, x, y)
292	292	</pre></font></code>
293
294	293	only two of the conditional expressions will be evaluated
295	294	(one will be skipped depending on the result of <code><font color="blue">left_z == right_z</font></code>).
296	295	For more details, see

410	409	Check[i * n + j] \|= F2[i * n + k] & r[ k * n + j];
411	410	^
412	411	</pre></font></code>
413
414		</li></ol>
415
416
417		<br/>
	412	</li></ol>
418	413	<br/>
419	414	<b><big><a name="09-20" id="09-20">09-20</a></big></b>
420	415

566	561	<br/>
567	562	Fix a case where the test <code><font color="blue">test_more/num_limits.cpp</font></code> failed because
568	563	<code><font color='blue'><pre style='display:inline'>
569		double inf = std::numeric_limits<double>::infinity();
570		double check = std::complex<double>(inf) / std::complex<float>(1.)
	564	double inf = std::numeric_limits<double>::infinity();
	565	double check = std::complex<double>(inf) / std::complex<float>(1.)
571	566	</pre></font></code>
572
573	567	can result in the imaginary part of <code><font color="blue">check</font></code> being <code><font color="blue">- nan</font></code>.
574	568
575	569	<br/>

740	734	matrix of <code><font color="blue">AD</font></code> elements.
741	735	This has been fixed using a template partial specialization of
742	736	<code><font color='blue'><pre style='display:inline'>
743		template<typename Scalar, bool IsInteger>
744		struct significant_decimals_default_impl
	737	template<typename Scalar, bool IsInteger>
	738	struct significant_decimals_default_impl
745	739	</pre></font></code>
746
747	740	because the original template requires definition of a implicit conversion
748	741	from the scalar type to an <code><font color="blue">int</font></code> and this is dangerous for AD types
749	742	(note that <a href="integer.xml" target="_top"><span style='white-space: nowrap'>Integer</span></a>

+6

-9

doc/whats_new_14.xml less more

5	5	<title>CppAD Changes and Additions During 2014</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	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-30 12-29 12-28 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 "/>
	8	<meta name="keywords" id="keywords" content=" cppad changes additions during 2014 introduction 12-30 12-29 12-28 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	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

162	162	whereby it would sometimes mistakenly
163	163	exit with the error message
164	164	<code><font color='blue'><pre style='display:inline'>
165		cppad_max_num_threads is not an integer greater than or equal 4
	165	cppad_max_num_threads is not an integer greater than or equal 4
166	166	</pre></font></code>
167
168	167	This has been fixed.
169	168
170	169	<br/>

466	465	results
467	466	before this change:
468	467	<code><font color='blue'><pre style='display:inline'>
469		cppad_sparse_jacobian_size = [ 100, 400, 900, 1600, 2500 ]
470		cppad_sparse_jacobian_rate = [ 2973, 431.94, 142.25, 78.64, 26.87 ]
	468	cppad_sparse_jacobian_size = [ 100, 400, 900, 1600, 2500 ]
	469	cppad_sparse_jacobian_rate = [ 2973, 431.94, 142.25, 78.64, 26.87 ]
471	470	</pre></font></code>
472
473	471	and after this change:
474	472	<code><font color='blue'><pre style='display:inline'>
475		cppad_sparse_jacobian_size = [ 100, 400, 900, 1600, 2500 ]
476		cppad_sparse_jacobian_rate = [ 6389, 954.26, 314.04, 180.06, 56.95 ]
	473	cppad_sparse_jacobian_size = [ 100, 400, 900, 1600, 2500 ]
	474	cppad_sparse_jacobian_rate = [ 6389, 954.26, 314.04, 180.06, 56.95 ]
477	475	</pre></font></code>
478
479	476	Due to the success of this change,
480	477	<code><font color="blue">multiple direction</font></code> items were added to the wish list
481	478	(they were later removed).

+14

-24

doc/whats_new_15.xml less more

5	5	<title>CppAD Changes and Additions During 2015</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="CppAD Changes and Additions During 2015"/>
8		<meta name="keywords" id="keywords" content=" cppad changes and additions during 2015 introduction 12-29 12-28 12-08 12-01 11-30 11-25 11-24 11-14 11-08 11-06 10-21 10-16 10-06 10-04 10-03 10-02 09-28 09-27 09-25 09-24 09-23 09-21 09-20 09-19 09-16 09-03 09-02 08-31 08-30 08-29 08-28 08-26 08-25 08-20 08-17 08-16 08-09 08-06 07-31 06-16 06-11 06-09 06-07 05-26 cond_exp_1 cond_exp_2 05-11 05-10 05-09 05-08 05-07 05-05 04-18 03-13 03-06 02-28 02-18 02-16 02-14 02-11 02-10 02-09 02-07 02-06 02-04 02-03 02-02 01-30 01-29 01-26 01-23 01-21 01-20 01-09 01-07 01-02 "/>
	8	<meta name="keywords" id="keywords" content=" cppad changes additions during 2015 introduction 12-29 12-28 12-08 12-01 11-30 11-25 11-24 11-14 11-08 11-06 10-21 10-16 10-06 10-04 10-03 10-02 09-28 09-27 09-25 09-24 09-23 09-21 09-20 09-19 09-16 09-03 09-02 08-31 08-30 08-29 08-28 08-26 08-25 08-20 08-17 08-16 08-09 08-06 07-31 06-16 06-11 06-09 06-07 05-26 cond_exp_1 cond_exp_2 05-11 05-10 05-09 05-08 05-07 05-05 04-18 03-13 03-06 02-28 02-18 02-16 02-14 02-11 02-10 02-09 02-07 02-06 02-04 02-03 02-02 01-30 01-29 01-26 01-23 01-21 01-20 01-09 01-07 01-02 "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

274	274	.
275	275	For example,
276	276	<code><font color='blue'><pre style='display:inline'>
277		# include <cppad/runge_45.hpp>
	277	# include <cppad/runge_45.hpp>
278	278	</pre></font></code>
279
280	279	You should us the utility include instead; i.e.,
281	280	<code><font color='blue'><pre style='display:inline'>
282		# include <cppad/utility.hpp>
	281	# include <cppad/utility.hpp>
283	282	</pre></font></code>
284
285		</li><li>
286
	283	</li><li>
287	284	The <a href="numeric_ad.xml" target="_top"><span style='white-space: nowrap'>numeric_ad</span></a>
288	285	routines where moved from the <code><font color="blue">library</font></code>
289	286	the a separate documentation section.

311	308	<ol type="1"><li>
312	309	CppAD now installs the object library
313	310	<code><font color='blue'><pre style='display:inline'>
314		-lcppad_lib
	311	-lcppad_lib
315	312	</pre></font></code>
316
317	313	to be included when linking.
318	314	Currently, it is only required when
319	315	<a href="colpack_prefix.xml" target="_top"><span style='white-space: nowrap'>colpack_prefix</span></a>

324	320
325	321	It is no longer necessary to compile and link the file
326	322	<code><font color='blue'><pre style='display:inline'>
327		cppad_colpack.cpp
	323	cppad_colpack.cpp
328	324	</pre></font></code>
329
330	325	when <a href="colpack_prefix.xml" target="_top"><span style='white-space: nowrap'>colpack_prefix</span></a>
331	326
332	327	is specified during the install process; see

1260	1255	case that is not used.
1261	1256	For example, if
1262	1257	<code><font color='blue'><pre style='display:inline'>
1263		<a href="independent.xml" target="_top">Independent</a>(ax);
1264		<a href="ad.xml" target="_top">AD</a><double> aeps = 1e-10;
1265		ay[0] = CondExpGt( ax[0], aeps, 1.0/ax[0], 1.0/aeps );
1266		<a href="funconstruct.xml" target="_top">ADFun</a><double> f(ax, ay);
	1258	<a href="independent.xml" target="_top">Independent</a>(ax);
	1259	<a href="ad.xml" target="_top">AD</a><double> aeps = 1e-10;
	1260	ay[0] = CondExpGt( ax[0], aeps, 1.0/ax[0], 1.0/aeps );
	1261	<a href="funconstruct.xml" target="_top">ADFun</a><double> f(ax, ay);
1267	1262	</pre></font></code>
1268
1269	1263	The corresponding reverse mode calculation,
1270	1264	at <code><font color="blue">x[0] = 0.0</font></code>, would result in
1271	1265	<code><font color='blue'><pre style='display:inline'>
1272		Error detected by false result for
1273		! ( hasnan(value) && check_for_nan_ )
	1266	Error detected by false result for
	1267	! ( hasnan(value) && check_for_nan_ )
1274	1268	</pre></font></code>
1275
1276	1269	This has been fixed so that only the conditional expression case that is used
1277	1270	affects the reverse mode results.
1278	1271	The example <a href="cond_exp.cpp.xml" target="_top"><span style='white-space: nowrap'>cond_exp.cpp</span></a>

1321	1314	is not defined, one could get
1322	1315	an assert with the message:
1323	1316	<code><font color='blue'><pre style='display:inline'>
1324		Error detected by false result for
1325		var_index_ >= NumRes(op_)
	1317	Error detected by false result for
	1318	var_index_ >= NumRes(op_)
1326	1319	</pre></font></code>
1327
1328
1329		<br/>
1330	1320	<br/>
1331	1321	<b><big><a name="02-10" id="02-10">02-10</a></big></b>
1332	1322	<br/>

+8

-11

doc/wish_list.xml less more

5	5	<title>The CppAD Wish List</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="The CppAD Wish List"/>
8		<meta name="keywords" id="keywords" content=" the cppad wish list base requirements printfor optimization checkpoint machine epsilon in examples adolc optimizing nested conditional expressions forward mode recomputation iterator interface compilation speed operation sequence comparison changes and software guidelines tracing atan2 benderquad "/>
	8	<meta name="keywords" id="keywords" content=" the cppad wish list base requirements printfor optimization checkpoint machine epsilon examples adolc optimizing nested conditional expressions forward mode recomputation iterator interface compilation speed operation sequence comparison changes software guidelines tracing atan2 benderquad "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

155	155	If one <a href="optimize.xml" target="_top"><span style='white-space: nowrap'>optimizes</span></a>
156	156	the code
157	157	<code><font color='blue'><pre style='display:inline'>
158		x = CondExpLt(left_x, right_x, true_x, false_x)
159		y = CondExpGt(left_y, right_y, true_y, false_y)
160		z = CondExpEq(left_z, right_z, x, y)
	158	x = CondExpLt(left_x, right_x, true_x, false_x)
	159	y = CondExpGt(left_y, right_y, true_y, false_y)
	160	z = CondExpEq(left_z, right_z, x, y)
161	161	</pre></font></code>
162
163	162	only two of the expressions
164	163	<code><font color="blue">true_x</font></code>, <code><font color="blue">false_x</font></code>, <code><font color="blue">true_y</font></code>, <code><font color="blue">false_y</font></code>
165	164	will be evaluated

267	266	Currently, CppAD uses a tabs stops at column multiples of 5.
268	267	Five columns were chosen to avoid high levels of indenting and to allow for
269	268	<code><font color='blue'><pre style='display:inline'>
270		if( expression )
271		statement
272		else statement
	269	if( expression )
	270	statement
	271	else statement
273	272	</pre></font></code>
274
275	273	with a tab after the else.
276	274	Automatic conversion to actual spaces should be easy.
277	275

286	284	Tracing the operation sequence is currently done by changing the CppAD
287	285	source code. Use the command
288	286	<code><font color='blue'><pre style='display:inline'>
289		grep '^# define CPPAD_._TRACE' cppad/local/.hpp
	287	grep '^# define CPPAD_._TRACE' cppad/local/.hpp
290	288	</pre></font></code>
291
292	289	to find all the possible tracing flags.
293	290
294	291

+1

-1

doc/zdouble.cpp.xml less more

5	5	<title>zdouble: Example and Test</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="zdouble: Example and Test"/>
8		<meta name="keywords" id="keywords" content=" zdouble: example and test "/>
	8	<meta name="keywords" id="keywords" content=" zdouble: example test "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

+1

-3

doc/zdouble.xml less more

5	5	<title>zdouble: An AD Base Type With Absolute Zero</title>
6	6	<meta http-equiv='Content-Type' content='text/html' charset='utf-8'/>
7	7	<meta name="description" id="description" content="zdouble: An AD Base Type With Absolute Zero"/>
8		<meta name="keywords" id="keywords" content=" zdouble: an ad base type with absolute zero deprecated 2015-09-26 syntax constructor and assignment comparison operators arithmetic standard math nan motivation general cppad requirements example "/>
	8	<meta name="keywords" id="keywords" content=" zdouble: ad base type with absolute zero deprecated 2015-09-26 syntax constructor assignment comparison operators arithmetic standard math nan motivation general cppad requirements example "/>
9	9	<style type='text/css'>
10	10	body { color : black }
11	11	body { background-color : white }

116	116	</select>
117	117	</td>
118	118	</tr></table><br/>
119
120
121	119	<center><b><big><big>zdouble: An AD Base Type With Absolute Zero</big></big></b></center>
122	120	<br/>
123	121	<b><big><a name="Deprecated 2015-09-26" id="Deprecated 2015-09-26">Deprecated 2015-09-26</a></big></b>

+2

-2

doc.omh less more

0		$Id: doc.omh 3772 2015-12-31 14:01:01Z bradbell $
	0	$Id: doc.omh 3786 2016-02-08 13:14:26Z bradbell $
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3

90	90
91	91	$comment bin/version assumes that : follows cppad version number here$$
92	92	$section
93		cppad-20160000.0: A Package for Differentiation of C++ Algorithms
	93	cppad-20160000.1: A Package for Differentiation of C++ Algorithms
94	94	$$
95	95	$mindex AD algorithmic differentiation automatic C++ algorithm derivative CppAD version cppad.hpp$$
96	96

+2

-2

example/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3768 2015-12-28 18:58:35Z bradbell $
	0	# $Id: CMakeLists.txt 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

214	214
215	215	# List of libraries to be linked into the specified target
216	216	TARGET_LINK_LIBRARIES(example
217		cppad_lib
	217	${cppad_lib}
218	218	${adolc_libs}
219	219	${colpack_libs}
220	220	${eigen_libs}

+2

-2

example/ipopt_solve/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3754 2015-11-26 22:23:05Z bradbell $
	0	# $Id: CMakeLists.txt 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

38	38	# libraries to be linked into the specified target,
39	39	# as determined by pkg-config for ipopt
40	40	TARGET_LINK_LIBRARIES(example_ipopt_solve
41		cppad_lib
	41	${cppad_lib}
42	42	${ipopt_LIBRARIES}
43	43	${colpack_libs}
44	44	)

+4

-4

example/ipopt_solve/makefile.am less more

0		# $Id: makefile.am 2661 2012-12-28 16:23:17Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

15	15	#
16	16	check_PROGRAMS = solve
17	17	#
18		AM_CXXFLAGS = -g $(CXX_FLAGS)
	18	AM_CXXFLAGS = -g $(CXX_FLAGS)
19	19	#
20	20	AM_CPPFLAGS = -I. \
21	21	-I$(top_srcdir) \

+5

-5

introduction/exp_apx/exp_2.cpp less more

0		/* $Id: exp_2.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: exp_2.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

13	13	# include "exp_2.hpp" // definition of exp_2 algorithm
14	14	bool exp_2(void)
15	15	{ double x = .5;
16		double check = 1 + x + x * x / 2.;
17		bool ok = std::fabs( exp_2(x) - check ) <= 1e-10;
	16	double check = 1 + x + x * x / 2.;
	17	bool ok = std::fabs( exp_2(x) - check ) <= 1e-10;
18	18	return ok;
19	19	}
20	20	// END C++

+13

-13

introduction/exp_apx/exp_2_cppad.cpp less more

0		/* $Id: exp_2_cppad.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: exp_2_cppad.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

38	38	Use CppAD forward and reverse modes to compute the
39	39	partial derivative with respect to $latex x$$,
40	40	at the point $latex x = .5$$,
41		of the function
	41	of the function
42	42	$codei%
43	43	exp_2(%x%)
44	44	%$$

48	48	$list number$$
49	49	Create and test a modified version of the routine below that computes
50	50	the same order derivatives with respect to $latex x$$,
51		at the point $latex x = .1$$
52		of the function
	51	at the point $latex x = .1$$
	52	of the function
53	53	$codei%
54	54	exp_2(%x%)
55	55	%$$

57	57	Create a routine called
58	58	$codei%
59	59	exp_3(%x%)
60		%$$
	60	%$$
61	61	that evaluates the function
62	62	$latex \[
63	63	f(x) = 1 + x^2 / 2 + x^3 / 6

68	68	$lend
69	69	$codep */
70	70
71		# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
	71	# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
72	72	# include "exp_2.hpp" // second order exponential approximation
73	73	bool exp_2_cppad(void)
74	74	{ bool ok = true;

86	86
87	87	// evaluate our exponential approximation
88	88	AD<double> x = X[0];
89		AD<double> apx = exp_2(x);
	89	AD<double> apx = exp_2(x);
90	90
91	91	// range space vector
92	92	size_t m = 1; // dimension of the range space

94	94	Y[0] = apx; // variable that represents only range space component
95	95
96	96	// Create f: X -> Y corresponding to this operation sequence
97		// and stop recording. This also executes a zero order forward
	97	// and stop recording. This also executes a zero order forward
98	98	// sweep using values in X for x.
99	99	CppAD::ADFun<double> f(X, Y);
100	100

117	117
118	118	// second order forward sweep that computes
119	119	// second partial of exp_2(x) with respect to x
120		vector<double> x2(n); // second order Taylor coefficients
121		vector<double> y2(m);
	120	vector<double> x2(n); // second order Taylor coefficients
	121	vector<double> y2(m);
122	122	x2[0] = 0.; // evaluate second partial .w.r.t. x
123	123	y2 = f.Forward(2, x2);
124		check = 0.5 * 1.; // Taylor coef is 1/2 second derivative
	124	check = 0.5 * 1.; // Taylor coef is 1/2 second derivative
125	125	ok &= NearEqual(y2[0], check, 1e-10, 1e-10);
126	126
127	127	// second order reverse sweep that computes

+4

-4

introduction/exp_apx/exp_eps.cpp less more

0		/* $Id: exp_eps.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: exp_eps.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

15	15	{ double x = .5;
16	16	double epsilon = .2;
17	17	double check = 1 + .5 + .125; // include 1 term less than epsilon
18		bool ok = std::fabs( exp_eps(x, epsilon) - check ) <= 1e-10;
	18	bool ok = std::fabs( exp_eps(x, epsilon) - check ) <= 1e-10;
19	19	return ok;
20	20	}
21	21	// END C++

+10

-10

introduction/exp_apx/exp_eps_cppad.cpp less more

0		/* $Id: exp_eps_cppad.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: exp_eps_cppad.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

39	39	Use CppAD forward and reverse modes to compute the
40	40	partial derivative with respect to $latex x$$,
41	41	at the point $latex x = .5$$ and $latex \varepsilon = .2$$,
42		of the function
	42	of the function
43	43	$codei%
44	44	exp_eps(%x%, %epsilon%)
45	45	%$$

50	50	Create and test a modified version of the routine below that computes
51	51	the same order derivatives with respect to $latex x$$,
52	52	at the point $latex x = .1$$ and $latex \varepsilon = .2$$,
53		of the function
	53	of the function
54	54	$codei%
55	55	exp_eps(%x%, %epsilon%)
56	56	%$$

58	58	Create and test a modified version of the routine below that computes
59	59	partial derivative with respect to $latex x$$,
60	60	at the point $latex x = .1$$ and $latex \varepsilon = .2$$,
61		of the function corresponding to the operation sequence
	61	of the function corresponding to the operation sequence
62	62	for $latex x = .5$$ and $latex \varepsilon = .2$$.
63	63	Hint: you could define a vector u with two components and use
64	64	$codei%

69	69	$icode f$$ was recorded.
70	70	$lend
71	71	$codep */
72		# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
	72	# include <cppad/cppad.hpp> // http://www.coin-or.org/CppAD/
73	73	# include "exp_eps.hpp" // our example exponential function approximation
74	74	bool exp_eps_cppad(void)
75	75	{ bool ok = true;

89	89	// evaluate our exponential approximation
90	90	AD<double> x = U[0];
91	91	AD<double> epsilon = U[1];
92		AD<double> apx = exp_eps(x, epsilon);
	92	AD<double> apx = exp_eps(x, epsilon);
93	93
94	94	// range space vector
95	95	size_t m = 1; // dimension of the range space

97	97	Y[0] = apx; // variable that represents only range space component
98	98
99	99	// Create f: U -> Y corresponding to this operation sequence
100		// and stop recording. This also executes a zero order forward
	100	// and stop recording. This also executes a zero order forward
101	101	// mode sweep using values in U for x and e.
102	102	CppAD::ADFun<double> f(U, Y);
103	103

113	113	// first order reverse mode sweep that computes the derivative
114	114	vector<double> w(m); // weights for components of the range
115	115	vector<double> dw(n); // derivative of the weighted function
116		w[0] = 1.; // there is only one weight
	116	w[0] = 1.; // there is only one weight
117	117	dw = f.Reverse(1, w); // derivative of w[0] * exp_eps(x, epsilon)
118	118	check = 1.5; // partial w.r.t. x
119	119	ok &= NearEqual(dw[0], check, 1e-10, 1e-10);

+4

-4

introduction/exp_apx/makefile.am less more

0		# $Id: makefile.am 2541 2012-11-06 16:32:36Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

18	18	exp_2.omh \
19	19	exp_eps.omh
20	20	#
21		check_PROGRAMS = exp_apx
	21	check_PROGRAMS = exp_apx
22	22	#
23	23	AM_CPPFLAGS = -I. -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
24	24	AM_CXXFLAGS = -g $(CXX_FLAGS)

+4

-4

introduction/get_started/makefile.am less more

0		# $Id: makefile.am 2541 2012-11-06 16:32:36Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

14	14	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
15	15	DEFS =
16	16	#
17		check_PROGRAMS = get_started
	17	check_PROGRAMS = get_started
18	18	#
19	19	AM_CPPFLAGS = -I. -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
20	20	AM_CXXFLAGS = -g $(CXX_FLAGS)

+13

-13

multi_thread/makefile.am less more

0		# $Id: makefile.am 2556 2012-11-10 00:53:00Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

16	16	if CppAD_OPENMP
17	17	OPENMP_TEST = openmp_test
18	18	else
19		OPENMP_TEST =
	19	OPENMP_TEST =
20	20	endif
21	21	#
22	22	if CppAD_BTHREAD

27	27	endif
28	28	else
29	29	# BTHREAD_LIB empty in this case
30		BTHREAD_TEST =
31		BOOST_LIB =
	30	BTHREAD_TEST =
	31	BOOST_LIB =
32	32	endif
33	33	#
34	34	if CppAD_PTHREAD
35	35	PTHREAD_TEST = pthread_test
36	36	else
37		PTHREAD_TEST =
	37	PTHREAD_TEST =
38	38	endif
39	39	#
40		check_PROGRAMS = $(OPENMP_TEST) $(BTHREAD_TEST) $(PTHREAD_TEST)
	40	check_PROGRAMS = $(OPENMP_TEST) $(BTHREAD_TEST) $(PTHREAD_TEST)
41	41	#
42	42	if CppAD_MS_COMPILER
43		# AM_CXXFLAGS = -EHsc -g $(CXX_FLAGS)
44		AM_CXXFLAGS = -EHsc -DNDEBUG -O2 $(CXX_FLAGS)
	43	# AM_CXXFLAGS = -EHsc -g $(CXX_FLAGS)
	44	AM_CXXFLAGS = -EHsc -DNDEBUG -O2 $(CXX_FLAGS)
45	45	else
46	46	# AM_CXXFLAGS = -g $(CXX_FLAGS)
47	47	AM_CXXFLAGS = -DNDEBUG -O2 $(CXX_FLAGS)

67	67	team_example.cpp team_example.hpp \
68	68	harmonic_time.cpp harmonic_time.hpp \
69	69	harmonic.cpp harmonic.hpp \
70		harmonic_work.cpp harmonic_work.hpp
	70	harmonic_work.cpp harmonic_work.hpp
71	71	#
72	72	bthread_test_SOURCES = \
73	73	$(SHARED_SRC) \

79	79	$(SHARED_SRC) \
80	80	openmp/team_openmp.cpp \
81	81	openmp/a11c_openmp.cpp \
82		openmp/simple_ad_openmp.cpp
	82	openmp/simple_ad_openmp.cpp
83	83	#
84	84	pthread_test_SOURCES = \
85	85	$(SHARED_SRC) \
86	86	pthread/team_pthread.cpp \
87	87	pthread/a11c_pthread.cpp \
88		pthread/simple_ad_pthread.cpp
	88	pthread/simple_ad_pthread.cpp
89	89	#
90	90	dist_noinst_SCRIPTS = test.sh
91	91	#

+5

-5

multi_thread/test_multi/makefile.am less more

0		# $Id: makefile.am 2506 2012-10-24 19:36:49Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

16	16	if CppAD_OPENMP
17	17	TEST_OPENMP_FLAG = -DCPPAD_TEST_OPENMP
18	18	else
19		TEST_OPENMP_FLAG =
	19	TEST_OPENMP_FLAG =
20	20	endif
21	21	#
22	22	check_PROGRAMS = test_multi

34	34	#
35	35	test_multi_SOURCES = \
36	36	test_multi.cpp \
37		user_atomic.cpp
	37	user_atomic.cpp
38	38
39	39	test: check
40	40	./test_multi

+20

-20

multi_thread/test_multi/user_atomic.cpp less more

0		/* $Id: user_atomic.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: user_atomic.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

27	27	size_t thread_number(void)
28	28	{ return static_cast<size_t>( omp_get_thread_num() ); }
29	29	# endif
30
	30
31	31	// y[0] = x[0] + x[1]
32	32	bool user_atomic_forward(
33	33	size_t id ,
34		size_t k ,
	34	size_t k ,
35	35	size_t n ,
36	36	size_t m ,
37	37	const CppAD::vector<bool>& vx ,
38	38	CppAD::vector<bool>& vy ,
39		const CppAD::vector<double>& tx ,
	39	const CppAD::vector<double>& tx ,
40	40	CppAD::vector<double>& ty )
41	41	{ assert(n >= 3 && m == 2);
42		if( k > 0 )
	42	if( k > 0 )
43	43	return false;
44	44
45	45	ty[0] = tx[0] + tx[1];
46	46	ty[1] = tx[1] + tx[2];
47
	47
48	48	if( vy.size() > 0 )
49	49	{ vy[0] = (vx[0] \| vx[1]);
50	50	vy[1] = (vx[1] \| vx[2]);
51	51	}
52		return true;
	52	return true;
53	53	}
54	54
55	55	bool user_atomic_reverse(
56	56	size_t id ,
57		size_t k ,
58		size_t n ,
59		size_t m ,
60		const CppAD::vector<double>& tx ,
	57	size_t k ,
	58	size_t n ,
	59	size_t m ,
	60	const CppAD::vector<double>& tx ,
61	61	const CppAD::vector<double>& ty ,
62	62	CppAD::vector<double>& px ,
63	63	const CppAD::vector<double>& py )

101	101	user_atomic_reverse ,
102	102	user_atomic_for_jac_sparse ,
103	103	user_atomic_rev_jac_sparse ,
104		user_atomic_rev_hes_sparse
	104	user_atomic_rev_hes_sparse
105	105	)
106	106
107	107	bool user_atomic(int call_index)

116	116	for(j = 0; j < n; j++)
117	117	ax[j] = AD<double>(j + 1);
118	118	CppAD::Independent(ax);
119
	119
120	120	// use user atomic function
121	121	size_t id = 0;
122	122	my_user_atomic(id, ax, ay);
123
	123
124	124	// create function
125	125	CppAD::ADFun<double> g(ax, ay);
126
	126
127	127	// now use the tape with the user atomic function
128	128	vector<double> x(n), y(m);
129	129	for(j = 0; j < n; j++)

133	133	ok &= (y[0] == x[0] + x[1]);
134	134	// y[1] = x[1] + x[2]
135	135	ok &= (y[0] == x[0] + x[1]);
136
	136
137	137	return ok;
138	138	}
139	139	}

181	181	ok &= ok_all[call_index];
182	182
183	183	// --------------------------------------------------------------------
184		// Free all temporary work space associated with user_atomic objects.
185		// (If there are future calls to user atomic functions, they will
	184	// Free all temporary work space associated with user_atomic objects.
	185	// (If there are future calls to user atomic functions, they will
186	186	// create new temporary work space.)
187	187	CppAD::user_atomic<double>::clear();
188	188

+5

-5

omh/bib.omh less more

0		$Id: bib.omh 2506 2012-10-24 19:36:49Z bradbell $
	0	$Id: bib.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	// BEGIN SHORT COPYRIGHT
2	2	/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
4	4
5	5	CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
	6	the terms of the
7	7	GNU General Public License Version 3.
8	8
9	9	A copy of this license is included in the COPYING file of this distribution.

42	42	$head Evaluating Derivatives$$
43	43	Evaluating Derivatives: Principles and Techniques of
44	44	Algorithmic Differentiation,
45		Andreas Griewank,
46		SIAM,
	45	Andreas Griewank,
	46	SIAM,
47	47	Philadelphia,
48	48	2000
49	49

+2

-2

omh/forward/forward.omh less more

0		/* $Id: forward.omh 3607 2015-01-20 16:20:41Z bradbell $ */
	0	// $Id: forward.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

+10

-10

omh/forward/size_order.omh less more

0		/* $Id: size_order.omh 3214 2014-03-18 20:50:38Z bradbell $ */
	0	// $Id: size_order.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

25	25
26	26	$head Purpose$$
27	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
	28	currently calculated and stored in the ADFun object $icode f$$.
	29	See the discussion under
30	30	$cref/Constructor/size_order/Constructor/$$,
31	31	$cref/Forward/size_order/Forward/$$, and
32	32	$cref/capacity_order/size_order/capacity_order/$$

44	44	$codei%
45	45	size_t %s%
46	46	%$$
47		and is the number of Taylor coefficient orders,
	47	and is the number of Taylor coefficient orders,
48	48	per variable,direction in the AD operation sequence,
49	49	currently calculated and stored in the ADFun object $icode f$$.
50	50

63	63	$codei%
64	64	%f%.Forward(%q%, %x_q%)
65	65	%$$
66		the value of $icode s$$ returned by $code size_order$$
	66	the value of $icode s$$ returned by $code size_order$$
67	67	would be $latex q + 1$$.
68	68	The call to $code Forward$$ above
69		uses the lower order Taylor coefficients to compute and store
	69	uses the lower order Taylor coefficients to compute and store
70	70	the $th q$$ order Taylor coefficients for all
71	71	the variables in the operation sequence corresponding to $icode f$$.
72	72	Thus there are $latex q + 1$$ (order zero through $icode q$$)

76	76
77	77	$head capacity_order$$
78	78	If the number of Taylor coefficient orders
79		currently stored in $icode f$$ is less than or equal $icode c$$,
	79	currently stored in $icode f$$ is less than or equal $icode c$$,
80	80	a call to $cref capacity_order$$ with the syntax
81	81	$codei%
82	82	%f%.capacity_order(%c%)

85	85	Otherwise,
86	86	the value $icode s$$ returned by $code size_order$$
87	87	is equal to $icode c$$
88		(only Taylor coefficients of order zero through $latex c-1$$
	88	(only Taylor coefficients of order zero through $latex c-1$$
89	89	have been retained).
90	90
91	91	$head Example$$

+5

-5

omh/install/download.omh less more

0		$Id: download.omh 3772 2015-12-31 14:01:01Z bradbell $
	0	$Id: download.omh 3786 2016-02-08 13:14:26Z bradbell $
1	1	/* --------------------------------------------------------------------------
2	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3

64	64	$bold version$$ $pre $$ $cnext $bold license$$ $pre $$ $cnext $bold link$$
65	65	$rnext
66	66	current $cnext EPL $cnext $href%
67		http://www.coin-or.org/download/source/CppAD/cppad-20160000.0.epl.tgz%
68		cppad-20160000.0.epl.tgz%$$
	67	http://www.coin-or.org/download/source/CppAD/cppad-20160000.1.epl.tgz%
	68	cppad-20160000.1.epl.tgz%$$
69	69	$rnext
70	70	current $cnext GPL $cnext $href%
71		http://www.coin-or.org/download/source/CppAD/cppad-20160000.0.gpl.tgz%
72		cppad-20160000.0.gpl.tgz%$$
	71	http://www.coin-or.org/download/source/CppAD/cppad-20160000.1.gpl.tgz%
	72	cppad-20160000.1.gpl.tgz%$$
73	73	$rnext
74	74	old $cnext Both $cnext
75	75	$href%http://www.coin-or.org/download/source/CppAD/%CppAD download page%$$

+3

-3

omh/license.omh less more

0		$Id: license.omh 2506 2012-10-24 19:36:49Z bradbell $
	0	$Id: license.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

+8

-8

omh/new_feature.omh less more

0		$Id: new_feature.omh 2506 2012-10-24 19:36:49Z bradbell $
	0	$Id: new_feature.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	// BEGIN SHORT COPYRIGHT
2	2	/* --------------------------------------------------------------------------
3		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
	3	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
4	4
5	5	CppAD is distributed under multiple licenses. This distribution is under
6		the terms of the
	6	the terms of the
7	7	GNU General Public License Version 3.
8	8
9	9	A copy of this license is included in the COPYING file of this distribution.

26	26	$section Adding a New Feature to the CppAD Distribution$$
27	27
28	28	$head Overview$$
29		Suppose that you add a new feature to CppAD and the
	29	Suppose that you add a new feature to CppAD and the
30	30	corresponding include file is $icode%Name%.h%$$.
31		You should check each of the following steps:
	31	You should check each of the following steps:
32	32
33	33	$list number$$
34	34	Add the new file $icode%Name%.h%$$ to the cvs repository.
35	35
36	36	$lnext
37		Add a test file called $codei%example/%Name%.cpp%$$ that check
	37	Add a test file called $codei%example/%Name%.cpp%$$ that check
38	38	for correct results (and run the test to make sure it works).
39	39
40	40	$lnext

44	44	Add a call to the new test in the file $code example/example.cpp$$.
45	45
46	46	$lnext
47		Add the file $icode%Name%.cpp%$$ to the list of
	47	Add the file $icode%Name%.cpp%$$ to the list of
48	48	$code Example_SOURCES$$ in the file $code example/Makefile.am$$.
49	49
50	50	$lnext

52	52	corresponding to the Microsoft C++ project file $code example/Example.dsp$$.
53	53
54	54	$lnext
55		Add the file $icode%Name%.h%$$ to the list of
	55	Add the file $icode%Name%.h%$$ to the list of
56	56	$code nobase_include_HEADERS$$ in the file $code Makefile.am$$.
57	57
58	58	$lnext

+3

-3

omh/reverse/reverse.omh less more

0		/* $Id: reverse.omh 3301 2014-05-24 05:20:21Z bradbell $ */
	0	// $Id: reverse.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

+20

-20

omh/theory/reverse_identity.omh less more

0		$Id: reverse_identity.omh 3169 2014-03-09 13:37:59Z bradbell $
	0	$Id: reverse_identity.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

50	50	where $latex x^{(j)}$$ is the $th j$$ column of $latex x \in B^{n \times p}$$.
51	51	The theorem below implies that
52	52	$latex \[
53		\D{ W_j }{ x^{(i)} } (x) = \D{ W_{j-i} }{ x^{(0)} } (x)
	53	\D{ W_j }{ x^{(i)} } (x) = \D{ W_{j-i} }{ x^{(0)} } (x)
54	54	\] $$
55	55	A $cref/general reverse sweep/reverse_any/$$ calculates the values
56	56	$latex \[

65	65	$head Theorem$$
66	66	Suppose that $latex F : B^n \rightarrow B^m$$ is a $latex p$$ times
67	67	continuously differentiable function.
68		Define the functions
	68	Define the functions
69	69	$latex Z : B \times B^{n \times p} \rightarrow B^n$$,
70	70	$latex Y : B \times B^{n \times p }\rightarrow B^m$$,
71	71	and

76	76	\\
77	77	Y(t, x) & = & F [ Z(t, x) ]
78	78	\\
79		y^{(j)} (x) & = & \frac{1}{j !} \Dpow{j}{t} Y(0, x)
	79	y^{(j)} (x) & = & \frac{1}{j !} \Dpow{j}{t} Y(0, x)
80	80	\end{array}
81	81	\] $$
82		where $latex x^{(j)}$$ denotes the $th j$$ column of
	82	where $latex x^{(j)}$$ denotes the $th j$$ column of
83	83	$latex x \in B^{n \times p}$$.
84	84	It follows that
85	85	for all $latex i, j$$ such that $latex i \leq j < p$$,

95	95	$latex \[
96	96	\begin{array}{rclr}
97	97	\D{ y^{(j)} }{ x^{(i)} } (x)
98		& = &
99		\frac{1}{j ! } \D{ }{ x^{(i)} }
	98	& = &
	99	\frac{1}{j ! } \D{ }{ x^{(i)} }
100	100	\left[ \Dpow{j}{t} (F \circ Z) (t, x) \right]_{t=0}
101	101	\\
102	102	& = &
103		\frac{1}{j ! } \left[ \Dpow{j}{t}
104		\D{ }{ x^{(i)} } (F \circ Z) (t, x)
	103	\frac{1}{j ! } \left[ \Dpow{j}{t}
	104	\D{ }{ x^{(i)} } (F \circ Z) (t, x)
105	105	\right]_{t=0}
106	106	\\
107	107	& = &
108		\frac{1}{j ! } \left\{
109		\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
	108	\frac{1}{j ! } \left\{
	109	\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
110	110	\right\}_{t=0}
111	111	\end{array}
112	112	\] $$
113		For $latex k > i$$, the $th k$$
	113	For $latex k > i$$, the $th k$$
114	114	partial of $latex t^i$$ with respect to $latex t$$ is zero.
115	115	Thus, the partial with respect to $latex t$$ is given by
116	116	$latex \[
117	117	\begin{array}{rcl}
118		\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
	118	\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
119	119	& = &
120		\sum_{k=0}^i
	120	\sum_{k=0}^i
121	121	\left( \begin{array}{c} j \\ k \end{array} \right)
122		\frac{ i ! }{ (i - k) ! } t^{i-k} \;
	122	\frac{ i ! }{ (i - k) ! } t^{i-k} \;
123	123	\Dpow{j-k}{t} ( F^{(1)} \circ Z ) (t, x)
124	124	\\
125		\left\{
126		\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
	125	\left\{
	126	\Dpow{j}{t} \left[ t^i ( F^{(1)} \circ Z ) (t, x) \right]
127	127	\right\}_{t=0}
128	128	& = &
129	129	\left( \begin{array}{c} j \\ i \end{array} \right)

134	134	\Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
135	135	\\
136	136	\D{ y^{(j)} }{ x^{(i)} } (x)
137		& = &
	137	& = &
138	138	\frac{ 1 }{ (j - i) ! }
139	139	\Dpow{j-i}{t} ( F^{(1)} \circ Z ) (t, x)
140	140	\end{array}

+28

-28

omh/theory/reverse_theory.omh less more

0		$Id: reverse_theory.omh 3495 2014-12-24 01:16:15Z bradbell $
	0	$Id: reverse_theory.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

18	18	$section The Theory of Reverse Mode$$
19	19
20	20	$head Taylor Notation$$
21		In Taylor notation, each variable corresponds to
	21	In Taylor notation, each variable corresponds to
22	22	a function of a single argument which we denote by $icode t$$
23	23	(see Section 10.2 of
24	24	$cref/Evaluating Derivatives/Bib/Evaluating Derivatives/$$).
25	25	Here and below
26		$latex X(t)$$, $latex Y(t)$$, and $icode Z(t)$$ are scalar valued functions
	26	$latex X(t)$$, $latex Y(t)$$, and $icode Z(t)$$ are scalar valued functions
27	27	and the corresponding $th p$$ order Taylor coefficients row vectors are
28	28	$latex x$$, $latex y$$ and $latex z$$; i.e.,
29	29	$latex \[
30	30	\begin{array}{lcr}
31	31	X(t) & = & x^{(0)} + x^{(1)} * t + \cdots + x^{(p)} * t^p + O( t^{p+1} ) \\
32	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} )
	33	Z(t) & = & z^{(0)} + z^{(1)} * t + \cdots + z^{(p)} * t^p + O( t^{p+1} )
34	34	\end{array}
35	35	\] $$
36	36	For the purposes of this discussion,
37	37	we are given the $th p$$ order Taylor coefficient row vectors
38	38	$latex x$$, $latex y$$, and $latex z$$.
39		In addition, we are given the partial derivatives of a scalar valued function
	39	In addition, we are given the partial derivatives of a scalar valued function
40	40	$latex \[
41	41	G ( z^{(j)} , \ldots , z^{(0)}, x, y)
42	42	\] $$
43	43	We need to compute the partial derivatives of the scalar valued function
44	44	$latex \[
45		H ( z^{(j-1)} , \ldots , z^{(0)}, x, y) =
	45	H ( z^{(j-1)} , \ldots , z^{(0)}, x, y) =
46	46	G ( z^{(j)}, z^{(j-1)} , \ldots , z^{(0)}, x , y )
47	47	\] $$
48		where $latex z^{(j)}$$ is expressed as a function of the
	48	where $latex z^{(j)}$$ is expressed as a function of the
49	49	$th j-1$$ order Taylor coefficient row
50	50	vector for $latex Z$$ and the vectors $latex x$$, $latex y$$; i.e.,
51	51	$latex z^{(j)}$$ above is a shorthand for

72	72	\D{G}{ x^{(k)} } + \D{G}{ z^{(k)} } \\
73	73	\\
74	74	\D{H}{ y^{(k)} } & = &
75		\D{G}{ y^{(k)} } + \D{G}{ z^{(k)} }
	75	\D{G}{ y^{(k)} } + \D{G}{ z^{(k)} }
76	76	\\
77		\D{H}{ z^{(l)} } & = & \D{G}{ z^{(l)} }
78		\end{array}
	77	\D{H}{ z^{(l)} } & = & \D{G}{ z^{(l)} }
	78	\end{array}
79	79	\] $$
80	80
81	81	$subhead Subtraction$$

91	91	\D{G}{ x^{(k)} } - \D{G}{ z^{(k)} } \\
92	92	\\
93	93	\D{H}{ y^{(k)} } & = &
94		\D{G}{ y^{(k)} } - \D{G}{ z^{(k)} }
95		\end{array}
	94	\D{G}{ y^{(k)} } - \D{G}{ z^{(k)} }
	95	\end{array}
96	96	\] $$
97	97
98	98	$subhead Multiplication$$

107	107	\begin{array}{rcl}
108	108	\D{H}{ x^{(j-k)} } & = &
109	109	\D{G}{ x^{(j-k)} } +
110		\sum_{k=0}^j \D{G}{ z^{(j)} } y^{(k)}
	110	\sum_{k=0}^j \D{G}{ z^{(j)} } y^{(k)}
111	111	\\
112	112	\D{H}{ y^{(k)} } & = &
113	113	\D{G}{ y^{(k)} } +
114		\sum_{k=0}^j \D{G}{ z^{(j)} } x^{(j-k)}
115		\end{array}
	114	\sum_{k=0}^j \D{G}{ z^{(j)} } x^{(j-k)}
	115	\end{array}
116	116	\] $$
117	117
118	118	$subhead Division$$
119	119	The forward mode formula for
120	120	$cref/division/ForwardTheory/Binary Operators/Division/$$ is
121	121	$latex \[
122		z^{(j)} =
123		\frac{1}{y^{(0)}}
124		\left(
125		x^{(j)} - \sum_{k=1}^j z^{(j-k)} y^{(k)}
	122	z^{(j)} =
	123	\frac{1}{y^{(0)}}
	124	\left(
	125	x^{(j)} - \sum_{k=1}^j z^{(j-k)} y^{(k)}
126	126	\right)
127	127	\] $$
128	128	If follows that for $latex k = 1 , \ldots , j$$
129	129	$latex \[
130	130	\begin{array}{rcl}
131	131	\D{H}{ x^{(j)} } & = &
132		\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{y^{(0)}}
	132	\D{G}{ x^{(j)} } + \D{G}{ z^{(j)} } \frac{1}{y^{(0)}}
133	133	\\
134	134	\D{H}{ z^{(j-k)} } & = &
135	135	\D{G}{ z^{(j-k)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} y^{(k)}

138	138	\D{G}{ y^{(k)} } - \D{G}{ z^{(j)} } \frac{1}{y^{(0)}} z^{(j-k)}
139	139	\\
140	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)}
	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	144	\right)
145	145	\\
146	146	& = &

150	150
151	151	$head Standard Math Functions$$
152	152	The standard math functions have only one argument.
153		Hence we are given the partial derivatives of a scalar valued function
	153	Hence we are given the partial derivatives of a scalar valued function
154	154	$latex \[
155	155	G ( z^{(j)} , \ldots , z^{(0)}, x)
156	156	\] $$
157	157	We need to compute the partial derivatives of the scalar valued function
158	158	$latex \[
159		H ( z^{(j-1)} , \ldots , z^{(0)}, x) =
	159	H ( z^{(j-1)} , \ldots , z^{(0)}, x) =
160	160	G ( z^{(j)}, z^{(j-1)} , \ldots , z^{(0)}, x)
161	161	\] $$
162		where $latex z^{(j)}$$ is expressed as a function of the
	162	where $latex z^{(j)}$$ is expressed as a function of the
163	163	$th j-1$$ order Taylor coefficient row
164	164	vector for $latex Z$$ and the vector $latex x$$; i.e.,
165	165	$latex z^{(j)}$$ above is a shorthand for

+3

-3

omh/theory/theory.omh less more

0		$Id: theory.omh 3169 2014-03-09 13:37:59Z bradbell $
	0	$Id: theory.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

+4

-4

omh/whats_new/whats_new.omh less more

0		$Id: whats_new.omh 3552 2015-01-03 12:41:46Z bradbell $
	0	$Id: whats_new.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

17	17	$section Changes and Additions to CppAD$$
18	18
19	19	$head Introduction$$
20		The sections listed below contain a list of the changes to CppAD
	20	The sections listed below contain a list of the changes to CppAD
21	21	in reverse order by date.
22	22	The purpose of these sections is to
23	23	assist you in learning about changes between various versions of CppAD.

+68

-68

omh/whats_new/whats_new_09.omh less more

0		$Id: whats_new_09.omh 3627 2015-01-30 15:49:51Z bradbell $
	0	$Id: whats_new_09.omh 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

61	61	trying to read and understand the CppAD source code.)
62	62
63	63	$head 12-23$$
64		The
	64	The
65	65	$code ADFun$$ $cref/assignment operator/FunConstruct/Assignment Operator/$$
66	66	was changed so that it now copies forward mode
67	67	Taylor coefficients and sparsity pattern information.

75	75	$cref/size_forward_set/ForSparseJac/f/size_forward_set/$$.
76	76
77	77	$head 12-22$$
78		Convert the optimization of a sequence of additions from multiple operators
79		to one operator with a varying number of arguments. This improved the speed
	78	Convert the optimization of a sequence of additions from multiple operators
	79	to one operator with a varying number of arguments. This improved the speed
80	80	for forward and reverse mode computations of an optimized tape.
81	81
82	82	$head 12-18$$

98	98
99	99	$head 12-02$$
100	100	Fix minor grammatical error in the Purpose heading
101		for $cref/conditional expressions/CondExp/Purpose/$$.
102		$pre
103
104		$$
105		Add the following functions:
	101	for $cref/conditional expressions/CondExp/Purpose/$$.
	102	$pre
	103
	104	$$
	105	Add the following functions:
106	106	$cref/size_op/seq_property/size_op/$$,
107	107	$cref/size_op_arg/seq_property/size_op_arg/$$,
108	108	and
109	109	$cref/size_op_seq/seq_property/size_op_seq/$$.
110		In addition, improve and extend the
111		$cref seq_property.cpp$$ example.
	110	In addition, improve and extend the
	111	$cref seq_property.cpp$$ example.
112	112
113	113	$head 11-28$$
114	114	Fix bug in tape optimization with $cref VecAD$$ objects.

128	128	Add the speed testing problem $code ipopt_cppad/ipopt_ode_speed.cpp$$.
129	129
130	130	$head 10-29$$
131		Split out the
	131	Split out the
132	132	$cref/ode inverse problem/ipopt_nlp_ode_problem/$$,
133	133	$cref/its simple representation/ipopt_nlp_ode_simple/$$,
134	134	and

137	137	$cref ipopt_nlp_ode_problem.hpp$$,
138	138	$cref ipopt_nlp_ode_simple.hpp$$,
139	139	$cref ipopt_nlp_ode_fast.hpp$$,
140		and
	140	and
141	141	$cref ipopt_nlp_ode_check.cpp$$.
142	142
143	143	$head 10-28$$
144		Improve the documentation for $cref ipopt_nlp_ode_simple$$ and
	144	Improve the documentation for $cref ipopt_nlp_ode_simple$$ and
145	145	$cref ipopt_nlp_ode_fast$$.
146	146
147	147	$head 10-27$$
148	148	Moved old $code ipopt_cppad_simple.cpp$$ to $cref ipopt_nlp_get_started.cpp$$,
149	149	created the example $cref ipopt_nlp_ode_simple.hpp$$,
150		and split and $code ipopt_cppad_ode.cpp$$
	150	and split and $code ipopt_cppad_ode.cpp$$
151	151	into $cref ipopt_nlp_ode_fast.hpp$$ and $cref ipopt_nlp_ode_check.cpp$$.
152	152
153	153	$head 10-24$$
154	154	Added the $cref/assignment operator/FunConstruct/Assignment Operator/$$
155	155	to the $code ADFun$$ object class.
156		This makes a copy of the entire operation sequence in another
	156	This makes a copy of the entire operation sequence in another
157	157	function object.
158	158	The intention is that the two functions objects can do calculations in
159	159	parallel.
160	160	In addition,
161		CppAD now check for the $code ADFun$$
	161	CppAD now check for the $code ADFun$$
162	162	$cref/copy constructor/FunConstruct/Copy Constructor/$$
163	163	and generates an error message if it is used.
164	164

191	191	(see $cref/sparsity patterns/glossary/Sparsity Pattern/$$).
192	192
193	193	$head 10-03$$
194		The Microsoft Visual Studio project files for
	194	The Microsoft Visual Studio project files for
195	195	examples and testing
196	196	and for
197	197	more correctness testing

211	211
212	212	$head 09-28$$
213	213	Changed $cref RevSparseHes$$ so that it uses a sparse
214		representation when the corresponding call to
	214	representation when the corresponding call to
215	215	$cref ForSparseJac$$ used a sparse representation.
216		This should have been included with the change on 09-26
	216	This should have been included with the change on 09-26
217	217	because Hessian sparsity patters after $code ForSparseJac$$
218	218	with $icode packed$$ did not work.
219	219	Thus, this could be considered a bug fix.

222	222	Added the $code packed$$ parameter to
223	223	$cref ForSparseJac$$ and $cref RevSparseJac$$.
224	224	If $icode packed$$ is false,
225		a sparse instead of packed representation is used
	225	a sparse instead of packed representation is used
226	226	during the calculations of sparsity patterns.
227	227	The sparse representation
228	228	should be faster, and use less memory, for very large sparse Jacobians.

236	236	that included use of $cref VecAD$$ objects.
237	237
238	238	$head 09-19$$
239		Some more memory allocation improvements (related to those
240		on 09-18) were made.
	239	Some more memory allocation improvements (related to those
	240	on 09-18) were made.
241	241
242	242	$head 09-18$$
243	243	A bug was found in all the $cref/Sparsity/Sparse/$$ calculations.

257	257	Add an option to $cref optimize$$ an operation sequence.
258	258	$pre
259	259
260		$$
261		$bold Begin Merge$$
262		$pre
263		$$
264		of changes from the directory $code branches/optimize$$
	260	$$
	261	$bold Begin Merge$$
	262	$pre
	263	$$
	264	of changes from the directory $code branches/optimize$$
265	265	in the CppAD subversion repository.
266		The subheading dates below represent when the correspond change was made in
	266	The subheading dates below represent when the correspond change was made in
267	267	$code branches/optimize$$.
268	268
269	269	$subhead 08-13$$
270	270	An automatic check of the $cref forward_zero$$ results was added
271	271	after each call to $cref/f.optimize()/optimize/$$
272		(this $cref/check/optimize/Checking Optimization/$$
	272	(this $cref/check/optimize/Checking Optimization/$$
273	273	is skipped when $code NDEBUG$$ is defined).
274	274	In addition, all of the $codei%speed/cppad/%*%.cpp%$$ tests
275	275	now check and use the speed test

291	291	$pre
292	292
293	293	$$
294		The function
	294	The function
295	295	$cref/size_VecAD/seq_property/size_VecAD/$$ function was added
296		so that the user could see the $code VecAD$$ vectors
	296	so that the user could see the $code VecAD$$ vectors
297	297	and elements corresponding to an operation sequence.
298	298
299	299	$subhead 08-09$$

309	309	$head 08-06$$
310	310	Add hash table coding to reduce the number of copies of the same
311	311	parameter value necessary in a tape recording.
312		In addition, add the function
	312	In addition, add the function
313	313	$cref/size_par/seq_property/size_par/$$ was added
314	314	so that the user could see the number of parameters
315	315	corresponding to an operation sequence.

320	320	$pre
321	321
322	322	$$
323		Fix bug in overnight build where HTML version and entire documentation
	323	Fix bug in overnight build where HTML version and entire documentation
324	324	as one page versions of documentation were not being built.
325	325	$pre
326	326
327	327	$$
328		Fix missing new line under
	328	Fix missing new line under
329	329	$cref/Using Value/SimpleVector/Element Access/Using Value/$$
330	330	heading for simple vector documentation.
331	331
332	332	$head 08-01$$
333	333	Fix bug in reverse mode Jacobian $cref/sparsity/RevSparseJac/$$
334		for $cref VecAD$$ objects.
	334	for $cref VecAD$$ objects.
335	335
336	336	$head 07-31$$
337	337	The $cref/forward/ForSparseJac/$$ and $cref/reverse/RevSparseJac/$$

355	355	$pre
356	356
357	357	$$
358		Improve the $cref vec_ad.cpp$$ user example.
	358	Improve the $cref vec_ad.cpp$$ user example.
359	359
360	360	$subhead 07-06$$
361	361	Fixed a bug in second or higher order reverse mode calculations

366	366
367	367	$$
368	368	Add developer documentation for tape evaluation of the
369		VecAD load operations
	369	VecAD load operations
370	370	(a load operation accesses an element of the vector but
371	371	does not change it.)
372	372	$pre
373	373
374	374	$$
375		Fix $code isnan$$ undefined in $code example/cond_exp.cpp$$ error
	375	Fix $code isnan$$ undefined in $code example/cond_exp.cpp$$ error
376	376	introduced on 07-04 change.
377	377
378	378	$head 07-04$$

380	380	$cref CompareChange$$ operations during tape evaluation.
381	381	$pre
382	382
383		$$
384		$bold Begin Merge$$
385		$pre
386		$$
387		of changes from the directory $code branches/sweep$$
	383	$$
	384	$bold Begin Merge$$
	385	$pre
	386	$$
	387	of changes from the directory $code branches/sweep$$
388	388	in the CppAD subversion repository.
389		The subheading dates below represent when the correspond change was made in
	389	The subheading dates below represent when the correspond change was made in
390	390	$code branches/sweep$$.
391	391
392	392	$subhead 07-04$$

398	398
399	399	$$
400	400	A simpler and useful example was provided for
401		$cref/conditional expressions/CondExp/$$;
	401	$cref/conditional expressions/CondExp/$$;
402	402	see $cref cond_exp.cpp$$.
403	403
404	404
405	405	$subhead 07-03$$
406		Some minor improvements were made to the documentation for
	406	Some minor improvements were made to the documentation for
407	407	$cref CondExp$$.
408	408	To be specific, a newer OMhelp option was used to change the formatting
409	409	of the syntax, some of the argument names were changed to be more descriptive.
410	410
411	411	$subhead 07-02$$
412		Add developer doxygen documentation of
	412	Add developer doxygen documentation of
413	413	tape evaluation for power (exponentiation) operators.
414	414
415	415	$subhead 07-01$$
416		Fix an example indexing error in
	416	Fix an example indexing error in
417	417	$code introduction/exp_apx/exp_eps_for2.cpp$$ (found by valgrind).
418	418	$pre
419	419
420	420	$$
421		Add developer doxygen documentation of
	421	Add developer doxygen documentation of
422	422	tape evaluation for multiplication and division operators.
423	423
424	424	$subhead 06-30$$
425		Add developer doxygen documentation of
	425	Add developer doxygen documentation of
426	426	tape evaluation for addition and subtraction operators.
427	427
428	428	$subhead 06-29$$
429		Add developer doxygen documentation of
	429	Add developer doxygen documentation of
430	430	tape evaluation for sin, sinh, cos, and cosh.
431	431
432	432	$subhead 06-28$$
433		Add developer doxygen documentation of
	433	Add developer doxygen documentation of
434	434	tape evaluation for atan, asin, acos, sqrt, log.
435	435	$pre
436	436	$$
437	437	$bold End Merge$$
438	438
439	439	$head 06-25$$
440		The tarball for most recent release (of the subversion trunk for CppAD)
441		was not being placed in the
442		$href%http://www.coin-or.org/download/source/CppAD/%download%$$
443		directory.
	440	The tarball for most recent release (of the subversion trunk for CppAD)
	441	was not being placed in the
	442	$href%http://www.coin-or.org/download/source/CppAD/%download%$$
	443	directory.
444	444	This has been fixed.
445	445
446	446	$head 06-22$$

465	465
466	466	$$
467	467	Fix conflict between CppAD's use of config.h preprocessor symbols
468		and other packages use of the same symbol names.
	468	and other packages use of the same symbol names.
469	469
470	470	$head 06-06$$
471	471	$list number$$
472	472	Using complex of an AD type (instead of AD of complex) was not working
473		correctly in $code not_complex_ad.cpp$$ because the
	473	correctly in $code not_complex_ad.cpp$$ because the
474	474	$cref/default constructor/ad_ctor/$$ for an AD object has an unspecified value.
475	475	This has been fixed for the complex type by changing the default constructor
476		to use value zero.
477		(The $code not_complex_ad.cpp$$ example has been removed;
	476	to use value zero.
	477	(The $code not_complex_ad.cpp$$ example has been removed;
478	478	see $cref/complex FAQ/Faq/Complex Types/$$.)
479	479	$lnext
480	480	Fixing the $code not_complex_ad.cpp$$ problem above also fixed a warning

482	482	Now $code valgrind$$ runs the CppAD $code example/example$$ program
483	483	with out any warning or error messages.
484	484	In addition, a minor initialization error was fixed in the
485		$code test_more/jacobian.cpp$$ routine so now
	485	$code test_more/jacobian.cpp$$ routine so now
486	486	$code valgrind$$ also runs the CppAD $code test_more/test_more$$ program
487	487	with out any warnings or error messages.
488	488	$lend

493	493	This was has been fixed (revision 1362).
494	494
495	495	$head 03-24$$
496		Added cross references in
	496	Added cross references in
497	497	the $cref/examples/ListAllExamples/$$ to occurrence of the following tokens:
498	498	$cref AD$$,
499	499	$cref/ADFun/FunConstruct/$$,

528	528
529	529	$head 01-18$$
530	530	Sometimes an error occurs while taping AD operations.
531		The $cref abort_recording$$ function has been added
	531	The $cref abort_recording$$ function has been added
532	532	to make it easier to recover in such cases.
533	533	$pre
534	534

542	542	$pre
543	543
544	544	$$
545		A discussion has been added to the documentation for $cref Jacobian$$
	545	A discussion has been added to the documentation for $cref Jacobian$$
546	546	about its use of
547	547	$cref/forward or reverse/Jacobian/Forward or Reverse/$$
548	548	mode depending on which it estimates is more efficient.

551	551	$$
552	552	A minor typo has been fixed in the description of
553	553	$code W(t, u)$$ in $cref reverse_any$$.
554		To be specific,
	554	To be specific,
555	555	$latex o ( t^{p-1} ) * t^{1-p} \rightarrow 0$$
556	556	has been replaced by
557	557	$latex o ( t^{p-1} ) / t^{1-p} \rightarrow 0$$.

+4

-4

print_for/makefile.am less more

0		# $Id: makefile.am 2541 2012-11-06 16:32:36Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

24	24	endif
25	25	#
26	26	# Microsoft project files
27		EXTRA_DIST = test.sh
	27	EXTRA_DIST = test.sh
28	28	#
29	29	check_PROGRAMS = print_for
30	30	#

+2

-2

speed/adolc/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3754 2015-11-26 22:23:05Z bradbell $
	0	# $Id: CMakeLists.txt 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

47	47	# List of libraries to be linked into the specified target
48	48	TARGET_LINK_LIBRARIES(speed_adolc
49	49	speed_src
50		cppad_lib
	50	${cppad_lib}
51	51	adolc
52	52	${colpack_libs}
53	53	)

+4

-4

speed/adolc/makefile.am less more

0		# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

18	18	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
19	19	DEFS =
20	20	#
21		check_PROGRAMS = speed_adolc
	21	check_PROGRAMS = speed_adolc
22	22	#
23	23	AM_CPPFLAGS = \
24	24	-I$(top_srcdir) \

+2

-2

speed/cppad/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3754 2015-11-26 22:23:05Z bradbell $
	0	# $Id: CMakeLists.txt 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

39	39	# List of libraries to be linked into the specified target
40	40	TARGET_LINK_LIBRARIES(speed_cppad
41	41	speed_src
42		cppad_lib
	42	${cppad_lib}
43	43	${colpack_libs}
44	44	)
45	45

+4

-4

speed/cppad/makefile.am less more

0		# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

17	17	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
18	18	DEFS =
19	19	#
20		check_PROGRAMS = speed_cppad
	20	check_PROGRAMS = speed_cppad
21	21	#
22	22	AM_CPPFLAGS = -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
23	23	#

+4

-4

speed/double/makefile.am less more

0		# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

17	17	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
18	18	DEFS =
19	19	#
20		check_PROGRAMS = speed_double
	20	check_PROGRAMS = speed_double
21	21	#
22	22	AM_CPPFLAGS = -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
23	23	#

+5

-5

speed/example/makefile.am less more

0		# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

16	16	EXTRA_DIST = \
17	17	speed_program.cpp
18	18	#
19		check_PROGRAMS = speed_example
	19	check_PROGRAMS = speed_example
20	20	#
21	21	AM_CPPFLAGS = -I. -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
22	22	#

36	36	sparse_jac_fun.cpp \
37	37	speed_test.cpp \
38	38	time_test.cpp \
39		../src/microsoft_timer.cpp
	39	../src/microsoft_timer.cpp
40	40
41	41	test: check
42	42	./speed_example

+4

-4

speed/fadbad/makefile.am less more

0		# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

18	18	# CppAD pusts all it's preprocessor definitions in the cppad/configure.hpp
19	19	DEFS =
20	20	#
21		check_PROGRAMS = speed_fadbad
	21	check_PROGRAMS = speed_fadbad
22	22	#
23	23	AM_CPPFLAGS = \
24	24	-I$(top_srcdir) \

+2

-2

speed/profile/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3754 2015-11-26 22:23:05Z bradbell $
	0	# $Id: CMakeLists.txt 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

50	50	# profile builds it own copy of src/speed library (see ADD_EXECUTABLE above)
51	51	# TARGET_LINK_LIBRARIES(speed_profile speed_src )
52	52	TARGET_LINK_LIBRARIES(speed_profile
53		cppad_lib
	53	${cppad_lib}
54	54	${colpack_libs}
55	55	)
56	56

+4

-4

speed/profile/makefile.am less more

0		# $Id: makefile.am 3481 2014-12-17 23:39:47Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

68	68	EXTRA_DIST = \
69	69	gprof.sed
70	70	#
71		check_PROGRAMS = speed_profile
	71	check_PROGRAMS = speed_profile
72	72	#
73	73	AM_CPPFLAGS = -I$(top_srcdir) $(BOOST_INCLUDE) $(EIGEN_INCLUDE)
74	74	#

+4

-4

speed/src/makefile.am less more

0		# $Id: makefile.am 2529 2012-10-31 17:37:50Z bradbell $
	0	# $Id: makefile.am 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2		# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#
4	4	# CppAD is distributed under multiple licenses. This distribution is under
5		# the terms of the
	5	# the terms of the
6	6	# GNU General Public License Version 3.
7	7	#
8	8	# A copy of this license is included in the COPYING file of this distribution.

18	18	# END OPTIMIZE
19	19	#
20	20	# BEGIN DEBUG
21		# AM_CXXFLAGS = -g $(CXX_FLAGS)
	21	# AM_CXXFLAGS = -g $(CXX_FLAGS)
22	22	# END DEBUG
23	23	#
24	24	AM_CPPFLAGS = \

+2

-2

test_more/CMakeLists.txt less more

0		# $Id: CMakeLists.txt 3768 2015-12-28 18:58:35Z bradbell $
	0	# $Id: CMakeLists.txt 3785 2016-02-08 12:53:06Z bradbell $
1	1	# -----------------------------------------------------------------------------
2	2	# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3	#

160	160
161	161	# List of libraries to be linked into the specified target
162	162	TARGET_LINK_LIBRARIES(test_more
163		cppad_lib
	163	${cppad_lib}
164	164	${adolc_libs}
165	165	${ipopt_libs}
166	166	${eigen_libs}

+3

-3

test_more/abs.cpp less more

0		/* $Id: abs.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: abs.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

+14

-14

test_more/add.cpp less more

0		/* $Id: add.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: add.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

39	39	// dependent variable values
40	40	Z[x] = U[s] + U[t]; // AD<double> + AD<double>
41	41	Z[y] = Z[x] + 1.; // AD<double> + double
42		Z[z] = 1. + Z[y]; // double + AD<double>
	42	Z[z] = 1. + Z[y]; // double + AD<double>
43	43
44	44	// create f: U -> Z and vectors used for derivative calculations
45	45	ADFun<double> f(U, Z);

79	79	// independent variable vector
80	80	double u0 = .5;
81	81	CPPAD_TESTVECTOR(AD<double>) U(1);
82		U[0] = u0;
	82	U[0] = u0;
83	83	Independent(U);
84	84
85	85	AD<double> a = U[0] + 1.; // AD<double> + double
86	86	AD<double> b = a + 2; // AD<double> + int
87		AD<double> c = 3. + b; // double + AD<double>
88		AD<double> d = 4 + c; // int + AD<double>
	87	AD<double> c = 3. + b; // double + AD<double>
	88	AD<double> d = 4 + c; // int + AD<double>
89	89
90		// dependent variable vector
	90	// dependent variable vector
91	91	CPPAD_TESTVECTOR(AD<double>) Z(1);
92		Z[0] = d + U[0]; // AD<double> + AD<double>
	92	Z[0] = d + U[0]; // AD<double> + AD<double>
93	93
94	94	// create f: U -> Z and vectors used for derivative calculations
95		ADFun<double> f(U, Z);
	95	ADFun<double> f(U, Z);
96	96	CPPAD_TESTVECTOR(double) v(1);
97	97	CPPAD_TESTVECTOR(double) w(1);
98	98
99		// check value
	99	// check value
100	100	ok &= NearEqual(Z[0] , 2 * u0 + 10, 1e-10 , 1e-10);
101	101
102	102	// forward computation of partials w.r.t. u

107	107	v[0] = 1.;
108	108	for(j = 1; j < p; j++)
109	109	{ jfac *= j;
110		w = f.Forward(j, v);
	110	w = f.Forward(j, v);
111	111	ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
112	112	v[0] = 0.;
113	113	value = 0.;
114	114	}
115	115
116	116	// reverse computation of partials of Taylor coefficients
117		CPPAD_TESTVECTOR(double) r(p);
	117	CPPAD_TESTVECTOR(double) r(p);
118	118	w[0] = 1.;
119	119	r = f.Reverse(p, w);
120	120	jfac = 1.;

133	133	bool Add(void)
134	134	{ bool ok = true;
135	135	ok &= AddTestOne();
136		ok &= AddTestTwo();
	136	ok &= AddTestTwo();
137	137	return ok;
138	138	}

+11

-11

test_more/add_eq.cpp less more

0		/* $Id: add_eq.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: add_eq.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

40	40	Z[y] = U[t];
41	41	Z[x] += U[s]; // parameter += variable
42	42	Z[x] += U[t]; // variable += variable
43		Z[y] += .5; // variable += double
	43	Z[y] += .5; // variable += double
44	44	// use .5 because it is represented exactly in binary and
45	45	// because it makes sure that += does not slice the double to an int
46	46

79	79	// independent variable vector
80	80	double u0 = .5;
81	81	CPPAD_TESTVECTOR(AD<double>) U(1);
82		U[0] = u0;
	82	U[0] = u0;
83	83	Independent(U);
84	84
85		// dependent variable vector
	85	// dependent variable vector
86	86	CPPAD_TESTVECTOR(AD<double>) Z(1);
87	87	Z[0] = U[0]; // initial value
88	88	Z[0] += 2; // AD<double> += int
89	89	Z[0] += 4.; // AD<double> += double
90		Z[0] += U[0]; // AD<double> += AD<double>
	90	Z[0] += U[0]; // AD<double> += AD<double>
91	91
92	92	// create f: U -> Z and vectors used for derivative calculations
93		ADFun<double> f(U, Z);
	93	ADFun<double> f(U, Z);
94	94	CPPAD_TESTVECTOR(double) v(1);
95	95	CPPAD_TESTVECTOR(double) w(1);
96	96
97		// check value
	97	// check value
98	98	ok &= NearEqual(Z[0] , u0+2+4+u0, 1e-10 , 1e-10);
99	99
100	100	// forward computation of partials w.r.t. u

105	105	v[0] = 1.;
106	106	for(j = 1; j < p; j++)
107	107	{ jfac *= j;
108		w = f.Forward(j, v);
	108	w = f.Forward(j, v);
109	109	ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
110	110	v[0] = 0.;
111	111	value = 0.;
112	112	}
113	113
114	114	// reverse computation of partials of Taylor coefficients
115		CPPAD_TESTVECTOR(double) r(p);
	115	CPPAD_TESTVECTOR(double) r(p);
116	116	w[0] = 1.;
117	117	r = f.Reverse(p, w);
118	118	jfac = 1.;

+4

-4

test_more/add_zero.cpp less more

0		/* $Id: add_zero.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: add_zero.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

19	19	typedef CppAD::AD< ADdouble > ADDdouble;
20	20
21	21	bool AddZero(void)
22		{
	22	{
23	23	using namespace CppAD;
24	24
25	25	bool ok = true;

+3

-3

test_more/adfun_copy.cpp less more

0		/* $Id: adfun_copy.cpp 3519 2014-12-28 16:22:57Z bradbell $ */
	0	// $Id: adfun_copy.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

+7

-7

test_more/alloc_openmp.cpp less more

0		/* $Id: alloc_openmp.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: alloc_openmp.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

46	46	// Test routine called by the master thread (thread_num = 0).
47	47	bool alloc_openmp(void)
48	48	{ bool ok = true;
49
	49
50	50	int num_threads = NUMBER_THREADS;
51	51
52	52	// call setup for using thread_alloc in parallel mode.
53	53	thread_alloc::parallel_setup(
54	54	size_t(num_threads), in_parallel, thread_number
55	55	);
56
	56
57	57	// Execute the worker function in parallel
58	58	int thread_num;
59	59	# pragma omp parallel for
60	60	for(thread_num = 0; thread_num < num_threads; thread_num++)
61	61	worker();
62	62	// end omp parallel for
63
	63
64	64	// now inform CppAD that there is only one thread
65	65	thread_alloc::parallel_setup(1, CPPAD_NULL, CPPAD_NULL);
66	66

68	68	{ // check calculations by this thread in parallel model
69	69	ok &= thread_all_[thread_num].x[0] == static_cast<double>(thread_num);
70	70
71		// test having master thread (thread number zero)
	71	// test having master thread (thread number zero)
72	72	// free memory that was allocated by thread number thread_num.
73	73	thread_all_[thread_num].x.clear();
74	74	}

+7

-7

test_more/assign.cpp less more

0		/* $Id: assign.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: assign.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

27	27
28	28	// declare independent variables and start tape recording
29	29	CppAD::Independent(x);
30
31		// range space vector
	30
	31	// range space vector
32	32	size_t m = 3;
33	33	CPPAD_TESTVECTOR(AD<double>) y(m);
34	34
35	35	// assign an AD<Base> object equal to an independent variable
36	36	// (choose the first independent variable to check a special case)
37	37	// use the value returned by the assignment (for another assignment)
38		y[0] = y[1] = x[0];
	38	y[0] = y[1] = x[0];
39	39
40		// assign an AD<Base> object equal to an expression
	40	// assign an AD<Base> object equal to an expression
41	41	y[1] = x[1] + 1.;
42	42	y[2] = x[2] + 2.;
43	43

+9

-9

test_more/atan2.cpp less more

0		/* $Id: atan2.cpp 3083 2014-01-10 18:35:07Z bradbell $ */
	0	// $Id: atan2.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

44	44
45	45	// a temporary values
46	46	AD<double> x = cos(U[0]);
47		AD<double> y = sin(U[0]);
	47	AD<double> y = sin(U[0]);
48	48
49		// dependent variable vector
	49	// dependent variable vector
50	50	CPPAD_TESTVECTOR(AD<double>) Z(1);
51		Z[0] = atan2(y, x);
	51	Z[0] = atan2(y, x);
52	52
53	53	// create f: U -> Z and vectors used for derivative calculations
54		ADFun<double> f(U, Z);
	54	ADFun<double> f(U, Z);
55	55	CPPAD_TESTVECTOR(double) v(1);
56	56	CPPAD_TESTVECTOR(double) w(1);
57	57

81	81	v[0] = 1.;
82	82	for(j = 1; j < p; j++)
83	83	{ jfac *= j;
84		w = f.Forward(j, v);
	84	w = f.Forward(j, v);
85	85	ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
86	86	v[0] = 0.;
87	87	value = 0.;
88	88	}
89	89
90	90	// reverse computation of partials of Taylor coefficients
91		CPPAD_TESTVECTOR(double) r(p);
	91	CPPAD_TESTVECTOR(double) r(p);
92	92	w[0] = 1.;
93	93	r = f.Reverse(p, w);
94	94	jfac = 1.;

+5

-5

test_more/base_adolc.cpp less more

0		/* $Id: base_adolc.cpp 2794 2013-05-02 08:20:30Z bradbell $ */
	0	// $Id: base_adolc.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 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	# include <adolc/taping.h>
13	13	# include <adolc/interfaces.h>
14	14
15		// adouble definitions not in Adolc distribution and
	15	// adouble definitions not in Adolc distribution and
16	16	// required in order to use CppAD::AD<adouble>
17	17	# include <cppad/example/base_adolc.hpp>
18	18
19	19	# include <cppad/cppad.hpp>
20	20
21		bool base_adolc(void)
	21	bool base_adolc(void)
22	22	{ bool ok = true; // initialize test result
23	23
24	24	typedef adouble ADdouble; // for first level of taping

38	38	for(j = 0; j < n; j++)
39	39	aa_x[j] = a_x[j]; // track how aa_x depends on a_x
40	40	CppAD::Independent(aa_x); // aa_x is independent for ADDdouble
41
	41
42	42
43	43	// compute function
44	44	size_t m = 5;

+3

-3

test_more/base_alloc.cpp less more

0		/* $Id: base_alloc.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: base_alloc.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 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	size_t i, N = 50;
29	29	for(i = 0; i < N; i++)
30	30	a_y[0] += double(i);
31
	31
32	32	CppAD::ADFun<base_alloc> f(a_x, a_y);
33	33
34	34	return ok;

+4

-4

test_more/check_simple_vector.cpp less more

0		/* $Id: check_simple_vector.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: check_simple_vector.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

18	18	template <class Scalar>
19	19	void Case(const Scalar& x, const Scalar& y)
20	20	{ using CppAD::CheckSimpleVector;
21
	21
22	22	CheckSimpleVector<Scalar, CppAD::vector<Scalar> > (x, y);
23	23	CheckSimpleVector<Scalar, std::vector<Scalar> > (x, y);
24	24	CheckSimpleVector<Scalar, std::valarray<Scalar> > (x, y);

+38

-38

test_more/compare.cpp less more

0		/* $Id: compare.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: compare.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

14	14	*/
15	15	# include <cppad/cppad.hpp>
16	16
17		namespace {
	17	namespace {
18	18	template <class Type>
19	19	bool Compare(void)
20	20	{ bool ok = true;
21	21	using CppAD::AD;
22
	22
23	23	Type middle = 4;
24	24	AD<double> three = 3;
25	25	AD<double> four = 4;
26	26	AD<double> five = 5;
27
	27
28	28	// AD<double> > Type
29		ok &= ! (three > middle);
30		ok &= ! (four > middle);
31		ok &= (five > middle);
32		// Type > AD<double>
33		ok &= (middle > three );
34		ok &= ! (middle > four );
35		ok &= ! (middle > five );
36
	29	ok &= ! (three > middle);
	30	ok &= ! (four > middle);
	31	ok &= (five > middle);
	32	// Type > AD<double>
	33	ok &= (middle > three );
	34	ok &= ! (middle > four );
	35	ok &= ! (middle > five );
	36
37	37	// AD<double> >= Type
38		ok &= ! (three >= middle);
39		ok &= (four >= middle);
40		ok &= (five >= middle);
41		// Type > AD<double>
42		ok &= (middle >= three );
43		ok &= (middle >= four );
44		ok &= ! (middle >= five );
45
	38	ok &= ! (three >= middle);
	39	ok &= (four >= middle);
	40	ok &= (five >= middle);
	41	// Type > AD<double>
	42	ok &= (middle >= three );
	43	ok &= (middle >= four );
	44	ok &= ! (middle >= five );
	45
46	46	// AD<double> < Type
47		ok &= (three < middle);
48		ok &= ! (four < middle);
49		ok &= ! (five < middle);
50		// Type > AD<double>
51		ok &= ! (middle < three );
52		ok &= ! (middle < four );
53		ok &= (middle < five );
54
	47	ok &= (three < middle);
	48	ok &= ! (four < middle);
	49	ok &= ! (five < middle);
	50	// Type > AD<double>
	51	ok &= ! (middle < three );
	52	ok &= ! (middle < four );
	53	ok &= (middle < five );
	54
55	55	// AD<double> <= Type
56		ok &= (three <= middle);
57		ok &= (four <= middle);
58		ok &= ! (five <= middle);
59		// Type > AD<double>
60		ok &= ! (middle <= three );
61		ok &= (middle <= four );
62		ok &= (middle <= five );
63
	56	ok &= (three <= middle);
	57	ok &= (four <= middle);
	58	ok &= ! (five <= middle);
	59	// Type > AD<double>
	60	ok &= ! (middle <= three );
	61	ok &= (middle <= four );
	62	ok &= (middle <= five );
	63
64	64	return ok;
65	65	}
66	66	}

+5

-5

test_more/cond_exp_ad.cpp less more

0		/* $Id: cond_exp_ad.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: cond_exp_ad.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

76	76	// create fa: Xaa -> Yaa function object
77	77	ADFun< ADdouble > fa(Xaa, Yaa);
78	78
79		// function values
	79	// function values
80	80	CPPAD_TESTVECTOR( ADdouble ) Ya(m);
81	81	Ya = fa.Forward(0, Xa);
82	82

226	226	// create fa: Xaa -> Yaa function object
227	227	ADFun< ADdouble > fa(Xaa, Yaa);
228	228
229		// function values
	229	// function values
230	230	CPPAD_TESTVECTOR( ADdouble ) Ya(m);
231	231	Ya = fa.Forward(0, Xa);
232	232

+9

-9

test_more/cos.cpp less more

0		/* $Id: cos.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: cos.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

26	26	U[0] = 1.;
27	27	Independent(U);
28	28
29		// dependent variable vector
	29	// dependent variable vector
30	30	CPPAD_TESTVECTOR(AD<double>) Z(1);
31		Z[0] = cos(U[0]);
	31	Z[0] = cos(U[0]);
32	32
33	33	// create f: U -> Z and vectors used for derivative calculations
34		ADFun<double> f(U, Z);
	34	ADFun<double> f(U, Z);
35	35	CPPAD_TESTVECTOR(double) v(1);
36	36	CPPAD_TESTVECTOR(double) w(1);
37	37
38		// check value
	38	// check value
39	39	double sin_u = sin( Value(U[0]) );
40	40	double cos_u = cos( Value(U[0]) );
41	41

47	47	double jfac = 1.;
48	48	v[0] = 1.;
49	49	for(j = 1; j < p; j++)
50		{ w = f.Forward(j, v);
	50	{ w = f.Forward(j, v);
51	51
52	52	double value;
53	53	if( j % 4 == 1 )

64	64	}
65	65
66	66	// reverse computation of partials of Taylor coefficients
67		CPPAD_TESTVECTOR(double) r(p);
	67	CPPAD_TESTVECTOR(double) r(p);
68	68	w[0] = 1.;
69	69	r = f.Reverse(p, w);
70	70	jfac = 1.;

+9

-9

test_more/cosh.cpp less more

0		/* $Id: cosh.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: cosh.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

26	26	U[0] = 1.;
27	27	Independent(U);
28	28
29		// dependent variable vector
	29	// dependent variable vector
30	30	CPPAD_TESTVECTOR(AD<double>) Z(1);
31		Z[0] = cosh(U[0]);
	31	Z[0] = cosh(U[0]);
32	32
33	33	// create f: U -> Z and vectors used for derivative calculations
34		ADFun<double> f(U, Z);
	34	ADFun<double> f(U, Z);
35	35	CPPAD_TESTVECTOR(double) v(1);
36	36	CPPAD_TESTVECTOR(double) w(1);
37	37
38		// check value
	38	// check value
39	39	double sinh_u = sinh( Value(U[0]) );
40	40	double cosh_u = cosh( Value(U[0]) );
41	41

47	47	double jfac = 1.;
48	48	v[0] = 1.;
49	49	for(j = 1; j < p; j++)
50		{ w = f.Forward(j, v);
	50	{ w = f.Forward(j, v);
51	51
52	52	double value;
53	53	if( j % 2 == 1 )

60	60	}
61	61
62	62	// reverse computation of partials of Taylor coefficients
63		CPPAD_TESTVECTOR(double) r(p);
	63	CPPAD_TESTVECTOR(double) r(p);
64	64	w[0] = 1.;
65	65	r = f.Reverse(p, w);
66	66	jfac = 1.;

+4

-4

test_more/dbl_epsilon.cpp less more

0		/* $Id: dbl_epsilon.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: dbl_epsilon.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-08 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

10	10	-------------------------------------------------------------------------- */
11	11
12	12	/*
13		Check the value of machine epsilon is accurate enough for the correctness tests
	13	Check the value of machine epsilon is accurate enough for the correctness tests
14	14	*/
15	15
16	16	# include <cfloat>

+4

-4

test_more/div_zero_one.cpp less more

0		/* $Id: div_zero_one.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: div_zero_one.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

19	19	typedef CppAD::AD< ADdouble > ADDdouble;
20	20
21	21	bool DivZeroOne(void)
22		{
	22	{
23	23	using namespace CppAD;
24	24
25	25	bool ok = true;

+17

-17

test_more/exp.cpp less more

0		/* $Id: exp.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: exp.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

58	58	v = f.Reverse(1,w);
59	59	ok &= NearEqual(v[s], Z[y] * Z[x], 1e-10 , 1e-10); // dy/ds
60	60
61		// forward computation of second partials w.r.t s
	61	// forward computation of second partials w.r.t s
62	62	v[s] = 1.;
63	63	w = f.Forward(1, v);
64	64	v[s] = 0.;
65	65	w = f.Forward(2, v);
66	66	ok &= NearEqual( // d^2 y / (ds ds)
67		2. * w[y] ,
	67	2. * w[y] ,
68	68	Z[y] * Z[x] * Z[x] + Z[y] * Z[x],
69	69	1e-10 ,
70		1e-10
71		);
	70	1e-10
	71	);
72	72
73	73	// reverse computation of second partials of y
74	74	CPPAD_TESTVECTOR(double) r( f.Domain() * 2 );

76	76	w[y] = 1.;
77	77	r = f.Reverse(2, w);
78	78	ok &= NearEqual( // d^2 y / (ds ds)
79		r[2 * s + 1] ,
	79	r[2 * s + 1] ,
80	80	Z[y] * Z[x] * Z[x] + Z[y] * Z[x],
81	81	1e-10 ,
82		1e-10
83		);
	82	1e-10
	83	);
84	84
85	85	return ok;
86	86	}

95	95	U[0] = 1.;
96	96	Independent(U);
97	97
98		// dependent variable vector
	98	// dependent variable vector
99	99	CPPAD_TESTVECTOR(AD<double>) Z(1);
100		Z[0] = exp(U[0]);
	100	Z[0] = exp(U[0]);
101	101
102	102	// create f: U -> Z and vectors used for derivative calculations
103		ADFun<double> f(U, Z);
	103	ADFun<double> f(U, Z);
104	104	CPPAD_TESTVECTOR(double) v(1);
105	105	CPPAD_TESTVECTOR(double) w(1);
106	106
107		// check value
	107	// check value
108	108	double exp_u = exp( Value(U[0]) );
109	109	ok &= NearEqual(exp_u, Value(Z[0]), 1e-10 , 1e-10);
110	110

114	114	double jfac = 1.;
115	115	v[0] = 1.;
116	116	for(j = 1; j < p; j++)
117		{ w = f.Forward(j, v);
	117	{ w = f.Forward(j, v);
118	118	jfac *= j;
119	119	ok &= NearEqual(jfac*w[0], exp_u, 1e-10 , 1e-10); // d^jz/du^j
120	120	v[0] = 0.;
121	121	}
122	122
123	123	// reverse computation of partials of Taylor coefficients
124		CPPAD_TESTVECTOR(double) r(p);
	124	CPPAD_TESTVECTOR(double) r(p);
125	125	w[0] = 1.;
126	126	r = f.Reverse(p, w);
127	127	jfac = 1.;

138	138	bool Exp(void)
139	139	{ bool ok = true;
140	140	ok &= ExpTestOne();
141		ok &= ExpTestTwo();
	141	ok &= ExpTestTwo();
142	142	return ok;
143	143	}

+6

-6

test_more/extern_value.cpp less more

0		/* $Id: extern_value.cpp 2756 2013-02-27 18:49:28Z bradbell $ */
	0	// $Id: extern_value.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

14	14
15	15	# define INSTANTIATE(Type) template class extern_value< Type >
16	16
17		template <class Type>
	17	template <class Type>
18	18	extern_value<Type>::extern_value(Type value)
19	19	{ value_ = value; }
20	20
21		template <class Type>
	21	template <class Type>
22	22	void extern_value<Type>::set(Type value)
23	23	{ value_ = value; }
24	24
25		template <class Type>
	25	template <class Type>
26	26	Type extern_value<Type>::get(void)
27	27	{ return value_; }
28	28

+6

-6

test_more/for_hess.cpp less more

0		/* $Id: for_hess.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: for_hess.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

37	37	// define the function
38	38	CPPAD_TESTVECTOR(AD<double>) Y(2);
39	39	Y[0] = U[0] * exp( U[1] );
40		Y[1] = U[1] * sin( U[2] );
	40	Y[1] = U[1] * sin( U[2] );
41	41
42	42	// create the function y = F(u)
43	43	ADFun<double> F(U, Y);
44	44
45		// formulas for the upper triangle of Hessian of F_0
	45	// formulas for the upper triangle of Hessian of F_0
46	46	CPPAD_TESTVECTOR(double) H0(9);
47	47	H0[0] = 0.; // d^2 y[0] / d_u[0] d_u[0]
48	48	H0[1] = exp( u0[1] ); // d^2 y[0] / d_u[0] d_u[1]

86	86	F.Forward(1, u1);
87	87	CPPAD_TESTVECTOR(double) Cij = F.Forward(2, u2);
88	88
89		// diagonal of Hessian in j-th coordinate direction
	89	// diagonal of Hessian in j-th coordinate direction
90	90	u1[i] = 0.;
91	91	F.Forward(1, u1);
92	92	CPPAD_TESTVECTOR(double) Dj = F.Forward(2, u2);

+26

-26

test_more/for_sparse_jac.cpp less more

0		/* $Id: for_sparse_jac.cpp 2859 2013-05-28 06:03:21Z bradbell $ */
	0	// $Id: for_sparse_jac.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

74	74	using namespace CppAD;
75	75
76	76	// dimension of the domain space
77		size_t n = 3;
	77	size_t n = 3;
78	78
79	79	// dimension of the range space
80	80	size_t m = (4 + 11 + 1) * 3 + 4;
81	81
82		// independent variable vector
	82	// independent variable vector
83	83	CPPAD_TESTVECTOR(AD<double>) X(n);
84		X[0] = .1;
	84	X[0] = .1;
85	85	X[1] = .2;
86	86	X[2] = .3;
87	87	Independent(X);

165	165	for(i = 0; i < m; i++)
166	166	{ for(j = 0; j < n; j++)
167	167	ok &= (Py[i * n + j] == Check[i * n + j]);
168		}
	168	}
169	169
170	170	// ---------------------------------------------------------
171	171	// dependency matrix for the identity function W(x) = x

186	186	{ found = Sy[i].find(j) != Sy[i].end();
187	187	ok &= (found == Check[i * n + j]);
188	188	}
189		}
	189	}
190	190
191	191	return ok;
192	192	}

196	196	using namespace CppAD;
197	197
198	198	// dimension of the domain space
199		size_t n = 3;
	199	size_t n = 3;
200	200
201	201	// dimension of the range space
202	202	size_t m = 3;

207	207	for(k = 0; k < n-1; k++)
208	208	Z[k] = 0.;
209	209
210		// independent variable vector
	210	// independent variable vector
211	211	CPPAD_TESTVECTOR(AD<double>) X(n);
212		X[0] = 0.;
	212	X[0] = 0.;
213	213	X[1] = 1.;
214	214	X[2] = 2.;
215	215	Independent(X);
216	216
217	217	// VecAD vector is going to depend on X[1] and X[2]
218	218	Z[ X[0] ] = X[1];
219		Z[ X[1] ] = X[2];
	219	Z[ X[1] ] = X[2];
220	220
221	221	// dependent variable vector
222	222	CPPAD_TESTVECTOR(AD<double>) Y(m);

273	273	for(i = 0; i < m; i++)
274	274	{ for(j = 0; j < n; j++)
275	275	ok &= (Py[i * n + j] == Check[i * n + j]);
276		}
	276	}
277	277
278	278	// ---------------------------------------------------------
279	279	// dependency matrix for the identity function W(x) = x

294	294	{ found = Sy[i].find(j) != Sy[i].end();
295	295	ok &= (found == Check[i * n + j]);
296	296	}
297		}
	297	}
298	298
299	299	return ok;
300	300	}

304	304	using namespace CppAD;
305	305
306	306	// dimension of the domain space
307		size_t n = 2;
	307	size_t n = 2;
308	308
309	309	// dimension of the range space
310	310	size_t m = 3;
311	311
312		// independent variable vector
	312	// independent variable vector
313	313	CPPAD_TESTVECTOR(AD<double>) X(n);
314		X[0] = 2.;
	314	X[0] = 2.;
315	315	X[1] = 3.;
316	316	Independent(X);
317	317

366	366	for(i = 0; i < m; i++)
367	367	{ for(j = 0; j < n; j++)
368	368	ok &= (Py[i * n + j] == Check[i * n + j]);
369		}
	369	}
370	370
371	371	// ---------------------------------------------------------
372		// dependency matrix for the identity function
	372	// dependency matrix for the identity function
373	373	CPPAD_TESTVECTOR(std::set<size_t>) Sx(n);
374	374	for(i = 0; i < n; i++)
375	375	{ assert( Sx[i].empty() );

387	387	{ found = Sy[i].find(j) != Sy[i].end();
388	388	ok &= (found == Check[i * n + j]);
389	389	}
390		}
	390	}
391	391
392	392	return ok;
393	393	}

397	397	using namespace CppAD;
398	398
399	399	// dimension of the domain space
400		size_t n = 2;
	400	size_t n = 2;
401	401
402	402	// dimension of the range space
403	403	size_t m = 3;
404	404
405		// independent variable vector
	405	// independent variable vector
406	406	CPPAD_TESTVECTOR(AD<double>) X(n);
407		X[0] = 2.;
	407	X[0] = 2.;
408	408	X[1] = 3.;
409	409	Independent(X);
410	410

460	460	for(i = 0; i < m; i++)
461	461	{ for(j = 0; j < n; j++)
462	462	ok &= (Py[j * m + i] == Check[i * n + j]);
463		}
	463	}
464	464
465	465	// ---------------------------------------------------------
466		// dependency matrix for the identity function
	466	// dependency matrix for the identity function
467	467	CPPAD_TESTVECTOR(std::set<size_t>) Sx(n);
468	468	for(i = 0; i < n; i++)
469	469	{ assert( Sx[i].empty() );

481	481	{ found = Sy[j].find(i) != Sy[j].end();
482	482	ok &= (found == Check[i * n + j]);
483	483	}
484		}
	484	}
485	485
486	486	return ok;
487	487	}

+4

-4

test_more/forward_order.cpp less more

0		/* $Id: forward_order.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
	0	// $Id: forward_order.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

87	87	size_t p = 2, p1 = p+1;
88	88	CPPAD_TESTVECTOR(double) x(n), x_p(n * p1), y_p(m * p1);
89	89	for(j = 0; j < n; j++)
90		{ x[j] = double(j) / double(n);
	90	{ x[j] = double(j) / double(n);
91	91	x_p[j * p1 + 0] = x[j]; // order 0
92	92	x_p[j * p1 + 1] = 1.; // order 1
93	93	x_p[j * p1 + 2] = 0.; // order 2

+7

-7

test_more/from_base.cpp less more

0		/* $Id: from_base.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: from_base.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

20	20
21	21	using namespace CppAD;
22	22
23		// construct directly form Base where Base = double
24		AD<double> x(1.);
	23	// construct directly form Base where Base = double
	24	AD<double> x(1.);
25	25	AD<double> y = 2.;
26	26
27		// construct from a type that can be converted to Base
	27	// construct from a type that can be converted to Base
28	28	// where Base = AD<double>
29		AD< AD<double> > X(1.);
	29	AD< AD<double> > X(1.);
30	30	AD< AD<double> > Y(2);
31	31
32	32	// check that resulting objects are parameters

+9

-9

test_more/fun_check.cpp less more

0		/* $Id: fun_check.cpp 3214 2014-03-18 20:50:38Z bradbell $ */
	0	// $Id: fun_check.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

31	31	size_t i;
32	32	for(i = 0; i < n; i++)
33	33	{ // This operaiton sequence depends on x
34		if( x[i] >= 0 )
	34	if( x[i] >= 0 )
35	35	y[i] = exp(x[i]);
36	36	else y[i] = exp(-x[i]);
37	37	}
38	38	return y;
39		}
	39	}
40	40	};
41	41	// template function FunCheckCases<Vector, ADVector> in empty namespace
42	42	template <class Vector, class ADVector>

73	73	// create function object to use with double
74	74	Fun<double, Vector> g(n);
75	75
76		// function values should agree when the independent variable
	76	// function values should agree when the independent variable
77	77	// values are the same as during recording
78	78	Vector x(n);
79	79	size_t j;
80	80	for(j = 0; j < n; j++)
81	81	x[j] = Value(X[j]);
82		double r = 1e-10;
	82	double r = 1e-10;
83	83	double a = 1e-10;
84	84	ok &= FunCheck(f, g, x, a, r);
85	85

104	104
105	105	return ok;
106	106	}
107		} // End empty namespace
	107	} // End empty namespace
108	108	# include <vector>
109	109	# include <valarray>
110	110	bool FunCheck(void)

116	116	typedef std::valarray<double> Vector3;
117	117	typedef std::valarray< CppAD::AD<double> > ADVector3;
118	118	// Run with Vector and ADVector equal to three different cases
119		// all of which are Simple Vectors with elements of type
	119	// all of which are Simple Vectors with elements of type
120	120	// double and AD<double> respectively.
121	121	ok &= FunCheckCases< Vector1, ADVector2 >();
122	122	ok &= FunCheckCases< Vector2, ADVector3 >();

+5

-5

test_more/jacobian.cpp less more

0		/* $Id: jacobian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: jacobian.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

43	43	}
44	44
45	45
46		} // End empty namespace
	46	} // End empty namespace
47	47
48	48	bool jacobian(void)
49	49	{ bool ok = true;

72	72	for(k = 0; k < m *n; k++)
73	73	ok &= CppAD::NearEqual(jac_g[k], check[k], 1e-10, 1e-10);
74	74
75		// one argument sparse jacobian
	75	// one argument sparse jacobian
76	76	jac_g = fun_g.SparseJacobian(x);
77	77	for(k = 0; k < m *n; k++)
78	78	ok &= CppAD::NearEqual(jac_g[k], check[k], 1e-10, 1e-10);

+13

-13

test_more/mul.cpp less more

0		/* $Id: mul.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: mul.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

44	44	// assign the dependent variables
45	45	Z[x] = U[s] * U[t]; // AD<double> * AD<double>
46	46	Z[y] = Z[x] * 4.; // AD<double> * double
47		Z[z] = 4. * Z[y]; // double * AD<double>
	47	Z[z] = 4. * Z[y]; // double * AD<double>
48	48	Z[u] = one * Z[z]; // multiplication by parameter equal to one
49	49	Z[v] = zero * Z[z]; // multiplication by parameter equal to zero
50	50

70	70	q[s] = 1.;
71	71	q[t] = 0.;
72	72	r = f.Forward(1, q);
73		ok &= ( r[x] == U[t] ); // dx/ds
	73	ok &= ( r[x] == U[t] ); // dx/ds
74	74	ok &= ( r[y] == U[t] * 4. ); // dy/ds
75	75	ok &= ( r[z] == 4. * U[t] * 4. ); // dz/ds
76	76	ok &= ( r[u] == r[z] ); // du/ds

105	105
106	106	AD<double> a = U[0] * 1.; // AD<double> * double
107	107	AD<double> b = a * 2; // AD<double> * int
108		AD<double> c = 3. * b; // double * AD<double>
109		AD<double> d = 4 * c; // int * AD<double>
	108	AD<double> c = 3. * b; // double * AD<double>
	109	AD<double> d = 4 * c; // int * AD<double>
110	110
111		// dependent variable vector
	111	// dependent variable vector
112	112	CPPAD_TESTVECTOR(AD<double>) Z(1);
113	113	Z[0] = U[0] * d; // AD<double> * AD<double>
114	114
115	115	// create f: U -> Z and vectors used for derivative calculations
116		ADFun<double> f(U, Z);
	116	ADFun<double> f(U, Z);
117	117	CPPAD_TESTVECTOR(double) v(1);
118	118	CPPAD_TESTVECTOR(double) w(1);
119	119
120		// check value
	120	// check value
121	121	ok &= NearEqual(Value(Z[0]) , u0432u0, 1e-10 , 1e-10);
122	122
123	123	// forward computation of partials w.r.t. u

134	134	else value = 0.;
135	135
136	136	jfac *= j;
137		w = f.Forward(j, v);
	137	w = f.Forward(j, v);
138	138	ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
139	139	v[0] = 0.;
140	140	}
141	141
142	142	// reverse computation of partials of Taylor coefficients
143		CPPAD_TESTVECTOR(double) r(p);
	143	CPPAD_TESTVECTOR(double) r(p);
144	144	w[0] = 1.;
145	145	r = f.Reverse(p, w);
146	146	jfac = 1.;

164	164	bool Mul(void)
165	165	{ bool ok = true;
166	166	ok &= MulTestOne();
167		ok &= MulTestTwo();
	167	ok &= MulTestTwo();
168	168	return ok;
169	169	}

+11

-11

test_more/mul_eq.cpp less more

0		/* $Id: mul_eq.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: mul_eq.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

86	86	// independent variable vector
87	87	double u0 = .5;
88	88	CPPAD_TESTVECTOR(AD<double>) U(1);
89		U[0] = u0;
	89	U[0] = u0;
90	90	Independent(U);
91	91
92		// dependent variable vector
	92	// dependent variable vector
93	93	CPPAD_TESTVECTOR(AD<double>) Z(1);
94	94	Z[0] = U[0]; // initial value
95	95	Z[0] = 2; // AD<double> = int
96	96	Z[0] = 4.; // AD<double> = double
97		Z[0] = U[0]; // AD<double> = AD<double>
	97	Z[0] = U[0]; // AD<double> = AD<double>
98	98
99	99	// create f: U -> Z and vectors used for derivative calculations
100		ADFun<double> f(U, Z);
	100	ADFun<double> f(U, Z);
101	101	CPPAD_TESTVECTOR(double) v(1);
102	102	CPPAD_TESTVECTOR(double) w(1);
103	103
104		// check value
	104	// check value
105	105	ok &= NearEqual(Z[0] , u024*u0, 1e-10 , 1e-10);
106	106
107	107	// forward computation of partials w.r.t. u

118	118	else value = 0.;
119	119
120	120	jfac *= j;
121		w = f.Forward(j, v);
	121	w = f.Forward(j, v);
122	122	ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
123	123	v[0] = 0.;
124	124	}
125	125
126	126	// reverse computation of partials of Taylor coefficients
127		CPPAD_TESTVECTOR(double) r(p);
	127	CPPAD_TESTVECTOR(double) r(p);
128	128	w[0] = 1.;
129	129	r = f.Reverse(p, w);
130	130	jfac = 1.;

148	148	bool MulEq(void)
149	149	{ bool ok = true;
150	150	ok &= MulEqTestOne();
151		ok &= MulEqTestTwo();
	151	ok &= MulEqTestTwo();
152	152	return ok;
153	153	}

+16

-16

test_more/mul_level.cpp less more

0		/* $Id: mul_level.cpp 3071 2014-01-01 04:02:27Z bradbell $ */
	0	// $Id: mul_level.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

14	14	# include <adolc/adouble.h>
15	15	# include <adolc/taping.h>
16	16	# include <adolc/interfaces.h>
17		// adouble definitions not in Adolc distribution and
	17	// adouble definitions not in Adolc distribution and
18	18	// required in order to use CppAD::AD<adouble>
19	19	# include <cppad/example/base_adolc.hpp>
20	20	# endif

24	24
25	25	namespace { // BEGIN empty namespace
26	26
27		bool One(void)
	27	bool One(void)
28	28	{ bool ok = true; // initialize test result
29	29	using CppAD::NearEqual;
30	30	double eps = 10. * std::numeric_limits<double>::epsilon();

93	93	sum += x[i] * x[i];
94	94
95	95	// check computed assignment AD< AD<double> > -= int
96		sum -= 1;
97
98		// check double * AD< AD<double> >
	96	sum -= 1;
	97
	98	// check double * AD< AD<double> >
99	99	return .5 * sum;
100		}
101
102		bool Two(void)
	100	}
	101
	102	bool Two(void)
103	103	{ bool ok = true; // initialize test result
104	104
105	105	typedef CppAD::AD<double> ADdouble; // for one level of taping

126	126	// declare inner function (corresponding to ADDdouble calculation)
127	127	CppAD::ADFun<ADdouble> a_F(aa_x, aa_f);
128	128
129		// compute f'(x)
	129	// compute f'(x)
130	130	size_t p = 1; // order of derivative of a_F
131	131	CPPAD_TESTVECTOR(ADdouble) a_w(1); // weight vector for a_F
132	132	CPPAD_TESTVECTOR(ADdouble) a_df(n); // value of derivative

154	154
155	155	# ifdef CPPAD_ADOLC_TEST
156	156
157		bool adolc(void)
	157	bool adolc(void)
158	158	{ bool ok = true; // initialize test result
159	159
160	160	typedef adouble ADdouble; // for first level of taping

185	185	// declare inner function (corresponding to ADDdouble calculation)
186	186	CppAD::ADFun<ADdouble> a_F(aa_x, aa_f);
187	187
188		// compute f'(x)
	188	// compute f'(x)
189	189	size_t p = 1; // order of derivative of a_F
190	190	CPPAD_TESTVECTOR(ADdouble) a_w(1); // weight vector for a_F
191	191	CPPAD_TESTVECTOR(ADdouble) a_df(n); // value of derivative
192	192	a_w[0] = 1; // weighted function same as a_F
193	193	a_df = a_F.Reverse(p, a_w); // gradient of f
194	194
195		// declare outter function
	195	// declare outter function
196	196	// (corresponding to the tape of adouble operations)
197	197	double df_j;
198	198	for(j = 0; j < n; j++)

250	250	ay = af.Forward(0, ax);
251	251	ADFun<double> g(ax, ay);
252	252
253		// evaluate h(x) = g(x)
	253	// evaluate h(x) = g(x)
254	254	x[0] = 1.;
255	255	y = g.Forward(0, x);
256	256

+4

-4

test_more/mul_zero_one.cpp less more

0		/* $Id: mul_zero_one.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: mul_zero_one.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

19	19	typedef CppAD::AD< ADdouble > ADDdouble;
20	20
21	21	bool MulZeroOne(void)
22		{
	22	{
23	23	using namespace CppAD;
24	24
25	25	bool ok = true;

+6

-6

test_more/near_equal_ext.cpp less more

0		/* $Id: near_equal_ext.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: near_equal_ext.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-06 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

21	21	using CppAD::AD;
22	22	using CppAD::NearEqual;
23	23
24		// double
	24	// double
25	25	double x = 1.00000;
26	26	double y = 1.00001;
27	27	double a = .00005;
28	28	double r = .00005;
29		double zero = 0.;
	29	double zero = 0.;
30	30	double inf = 1. / zero;
31	31	double nan = 0. / zero;
32	32
33		// AD<double>
	33	// AD<double>
34	34	AD<double> X(x);
35	35	AD<double> Y(y);
36	36	AD<double> Inf(inf);

+5

-5

test_more/neg.cpp less more

0		/* $Id: neg.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: neg.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

34	34	size_t x = 0;
35	35
36	36	// dependent variable values
37		Z[x] = - U[t]; // - AD<double>
	37	Z[x] = - U[t]; // - AD<double>
38	38
39	39	// create f: U -> Z and vectors used for derivative calculations
40	40	ADFun<double> f(U, Z);

62	62	r = f.Reverse(2, w);
63	63	ok &= ( r[2 * s + 1] == 0. ); // d^2 x / (ds ds)
64	64	ok &= ( r[2 * t + 1] == 0. ); // d^2 x / (ds dt)
65
	65
66	66	return ok;
67	67	}
68	68	// END C++

+8

-8

test_more/parameter.cpp less more

0		/* $Id: parameter.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: parameter.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

30	30	size_t j, n = n_parameter * n_repeat;
31	31	CPPAD_TESTVECTOR(AD<Float>) ax(n);
32	32	for(j = 0; j < n; j++)
33		ax[j] = Float(j);
	33	ax[j] = Float(j);
34	34	Independent(ax);
35	35
36	36	// dependent variable vector and indices
37	37	size_t i, m = n;
38	38	CPPAD_TESTVECTOR(AD<Float>) ay(m);
39	39	for(i = 0; i < m; i++)
40		{ // must avoid Float(k) = 0 because it would get optimized out
41		size_t k = (i % n_parameter);
	40	{ // must avoid Float(k) = 0 because it would get optimized out
	41	size_t k = (i % n_parameter);
42	42	k = k * k * 10 + 1;
43	43	j = i;
44	44	ay[i] = ax[j] + Float(k);
45	45	}
46	46
47		// create f: ax -> ay
	47	// create f: ax -> ay
48	48	ADFun<Float> f(ax, ay);
49	49
50	50	ok = f.size_par() == n_parameter;

57	57	bool parameter(void)
58	58	{ bool ok = true;
59	59	ok &= test<double>();
60		ok &= test<float>();
	60	ok &= test<float>();
61	61	return ok;
62	62	}

+5

-5

test_more/poly.cpp less more

0		/* $Id: poly.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: poly.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

41	41	Z[0] = 3.; // value of independent variable
42	42	Independent(Z); // declare independent variable
43	43
44		// dependent variables
	44	// dependent variables
45	45	CPPAD_TESTVECTOR(AD<double>) P(1); // one dependent variable
46	46	P[0] = Poly(0, A, Z[0]); // value of polynomial at Z[0]
47	47
48		// define f : Z -> P as a function mapping independent to dependent
	48	// define f : Z -> P as a function mapping independent to dependent
49	49	ADFun<double> f(Z, P); // ADFun corresponding to polynomial
50	50
51	51	// compute derivative of polynomial

+32

-32

test_more/pow.cpp less more

0		/* $Id: pow.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: pow.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

33	33	// declare independent variables and start tape recording
34	34	CppAD::Independent(XY);
35	35
36		// range space vector
	36	// range space vector
37	37	size_t m = 3;
38	38	CPPAD_TESTVECTOR(AD<double>) Z(m);
39	39	Z[0] = CppAD::pow(XY[0], XY[1]); // pow(variable, variable)

41	41	Z[2] = CppAD::pow(x, XY[1]); // pow(parameter, variable)
42	42
43	43	// create f: XY -> Z and stop tape recording
44		CppAD::ADFun<double> f(XY, Z);
45
46		// check value
	44	CppAD::ADFun<double> f(XY, Z);
	45
	46	// check value
47	47	double check = std::pow(x, y);
48	48	size_t i;
49	49	for(i = 0; i < m; i++)

151	151	w = f.Forward(1, v);
152	152	ok &= ( w[y] == U[s] * u * Z[y] ); // dy/dt
153	153
154		// forward computation of second Taylor coefficient w.r.t. t
	154	// forward computation of second Taylor coefficient w.r.t. t
155	155	v[t] = 1.;
156	156	w = f.Forward(1, v);
157	157	v[t] = 0.;
158	158	CPPAD_TESTVECTOR(double) f_tt = f.Forward(2, v);
159	159
160		// forward computation of second Taylor coefficient w.r.t. s
	160	// forward computation of second Taylor coefficient w.r.t. s
161	161	v[s] = 1.;
162	162	w = f.Forward(1, v);
163	163	v[s] = 0.;
164	164	CPPAD_TESTVECTOR(double) f_ss = f.Forward(2, v);
165	165
166		// second Taylor coefficient w.r.t. direction r = (s,t)
	166	// second Taylor coefficient w.r.t. direction r = (s,t)
167	167	v[s] = 1.;
168	168	v[t] = 1.;
169	169	w = f.Forward(1, v);

173	173
174	174	// check second order partial of y
175	175	ok &= NearEqual(
176		f_rr[y] - f_ss[y] - f_tt[y],
177		(1. + U[s]) * u * Z[y] +
	176	f_rr[y] - f_ss[y] - f_tt[y],
	177	(1. + U[s]) * u * Z[y] +
178	178	(1. + U[s]) * U[t] * u * U[s] * u * Z[y],
179	179	1e-10 ,
180		1e-10
181		);
	180	1e-10
	181	);
182	182
183	183	return ok;
184	184	}

197	197	// declare independent variables and start tape recording
198	198	CppAD::Independent(x);
199	199
200		// range space vector
	200	// range space vector
201	201	size_t m = 4;
202	202	CPPAD_TESTVECTOR(AD<double>) y(m);
203	203

208	208	y[3] = pow(1., x[0]);
209	209
210	210	// create f: x -> y and stop tape recording
211		CppAD::ADFun<double> f(x, y);
	211	CppAD::ADFun<double> f(x, y);
212	212
213	213	// check function values
214	214	ok &= (Value(y[0]) == 1.);

226	226	ok &= NearEqual(dy[2], 1., 1e-10, 1e-10);
227	227	ok &= (dy[3] == 0.);
228	228
229		// reverse mode computation of derivative of y[0]+y[1]+y[2]+y[3]
	229	// reverse mode computation of derivative of y[0]+y[1]+y[2]+y[3]
230	230	CPPAD_TESTVECTOR(double) w(m);
231	231	CPPAD_TESTVECTOR(double) dw(n);
232	232	w[0] = 1.;

236	236	dw = f.Reverse(1, w);
237	237	ok &= NearEqual(dw[0], 1., 1e-10, 1e-10);
238	238
239		return ok;
	239	return ok;
240	240	}
241	241
242	242	bool PowTestFour(void)

254	254	// declare independent variables and start tape recording
255	255	CppAD::Independent(x);
256	256
257		// range space vector
	257	// range space vector
258	258	size_t m = 5;
259	259	CPPAD_TESTVECTOR(AD<double>) y(m);
260	260
261	261	// some special cases (skip zero raised to a negative power)
262	262	y[0] = pow(1., x[0]);
263	263	size_t i;
264		for(i = 1; i < m; i++)
	264	for(i = 1; i < m; i++)
265	265	y[i] = pow(x[0], i-1); // pow(AD<double>, int)
266	266
267	267	// create f: x -> y and stop tape recording
268		CppAD::ADFun<double> f(x, y);
	268	CppAD::ADFun<double> f(x, y);
269	269
270	270	ok &= (Value(y[0]) == 1.);
271	271	double check;

297	297	dw = f.Reverse(1, w);
298	298	ok &= NearEqual(dw[0], sum, 1e-10, 1e-10);
299	299
300		return ok;
	300	return ok;
301	301	}
302	302	bool PowTestFive(void)
303	303	{ bool ok = true;

314	314	// declare independent variables and start tape recording
315	315	CppAD::Independent(x);
316	316
317		// range space vector
	317	// range space vector
318	318	size_t m = 1;
319	319	CPPAD_TESTVECTOR(AD<double>) y(m);
320	320

323	323	y[0] = pow(x[0], int(e)); // use pow(AD<double>, int)
324	324
325	325	// create f: x -> y and stop tape recording
326		CppAD::ADFun<double> f(x, y);
	326	CppAD::ADFun<double> f(x, y);
327	327
328	328	// check function value
329	329	ok &= (Value(y[0]) == pow(x0, e) );

336	336	dy = f.Forward(1, dx);
337	337	ok &= NearEqual(dy[0], d1, 1e-10, 1e-10);
338	338
339		// reverse mode computation of second partials
	339	// reverse mode computation of second partials
340	340	// x.r.t. x[1],x[0] and x[1], x[1]
341	341	double d2 = e * (e-1) * pow(x0, (e-2));
342	342	CPPAD_TESTVECTOR(double) w(m);

346	346	ok &= NearEqual(ddw[0], d1, 1e-10, 1e-10);
347	347	ok &= NearEqual(ddw[1], d2, 1e-10, 1e-10);
348	348
349		return ok;
	349	return ok;
350	350	}
351	351	bool PowTestSix(void)
352	352	{ bool ok = true;

367	367	// declare independent variables and start tape recording
368	368	CppAD::Independent(X);
369	369
370		// range space vector
	370	// range space vector
371	371	size_t m = 1;
372	372	CPPAD_TESTVECTOR(AD< AD<double> >) Y(m);
373	373
374	374	// case of AD< AD<double> > raised to a double power
375	375	double e = 2.5;
376		Y[0] = pow(X[0], e);
	376	Y[0] = pow(X[0], e);
377	377
378	378	// create F: X -> Y and stop tape recording
379		CppAD::ADFun< AD<double> > F(X, Y);
	379	CppAD::ADFun< AD<double> > F(X, Y);
380	380
381	381	// check function value
382	382	ok &= (Value( Value(Y[0]) ) == pow(x0, e) );

389	389	dy = F.Forward(1, dx);
390	390	ok &= NearEqual(dy[0], d1, 1e-10, 1e-10);
391	391
392		// reverse mode computation of second partials
	392	// reverse mode computation of second partials
393	393	// x.r.t. x[1],x[0] and x[1], x[1]
394	394	double d2 = e * (e-1) * pow(x0, (e-2));
395	395	CPPAD_TESTVECTOR(AD<double>) w(m);

399	399	ok &= NearEqual(ddw[0], d1, 1e-10, 1e-10);
400	400	ok &= NearEqual(ddw[1], d2, 1e-10, 1e-10);
401	401
402		return ok;
	402	return ok;
403	403	}
404	404
405	405	} // END empty namespace
406
	406
407	407	bool Pow(void)
408	408	{ bool ok = true;
409	409	ok &= PowTestOne();

+4

-4

test_more/pow_int.cpp less more

0		/* $Id: pow_int.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: pow_int.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

51	51	ok &= NearEqual(Z[0] , exp( log(u) * 5.), 1e-10 , 1e-10);
52	52	ok &= NearEqual(Z[1] , exp( - log(u) * 5.), 1e-10 , 1e-10);
53	53
54		// forward computation of partials
	54	// forward computation of partials
55	55	v[0] = 1.;
56	56	w = f.Forward(1, v);
57	57	ok &= NearEqual(w[0] , 5. * exp( log(u) * 4.), 1e-10 , 1e-10);

+13

-13

test_more/print_for.cpp less more

0		/* $Id: print_for.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: print_for.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

12	12	// modified version of test that used to be in ../print_for/print_for.cpp
13	13	# include <cppad/cppad.hpp>
14	14
15		namespace {
	15	namespace {
16	16	using std::endl;
17	17	using CppAD::AD;
18	18

25	25	PrintFor(y, "check_log: y == ", y , " which is <= 0\n");
26	26
27	27	return log(y);
28		}
	28	}
29	29	}
30	30
31	31	bool print_for(void)

45	45	CppAD::VecAD<double> av(1);
46	46	AD<double> Zero(0);
47	47	av[Zero] = 0.;
48		PrintFor("v[0] = ", av[Zero]);
	48	PrintFor("v[0] = ", av[Zero]);
49	49	string_check += "v[0] = 0"; // v[0] == 0 during Forward(0, x)
50	50
51	51	// Print a newline to separate this from previous output,
52	52	// then print an AD<double> object that is a variable.
53		PrintFor("\nv[0] + x[0] = ", av[0] + ax[0]);
54		string_check += "\nv[0] + x[0] = 2"; // x[0] == 2 during Forward(0, x)
	53	PrintFor("\nv[0] + x[0] = ", av[0] + ax[0]);
	54	string_check += "\nv[0] + x[0] = 2"; // x[0] == 2 during Forward(0, x)
55	55
56	56	// A conditional print that will not generate output when x[0] = 2.
57	57	PrintFor(ax[0], "\n 2. + x[0] = ", 2. + ax[0], "\n");

65	65	AD<double> log_var = check_log(var);
66	66	string_check += "check_log: y == 0 which is <= 0\n";
67	67
68		// dependent variable vector
	68	// dependent variable vector
69	69	size_t m = 2;
70	70	CPPAD_TESTVECTOR(AD<double>) ay(m);
71	71	ay[0] = av[Zero] + ax[0];
72	72
73	73	// define f: x -> y and stop tape recording
74		CppAD::ADFun<double> f(ax, ay);
	74	CppAD::ADFun<double> f(ax, ay);
75	75
76		// zero order forward with x[0] = 2
	76	// zero order forward with x[0] = 2
77	77	CPPAD_TESTVECTOR(double) x(n);
78	78	x[0] = 2.;
79		f.Forward(0, x, stream_out);
	79	f.Forward(0, x, stream_out);
80	80
81	81	std::string string_out = stream_out.str();
82		ok &= string_out == string_check;
	82	ok &= string_out == string_check;
83	83	return ok;
84	84	}

+31

-31

test_more/rev_sparse_hes.cpp less more

0		/* $Id: rev_sparse_hes.cpp 2935 2013-10-12 19:40:01Z bradbell $ */
	0	// $Id: rev_sparse_hes.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

11	11
12	12
13	13	# include <cppad/cppad.hpp>
14
	14
15	15	namespace { // Begin empty namespace
16	16
17	17	bool case_one()

19	19	using namespace CppAD;
20	20
21	21	// dimension of the domain space
22		size_t n = 10;
	22	size_t n = 10;
23	23
24	24	// dimension of the range space
25	25	size_t m = 2;

32	32	for(j = 0; j < n * n; j++)
33	33	Check[j] = false;
34	34
35		// independent variable vector
	35	// independent variable vector
36	36	CPPAD_TESTVECTOR(AD<double>) X(n);
37	37	for(j = 0; j < n; j++)
38	38	X[j] = AD<double>(j);

53	53	sum += CondExpLt(X[1], X[2], sin(X[6]), cos(X[7]) );
54	54	Check[6 * n + 6] = true;
55	55	Check[7 * n + 7] = true;
56
	56
57	57	// pow(variable, variable)
58	58	sum += pow(X[8], X[9]);
59	59	Check[8 * n + 8] = Check[8 * n + 9] = true;

81	81	// compute sparsity pattern for Jacobian of F(U(x))
82	82	F.ForSparseJac(n, Px);
83	83
84		// compute sparsity pattern for Hessian of F_0 ( U(x) )
	84	// compute sparsity pattern for Hessian of F_0 ( U(x) )
85	85	CPPAD_TESTVECTOR(bool) Py(m);
86	86	Py[0] = true;
87	87	Py[1] = false;

108	108	// compute sparsity pattern for Jacobian of F(U(x))
109	109	F.ForSparseJac(n, Sx);
110	110
111		// compute sparsity pattern for Hessian of F_0 ( U(x) )
	111	// compute sparsity pattern for Hessian of F_0 ( U(x) )
112	112	CPPAD_TESTVECTOR(std::set<size_t>) Sy(1);
113	113	Sy[0].insert(0);
114	114	CPPAD_TESTVECTOR(std::set<size_t>) Sxx(n);

141	141	using namespace CppAD;
142	142
143	143	// dimension of the domain space
144		size_t n = 4;
	144	size_t n = 4;
145	145
146	146	// dimension of the range space
147	147	size_t m = 1;

154	154	for(j = 0; j < n * n; j++)
155	155	Check[j] = false;
156	156
157		// independent variable vector
	157	// independent variable vector
158	158	CPPAD_TESTVECTOR(AD<double>) X(n);
159	159	for(j = 0; j < n; j++)
160	160	X[j] = AD<double>(j);
161	161	Independent(X);
162	162
163	163	// Test the case where dependent variable is a non-linear function
164		// of the result of a conditional expression.
	164	// of the result of a conditional expression.
165	165	CPPAD_TESTVECTOR(AD<double>) Y(m);
166	166	Y[0] = CondExpLt(X[0], X[1], X[2], X[3]);
167	167	Y[0] = cos(Y[0]) + X[0] + X[1];

172	172	// inefficiency of the conditional expression operator).
173	173	Check[2 * n + 2] = Check[ 2 * n + 3 ] = true;
174	174	Check[3 * n + 2] = Check[ 3 * n + 3 ] = true;
175
	175
176	176	// create function object F : X -> Y
177	177	ADFun<double> F(X, Y);
178	178

188	188	// compute sparsity pattern for Jacobian of F(U(x))
189	189	F.ForSparseJac(n, Px);
190	190
191		// compute sparsity pattern for Hessian of F_0 ( U(x) )
	191	// compute sparsity pattern for Hessian of F_0 ( U(x) )
192	192	CPPAD_TESTVECTOR(bool) Py(m);
193	193	Py[0] = true;
194	194	CPPAD_TESTVECTOR(bool) Pxx(n * n);

207	207	// compute sparsity pattern for Jacobian of F(U(x))
208	208	F.ForSparseJac(n, Sx);
209	209
210		// compute sparsity pattern for Hessian of F_0 ( U(x) )
	210	// compute sparsity pattern for Hessian of F_0 ( U(x) )
211	211	CPPAD_TESTVECTOR(std::set<size_t>) Sy(1);
212	212	Sy[0].insert(0);
213	213	CPPAD_TESTVECTOR(std::set<size_t>) Sxx(n);

229	229	using CppAD::AD;
230	230
231	231	// domain space vector
232		size_t n = 1;
	232	size_t n = 1;
233	233	CPPAD_TESTVECTOR(AD<double>) X(n);
234		X[0] = 0.;
	234	X[0] = 0.;
235	235
236	236	// declare independent variables and start recording
237	237	CppAD::Independent(X);

280	280	// compute sparsity pattern for Jacobian of F(U(x))
281	281	f.ForSparseJac(n, Sx);
282	282
283		// compute sparsity pattern for Hessian of F_0 ( U(x) )
	283	// compute sparsity pattern for Hessian of F_0 ( U(x) )
284	284	CPPAD_TESTVECTOR(std::set<size_t>) Sy(1);
285	285	Sy[0].insert(0);
286	286	CPPAD_TESTVECTOR(std::set<size_t>) Sxx(n);

298	298	using namespace CppAD;
299	299
300	300	// dimension of the domain space
301		size_t n = 3;
	301	size_t n = 3;
302	302
303	303	// dimension of the range space
304	304	size_t m = 1;

309	309	for(k = 0; k < n-1; k++)
310	310	Z[k] = 0.;
311	311
312		// independent variable vector
	312	// independent variable vector
313	313	CPPAD_TESTVECTOR(AD<double>) X(n);
314		X[0] = 0.;
	314	X[0] = 0.;
315	315	X[1] = 1.;
316	316	X[2] = 2.;
317	317	Independent(X);

319	319	// VecAD vector z depends on both x[1] and x[2]
320	320	// (component indices do not matter because they can change).
321	321	Z[ X[0] ] = X[1] * X[2];
322		Z[ X[1] ] = 0.;
	322	Z[ X[1] ] = 0.;
323	323
324	324	// dependent variable vector
325	325	CPPAD_TESTVECTOR(AD<double>) Y(m);

365	365	for(i = 0; i < n; i++)
366	366	{ for(j = 0; j < n; j++)
367	367	ok &= (h[i * n + j] == Check[i * n + j]);
368		}
	368	}
369	369
370	370	// ------------------------------------------------------------------
371	371	// sparsity pattern for the identity function U(x) = x

376	376	// compute sparsity pattern for Jacobian of F(U(x))
377	377	F.ForSparseJac(n, Sx);
378	378
379		// compute sparsity pattern for Hessian of F_0 ( U(x) )
	379	// compute sparsity pattern for Hessian of F_0 ( U(x) )
380	380	CPPAD_TESTVECTOR(std::set<size_t>) Sy(1);
381	381	Sy[0].insert(0);
382	382	CPPAD_TESTVECTOR(std::set<size_t>) Sxx(n);

399	399	size_t i, j, k;
400	400
401	401	size_t n = 2;
402		CPPAD_TESTVECTOR(AD<double>) X(n);
	402	CPPAD_TESTVECTOR(AD<double>) X(n);
403	403	X[0] = 1.;
404	404	X[1] = 2.;
405	405	CppAD::Independent(X);

421	421	// compute sparsity pattern for Jacobian of F(U(x))
422	422	F.ForSparseJac(n, Px);
423	423
424		// compute sparsity pattern for Hessian of F_k ( U(x) )
	424	// compute sparsity pattern for Hessian of F_k ( U(x) )
425	425	CPPAD_TESTVECTOR(bool) Py(m);
426	426	CPPAD_TESTVECTOR(bool) Pxx(n * n);
427	427	for(k = 0; k < m; k++)

444	444	using namespace CppAD;
445	445
446	446	// dimension of the domain space
447		size_t n = 3;
	447	size_t n = 3;
448	448
449	449	// dimension of the range space
450	450	size_t m = 1;
451	451
452		// independent variable vector
	452	// independent variable vector
453	453	CPPAD_TESTVECTOR(AD<double>) X(n);
454		X[0] = 0.;
	454	X[0] = 0.;
455	455	X[1] = 1.;
456	456	X[2] = 2.;
457	457	Independent(X);

511	511	for(i = 0; i < n; i++)
512	512	{ for(j = 0; j < n; j++)
513	513	ok &= (h[i * n + j] == Check[i * n + j]);
514		}
	514	}
515	515
516	516	// compute the reverse Hessian sparsity pattern for R^T * F^2
517	517	transpose = false;

521	521	for(i = 0; i < n; i++)
522	522	{ for(j = 0; j < n; j++)
523	523	ok &= (h[j * n + i] == Check[i * n + j]);
524		}
	524	}
525	525
526	526	return ok;
527	527	}

+41

-41

test_more/reverse.cpp less more

0		/* $Id: reverse.cpp 2859 2013-05-28 06:03:21Z bradbell $ */
	0	// $Id: reverse.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

21	21
22	22	using namespace CppAD;
23	23
24		// independent variable vector
	24	// independent variable vector
25	25	CPPAD_TESTVECTOR(AD<double>) U(3);
26	26	U[0] = 0.; U[1] = 1.; U[2] = 2.;
27	27	Independent(U);

35	35	Prod *= U[i];
36	36	}
37	37
38		// dependent variable vector
	38	// dependent variable vector
39	39	CPPAD_TESTVECTOR(AD<double>) V(2);
40	40	V[0] = Sum;
41	41	V[1] = Prod;

60	60
61	61	// compare values
62	62	for(i = 0; i < 3; i++)
63		{ ok &= NearEqual(r1[i] ,
	63	{ ok &= NearEqual(r1[i] ,
64	64	v[0] * g0[i] + v[1] * g1[i], 1e-10, 1e-10);
65	65	}
66	66

84	84
85	85	// check derivative of the zero order term
86	86	for(i = 0; i < 3; i++)
87		{ ok &= NearEqual(r2[p * i + 0] ,
	87	{ ok &= NearEqual(r2[p * i + 0] ,
88	88	v[0] * g0[i] + v[1] * g1[i], 1e-10, 1e-10);
89	89	}
90	90
91	91	/*
92		The j-th component of the first order term is
	92	The j-th component of the first order term is
93	93	d/dt z_j(0, u0, u1) = f_j^{(1)} (u0) * u1
94	94	We use ei to denote the vector with its i-th component one and all
95	95	the other components zero. The partial derivative of the j-th
96		component of the first order term with respect u0[i] is
	96	component of the first order term with respect u0[i] is
97	97	ei * f_j^{(2)} ( u0 ) * u1
98	98	*/
99	99

120	120	}
121	121
122	122	// define the template function reverse_any_cases<Vector> in empty namespace
123		template <typename Vector>
	123	template <typename Vector>
124	124	bool reverse_any_cases(void)
125	125	{ bool ok = true;
126	126	using CppAD::AD;

129	129	// domain space vector
130	130	size_t n = 3;
131	131	CPPAD_TESTVECTOR(AD<double>) X(n);
132		X[0] = 0.;
	132	X[0] = 0.;
133	133	X[1] = 1.;
134	134	X[2] = 2.;
135	135

217	217
218	218	$index composition, example$$
219	219	$index example, composition$$
220		$index test, composition$$
	220	$index test, composition$$
221	221
222	222	$head Purpose$$
223		Break a derivative computation into pieces and only store values at the
	223	Break a derivative computation into pieces and only store values at the
224	224	interface of the pieces.
225		In actual applications, there may be many functions, but
	225	In actual applications, there may be many functions, but
226	226	for this example there are only two.
227		The functions
228		$latex F : \B{R}^2 \rightarrow \B{R}^2$$
	227	The functions
	228	$latex F : \B{R}^2 \rightarrow \B{R}^2$$
229	229	and
230		$latex G : \B{R}^2 \rightarrow \B{R}^2$$
	230	$latex G : \B{R}^2 \rightarrow \B{R}^2$$
231	231	defined by
232	232	$latex \[
233		F(x) = \left( \begin{array}{c} x_0 x_1 \\ x_1 - x_0 \end{array} \right)
	233	F(x) = \left( \begin{array}{c} x_0 x_1 \\ x_1 - x_0 \end{array} \right)
234	234	\; , \;
235		G(y) = \left( \begin{array}{c} y_0 - y_1 \\ y_1 y_0 \end{array} \right)
	235	G(y) = \left( \begin{array}{c} y_0 - y_1 \\ y_1 y_0 \end{array} \right)
236	236	\] $$
237	237	Another difference is that in actual applications,
238	238	the memory corresponding to function objects not currently being used

244	244	is defined by
245	245	$latex \[
246	246	\begin{array}{rcl}
247		H(x)
248		& = & G_0 [ F(x) ] + G_1 [ F(x) ]
249		\\
250		& = & x_0 x_1 - ( x_1 - x_0 ) + x_0 x_1 ( x_1 - x_0 )
	247	H(x)
	248	& = & G_0 [ F(x) ] + G_1 [ F(x) ]
	249	\\
	250	& = & x_0 x_1 - ( x_1 - x_0 ) + x_0 x_1 ( x_1 - x_0 )
251	251	\\
252	252	& = & x_0 x_1 ( 1 - x_0 + x_1 ) - x_1 + x_0
253	253	\end{array}
254		\] $$
255		Given the zero and first order Taylor coefficients
	254	\] $$
	255	Given the zero and first order Taylor coefficients
256	256	$latex x^{(0)} $$ and $latex x^{(1)}$$,
257	257	we use $latex X(t)$$, $latex Y(t)$$ and $latex Z(t)$$
258	258	for the corresponding functions; i.e.,
259	259	$latex \[
260	260	\begin{array}{rcl}
261		X(t) & = & x^{(0)} + x^{(1)} t
	261	X(t) & = & x^{(0)} + x^{(1)} t
262	262	\\
263	263	Y(t) & = & F[X(t)] = y^{(0)} + y^{(1)} t + O(t^2)
264	264	\\

271	271	\] $$
272	272	Here are the processing steps:
273	273	$list number$$
274		Use forward mode on $latex F(x)$$ to compute
275		$latex y^{(0)}$$ and $latex y^{(1)}$$
	274	Use forward mode on $latex F(x)$$ to compute
	275	$latex y^{(0)}$$ and $latex y^{(1)}$$
276	276	$lnext
277		Use forward mode on $latex G(y)$$ to compute
278		$latex z^{(0)}$$ and $latex z^{(1)}$$
	277	Use forward mode on $latex G(y)$$ to compute
	278	$latex z^{(0)}$$ and $latex z^{(1)}$$
279	279	$lnext
280		Use reverse mode on $latex G(y)$$ to compute the derivative of
	280	Use reverse mode on $latex G(y)$$ to compute the derivative of
281	281	$latex h^{(k)}$$ with respect to
282	282	$latex y^{(0)}$$ and $latex y^{(1)}$$.
283	283	$lnext

387	387	w[0*p+0] = 1.; // coefficient for z^0_0
388	388	w[1*p+0] = 1.; // coefficient for z^0_1
389	389	w[0*p+1] = 0.; // coefficient for z^1_0
390		w[1*p+1] = 0.; // coefficient for z^1_1
	390	w[1*p+1] = 0.; // coefficient for z^1_1
391	391	dw = g.Reverse(p, w);
392	392
393		// dv^0 = dw^0 * \partial_x^0 y^0 (x) + dw^1 * \partial_x^0 y^1 (x)
394		// dv^1 = dw^0 * \partial_x^1 y^0 (x) + dw^1 * \partial_x^1 y^1 (x)
	393	// dv^0 = dw^0 * \partial_x^0 y^0 (x) + dw^1 * \partial_x^0 y^1 (x)
	394	// dv^1 = dw^0 * \partial_x^1 y^0 (x) + dw^1 * \partial_x^1 y^1 (x)
395	395	CPPAD_TESTVECTOR(double) dv(n*p);
396		dv = f.Reverse(p, dw);
	396	dv = f.Reverse(p, dw);
397	397
398	398	// check partial of h^0 w.r.t x^0_0
399	399	check = x0[1] * (1. - x0[0] + x0[1]) + 1.;

416	416	w[0*p+0] = 0.; // coefficient for z^0_0
417	417	w[1*p+0] = 0.; // coefficient for z^0_1
418	418	w[0*p+1] = 1.; // coefficient for z^1_0
419		w[1*p+1] = 1.; // coefficient for z^1_1
	419	w[1*p+1] = 1.; // coefficient for z^1_1
420	420	dw = g.Reverse(p, w);
421	421
422		// dv^0 = dw^0 * \partial_x^0 y^0 (x) + dw^1 * \partial_x^0 y^1 (x)
423		// dv^1 = dw^0 * \partial_x^1 y^0 (x) + dw^1 * \partial_x^1 y^1 (x)
424		dv = f.Reverse(p, dw);
	422	// dv^0 = dw^0 * \partial_x^0 y^0 (x) + dw^1 * \partial_x^0 y^1 (x)
	423	// dv^1 = dw^0 * \partial_x^1 y^0 (x) + dw^1 * \partial_x^1 y^1 (x)
	424	dv = f.Reverse(p, dw);
425	425
426	426	// check partial of h^1 w.r.t x^0_0
427	427	check = x0[1] * (- x1[0] + x1[1]);

431	431
432	432	// check partial of h^1 w.r.t x^0_1
433	433	check = x0[0] * (- x1[0] + x1[1]);
434		check += x1[0] * (1. - x0[0] + x0[1]) + x1[0] * x0[1];
	434	check += x1[0] * (1. - x0[0] + x0[1]) + x1[0] * x0[1];
435	435	check += x0[0] * x1[1];
436	436	ok &= NearEqual(dv[1*p+0], check, eps, eps);
437	437

450	450	return ok;
451	451	}
452	452	// ----------------------------------------------------------------------------
453		} // End empty namespace
	453	} // End empty namespace
454	454
455	455	# include <vector>
456	456	# include <valarray>

+21

-21

test_more/rosen_34.cpp less more

0		/* $Id: rosen_34.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: rosen_34.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

22	22	/*
23	23	Case where
24	24	x[0](0) = 1, x[0]'(t) = - w[0] * x[0](t)
25		x[1](0) = 1, x[1]'(t) = - w[1] * x[1](t)
	25	x[1](0) = 1, x[1]'(t) = - w[1] * x[1](t)
26	26	x[2](0) = 0, x[2]'(t) = w[2] * t
27	27
28	28	x[0](t) = exp( - w[0] * t )

38	38	w = w_;
39	39	}
40	40	void Ode(
41		const CppAD::AD<double> &t,
42		const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
43		CPPAD_TESTVECTOR(CppAD::AD<double>) &f)
	41	const CppAD::AD<double> &t,
	42	const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
	43	CPPAD_TESTVECTOR(CppAD::AD<double>) &f)
44	44	{
45	45	f[0] = - w[0] * x[0];
46	46	f[1] = - w[1] * x[1];
47	47	f[2] = w[2] * t;
48
	48
49	49	}
50
	50
51	51	void Ode_ind(
52		const CppAD::AD<double> &t,
53		const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
54		CPPAD_TESTVECTOR(CppAD::AD<double>) &f_t)
	52	const CppAD::AD<double> &t,
	53	const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
	54	CPPAD_TESTVECTOR(CppAD::AD<double>) &f_t)
55	55	{
56	56	f_t[0] = 0.;
57	57	f_t[1] = 0.;
58	58	f_t[2] = w[2];
59
	59
60	60	}
61
	61
62	62	void Ode_dep(
63		const CppAD::AD<double> &t,
64		const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
65		CPPAD_TESTVECTOR(CppAD::AD<double>) &f_x)
	63	const CppAD::AD<double> &t,
	64	const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
	65	CPPAD_TESTVECTOR(CppAD::AD<double>) &f_x)
66	66	{
67	67	f_x[0] = - w[0]; f_x[1] = 0.; f_x[2] = 0.;
68	68	f_x[3] = 0.; f_x[4] = - w[1]; f_x[5] = 0.;
69	69	f_x[6] = 0.; f_x[7] = 0.; f_x[8] = 0.;
70
	70
71	71	}
72
	72
73	73	private:
74	74	CPPAD_TESTVECTOR(CppAD::AD<double>) w;
75	75	};

95	95
96	96	// construct the function object using the independent variables
97	97	TestFun fun(w);
98
	98
99	99	// initial value of x
100	100	CPPAD_TESTVECTOR(AD<double>) xini(3);
101	101	xini[0] = 1.;
102	102	xini[1] = 1.;
103	103	xini[2] = 0.;
104
	104
105	105
106	106	// integrate the differential equation
107	107	x = Rosen34(fun, nstep, t0, t1, xini);

+11

-11

test_more/runge_45.cpp less more

0		/* $Id: runge_45.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: runge_45.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

25	25	w = w_;
26	26	}
27	27	void Ode(
28		const CppAD::AD<double> &t,
29		const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
30		CPPAD_TESTVECTOR(CppAD::AD<double>) &f)
	28	const CppAD::AD<double> &t,
	29	const CPPAD_TESTVECTOR(CppAD::AD<double>) &x,
	30	CPPAD_TESTVECTOR(CppAD::AD<double>) &f)
31	31	{
32	32	using CppAD::exp;
33
	33
34	34	size_t n = x.size();
35
	35
36	36	size_t i;
37	37	f[0] = 0.;
38	38	for(i = 1; i < n-1; i++)
39	39	f[i] = w[i] * x[i-1];
40
	40
41	41	f[n-1] = x[0] * x[1];
42	42	}
43	43	private:

116	116	{ // check partial of x[i] w.r.t w[j]
117	117	if (j == 0 )
118	118	ok &= NearEqual(q[j], x[i], 1e-14, 1e-14);
119		else if( j <= i )
	119	else if( j <= i )
120	120	ok &= NearEqual(
121	121	q[j], x[i]/w[j], 1e-14, 1e-14);
122	122	else ok &= NearEqual(q[j], 0., 1e-14, 1e-14);

134	134	{ // check partial of x[n-1] w.r.t w[j]
135	135	if (j == 0 )
136	136	ok &= NearEqual(q[j], 2.*x[i], 1e-14, 1e-14);
137		else if( j == 1 )
	137	else if( j == 1 )
138	138	ok &= NearEqual(
139	139	q[j], x[i]/w[1], 1e-14, 1e-14);
140	140	else ok &= NearEqual(q[j], 0., 1e-14, 1e-14);

+9

-9

test_more/sin.cpp less more

0		/* $Id: sin.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: sin.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

26	26	U[0] = 1.;
27	27	Independent(U);
28	28
29		// dependent variable vector
	29	// dependent variable vector
30	30	CPPAD_TESTVECTOR(AD<double>) Z(1);
31		Z[0] = sin(U[0]);
	31	Z[0] = sin(U[0]);
32	32
33	33	// create f: U -> Z and vectors used for derivative calculations
34		ADFun<double> f(U, Z);
	34	ADFun<double> f(U, Z);
35	35	CPPAD_TESTVECTOR(double) v(1);
36	36	CPPAD_TESTVECTOR(double) w(1);
37	37
38		// check value
	38	// check value
39	39	double sin_u = sin( Value(U[0]) );
40	40	double cos_u = cos( Value(U[0]) );
41	41

47	47	double jfac = 1.;
48	48	v[0] = 1.;
49	49	for(j = 1; j < p; j++)
50		{ w = f.Forward(j, v);
	50	{ w = f.Forward(j, v);
51	51
52	52	double value;
53	53	if( j % 4 == 1 )

64	64	}
65	65
66	66	// reverse computation of partials of Taylor coefficients
67		CPPAD_TESTVECTOR(double) r(p);
	67	CPPAD_TESTVECTOR(double) r(p);
68	68	w[0] = 1.;
69	69	r = f.Reverse(p, w);
70	70	jfac = 1.;

+32

-32

test_more/sin_cos.cpp less more

0		/* $Id: sin_cos.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: sin_cos.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

33	33	X[1] = y;
34	34	Independent(X);
35	35
36		// dependent variable vector
	36	// dependent variable vector
37	37	CPPAD_TESTVECTOR(AD<double>) Z(1);
38	38	AD<double> U = X[0] * X[1];
39		Z[0] = sin( U );
	39	Z[0] = sin( U );
40	40
41	41	// create f: X -> Z and vectors used for derivative calculations
42	42	// f(x, y) = sin(x, y)
43		ADFun<double> f(X, Z);
	43	ADFun<double> f(X, Z);
44	44	CPPAD_TESTVECTOR(double) v( 2 );
45	45	CPPAD_TESTVECTOR(double) w( 1 );
46	46
47		// check value
	47	// check value
48	48	double sin_u = sin( Value(U) );
49	49	double cos_u = cos( Value(U) );
50	50

58	58	v[1] = 0; // differential w.r.t. y
59	59	double yj = 1; // y^j
60	60	for(j = 1; j < p; j++)
61		{ w = f.Forward(j, v);
	61	{ w = f.Forward(j, v);
62	62
63	63	// compute j-th power of y
64	64	yj *= y ;

76	76	jfac *= j;
77	77
78	78	// check j-th derivative of z w.r.t x
79		ok &= NearEqual(jfacw[0], sinj yj, 1e-10 , 1e-10);
	79	ok &= NearEqual(jfacw[0], sinj yj, 1e-10 , 1e-10);
80	80
81	81	v[0] = 0.;
82	82	}
83	83
84	84	// reverse computation of partials of Taylor coefficients
85		CPPAD_TESTVECTOR(double) r( 2 * p);
	85	CPPAD_TESTVECTOR(double) r( 2 * p);
86	86	w[0] = 1.;
87	87	r = f.Reverse(p, w);
88	88	jfac = 1.;

130	130	X[1] = y;
131	131	Independent(X);
132	132
133		// dependent variable vector
	133	// dependent variable vector
134	134	CPPAD_TESTVECTOR(AD<double>) Z(1);
135	135	AD<double> U = X[0] * X[1];
136		Z[0] = cos( U );
	136	Z[0] = cos( U );
137	137
138	138	// create f: X -> Z and vectors used for derivative calculations
139	139	// f(x, y) = cos(x, y)
140		ADFun<double> f(X, Z);
	140	ADFun<double> f(X, Z);
141	141	CPPAD_TESTVECTOR(double) v( 2 );
142	142	CPPAD_TESTVECTOR(double) w( 1 );
143	143
144		// check value
	144	// check value
145	145	double sin_u = sin( Value(U) );
146	146	double cos_u = cos( Value(U) );
147	147

155	155	v[1] = 0; // differential w.r.t. y
156	156	double yj = 1; // y^j
157	157	for(j = 1; j < p; j++)
158		{ w = f.Forward(j, v);
	158	{ w = f.Forward(j, v);
159	159
160	160	// compute j-th power of y
161	161	yj *= y ;

173	173	jfac *= j;
174	174
175	175	// check j-th derivative of z w.r.t x
176		ok &= NearEqual(jfacw[0], cosj yj, 1e-10 , 1e-10);
	176	ok &= NearEqual(jfacw[0], cosj yj, 1e-10 , 1e-10);
177	177
178	178	v[0] = 0.;
179	179	}
180	180
181	181	// reverse computation of partials of Taylor coefficients
182		CPPAD_TESTVECTOR(double) r( 2 * p);
	182	CPPAD_TESTVECTOR(double) r( 2 * p);
183	183	w[0] = 1.;
184	184	r = f.Reverse(p, w);
185	185	jfac = 1.;

227	227	X[1] = y;
228	228	Independent(X);
229	229
230		// dependent variable vector
	230	// dependent variable vector
231	231	CPPAD_TESTVECTOR(AD<double>) Z(1);
232	232	AD<double> U = X[0] * X[1];
233		Z[0] = cosh( U );
	233	Z[0] = cosh( U );
234	234
235	235	// create f: X -> Z and vectors used for derivative calculations
236	236	// f(x, y) = cosh(x, y)
237		ADFun<double> f(X, Z);
	237	ADFun<double> f(X, Z);
238	238	CPPAD_TESTVECTOR(double) v( 2 );
239	239	CPPAD_TESTVECTOR(double) w( 1 );
240	240
241		// check value
	241	// check value
242	242	double sinh_u = sinh( Value(U) );
243	243	double cosh_u = cosh( Value(U) );
244	244

252	252	v[1] = 0; // differential w.r.t. y
253	253	double yj = 1; // y^j
254	254	for(j = 1; j < p; j++)
255		{ w = f.Forward(j, v);
	255	{ w = f.Forward(j, v);
256	256
257	257	// compute j-th power of y
258	258	yj *= y ;

266	266	jfac *= j;
267	267
268	268	// check j-th derivative of z w.r.t x
269		ok &= NearEqual(jfacw[0], coshj yj, 1e-10 , 1e-10);
	269	ok &= NearEqual(jfacw[0], coshj yj, 1e-10 , 1e-10);
270	270
271	271	v[0] = 0.;
272	272	}
273	273
274	274	// reverse computation of partials of Taylor coefficients
275		CPPAD_TESTVECTOR(double) r( 2 * p);
	275	CPPAD_TESTVECTOR(double) r( 2 * p);
276	276	w[0] = 1.;
277	277	r = f.Reverse(p, w);
278	278	jfac = 1.;

316	316	X[1] = y;
317	317	Independent(X);
318	318
319		// dependent variable vector
	319	// dependent variable vector
320	320	CPPAD_TESTVECTOR(AD<double>) Z(1);
321	321	AD<double> U = X[0] * X[1];
322		Z[0] = sinh( U );
	322	Z[0] = sinh( U );
323	323
324	324	// create f: X -> Z and vectors used for derivative calculations
325	325	// f(x, y) = sinh(x, y)
326		ADFun<double> f(X, Z);
	326	ADFun<double> f(X, Z);
327	327	CPPAD_TESTVECTOR(double) v( 2 );
328	328	CPPAD_TESTVECTOR(double) w( 1 );
329	329
330		// check value
	330	// check value
331	331	double sinh_u = sinh( Value(U) );
332	332	double cosh_u = cosh( Value(U) );
333	333

341	341	v[1] = 0; // differential w.r.t. y
342	342	double yj = 1; // y^j
343	343	for(j = 1; j < p; j++)
344		{ w = f.Forward(j, v);
	344	{ w = f.Forward(j, v);
345	345
346	346	// compute j-th power of y
347	347	yj *= y ;

355	355	jfac *= j;
356	356
357	357	// check j-th derivative of z w.r.t x
358		ok &= NearEqual(jfacw[0], sinhj yj, 1e-10 , 1e-10);
	358	ok &= NearEqual(jfacw[0], sinhj yj, 1e-10 , 1e-10);
359	359
360	360	v[0] = 0.;
361	361	}
362	362
363	363	// reverse computation of partials of Taylor coefficients
364		CPPAD_TESTVECTOR(double) r( 2 * p);
	364	CPPAD_TESTVECTOR(double) r( 2 * p);
365	365	w[0] = 1.;
366	366	r = f.Reverse(p, w);
367	367	jfac = 1.;

396	396	{ bool ok = Sin() & Cos() & Cosh() & Sinh();
397	397	return ok;
398	398	}
399
	399

+9

-9

test_more/sinh.cpp less more

0		/* $Id: sinh.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: sinh.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

26	26	U[0] = 1.;
27	27	Independent(U);
28	28
29		// dependent variable vector
	29	// dependent variable vector
30	30	CPPAD_TESTVECTOR(AD<double>) Z(1);
31		Z[0] = sinh(U[0]);
	31	Z[0] = sinh(U[0]);
32	32
33	33	// create f: U -> Z and vectors used for derivative calculations
34		ADFun<double> f(U, Z);
	34	ADFun<double> f(U, Z);
35	35	CPPAD_TESTVECTOR(double) v(1);
36	36	CPPAD_TESTVECTOR(double) w(1);
37	37
38		// check value
	38	// check value
39	39	double sin_u = sinh( Value(U[0]) );
40	40	double cos_u = cosh( Value(U[0]) );
41	41

47	47	double jfac = 1.;
48	48	v[0] = 1.;
49	49	for(j = 1; j < p; j++)
50		{ w = f.Forward(j, v);
	50	{ w = f.Forward(j, v);
51	51
52	52	double value;
53	53	if( j % 2 == 1 )

60	60	}
61	61
62	62	// reverse computation of partials of Taylor coefficients
63		CPPAD_TESTVECTOR(double) r(p);
	63	CPPAD_TESTVECTOR(double) r(p);
64	64	w[0] = 1.;
65	65	r = f.Reverse(p, w);
66	66	jfac = 1.;

+12

-12

test_more/sparse_hessian.cpp less more

0		/* $Id: sparse_hessian.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: sparse_hessian.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

37	37	check[ell] = 0.0;
38	38
39	39	for(i = 0; i < m; i++)
40		{ AD<double> diff = a_x[i+1] - a_x[i];
41		a_y[i] = 0.5 * diff * diff / double(i+2);
	40	{ AD<double> diff = a_x[i+1] - a_x[i];
	41	a_y[i] = 0.5 * diff * diff / double(i+2);
42	42	w[i] = double(i+1);
43	43	ell = i * n + i;
44	44	check[ell] += w[i] / double(i+2);

52	52
53	53	// create f: x -> y
54	54	CppAD::ADFun<double> f(a_x, a_y);
55
	55
56	56	// determine the sparsity pattern p for Hessian of w^T f
57	57	typedef CppAD::vector< std::set<size_t> > VectorSet;
58	58	VectorSet p_r(n);

80	80	c[k] = i+1;
81	81	k++;
82	82	}
83		}
	83	}
84	84	ok &= k == K;
85	85
86	86	// test computing sparse Hessian

98	98	}
99	99
100	100
101		template <class VectorBase, class VectorBool>
	101	template <class VectorBase, class VectorBool>
102	102	bool bool_case()
103	103	{ bool ok = true;
104	104	using CppAD::AD;

126	126	for(i = 0; i < n; i++)
127	127	x[i] = double(i);
128	128
129		// second derivative of y[1]
	129	// second derivative of y[1]
130	130	VectorBase w(m);
131	131	w[0] = 1.;
132	132	VectorBase h( n * n );

164	164
165	165	return ok;
166	166	}
167		template <class VectorBase, class VectorSet>
	167	template <class VectorBase, class VectorSet>
168	168	bool set_case()
169	169	{ bool ok = true;
170	170	using CppAD::AD;

192	192	for(i = 0; i < n; i++)
193	193	x[i] = double(i);
194	194
195		// second derivative of y[1]
	195	// second derivative of y[1]
196	196	VectorBase w(m);
197	197	w[0] = 1.;
198	198	VectorBase h( n * n );

228	228
229	229	return ok;
230	230	}
231		} // End empty namespace
	231	} // End empty namespace
232	232	# include <vector>
233	233	# include <valarray>
234	234	bool sparse_hessian(void)

+11

-11

test_more/sparse_vec_ad.cpp less more

0		/* $Id: sparse_vec_ad.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: sparse_vec_ad.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

17	17	using namespace CppAD;
18	18
19	19	// dimension of the domain space
20		size_t n = 3;
	20	size_t n = 3;
21	21
22	22	size_t i, j;
23	23
24		// independent variable vector
	24	// independent variable vector
25	25	CPPAD_TESTVECTOR(AD<double>) X(n);
26	26	for(j = 0; j < n; j++)
27		X[j] = AD<double>(j);
	27	X[j] = AD<double>(j);
28	28	Independent(X);
29	29
30	30	// dependent variable vector

60	60	{ for(i = 0; i < m; i++)
61	61	Check[ i * m + j ] = (j <= i);
62	62	}
63
	63
64	64	// create function object F : X -> Y
65	65	ADFun<double> F(X, Y);
66	66

79	79	for(i = 0; i < m; i++)
80	80	{ for(j = 0; j < n; j++)
81	81	ok &= (Px[i * m + j] == Check[i * m + j]);
82		}
	82	}
83	83
84	84	// evaluate the dependency matrix for F(Identity(x))
85	85	CPPAD_TESTVECTOR( bool ) Py(m * n);

89	89	for(i = 0; i < m; i++)
90	90	{ for(j = 0; j < n; j++)
91	91	ok &= (Py[i * m + j] == Check[i * m + j]);
92		}
	92	}
93	93
94		// test sparsity pattern for Hessian of F_2 ( Identity(x) )
	94	// test sparsity pattern for Hessian of F_2 ( Identity(x) )
95	95	CPPAD_TESTVECTOR(bool) Hy(m);
96	96	for(i = 0; i < m; i++)
97	97	Hy[i] = false;

103	103	ok &= (Pxx[i * n + j] == false );
104	104	}
105	105
106		// test sparsity pattern for Hessian of F_1 ( Identity(x) )
	106	// test sparsity pattern for Hessian of F_1 ( Identity(x) )
107	107	for(i = 0; i < m; i++)
108	108	Hy[i] = false;
109	109	Hy[1] = true;

+28

-28

test_more/sqrt.cpp less more

0		/* $Id: sqrt.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: sqrt.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

58	58	v = f.Reverse(1,w);
59	59	ok &= NearEqual(v[s], .25 * pow(4., -.75), 1e-10 , 1e-10); // dy/ds
60	60
61		// forward computation of second partials w.r.t s
	61	// forward computation of second partials w.r.t s
62	62	v[s] = 1.;
63	63	w = f.Forward(1, v);
64	64	v[s] = 0.;
65	65	w = f.Forward(2, v);
66	66	ok &= NearEqual( // d^2 y / (ds ds)
67		2. * w[y] ,
	67	2. * w[y] ,
68	68	-.75 * .25 * pow(4., -1.75),
69	69	1e-10 ,
70		1e-10
71		);
	70	1e-10
	71	);
72	72
73	73	// reverse computation of second partials of y
74	74	CPPAD_TESTVECTOR(double) r( f.Domain() * 2 );

76	76	w[y] = 1.;
77	77	r = f.Reverse(2, w);
78	78	ok &= NearEqual( // d^2 y / (ds ds)
79		r[2 * s + 1] ,
	79	r[2 * s + 1] ,
80	80	-.75 * .25 * pow(4., -1.75),
81	81	1e-10 ,
82		1e-10
83		);
	82	1e-10
	83	);
84	84
85	85	return ok;
86	86

95	95	Independent(U);
96	96
97	97	// a temporary values
98		AD<double> x = U[0] * U[0];
99
100		// dependent variable vector
	98	AD<double> x = U[0] * U[0];
	99
	100	// dependent variable vector
101	101	CPPAD_TESTVECTOR(AD<double>) Z(1);
102	102	Z[0] = sqrt( x ); // z = sqrt( u * u )
103	103
104	104	// create f: U -> Z and vectors used for derivative calculations
105		ADFun<double> f(U, Z);
	105	ADFun<double> f(U, Z);
106	106	CPPAD_TESTVECTOR(double) v(1);
107	107	CPPAD_TESTVECTOR(double) w(1);
108	108
109		// check value
	109	// check value
110	110	ok &= NearEqual(U[0] , Z[0], 1e-10 , 1e-10);
111	111
112	112	// forward computation of partials w.r.t. u

117	117	v[0] = 1.;
118	118	for(j = 1; j < p; j++)
119	119	{ jfac *= j;
120		w = f.Forward(j, v);
	120	w = f.Forward(j, v);
121	121	ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
122	122	v[0] = 0.;
123	123	value = 0.;
124	124	}
125	125
126	126	// reverse computation of partials of Taylor coefficients
127		CPPAD_TESTVECTOR(double) r(p);
	127	CPPAD_TESTVECTOR(double) r(p);
128	128	w[0] = 1.;
129	129	r = f.Reverse(p, w);
130	130	jfac = 1.;

162	162	CPPAD_TESTVECTOR(double) y1( f.Range() );
163	163	x1[0] = 1.;
164	164	y1 = f.Forward(1, x1);
165		ok &= NearEqual(y1[0], exp(x/2.)/2., 1e-10 , 1e-10);
	165	ok &= NearEqual(y1[0], exp(x/2.)/2., 1e-10 , 1e-10);
166	166
167	167	// forward computation of second Taylor coefficient
168	168	CPPAD_TESTVECTOR(double) x2( f.Domain() );
169	169	CPPAD_TESTVECTOR(double) y2( f.Range() );
170	170	x2[0] = 0.;
171	171	y2 = f.Forward(2, x2);
172		ok &= NearEqual(2.*y2[0] , exp(x/2.)/4., 1e-10 , 1e-10 );
	172	ok &= NearEqual(2.*y2[0] , exp(x/2.)/4., 1e-10 , 1e-10 );
173	173
174	174	// forward computation of third Taylor coefficient
175	175	CPPAD_TESTVECTOR(double) x3( f.Domain() );
176	176	CPPAD_TESTVECTOR(double) y3( f.Range() );
177	177	x3[0] = 0.;
178	178	y3 = f.Forward(3, x3);
179		ok &= NearEqual(6.*y3[0] , exp(x/2.)/8., 1e-10 , 1e-10 );
	179	ok &= NearEqual(6.*y3[0] , exp(x/2.)/8., 1e-10 , 1e-10 );
180	180
181	181	// reverse computation of deritavitve of Taylor coefficients
182	182	CPPAD_TESTVECTOR(double) r( f.Domain() * 4 );
183	183	CPPAD_TESTVECTOR(double) w(1);
184	184	w[0] = 1.;
185	185	r = f.Reverse(4, w);
186		ok &= NearEqual(r[0], exp(x/2.)/2., 1e-10 , 1e-10);
187		ok &= NearEqual(r[1], exp(x/2.)/4., 1e-10 , 1e-10 );
188		ok &= NearEqual(2.*r[2], exp(x/2.)/8., 1e-10 , 1e-10 );
189		ok &= NearEqual(6.*r[3], exp(x/2.)/16., 1e-10 , 1e-10 );
	186	ok &= NearEqual(r[0], exp(x/2.)/2., 1e-10 , 1e-10);
	187	ok &= NearEqual(r[1], exp(x/2.)/4., 1e-10 , 1e-10 );
	188	ok &= NearEqual(2.*r[2], exp(x/2.)/8., 1e-10 , 1e-10 );
	189	ok &= NearEqual(6.*r[3], exp(x/2.)/16., 1e-10 , 1e-10 );
190	190
191	191	return ok;
192	192

197	197	bool Sqrt(void)
198	198	{ bool ok = true;
199	199	ok &= SqrtTestOne();
200		ok &= SqrtTestTwo();
201		ok &= SqrtTestThree();
202		return ok;
203		}
	200	ok &= SqrtTestTwo();
	201	ok &= SqrtTestThree();
	202	return ok;
	203	}

+4

-4

test_more/std_math.cpp less more

0		/* $Id: std_math.cpp 3060 2013-12-27 20:38:57Z bradbell $ */
	0	// $Id: std_math.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

19	19	typedef CppAD::AD< ADdouble > ADDdouble;
20	20
21	21	bool std_math(void)
22		{ using CppAD::NearEqual;
	22	{ using CppAD::NearEqual;
23	23	bool ok = true;
24	24	ADDdouble half(.5);
25	25	ADDdouble one(1.);

+20

-20

test_more/sub.cpp less more

0		/* $Id: sub.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: sub.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

40	40	// dependent variable values
41	41	Z[x] = U[s] - U[t]; // AD<double> - AD<double>
42	42	Z[y] = Z[x] - 1.; // AD<double> - double
43		Z[z] = 1. - Z[y]; // double - AD<double>
	43	Z[z] = 1. - Z[y]; // double - AD<double>
44	44
45	45	// create f: U -> Z and vectors used for derivative calculations
46	46	ADFun<double> f(U, Z);

86	86
87	87	AD<double> a = 2. * U[0] - 1.; // AD<double> - double
88	88	AD<double> b = a - 2; // AD<double> - int
89		AD<double> c = 3. - b; // double - AD<double>
90		AD<double> d = 4 - c; // int - AD<double>
	89	AD<double> c = 3. - b; // double - AD<double>
	90	AD<double> d = 4 - c; // int - AD<double>
91	91
92		// dependent variable vector
	92	// dependent variable vector
93	93	CPPAD_TESTVECTOR(AD<double>) Z(1);
94	94	Z[0] = U[0] - d; // AD<double> - AD<double>
95	95
96	96	// create f: U -> Z and vectors used for derivative calculations
97		ADFun<double> f(U, Z);
	97	ADFun<double> f(U, Z);
98	98	CPPAD_TESTVECTOR(double) v(1);
99	99	CPPAD_TESTVECTOR(double) w(1);
100	100
101		// check value
	101	// check value
102	102	ok &= NearEqual(Value(Z[0]) , u0-4+3-2*u0+1+2, 1e-10 , 1e-10);
103	103
104	104	// forward computation of partials w.r.t. u

109	109	v[0] = 1.;
110	110	for(j = 1; j < p; j++)
111	111	{ jfac *= j;
112		w = f.Forward(j, v);
	112	w = f.Forward(j, v);
113	113	ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
114	114	v[0] = 0.;
115	115	value = 0.;
116	116	}
117	117
118	118	// reverse computation of partials of Taylor coefficients
119		CPPAD_TESTVECTOR(double) r(p);
	119	CPPAD_TESTVECTOR(double) r(p);
120	120	w[0] = 1.;
121	121	r = f.Reverse(p, w);
122	122	jfac = 1.;

134	134	{ bool ok = true;
135	135	using namespace CppAD;
136	136
137		// special cases where tests above check OK and SubpvOp
138		// implementation is known to be worng.
	137	// special cases where tests above check OK and SubpvOp
	138	// implementation is known to be worng.
139	139	// Probably two minuses make a plus.
140	140	size_t n = 1;
141	141	CPPAD_TESTVECTOR(AD<double>) X(n);

144	144	size_t m = 1;
145	145	CPPAD_TESTVECTOR(AD<double>) Y(m);
146	146	Y[0] = 1. - X[0];
147		ADFun<double> f(X, Y);
148
	147	ADFun<double> f(X, Y);
	148
149	149	CPPAD_TESTVECTOR(double) w(m), dw(n);
150	150	w[0] = 1.;
151	151	dw = f.Reverse(1, w);

169	169	if( 0. < X[0] && X[0] < 10. )
170	170	Y[0] = X[0] - 2.;
171	171	else Y[0] = X[0] - 2.;
172		ADFun<double> f(X, Y);
173
	172	ADFun<double> f(X, Y);
	173
174	174	CPPAD_TESTVECTOR(double) y(m), x(n);
175	175	x[0] = 1.;
176	176	y = f.Forward(0, x);
177	177	ok &= (y[0] == -1.);
178
	178
179	179	CPPAD_TESTVECTOR(double) dy(m), dx(n);
180	180	dx[0] = 1.;
181	181	dy = f.Forward(1, dx);

190	190	bool Sub(void)
191	191	{ bool ok = true;
192	192	ok &= One();
193		ok &= Two();
194		ok &= Three();
	193	ok &= Two();
	194	ok &= Three();
195	195	ok &= Four();
196	196	return ok;
197	197	}

+14

-14

test_more/sub_eq.cpp less more

0		/* $Id: sub_eq.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: sub_eq.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

35	35	size_t y = 1;
36	36
37	37	// dependent variable values
38		Z[x] = U[s];
	38	Z[x] = U[s];
39	39	Z[y] = U[t];
40		Z[x] -= U[t]; // AD<double> -= AD<double>
41		Z[y] -= 5.; // AD<double> -= double
	40	Z[x] -= U[t]; // AD<double> -= AD<double>
	41	Z[y] -= 5.; // AD<double> -= double
42	42
43	43	// create f: U -> Z and vectors used for derivative calculations
44	44	ADFun<double> f(U, Z);

75	75	// independent variable vector
76	76	double u0 = .5;
77	77	CPPAD_TESTVECTOR(AD<double>) U(1);
78		U[0] = u0;
	78	U[0] = u0;
79	79	Independent(U);
80	80
81		// dependent variable vector
	81	// dependent variable vector
82	82	CPPAD_TESTVECTOR(AD<double>) Z(1);
83	83	Z[0] = U[0]; // initial value
84	84	Z[0] -= 2; // AD<double> -= int
85	85	Z[0] -= 4.; // AD<double> -= double
86		Z[0] -= 2 * U[0]; // AD<double> -= AD<double>
	86	Z[0] -= 2 * U[0]; // AD<double> -= AD<double>
87	87
88	88	// create f: U -> Z and vectors used for derivative calculations
89		ADFun<double> f(U, Z);
	89	ADFun<double> f(U, Z);
90	90	CPPAD_TESTVECTOR(double) v(1);
91	91	CPPAD_TESTVECTOR(double) w(1);
92	92
93		// check value
	93	// check value
94	94	ok &= NearEqual(Z[0] , u0-2-4-2*u0, 1e-10 , 1e-10);
95	95
96	96	// forward computation of partials w.r.t. u

101	101	v[0] = 1.;
102	102	for(j = 1; j < p; j++)
103	103	{ jfac *= j;
104		w = f.Forward(j, v);
	104	w = f.Forward(j, v);
105	105	ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
106	106	v[0] = 0.;
107	107	value = 0.;
108	108	}
109	109
110	110	// reverse computation of partials of Taylor coefficients
111		CPPAD_TESTVECTOR(double) r(p);
	111	CPPAD_TESTVECTOR(double) r(p);
112	112	w[0] = 1.;
113	113	r = f.Reverse(p, w);
114	114	jfac = 1.;

127	127	bool SubEq(void)
128	128	{ bool ok = true;
129	129	ok &= SubEqTestOne();
130		ok &= SubEqTestTwo();
	130	ok &= SubEqTestTwo();
131	131	return ok;
132	132	}

+4

-4

test_more/sub_zero.cpp less more

0		/* $Id: sub_zero.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: sub_zero.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

19	19	typedef CppAD::AD< ADdouble > ADDdouble;
20	20
21	21	bool SubZero(void)
22		{
	22	{
23	23	using namespace CppAD;
24	24
25	25	bool ok = true;

+10

-10

test_more/test_vector.cpp less more

0		/* $Id: test_vector.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: test_vector.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

24	24	size_t n = 1;
25	25	double x0 = 0.5;
26	26	CPPAD_TEST_VECTOR< AD<double> > x(n);
27		x[0] = x0;
	27	x[0] = x0;
28	28
29	29	// declare independent variables and start tape recording
30	30	CppAD::Independent(x);

32	32	// some binary addition operations
33	33	AD<double> a = x[0] + 1.; // AD<double> + double
34	34	AD<double> b = a + 2; // AD<double> + int
35		AD<double> c = 3. + b; // double + AD<double>
36		AD<double> d = 4 + c; // int + AD<double>
	35	AD<double> c = 3. + b; // double + AD<double>
	36	AD<double> d = 4 + c; // int + AD<double>
37	37
38		// range space vector
	38	// range space vector
39	39	size_t m = 1;
40	40	CPPAD_TEST_VECTOR< AD<double> > y(m);
41		y[0] = d + x[0]; // AD<double> + AD<double>
	41	y[0] = d + x[0]; // AD<double> + AD<double>
42	42
43	43	// create f: x -> y and stop tape recording
44		CppAD::ADFun<double> f(x, y);
	44	CppAD::ADFun<double> f(x, y);
45	45
46		// check value
	46	// check value
47	47	ok &= NearEqual(y[0] , 2. * x0 + 10, 1e-10 , 1e-10);
48	48
49	49	// forward computation of partials w.r.t. x[0]

+3

-3

test_more/value.cpp less more

0		/* $Id: value.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: value.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

+30

-30

test_more/vec_ad.cpp less more

0		/* $Id: vec_ad.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: vec_ad.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

47	47
48	48	// check array values (while not taping)
49	49	for(i = 0; i < n; i++)
50		ok &= ( V[i] == 2. * double(n - i) );
51
52		// independent variable
	50	ok &= ( V[i] == 2. * double(n - i) );
	51
	52	// independent variable
53	53	CPPAD_TESTVECTOR(AD<double>) X(1);
54	54	X[0] = double(n - 1);
55	55	Independent(X);

85	85	x[0] = double(i);
86	86	z = f.Forward(0, x);
87	87	vx = double(n - i);
88		ok &= NearEqual(z[0], sin(x[0]) * vx, 1e-10, 1e-10);
	88	ok &= NearEqual(z[0], sin(x[0]) * vx, 1e-10, 1e-10);
89	89
90	90	// note that derivative of v[x] w.r.t. x is zero
91	91	dx[0] = 1.;
92	92	dz = f.Forward(1, dx);
93		ok &= NearEqual(dz[0], cos(x[0]) * vx, 1e-10, 1e-10);
	93	ok &= NearEqual(dz[0], cos(x[0]) * vx, 1e-10, 1e-10);
94	94
95	95	// reverse mode calculation of same value
96	96	dz[0] = 1.;
97	97	dx = f.Reverse(1, dz);
98		ok &= NearEqual(dx[0], cos(x[0]) * vx, 1e-10, 1e-10);
99		}
100
101
102		return ok;
103		}
104
105		// create the discrete function AD<double> Floor(const AD<double> &X)
	98	ok &= NearEqual(dx[0], cos(x[0]) * vx, 1e-10, 1e-10);
	99	}
	100
	101
	102	return ok;
	103	}
	104
	105	// create the discrete function AD<double> Floor(const AD<double> &X)
106	106	double Floor(const double &x)
107		{ return std::floor(x); }
	107	{ return std::floor(x); }
108	108	CPPAD_DISCRETE_FUNCTION(double, Floor)
109	109
110	110	bool VecADTestTwo(void)
111	111	{ bool ok = true;
112	112	using namespace CppAD;
113
	113
114	114	double pi = 4. * CppAD::atan(1.);
115	115	size_t nx = 10; // number of x grid point
116	116	double xLow = 0; // minimum value for x

122	122	VecAD<double> Data(nx);
123	123	size_t i;
124	124	for(i = 0; i < nx; i++)
125		{ xCur = xLow + double(i) * xStep;
	125	{ xCur = xLow + double(i) * xStep;
126	126	// use size_t indexing of Data while not taping
127		Data[i] = CppAD::sin(xCur);
128		}
129
130		// declare independent variable
	127	Data[i] = CppAD::sin(xCur);
	128	}
	129
	130	// declare independent variable
131	131	CPPAD_TESTVECTOR(AD<double>) X(1);
132	132	X[0] = 2.;
133	133	Independent(X);

173	173
174	174	# include <limits>
175	175	bool SecondOrderReverse(void)
176		{ // Bradley M. Bell 2009-07-06
	176	{ // Bradley M. Bell 2009-07-06
177	177	// Reverse mode for LdpOp was only modifying the highest order partial
178	178	// This test demonstrated the bug
179	179	bool ok = true;

197	197	// The LdvOp instruction corresponds to the index being a variable.
198	198	AD<double> one = X[0] - 1; // one in a variable here
199	199	Z[one] = X[0] + 1.;
200
	200
201	201
202	202	// Compute a function where the second order partial for y
203	203	// depends on the first order partials for z

224	224
225	225	// check first derivative in dw
226	226	double check = 2. * (Value( X[0] ) + 1.);
227		ok &= NearEqual(dw[0], check, eps, eps);
	227	ok &= NearEqual(dw[0], check, eps, eps);
228	228
229	229	// check second derivative in dw
230	230	check = 2.;
231		ok &= NearEqual(dw[1], check, eps, eps);
	231	ok &= NearEqual(dw[1], check, eps, eps);
232	232
233	233	// Test LdvOp
234	234	// second order reverse (test exp_if_true case)

239	239
240	240	// check first derivative in dw
241	241	check = 2. * (Value( X[0] ) + 1.);
242		ok &= NearEqual(dw[0], check, eps, eps);
	242	ok &= NearEqual(dw[0], check, eps, eps);
243	243
244	244	// check second derivative in dw
245	245	check = 2.;
246		ok &= NearEqual(dw[1], check, eps, eps);
	246	ok &= NearEqual(dw[1], check, eps, eps);
247	247
248	248	return ok;
249	249	}

253	253	bool VecAD(void)
254	254	{ bool ok = true;
255	255	ok &= VecADTestOne();
256		ok &= VecADTestTwo();
	256	ok &= VecADTestTwo();
257	257	ok &= SecondOrderReverse();
258	258	return ok;
259	259	}

+5

-5

test_more/vec_ad_par.cpp less more

0		/* $Id: vec_ad_par.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: vec_ad_par.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

19	19	typedef CppAD::AD< ADdouble > ADDdouble;
20	20
21	21	bool VecADPar(void)
22		{
	22	{
23	23	using namespace CppAD;
24	24
25	25	bool ok = true;

36	36	VecAD< ADdouble > v(2);
37	37	ADDdouble zero(0);
38	38	ADDdouble one(1);
39		v[zero] = x[0]; // these two parameter values are equal,
	39	v[zero] = x[0]; // these two parameter values are equal,
40	40	v[one] = x[1]; // but they are not identically equal
41	41
42	42	CPPAD_TESTVECTOR( ADDdouble ) z(1);

+13

-13

test_more/vec_unary.cpp less more

0		/* $Id: vec_unary.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
	0	// $Id: vec_unary.cpp 3785 2016-02-08 12:53:06Z bradbell $
1	1	/* --------------------------------------------------------------------------
2		CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell
	2	CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
3	3
4	4	CppAD is distributed under multiple licenses. This distribution is under
5		the terms of the
	5	the terms of the
6	6	GNU General Public License Version 3.
7	7
8	8	A copy of this license is included in the COPYING file of this distribution.

17	17
18	18
19	19	bool VecUnary(void)
20		{
	20	{
21	21	using namespace CppAD;
22	22	using CppAD::abs;
23	23	using CppAD::sin;

43	43	AD<double> j;
44	44
45	45	j = 0.;
46		Y[j] = X[0];
	46	Y[j] = X[0];
47	47	Z[0] = -Y[j];
48	48
49	49	j = 1.;
50		Y[j] = X[1];
	50	Y[j] = X[1];
51	51	Z[1] = sin( Y[j] );
52	52
53	53	j = 2.;
54		Y[j] = X[2];
	54	Y[j] = X[2];
55	55	Z[2] = abs( Y[j] );
56	56
57	57	j = 3.;
58		Y[j] = X[3];
	58	Y[j] = X[3];
59	59	Z[3] = atan( Y[j] );
60	60
61	61	j = 4.;
62		Y[j] = X[4];
	62	Y[j] = X[4];
63	63	Z[4] = cos( Y[j] );
64	64
65	65	j = 5.;
66		Y[j] = X[5];
	66	Y[j] = X[5];
67	67	Z[5] = exp( Y[j] );
68	68
69	69	j = 6.;
70		Y[j] = X[6];
	70	Y[j] = X[6];
71	71	Z[6] = log( Y[j] );
72	72
73	73	j = 7.;
74		Y[j] = X[7];
	74	Y[j] = X[7];
75	75	Z[7] = sqrt( Y[j] );
76	76
77
	77
78	78	ADFun<double> f(X, Z);
79	79	CPPAD_TESTVECTOR(double) x(n);
80	80	CPPAD_TESTVECTOR(double) z(n);