include/realroot/assign.hpp

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of realroot library.       *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************
History:
$Id: let.hpp,v 1.3 2005/09/28 06:40:43 mourrain Exp $
**********************************************************************/
#ifndef mmx_assign_hpp
#define mmx_assign_hpp
//--------------------------------------------------------------------
#include <cstdlib>
#include <complex>
#include <iostream>
//====================================================================
namespace std {template<class C> struct complex;}
//--------------------------------------------------------------------
namespace mmx {

#ifndef WITH_AS
#define WITH_AS
  template<typename T,typename F> struct as_helper { 
    static inline T cv (const F& x) { return T(x); }
  };
  template<typename T,typename F> inline T as (const F& x) { 
    return as_helper<T,F>::cv (x); 
  }

  template<typename T,typename F, class U> inline T 
  as (const F& x, const U& u) { 
    return as_helper<T,F>::cv (x,u); 
  }

  template<typename T,typename F, class U, class V> inline T 
  as (const F& x, const U& u, const V& v) { 
    return as_helper<T,F>::cv (x,u,v); 
  }
#endif

//====================================================================

namespace let {
  //--------------------------------------------------------------------
  //  template<class A, class B> inline void assign(A& a, const B& b);
  //--------------------------------------------------------------------
  template<class A, class B> inline void assign(A& a, const B & b) {
    a=as<A>(b);
  }
  inline void assign( int & a, double d ) { a =  (int)rint(d); };
  //--------------------------------------------------------------------
  inline void assign(double & d, int i)        {d = double(i);}
  inline void assign(double & d, unsigned i)   {d = double(i);}
  inline void assign(double & d, double z)     {d = z;}
  //--------------------------------------------------------------------
  template<class C> inline void 
  assign(std::complex<C> & z, const C& x) { z= std::complex<C>(x);}
  //--------------------------------------------------------------------
  template<class X> inline void assign(X & a, const char *s) { a = X(s); }
  //----------------------------------------------------------------------
  template<> inline void assign(int &i, const char *s)      {i = atoi(s);}
  template<> inline void assign(long int &i,  const char *s) {i = atol(s);}
  //----------------------------------------------------------------------
#ifndef __CYGWIN__
  template<> inline void assign(long long int &i, const char *s) {i = atoll(s);}
#endif //__CYGWIN__
  //----------------------------------------------------------------------
  //  template<> 
  inline void assign(float & d,  char* s)       {d = atof(s);}
  //  template<> 
  inline void assign(double & d,  char* s)      {d = atof(s);}
  //  template<> 
  inline void assign(long double & d, char *s) {d = atof(s);}
  //--------------------------------------------------------------------
  inline void 
  assign(std::complex<double> & z, const char* s) {
    z = std::complex<double>(atof(s),0);
  }
  //--------------------------------------------------------------------
}
//========================================================================
} //namespace mmx
//========================================================================
#endif // realroot_assign_hpp

---