CppAD: A C++ Algorithmic Differentiation Package  20171217
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
sign_op.hpp
Go to the documentation of this file.
1 // $Id: sign_op.hpp 3865 2017-01-19 01:57:55Z bradbell $
2 # ifndef CPPAD_LOCAL_SIGN_OP_HPP
3 # define CPPAD_LOCAL_SIGN_OP_HPP
4 
5 /* --------------------------------------------------------------------------
6 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
7 
8 CppAD is distributed under multiple licenses. This distribution is under
9 the terms of the
10  Eclipse Public License Version 1.0.
11 
12 A copy of this license is included in the COPYING file of this distribution.
13 Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
14 -------------------------------------------------------------------------- */
15 
16 
17 namespace CppAD { namespace local { // BEGIN_CPPAD_LOCAL_NAMESPACE
18 /*!
19 \file sign_op.hpp
20 Forward and reverse mode calculations for z = sign(x).
21 */
22 
23 /*!
24 Compute forward mode Taylor coefficient for result of op = SignOp.
25 
26 The C++ source code corresponding to this operation is
27 \verbatim
28  z = sign(x)
29 \endverbatim
30 
31 \copydetails CppAD::local::forward_unary1_op
32 */
33 template <class Base>
34 inline void forward_sign_op(
35  size_t p ,
36  size_t q ,
37  size_t i_z ,
38  size_t i_x ,
39  size_t cap_order ,
40  Base* taylor )
41 {
42  // check assumptions
43  CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
44  CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
45  CPPAD_ASSERT_UNKNOWN( q < cap_order );
46  CPPAD_ASSERT_UNKNOWN( p <= q );
47 
48  // Taylor coefficients corresponding to argument and result
49  Base* x = taylor + i_x * cap_order;
50  Base* z = taylor + i_z * cap_order;
51 
52  if( p == 0 )
53  { z[0] = sign(x[0]);
54  p++;
55  }
56  for(size_t j = p; j <= q; j++)
57  z[j] = Base(0.);
58 }
59 /*!
60 Multiple direction forward mode Taylor coefficient for op = SignOp.
61 
62 The C++ source code corresponding to this operation is
63 \verbatim
64  z = sign(x)
65 \endverbatim
66 
67 \copydetails CppAD::local::forward_unary1_op_dir
68 */
69 template <class Base>
70 inline void forward_sign_op_dir(
71  size_t q ,
72  size_t r ,
73  size_t i_z ,
74  size_t i_x ,
75  size_t cap_order ,
76  Base* taylor )
77 {
78  // check assumptions
79  CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
80  CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
81  CPPAD_ASSERT_UNKNOWN( 0 < q );
82  CPPAD_ASSERT_UNKNOWN( q < cap_order );
83 
84  // Taylor coefficients corresponding to argument and result
85  size_t num_taylor_per_var = (cap_order-1) * r + 1;
86  size_t m = (q - 1) * r + 1;
87  Base* z = taylor + i_z * num_taylor_per_var;
88 
89  for(size_t ell = 0; ell < r; ell++)
90  z[m+ell] = Base(0.);
91 }
92 
93 /*!
94 Compute zero order forward mode Taylor coefficient for result of op = SignOp.
95 
96 The C++ source code corresponding to this operation is
97 \verbatim
98  z = sign(x)
99 \endverbatim
100 
101 \copydetails CppAD::local::forward_unary1_op_0
102 */
103 template <class Base>
104 inline void forward_sign_op_0(
105  size_t i_z ,
106  size_t i_x ,
107  size_t cap_order ,
108  Base* taylor )
109 {
110 
111  // check assumptions
112  CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
113  CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
114  CPPAD_ASSERT_UNKNOWN( 0 < cap_order );
115 
116  // Taylor coefficients corresponding to argument and result
117  Base x0 = *(taylor + i_x * cap_order);
118  Base* z = taylor + i_z * cap_order;
119 
120  z[0] = sign(x0);
121 }
122 /*!
123 Compute reverse mode partial derivatives for result of op = SignOp.
124 
125 The C++ source code corresponding to this operation is
126 \verbatim
127  z = sign(x)
128 \endverbatim
129 
130 \copydetails CppAD::local::reverse_unary1_op
131 */
132 
133 template <class Base>
134 inline void reverse_sign_op(
135  size_t d ,
136  size_t i_z ,
137  size_t i_x ,
138  size_t cap_order ,
139  const Base* taylor ,
140  size_t nc_partial ,
141  Base* partial )
142 {
143  // check assumptions
144  CPPAD_ASSERT_UNKNOWN( NumArg(SignOp) == 1 );
145  CPPAD_ASSERT_UNKNOWN( NumRes(SignOp) == 1 );
146  CPPAD_ASSERT_UNKNOWN( d < cap_order );
147  CPPAD_ASSERT_UNKNOWN( d < nc_partial );
148 
149  // nothing to do because partials of sign are zero
150  return;
151 }
152 
153 } } // END_CPPAD_LOCAL_NAMESPACE
154 # endif
CppAD::local::forward_sign_op
void forward_sign_op(size_t p, size_t q, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Compute forward mode Taylor coefficient for result of op = SignOp.
Definition: sign_op.hpp:34
CppAD::local::forward_sign_op_dir
void forward_sign_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple direction forward mode Taylor coefficient for op = SignOp.
Definition: sign_op.hpp:70
CppAD::local::NumArg
size_t NumArg(OpCode op)
Number of arguments for a specified operator.
Definition: op_code.hpp:175
CppAD::local::reverse_sign_op
void reverse_sign_op(size_t d, size_t i_z, size_t i_x, size_t cap_order, const Base *taylor, size_t nc_partial, Base *partial)
Compute reverse mode partial derivatives for result of op = SignOp.
Definition: sign_op.hpp:134
CppAD::local::NumRes
size_t NumRes(OpCode op)
Number of variables resulting from the specified operation.
Definition: op_code.hpp:281
CppAD::local::forward_sign_op_0
void forward_sign_op_0(size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Compute zero order forward mode Taylor coefficient for result of op = SignOp.
Definition: sign_op.hpp:104
CPPAD_ASSERT_UNKNOWN
#define CPPAD_ASSERT_UNKNOWN(exp)
Check that exp is true, if not terminate execution.
Definition: cppad_assert.hpp:139
CppAD::sign
std::complex< double > sign(const std::complex< double > &x)
Definition: base_complex.hpp:242