Prev

Next

Index-> contents reference index search external

Up-> CppAD library SimpleVector

CppAD-> Install Introduction AD ADFun multi_thread library cppad_ipopt_nlp Example preprocessor Appendix

library-> ErrorHandler NearEqual speed_test SpeedTest time_test NumericType CheckNumericType SimpleVector CheckSimpleVector nan pow_int Poly LuDetAndSolve RombergOne RombergMul Runge45 Rosen34 OdeErrControl OdeGear OdeGearControl BenderQuad opt_val_hes LuRatio CppAD_vector thread_alloc memory_leak

SimpleVector-> SimpleVector.cpp

Headings-> Template Class Requirements Elements of Specified Type Default Constructor Sizing Constructor Copy Constructor Element Constructor and Destructor Assignment Size Resize Value Type Element Access ---..Using Value ---..Assignment Example Exercise

Definition of a Simple Vector
Template Class Requirements
A simple vector template class SimpleVector , is any template class that satisfies the requirements below. The following is a list of some simple vector template classes:

Name	Documentation
std::vector	Section 16.3 of The C++ Programming Language
std::valarray	Section 22.4 of The C++ Programming Language
CppAD::vector	The CppAD::vector Template Class

Elements of Specified Type
A simple vector class with elements of type Scalar , is any class that satisfies the requirements for a class of the form
     SimpleVector<Scalar>
The routine CheckSimpleVector can be used to check that a class is a simple vector class with a specified element type.

Default Constructor
The syntax
     SimpleVector<Scalar> x;
creates an empty vector x ( x.size() is zero) that can later contain elements of the specified type (see resize below).

Sizing Constructor
If n has type size_t,
     SimpleVector<Scalar> x(n)
creates a vector x with n elements each of the specified type.

Copy Constructor
If x is a SimpleVector<Scalar> object,
     SimpleVector<Scalar> y(x)
creates a vector with the same type and number of elements as x . The Scalar assignment operator ( = ) is used to set each element of y equal to the corresponding element of x . This is a `deep copy' in that the values of the elements of x and y can be set independently after the copy. The argument x is passed by reference and may be const.

Element Constructor and Destructor
The default constructor for type Scalar is called for every element in a vector when the vector element is created. The Scalar destructor is called when it is removed from the vector (this includes when the vector is destroyed).

Assignment
If x and y are SimpleVector<Scalar> objects,
     y = x
uses the Scalar assignment operator ( = ) to set each element of y equal to the corresponding element of x . This is a `deep assignment' in that the values of the elements of x and y can be set independently after the assignment. The vectors x and y must have the same number of elements. The argument x is passed by reference and may be const.

The type returned by this assignment is unspecified; for example, it might be void in which case the syntax
     z = y = x
would not be valid.

Size
If x is a SimpleVector<Scalar> object and n has type size_t,
     n = x.size()
sets n to the number of elements in the vector x. The object x may be const.

Resize
If x is a SimpleVector<Scalar> object and n has type size_t,
     x.resize(n)
changes the number of elements contained in the vector x to be n . The value of the elements of x are not specified after this operation; i.e., any values previously stored in x are lost. (The object x can not be const.)

Value Type
If Vector is any simple vector class, the syntax
     Vector::value_type
is the type of the elements corresponding to the vector class; i.e.,
     SimpleVector<Scalar>::value_type
is equal to Scalar .

Element Access
If x is a SimpleVector<Scalar> object and i has type size_t,
     x[i]
returns an object of an unspecified type, referred to here as elementType .

Using Value
If elementType is not the same as Scalar, the conversion operator
     static_cast<Scalar>(x[i])
is used implicitly when x[i] is used in an expression with values of type Scalar . For this type of usage, the object x may be const.

Assignment
If y is an object of type Scalar,
     x[i] = y
assigns the i-th element of x to have value y. For this type of usage, the object x can not be const. The type returned by this assignment is unspecified; for example, it might be void in which case the syntax
     z = x[i] = y
would not be valid.

Example
The file SimpleVector.cpp contains an example and test of a Simple template class. It returns true if it succeeds and false otherwise. (It is easy to modify to test additional simple vector template classes.)

Exercise

1. If Vector is a simple vector template class, the following code may not be valid:
     Vector<double> x(2);
     x[2] = 1.;
Create and run a program that executes the code segment above where Vector is each of the following cases: std::vector, CppAD::vector. Do this both where the compiler option -DNDEBUG is and is not present on the compilation command line.
2. If Vector is a simple vector template class, the following code may not be valid:
     Vector<int> x(2);
     Vector<int> y(1);
     x[0] = 0;
     x[1] = 1;
     y    = x;
Create and run a program that executes the code segment above where Vector is each of the following cases: std::valarray, CppAD::vector. Do this both where the compiler option -DNDEBUG is and is not present on the compilation command line.

---

Input File: omh/simple_vector.omh