X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fremember.h;h=868b96620967871d507aca9c6501d82e08589a2c;hp=0d9bb687e875047152a04078b9ab0c61ed4c8bac;hb=e8c9b4a51a1c8f1230b023b0af6a708881ef23d3;hpb=703c6cebb5d3d395437e73e6935f3691aed68e0a

diff --git a/ginac/remember.h b/ginac/remember.h
index 0d9bb687..868b9662 100644
--- a/ginac/remember.h
+++ b/ginac/remember.h
@@ -4,7 +4,7 @@
  *  in GiNaC functions */
 
 /*
- *  GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -24,27 +24,26 @@
 #ifndef __GINAC_REMEMBER_H__
 #define __GINAC_REMEMBER_H__
 
+#include <iosfwd>
 #include <vector>
 #include <list>
 
-#ifndef NO_NAMESPACE_GINAC
 namespace GiNaC {
-#endif // ndef NO_NAMESPACE_GINAC
 
 class function;
 class ex;
 	
 /** A single entry in the remember table of a function.
-	Needs to be a friend of class function to access 'seq'.
-	'last_access' and 'successful_hits' are updated at each successful
-	'is_equal'. */
+ *  Needs to be a friend of class function to access 'seq'.
+ *  'last_access' and 'successful_hits' are updated at each successful
+ *  'is_equal'. */
 class remember_table_entry {
 public:
 	remember_table_entry(function const & f, ex const & r);
 	bool is_equal(function const & f) const;
-	ex get_result(void) const { return result; }
-	unsigned long get_last_access(void) const { return last_access; }
-	unsigned long get_successful_hits(void) const { return successful_hits; };
+	ex get_result() const { return result; }
+	unsigned long get_last_access() const { return last_access; }
+	unsigned long get_successful_hits() const { return successful_hits; };
 
 protected:
 	unsigned hashvalue;
@@ -56,7 +55,7 @@ protected:
 };    
 
 /** A list of entries in the remember table having some least
-	significant bits of the hashvalue in common. */
+ *  significant bits of the hashvalue in common. */
 class remember_table_list : public std::list<remember_table_entry> {
 public:
 	remember_table_list(unsigned as, unsigned strat);
@@ -68,37 +67,35 @@ protected:
 };
 
 /** The remember table is organized like an n-fold associative cache
-	in a microprocessor.  The table has a width of 's' (which is rounded
-	to table_size, some power of 2 near 's', internally) and a depth of 'as'
-	(unless you choose that entries are never discarded). The place where
-	an entry is stored depends on the hashvalue of the parameters of the
-	function (this corresponds to the address of byte to be cached).
-	The 'log_2(table_size)' least significant bits of this hashvalue
-	give the slot in which the entry will be stored or looked up.
-	Each slot can take up to 'as' entries. If a slot is full, an older
-	entry is removed by one of the following strategies:
-	- oldest entry (the first one in the list)
-	- least recently used (the one with the lowest 'last_access')
-	- least frequently used (the one with the lowest 'successful_hits')
-	or all entries are kept which means that the table grows indefinitely. */
+ *  in a microprocessor.  The table has a width of 's' (which is rounded
+ *  to table_size, some power of 2 near 's', internally) and a depth of 'as'
+ *  (unless you choose that entries are never discarded). The place where
+ *  an entry is stored depends on the hashvalue of the parameters of the
+ *  function (this corresponds to the address of byte to be cached).
+ *  The 'log_2(table_size)' least significant bits of this hashvalue
+ *  give the slot in which the entry will be stored or looked up.
+ *  Each slot can take up to 'as' entries. If a slot is full, an older
+ *  entry is removed by one of the following strategies:
+ *   - oldest entry (the first one in the list)
+ *   - least recently used (the one with the lowest 'last_access')
+ *   - least frequently used (the one with the lowest 'successful_hits')
+ *  or all entries are kept which means that the table grows indefinitely. */
 class remember_table : public std::vector<remember_table_list> {
 public:
 	remember_table();
 	remember_table(unsigned s, unsigned as, unsigned strat);
 	bool lookup_entry(function const & f, ex & result) const;
 	void add_entry(function const & f, ex const & result);
-	void clear_all_entries(void);
+	void clear_all_entries();
 	void show_statistics(std::ostream & os, unsigned level) const;
-	static std::vector<remember_table> & remember_tables(void);
+	static std::vector<remember_table> & remember_tables();
 protected:
-	void init_table(void);
+	void init_table();
 	unsigned table_size;
 	unsigned max_assoc_size;
 	unsigned remember_strategy;
 };      
 
-#ifndef NO_NAMESPACE_GINAC
 } // namespace GiNaC
-#endif // ndef NO_NAMESPACE_GINAC
 
 #endif // ndef __GINAC_REMEMBER_H__