inline AD<Base>::AD(const T &t)
: value_(Base(t))
, id_(CPPAD_MAX_NUM_THREADS)
, taddr_(0)
{ }
remove_whitespace(T start) :
super_t(Base(static_cast< T >(start)))
{}
static void main1(int argc, const char** argv)
{
print_g = true; // want to be able to see lprintfs
if (argc != 2)
Err("Usage: shapetostasm31 file.shape");
ShapeFile sh; // contents of the shape file
sh.Open_(argv[1]);
if (sh.shapes_[0].rows == 77)
lprintf("Converting 77 point to 76 point shapes\n");
char newpath[SLEN];
sprintf(newpath, "%s_stasm31.shape", Base(argv[1]));
lprintf("Generating %s ", newpath);
FILE* file = fopen(newpath, "wb");
if (!file)
Err("Cannot open %s for writing", newpath);
Fprintf(file, "ss %s\n\n", newpath);
Fprintf(file, "Directories %s\n\n", sh.dirs_);
Pacifier pacifier(sh.nshapes_);
for (int ishape = 0; ishape < sh.nshapes_; ishape++)
{
// we need the image width and height to convert the coords
const char* imgpath = PathGivenDirs(sh.bases_[ishape], sh.dirs_, sh.shapepath_);
cv::Mat_<unsigned char> img(cv::imread(imgpath, CV_LOAD_IMAGE_GRAYSCALE));
if (!img.data)
Err("Cannot load %s", imgpath);
Shape shape;
if (sh.shapes_[0].rows == 77)
shape = (ConvertShape(sh.shapes_[ishape], 76)); // convert 76 point shape
else
shape = sh.shapes_[ishape].clone();
CV_Assert(shape.rows);
Fprintf(file, "\"%4.4x %s\"\n",
NewBits(sh.bits_[ishape]), sh.bases_[ishape].c_str());
Fprintf(file, "{ %d %d\n", shape.rows, shape.cols);
const int cols2 = img.cols / 2;
const int rows2 = img.rows / 2;
for (int i = 0; i < shape.rows; i++)
{
if (!PointUsed(shape, i))
Fprintf(file, "0 0\n");
else
{
double oldx = shape(i, IX) - cols2;
double oldy = rows2 - shape(i, IY) - 1;
if (!PointUsed(oldx, oldy))
oldx = XJITTER;
Print(file, oldx, " ");
Print(file, oldy, "\n");
}
}
Fprintf(file, "}\n");
pacifier.Print_(ishape);
}
pacifier.End_();
fclose(file);
lprintf("\n");
}
void test()
{
// This function tests C++0x 5.16
// p1 (contextually convert to bool)
int i1 = ToBool() ? 0 : 1;
// p2 (one or both void, and throwing)
i1 ? throw 0 : throw 1;
i1 ? test() : throw 1;
i1 ? throw 0 : test();
i1 ? test() : test();
i1 = i1 ? throw 0 : 0;
i1 = i1 ? 0 : throw 0;
i1 ? 0 : test(); // expected-error {{right operand to ? is void, but left operand is of type 'int'}}
i1 ? test() : 0; // expected-error {{left operand to ? is void, but right operand is of type 'int'}}
(i1 ? throw 0 : i1) = 0; // expected-error {{expression is not assignable}}
(i1 ? i1 : throw 0) = 0; // expected-error {{expression is not assignable}}
// p3 (one or both class type, convert to each other)
// b1 (lvalues)
Base base;
Derived derived;
Convertible conv;
Base &bar1 = i1 ? base : derived;
Base &bar2 = i1 ? derived : base;
Base &bar3 = i1 ? base : conv;
Base &bar4 = i1 ? conv : base;
// these are ambiguous
BadBase bb;
BadDerived bd;
(void)(i1 ? bb : bd); // expected-error {{conditional expression is ambiguous; 'struct BadBase' can be converted to 'struct BadDerived' and vice versa}}
(void)(i1 ? bd : bb); // expected-error {{conditional expression is ambiguous}}
// curiously enough (and a defect?), these are not
// for rvalues, hierarchy takes precedence over other conversions
(void)(i1 ? BadBase() : BadDerived());
(void)(i1 ? BadDerived() : BadBase());
// b2.1 (hierarchy stuff)
const Base constret();
const Derived constder();
// should use const overload
A a1((i1 ? constret() : Base()).trick());
A a2((i1 ? Base() : constret()).trick());
A a3((i1 ? constret() : Derived()).trick());
A a4((i1 ? Derived() : constret()).trick());
// should use non-const overload
i1 = (i1 ? Base() : Base()).trick();
i1 = (i1 ? Base() : Base()).trick();
i1 = (i1 ? Base() : Derived()).trick();
i1 = (i1 ? Derived() : Base()).trick();
// should fail: const lost
(void)(i1 ? Base() : constder()); // expected-error {{incompatible operand types ('struct Base' and 'struct Derived const')}}
(void)(i1 ? constder() : Base()); // expected-error {{incompatible operand types ('struct Derived const' and 'struct Base')}}
Priv priv;
Fin fin;
(void)(i1 ? Base() : Priv()); // expected-error{{private base class}}
(void)(i1 ? Priv() : Base()); // expected-error{{private base class}}
(void)(i1 ? Base() : Fin()); // expected-error{{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
(void)(i1 ? Fin() : Base()); // expected-error{{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
(void)(i1 ? base : priv); // expected-error {{private base class}}
(void)(i1 ? priv : base); // expected-error {{private base class}}
(void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
(void)(i1 ? fin : base); // expected-error {{ambiguous conversion from derived class 'struct Fin' to base class 'struct Base'}}
// b2.2 (non-hierarchy)
i1 = i1 ? I() : i1;
i1 = i1 ? i1 : I();
I i2(i1 ? I() : J());
I i3(i1 ? J() : I());
// "the type [it] woud have if E2 were converted to an rvalue"
vfn pfn = i1 ? F() : test;
pfn = i1 ? test : F();
(void)(i1 ? A() : B()); // expected-error {{conversion from 'struct B' to 'struct A' is ambiguous}}
(void)(i1 ? B() : A()); // expected-error {{conversion from 'struct B' to 'struct A' is ambiguous}}
(void)(i1 ? 1 : Ambig()); // expected-error {{conversion from 'struct Ambig' to 'int' is ambiguous}}
(void)(i1 ? Ambig() : 1); // expected-error {{conversion from 'struct Ambig' to 'int' is ambiguous}}
// By the way, this isn't an lvalue:
&(i1 ? i1 : i2); // expected-error {{address expression must be an lvalue or a function designator}}
// p4 (lvalue, same type)
Fields flds;
int &ir1 = i1 ? flds.i1 : flds.i2;
(i1 ? flds.b1 : flds.i2) = 0;
(i1 ? flds.i1 : flds.b2) = 0;
(i1 ? flds.b1 : flds.b2) = 0;
// p5 (conversion to built-in types)
// GCC 4.3 fails these
double d1 = i1 ? I() : K();
pfn = i1 ? F() : G();
DFnPtr pfm;
pfm = i1 ? DFnPtr() : &Base::fn1;
pfm = i1 ? &Base::fn1 : DFnPtr();
// p6 (final conversions)
i1 = i1 ? i1 : ir1;
int *pi1 = i1 ? &i1 : 0;
pi1 = i1 ? 0 : &i1;
i1 = i1 ? i1 : EVal; // expected-warning {{operands of ? are integers of different signs}} ??
i1 = i1 ? EVal : i1; // expected-warning {{operands of ? are integers of different signs}} ??
d1 = i1 ? 'c' : 4.0;
d1 = i1 ? 4.0 : 'c';
Base *pb = i1 ? (Base*)0 : (Derived*)0;
pb = i1 ? (Derived*)0 : (Base*)0;
pfm = i1 ? &Base::fn1 : &Derived::fn2;
pfm = i1 ? &Derived::fn2 : &Base::fn1;
pfm = i1 ? &Derived::fn2 : 0;
pfm = i1 ? 0 : &Derived::fn2;
const int (MixedFieldsDerived::*mp1) =
i1 ? &MixedFields::ci : &MixedFieldsDerived::i;
const volatile int (MixedFields::*mp2) =
i1 ? &MixedFields::ci : &MixedFields::cvi;
(void)(i1 ? &MixedFields::ci : &MixedFields::vi);
// Conversion of primitives does not result in an lvalue.
&(i1 ? i1 : d1); // expected-error {{address expression must be an lvalue or a function designator}}
(void)&(i1 ? flds.b1 : flds.i1); // expected-error {{address of bit-field requested}}
(void)&(i1 ? flds.i1 : flds.b1); // expected-error {{address of bit-field requested}}
unsigned long test0 = 5;
test0 = test0 ? (long) test0 : test0; // expected-warning {{operands of ? are integers of different signs}}
test0 = test0 ? (int) test0 : test0; // expected-warning {{operands of ? are integers of different signs}}
test0 = test0 ? (short) test0 : test0; // expected-warning {{operands of ? are integers of different signs}}
test0 = test0 ? test0 : (long) test0; // expected-warning {{operands of ? are integers of different signs}}
test0 = test0 ? test0 : (int) test0; // expected-warning {{operands of ? are integers of different signs}}
test0 = test0 ? test0 : (short) test0; // expected-warning {{operands of ? are integers of different signs}}
test0 = test0 ? test0 : (long) 10;
test0 = test0 ? test0 : (int) 10;
test0 = test0 ? test0 : (short) 10;
test0 = test0 ? (long) 10 : test0;
test0 = test0 ? (int) 10 : test0;
test0 = test0 ? (short) 10 : test0;
test0 = test0 ? EVal : test0;
test0 = test0 ? EVal : (int) test0; // expected-warning {{operands of ? are integers of different signs}}
// Note the thing that this does not test: since DR446, various situations
// *must* create a separate temporary copy of class objects. This can only
// be properly tested at runtime, though.
}
Line_d<R> Ray_d<R>::supporting_line() const
{
return Line_d<R>(Base(*this));
}
size_t forward_sweep(
std::ostream& s_out,
const bool print,
const size_t q,
const size_t p,
const size_t n,
const size_t numvar,
player<Base> *Rec,
const size_t J,
Base *Taylor,
CppAD::vector<bool>& cskip_op
)
{ CPPAD_ASSERT_UNKNOWN( J >= p + 1 );
CPPAD_ASSERT_UNKNOWN( q <= p );
// op code for current instruction
OpCode op;
// index for current instruction
size_t i_op;
// next variables
size_t i_var;
// arg (not as a constant)
addr_t* non_const_arg = CPPAD_NULL;
// arg (as a constant)
const addr_t* arg = CPPAD_NULL;
// temporary indices
size_t i, ell;
// initialize the comparision operator (ComOp) counter
size_t compareCount = 0;
pod_vector<size_t> VectorInd; // address for each element
pod_vector<bool> VectorVar; // is element a variable
if( q == 0 )
{
// this includes order zero calculation, initialize vector indices
i = Rec->num_rec_vecad_ind();
if( i > 0 )
{ VectorInd.extend(i);
VectorVar.extend(i);
while(i--)
{ VectorInd[i] = Rec->GetVecInd(i);
VectorVar[i] = false;
}
}
// includes zero order, so initialize conditional skip flags
for(i = 0; i < Rec->num_rec_op(); i++)
cskip_op[i] = false;
}
// Work space used by UserOp. Note User assumes q = p.
const size_t user_p1 = p+1; // number of orders for this user calculation
vector<bool> user_vx; // empty vector
vector<bool> user_vy; // empty vector
vector<Base> user_tx; // argument vector Taylor coefficients
vector<Base> user_ty; // result vector Taylor coefficients
vector<size_t> user_iy; // variable indices for results vector
size_t user_index = 0; // indentifier for this atomic operation
size_t user_id = 0; // user identifier for this call to operator
size_t user_i = 0; // index in result vector
size_t user_j = 0; // index in argument vector
size_t user_m = 0; // size of result vector
size_t user_n = 0; // size of arugment vector
//
atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
# ifndef NDEBUG
bool user_ok = false; // atomic op return value
# endif
//
// next expected operator in a UserOp sequence
enum { user_start, user_arg, user_ret, user_end } user_state = user_start;
// check numvar argument
CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
// length of the parameter vector (used by CppAD assert macros)
const size_t num_par = Rec->num_rec_par();
// pointer to the beginning of the parameter vector
const Base* parameter = CPPAD_NULL;
if( num_par > 0 )
parameter = Rec->GetPar();
// length of the text vector (used by CppAD assert macros)
const size_t num_text = Rec->num_rec_text();
// pointer to the beginning of the text vector
const char* text = CPPAD_NULL;
if( num_text > 0 )
text = Rec->GetTxt(0);
// skip the BeginOp at the beginning of the recording
Rec->start_forward(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( op == BeginOp );
# if CPPAD_FORWARD_SWEEP_TRACE
std::cout << std::endl;
# endif
bool more_operators = true;
while(more_operators)
{
// this op
Rec->next_forward(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( (i_op > n) | (op == InvOp) );
CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
// check if we are skipping this operation
while( cskip_op[i_op] )
{ if( op == CSumOp )
{ // CSumOp has a variable number of arguments
Rec->forward_csum(op, arg, i_op, i_var);
}
Rec->next_forward(op, arg, i_op, i_var);
}
// action depends on the operator
switch( op )
{
case AbsOp:
forward_abs_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case AddvvOp:
forward_addvv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case AddpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_addpv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case AcosOp:
// sqrt(1 - x * x), acos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_acos_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case AsinOp:
// sqrt(1 - x * x), asin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_asin_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case AtanOp:
// 1 + x * x, atan(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_atan_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case CExpOp:
forward_cond_op(
q, p, i_var, arg, num_par, parameter, J, Taylor
);
break;
// ---------------------------------------------------
case ComOp:
if( q == 0 ) forward_comp_op_0(
compareCount, arg, num_par, parameter, J, Taylor
);
break;
// ---------------------------------------------------
case CosOp:
// sin(x), cos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cos_op(q, p, i_var, arg[0], J, Taylor);
break;
// ---------------------------------------------------
case CoshOp:
// sinh(x), cosh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cosh_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case CSkipOp:
// CSkipOp has a variable number of arguments and
// next_forward thinks it one has one argument.
// we must inform next_forward of this special case.
Rec->forward_cskip(op, arg, i_op, i_var);
if( q == 0 )
{ forward_cskip_op_0(
i_var, arg, num_par, parameter, J, Taylor, cskip_op
);
}
break;
// -------------------------------------------------
case CSumOp:
// CSumOp has a variable number of arguments and
// next_forward thinks it one has one argument.
// we must inform next_forward of this special case.
Rec->forward_csum(op, arg, i_op, i_var);
forward_csum_op(
q, p, i_var, arg, num_par, parameter, J, Taylor
);
break;
// -------------------------------------------------
case DisOp:
i = q;
if( i == 0 )
{ forward_dis_op_0(i_var, arg, J, Taylor);
i++;
}
while(i <= p)
{ Taylor[ i_var * J + i] = Base(0);
i++;
}
break;
// -------------------------------------------------
case DivvvOp:
forward_divvv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case DivpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_divpv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case DivvpOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
forward_divvp_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case EndOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 0);
more_operators = false;
break;
// -------------------------------------------------
case ExpOp:
forward_exp_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case InvOp:
CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
break;
// -------------------------------------------------
case LdpOp:
if( q == 0 )
{ non_const_arg = Rec->forward_non_const_arg();
forward_load_p_op_0(
i_var,
non_const_arg,
num_par,
parameter,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar.data(),
VectorInd.data()
);
if( q < p )
forward_load_op( op, q+1, p, i_var, arg, J, Taylor);
}
else
{ forward_load_op( op, q, p, i_var, arg, J, Taylor);
}
break;
// -------------------------------------------------
case LdvOp:
if( q == 0 )
{ non_const_arg = Rec->forward_non_const_arg();
forward_load_v_op_0(
i_var,
non_const_arg,
num_par,
parameter,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar.data(),
VectorInd.data()
);
if( q < p )
forward_load_op( op, q+1, p, i_var, arg, J, Taylor);
}
else
{ forward_load_op( op, q, p, i_var, arg, J, Taylor);
}
break;
// -------------------------------------------------
case LogOp:
forward_log_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case MulvvOp:
forward_mulvv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case MulpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_mulpv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case ParOp:
i = q;
if( i == 0 )
{ forward_par_op_0(
i_var, arg, num_par, parameter, J, Taylor
);
i++;
}
while(i <= p)
{ Taylor[ i_var * J + i] = Base(0);
i++;
}
break;
// -------------------------------------------------
case PowvpOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
forward_powvp_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case PowpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_powpv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case PowvvOp:
forward_powvv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case PriOp:
if( (q == 0) & print ) forward_pri_0(s_out,
i_var, arg, num_text, text, num_par, parameter, J, Taylor
);
break;
// -------------------------------------------------
case SignOp:
// sign(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sign_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case SinOp:
// cos(x), sin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sin_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case SinhOp:
// cosh(x), sinh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sinh_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case SqrtOp:
forward_sqrt_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case StppOp:
if( q == 0 )
{ forward_store_pp_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar.data(),
VectorInd.data()
);
}
break;
// -------------------------------------------------
case StpvOp:
if( q == 0 )
{ forward_store_pv_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar.data(),
VectorInd.data()
);
}
break;
// -------------------------------------------------
case StvpOp:
if( q == 0 )
{ forward_store_vp_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar.data(),
VectorInd.data()
);
}
break;
// -------------------------------------------------
case StvvOp:
if( q == 0 )
{ forward_store_vv_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar.data(),
VectorInd.data()
);
}
break;
// -------------------------------------------------
case SubvvOp:
forward_subvv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case SubpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_subpv_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case SubvpOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
forward_subvp_op(q, p, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case TanOp:
// tan(x)^2, tan(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_tan_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case TanhOp:
// tanh(x)^2, tanh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_tanh_op(q, p, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case UserOp:
// start or end an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
if( user_state == user_start )
{ user_index = arg[0];
user_id = arg[1];
user_n = arg[2];
user_m = arg[3];
user_atom = atomic_base<Base>::class_object(user_index);
# ifndef NDEBUG
if( user_atom == CPPAD_NULL )
{ std::string msg =
atomic_base<Base>::class_name(user_index)
+ ": atomic_base function has been deleted";
CPPAD_ASSERT_KNOWN(false, msg.c_str() );
}
# endif
if(user_tx.size() != user_n * user_p1)
user_tx.resize(user_n * user_p1);
if(user_ty.size() != user_m * user_p1)
user_ty.resize(user_m * user_p1);
if(user_iy.size() != user_m)
user_iy.resize(user_m);
user_j = 0;
user_i = 0;
user_state = user_arg;
}
else
{ CPPAD_ASSERT_UNKNOWN( user_state == user_end );
CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
CPPAD_ASSERT_UNKNOWN( user_id == size_t(arg[1]) );
CPPAD_ASSERT_UNKNOWN( user_n == size_t(arg[2]) );
CPPAD_ASSERT_UNKNOWN( user_m == size_t(arg[3]) );
// call users function for this operation
user_atom->set_id(user_id);
CPPAD_ATOMIC_CALL(
q, p, user_vx, user_vy, user_tx, user_ty
);
# ifndef NDEBUG
if( ! user_ok )
{ std::string msg =
atomic_base<Base>::class_name(user_index)
+ ": atomic_base.forward: returned false";
CPPAD_ASSERT_KNOWN(false, msg.c_str() );
}
# endif
for(i = 0; i < user_m; i++)
if( user_iy[i] > 0 )
for(ell = q; ell <= p; ell++)
Taylor[ user_iy[i] * J + ell ] =
user_ty[ i * user_p1 + ell ];
user_state = user_start;
}
break;
case UsrapOp:
// parameter argument in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
CPPAD_ASSERT_UNKNOWN( user_j < user_n );
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
user_tx[user_j * user_p1 + 0] = parameter[ arg[0]];
for(ell = 1; ell < user_p1; ell++)
user_tx[user_j * user_p1 + ell] = Base(0);
++user_j;
if( user_j == user_n )
user_state = user_ret;
break;
case UsravOp:
// variable argument in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
CPPAD_ASSERT_UNKNOWN( user_j < user_n );
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
for(ell = 0; ell < user_p1; ell++)
user_tx[user_j * user_p1 + ell] = Taylor[ arg[0] * J + ell];
++user_j;
if( user_j == user_n )
user_state = user_ret;
break;
case UsrrpOp:
// parameter result in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
CPPAD_ASSERT_UNKNOWN( user_i < user_m );
user_iy[user_i] = 0;
user_ty[user_i * user_p1 + 0] = parameter[ arg[0]];
for(ell = 1; ell < q; ell++)
user_ty[user_i * user_p1 + ell] = Base(0);
user_i++;
if( user_i == user_m )
user_state = user_end;
break;
case UsrrvOp:
// variable result in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
CPPAD_ASSERT_UNKNOWN( user_i < user_m );
user_iy[user_i] = i_var;
for(ell = 0; ell < q; ell++)
user_ty[user_i * user_p1 + ell] = Taylor[ i_var * J + ell];
user_i++;
if( user_i == user_m )
user_state = user_end;
break;
// -------------------------------------------------
default:
CPPAD_ASSERT_UNKNOWN(0);
}
# if CPPAD_FORWARD_SWEEP_TRACE
size_t i_tmp = i_var;
Base* Z_tmp = Taylor + J * i_var;
printOp(
std::cout,
Rec,
i_op,
i_tmp,
op,
arg,
p + 1,
Z_tmp,
0,
(Base *) CPPAD_NULL
);
}
std::cout << std::endl;
# else
}
inline AD<Base> log10(const VecAD_reference<Base> &x)
{ return CppAD::log(x.ADBase()) / CppAD::log( Base(10) ); }
inline void reverse_acos_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 )
{
// check assumptions
CPPAD_ASSERT_UNKNOWN( NumArg(AcosOp) == 1 );
CPPAD_ASSERT_UNKNOWN( NumRes(AcosOp) == 2 );
CPPAD_ASSERT_UNKNOWN( d < cap_order );
CPPAD_ASSERT_UNKNOWN( d < nc_partial );
// Taylor coefficients and partials corresponding to argument
const Base* x = taylor + i_x * cap_order;
Base* px = partial + i_x * nc_partial;
// Taylor coefficients and partials corresponding to first result
const Base* z = taylor + i_z * cap_order;
Base* pz = partial + i_z * nc_partial;
// Taylor coefficients and partials corresponding to auxillary result
const Base* b = z - cap_order; // called y in documentation
Base* pb = pz - nc_partial;
// If pz is zero, make sure this operation has no effect
// (zero times infinity or nan would be non-zero).
bool skip(true);
for(size_t i_d = 0; i_d <= d; i_d++)
skip &= IdenticalZero(pz[i_d]);
if( skip )
return;
// number of indices to access
size_t j = d;
size_t k;
while(j)
{
// scale partials w.r.t b[j] by 1 / b[0]
pb[j] /= b[0];
// scale partials w.r.t z[j] by 1 / b[0]
pz[j] /= b[0];
// update partials w.r.t b^0
pb[0] -= pz[j] * z[j] + pb[j] * b[j];
// update partial w.r.t. x^0
px[0] -= pb[j] * x[j];
// update partial w.r.t. x^j
px[j] -= pz[j] + pb[j] * x[0];
// further scale partial w.r.t. z[j] by 1 / j
pz[j] /= Base(j);
for(k = 1; k < j; k++)
{ // update partials w.r.t b^(j-k)
pb[j-k] -= Base(k) * pz[j] * z[k] + pb[j] * b[k];
// update partials w.r.t. x^k
px[k] -= pb[j] * x[j-k];
// update partials w.r.t. z^k
pz[k] -= pz[j] * Base(k) * b[j-k];
}
--j;
}
// j == 0 case
px[0] -= ( pz[0] + pb[0] * x[0]) / b[0];
}
VectorBase ADFun<Base>::ForTwo(
const VectorBase &x,
const VectorSize_t &j,
const VectorSize_t &k)
{ size_t i;
size_t j1;
size_t k1;
size_t l;
size_t n = Domain();
size_t m = Range();
size_t p = j.size();
// check VectorBase is Simple Vector class with Base type elements
CheckSimpleVector<Base, VectorBase>();
// check VectorSize_t is Simple Vector class with size_t elements
CheckSimpleVector<size_t, VectorSize_t>();
CPPAD_ASSERT_KNOWN(
x.size() == n,
"ForTwo: Length of x not equal domain dimension for f."
);
CPPAD_ASSERT_KNOWN(
j.size() == k.size(),
"ForTwo: Lenght of the j and k vectors are not equal."
);
// point at which we are evaluating the second partials
Forward(0, x);
// dimension the return value
VectorBase ddy(m * p);
// allocate memory to hold all possible diagonal Taylor coefficients
// (for large sparse cases, this is not efficient)
VectorBase D(m * n);
// boolean flag for which diagonal coefficients are computed
CppAD::vector<bool> c(n);
for(j1 = 0; j1 < n; j1++)
c[j1] = false;
// direction vector in argument space
VectorBase dx(n);
for(j1 = 0; j1 < n; j1++)
dx[j1] = Base(0);
// result vector in range space
VectorBase dy(m);
// compute the diagonal coefficients that are needed
for(l = 0; l < p; l++)
{ j1 = j[l];
k1 = k[l];
CPPAD_ASSERT_KNOWN(
j1 < n,
"ForTwo: an element of j not less than domain dimension for f."
);
CPPAD_ASSERT_KNOWN(
k1 < n,
"ForTwo: an element of k not less than domain dimension for f."
);
size_t count = 2;
while(count)
{ count--;
if( ! c[j1] )
{ // diagonal term in j1 direction
c[j1] = true;
dx[j1] = Base(1);
Forward(1, dx);
dx[j1] = Base(0);
dy = Forward(2, dx);
for(i = 0; i < m; i++)
D[i * n + j1 ] = dy[i];
}
j1 = k1;
}
}
// compute all the requested cross partials
for(l = 0; l < p; l++)
{ j1 = j[l];
k1 = k[l];
if( j1 == k1 )
{ for(i = 0; i < m; i++)
ddy[i * p + l] = Base(2) * D[i * n + j1];
}
else
{
// cross term in j1 and k1 directions
dx[j1] = Base(1);
dx[k1] = Base(1);
Forward(1, dx);
dx[j1] = Base(0);
dx[k1] = Base(0);
dy = Forward(2, dx);
// place result in return value
for(i = 0; i < m; i++)
ddy[i * p + l] = dy[i] - D[i*n+j1] - D[i*n+k1];
}
}
return ddy;
}
static void ProcessFace(
const Image& img, // in
const char* imgpath, // in
int foundface, // in
const Shape& shape, // in
float estyaw, // in
double facedet_time, // in
double asmsearch_time, // in
const Shape& refshape, // in
FILE* fitfile, // in
const ShapeFile& sh, // in
int ishape) // in: shape index in the shapefile
{
double meanfit = NOFIT; // fitness measure over all shapefile points
int iworst = -1; // worst fitting point in above measure of fitness
double me17 = NOFIT; // fitness measure me17
double fm29 = NOFIT; // fitness measure FM29 (only for 77 point shapes)
int iworst_fm29 = -1; // worst fitting point using FM29 measure
if (!foundface)
printf_g("no face ");
else
{
if (trace_g)
LogShape(shape, imgpath);
// we will succesfully get the meanfit only if the shape can be converted to
// the shapefile number of points (by ConvertShape in MeanFitOverInterEye)
meanfit = MeanFitOverInterEye(iworst, shape, refshape);
if (meanfit != NOFIT) // were able to get the mean fit?
printf_g("meanfit %5.3f ", meanfit);
// use fitness measure me17 if can convert the shape to a shape17
me17 = Me17(shape, refshape);
if (me17 != NOFIT) // were able to get the me17 fit?
printf_g("me17 %5.3f ", me17);
// get fitness measure fm29 if the shape has 77 points
if (shape.rows == 77 && refshape.rows == 77)
{
Fm29(fm29, iworst_fm29, shape, refshape);
printf_g("fm29 %5.3f ", fm29);
}
if (writeimgs_g) // -i flag
WriteImgs(img, imgpath, shape, refshape,
meanfit, iworst, me17, fm29, iworst_fm29);
}
printf_g("\n");
if (trace_g)
lprintf("\n");
const char* const base = Base(imgpath);
const VEC pose(sh.Pose_(base));
Fprintf(fitfile,
"%-*s%s "
"%7.5f % 6d "
"%7.5f "
"%7.5f % 6d "
"%8.2f %8.2f ",
sh.nchar_, base, " ",
meanfit, iworst,
me17,
fm29, iworst_fm29,
InterEyeDist(refshape), EyeMouthDist(refshape));
Fprintf(fitfile,
"% 5.0f "
"% 6.0f % 6.0f % 6.0f %9.3f "
"[%5.3f] [%5.3f]\n",
estyaw,
pose(0), pose(1), pose(2), pose(3),
facedet_time, asmsearch_time);
}
size_t forward_sweep(
bool print,
size_t d,
size_t n,
size_t numvar,
player<Base> *Rec,
size_t J,
Base *Taylor
)
{ CPPAD_ASSERT_UNKNOWN( J >= d + 1 );
// op code for current instruction
OpCode op;
// index for current instruction
size_t i_op;
// next variables
size_t i_var;
# if CPPAD_USE_FORWARD0SWEEP
CPPAD_ASSERT_UNKNOWN( d > 0 );
# else
size_t* non_const_arg;
# endif
const size_t *arg = 0;
size_t i;
// initialize the comparision operator (ComOp) counter
size_t compareCount = 0;
// if this is an order zero calculation, initialize vector indices
size_t *VectorInd = CPPAD_NULL; // address for each element
bool *VectorVar = CPPAD_NULL; // is element a variable
i = Rec->num_rec_vecad_ind();
if( i > 0 )
{ VectorInd = CPPAD_TRACK_NEW_VEC(i, VectorInd);
VectorVar = CPPAD_TRACK_NEW_VEC(i, VectorVar);
while(i--)
{ VectorInd[i] = Rec->GetVecInd(i);
VectorVar[i] = false;
}
}
// check numvar argument
CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
// length of the parameter vector (used by CppAD assert macros)
const size_t num_par = Rec->num_rec_par();
// length of the text vector (used by CppAD assert macros)
const size_t num_text = Rec->num_rec_text();
// pointer to the beginning of the parameter vector
const Base* parameter = 0;
if( num_par > 0 )
parameter = Rec->GetPar();
// pointer to the beginning of the text vector
const char* text = 0;
if( num_text > 0 )
text = Rec->GetTxt(0);
// skip the BeginOp at the beginning of the recording
Rec->start_forward(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( op == BeginOp );
# if CPPAD_FORWARD_SWEEP_TRACE
std::cout << std::endl;
# endif
while(op != EndOp)
{
// this op
Rec->next_forward(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( (i_op > n) | (op == InvOp) );
CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
// action depends on the operator
switch( op )
{
case AbsOp:
forward_abs_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case AddvvOp:
forward_addvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case AddpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_addpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case AcosOp:
// variables: sqrt(1 - x * x), acos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_acos_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case AsinOp:
// results: sqrt(1 - x * x), asin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_asin_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case AtanOp:
// results: 1 + x * x, atan(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_atan_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case CSumOp:
// CSumOp has a variable number of arguments and
// next_forward thinks it one has one argument.
// we must inform next_forward of this special case.
Rec->forward_csum(op, arg, i_op, i_var);
forward_csum_op(
d, i_var, arg, num_par, parameter, J, Taylor
);
break;
// -------------------------------------------------
case CExpOp:
forward_cond_op(
d, i_var, arg, num_par, parameter, J, Taylor
);
break;
// ---------------------------------------------------
case ComOp:
# if ! USE_FORWARD0SWEEP
if( d == 0 ) forward_comp_op_0(
compareCount, arg, num_par, parameter, J, Taylor
);
# endif
break;
// ---------------------------------------------------
case CosOp:
// variables: sin(x), cos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cos_op(d, i_var, arg[0], J, Taylor);
break;
// ---------------------------------------------------
case CoshOp:
// variables: sinh(x), cosh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cosh_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case DisOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
forward_dis_op_0(i_var, arg, J, Taylor);
else
# endif
{ Taylor[ i_var * J + d] = Base(0);
}
break;
// -------------------------------------------------
case DivvvOp:
forward_divvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case DivpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_divpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case DivvpOp:
CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
forward_divvp_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case EndOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 0);
break;
// -------------------------------------------------
case ExpOp:
forward_exp_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case InvOp:
CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
break;
// -------------------------------------------------
case LdpOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ non_const_arg = Rec->forward_non_const_arg();
forward_load_p_op_0(
i_var,
non_const_arg,
num_par,
parameter,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
else
# endif
{ forward_load_op( op, d, i_var, arg, J, Taylor);
}
break;
// -------------------------------------------------
case LdvOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ non_const_arg = Rec->forward_non_const_arg();
forward_load_v_op_0(
i_var,
non_const_arg,
num_par,
parameter,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
else
# endif
{ forward_load_op( op, d, i_var, arg, J, Taylor);
}
break;
// -------------------------------------------------
case LogOp:
forward_log_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case MulvvOp:
forward_mulvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case MulpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_mulpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case ParOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 ) forward_par_op_0(
i_var, arg, num_par, parameter, J, Taylor
);
else
# endif
{ Taylor[ i_var * J + d] = Base(0);
}
break;
// -------------------------------------------------
case PowvpOp:
CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
forward_powvp_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case PowpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_powpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case PowvvOp:
forward_powvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case PripOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( print && ( d == 0 ) ) forward_prip_0(
arg, num_text, text, num_par, parameter
);
# endif
break;
// -------------------------------------------------
case PrivOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( print && ( d == 0 ) ) forward_priv_0(
i_var, arg, num_text, text, J, Taylor
);
# endif
break;
// -------------------------------------------------
case SinOp:
// variables: cos(x), sin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sin_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case SinhOp:
// variables: cosh(x), sinh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sinh_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case SqrtOp:
forward_sqrt_op(d, i_var, arg[0], J, Taylor);
break;
// -------------------------------------------------
case StppOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ forward_store_pp_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
# endif
break;
// -------------------------------------------------
case StpvOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ forward_store_pv_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
# endif
break;
// -------------------------------------------------
case StvpOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ forward_store_vp_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
# endif
break;
// -------------------------------------------------
case StvvOp:
# if ! CPPAD_USE_FORWARD0SWEEP
if( d == 0 )
{ forward_store_vv_op_0(
i_var,
arg,
num_par,
J,
Taylor,
Rec->num_rec_vecad_ind(),
VectorVar,
VectorInd
);
}
# endif
break;
// -------------------------------------------------
case SubvvOp:
forward_subvv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case SubpvOp:
CPPAD_ASSERT_UNKNOWN( arg[0] < num_par );
forward_subpv_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
case SubvpOp:
CPPAD_ASSERT_UNKNOWN( arg[1] < num_par );
forward_subvp_op(d, i_var, arg, parameter, J, Taylor);
break;
// -------------------------------------------------
default:
CPPAD_ASSERT_UNKNOWN(0);
}
# if CPPAD_FORWARD_SWEEP_TRACE
size_t i_tmp = i_var;
Base* Z_tmp = Taylor + J * i_var;
printOp(
std::cout,
Rec,
i_tmp,
op,
arg,
d + 1,
Z_tmp,
0,
(Base *) CPPAD_NULL
);
}
std::cout << std::endl;
# else
}
uint8
ArchUART8250Omap::In8(int reg)
{
return *((uint8 *)Base() + reg * sizeof(uint32));
}
void
ArchUART8250Omap::Out8(int reg, uint8 value)
{
*((uint8 *)Base() + reg * sizeof(uint32)) = value;
}
inline AD<Base>& AD<Base>::operator=(const T &t)
{ return *this = Base(t); }
xml_unescape(T start) :
super_t(Base(static_cast< T >(start)))
{}
//-----------------------------------------------------------------------------
// Converts a buffer from a CRLF buffer to a CR buffer (and back)
// Returns false if no conversion was necessary (and outBuf is left untouched)
// If the conversion occurs, outBuf will be cleared.
//-----------------------------------------------------------------------------
bool CUtlBufferEditor::ConvertCRLF( CUtlBufferEditor &outBuf )
{
if ( !IsText() || !outBuf.IsText() )
return false;
if ( ContainsCRLF() == outBuf.ContainsCRLF() )
return false;
int nInCount = TellMaxPut();
outBuf.Purge();
outBuf.EnsureCapacity( nInCount );
bool bFromCRLF = ContainsCRLF();
// Start reading from the beginning
int nGet = TellGet();
int nPut = TellPut();
int nGetDelta = 0;
int nPutDelta = 0;
const char *pBase = (const char*)Base();
int nCurrGet = 0;
while ( nCurrGet < nInCount )
{
const char *pCurr = &pBase[nCurrGet];
if ( bFromCRLF )
{
const char *pNext = Q_strnistr( pCurr, "\r\n", nInCount - nCurrGet );
if ( !pNext )
{
outBuf.Put( pCurr, nInCount - nCurrGet );
break;
}
int nBytes = (size_t)pNext - (size_t)pCurr;
outBuf.Put( pCurr, nBytes );
outBuf.PutChar( '\n' );
nCurrGet += nBytes + 2;
if ( nGet >= nCurrGet - 1 )
{
--nGetDelta;
}
if ( nPut >= nCurrGet - 1 )
{
--nPutDelta;
}
}
else
{
const char *pNext = Q_strnchr( pCurr, '\n', nInCount - nCurrGet );
if ( !pNext )
{
outBuf.Put( pCurr, nInCount - nCurrGet );
break;
}
int nBytes = (size_t)pNext - (size_t)pCurr;
outBuf.Put( pCurr, nBytes );
outBuf.PutChar( '\r' );
outBuf.PutChar( '\n' );
nCurrGet += nBytes + 1;
if ( nGet >= nCurrGet )
{
++nGetDelta;
}
if ( nPut >= nCurrGet )
{
++nPutDelta;
}
}
}
Assert( nPut + nPutDelta <= outBuf.TellMaxPut() );
outBuf.SeekGet( SEEK_HEAD, nGet + nGetDelta );
outBuf.SeekPut( SEEK_HEAD, nPut + nPutDelta );
return true;
}
int main()
{
Base()->operator=(Base());
}
void CUtlBufferEditor::WriteToBuffer( CUtlBuffer &buf )
{
int size = TellPut();
buf.Put( Base(), size );
}
inline AD<Base> log10(const AD<Base> &x)
{ return CppAD::log(x) / CppAD::log( Base(10) ); }
void forward2sweep(
const size_t q,
const size_t r,
const size_t n,
const size_t numvar,
player<Base>* play,
const size_t J,
Base* taylor,
const bool* cskip_op,
const pod_vector<addr_t>& var_by_load_op
)
{
CPPAD_ASSERT_UNKNOWN( q > 0 );
CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
// used to avoid compiler errors until all operators are implemented
size_t p = q;
// op code for current instruction
OpCode op;
// index for current instruction
size_t i_op;
// next variables
size_t i_var;
// operation argument indices
const addr_t* arg = CPPAD_NULL;
// work space used by UserOp.
vector<bool> user_vx; // empty vecotor
vector<bool> user_vy; // empty vecotor
vector<Base> user_tx_one; // argument vector Taylor coefficients
vector<Base> user_tx_all;
vector<Base> user_ty_one; // result vector Taylor coefficients
vector<Base> user_ty_all;
size_t user_index = 0; // indentifier for this atomic operation
size_t user_id = 0; // user identifier for this call to operator
size_t user_i = 0; // index in result vector
size_t user_j = 0; // index in argument vector
size_t user_m = 0; // size of result vector
size_t user_n = 0; // size of arugment vector
//
atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
# ifndef NDEBUG
bool user_ok = false; // atomic op return value
# endif
//
// next expected operator in a UserOp sequence
enum { user_start, user_arg, user_ret, user_end, user_trace }
user_state = user_start;
// length of the parameter vector (used by CppAD assert macros)
const size_t num_par = play->num_par_rec();
// pointer to the beginning of the parameter vector
const Base* parameter = CPPAD_NULL;
if( num_par > 0 )
parameter = play->GetPar();
// temporary indices
size_t i, j, k, ell;
// number of orders for this user calculation
// (not needed for order zero)
const size_t user_q1 = q+1;
// variable indices for results vector
// (done differently for order zero).
vector<size_t> user_iy;
// skip the BeginOp at the beginning of the recording
play->forward_start(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( op == BeginOp );
# if CPPAD_FORWARD2SWEEP_TRACE
std::cout << std::endl;
CppAD::vector<Base> Z_vec(q+1);
# endif
bool more_operators = true;
while(more_operators)
{
// this op
play->forward_next(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( (i_op > n) | (op == InvOp) );
CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
// check if we are skipping this operation
while( cskip_op[i_op] )
{ if( op == CSumOp )
{ // CSumOp has a variable number of arguments
play->forward_csum(op, arg, i_op, i_var);
}
CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
// if( op == CSkipOp )
// { // CSkip has a variable number of arguments
// play->forward_cskip(op, arg, i_op, i_var);
// }
play->forward_next(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
}
// action depends on the operator
switch( op )
{
case AbsOp:
forward_abs_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case AddvvOp:
forward_addvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case AddpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_addpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case AcosOp:
// sqrt(1 - x * x), acos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_acos_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
# if CPPAD_USE_CPLUSPLUS_2011
case AcoshOp:
// sqrt(x * x - 1), acosh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_acosh_op_dir(q, r, i_var, arg[0], J, taylor);
break;
# endif
// -------------------------------------------------
case AsinOp:
// sqrt(1 - x * x), asin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_asin_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
# if CPPAD_USE_CPLUSPLUS_2011
case AsinhOp:
// sqrt(1 + x * x), asinh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_asinh_op_dir(q, r, i_var, arg[0], J, taylor);
break;
# endif
// -------------------------------------------------
case AtanOp:
// 1 + x * x, atan(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_atan_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
# if CPPAD_USE_CPLUSPLUS_2011
case AtanhOp:
// 1 - x * x, atanh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_atanh_op_dir(q, r, i_var, arg[0], J, taylor);
break;
# endif
// -------------------------------------------------
case CExpOp:
forward_cond_op_dir(
q, r, i_var, arg, num_par, parameter, J, taylor
);
break;
// ---------------------------------------------------
case CosOp:
// sin(x), cos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cos_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// ---------------------------------------------------
case CoshOp:
// sinh(x), cosh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cosh_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case CSkipOp:
// CSkipOp has a variable number of arguments and
// forward_next thinks it has no arguments.
// we must inform forward_next of this special case.
play->forward_cskip(op, arg, i_op, i_var);
break;
// -------------------------------------------------
case CSumOp:
// CSumOp has a variable number of arguments and
// forward_next thinks it has no arguments.
// we must inform forward_next of this special case.
forward_csum_op_dir(
q, r, i_var, arg, num_par, parameter, J, taylor
);
play->forward_csum(op, arg, i_op, i_var);
break;
// -------------------------------------------------
case DisOp:
forward_dis_op(p, q, r, i_var, arg, J, taylor);
break;
// -------------------------------------------------
case DivvvOp:
forward_divvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case DivpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_divpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case DivvpOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
forward_divvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case EndOp:
// needed for sparse_jacobian test
CPPAD_ASSERT_NARG_NRES(op, 0, 0);
more_operators = false;
break;
// -------------------------------------------------
case ExpOp:
forward_exp_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
# if CPPAD_USE_CPLUSPLUS_2011
case Expm1Op:
forward_expm1_op_dir(q, r, i_var, arg[0], J, taylor);
break;
# endif
// -------------------------------------------------
case InvOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 1);
break;
// -------------------------------------------------
case LdpOp:
case LdvOp:
forward_load_op(
play,
op,
p,
q,
r,
J,
i_var,
arg,
var_by_load_op.data(),
taylor
);
break;
// ---------------------------------------------------
case EqpvOp:
case EqvvOp:
case LtpvOp:
case LtvpOp:
case LtvvOp:
case LepvOp:
case LevpOp:
case LevvOp:
case NepvOp:
case NevvOp:
CPPAD_ASSERT_UNKNOWN(q > 0 );
break;
// -------------------------------------------------
case LogOp:
forward_log_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// ---------------------------------------------------
# if CPPAD_USE_CPLUSPLUS_2011
case Log1pOp:
forward_log1p_op_dir(q, r, i_var, arg[0], J, taylor);
break;
# endif
// ---------------------------------------------------
case MulvvOp:
forward_mulvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case MulpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_mulpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case ParOp:
k = i_var*(J-1)*r + i_var + (q-1)*r + 1;
for(ell = 0; ell < r; ell++)
taylor[k + ell] = Base(0);
break;
// -------------------------------------------------
case PowpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_powpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case PowvpOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
forward_powvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case PowvvOp:
forward_powvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case PriOp:
CPPAD_ASSERT_UNKNOWN(q > 0);
break;
// -------------------------------------------------
case SignOp:
// sign(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sign_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case SinOp:
// cos(x), sin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sin_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case SinhOp:
// cosh(x), sinh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sinh_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case SqrtOp:
forward_sqrt_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case StppOp:
case StpvOp:
case StvpOp:
case StvvOp:
CPPAD_ASSERT_UNKNOWN(q > 0 );
break;
// -------------------------------------------------
case SubvvOp:
forward_subvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case SubpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_subpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case SubvpOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
forward_subvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case TanOp:
// tan(x)^2, tan(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_tan_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case TanhOp:
// tanh(x)^2, tanh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_tanh_op_dir(q, r, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case UserOp:
// start or end an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
if( user_state == user_start )
{ user_index = arg[0];
user_id = arg[1];
user_n = arg[2];
user_m = arg[3];
user_atom = atomic_base<Base>::class_object(user_index);
# ifndef NDEBUG
if( user_atom == CPPAD_NULL )
{ std::string msg =
atomic_base<Base>::class_name(user_index)
+ ": atomic_base function has been deleted";
CPPAD_ASSERT_KNOWN(false, msg.c_str() );
}
# endif
if(user_tx_one.size() != user_n * user_q1)
user_tx_one.resize(user_n * user_q1);
if( user_tx_all.size() != user_n * (q * r + 1) )
user_tx_all.resize(user_n * (q * r + 1));
//
if(user_ty_one.size() != user_m * user_q1)
user_ty_one.resize(user_m * user_q1);
if( user_ty_all.size() != user_m * (q * r + 1) )
user_ty_all.resize(user_m * (q * r + 1));
//
if(user_iy.size() != user_m)
user_iy.resize(user_m);
user_j = 0;
user_i = 0;
user_state = user_arg;
}
else
{ CPPAD_ASSERT_UNKNOWN( user_state == user_end );
CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
CPPAD_ASSERT_UNKNOWN( user_id == size_t(arg[1]) );
CPPAD_ASSERT_UNKNOWN( user_n == size_t(arg[2]) );
CPPAD_ASSERT_UNKNOWN( user_m == size_t(arg[3]) );
// call users function for this operation
user_atom->set_id(user_id);
for(ell = 0; ell < r; ell++)
{ // set user_tx
for(j = 0; j < user_n; j++)
{ size_t j_all = j * (q * r + 1);
size_t j_one = j * user_q1;
user_tx_one[j_one+0] = user_tx_all[j_all+0];
for(k = 1; k < user_q1; k++)
{ size_t k_all = j_all + (k-1)*r+1+ell;
size_t k_one = j_one + k;
user_tx_one[k_one] = user_tx_all[k_all];
}
}
// set user_ty
for(i = 0; i < user_m; i++)
{ size_t i_all = i * (q * r + 1);
size_t i_one = i * user_q1;
user_ty_one[i_one+0] = user_ty_all[i_all+0];
for(k = 1; k < q; k++)
{ size_t k_all = i_all + (k-1)*r+1+ell;
size_t k_one = i_one + k;
user_ty_one[k_one] = user_ty_all[k_all];
}
}
CPPAD_ATOMIC_CALL(
q, q, user_vx, user_vy, user_tx_one, user_ty_one
);
# ifndef NDEBUG
if( ! user_ok )
{ std::string msg =
atomic_base<Base>::class_name(user_index)
+ ": atomic_base.forward: returned false";
CPPAD_ASSERT_KNOWN(false, msg.c_str() );
}
# endif
for(i = 0; i < user_m; i++)
{ if( user_iy[i] > 0 )
{ size_t i_taylor = user_iy[i]*((J-1)*r+1);
size_t q_taylor = i_taylor + (q-1)*r+1+ell;
size_t q_one = i * user_q1 + q;
taylor[q_taylor] = user_ty_one[q_one];
}
}
}
# if CPPAD_FORWARD2SWEEP_TRACE
user_state = user_trace;
# else
user_state = user_start;
# endif
}
break;
case UsrapOp:
// parameter argument in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
CPPAD_ASSERT_UNKNOWN( user_j < user_n );
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
user_tx_all[user_j*(q*r+1) + 0] = parameter[ arg[0]];
for(ell = 0; ell < r; ell++)
for(k = 1; k < user_q1; k++)
user_tx_all[user_j*(q*r+1) + (k-1)*r+1+ell] = Base(0);
++user_j;
if( user_j == user_n )
user_state = user_ret;
break;
case UsravOp:
// variable argument in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
CPPAD_ASSERT_UNKNOWN( user_j < user_n );
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
user_tx_all[user_j*(q*r+1)+0] = taylor[arg[0]*((J-1)*r+1)+0];
for(ell = 0; ell < r; ell++)
{ for(k = 1; k < user_q1; k++)
{ user_tx_all[user_j*(q*r+1) + (k-1)*r+1+ell] =
taylor[arg[0]*((J-1)*r+1) + (k-1)*r+1+ell];
}
}
++user_j;
if( user_j == user_n )
user_state = user_ret;
break;
case UsrrpOp:
// parameter result in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
CPPAD_ASSERT_UNKNOWN( user_i < user_m );
user_iy[user_i] = 0;
user_ty_all[user_i*(q*r+1) + 0] = parameter[ arg[0]];
for(ell = 0; ell < r; ell++)
for(k = 1; k < user_q1; k++)
user_ty_all[user_i*(q*r+1) + (k-1)*r+1+ell] = Base(0);
user_i++;
if( user_i == user_m )
user_state = user_end;
break;
case UsrrvOp:
// variable result in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
CPPAD_ASSERT_UNKNOWN( user_i < user_m );
user_iy[user_i] = i_var;
user_ty_all[user_i*(q*r+1)+0] = taylor[i_var*((J-1)*r+1)+0];
for(ell = 0; ell < r; ell++)
{ for(k = 1; k < user_q1; k++)
{ user_ty_all[user_i*(q*r+1) + (k-1)*r+1+ell] =
taylor[i_var*((J-1)*r+1) + (k-1)*r+1+ell];
}
}
user_i++;
if( user_i == user_m )
user_state = user_end;
break;
// -------------------------------------------------
default:
CPPAD_ASSERT_UNKNOWN(0);
}
# if CPPAD_FORWARD2SWEEP_TRACE
if( user_state == user_trace )
{ user_state = user_start;
CPPAD_ASSERT_UNKNOWN( op == UserOp );
CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
{ size_t i_tmp = (i_op + i) - user_m;
printOp(
std::cout,
play,
i_tmp,
user_iy[i],
UsrrvOp,
CPPAD_NULL
);
Base* Z_tmp = taylor + user_iy[i]*((J-1) * r + 1);
{ Z_vec[0] = Z_tmp[0];
for(ell = 0; ell < r; ell++)
{ std::cout << std::endl << " ";
for(size_t p_tmp = 1; p_tmp <= q; p_tmp++)
Z_vec[p_tmp] = Z_tmp[(p_tmp-1)*r+ell+1];
printOpResult(
std::cout,
q + 1,
Z_vec.data(),
0,
(Base *) CPPAD_NULL
);
}
}
std::cout << std::endl;
}
}
const addr_t* arg_tmp = arg;
if( op == CSumOp )
arg_tmp = arg - arg[-1] - 4;
if( op == CSkipOp )
arg_tmp = arg - arg[-1] - 7;
if( op != UsrrvOp )
{ printOp(
std::cout,
play,
i_op,
i_var,
op,
arg_tmp
);
Base* Z_tmp = CPPAD_NULL;
if( op == UsravOp )
Z_tmp = taylor + arg[0]*((J-1) * r + 1);
else if( NumRes(op) > 0 )
Z_tmp = taylor + i_var*((J-1)*r + 1);
if( Z_tmp != CPPAD_NULL )
{ Z_vec[0] = Z_tmp[0];
for(ell = 0; ell < r; ell++)
{ std::cout << std::endl << " ";
for(size_t p_tmp = 1; p_tmp <= q; p_tmp++)
Z_vec[p_tmp] = Z_tmp[ (p_tmp-1)*r + ell + 1];
printOpResult(
std::cout,
q + 1,
Z_vec.data(),
0,
(Base *) CPPAD_NULL
);
}
}
std::cout << std::endl;
}
}
std::cout << std::endl;
# else
}
void forward1sweep(
std::ostream& s_out,
const bool print,
const size_t p,
const size_t q,
const size_t n,
const size_t numvar,
player<Base>* play,
const size_t J,
Base* taylor,
bool* cskip_op,
pod_vector<addr_t>& var_by_load_op,
size_t compare_change_count,
size_t& compare_change_number,
size_t& compare_change_op_index
)
{
// number of directions
const size_t r = 1;
CPPAD_ASSERT_UNKNOWN( p <= q );
CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
/*
<!-- replace forward0sweep_code_define -->
*/
// op code for current instruction
OpCode op;
// index for current instruction
size_t i_op;
// next variables
size_t i_var;
// operation argument indices
const addr_t* arg = CPPAD_NULL;
// initialize the comparision operator counter
if( p == 0 )
{ compare_change_number = 0;
compare_change_op_index = 0;
}
// If this includes a zero calculation, initialize this information
pod_vector<bool> isvar_by_ind;
pod_vector<size_t> index_by_ind;
if( p == 0 )
{ size_t i;
// this includes order zero calculation, initialize vector indices
size_t num = play->num_vec_ind_rec();
if( num > 0 )
{ isvar_by_ind.extend(num);
index_by_ind.extend(num);
for(i = 0; i < num; i++)
{ index_by_ind[i] = play->GetVecInd(i);
isvar_by_ind[i] = false;
}
}
// includes zero order, so initialize conditional skip flags
num = play->num_op_rec();
for(i = 0; i < num; i++)
cskip_op[i] = false;
}
// work space used by UserOp.
vector<bool> user_vx; // empty vecotor
vector<bool> user_vy; // empty vecotor
vector<Base> user_tx; // argument vector Taylor coefficients
vector<Base> user_ty; // result vector Taylor coefficients
size_t user_index = 0; // indentifier for this atomic operation
size_t user_id = 0; // user identifier for this call to operator
size_t user_i = 0; // index in result vector
size_t user_j = 0; // index in argument vector
size_t user_m = 0; // size of result vector
size_t user_n = 0; // size of arugment vector
//
atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
# ifndef NDEBUG
bool user_ok = false; // atomic op return value
# endif
//
// next expected operator in a UserOp sequence
enum { user_start, user_arg, user_ret, user_end, user_trace }
user_state = user_start;
// length of the parameter vector (used by CppAD assert macros)
const size_t num_par = play->num_par_rec();
// pointer to the beginning of the parameter vector
const Base* parameter = CPPAD_NULL;
if( num_par > 0 )
parameter = play->GetPar();
// length of the text vector (used by CppAD assert macros)
const size_t num_text = play->num_text_rec();
// pointer to the beginning of the text vector
const char* text = CPPAD_NULL;
if( num_text > 0 )
text = play->GetTxt(0);
/*
<!-- end forward0sweep_code_define -->
*/
// temporary indices
size_t i, k;
// number of orders for this user calculation
// (not needed for order zero)
const size_t user_q1 = q+1;
// variable indices for results vector
// (done differently for order zero).
vector<size_t> user_iy;
// skip the BeginOp at the beginning of the recording
play->forward_start(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( op == BeginOp );
# if CPPAD_FORWARD1SWEEP_TRACE
std::cout << std::endl;
# endif
bool more_operators = true;
while(more_operators)
{
// this op
play->forward_next(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( (i_op > n) | (op == InvOp) );
CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
// check if we are skipping this operation
while( cskip_op[i_op] )
{ if( op == CSumOp )
{ // CSumOp has a variable number of arguments
play->forward_csum(op, arg, i_op, i_var);
}
CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
// if( op == CSkipOp )
// { // CSkip has a variable number of arguments
// play->forward_cskip(op, arg, i_op, i_var);
// }
play->forward_next(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
}
// action depends on the operator
switch( op )
{
case AbsOp:
forward_abs_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case AddvvOp:
forward_addvv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case AddpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_addpv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case AcosOp:
// sqrt(1 - x * x), acos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_acos_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case AsinOp:
// sqrt(1 - x * x), asin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_asin_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case AtanOp:
// 1 + x * x, atan(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_atan_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case CExpOp:
forward_cond_op(
p, q, i_var, arg, num_par, parameter, J, taylor
);
break;
// ---------------------------------------------------
case CosOp:
// sin(x), cos(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cos_op(p, q, i_var, arg[0], J, taylor);
break;
// ---------------------------------------------------
case CoshOp:
// sinh(x), cosh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_cosh_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case CSkipOp:
// CSkipOp has a variable number of arguments and
// forward_next thinks it has no arguments.
// we must inform forward_next of this special case.
if( p == 0 )
{ forward_cskip_op_0(
i_var, arg, num_par, parameter, J, taylor, cskip_op
);
}
play->forward_cskip(op, arg, i_op, i_var);
break;
// -------------------------------------------------
case CSumOp:
// CSumOp has a variable number of arguments and
// forward_next thinks it has no arguments.
// we must inform forward_next of this special case.
forward_csum_op(
p, q, i_var, arg, num_par, parameter, J, taylor
);
play->forward_csum(op, arg, i_op, i_var);
break;
// -------------------------------------------------
case DisOp:
forward_dis_op(p, q, r, i_var, arg, J, taylor);
break;
// -------------------------------------------------
case DivvvOp:
forward_divvv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case DivpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_divpv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case DivvpOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
forward_divvp_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case EndOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 0);
more_operators = false;
break;
// -------------------------------------------------
case EqpvOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_eqpv_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
// -------------------------------------------------
case EqvvOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_eqvv_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
// -------------------------------------------------
# if CPPAD_COMPILER_HAS_ERF
case ErfOp:
CPPAD_ASSERT_UNKNOWN( CPPAD_COMPILER_HAS_ERF );
// 2DO: implement zero order version of this function
forward_erf_op(p, q, i_var, arg, parameter, J, taylor);
break;
# endif
// -------------------------------------------------
case ExpOp:
forward_exp_op(p, q, i_var, arg[0], J, taylor);
break;
// ---------------------------------------------------
case InvOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 1);
break;
// -------------------------------------------------
case LdpOp:
if( p == 0 )
{ forward_load_p_op_0(
play,
i_var,
arg,
parameter,
J,
taylor,
isvar_by_ind.data(),
index_by_ind.data(),
var_by_load_op.data()
);
if( p < q ) forward_load_op(
play,
op,
p+1,
q,
r,
J,
i_var,
arg,
var_by_load_op.data(),
taylor
);
}
else forward_load_op(
play,
op,
p,
q,
r,
J,
i_var,
arg,
var_by_load_op.data(),
taylor
);
break;
// -------------------------------------------------
case LdvOp:
if( p == 0 )
{ forward_load_v_op_0(
play,
i_var,
arg,
parameter,
J,
taylor,
isvar_by_ind.data(),
index_by_ind.data(),
var_by_load_op.data()
);
if( p < q ) forward_load_op(
play,
op,
p+1,
q,
r,
J,
i_var,
arg,
var_by_load_op.data(),
taylor
);
}
else forward_load_op(
play,
op,
p,
q,
r,
J,
i_var,
arg,
var_by_load_op.data(),
taylor
);
break;
// -------------------------------------------------
case LepvOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_lepv_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
case LevpOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_levp_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
// -------------------------------------------------
case LevvOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_levv_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
// -------------------------------------------------
case LogOp:
forward_log_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case LtpvOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_ltpv_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
case LtvpOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_ltvp_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
// -------------------------------------------------
case LtvvOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_ltvv_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
// -------------------------------------------------
case MulvvOp:
forward_mulvv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case MulpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_mulpv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case NepvOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_nepv_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
// -------------------------------------------------
case NevvOp:
if( ( p == 0 ) & ( compare_change_count > 0 ) )
{ forward_nevv_op_0(
compare_change_number, arg, parameter, J, taylor
);
if( compare_change_count == compare_change_number )
compare_change_op_index = i_op;
}
break;
// -------------------------------------------------
case ParOp:
i = p;
if( i == 0 )
{ forward_par_op_0(
i_var, arg, num_par, parameter, J, taylor
);
i++;
}
while(i <= q)
{ taylor[ i_var * J + i] = Base(0);
i++;
}
break;
// -------------------------------------------------
case PowvpOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
forward_powvp_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case PowpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_powpv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case PowvvOp:
forward_powvv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case PriOp:
if( (p == 0) & print ) forward_pri_0(s_out,
arg, num_text, text, num_par, parameter, J, taylor
);
break;
// -------------------------------------------------
case SignOp:
// sign(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sign_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case SinOp:
// cos(x), sin(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sin_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case SinhOp:
// cosh(x), sinh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_sinh_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case SqrtOp:
forward_sqrt_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case StppOp:
if( p == 0 )
{ forward_store_pp_op_0(
i_var,
arg,
num_par,
J,
taylor,
isvar_by_ind.data(),
index_by_ind.data()
);
}
break;
// -------------------------------------------------
case StpvOp:
if( p == 0 )
{ forward_store_pv_op_0(
i_var,
arg,
num_par,
J,
taylor,
isvar_by_ind.data(),
index_by_ind.data()
);
}
break;
// -------------------------------------------------
case StvpOp:
if( p == 0 )
{ forward_store_vp_op_0(
i_var,
arg,
num_par,
J,
taylor,
isvar_by_ind.data(),
index_by_ind.data()
);
}
break;
// -------------------------------------------------
case StvvOp:
if( p == 0 )
{ forward_store_vv_op_0(
i_var,
arg,
num_par,
J,
taylor,
isvar_by_ind.data(),
index_by_ind.data()
);
}
break;
// -------------------------------------------------
case SubvvOp:
forward_subvv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case SubpvOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
forward_subpv_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case SubvpOp:
CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
forward_subvp_op(p, q, i_var, arg, parameter, J, taylor);
break;
// -------------------------------------------------
case TanOp:
// tan(x)^2, tan(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_tan_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case TanhOp:
// tanh(x)^2, tanh(x)
CPPAD_ASSERT_UNKNOWN( i_var < numvar );
forward_tanh_op(p, q, i_var, arg[0], J, taylor);
break;
// -------------------------------------------------
case UserOp:
// start or end an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
if( user_state == user_start )
{ user_index = arg[0];
user_id = arg[1];
user_n = arg[2];
user_m = arg[3];
user_atom = atomic_base<Base>::class_object(user_index);
# ifndef NDEBUG
if( user_atom == CPPAD_NULL )
{ std::string msg =
atomic_base<Base>::class_name(user_index)
+ ": atomic_base function has been deleted";
CPPAD_ASSERT_KNOWN(false, msg.c_str() );
}
# endif
if(user_tx.size() != user_n * user_q1)
user_tx.resize(user_n * user_q1);
if(user_ty.size() != user_m * user_q1)
user_ty.resize(user_m * user_q1);
if(user_iy.size() != user_m)
user_iy.resize(user_m);
user_j = 0;
user_i = 0;
user_state = user_arg;
}
else
{ CPPAD_ASSERT_UNKNOWN( user_state == user_end );
CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
CPPAD_ASSERT_UNKNOWN( user_id == size_t(arg[1]) );
CPPAD_ASSERT_UNKNOWN( user_n == size_t(arg[2]) );
CPPAD_ASSERT_UNKNOWN( user_m == size_t(arg[3]) );
// call users function for this operation
user_atom->set_id(user_id);
CPPAD_ATOMIC_CALL(
p, q, user_vx, user_vy, user_tx, user_ty
);
# ifndef NDEBUG
if( ! user_ok )
{ std::string msg =
atomic_base<Base>::class_name(user_index)
+ ": atomic_base.forward: returned false";
CPPAD_ASSERT_KNOWN(false, msg.c_str() );
}
# endif
for(i = 0; i < user_m; i++)
if( user_iy[i] > 0 )
for(k = p; k <= q; k++)
taylor[ user_iy[i] * J + k ] =
user_ty[ i * user_q1 + k ];
# if CPPAD_FORWARD1SWEEP_TRACE
user_state = user_trace;
# else
user_state = user_start;
# endif
}
break;
case UsrapOp:
// parameter argument in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
CPPAD_ASSERT_UNKNOWN( user_j < user_n );
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
user_tx[user_j * user_q1 + 0] = parameter[ arg[0]];
for(k = 1; k < user_q1; k++)
user_tx[user_j * user_q1 + k] = Base(0);
++user_j;
if( user_j == user_n )
user_state = user_ret;
break;
case UsravOp:
// variable argument in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
CPPAD_ASSERT_UNKNOWN( user_j < user_n );
CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
for(k = 0; k < user_q1; k++)
user_tx[user_j * user_q1 + k] = taylor[ arg[0] * J + k];
++user_j;
if( user_j == user_n )
user_state = user_ret;
break;
case UsrrpOp:
// parameter result in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
CPPAD_ASSERT_UNKNOWN( user_i < user_m );
user_iy[user_i] = 0;
user_ty[user_i * user_q1 + 0] = parameter[ arg[0]];
for(k = 1; k < p; k++)
user_ty[user_i * user_q1 + k] = Base(0);
user_i++;
if( user_i == user_m )
user_state = user_end;
break;
case UsrrvOp:
// variable result in an atomic operation sequence
CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
CPPAD_ASSERT_UNKNOWN( user_i < user_m );
user_iy[user_i] = i_var;
for(k = 0; k < p; k++)
user_ty[user_i * user_q1 + k] = taylor[ i_var * J + k];
user_i++;
if( user_i == user_m )
user_state = user_end;
break;
// -------------------------------------------------
default:
CPPAD_ASSERT_UNKNOWN(0);
}
# if CPPAD_FORWARD1SWEEP_TRACE
if( user_state == user_trace )
{ user_state = user_start;
CPPAD_ASSERT_UNKNOWN( op == UserOp );
CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
{ size_t i_tmp = (i_op + i) - user_m;
printOp(
std::cout,
play,
i_tmp,
user_iy[i],
UsrrvOp,
CPPAD_NULL
);
Base* Z_tmp = taylor + user_iy[i] * J;
printOpResult(
std::cout,
q + 1,
Z_tmp,
0,
(Base *) CPPAD_NULL
);
std::cout << std::endl;
}
}
Base* Z_tmp = taylor + J * i_var;
const addr_t* arg_tmp = arg;
if( op == CSumOp )
arg_tmp = arg - arg[-1] - 4;
if( op == CSkipOp )
arg_tmp = arg - arg[-1] - 7;
if( op != UsrrvOp )
{
printOp(
std::cout,
play,
i_op,
i_var,
op,
arg_tmp
);
if( NumRes(op) > 0 ) printOpResult(
std::cout,
q + 1,
Z_tmp,
0,
(Base *) CPPAD_NULL
);
std::cout << std::endl;
}
}
std::cout << std::endl;
# else
}
void FCascadeEdPreviewViewportClient::Draw(FViewport* Viewport, FCanvas* Canvas)
{
if (!CascadePtr.IsValid())
{
return;
}
Canvas->Clear( GetPreviewBackgroundColor());
// Clear out the lines from the previous frame
CascadePreviewScene.ClearLineBatcher();
ULineBatchComponent* LineBatcher = CascadePreviewScene.GetLineBatcher();
CascadePreviewScene.RemoveComponent(LineBatcher);
const FVector XAxis(1,0,0);
const FVector YAxis(0,1,0);
const FVector ZAxis(0,0,1);
if (GetDrawElement(OriginAxis))
{
FMatrix ArrowMatrix = FMatrix(XAxis, YAxis, ZAxis, FVector::ZeroVector);
LineBatcher->DrawDirectionalArrow(ArrowMatrix, FColorList::Red, 10.f, 1.0f, SDPG_World);
ArrowMatrix = FMatrix(YAxis, ZAxis, XAxis, FVector::ZeroVector);
LineBatcher->DrawDirectionalArrow(ArrowMatrix, FColorList::Green, 10.f, 1.0f, SDPG_World);
ArrowMatrix = FMatrix(ZAxis, XAxis, YAxis, FVector::ZeroVector);
LineBatcher->DrawDirectionalArrow(ArrowMatrix, FColorList::Blue, 10.f, 1.0f, SDPG_World);
}
if (GetDrawElement(WireSphere))
{
FVector Base(0.f);
FColor WireColor = FColor::Red;
const int32 NumRings = 16;
const float RotatorMultiplier = 360.f / NumRings;
const int32 NumSides = 32;
for (int32 i = 0; i < NumRings; i++)
{
FVector RotXAxis;
FVector RotYAxis;
FVector RotZAxis;
FRotationMatrix RotMatrix(FRotator(i * RotatorMultiplier, 0, 0));
RotXAxis = RotMatrix.TransformPosition(XAxis);
RotYAxis = RotMatrix.TransformPosition(YAxis);
RotZAxis = RotMatrix.TransformPosition(ZAxis);
LineBatcher->DrawCircle(Base, RotXAxis, RotYAxis, WireColor, WireSphereRadius, NumSides, SDPG_World);
LineBatcher->DrawCircle(Base, RotXAxis, RotZAxis, WireColor, WireSphereRadius, NumSides, SDPG_World);
LineBatcher->DrawCircle(Base, RotYAxis, RotZAxis, WireColor, WireSphereRadius, NumSides, SDPG_World);
RotMatrix = FRotationMatrix(FRotator(0, i * RotatorMultiplier, 0));
RotXAxis = RotMatrix.TransformPosition(XAxis);
RotYAxis = RotMatrix.TransformPosition(YAxis);
RotZAxis = RotMatrix.TransformPosition(ZAxis);
LineBatcher->DrawCircle(Base, RotXAxis, RotYAxis, WireColor, WireSphereRadius, NumSides, SDPG_World);
LineBatcher->DrawCircle(Base, RotXAxis, RotZAxis, WireColor, WireSphereRadius, NumSides, SDPG_World);
LineBatcher->DrawCircle(Base, RotYAxis, RotZAxis, WireColor, WireSphereRadius, NumSides, SDPG_World);
}
}
FEngineShowFlags SavedEngineShowFlags = EngineShowFlags;
if (GetDrawElement(Bounds))
{
EngineShowFlags.SetBounds(true);
EngineShowFlags.Game = 1;
}
EngineShowFlags.SetVectorFields(GetDrawElement(VectorFields));
CascadePreviewScene.AddComponent(LineBatcher,FTransform::Identity);
FEditorViewportClient::Draw(Viewport, Canvas);
EngineShowFlags = SavedEngineShowFlags;
FCanvasTextItem TextItem( FVector2D::ZeroVector, FText::GetEmpty(), GEngine->GetTinyFont(), FLinearColor::White );
if (GetDrawElement(ParticleCounts) || GetDrawElement(ParticleTimes) || GetDrawElement(ParticleEvents) || GetDrawElement(ParticleMemory) || GetDrawElement(ParticleSystemCompleted))
{
// 'Up' from the lower left...
FString strOutput;
const int32 XPosition = Viewport->GetSizeXY().X - 5;
int32 YPosition = Viewport->GetSizeXY().Y - (GetDrawElement(ParticleMemory) ? 15 : 5);
UParticleSystemComponent* PartComp = CascadePtr.Pin()->GetParticleSystemComponent();
int32 iWidth, iHeight;
if (PartComp->EmitterInstances.Num())
{
for (int32 i = 0; i < PartComp->EmitterInstances.Num(); i++)
{
FParticleEmitterInstance* Instance = PartComp->EmitterInstances[i];
if (!Instance || !Instance->SpriteTemplate)
{
continue;
}
UParticleLODLevel* LODLevel = Instance->SpriteTemplate->GetCurrentLODLevel(Instance);
if (!LODLevel)
{
continue;
}
strOutput = TEXT("");
if (Instance->SpriteTemplate->EmitterRenderMode != ERM_None)
{
UParticleLODLevel* HighLODLevel = Instance->SpriteTemplate->GetLODLevel(0);
if (GetDrawElement(ParticleCounts))
{
strOutput += FString::Printf(TEXT("%4d/%4d"),
Instance->ActiveParticles, HighLODLevel->PeakActiveParticles);
}
if (GetDrawElement(ParticleTimes))
{
if (GetDrawElement(ParticleCounts))
{
strOutput += TEXT("/");
}
strOutput += FString::Printf(TEXT("%8.4f/%8.4f"),
Instance->EmitterTime, Instance->SecondsSinceCreation);
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (GetDrawElement(ParticleEvents))
{
if (GetDrawElement(ParticleCounts) || GetDrawElement(ParticleTimes))
{
strOutput += TEXT("/");
}
strOutput += FString::Printf(TEXT("Evts: %4d/%4d"), Instance->EventCount, Instance->MaxEventCount);
}
#endif //#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
UCanvas::ClippedStrLen(GEngine->GetTinyFont(), 1.0f, 1.0f, iWidth, iHeight, *strOutput);
TextItem.SetColor( Instance->SpriteTemplate->EmitterEditorColor );
TextItem.Text = FText::FromString( strOutput );
Canvas->DrawItem( TextItem, XPosition - iWidth, YPosition - iHeight );
YPosition -= iHeight - 2;
}
}
if (GetDrawElement(ParticleMemory))
{
YPosition = Viewport->GetSizeXY().Y - 5;
FString MemoryOutput = FString::Printf(TEXT("Template: %.0f KByte / Instance: %.0f KByte"),
(float)ParticleSystemRootSize / 1024.0f + (float)ParticleModuleMemSize / 1024.0f,
(float)PSysCompRootSize / 1024.0f + (float)PSysCompResourceSize / 1024.0f);
UCanvas::ClippedStrLen(GEngine->GetTinyFont(), 1.0f, 1.0f, iWidth, iHeight, *MemoryOutput);
TextItem.SetColor( FLinearColor::White );
TextItem.Text = FText::FromString( MemoryOutput );
Canvas->DrawItem( TextItem, XPosition - iWidth, YPosition - iHeight );
}
}
else
{
for (int32 i = 0; i < PartComp->Template->Emitters.Num(); i++)
{
strOutput = TEXT("");
UParticleEmitter* Emitter = PartComp->Template->Emitters[i];
UParticleLODLevel* LODLevel = Emitter->GetLODLevel(0);
if (LODLevel && LODLevel->bEnabled && (Emitter->EmitterRenderMode != ERM_None))
{
if (GetDrawElement(ParticleCounts))
{
strOutput += FString::Printf(TEXT("%4d/%4d"),
0, LODLevel->PeakActiveParticles);
}
if (GetDrawElement(ParticleTimes))
{
if (GetDrawElement(ParticleCounts))
{
strOutput += TEXT("/");
}
strOutput += FString::Printf(TEXT("%8.4f/%8.4f"), 0.f, 0.f);
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (GetDrawElement(ParticleEvents))
{
if (GetDrawElement(ParticleCounts) || GetDrawElement(ParticleTimes))
{
strOutput += TEXT("/");
}
strOutput += FString::Printf(TEXT("Evts: %4d/%4d"), 0, 0);
}
#endif //#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
UCanvas::ClippedStrLen(GEngine->GetTinyFont(), 1.0f, 1.0f, iWidth, iHeight, *strOutput);
TextItem.SetColor( Emitter->EmitterEditorColor );
TextItem.Text = FText::FromString( strOutput );
Canvas->DrawItem( TextItem, XPosition - iWidth, YPosition - iHeight );
YPosition -= iHeight - 2;
}
}
if (GetDrawElement(ParticleMemory))
{
YPosition = Viewport->GetSizeXY().Y - 5;
FString MemoryOutput = FString::Printf(TEXT("Template: %.0f KByte / Instance: %.0f KByte"),
(float)ParticleSystemRootSize / 1024.0f + (float)ParticleModuleMemSize / 1024.0f,
(float)PSysCompRootSize / 1024.0f + (float)PSysCompResourceSize / 1024.0f);
UCanvas::ClippedStrLen(GEngine->GetTinyFont(), 1.0f, 1.0f, iWidth, iHeight, *MemoryOutput);
TextItem.SetColor( FLinearColor::White );
TextItem.Text = FText::FromString( MemoryOutput );
Canvas->DrawItem( TextItem, XPosition - iWidth, YPosition - iHeight );
}
}
if (GetDrawElement(ParticleSystemCompleted))
{
if (PartComp->HasCompleted())
{
TextItem.SetColor(FLinearColor::White);
TextItem.Text = LOCTEXT("SystemCompleted", "Completed");
TextItem.bCentreX = true;
TextItem.bCentreY = true;
Canvas->DrawItem(TextItem, Viewport->GetSizeXY().X * 0.5f, Viewport->GetSizeXY().Y - 10);
TextItem.bCentreX = false;
TextItem.bCentreY = false;
}
}
}
//Display a warning message in the preview window if the system has no fixed bounding-box and contains a GPU emitter.
if(CascadePtr.Pin()->GetParticleSystem()->bUseFixedRelativeBoundingBox == false)
{
UParticleSystemComponent* PartComp = CascadePtr.Pin()->GetParticleSystemComponent();
if (PartComp->EmitterInstances.Num())
{
//We iterate over the emitter instances to find any that contain a GPU Sprite TypeData module. If found, we draw the warning message.
for (int32 i = 0; i < PartComp->EmitterInstances.Num(); i++)
{
FParticleEmitterInstance* Instance = PartComp->EmitterInstances[i];
if(!Instance || !Instance->SpriteTemplate)
{
continue;
}
UParticleLODLevel* LODLevel = Instance->SpriteTemplate->GetCurrentLODLevel(Instance);
if (!LODLevel || !LODLevel->TypeDataModule)
{
continue;
}
const bool bIsAGPUEmitter = LODLevel->TypeDataModule->IsA(UParticleModuleTypeDataGpu::StaticClass());
if(bIsAGPUEmitter)
{
const int32 XPosition = 5;
const int32 YPosition = Viewport->GetSizeXY().Y - 75.0f;
FString strOutput = NSLOCTEXT("Cascade", "NoFixedBounds_Warning", "WARNING: This particle system has no fixed bounding box and contains a GPU emitter.").ToString();
TextItem.SetColor( FLinearColor::White );
TextItem.Text = FText::FromString( strOutput );
Canvas->DrawItem( TextItem, XPosition, YPosition );
break;
}
}
}
}
int32 DetailMode = CascadePtr.Pin()->GetDetailMode();
if (DetailMode != DM_High)
{
FString DetailModeOutput = FString::Printf(TEXT("DETAIL MODE: %s"), (DetailMode == DM_Medium)? TEXT("MEDIUM"): TEXT("LOW"));
TextItem.SetColor( FLinearColor::Red );
TextItem.Text = FText::FromString( DetailModeOutput );
Canvas->DrawItem( TextItem, 5.0f, Viewport->GetSizeXY().Y - 90.0f );
}
if (GEngine->bEnableEditorPSysRealtimeLOD)
{
TextItem.SetColor( FLinearColor(0.25f, 0.25f, 1.0f) );
TextItem.Text = LOCTEXT("LODPREVIEWMODEENABLED","LOD PREVIEW MODE ENABLED");
Canvas->DrawItem( TextItem, 5.0f, Viewport->GetSizeXY().Y - 105.0f );
}
EParticleSignificanceLevel ReqSignificance = CascadePtr.Pin()->GetRequiredSignificance();
if (ReqSignificance != EParticleSignificanceLevel::Low)
{
FString ReqSigOutput = FString::Printf(TEXT("REQUIRED SIGNIFICANCE: %s"), (ReqSignificance == EParticleSignificanceLevel::Medium) ? TEXT("MEDIUM") : ((ReqSignificance == EParticleSignificanceLevel::High) ? TEXT("HIGH") : TEXT("CRITICAL")));
TextItem.SetColor(FLinearColor::Red);
TextItem.Text = FText::FromString(ReqSigOutput);
Canvas->DrawItem(TextItem, 5.0f, Viewport->GetSizeXY().Y - 120.0f);
}
if (bCaptureScreenShot)
{
UParticleSystem* ParticleSystem = CascadePtr.Pin()->GetParticleSystem();
int32 SrcWidth = Viewport->GetSizeXY().X;
int32 SrcHeight = Viewport->GetSizeXY().Y;
// Read the contents of the viewport into an array.
TArray<FColor> OrigBitmap;
if (Viewport->ReadPixels(OrigBitmap))
{
check(OrigBitmap.Num() == SrcWidth * SrcHeight);
// Resize image to enforce max size.
TArray<FColor> ScaledBitmap;
int32 ScaledWidth = 512;
int32 ScaledHeight = 512;
FImageUtils::ImageResize(SrcWidth, SrcHeight, OrigBitmap, ScaledWidth, ScaledHeight, ScaledBitmap, true);
// Compress.
FCreateTexture2DParameters Params;
Params.bDeferCompression = true;
ParticleSystem->ThumbnailImage = FImageUtils::CreateTexture2D(ScaledWidth, ScaledHeight, ScaledBitmap, ParticleSystem, TEXT("ThumbnailTexture"), RF_NoFlags, Params);
ParticleSystem->ThumbnailImageOutOfDate = false;
ParticleSystem->MarkPackageDirty();
}
bCaptureScreenShot = false;
}
}
Line_d<R> Segment_d<R>::supporting_line() const
{ CGAL_assertion_msg((!is_degenerate()),
"Segment_d::supporting_line(): degenerate segment cannot be converted.");
return Line_d<R>(Base(*this));
}
head_iterator(Predicate f, T start) :
super_t(Base(start)),
m_predicate(f),
m_end(false)
{}
TDerived() { Base(); }
// intel 7.1 doesn't like default copy constructor
binary_from_base64(const binary_from_base64 & rhs) :
super_t(
Base(rhs.base_reference()),
detail::to_6_bit<CharType>()
)
{}
inline void reverse_acosh_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 )
{
// check assumptions
CPPAD_ASSERT_UNKNOWN( NumArg(AcoshOp) == 1 );
CPPAD_ASSERT_UNKNOWN( NumRes(AcoshOp) == 2 );
CPPAD_ASSERT_UNKNOWN( d < cap_order );
CPPAD_ASSERT_UNKNOWN( d < nc_partial );
// Taylor coefficients and partials corresponding to argument
const Base* x = taylor + i_x * cap_order;
Base* px = partial + i_x * nc_partial;
// Taylor coefficients and partials corresponding to first result
const Base* z = taylor + i_z * cap_order;
Base* pz = partial + i_z * nc_partial;
// Taylor coefficients and partials corresponding to auxillary result
const Base* b = z - cap_order; // called y in documentation
Base* pb = pz - nc_partial;
Base inv_b0 = Base(1) / b[0];
// number of indices to access
size_t j = d;
size_t k;
while(j)
{
// scale partials w.r.t b[j] by 1 / b[0]
pb[j] = azmul(pb[j], inv_b0);
// scale partials w.r.t z[j] by 1 / b[0]
pz[j] = azmul(pz[j], inv_b0);
// update partials w.r.t b^0
pb[0] -= azmul(pz[j], z[j]) + azmul(pb[j], b[j]);
// update partial w.r.t. x^0
px[0] += azmul(pb[j], x[j]);
// update partial w.r.t. x^j
px[j] += pz[j] + azmul(pb[j], x[0]);
// further scale partial w.r.t. z[j] by 1 / j
pz[j] /= Base(j);
for(k = 1; k < j; k++)
{ // update partials w.r.t b^(j-k)
pb[j-k] -= Base(k) * azmul(pz[j], z[k]) + azmul(pb[j], b[k]);
// update partials w.r.t. x^k
px[k] += azmul(pb[j], x[j-k]);
// update partials w.r.t. z^k
pz[k] -= Base(k) * azmul(pz[j], b[j-k]);
}
--j;
}
// j == 0 case
px[0] += azmul(pz[0] + azmul(pb[0], x[0]), inv_b0);
}
VectorCd<FT,LA> PointCd<FT,LA>::operator-(const Origin&) const
{ return VectorCd<FT,LA>(Base(*this)); }
m_bnext = 0;
++(this->base_reference());
m_full = false;
}
// buffer to handle pending characters
int m_bend;
int m_bnext;
char m_buffer[9];
bool m_full;
public:
// make composible buy using templated constructor
template<class T>
mb_from_wchar(BOOST_PFTO_WRAPPER(T) start) :
super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast< T >(start)))),
m_bend(0),
m_bnext(0),
m_full(false)
{}
// intel 7.1 doesn't like default copy constructor
mb_from_wchar(const mb_from_wchar & rhs) :
super_t(rhs.base_reference()),
m_bend(rhs.m_bend),
m_bnext(rhs.m_bnext),
m_full(rhs.m_full)
{}
};
} // namespace iterators
} // namespace archive
VectorBase ADFun<Base>::RevTwo(
const VectorBase &x,
const VectorSize_t &i,
const VectorSize_t &j)
{ size_t i1;
size_t j1;
size_t k;
size_t l;
size_t n = Domain();
size_t m = Range();
size_t p = i.size();
// check VectorBase is Simple Vector class with Base elements
CheckSimpleVector<Base, VectorBase>();
// check VectorSize_t is Simple Vector class with size_t elements
CheckSimpleVector<size_t, VectorSize_t>();
CPPAD_ASSERT_KNOWN(
x.size() == n,
"RevTwo: Length of x not equal domain dimension for f."
);
CPPAD_ASSERT_KNOWN(
i.size() == j.size(),
"RevTwo: Lenght of the i and j vectors are not equal."
);
// point at which we are evaluating the second partials
Forward(0, x);
// dimension the return value
VectorBase ddw(n * p);
// direction vector in argument space
VectorBase dx(n);
for(j1 = 0; j1 < n; j1++)
dx[j1] = Base(0);
// direction vector in range space
VectorBase w(m);
for(i1 = 0; i1 < m; i1++)
w[i1] = Base(0);
// place to hold the results of a reverse calculation
VectorBase r(n * 2);
// check the indices in i and j
for(l = 0; l < p; l++)
{ i1 = i[l];
j1 = j[l];
CPPAD_ASSERT_KNOWN(
i1 < m,
"RevTwo: an eleemnt of i not less than range dimension for f."
);
CPPAD_ASSERT_KNOWN(
j1 < n,
"RevTwo: an element of j not less than domain dimension for f."
);
}
// loop over all forward directions
for(j1 = 0; j1 < n; j1++)
{ // first order forward mode calculation done
bool first_done = false;
for(l = 0; l < p; l++) if( j[l] == j1 )
{ if( ! first_done )
{ first_done = true;
// first order forward mode in j1 direction
dx[j1] = Base(1);
Forward(1, dx);
dx[j1] = Base(0);
}
// execute a reverse in this component direction
i1 = i[l];
w[i1] = Base(1);
r = Reverse(2, w);
w[i1] = Base(0);
// place the reverse result in return value
for(k = 0; k < n; k++)
ddw[k * p + l] = r[k * 2 + 1];
}
}
return ddw;
}
