Prev

Next

Index-> contents reference index search external

Up-> CppAD utility SimpleVector

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

@(@\newcommand{\W}[1]{ \; #1 \; } \newcommand{\R}[1]{ {\rm #1} } \newcommand{\B}[1]{ {\bf #1} } \newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} } \newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} } \newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} } \newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }@)@This is cppad-20221105 documentation. Here is a link to its current documentation . C++ Concept: 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 = size_t( 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 simple_vector.cpp contains an example and test of a Simple template class. (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