math_lib.h

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * 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 the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef MATH_MATH_LIB_H
#define MATH_MATH_LIB_H

#include "fastlib/base/base.h"

#include <math.h>

namespace math {
  const double SQRT2 = 1.41421356237309504880;
  const double E = 2.7182818284590452354;
  const double LOG2_E = 1.4426950408889634074;
  const double LOG10_E = 0.43429448190325182765;
  const double LN_2 = 0.69314718055994530942;
  const double LN_10 = 2.30258509299404568402;
  const double PI = 3.141592653589793238462643383279;
  const double PI_2 = 1.57079632679489661923;

  template<typename T>
  inline T Sqr(T v) {
    return v * v;
  }

  inline int64 RoundInt(double d) {
    return int64(nearbyint(d));
  }

  inline double ClampNonNegative(double d) {
    return (d + fabs(d)) / 2;
  }

  inline double ClampNonPositive(double d) {
    return (d - fabs(d)) / 2;
  }
  
  inline double ClampRange(double value, double range_min, double range_max) {
    if (unlikely(value <= range_min)) {
      return range_min;
    } else if (unlikely(value >= range_max)) {
      return range_max; 
    } else {
      return value;
    }
  }
  
  inline double Random() {
    return rand() * (1.0 / RAND_MAX);
  }
  
  inline double Random(double lo, double hi) {
    return Random() * (hi - lo) + lo;
  }

  inline int RandInt(int hi_exclusive) {
    return rand() % hi_exclusive;
  }  
  inline int RandInt(int lo, int hi_exclusive) {
    return (rand() % (hi_exclusive - lo)) + lo;
  }
};

#include "fastlib/math/math_lib_impl.h"
//#include "math_lib_impl.h"

namespace math {
  template<int t_numerator, int t_denominator> 
  inline double Pow(double d) {
    return math__private::ZPowImpl<t_numerator, t_denominator>::Calculate(d);
  }
  
  template<int t_numerator, int t_denominator> 
  inline double PowAbs(double d) {
    // we specify whether it's an even function -- if so, we can sometimes
    // avoid the absolute value sign
    return math__private::ZPowAbsImpl<t_numerator, t_denominator,
        (t_numerator%t_denominator == 0) && ((t_numerator/t_denominator)%2 == 0)>::Calculate(fabs(d));
  }
};

template<typename TValue>
class MinMaxVal {
 public:
  typedef TValue Value;

 public:
  Value val;

  OBJECT_TRAVERSAL(MinMaxVal) {
    OT_OBJ(val);
  }

 public:
  operator Value() const { return val; }

  const Value& operator = (Value val_in) {
    return (val = val_in);
  }

  void MinWith(Value incoming_val) {
    if (unlikely(incoming_val < val)) {
      val = incoming_val;
    }
  }
  
  void MaxWith(Value incoming_val) {
    if (unlikely(incoming_val > val)) {
      val = incoming_val;
    }
  }
};

struct DRange {
 public:
  double lo;
  double hi;

  OBJECT_TRAVERSAL(DRange) {
    OT_OBJ(lo);
    OT_OBJ(hi);
  }
  
 public:
  DRange(double lo_in, double hi_in)
      : lo(lo_in), hi(hi_in)
      {}

  void InitEmptySet() {
    lo = DBL_MAX;
    hi = -DBL_MAX;
  }

  void InitUniversalSet() {
    lo = -DBL_MAX;
    hi = DBL_MAX;
  }
  
  void Init(double lo_in, double hi_in) {
    lo = lo_in;
    hi = hi_in;
  }

  void Reset(double lo_in, double hi_in) {
    lo = lo_in;
    hi = hi_in;
  }

  double width() const {
    return hi - lo;
  }

  double mid() const {
    return (hi + lo) / 2;
  }
  
  double interpolate(double factor) const {
    return factor * width() + lo;
  }

  const DRange& operator |= (double d) {
    if (unlikely(d < lo)) {
      lo = d;
    }
    if (unlikely(d > hi)) {
      hi = d;
    }
    return *this;
  }

  const DRange& operator &= (double d) {
    if (likely(d > lo)) {
      lo = d;
    }
    if (likely(d < hi)) {
      hi = d;
    }
    return *this;
  }

  const DRange& operator |= (const DRange& other) {
    if (unlikely(other.lo < lo)) {
      lo = other.lo;
    }
    if (unlikely(other.hi > hi)) {
      hi = other.hi;
    }
    return *this;
  }
  
  const DRange& operator &= (const DRange& other) {
    if (unlikely(other.lo > lo)) {
      lo = other.lo;
    }
    if (unlikely(other.hi < hi)) {
      hi = other.hi;
    }
    return *this;
  }

  friend DRange operator - (const DRange& r) {
    return DRange(-r.hi, -r.lo);
  }
  
  const DRange& operator *= (double d) {
    DEBUG_ASSERT_MSG(d >= 0, "don't multiply DRanges by negatives, explicitly negate");
    lo *= d;
    hi *= d;
    return *this;
  }

  friend DRange operator * (const DRange& r, double d) {
    DEBUG_ASSERT_MSG(d >= 0, "don't multiply DRanges by negatives, explicitly negate");
    return DRange(r.lo * d, r.hi * d);
  }

  friend DRange operator * (double d, const DRange& r) {
    DEBUG_ASSERT_MSG(d >= 0, "don't multiply DRanges by negatives, explicitly negate");
    return DRange(r.lo * d, r.hi * d);
  }
  
  const DRange& operator += (const DRange& other) {
    lo += other.lo;
    hi += other.hi;
    return *this;
  }
  
  const DRange& operator -= (const DRange& other) {
    lo -= other.hi;
    hi -= other.lo;
    return *this;
  }
  
  const DRange& operator += (double d) {
    lo += d;
    hi += d;
    return *this;
  }
  
  const DRange& operator -= (double d) {
    lo -= d;
    hi -= d;
    return *this;
  }

  friend DRange operator + (const DRange& a, const DRange& b) {
    DRange result;
    result.lo = a.lo + b.lo;
    result.hi = a.hi + b.hi;
    return result;
  }

  friend DRange operator - (const DRange& a, const DRange& b) {
    DRange result;
    result.lo = a.lo - b.hi;
    result.hi = a.hi - b.lo;
    return result;
  }
  
  friend DRange operator + (const DRange& a, double b) {
    DRange result;
    result.lo = a.lo + b;
    result.hi = a.hi + b;
    return result;
  }

  friend DRange operator - (const DRange& a, double b) {
    DRange result;
    result.lo = a.lo - b;
    result.hi = a.hi - b;
    return result;
  }

  void MaxWith(const DRange& range) {
    if (unlikely(range.lo > lo)) {
      lo = range.lo;
    }
    if (unlikely(range.hi > hi)) {
      hi = range.hi;
    }
  }
  
  void MinWith(const DRange& range) {
    if (unlikely(range.lo < lo)) {
      lo = range.lo;
    }
    if (unlikely(range.hi < hi)) {
      hi = range.hi;
    }
  }

  void MaxWith(double v) {
    if (unlikely(v > lo)) {
      lo = v;
      if (unlikely(v > hi)) {
        hi = v;
      }
    }
  }
  
  void MinWith(double v) {
    if (unlikely(v < hi)) {
      hi = v;
      if (unlikely(v < lo)) {
        lo = v;
      }
    }
  }

  friend bool operator < (const DRange& a, const DRange& b) {
    return a.hi < b.lo;
  }
  EXPAND_LESS_THAN(DRange);
  friend bool operator == (const DRange& a, const DRange& b) {
    return a.lo == b.lo && a.hi == b.hi;
  }
  EXPAND_EQUALS(DRange);
  
  friend bool operator < (const DRange& a, double b) {
    return a.hi < b;
  }
  EXPAND_HETERO_LESS_THAN(DRange, double);
  friend bool operator < (double a, const DRange& b) {
    return a < b.lo;
  }
  EXPAND_HETERO_LESS_THAN(double, DRange);

  bool Contains(double d) const {
    return d >= lo || d <= hi;
  }
};

#include "fastlib/math/discrete.h"
#include "fastlib/math/kernel.h"
#include "fastlib/math/geometry.h"
//#include "discrete.h"
//#include "kernel.h"
//#include "geometry.h"

#endif