u_base_math.hpp

// u3d_math.hpp
// $Id: u_base_math.hpp,v 1.3 2008/05/13 12:13:33 sad Exp $
#ifndef __u_base_math_hpp
#define __u_base_math_hpp

#ifdef GE_BUILD
#include <u_message.hpp>
#else
#include <mix/u_message.hpp>
#endif

#include <vector>
#include <limits>

class UBaseMath
{
public:
  
  static bool gauss(const std::vector< std::vector<double> > &LN,
            const std::vector<double> &P, 
            std::vector<double> &x);
  
  static double compositionMul(double x1, double y1, double z1,
                   double x2, double y2, double z2,
                   double x3, double y3, double z3);
  

  static void fiazr2xyz(double f, double az, double r, double &px, double &py, double &pz);
  

  static void xyz2fiazr(double px, double py, double pz, double &f, double &az, double &r);
  
  
  static double scalarMul(double x1, double y1, double z1,
              double x2, double y2, double z2);
  
  static void matrix4x4Mul(const double (&m1)[4][4], const double (&m2)[4][4], double (&m3)[4][4], 
               bool tr1 = false, bool tr2 = false);
  
  static void matrix2vec4x4Mul(const double (&m)[4][4], const double (&u)[4], double (&v)[4], 
                   bool tr = false);
  
  static void vec2matrix4x4Mul(const double (&u)[4], const double (&m)[4][4], double (&v)[4], 
                   bool tr = false);

  static void getLineCoeffs(double x1, double y1, double x2, double y2, 
                double &k, double &b);
  
  static int solveSquareEq(double a, double b, double c, double &x1, double &x2); 

  
  template <typename T>
  static bool isNAN(const T &t)
  {return (t != t);}

  template <typename T>
  static bool isInf(const T &t)
  {
    return 
      (std::numeric_limits<T>::has_infinity) &&
      (t == std::numeric_limits<T>::infinity() ||
       t == -std::numeric_limits<T>::infinity());
  }

  

  static double m_d_prec;
};

class UEqAbstractFunction
{
public:
  UEqAbstractFunction();
  
  virtual ~UEqAbstractFunction() {;}

  virtual double calc(double x) = 0; 
};

//------------------------------------------------------------------------------------------
class UEqAbstractSolve 
{
public:
  UEqAbstractSolve();
  
  virtual ~UEqAbstractSolve() {;}
  
  virtual void solve(UEqAbstractFunction* func) = 0;
  
  virtual double getRoot()
  {return cur_root;}
  
  virtual double getFunc()
  {return cur_func;}
  
protected:
  
  double cur_root;
  
  double cur_func;
  
  static int num_eq_solve; 
};

//------------------------------------------------------------------------------------------
class UEqDiv2Solve : public UEqAbstractSolve
{
public:
  UEqDiv2Solve();
  
  void solve(UEqAbstractFunction* func);
  
  void setRanges(double zmn, double zmx)
  {zmin = zmn; zmax = zmx;}
  
  void setMaxItersNum(int n)
  {itn_max = n;}
   
protected:
  int itn_max;
  
  double zmin, zmax;
};

#endif //__u_base_math_hpp