asc26 amss-ncku initialized

AMSS_NCKU_source/util.h

@@ -0,0 +1,157 @@
+#ifndef AHFINDERDIRECT__UTIL_HH
+#define AHFINDERDIRECT__UTIL_HH
+#ifdef newc
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+#include <strstream>
+#include <cmath>
+using namespace std;
+#else
+#include <iostream.h>
+#include <iomanip.h>
+#include <fstream.h>
+#include <string.h>
+#include <math.h>
+#endif
+
+#define PI M_PI
+
+namespace AHFinderDirect
+{
+	namespace jtutil
+	{
+		inline int how_many_in_range(int low, int high) { return high - low + 1; }
+
+		inline int is_even(int i) { return !(i & 0x1); }
+		inline int is_odd(int i) { return (i & 0x1); }
+
+		template <typename T>
+		inline T tmin(T x, T y) { return (x < y) ? x : y; }
+		template <typename T>
+		inline T tmax(T x, T y) { return (x > y) ? x : y; }
+		template <typename T>
+		inline T abs(T x) { return (x > 0) ? x : -x; }
+
+		template <typename T>
+		inline T pow2(T x) { return x * x; }
+		template <typename T>
+		inline T pow3(T x) { return x * x * x; }
+		template <typename T>
+		inline T pow4(T x) { return pow2(pow2(x)); }
+
+		template <typename fp_t>
+		inline fp_t degrees_of_radians(fp_t radians) { return (180.0 / PI) * radians; }
+		template <typename fp_t>
+		inline fp_t radians_of_degrees(fp_t degrees) { return (PI / 180.0) * degrees; }
+
+		// in miscfp.cc
+		//-----------------------------------------------------
+		double signum(double x);
+		double hypot3(double x, double y, double z);
+		double arctan_xy(double x, double y);
+
+		double modulo_reduce(double x, double xmod, double xmin, double xmax);
+
+		template <typename fp_t>
+		void zero_C_array(int N, fp_t array[]);
+
+		// in error_exit.cc
+		// ------------------------------------------------------
+		int error_exit(int msg_level, const char *format, ...);
+
+		// in norm.cc
+		//
+		template <typename fp_t>
+		class norm
+		{
+		public:
+			// get norms etc
+			fp_t mean() const;
+			fp_t two_norm() const; // sqrt(sum x_i^2)
+			fp_t rms_norm() const; // sqrt(average of x_i^2)
+			fp_t infinity_norm() const { return max_abs_value_; }
+
+			fp_t max_abs_value() const { return max_abs_value_; }
+			fp_t min_abs_value() const { return min_abs_value_; }
+
+			fp_t max_value() const { return max_value_; }
+			fp_t min_value() const { return min_value_; }
+
+			// specify data point
+			void data(fp_t x);
+
+			// have any data points been specified?
+			bool is_empty() const { return N_ == 0; }
+			bool is_nonempty() const { return N_ > 0; }
+
+			// reset ==> just like newly-constructed object
+			void reset();
+
+			// constructor, destructor
+			// ... compiler-generated no-op destructor is ok
+			norm();
+
+		private:
+			// we forbid copying and passing by value
+			// by declaring the copy constructor and assignment operator
+			// private, but never defining them
+			norm(const norm &rhs);
+			norm &operator=(const norm &rhs);
+
+		private:
+			long N_;			 // # of data points
+			fp_t sum_;			 // sum(data)
+			fp_t sum2_;			 // sum(data^2)
+			fp_t max_abs_value_; // max |data|
+			fp_t min_abs_value_; // min |data|
+			fp_t max_value_;	 // max data
+			fp_t min_value_;	 // min data
+		};
+
+		// in fuzzy.cc
+		template <typename fp_t>
+		class fuzzy
+		{
+		public:
+			// comparison tolerance (may be modified by user code if needed)
+			static fp_t get_tolerance() { return tolerance_; }
+			static void set_tolerance(fp_t new_tolerance)
+			{
+				tolerance_ = new_tolerance;
+			}
+
+			// fuzzy commparisons
+			static bool EQ(fp_t x, fp_t y);
+			static bool NE(fp_t x, fp_t y) { return !EQ(x, y); }
+			static bool LT(fp_t x, fp_t y) { return EQ(x, y) ? false : (x < y); }
+			static bool LE(fp_t x, fp_t y) { return EQ(x, y) ? true : (x < y); }
+			static bool GT(fp_t x, fp_t y) { return EQ(x, y) ? false : (x > y); }
+			static bool GE(fp_t x, fp_t y) { return EQ(x, y) ? true : (x > y); }
+
+			static bool is_integer(fp_t x); // is x fuzzily an integer?
+			static int floor(fp_t x);		// round x fuzzily down to integer
+			static int ceiling(fp_t x);		// round x fuzzily up to integer
+
+		private:
+			// comparison tolerance
+			// ... must be explicitly initialized when instantiating
+			//     for a new <fp_t> type, see "fuzzy.cc" for details/examples
+			static fp_t tolerance_;
+		};
+
+		// in round.cc
+		template <typename fp_t>
+		class round
+		{
+		public:
+			static int to_integer(fp_t x); // round to nearest integer
+
+			static int floor(fp_t x);	// round down to integer
+			static int ceiling(fp_t x); // round up to integer
+		};
+
+	} // namespace jtutil
+} // namespace AHFinderDirect
+
+#endif /* AHFINDERDIRECT__UTIL_HH */