158 lines
4.5 KiB
C++
158 lines
4.5 KiB
C++
#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 */
|