Example Code

TList example code

Inserting items into a list

There is no easy way to initialise a list so we'll just set it from the strings array.

// append adds items on to the end of a list for (unsigned int i1 = 0; i1 < sizeof(strings) /sizeof(strings[0]); i1++) slist.append(strings[i1]); // add item to start of list slist.prepend("dove"); // find pointer to "eagle", add "hawk" before it, and then add sparrow // after "hawk" for (p = slist.head(); p != 0; p = next(p)) if (slist(p) == "eagle") { p = slist.insert_before(p,"hawk"); p = slist.insert_after(p,"sparrow"); }

Iteration over a list

A dummy pointer of type \Ref{EST_Litem} is used to iterate through a list. This acts somewhat like the index in an array in that it is used to access an item, in the list but does not contain a value itself. Iteration is usually done in a for loop. Initialisation involves setting the pointer to the head() function. Increments are done by the next() function. At the end of the list, the pointer will be set to null, and this can be used to check for the end. Items in the list are accessed by passing the pointer is as the argument to the function operator(), as in the following example.

cout << "[ List Accessed by LItem\n"; // print out contents of array. for (p = slist.head(); p != 0; p = next(p)) cout << " " << slist(p) << "\n"; cout << "]\n"; // items can also be accessed by their position in the list by using the // nth() function. The length() function returns the number of items // in a list. cout << "\n[ List Accessed by integer index\n"; for (int i2 = 0; i2 < slist.length(); ++i2) cout << " " << slist.nth(i2) << "\n"; cout << "]\n";

Accessing elements of a list

The normal way to access an item is to use the \Ref{EST_Litem} in conjunction with the () operator. Other functions also exist, eg. first(), last() and nth(). Const and non-const version of each access function exist, allowing both reading and writing.

// Capital;ise all 'e's in all strings for (p = slist.head(); p != 0; p = next(p)) slist(p).gsub("e", "E"); // print out last item in list p = slist.tail(); cout << "Last item: " << slist(p) << endl; // but a more direct method is cout << "Last item: " << slist.last() << endl; // likewise with the head of the list: cout << "First item: " << slist.first() << endl; // print out the 4th item: cout << "4th item: " << slist.nth(4) << endl; // All these can be used for overwriting existing members in the list. // To add new members use append(), prepend(), insert_before() or // insert_after() as shown in \Ref{Addition} slist.first() = "Swallow"; slist.last() = "TurkEy"; slist.nth(2) = "SEagull";

Removing items from a list.

Removing items from lists is done by having the EST_Litem point to a particular item, and then passing this pointer to the remove function. This can be tricky as this leaves the EST_Litem pointer pointing to a non-existant item. To get round this, the remove() function returns a pointer to the previous item in the list.

In the following example, the item "eagle" is removed and a pointer to the previous item is returned. The for loop then points this to the next item in the loop, giving the appearance of seamless iteration.

for (p = slist.head(); p != 0; p = next(p)) if (slist(p) == "EaglE") p = slist.remove(p);

Reverse the list:

Sorting a list

A number of sort routines for lists are defined. The most useful are probably sort (a simple bubble sort, quick for small lists) and qsort (quick-sort, faster for long lists). If the default collation order is not what you want you can pass a comparison operator to the sort routine.

Sort into alphbetical order */ //@{ code sort(slist); //@} code cout << "\n[ Sorted\n"; for(p=slist.head(); p ; p=next(p)) cout << " " << slist(p) << "\n"; cout << "]\n"; /** Sort by second character

qsort(slist,&second_char_gt );
EST_TMatrix<float> m(10, 5);


Access to values in the matrix is via the a() member function. This returns a reference, so you can assign values to matrix cells. As is usually the case in C++, column and row indecies start from 0.

for(int i=0; i<m.num_rows(); i++) for(int j=0; j<m.num_columns(); j++) m.a(i,j) = i+j/100.0; // Just something easy to recognise


A simple output method is supplied, it just outputs a row at a time, tab separated to a named file. A filename of "-" means standard output.

cout << "Initial Matrix\n"; m.save("-"); cout << "\n";


Resize to 20 rows by 10 columns This fills the new area with def_val, which is 0.0 for floats.


Copying Data to/from a buffer

Whole rows or columns can be extracted into a buffer, or can be filled with data from a buffer. The buffer must be pre-declared, and it is up to you to ensure it is big enough.

Data can be extracted into a buffer in one operation

float *buf = new float[max(m.num_rows(),m.num_columns())]; m.copy_row(5, buf);

And data can be inserted in a similar manner.


Sub-Matrices and Sub-Vectors

A sub-vector or sub-matrix is a window onto a matrix. If you obtain a sub vector representing a row, for instance, you can treat it a normal vector, any changes you make affecting the underlying matrix.

Here is how we can create new variables which refer to the 11th row, 4th column and a 5X3 rectnagle with top left hand corner (8,2). (since the first column or row is numbered 0, the numbers may be one less than you expect).

EST_TVector<float> row; EST_TVector<float> column; EST_TMatrix<float> rectangle; m.row(row, 10); m.column(column, 3); m.sub_matrix(rectangle, 8, 5, 2, 3);

If we update the sub-vector, the main matrix changes.

// 10th row becomes squares of the index for(int i2=0; i2<row.n(); i2++) row[i2] = i2*i2; // 3rd column becomes cubes of the index for(int i3=0; i3<column.n(); i3++) column[i3] = i3*i3*i3; // Central rectangle filled with -1 for(int i4=0; i4<rectangle.num_rows(); i4++) for(int j4=0; j4<rectangle.num_columns(); j4++) rectangle.a(i4, j4) = -1;

We can even extract rows and columns from a sub-matrix as follows.

EST_TVector<float> rrow; EST_TVector<float> rcolumn; // 3rd row of sub-matrix, part of 12th row of main matrix rectangle.row(rrow, 2); // 2nd column of sub-matrix, part of 8th column of main matrix rectangle.column(rcolumn, 1);

Template Instantiation.

Some C++ compilers requre explicit guidance about which types of Matrix will be used. For many common types, including float, this guidance is included in the speech tools libraries. However, if you need to use matrecies of your own types, you will need to include declarations similar to the following.

Declare_TMatrix(MyType) #if defined(INSTANTIATE_TEMPLATES) #include "../base_class/EST_TMatrix.cc" Instantiate_TMatrix(MyType) #endif

By using this form of declaration, you should ensure that your code will compile anywhere where the speech tools libraries will.