/home/coin/SVN-release/CoinAll-1.1.0/cppad/cppad/check_simple_vector.hpp

Go to the documentation of this file.

# ifndef CPPAD_CHECK_SIMPLE_VECTOR_INCLUDED
# define CPPAD_CHECK_SIMPLE_VECTOR_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 CheckSimpleVector$$
$spell
        cppad.hpp
        CppAD
$$

$section Check Simple Vector Concept$$

$index simple, vector check$$
$index vector, simple check$$
$index check, simple vector$$
$index concept, check simple vector$$

$head Syntax$$
$code # include <cppad/check_simple_vector.hpp>$$
$pre
$$
$syntax%CheckSimpleVector<%Scalar%, %Vector%>()%$$


$head Purpose$$
The syntax 
$syntax%
        CheckSimpleVector<%Scalar%, %Vector%>()
%$$
preforms compile and run time checks that the type specified
by $italic Vector$$ satisfies all the requirements for 
a $xref/SimpleVector/$$ class with 
$xref/SimpleVector/Elements of Specified Type/elements of type Scalar/$$.
If a requirement is not satisfied,
a an error message makes it clear what condition is not satisfied.

$head Restrictions$$
The following extra assumption is made by $code CheckSimpleVector$$:
The type $italic Scalar$$ supports the syntax
$syntax%
        %Scalar%(%i%) == %Scalar%(%j%)%
%$$
where $italic i$$ and $italic j$$ are either $code 0$$ or $code 1$$.
In addition, this syntax returns the value true (false) if and only if
$italic i$$ equals $italic j$$.
($italic i$$ does not equal $italic j$$).


$head Include$$
The file $code cppad/check_simple_vector.hpp$$ is included by $code cppad/cppad.hpp$$
but it can also be included separately with out the rest
if the CppAD include files.

$head Example$$
$children%
        example/check_simple_vector.cpp
%$$
The file $xref/CheckSimpleVector.cpp/$$
contains an example and test of this function where $italic S$$
is the same as $italic T$$.
It returns true, if it succeeds an false otherwise.
The comments in this example suggest a way to change the example
so $italic S$$ is not the same as $italic T$$.

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

# include <cppad/local/cppad_assert.hpp>

namespace CppAD {

# ifdef NDEBUG
        template <class Scalar, class Vector>
        inline void CheckSimpleVector(void)
        { }
# else
        template <class S, class T>
        struct ok_if_S_same_as_T { };

        template <class T>
        struct ok_if_S_same_as_T<T,T> { typedef T ok; };

        template <class Scalar, class Vector>
        void CheckSimpleVector(void)
        {       Scalar zero = Scalar(0);
                Scalar one  = Scalar(1);

                // only need execute once per value Scalar, Vector pair
                static bool runOnce = false;
                if( runOnce )
                        return;
                runOnce = true;

                // value_type must be type of elements of Vector
                typedef typename Vector::value_type value_type;

                // check that elements of Vector have type Scalar
                typedef typename ok_if_S_same_as_T<Scalar, value_type>::ok ok;

                // check default constructor
                Vector d;

                // size member function
                CPPAD_ASSERT_KNOWN(
                        d.size() == 0,
                        "default construtor result does not have size zero"
                );

                // resize to same size as other vectors in test
                d.resize(1);

                // check sizing constructor
                Vector s(1);

                // check element assignment
                s[0] = one;
                CPPAD_ASSERT_KNOWN(
                        s[0] == one,
                        "element assignment failed"
                );

                // check copy constructor
                s[0] = zero;
                const Vector c(s);
                s[0] = one;
                CPPAD_ASSERT_KNOWN(
                        c[0] == zero,
                        "copy constructor is shallow"
                );

                // vector assignment operator
                s = c;
                s[0] = one;
                CPPAD_ASSERT_KNOWN(
                        c[0] == zero,
                        "assignment operator is shallow"
                );

                // element access, right side const
                // element assignment, left side not const
                d[0] = s[0];
        }
# endif

} // end namespace CppAD

# endif

---