Category

Development Platform
Home > SourceCode/Document > Mathimatics-Numerical algorithms > View Code
gen_array.h
Package: leda.tar.gz　[view]
Upload User: gzelex
Upload Date: 2007-01-07
Package Size: 707k
Code Size: 4k
Category:

Mathimatics-Numerical algorithms

Development Platform:

MultiPlatform

gen_array.h：Code Content
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  gen_array.h
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  13. #ifndef LEDA_GEN_ARRAY_H
  14. #define LEDA_GEN_ARRAY_H
  16. //------------------------------------------------------------------------------
  17. // arrays
  18. //------------------------------------------------------------------------------
  20. #include <LEDA/basic.h>
  23. class gen_array {
  25. friend class gen_array2;
  27. protected:
  28. GenPtr* v;
  29. GenPtr* last;
  30. int sz;
  31.         int Low;
  32.         int High;
  34. virtual int  cmp(GenPtr, GenPtr)  const { return 0; }
  35. virtual void print_el(GenPtr&,ostream&) const {}
  36. virtual void read_el(GenPtr& ,istream&) const {}
  37. virtual void clear_entry(GenPtr&) const {}
  38. virtual void copy_entry(GenPtr&)  const {}
  39. virtual void init_entry(GenPtr&)  const {}
  40. virtual int  int_type() const { return 0; }
  42.   void quick_sort(GenPtr*,GenPtr*);
  43.   void int_quick_sort(GenPtr*,GenPtr*);
  44.   void insertion_sort(GenPtr*,GenPtr*,GenPtr*);
  45.   void int_insertion_sort(GenPtr*,GenPtr*,GenPtr*);
  47. protected:
  49.   int  binary_search(GenPtr);
  50.   void sort(int,int); 
  51.   void init();
  52.   void clear();
  54. public:
  57.          gen_array();
  58.          gen_array(int);
  59.          gen_array(int, int);
  60.          gen_array(const gen_array&);
  61. virtual ~gen_array() { if (v) delete[] v; }
  63.    gen_array& operator=(const gen_array&);
  65.    int     size() const     { return sz; }
  66.    int     low()  const     { return Low; }
  67.    int     high() const     { return High; }
  69.    GenPtr& elem(int i)       { return v[i]; }
  70.    GenPtr  elem(int i) const { return v[i]; }
  72.    GenPtr& entry(int i)
  73.    { if (i<Low || i>High)
  74.      error_handler(2,"array::entry index out of range");
  75.      return v[i-Low];
  76.     }
  78.    GenPtr  inf(int i) const
  79.    { if (i<Low || i>High)
  80.      error_handler(2,"array::inf index out of range");
  81.      return v[i-Low];
  82.     }
  84.    void permute(int,int);
  85.    void permute()  { permute(Low,High); }
  87.    void print(ostream&,string, char space) const;    
  88.    void print(ostream& out,char space=' ') const { print(out,"",space);  }
  89.    void print(string s, char space=' ')    const { print(cout,s,space);  }
  90.    void print(char space=' ')              const { print(cout,"",space); }   
  92.    void read(istream&,string);  
  93.    void read(istream& in)      { read(in,"");  }
  94.    void read(string s )        { read(cin,s);  }   
  95.    void read()                 { read(cin,""); }   
  97. // Iteration
  99.    GenPtr first_item() { return v; }
  100.    GenPtr last_item()  { return last; }
  102.    void loop_to_succ(GenPtr& p) { p = (p == last) ? 0 : (GenPtr*)p + 1;}
  103.    void loop_to_pred(GenPtr& p) { p = (p == v)    ? 0 : (GenPtr*)p - 1;}
  105. #if defined(__ELSE_SCOPE_BUG__)
  106.    GenPtr* forall_loop_item;
  107.    GenPtr& Forall_Loop_Item() const { return *(GenPtr*)&forall_loop_item; }
  108. #endif
  110. };
  113. /*------------------------------------------------------------------------*/
  114. /* 2 dimensional arrays                                                   */
  115. /*------------------------------------------------------------------------*/
  118. class gen_array2 {
  119. gen_array A;
  120. int Low1, Low2, High1, High2;
  121. virtual void clear_entry(GenPtr& x) const { x = 0; }
  122. virtual void copy_entry(GenPtr& x)  const { x = 0; }
  123. virtual void init_entry(GenPtr& x)  const { x = 0; }
  125. protected:
  126. void clear();
  127. gen_array* row(int i) const { return (gen_array*)A.inf(i); }
  129. void copy_row(gen_array*, gen_array*) const;
  131. public:
  132. void init(int,int,int,int);
  133. int low1()  const { return Low1; }
  134. int low2()  const { return Low2; }
  135. int high1() const { return High1; }
  136. int high2() const { return High2; }
  137. gen_array2(int,int,int,int);
  138. gen_array2(int,int);
  139. virtual ~gen_array2();
  141. gen_array2(const gen_array2& a);
  143. gen_array2& operator=(const gen_array2& a);
  145. };
  149. #if !defined(__TEMPLATE_FUNCTIONS__)
  150. // default I/O and cmp functions
  152. inline void Print(const gen_array& A, ostream& out) { A.print(out); }
  153. inline void Read(gen_array& A, istream& in) { A.read(in); }
  154. inline int compare(const gen_array&,const gen_array&) { return 0; }
  155. #endif
  157. #endif