自学教程：C++ AD类代码示例

double bug_1222() {  typedef Eigen::AutoDiffScalar<Eigen::Vector3d> AD;  const double _cv1_3 = 1.0;  const AD chi_3 = 1.0;  // this line did not work, because operator+ returns ADS<DerType&>, which then cannot be converted to ADS<DerType>  const AD denom = chi_3 + _cv1_3;  return denom.value();}

void test_autodiff_scalar(){  Vector2f p = Vector2f::Random();  typedef AutoDiffScalar<Vector2f> AD;  AD ax(p.x(),Vector2f::UnitX());  AD ay(p.y(),Vector2f::UnitY());  AD res = foo<AD>(ax,ay);  VERIFY_IS_APPROX(res.value(), foo(p.x(),p.y()));}

// check a compilation issue with numext::maxdouble bug_1261() {  typedef AutoDiffScalar<Matrix2d> AD;  typedef Matrix<AD,2,1> VectorAD;  VectorAD v(0.,0.);  const AD maxVal = v.maxCoeff();  const AD minVal = v.minCoeff();  return maxVal.value() + minVal.value();}

void test_autodiff_scalar(){    std::cerr << foo<float>(1,2) << "/n";    typedef AutoDiffScalar<Vector2f> AD;    AD ax(1,Vector2f::UnitX());    AD ay(2,Vector2f::UnitY());    AD res = foo<AD>(ax,ay);    std::cerr << res.value() << " <> "              << res.derivatives().transpose() << "/n/n";}

void test_autodiff_vector(){  Vector2f p = Vector2f::Random();  typedef AutoDiffScalar<Vector2f> AD;  typedef Matrix<AD,2,1> VectorAD;  VectorAD ap = p.cast<AD>();  ap.x().derivatives() = Vector2f::UnitX();  ap.y().derivatives() = Vector2f::UnitY();  AD res = foo<VectorAD>(ap);  VERIFY_IS_APPROX(res.value(), foo(p));}

void test_autodiff_vector(){    std::cerr << foo<Vector2f>(Vector2f(1,2)) << "/n";    typedef AutoDiffScalar<Vector2f> AD;    typedef Matrix<AD,2,1> VectorAD;    VectorAD p(AD(1),AD(-1));    p.x().derivatives() = Vector2f::UnitX();    p.y().derivatives() = Vector2f::UnitY();    AD res = foo<VectorAD>(p);    std::cerr << res.value() << " <> "              << res.derivatives().transpose() << "/n/n";}

CPPAD_INLINE bool operator != (const AD<Base> &left , const AD<Base> &right){	bool result =  (left.value_ != right.value_);	ADTape<Base> *tape = CPPAD_NULL;	if( Variable(left) )		tape = left.tape_this();	else if ( Variable(right) )		tape = right.tape_this();	if( tape != CPPAD_NULL )		tape->RecordCompare(CompareNe, result, left, right);	return result;}

UINT RandomWalk::collectData(LPVOID lparam){	AD obj;	while(TRUE){		obj.readData();		obj.getDistance(arrayDistance, 8);		for(int i=0; i< 8; i++){			if(arrayDistance[i] <= 5.0){				SetEvent(hSysStatus);				continue;			}		}		obj.getVoltage(arrayVoltage, 2);	}	return 0;}

template<typename Scalar> void check_atan2(){  typedef Matrix<Scalar, 1, 1> Deriv1;  typedef AutoDiffScalar<Deriv1> AD;    AD x(internal::random<Scalar>(-3.0, 3.0), Deriv1::UnitX());    using std::exp;  Scalar r = exp(internal::random<Scalar>(-10, 10));    AD s = sin(x), c = cos(x);  AD res = atan2(r*s, r*c);    VERIFY_IS_APPROX(res.value(), x.value());  VERIFY_IS_APPROX(res.derivatives(), x.derivatives());}

double bug_1223() {  using std::min;  typedef Eigen::AutoDiffScalar<Eigen::Vector3d> AD;  const double _cv1_3 = 1.0;  const AD chi_3 = 1.0;  const AD denom = 1.0;  // failed because implementation of min attempts to construct ADS<DerType&> via constructor AutoDiffScalar(const Real& value)  // without initializing m_derivatives (which is a reference in this case)  #define EIGEN_TEST_SPACE  const AD t = min EIGEN_TEST_SPACE (denom / chi_3, 1.0);  const AD t2 = min EIGEN_TEST_SPACE (denom / (chi_3 * _cv1_3), 1.0);  return t.value() + t2.value();}

CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTIONbool operator >= (const AD<Base> &left , const AD<Base> &right){	bool result    =  (left.value_ >= right.value_);	bool var_left  = Variable(left);	bool var_right = Variable(right);	ADTape<Base> *tape = CPPAD_NULL;	if( var_left )	{	tape = left.tape_this();		if( var_right )		{	if( result )			{	tape->Rec_.PutOp(LevvOp);				tape->Rec_.PutArg(right.taddr_, left.taddr_);			}			else			{	tape->Rec_.PutOp(LtvvOp);				tape->Rec_.PutArg(left.taddr_, right.taddr_);			}		}		else		{	addr_t arg1 = tape->Rec_.PutPar(right.value_);			if( result )			{	tape->Rec_.PutOp(LepvOp);				tape->Rec_.PutArg(arg1, left.taddr_);			}			else			{	tape->Rec_.PutOp(LtvpOp);				tape->Rec_.PutArg(left.taddr_, arg1);			}		}	}	else if ( var_right )	{	tape = right.tape_this();		addr_t arg0 = tape->Rec_.PutPar(left.value_);		if( result )		{	tape->Rec_.PutOp(LevpOp);			tape->Rec_.PutArg(right.taddr_, arg0);		}		else		{	tape->Rec_.PutOp(LtpvOp);			tape->Rec_.PutArg(arg0, right.taddr_);		}	}	return result;}

	// used during the recording process	AD<Base> Eval(const AD<Base> &x) const	{	AD<Base> z;		z.value_ = f(x.value_);		if( Variable(x) )		{	x.tape_this()->RecordDisOp(				z,				x.taddr_,				y_taddr			);		}		return z;	}

CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTIONbool operator != (const AD<Base> &left , const AD<Base> &right){	bool result    =  (left.value_ != right.value_);	bool var_left  = Variable(left);	bool var_right = Variable(right);	local::ADTape<Base> *tape = CPPAD_NULL;	if( var_left )	{	tape = left.tape_this();		if( var_right )		{	tape->Rec_.PutArg(left.taddr_, right.taddr_);			if( result )				tape->Rec_.PutOp(local::NevvOp);			else				tape->Rec_.PutOp(local::EqvvOp);		}		else		{	addr_t arg1 = tape->Rec_.PutPar(right.value_);			tape->Rec_.PutArg(arg1, left.taddr_);			if( result )				tape->Rec_.PutOp(local::NepvOp);			else				tape->Rec_.PutOp(local::EqpvOp);		}	}	else if ( var_right )	{	tape = right.tape_this();		addr_t arg0 = tape->Rec_.PutPar(left.value_);		tape->Rec_.PutArg(arg0, right.taddr_);		if( result )			tape->Rec_.PutOp(local::NepvOp);		else			tape->Rec_.PutOp(local::EqpvOp);	}	return result;}

// DO NOT MODIFY THE AUDIO CALLBACK FUNCTION void audioCallBack(AudioIOData& io){	while(io()) 	{		if(tmr()) env.reset();	// Reset AD envelope				input = white() * env(); // Apply envelope to white noise 		roomReverb(input, output, decayTime); // Apply reverb		for (int i = 0; i < channelsOut; i++) 		{			io.out(i) = ( (1.0 - dryWet) * input + dryWet * output ) * level; 		}	} }

AD<T> log(const AD<T>& x){  AD<T> newAD;  ADnode<T>* orx = x.getRoot();  newAD.setRoot(new ADlog<T>(orx));  return newAD;}

AD<T> asin(const AD<T>& x){  AD<T> newAD;  ADnode<T>* orx = x.getRoot();  newAD.setRoot(new ADasin<T>(orx));  return newAD;}

AD<Base> operator / (const AD<Base> &left , const AD<Base> &right){    // compute the Base part    AD<Base> result;    result.value_  = left.value_ / right.value_;    CPPAD_ASSERT_UNKNOWN( Parameter(result) );    // check if there is a recording in progress    local::ADTape<Base>* tape = AD<Base>::tape_ptr();    if( tape == CPPAD_NULL )        return result;    tape_id_t tape_id = tape->id_;    // tape_id cannot match the default value for tape_id_; i.e., 0    CPPAD_ASSERT_UNKNOWN( tape_id > 0 );    // check if left and right tapes match    bool match_left  = left.tape_id_  == tape_id;    bool match_right = right.tape_id_ == tape_id;    // check if left and right are dynamic parameters    bool dyn_left  = match_left  & (left.ad_type_ == dynamic_enum);    bool dyn_right = match_right & (right.ad_type_ == dynamic_enum);    // check if left and right are variables    bool var_left  = match_left  & (left.ad_type_ != dynamic_enum);    bool var_right = match_right & (right.ad_type_ != dynamic_enum);    CPPAD_ASSERT_KNOWN(        left.tape_id_ == right.tape_id_ || ! match_left || ! match_right ,        "Divide: AD variables or dynamic parameters on different threads."    );    if( var_left )    {   if( var_right )        {   // result = variable / variable            CPPAD_ASSERT_UNKNOWN( local::NumRes(local::DivvvOp) == 1 );            CPPAD_ASSERT_UNKNOWN( local::NumArg(local::DivvvOp) == 2 );            // put operand addresses in tape            tape->Rec_.PutArg(left.taddr_, right.taddr_);            // put operator in the tape            result.taddr_ = tape->Rec_.PutOp(local::DivvvOp);            // make result a variable            result.tape_id_ = tape_id;            result.ad_type_ = variable_enum;        }        else if( (! dyn_right) & IdenticalOne(right.value_) )        {   // result = variable / 1            result.make_variable(left.tape_id_, left.taddr_);        }        else        {   // result = variable / parameter            CPPAD_ASSERT_UNKNOWN( local::NumRes(local::DivvpOp) == 1 );            CPPAD_ASSERT_UNKNOWN( local::NumArg(local::DivvpOp) == 2 );            // put operand addresses in tape            addr_t p = right.taddr_;            if( ! dyn_right )                p = tape->Rec_.put_con_par(right.value_);            tape->Rec_.PutArg(left.taddr_, p);            // put operator in the tape            result.taddr_ = tape->Rec_.PutOp(local::DivvpOp);            // make result a variable            result.tape_id_ = tape_id;            result.ad_type_ = variable_enum;        }    }    else if( var_right )    {   if( (! dyn_left) & IdenticalZero(left.value_) )        {   // result = 0 / variable        }        else        {   // result = parameter / variable            CPPAD_ASSERT_UNKNOWN( local::NumRes(local::DivpvOp) == 1 );            CPPAD_ASSERT_UNKNOWN( local::NumArg(local::DivpvOp) == 2 );            // put operand addresses in tape            addr_t p = left.taddr_;            if( ! dyn_left )                p = tape->Rec_.put_con_par(left.value_);            tape->Rec_.PutArg(p, right.taddr_);            // put operator in the tape            result.taddr_ = tape->Rec_.PutOp(local::DivpvOp);            // make result a variable            result.tape_id_ = tape_id;            result.ad_type_ = variable_enum;        }    }    else if( dyn_left | dyn_right )    {   addr_t arg0 = left.taddr_;        addr_t arg1 = right.taddr_;        if( ! dyn_left )            arg0 = tape->Rec_.put_con_par(left.value_);        if( ! dyn_right )            arg1 = tape->Rec_.put_con_par(right.value_);        //        // parameters with a dynamic parameter result        result.taddr_   = tape->Rec_.put_dyn_par(            result.value_, local::div_dyn,   arg0, arg1        );        result.tape_id_ = tape_id;//.........这里部分代码省略.........

inline AD<Base> sign(const AD<Base> &x){	return x.Sign(); }

	inline AD<Base> erf(const AD<Base> &x)	{	return x.erf(); }

AD<Base> operator - (const AD<Base> &left , const AD<Base> &right){	ADTape<Base> *tape = AD<Base>::tape_ptr();	bool var_left, var_right;# ifdef NDEBUG	if( tape == CPPAD_NULL )	{	var_left =  false;		var_right = false;	}	else	{		var_left  = left.id_  == tape->id_;		var_right = right.id_ == tape->id_;	}# else	var_left  = Variable(left);	var_right = Variable(right);	CPPAD_ASSERT_KNOWN(		(! var_left) || left.id_ == tape->id_ ,		"- left operand is a variable for a different thread"	);	CPPAD_ASSERT_KNOWN(		(! var_right) || right.id_ == tape->id_ ,		"- right operand is a variable for a different thread"	);# endif	AD<Base> result;	result.value_  = left.value_ - right.value_;	CPPAD_ASSERT_UNKNOWN( Parameter(result) );	if( var_left )	{	if( var_right )		{	// result = variable - variable			CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );			// put operand addresses in tape			tape->Rec_.PutArg(left.taddr_, right.taddr_);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(SubvvOp);			// make result a variable			result.id_ = tape->id_;		}		else if( IdenticalZero(right.value_) )		{	// result = variable - 0			result.make_variable(left.id_, left.taddr_);		}		else		{	// result = variable - parameter			CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );			// put operand addresses in tape			size_t p = tape->Rec_.PutPar(right.value_);			tape->Rec_.PutArg(left.taddr_, p);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(SubvpOp);			// make result a variable			result.id_ = tape->id_;		}	}	else if( var_right )	{	// result = parameter - variable		CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );		CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );		// put operand addresses in tape		size_t p = tape->Rec_.PutPar(left.value_);		tape->Rec_.PutArg(p, right.taddr_);		// put operator in the tape		result.taddr_ = tape->Rec_.PutOp(SubpvOp);		// make result a variable		result.id_ = tape->id_;	}	return result;}

AD<Base> operator + (const AD<Base> &left , const AD<Base> &right){	// compute the Base part of this AD object	AD<Base> result;	result.value_  = left.value_ + right.value_;	CPPAD_ASSERT_UNKNOWN( Parameter(result) );	// check if there is a recording in progress	ADTape<Base>* tape = AD<Base>::tape_ptr();	if( tape == CPPAD_NULL )		return result;	tape_id_t tape_id = tape->id_;	// tape_id cannot match the default value for tape_id_; i.e., 0	CPPAD_ASSERT_UNKNOWN( tape_id > 0 );	bool var_left  = left.tape_id_  == tape_id;	bool var_right = right.tape_id_ == tape_id;	if( var_left )	{	if( var_right )		{	// result = variable + variable			CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );			// put operand addresses in tape			tape->Rec_.PutArg(left.taddr_, right.taddr_);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(AddvvOp);			// make result a variable			result.tape_id_ = tape_id;		}		else if( IdenticalZero(right.value_) )		{	// result = variable + 0			result.make_variable(left.tape_id_, left.taddr_);		}		else		{	// result = variable  + parameter			//        = parameter + variable			CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );			// put operand addresses in tape			addr_t p = tape->Rec_.PutPar(right.value_);			tape->Rec_.PutArg(p, left.taddr_);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(AddpvOp);			// make result a variable			result.tape_id_ = tape_id;		}	}	else if( var_right )	{	if( IdenticalZero(left.value_) )		{	// result = 0 + variable			result.make_variable(right.tape_id_, right.taddr_);		}		else		{	// result = parameter + variable			CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );			// put operand addresses in tape			addr_t p = tape->Rec_.PutPar(left.value_);			tape->Rec_.PutArg(p, right.taddr_);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(AddpvOp);			// make result a variable			result.tape_id_ = tape_id;		}	}	return result;}

// case where x and y are AD<Base> -------------------------------------------template <class Base> AD<Base>azmul(const AD<Base>& x, const AD<Base>& y){	// compute the Base part	AD<Base> result;	result.value_ = azmul(x.value_, y.value_);	// check if there is a recording in progress	ADTape<Base>* tape = AD<Base>::tape_ptr();	if( tape == CPPAD_NULL )		return result;	tape_id_t tape_id = tape->id_;	// tape_id cannot match the default value for tape_id_; i.e., 0	CPPAD_ASSERT_UNKNOWN( tape_id > 0 );	bool var_x = x.tape_id_ == tape_id;	bool var_y = y.tape_id_ == tape_id;	if( var_x )	{	if( var_y )		{	// result = azmul(variable, variable)			CPPAD_ASSERT_UNKNOWN( NumRes(ZmulvvOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(ZmulvvOp) == 2 );			// put operand addresses in tape			tape->Rec_.PutArg(x.taddr_, y.taddr_);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(ZmulvvOp);			// make result a variable			result.tape_id_ = tape_id;		}		else if( IdenticalZero( y.value_ ) )		{	// result = variable * 0		}		else if( IdenticalOne( y.value_ ) )		{	// result = variable * 1			result.make_variable(x.tape_id_, x.taddr_);		}		else		{	// result = zmul(variable, parameter)			CPPAD_ASSERT_UNKNOWN( NumRes(ZmulvpOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(ZmulvpOp) == 2 );			// put operand addresses in tape			addr_t p = tape->Rec_.PutPar(y.value_);			tape->Rec_.PutArg(x.taddr_, p);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(ZmulvpOp);			// make result a variable			result.tape_id_ = tape_id;		}	}	else if( var_y )	{	if( IdenticalZero(x.value_) )		{	// result = 0 * variable		}		else if( IdenticalOne( x.value_ ) )		{	// result = 1 * variable			result.make_variable(y.tape_id_, y.taddr_);		}		else		{	// result = zmul(parameter, variable)			CPPAD_ASSERT_UNKNOWN( NumRes(ZmulpvOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(ZmulpvOp) == 2 );			// put operand addresses in tape			addr_t p = tape->Rec_.PutPar(x.value_);			tape->Rec_.PutArg(p, y.taddr_);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(ZmulpvOp);			// make result a variable			result.tape_id_ = tape_id;		}	}	return result;}

CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTIONAD<Base> CondExpOp(	enum  CompareOp cop       ,	const AD<Base> &left      ,	const AD<Base> &right     ,	const AD<Base> &if_true   ,	const AD<Base> &if_false  ){	AD<Base> returnValue;	CPPAD_ASSERT_UNKNOWN( Parameter(returnValue) );	// check first case where do not need to tape	if( IdenticalPar(left) & IdenticalPar(right) )	{	switch( cop )		{			case CompareLt:			if( left.value_ < right.value_ )				returnValue = if_true;			else	returnValue = if_false;			break;			case CompareLe:			if( left.value_ <= right.value_ )				returnValue = if_true;			else	returnValue = if_false;			break;			case CompareEq:			if( left.value_ == right.value_ )				returnValue = if_true;			else	returnValue = if_false;			break;			case CompareGe:			if( left.value_ >= right.value_ )				returnValue = if_true;			else	returnValue = if_false;			break;			case CompareGt:			if( left.value_ > right.value_ )				returnValue = if_true;			else	returnValue = if_false;			break;			default:			CPPAD_ASSERT_UNKNOWN(0);			returnValue = if_true;		}		return returnValue;	}	// must use CondExp incase Base is an AD type and recording	returnValue.value_ = CondExpOp(cop,		left.value_, right.value_, if_true.value_, if_false.value_);	ADTape<Base> *tape = CPPAD_NULL;	if( Variable(left) )		tape = left.tape_this();	if( Variable(right) )		tape = right.tape_this();	if( Variable(if_true) )		tape = if_true.tape_this();	if( Variable(if_false) )		tape = if_false.tape_this();	// add this operation to the tape	if( tape != CPPAD_NULL )		tape->RecordCondExp(cop,			returnValue, left, right, if_true, if_false);	return returnValue;}

void ADTape<Base>::RecordCondExp(	enum CompareOp  cop         ,	AD<Base>       &returnValue ,	const AD<Base> &left        ,	const AD<Base> &right       ,	const AD<Base> &if_true     ,	const AD<Base> &if_false    ){	size_t   ind0, ind1, ind2, ind3, ind4, ind5;	size_t   returnValue_taddr;	// taddr_ of this variable	CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );	returnValue_taddr = Rec_.PutOp(CExpOp);	// ind[0] = cop	ind0 = addr_t( cop );	// ind[1] = base 2 representaion of the value	// [Var(left), Var(right), Var(if_true), Var(if_false)]	ind1 = 0;	// Make sure returnValue is in the list of variables and set its taddr	if( Parameter(returnValue) )		returnValue.make_variable(id_, returnValue_taddr );	else	returnValue.taddr_ = returnValue_taddr;	// ind[2] = left address	if( Parameter(left) )		ind2 = Rec_.PutPar(left.value_);	else	{	ind1 += 1;		ind2 = left.taddr_;	}	// ind[3] = right address	if( Parameter(right) )		ind3 = Rec_.PutPar(right.value_);	else	{	ind1 += 2;		ind3 = right.taddr_;	}	// ind[4] = if_true address	if( Parameter(if_true) )		ind4 = Rec_.PutPar(if_true.value_);	else	{	ind1 += 4;		ind4 = if_true.taddr_;	}	// ind[5] =  if_false address	if( Parameter(if_false) )		ind5 = Rec_.PutPar(if_false.value_);	else	{	ind1 += 8;		ind5 = if_false.taddr_;	}	CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );	CPPAD_ASSERT_UNKNOWN( ind1 > 0 );	Rec_.PutArg(ind0, ind1, ind2, ind3, ind4, ind5);	// check that returnValue is a dependent variable	CPPAD_ASSERT_UNKNOWN( Variable(returnValue) );}

AD<Base> operator / (const AD<Base> &left , const AD<Base> &right){	// compute the Base part	AD<Base> result;	result.value_  = left.value_ / right.value_;	CPPAD_ASSERT_UNKNOWN( Parameter(result) );	// check if there is a recording in progress	ADTape<Base>* tape = AD<Base>::tape_ptr();	if( tape == CPPAD_NULL )		return result;	tape_id_t tape_id = tape->id_;	// tape_id cannot match the default value for tape_id_; i.e., 0	CPPAD_ASSERT_UNKNOWN( tape_id > 0 );	bool var_left  = left.tape_id_  == tape_id;	bool var_right = right.tape_id_ == tape_id;	if( var_left )	{	if( var_right )		{	// result = variable / variable			CPPAD_ASSERT_KNOWN(				left.tape_id_ == right.tape_id_,				"Dividing AD objects that are"				" variables on different tapes."			);			CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );			// put operand addresses in tape			tape->Rec_.PutArg(left.taddr_, right.taddr_);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(DivvvOp);			// make result a variable			result.tape_id_ = tape_id;		}		else if( IdenticalOne(right.value_) )		{	// result = variable / 1			result.make_variable(left.tape_id_, left.taddr_);		}		else		{	// result = variable / parameter			CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );			// put operand addresses in tape			addr_t p = tape->Rec_.PutPar(right.value_);			tape->Rec_.PutArg(left.taddr_, p);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(DivvpOp);			// make result a variable			result.tape_id_ = tape_id;		}	}	else if( var_right )	{	if( IdenticalZero(left.value_) )		{	// result = 0 / variable		}		else		{	// result = parameter / variable			CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );			CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );			// put operand addresses in tape			addr_t p = tape->Rec_.PutPar(left.value_);			tape->Rec_.PutArg(p, right.taddr_);			// put operator in the tape			result.taddr_ = tape->Rec_.PutOp(DivpvOp);			// make result a variable			result.tape_id_ = tape_id;		}	}	return result;}

inline AD<Base> abs(const AD<Base> &x){	return x.Abs(); }

	MyApp(){		lpf.type(LOW_PASS);		// Set filter to low-pass response		lpf.res(4);				// Set resonance amount to emphasize filter		env.attack(0.01);		// Set short (10 ms) attack		env.decay(0.4);			// Set longer (400 ms) decay		tmr.freq(120./60.*4.);	// Set timer frequency to 120 BPM		tmr.phaseMax();			// Ensures timer triggers on first sample		modCutoff.period(30);	// Set period of cutoff modulation		modCutoff.phase(0.5);	// Start half-way through cycle		freq.lag(0.1);			// Lag time of portamento effect		step=0;	}

	void onAudio(AudioIOData& io){		while(io()){			if(tmr()){				// Our sequence of pitches				float pitches[] = {0,0,12,0,0,10,-5,0};				// Map pitch class to a frequency in Hz				float f = 55 * pow(2, pitches[step]/12.);				// Increment step counter				step = (step + 1) % 8;				// Set new target frequence of portamento				freq = f;				// Restart envelope using a soft reset (to avoid clicks)				env.resetSoft();			}			// Set saw frequency from portamento filter			saw.freq(freq());			// Get next envelope value			float e = env();			// Map envelope value to cutoff frequency			lpf.freq(e * (modCutoff.paraU()*6000 + 500) + 40);			// Generate next saw sample			float s = saw() * 0.3;			// Filter saw sample			s = lpf(s) * e;			// Send sample to DAC			io.out(0) = io.out(1) = s;		}	}

int main() {	tmr.period(3);	// Reset the envelope every 3 seconds 	env.attack(0.01);	// Attack time	env.decay(0.05);	// Decay time	// Delays, lowpass, and allpass filters setup code goes here 	//	lpf.type(LOW_PASS);	lpf.freq(2600);	lpf.res(sqrt(2.0)/2.0);	AudioIO audioIO(frameCount, samplingRate, audioCallBack, NULL, channelsOut, channelsIn);	Sync::master().spu(audioIO.framesPerSecond()); 	audioIO.start();	printf("Press 'enter' to quit.../n"); 	getchar();	return 0; }

void audioCB(AudioIOData& io){		position pos;		pos.x=-10;		pos.y=0;		pos.z=0;	while(io()){		float r;		r=rand()%7;	//	cout<<bpmInput<<endl;	//	cout<<tmr2.freq()<<endl;		float s = 0;		float tone = 0;		float bass = 0;		if (tmr()){				src3.reset();			envLPF.reset();			}	if(tmr3()){			env.reset();			env2.reset();			//src3.reset();			tmr3.freq(rnd::uni(beat,beat*2));			src2.reset();		}		if(tmr2()){//			src.reset();			tmr2.freq(rnd::uni(beat,beat*3));			src3.reset();			src2.reset();		}		if (tmr4()){		//		src.reset();			pos.x+=1;			tmr4.freq(rnd::uni(beat,beat*2));			src3.reset();			envLPF.reset();			}		if (tmr5()){		//		src.reset();			pos.x+=1;			tmr5.freq(rnd::uni(beat/2,beat*2));			src4.reset();			envLPF.reset();			}		if (tmr6()){		//		src.reset();			pos.x+=1;			src5.reset();			envLPF.reset();			}		if (tmr7()){		//		src.reset();			pos.x+=1;			src6.reset();			envLPF.reset();			}		if (tmrRand())		{			envswell.reset();			envpan.set(434200,-3);//			beat*=(float)r;		}		if(sweep()){				envwhite.reset();				}					float wet1, wet2;		s=src()*env()*.3;		hpfreq*=envLPF();		tone = src2()*.2;	 	bass = src3()*.3;	 	s+=src4()*.2+src5()*.2+src6()*.2;		tone+=bass;		s+=tone;		reverb(s,wet1, wet2);		//double xplane =  pos.x/10;		//define my sound variables with pan		float batleft=swnoise()*envwhite()*envswell()*.15*envpan();		float batright= swnoise()*envwhite()*(envswell())*.15*(1-envpan());		float preout=LPF(s);		float out = preout+LPF(wet1*.2);//.........这里部分代码省略.........