Heed::DynLinArr< T > Class Template Reference

#include <AbsArr.h>

Inheritance diagram for Heed::DynLinArr< T >:

Public Member Functions
	DynLinArr (void)
	DynLinArr (long fqel)
	DynLinArr (long fqel, const T &val)
	DynLinArr (long fqel, const T *ar, ArgInterp_Arr)
DynLinArr< T > &	operator= (const DynLinArr< T > &f)
template<class D >
DynLinArr< T > &	operator= (const DynLinArr< D > &f)
void	pass (long fqel, T *fel)
	DynLinArr (const DynLinArr< T > &f)
	DynLinArr (const DynLinArr< T > &f, Pilfer)
	DynLinArr (const DynArr< T > &f)
	DynLinArr (const DynArr< T > &f, int n_of_dim, long roc_number)
DynLinArr &	assignAll (const T &f)
template<class X >
DynLinArr< T > &	assignAll1 (const X &f)
T &	operator[] (long n)
const T &	operator[] (long n) const
T &	acu (long n)
const T &	acu (long n) const
T &	last_el (void)
const T &	last_el (void) const
long	get_qel (void) const
void	put_qel (long fqel)
void	put_qel (long fqel, const T *val, ArgInterp_SingleAdr t)
void	put_qel (long fqel, const T &val)
void	increment (const T *val=NULL)
void	increment (const T &val)
void	clear (void)
void	pilfer (const DynLinArr< T > &f)
void	check (void) const
DynArr< T >	top (void)
void	sort (long q_to_sort=0)
void	sort (DynLinArr< long > &sort_ind, long q_to_sort=0) const
void	sort_select_increasing (DynLinArr< long > &sort_ind, long q_to_sort=0) const
void	sort_select_decreasing (DynLinArr< long > &sort_ind, long q_to_sort=0) const
virtual DynLinArr *	copy () const
virtual	~DynLinArr ()
Public Member Functions inherited from Heed::RegPassivePtr
	RegPassivePtr (void)
	RegPassivePtr (char fs_ban_del, char fs_ban_sub, char fs_ban_cop=0)
	RegPassivePtr (const RegPassivePtr &f)
RegPassivePtr &	operator= (const RegPassivePtr &f)
CountPP_ns::CountPassivePtr *	book (void) const
void	clear_pointers (void) const
virtual RegPassivePtr *	copy () const
virtual	~RegPassivePtr ()
virtual void	print (std::ostream &file, int l=1) const
void	set_s_ban_del (char fs_ban_del)
char	get_s_ban_del (void) const
void	set_s_ban_sub (char fs_ban_sub)
char	get_s_ban_sub (void) const
void	set_s_ban_cop (char fs_ban_cop)
char	get_s_ban_cop (void) const
void	set_s_allow_del_at_zero_count (char fs_allow_del_at_zero_count)
char	get_s_allow_del_at_zero_count (void) const
long	get_total_number_of_references (void) const

Friends
template<class P >
void	apply1 (DynLinArr< P > &ar, void(*fun)(P &f))
template<class P , class X >
void	apply2 (DynLinArr< P > &ar, void(*fun1)(P &f, void(*fun21)(X &f)), void(*fun2)(X &f))

Additional Inherited Members
Static Public Member Functions inherited from Heed::RegPassivePtr
static void	set_s_ban_del_ignore (char fs_ban_del_ignore)
static char	get_s_ban_del_ignore (void)
static void	set_s_print_adr_cpp (char fs_print_adr_cpp)
static char	get_s_print_adr_cpp (void)

Detailed Description

template<class T>
class Heed::DynLinArr< T >

Definition at line 102 of file AbsArr.h.

Constructor & Destructor Documentation

DynLinArr() [1/8]

template<class T >

Heed::DynLinArr< T >::DynLinArr ( void  )

inline

Definition at line 105 of file AbsArr.h.

: qel(0), el(NULL) { ; }

DynLinArr() [2/8]

template<class T >

Heed::DynLinArr< T >::DynLinArr ( long  fqel )

inlineexplicit

Definition at line 106 of file AbsArr.h.

                                : qel(fqel), el(NULL) {
    if (qel > max_qel_DynLinArr) {
      mcerr << "ERROR in DynLinArr(long fqel):\n";
      mcerr << "qel > max_qel_DynLinArr:\n";
      Iprint2n(mcout, qel, max_qel_DynLinArr);
      mcerr << "Type of T is (in internal notations) " << typeid(T).name()
            << '\n';
      spexit(mcerr);
    }
    if (qel < 0) {
      mcerr << "ERROR in DynLinArr(long fqel):\n";
      mcerr << "qel < 0:\n";
      Iprintn(mcout, qel);
      mcerr << "Type of T is (in internal notations) " << typeid(T).name()
            << '\n';
      spexit(mcerr);
    }
    el = (fqel > 0) ? (new T[fqel]) : (T*)NULL;
  }

DynLinArr() [3/8]

template<class T >

Heed::DynLinArr< T >::DynLinArr ( long  fqel, const T &  val  )

inline

Definition at line 126 of file AbsArr.h.

                                     : qel(fqel), el(NULL) {
    if (qel > max_qel_DynLinArr) {
      mcerr << "ERROR in DynLinArr(long fqel, const T& val):\n";
      mcerr << "qel > max_qel_DynLinArr:\n";
      Iprint2n(mcout, qel, max_qel_DynLinArr);
      mcerr << "Type of T is (in internal notations) " << typeid(T).name()
            << '\n';
      spexit(mcerr);
    }
    if (qel < 0) {
      mcerr << "ERROR in DynLinArr(long fqel, const T& val):\n";
      mcerr << "qel < 0:\n";
      Iprintn(mcout, qel);
      mcerr << "Type of T is (in internal notations) " << typeid(T).name()
            << '\n';
      spexit(mcerr);
    }
    el = (fqel > 0) ? (new T[fqel]) : (T*)NULL;
    assignAll(val);
  }

DynLinArr() [4/8]

template<class T >

Heed::DynLinArr< T >::DynLinArr ( long  fqel, const T *  ar, ArgInterp_Arr    )

inline

Definition at line 146 of file AbsArr.h.

                                                     : qel(fqel), el(NULL) {
    if (qel > max_qel_DynLinArr) {
      mcerr << "ERROR in DynLinArr(long fqel, const T* ar, ArgInterp_Arr):\n";
      mcerr << "qel > max_qel_DynLinArr:\n";
      Iprint2n(mcout, qel, max_qel_DynLinArr);
      mcerr << "Type of T is (in internal notations) " << typeid(T).name()
            << '\n';
      spexit(mcerr);
    }
    if (qel < 0) {
      mcerr << "ERROR in DynLinArr(long fqel, const T* ar, ArgInterp_Arr):\n";
      mcerr << "qel < 0:\n";
      Iprintn(mcout, qel);
      mcerr << "Type of T is (in internal notations) " << typeid(T).name()
            << '\n';
      spexit(mcerr);
    }
    el = (fqel > 0) ? (new T[fqel]) : (T*)NULL;
    for (long n = 0; n < qel; n++) el[n] = ar[n];
  }

DynLinArr() [5/8]

template<class T >

Heed::DynLinArr< T >::DynLinArr ( const DynLinArr< T > &  f )

inline

Definition at line 516 of file AbsArr.h.

    : RegPassivePtr(),
      qel(0),
      el(NULL) {
#ifdef DEBUG_DYNLINARR
  mcout << "DynLinArr(const DynLinArr<T>& f) is working\n";
#endif
  *this = f;
}

DynLinArr() [6/8]

template<class T >

Heed::DynLinArr< T >::DynLinArr ( const DynLinArr< T > &  f, Pilfer    )

inline

Definition at line 192 of file AbsArr.h.

                                           : qel(f.qel), el(f.el) {
#ifdef DEBUG_DYNLINARR
    mcout << "DynLinArr( DynLinArr<T>& f, Pilfer) is working\n";
#endif
    f.qel = 0;
    f.el = 0;
  }

DynLinArr() [7/8]

template<class T >

Heed::DynLinArr< T >::DynLinArr

(

const DynArr< T > &

f

)

Definition at line 2537 of file AbsArr.h.

                                          {
  // mcout<<"template<class T> DynLinArr<T>::DynLinArr(const DynArr<T>& f):\n";
  f.check();
  long qdim = f.get_qdim();
  if (qdim != 1) {
    mcerr << "ERROR in DynLinArr<T>::DynLinArr(const DynArr<T>& f):\n"
          << "f.get_qdim() != 1, f.get_qdim()=" << f.get_qdim() << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
  }
  const DynLinArr<long>& qelem = f.get_qel();
  qel = qelem[0];
  // mcout<<"qel="<<qel<<'\n';
  if (qel > 0) {
    el = new T[qel];
    for (long n = 0; n < qel; n++) el[n] = f.ac(n);
  } else
    el = NULL;
}

DynLinArr() [8/8]

template<class T >

Heed::DynLinArr< T >::DynLinArr	(	const DynArr< T > &	f,
		int	n_of_dim,
		long	roc_number
	)

Definition at line 2559 of file AbsArr.h.

{
  f.check();
  long qdim = f.get_qdim();
  if (qdim != 2) {
    mcerr << "ERROR in DynLinArr<T>::DynLinArr(const DynArr<T>& f, int "
             "n_of_dim,long roc_number):\n"
          << "f.get_qdim() != 2, f.get_qdim()=" << f.get_qdim() << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
  }
  const DynLinArr<long>& qelem = f.get_qel();
  if (n_of_dim == 0) {
    qel = qelem[1];
  } else {
    qel = qelem[0];
  }
  // mcout<<"qel="<<qel<<'\n';
  if (qel > 0) {
    el = new T[qel];
    long n;
    if (n_of_dim == 0) {
      for (n = 0; n < qel; n++) el[n] = f.ac(roc_number, n);
    } else {
      for (n = 0; n < qel; n++) el[n] = f.ac(n, roc_number);
    }
  }
}

~DynLinArr()

template<class T >

virtual Heed::DynLinArr< T >::~DynLinArr ( )

inlinevirtual

Definition at line 406 of file AbsArr.h.

                       {
    check();
    if (el) delete[] el;
  }

Member Function Documentation

acu() [1/2]

template<class T >

T & Heed::DynLinArr< T >::acu ( long  n )

inline

Definition at line 247 of file AbsArr.h.

                        {
    // unchecked access
    return el[n];
  }

Referenced by Heed::DynArr< T >::ac(), Heed::DynArr< T >::acp(), Heed::DynArr< T >::acu(), Heed::apeq_mant(), Heed::change_sign(), Heed::find_next_comb(), Heed::DynArr< T >::IndexingProvider< D >::operator D&(), Heed::operator*(), Heed::operator*=(), Heed::operator+(), Heed::operator+=(), Heed::operator-(), Heed::operator-=(), Heed::operator/(), Heed::operator/=(), Heed::operator==(), Heed::DynArr< T >::IndexingProvider< D >::operator[](), Heed::DynArr< T >::operator[](), and Heed::DynLinArr< T >::sort().

acu() [2/2]

template<class T >

const T & Heed::DynLinArr< T >::acu ( long  n ) const

inline

Definition at line 251 of file AbsArr.h.

                                    {
    // unchecked access
    return el[n];
  }

assignAll()

template<class T >

DynLinArr & Heed::DynLinArr< T >::assignAll ( const T &  f )

inline

Definition at line 207 of file AbsArr.h.

                                   {
    check();
    for (long n = 0; n < qel; n++) el[n] = f;
    return *this;
  }

Referenced by Heed::DynArr< T >::assignAll(), Heed::DynLinArr< T >::assignAll1(), and Heed::DynLinArr< T >::DynLinArr().

assignAll1()

template<class T >

template<class X >

DynLinArr< T > & Heed::DynLinArr< T >::assignAll1 ( const X &  f )

inline

Definition at line 213 of file AbsArr.h.

                                       {
    // assumes that element is object
    // which also accepts assignAll, which is called for it.
    check();
    for (long n = 0; n < qel; n++) el[n].assignAll(f);
    return *this;
  }

check()

template<class T >

void Heed::DynLinArr< T >::check

(

void

)

const

Definition at line 433 of file AbsArr.h.

                                   {
  if (qel < 0) {
    mcerr << "ERROR in template<class T> void DynLinArr<T>::check(void):\n";
    mcerr << "qel < 0, qel=" << qel << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
  }
  if (qel == 0 && el != NULL) {
    mcerr << "ERROR in template<class T> void DynLinArr<T>::check(void):\n";
    mcerr << "qel == 0 && el != NULL: el=" << el << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
  }
  if (qel > 0) {
    if (el == NULL) {
      mcerr << "ERROR in template<class T> void DynLinArr<T>::check(void):\n";
      mcerr << "qel > 0 && el == NULL: qel=" << qel << '\n';
      mcerr << "Type of T is (in internal notations) " << typeid(T).name()
            << '\n';
      spexit(mcerr);
    }
    if (qel > max_qel_DynLinArr) {
      mcerr << "ERROR in template<class T> void DynLinArr<T>::check(void):\n";
      mcerr << "qel > max_qel_DynLinArr: \n";
      Iprint2n(mcout, qel, max_qel_DynLinArr);
      mcerr << "Type of T is (in internal notations) " << typeid(T).name()
            << '\n';
      spexit(mcerr);
    }
  }
}

Referenced by Heed::DynLinArr< T >::assignAll(), Heed::DynLinArr< T >::assignAll1(), Heed::DynArr< T >::check(), Heed::DynLinArr< T >::increment(), Heed::operator<<(), Heed::DynLinArr< T >::operator=(), Heed::print_adr_DynLinArr(), Heed::print_DynArr_double(), Heed::print_DynArr_float(), Heed::print_DynArr_int_w(), Heed::print_DynLinArr(), Heed::print_DynLinArr_double(), Heed::print_DynLinArr_double2(), Heed::print_DynLinArr_float(), Heed::print_DynLinArr_int(), Heed::print_DynLinArr_int_double(), Heed::print_DynLinArr_int_double3(), Heed::print_DynLinArr_long(), and Heed::DynLinArr< T >::~DynLinArr().

clear()

template<class T >

void Heed::DynLinArr< T >::clear ( void  )

inline

Definition at line 313 of file AbsArr.h.

{ put_qel(0); }  // Not only clears the content,

Referenced by Heed::DynArr< T >::clear(), Heed::operator>>(), Heed::DynLinArr< T >::pass(), Heed::DynArr< T >::pilfer(), Heed::DynLinArr< T >::sort(), Heed::DynLinArr< T >::sort_select_decreasing(), and Heed::DynLinArr< T >::sort_select_increasing().

copy()

template<class T >

DynLinArr< T > * Heed::DynLinArr< T >::copy

virtual

Reimplemented from Heed::RegPassivePtr.

Definition at line 417 of file AbsArr.h.

                                       {
  return new DynLinArr<T>(*this);  
}

get_qel()

template<class T >

long Heed::DynLinArr< T >::get_qel ( void  ) const

inline

Definition at line 283 of file AbsArr.h.

{ return qel; }

Referenced by Heed::DynArr< T >::ac(), Heed::DynArr< T >::acp(), Heed::DynArr< T >::acu(), Heed::apeq_mant(), Heed::append(), Heed::assignAll_1(), Heed::change_sign(), Heed::IterDynArr< T >::current(), Heed::determinant_DynArr(), Heed::DynArr< T >::DynArr(), Heed::find_next_comb(), Heed::find_next_comb_not_less(), Heed::find_prev_comb(), Heed::gconfirm_ind(), Heed::gconfirm_ind_ext(), Heed::DynArr< T >::get_qdim(), Heed::DynArr< T >::get_s_non_emplty(), Heed::ifequal(), Heed::inverse_DynArr(), Heed::inverse_DynArr_prot(), Heed::IterDynArr< T >::IterDynArr(), Heed::merge(), Heed::DynArr< T >::IndexingProvider< D >::operator D&(), Heed::operator*(), Heed::operator*=(), Heed::operator+(), Heed::operator+=(), Heed::operator-(), Heed::operator-=(), Heed::operator/(), Heed::operator/=(), Heed::operator<<(), Heed::DynArr< T >::IndexingProvider< D >::operator=(), Heed::DynLinArr< T >::operator=(), Heed::operator==(), Heed::operator>>(), Heed::DynArr< T >::IndexingProvider< D >::operator[](), Heed::DynArr< T >::operator[](), Heed::DynArr< T >::pilfer(), Heed::print_adr_DynLinArr(), Heed::print_DynLinArr(), Heed::print_DynLinArr_double(), Heed::print_DynLinArr_double2(), Heed::print_DynLinArr_float(), Heed::print_DynLinArr_int(), Heed::print_DynLinArr_int_double(), Heed::print_DynLinArr_int_double3(), Heed::print_DynLinArr_long(), Heed::DynArr< T >::put_qel(), and Heed::put_qel_1().

increment() [1/2]

template<class T >

void Heed::DynLinArr< T >::increment ( const T &  val )

inline

Definition at line 308 of file AbsArr.h.

                               {
    check();
    long q = qel + 1;
    put_qel(q, val);
  }

increment() [2/2]

template<class T >

void Heed::DynLinArr< T >::increment ( const T *  val = NULL )

inline

Definition at line 303 of file AbsArr.h.

                                      {
    check();
    long q = qel + 1;
    put_qel(q, *val);
  }

last_el() [1/2]

template<class T >

T & Heed::DynLinArr< T >::last_el ( void  )

inline

Definition at line 255 of file AbsArr.h.

                          {
#ifdef ALR_CHECK_BOUND
    if (qel > 0) return el[qel - 1];
    mcerr << "ERROR in const T& DynLinArr::last_el(void) const: qel <=0:"
          << " qel" << qel << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
    return el[0];
#else
    return el[qel];
#endif
  }

last_el() [2/2]

template<class T >

const T & Heed::DynLinArr< T >::last_el ( void  ) const

inline

Definition at line 269 of file AbsArr.h.

                                      {
#ifdef ALR_CHECK_BOUND
    if (qel > 0) return el[qel - 1];
    mcerr << "ERROR in const T& DynLinArr::last_el(void) const: qel <=0:"
          << " qel" << qel << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
    return el[0];
#else
    return el[qel];
#endif
  }

operator=() [1/2]

template<class T >

template<class D >

DynLinArr< T > & Heed::DynLinArr< T >::operator=

(

const DynLinArr< D > &

f

)

Definition at line 494 of file AbsArr.h.

                                                           {
#ifdef DEBUG_DYNLINARR
  mcout << "DynLinArr<T>& DynLinArr<T>::operator=(const DynLinArr<D>& f) is "
           "working\n";
#endif
  if (this == &f) return *this;
  check();
  f.check();
  // First of all we allocate memory and copy to there
  // all elements from f, because f can be part of this array,
  // for example, one of its elements.
  long q = f.get_qel();
  T* temp_el = (T*)NULL;
  if (q > 0) {
    temp_el = new T[q];
    for (long n = 0; n < q; n++) temp_el[n] = f[n];
  }
  pass(q, temp_el);
  return *this;
}

operator=() [2/2]

template<class T >

DynLinArr< T > & Heed::DynLinArr< T >::operator=

(

const DynLinArr< T > &

f

)

Definition at line 468 of file AbsArr.h.

                                                           {
#ifdef DEBUG_DYNLINARR
  mcout << "DynLinArr<T>& DynLinArr<T>::operator=(const DynLinArr<T>& f) is "
           "working\n";
#endif
  if (this != &f) {
    // mcout<<"DynLinArr<T>& operator=(const DynLinArr<T>& f): long(el)="
    //<<long(el)<<'\n';
    check();
    f.check();
    // First of all we allocate memory and copy to there
    // all elements from f, because f can be part of this array,
    // for example, one of its elements.
    long q = f.get_qel();
    T* temp_el = (T*)NULL;
    if (q > 0) {
      temp_el = new T[q];
      for (long n = 0; n < q; n++) temp_el[n] = f.el[n];
    }
    pass(q, temp_el);
  }
  return *this;
}

operator[]() [1/2]

template<class T >

T & Heed::DynLinArr< T >::operator[] ( long  n )

inline

Definition at line 221 of file AbsArr.h.

                               {
#ifdef ALR_CHECK_BOUND
    if (n >= 0 && n < qel) return el[n];
    mcerr << "ERROR in const T& DynLinArr::operator[](long n) const: "
          << "n is out of bounds, n=" << n << " qel=" << qel << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
    return el[0];
#else
    return el[n];
#endif
  }

operator[]() [2/2]

template<class T >

const T & Heed::DynLinArr< T >::operator[] ( long  n ) const

inline

Definition at line 234 of file AbsArr.h.

                                           {
#ifdef ALR_CHECK_BOUND
    if (n >= 0 && n < qel) return el[n];
    mcerr << "ERROR in const T& DynLinArr::operator[](long n) const: "
          << "n is out of bounds, n=" << n << " qel=" << qel << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
    return el[0];
#else
    return el[n];
#endif
  }

pass()

template<class T >

void Heed::DynLinArr< T >::pass ( long  fqel, T *  fel  )

inline

Definition at line 183 of file AbsArr.h.

                               {
    // Do not call directly! Is to be used only
    // from assignment operator above
    clear();
    qel = fqel;
    el = fel;
  }

pilfer()

template<class T >

void Heed::DynLinArr< T >::pilfer ( const DynLinArr< T > &  f )

inline

Definition at line 315 of file AbsArr.h.

                                     {
#ifdef DEBUG_DYNLINARR
    mcout << "DynLinArr::pilfer is called\n";
#endif
    if (this != &f) {
      if (qel != 0) {
        if (f.qel != 0) {
          mcerr << "ERROR in DynLinArr::pilfer(...):\n";
          mcerr << "Both the destination and source arrays are not empty\n";
          // For explanations why it is dengerous, see similar function
          // of ActivePtr.
          spexit(mcerr);
        } else {
          delete[] el;
          qel = 0;
        }
      }
      el = f.el;
      qel = f.qel;
      f.el = NULL;
      f.qel = 0;
    }
  }

Referenced by Heed::DynArr< T >::pilfer(), Heed::DynLinArr< T >::sort(), Heed::DynLinArr< T >::sort_select_decreasing(), and Heed::DynLinArr< T >::sort_select_increasing().

put_qel() [1/3]

template<class T >

void Heed::DynLinArr< T >::put_qel

(

long

fqel

)

Definition at line 527 of file AbsArr.h.

                                    {
  //
  // creates array with size fqel
  // If old array existed, then
  //   If it was less than fqel, it all is copied to new array
  //       and the other elements either assigned *val or
  //       remains not inited.
  //   else its fqel part is copyed to new array.
  // mcout<<"put_qel: *this="<<(*this);
  if (fqel < 0) {
    mcerr << "ERROR in template<class T> void DynLinArr<T>::put_qel(long "
             "fqel):\n";
    mcerr << "fqel < 0, fqel=" << fqel << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
  }
  check();
  if (el == NULL) {
    qel = fqel;
    if (qel > 0) el = new T[fqel];
  } else {
    if (qel != fqel) {
      if (fqel <= 0) {
        qel = 0;
        delete[] el;
        el = NULL;
      } else {
        T* elh;
        elh = new T[fqel];  
        for (long n = 0; n < fqel; ++n) {
          if (n < qel) elh[n] = el[n];
        }
        delete[] el;
        el = elh;
        qel = fqel;
      }
    }
  }
}

Referenced by Heed::append(), Heed::DynLinArr< T >::clear(), Heed::DynArr< T >::DynArr(), Heed::DynLinArr< T >::increment(), Heed::operator>>(), Heed::DynLinArr< T >::put_qel(), Heed::DynLinArr< T >::sort_select_decreasing(), and Heed::DynLinArr< T >::sort_select_increasing().

put_qel() [2/3]

template<class T >

void Heed::DynLinArr< T >::put_qel ( long  fqel, const T &  val  )

inline

Definition at line 300 of file AbsArr.h.

                                        {
    put_qel(fqel, &val, ArgInterp_SingleAdr());
  }

put_qel() [3/3]

template<class T >

void Heed::DynLinArr< T >::put_qel	(	long	fqel,
		const T *	val,
		ArgInterp_SingleAdr	t
	)

Definition at line 569 of file AbsArr.h.

                                                                         {
  // By default val == NULL
  // creates array with size fqel
  // If old array existed, then
  //   If it was less than fqel, it all is copied to new array
  //       and the other elements either assigned *val or
  //       remains not inited.
  //   else its fqel part is copyed to new array.
  // mcout<<"put_qel: *this="<<(*this);
  if (fqel < 0) {
    mcerr << "ERROR in template<class T> void DynLinArr<T>::put_qel(long fqel, "
             "const T* val, ArgInterp_SingleAdr):\n";
    mcerr << "fqel < 0, fqel=" << fqel << '\n';
    mcerr << "Type of T is (in internal notations) " << typeid(T).name()
          << '\n';
    spexit(mcerr);
    // Avoid compiler warning because of unused variable t (HS).
    mcerr << sizeof(t) << "\n";
  }
  check();
  if (el == NULL) {
    qel = fqel;
    if (qel > 0) el = new T[fqel];
    if (val != NULL)
      for (long n = 0; n < qel; ++n) el[n] = *val;
  } else {
    if (qel != fqel) {
      if (fqel <= 0) {
        qel = 0;
        delete[] el;
        el = NULL;
      } else {
        T* elh;
        elh = new T[fqel];
        for (long n = 0; n < fqel; ++n) {
          if (n < qel)
            elh[n] = el[n];
          else if (val != NULL)
            elh[n] = *val;
        }
        delete[] el;
        el = elh;
        qel = fqel;
      }
    }
  }
}

sort() [1/2]

template<class T >

void Heed::DynLinArr< T >::sort	(	DynLinArr< long > &	sort_ind,
		long	q_to_sort = 0
	)		const

Definition at line 686 of file AbsArr.h.

                                                                       {
  mfunnamep(
      "void DynLinArr<T>::sort(DynLinArr< long >& sort_ind, long "
      "q_to_sort = 0) const");
 
  check_econd12(q_to_sort, >, qel, mcerr);
  if (q_to_sort <= 0) q_to_sort = qel;
  // if(q_to_sort <= 1) return;
 
  sort_ind.clear();
  sort_ind.pilfer(DynLinArr<long>(q_to_sort));
  long n, m;
  for (n = 0; n < q_to_sort; n++) {
    sort_ind.acu(n) = n;
  }
  if (q_to_sort <= 1) return;
 
  long n_possible_next = 1;
 
  for (n = 0; n < q_to_sort - 1; n++) {
    // first it finds the minimum along the rest and replaces if it is less
    long nmin = n_possible_next;
    long ind_nmin = sort_ind.acu(nmin);
    int s_change_possible_next = 0;
 
    // for(m=n+2; m<q_to_sort; m++)
    for (m = n_possible_next + 1; m < q_to_sort; m++) {
      if (el[ind_nmin] > el[sort_ind.acu(m)])
          // if(el[sort_ind.acu(nmin)] > el[sort_ind.acu(m)])
      {
        n_possible_next = nmin;
        s_change_possible_next = 1;
        nmin = m;
        ind_nmin = sort_ind.acu(nmin);
      }
    }
    if (s_change_possible_next == 0 || n_possible_next < n + 2) {
      n_possible_next = n + 2;
    }
    if (el[sort_ind.acu(n)] > el[ind_nmin])
        // if(el[sort_ind.acu(n)] > el[sort_ind.acu(nmin)])
    {
      if (s_change_possible_next == 1) {
        if (n_possible_next < q_to_sort &&
            el[sort_ind.acu(n)] < el[sort_ind.acu(n_possible_next)]) {
          n_possible_next = nmin;
        }
      }
      // long t = sort_ind.acu(nmin);
      sort_ind.acu(nmin) = sort_ind.acu(n);
      sort_ind.acu(n) = ind_nmin;
    }
  }
}

sort() [2/2]

template<class T >

void Heed::DynLinArr< T >::sort

(

long

q_to_sort = 0

)

Definition at line 625 of file AbsArr.h.

                                      {
  mfunnamep("void DynLinArr<T>::sort(long q_to_sort = 0)");
 
  check_econd12(q_to_sort, >, qel, mcerr);
  if (q_to_sort <= 0) q_to_sort = qel;
  if (q_to_sort <= 1) return;
 
  long n_possible_next = 1;
  long q_comp = 0;
  long n, m;
  for (n = 0; n < q_to_sort - 1; n++) {
    // Iprint2n(mcout, n, n_possible_next);
    // first it finds the minimum along the rest and replaces if it is less
    // long nmin = n+1;
    long nmin = n_possible_next;
    T el_min = el[nmin];
    int s_change_possible_next = 0;
 
    // for(m=n+2; m<q_to_sort; m++)
    for (m = n_possible_next + 1; m < q_to_sort; m++) {
      q_comp++;
      // if(el[nmin] > el[m])
      if (el_min > el[m]) {
        n_possible_next = nmin;
        s_change_possible_next = 1;
        nmin = m;
        el_min = el[nmin];
      }
    }
    // Iprint4n(mcout, n_possible_next, s_change_possible_next, nmin, el_min);
    if (s_change_possible_next == 0 || n_possible_next < n + 2) {
      n_possible_next = n + 2;
    }
    // if(el[n] > el[nmin])
    //{
    //  T t = el[nmin];
    //  el[nmin] = el[n];
    //  el[n] = t;
    //}
    // Iprintn(mcout, n_possible_next);
    // Iprint2n(mcout, el[n], el_min);
    if (el[n] > el_min) {
      if (s_change_possible_next == 1) {
        // if(n_possible_next < q_to_sort)
        if (n_possible_next < q_to_sort && el[n] < el[n_possible_next]) {
          n_possible_next = nmin;
        }
      }
      // mcout<<"replacing el[n] and el_min\n";
      T t = el_min;
      el[nmin] = el[n];
      el[n] = t;
    }
    // Iprintn(mcout, (*this));
  }
  // Iprintn(mcout, q_comp);
}

sort_select_decreasing()

template<class T >

void Heed::DynLinArr< T >::sort_select_decreasing	(	DynLinArr< long > &	sort_ind,
		long	q_to_sort = 0
	)		const

Definition at line 806 of file AbsArr.h.

                                                                {
  mfunnamep(
      "void DynLinArr<T>::sort_select_decreasing(DynLinArr< long >& "
      "sort_ind, long q_to_sort = 0) const");
 
  check_econd12(q_to_sort, >, qel, mcerr);
  long s_last_noninc = 0;
  if (q_to_sort <= 0) {
    q_to_sort = qel;
    s_last_noninc = 1;
  } else if (q_to_sort == qel) {
    s_last_noninc = 1;
  }
  // Iprintn(mcout, q_to_sort);
 
  // if(qel <= 1) return;
  sort_ind.clear();
  sort_ind.pilfer(DynLinArr<long>(qel));
  long n, m;
  for (n = 0; n < qel; n++) {
    sort_ind[n] = n;
  }
  if (q_to_sort <= 1) return;
 
  long n_possible_next = 1;
 
  for (n = 0; n < q_to_sort - s_last_noninc; n++) {
    // Iprintn(mcout, n);
    // first it finds the minimum along the rest and replaces if it is less
    long nmax = n_possible_next;
    // Iprintn(mcout, nmax);
    long ind_nmax = sort_ind[nmax];
    int s_change_possible_next = 0;
 
    // for(m=n+2; m<q_to_sort; m++)
    for (m = n_possible_next + 1; m < qel; m++) {
      // Iprint3n(mcout, ind_nmax, m, sort_ind[m]);
      if (el[ind_nmax] < el[sort_ind[m]]) {
        n_possible_next = nmax;
        s_change_possible_next = 1;
        nmax = m;
        // Iprintn(mcout, nmax);
        ind_nmax = sort_ind[nmax];
      }
    }
    if (s_change_possible_next == 0 || n_possible_next < n + 2) {
      n_possible_next = n + 2;
    }
    // Iprint4n(mcout, n, sort_ind[n], ind_nmax, el[ind_nmax]);
    if (el[sort_ind[n]] < el[ind_nmax]) {
      if (s_change_possible_next == 1) {
        if (n_possible_next < q_to_sort &&
            el[sort_ind[n]] > el[sort_ind[n_possible_next]]) {
          n_possible_next = nmax;
        }
      }
      // long t = sort_ind.acu(nmin);
      sort_ind[nmax] = sort_ind[n];
      sort_ind[n] = ind_nmax;
    }
  }
  sort_ind.put_qel(qel);
}

sort_select_increasing()

template<class T >

void Heed::DynLinArr< T >::sort_select_increasing	(	DynLinArr< long > &	sort_ind,
		long	q_to_sort = 0
	)		const

Definition at line 742 of file AbsArr.h.

                                                                {
  mfunnamep(
      "void DynLinArr<T>::sort_select_increasing(DynLinArr< long >& "
      "sort_ind, long q_to_sort = 0) const");
 
  check_econd12(q_to_sort, >, qel, mcerr);
  long s_last_noninc = 0;
  if (q_to_sort <= 0) {
    q_to_sort = qel;
    s_last_noninc = 1;
  } else if (q_to_sort == qel) {
    s_last_noninc = 1;
  }
 
  // if(qel <= 1) return;
  sort_ind.clear();
  sort_ind.pilfer(DynLinArr<long>(qel));
  long n, m;
  for (n = 0; n < qel; n++) {
    sort_ind[n] = n;
  }
  if (q_to_sort <= 1) return;
 
  long n_possible_next = 1;
 
  for (n = 0; n < q_to_sort - s_last_noninc; n++) {
    // first it finds the minimum along the rest and replaces if it is less
    long nmin = n_possible_next;
    long ind_nmin = sort_ind[nmin];
    int s_change_possible_next = 0;
 
    // for(m=n+2; m<q_to_sort; m++)
    for (m = n_possible_next + 1; m < qel; m++) {
      if (el[ind_nmin] > el[sort_ind[m]])
          // if(el[sort_ind.acu(nmin)] > el[sort_ind.acu(m)])
      {
        n_possible_next = nmin;
        s_change_possible_next = 1;
        nmin = m;
        ind_nmin = sort_ind[nmin];
      }
    }
    if (s_change_possible_next == 0 || n_possible_next < n + 2) {
      n_possible_next = n + 2;
    }
    if (el[sort_ind[n]] > el[ind_nmin])
        // if(el[sort_ind.acu(n)] > el[sort_ind.acu(nmin)])
    {
      if (s_change_possible_next == 1) {
        if (n_possible_next < q_to_sort &&
            el[sort_ind[n]] < el[sort_ind[n_possible_next]]) {
          n_possible_next = nmin;
        }
      }
      // long t = sort_ind.acu(nmin);
      sort_ind[nmin] = sort_ind[n];
      sort_ind[n] = ind_nmin;
    }
  }
  sort_ind.put_qel(qel);
}

top()

template<class T >

DynArr< T > Heed::DynLinArr< T >::top

(

void

)

Definition at line 2511 of file AbsArr.h.

                                {
  check();
  DynArr<T> r(1, qel);
  long n;
  for (n = 0; n < qel; n++) {
    r.ac(0, n) = el[n];
  }
  return r;
}

Friends And Related Function Documentation

apply1

template<class T >

template<class P >

void apply1 ( DynLinArr< P > &  ar, void(*)(P &f)  fun  )

friend

apply2

template<class T >

template<class P , class X >

void apply2 ( DynLinArr< P > &  ar, void(*)(P &f, void(*fun21)(X &f))  fun1, void(*)(X &f)  fun2  )

friend

---

The documentation for this class was generated from the following file:

• AbsArr.h