The CheckSimpleVector Function: Example and Test
Keywords: the checksimplevector function: example test check Simplevector

| Prev | Next |  |  |  |  |  | check_simple_vector.cpp | Headings

The CheckSimpleVector Function: Example and Test
`

    # include <cppad/utility/vector.hpp>
    # include <cppad/utility/check_simple_vector.hpp>
    # include <iostream>

    // Chosing a value between 1 and 9 selects a simple vector properity to be
    // omitted and result in an error message being generated
    # define CppADMyVectorOmit 0

    // -------------------------------------------------------------------------

    // example class used for non-constant elements (different from Scalar)
    template <class Scalar>
    class MyElement {
    private:
    	Scalar *element;
    public:
    	// element constructor
    	MyElement(Scalar *e)
    	{	element = e; }
    	// an example element assignment that returns void
    	void operator = (const Scalar &s)
    	{	*element = s; }
    	// conversion to Scalar
    	operator Scalar() const
    	{	return *element; }
    };

    // example simple vector class
    template <class Scalar>
    class MyVector {
    private:
    	size_t length;
    	Scalar * data;
    public:

    # if CppADMyVectorOmit != 1
    	// type of the elements in the vector
    	typedef Scalar value_type;
    # endif
    # if CppADMyVectorOmit != 2
    	// default constructor
    	inline MyVector(void) : length(0) , data(0)
    	{ }
    # endif
    # if CppADMyVectorOmit != 3
    	// constructor with a specified size
    	inline MyVector(size_t n) : length(n)
    	{	if( length == 0 )
    			data = 0;
    		else	data = new Scalar[length];
    	}
    # endif
    # if CppADMyVectorOmit != 4
    	// copy constructor
    	inline MyVector(const MyVector &x) : length(x.length)
    	{	size_t i;
    		if( length == 0 )
    			data = 0;
    		else	data = new Scalar[length];

    		for(i = 0; i < length; i++)
    			data[i] = x.data[i];
    	}
    # endif
    # if CppADMyVectorOmit != 4
    # if CppADMyVectorOmit != 7
    	// destructor (it is not safe to delete the pointer in cases 4 and 7)
    	~MyVector(void)
    	{	delete [] data; }
    # endif
    # endif
    # if CppADMyVectorOmit != 5
    	// size function
    	inline size_t size(void) const
    	{	return length; }
    # endif
    # if CppADMyVectorOmit != 6
    	// resize function
    	inline void resize(size_t n)
    	{	if( length > 0 )
    			delete [] data;
    		length = n;
    		if( length > 0 )
    			data = new Scalar[length];
    		else	data = 0;
    	}
    # endif
    # if CppADMyVectorOmit != 7
    	// assignment operator
    	inline MyVector & operator=(const MyVector &x)
    	{	size_t i;
    		for(i = 0; i < length; i++)
    			data[i] = x.data[i];
    		return *this;
    	}
    # endif
    # if CppADMyVectorOmit != 8
    	// non-constant element access
    	MyElement<Scalar> operator[](size_t i)
    	{	return data + i; }
    # endif
    # if CppADMyVectorOmit != 9
    	// constant element access
    	const Scalar & operator[](size_t i) const
    	{	return data[i]; }
    # endif
    };
    // -------------------------------------------------------------------------

    /*
    Compute r = a * v, where a is a scalar with same type as the elements of
    the Simple Vector v. This routine uses the CheckSimpleVector function to ensure that
    the types agree.
    */
    namespace { // Empty namespace
    	template <class Scalar, class Vector>
    	Vector Sscal(const Scalar &a, const Vector &v)
    	{
    		// invoke CheckSimpleVector function
    		CppAD::CheckSimpleVector<Scalar, Vector>();

    		size_t n = v.size();
    		Vector r(n);

    		size_t i;
    		for(i = 0; i < n; i++)
    			r[i] = a * v[i];

    		return r;
    	}
    }

    bool CheckSimpleVector(void)
    {	bool ok  = true;
    	using CppAD::vector;

    	// --------------------------------------------------------
    	// If you change double to float in the next statement,
    	// CheckSimpleVector will generate an error message at compile time.
    	double a = 3.;
    	// --------------------------------------------------------

    	size_t n = 2;
    	MyVector<double> v(n);
    	v[0]     = 1.;
    	v[1]     = 2.;
    	MyVector<double> r = Sscal(a, v);
    	ok      &= (r[0] == 3.);
    	ok      &= (r[1] == 6.);

    	return ok;
    }

`

Input File: example/check_simple_vector.cpp