In file ../include/EST_TVector.h:

## template<class T> class EST_TVector

## Inheritance:

### Public Fields

  T* | p_memory Pointer to the start of the vector.
  unsigned int | p_num_columns Visible shape
  unsigned int | p_offset How to access the memory
  static const T* | def_val default value, used for filling matrix after resizing
  static T* | error_return A reference to this variable is returned if you try and access beyond the bounds of the matrix.

### Public Methods

  INLINE unsigned int | vcell_pos (unsigned int c, unsigned int cs) const The memory access rule, in one place for easy reference
  INLINE const T& | fast_a_v (int c) const quick method for returning \(x[n]\)
  void | set_values (const T* data, int step, int start_c, int num_c) Get and set values from array
  void | copy (const EST_TVector<T> &a) private copy function, called from all other copying functions
  void | copy_data (const EST_TVector<T> &a) just copy data, no resizing, no size check
  void | just_resize (int new_cols, T** old_vals) resize the memory and reset the bounds, but don't set values
  void | default_vals () sets data and length to default values (0 in both cases)
  | EST_TVector () default constructor
  | EST_TVector (const EST_TVector<T> &v) copy constructor
  | EST_TVector (int n) "size" constructor - make vector of size n
  | EST_TVector (int, T* memory, int offset=0, int free_when_destroyed=0) construct from memory supplied by caller
  | ~EST_TVector () destructor
  void | resize (int n, int set=1) resize vector.
  const T* | memory () const For when you absolutely have to have access to the memory
  | access
  int | num_columns () const number of items in vector
  int | length () const number of items in vector
  int | n () const number of items in vector
  INLINE const T& | a_no_check (int n) const read-only const access operator: without bounds checking
  INLINE T& | a_no_check (int n) read/write non-const access operator: without bounds checking
  INLINE const T& | a_no_check_1 (int n) const read-only const access operator: without bounds checking
  INLINE T& | a_no_check_1 (int n) read/write non-const access operator: without bounds checking
  const T& | a_check (int n) const read-only const access operator: with bounds checking
  T& | a_check (int n) read/write non-const access operator: with bounds checking
  const T& | operator () (int n) const read-only const access operator: return reference to nth member
  T& | operator [] (int n) read/write non const access operator: return reference to nth member
  EST_TVector& | operator= (const EST_TVector &s) assignment operator
  void | fill (const T &v) Fill entire array will value <parameter>v</parameter>
  void | empty () Fill vector with default value
  EST_write_status | save (const EST_String &filename) Save vector to file <parameter>filename</parameter>
  int | operator == (const EST_TVector &v) const is true if vectors are equal size and all elements are equal
  int | operator != (const EST_TVector &v) const is true if vectors are not equal size or a single elements isn't equal
  void | copy_section (T* dest, int offset=0, int num=-1) const Copy data in and out.
  void | sub_vector (EST_TVector<T> &sv, int start_c=0, int len=-1) Create a sub vector
  void | integrity () const

## Documentation

`T* p_memory`
  Pointer to the start of the vector. The start of allocated memory is p_memory-p_offset.

`unsigned int p_num_columns`
  Visible shape

`unsigned int p_offset`
  How to access the memory

`INLINE unsigned int vcell_pos(unsigned int c, unsigned int cs) const`
  The memory access rule, in one place for easy reference

`INLINE const T& fast_a_v(int c) const`
  quick method for returning \(x[n]\)

`void set_values(const T* data, int step, int start_c, int num_c)`
  Get and set values from array

`void copy(const EST_TVector<T> &a)`
  private copy function, called from all other copying functions

`void copy_data(const EST_TVector<T> &a)`
  just copy data, no resizing, no size check

`void just_resize(int new_cols, T** old_vals)`
  resize the memory and reset the bounds, but don't set values

`void default_vals()`
  sets data and length to default values (0 in both cases)

`EST_TVector()`
  default constructor

`EST_TVector(const EST_TVector<T> &v)`
  copy constructor

`EST_TVector(int n)`
  "size" constructor - make vector of size n

`EST_TVector(int, T* memory, int offset=0, int free_when_destroyed=0)`
  construct from memory supplied by caller

`~EST_TVector()`
  destructor

`static const T* def_val`
  default value, used for filling matrix after resizing

`static T* error_return`
  A reference to this variable is returned if you try and access beyond the bounds of the matrix. The vaue is undefined, but you can check for the reference you get having the same address as this variable to test for an error.

`void resize(int n, int set=1)`
  resize vector. If <expr>set=1</expr>, then the current values in the vector are preserved up to the new length <parameter>n</parameter>. If the new length exceeds the old length, the rest of the vector is filled with the <variable>def_val</variable>

`const T* memory() const`
  For when you absolutely have to have access to the memory

`access`
  Basic access methods for vectors.

  `int num_columns() const`
    number of items in vector

  `int length() const`
    number of items in vector

  `int n() const`
    number of items in vector

  `INLINE const T& a_no_check(int n) const`
    read-only const access operator: without bounds checking

  `INLINE T& a_no_check(int n)`
    read/write non-const access operator: without bounds checking

  `INLINE const T& a_no_check_1(int n) const`
    read-only const access operator: without bounds checking

  `INLINE T& a_no_check_1(int n)`
    read/write non-const access operator: without bounds checking

  `const T& a_check(int n) const`
    read-only const access operator: with bounds checking

  `T& a_check(int n)`
    read/write non-const access operator: with bounds checking

  `const T& operator () (int n) const`
    read-only const access operator: return reference to nth member

  `T& operator [] (int n)`
    read/write non const access operator: return reference to nth member

`EST_TVector& operator=(const EST_TVector &s)`
  assignment operator

`void fill(const T &v)`
  Fill entire array will value <parameter>v</parameter>

`void empty()`
  Fill vector with default value

`EST_write_status save(const EST_String &filename)`
  Save vector to file <parameter>filename</parameter>

`int operator == (const EST_TVector &v) const`
  is true if vectors are equal size and all elements are equal

`int operator != (const EST_TVector &v) const`
  is true if vectors are not equal size or a single elements isn't equal

`void copy_section(T* dest, int offset=0, int num=-1) const`
  Copy data in and out. Subclassed by SimpleVector for speed.

`void sub_vector(EST_TVector<T> &sv, int start_c=0, int len=-1)`
  Create a sub vector

`void integrity() const`

Direct child classes:
  EST_TSimpleVector
  EST_TMatrix

Friends:
  ostream& operator << (ostream &st, const EST_TVector<T> &m)
  class EST_TMatrix<T>

Alphabetic index HTML hierarchy of classes or Java

This page is part of the Edinburgh Speech Tools Library documentation
Copyright University of Edinburgh 1997
Contact: speech_tools@cstr.ed.ac.uk