/home/coin/SVN-release/CoinAll-1.1.0/cppad/cppad/local/identical.hpp

Go to the documentation of this file.

# ifndef CPPAD_IDENTICAL_INCLUDED
# define CPPAD_IDENTICAL_INCLUDED

/* --------------------------------------------------------------------------
CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell

CppAD is distributed under multiple licenses. This distribution is under
the terms of the 
                    Common Public License Version 1.0.

A copy of this license is included in the COPYING file of this distribution.
Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
-------------------------------------------------------------------------- */

/*
------------------------------------------------------------------------------
$begin IdenticalPar$$ $comment CppAD Developer Documentation$$
$spell
        inline
        const
        bool
$$

$index identical, parameter$$
$index parameter, identical$$

$section Check if a Value is Identically a Parameter$$

$head Syntax$$
$syntax%inline bool IdenticalPar(const %Type% &%x%)%$$

$head Description$$
If $italic x$$ is not of type $syntax%AD<%Base%>%$$,
this function returns true. 
Otherwise, it returns true if and only if 
the sequence of values
$syntax%
        %x%, %x%.value_, %x%.value_.value , ...
%$$
are all parameters.

$end 
------------------------------------------------------------------------------
$begin IdenticalZero$$ $comment CppAD Developer Documentation$$
$spell
        inline
        const
        bool
$$

$index identical, zero$$
$index zero, identical$$

$section Check if a Value is Identically Zero$$

$head Syntax$$
$syntax%inline bool IdenticalZero(const %Type% &%x%)%$$

$head Description$$
If $italic x$$ is not of type $syntax%AD<%Base%>%$$,
this function returns true if and only if
$italic x$$ is equal to zero.
Otherwise, it returns true if and only if it is equal to zero
and the sequence of values
$syntax%
        %x%, %x%.value_, %x%.value_.value , ...
%$$
are all parameters.

$end 
------------------------------------------------------------------------------


$begin IdenticalOne$$ $comment CppAD Developer Documentation$$
$spell
        inline
        const
        bool
$$

$index identical, one$$
$index one, identical$$

$section Check if a Value is Identically One$$

$head Syntax$$
$syntax%inline bool IdenticalOne(const %Type% &%x%)%$$

$head Description$$
If $italic x$$ is not of type $syntax%AD<%Base%>%$$,
this function returns true if and only if
$italic x$$ is equal to zero.
Otherwise, it returns true if and only if it is equal to zero
and the sequence of values
$syntax%
        %x%, %x%.value_, %x%.value_.value , ...
%$$
are all parameters.

$end 
------------------------------------------------------------------------------
$begin IdenticalEqualPar$$ $comment CppAD Developer Documentation$$
$spell
        inline
        const
        bool
$$

$index identical, equal$$
$index equal, identical$$

$section Check if a Value is Identically Equal Another$$

$head Syntax$$
$syntax%inline bool IdenticalEqualPar(const %Type% &%x%, const %Type%)%$$

$head Description$$
If $italic Type$$ is $syntax%AD<%Base%>%$$ for some $italic Base$$,
$italic x$$ is identically equal $italic y$$ if and only if
both $italic x$$ and $italic y$$ are parameters
and $syntax%%x%.value_%$$ is identically equal $syntax%%y%.value_%$$.
If $italic Type$$ is not $syntax%AD<%Base%>%$$ for some $italic Base$$,
$italic x$$ is identically equal $italic y$$ if and only if
$syntax%
        %x% == %y%
%$$

$end 
------------------------------------------------------------------------------
*/


namespace CppAD {
        // Parameter -------------------------------------------
        inline bool IdenticalPar(const float &x)
        {       return true; }
        inline bool IdenticalPar(const double &x)
        {       return true; }
        template <class Base>
        inline bool IdenticalPar(const AD<Base> &x)
        {       return Parameter(x) && IdenticalPar(x.value_); }

        // Zero -----------------------------------------------
        inline bool IdenticalZero(const float &x)
        {       return (x == 0.); }
        inline bool IdenticalZero(const double &x)
        {       return (x == 0.); }
        template <class Base>
        inline bool IdenticalZero(const AD<Base> &x)
        {       return Parameter(x) && IdenticalZero(x.value_); }

        // One -----------------------------------------------
        inline bool IdenticalOne(const float &x)
        {       return (x == 1.); }
        inline bool IdenticalOne(const double &x)
        {       return (x == 1.); }
        template <class Base>
        inline bool IdenticalOne(const AD<Base> &x)
        {       return Parameter(x) && IdenticalOne(x.value_); }

        // Equal -----------------------------------------------
        inline bool IdenticalEqualPar(const float &x, const float &y)
        {       return (x == y); }
        inline bool IdenticalEqualPar(const double &x, const double &y)
        {       return (x == y); }
        template <class Base>
        inline bool IdenticalEqualPar(const AD<Base> &x, const AD<Base> &y)
        {       bool parameter;
                parameter = ( Parameter(x) & Parameter(y) );
                return parameter  && IdenticalEqualPar(x.value_, y.value_); 
        }
}

# endif

---