synaps/arithm/let.h

/*********************************************************************
*      This file is part of the source code of SYNAPS library.       *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************
History:
$Id: let.h,v 1.3 2005/09/28 06:40:43 mourrain Exp $
**********************************************************************/
#ifndef synaps_arithm_let_H
#define synaps_arithm_let_H
//--------------------------------------------------------------------
#include <cstdlib>
#include <complex>
#include <iostream>
#include <synaps/init.h>
#include <synaps/base/type.h>
#include <synaps/arithm/let.h>

//--------------------------------------------------------------------
namespace std {template<class C> struct complex;}
//--------------------------------------------------------------------
__BEGIN_NAMESPACE_SYNAPS
//====================================================================

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)
  {
    //PRT_DEBUG("generic assign");
    a=b;
  }
  //  template<class A> inline void assign(A& a, const A& b) {a=b;};
  //--------------------------------------------------------------------
  template<class A, class B> void copy( A & a, const B& 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 X> inline
  const X & convert(const X& x, const type::As<X>& mth)
  {
    return x;
  }
  template<class X, class Y> inline
  Y  convert(const X& x, const type::As<Y>& mth )
  {
    return (Y)x;
  };
  //--------------------------------------------------------------------
  template < typename FT,
             typename T > inline
  FT convert(const T& a, const T& b, const type::As<FT>& mth)   {return FT(a, b); }

  template<class T> 
  double convert(const T&  a, const T& b, const type::As<double>& mth) 
  {
    double u,v;
    assign(u,a); assign(v,b);
    return  u/v;
  }
  inline double convert(double a, double b, const type::As<double>& mth) {return  a/b;}

  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, char *s) { a = X(s); }
  //----------------------------------------------------------------------
  template<> inline void assign(int &i, char *s)      {i = atoi(s);}
  template<> inline void assign(long int &i,  char *s) {i = atol(s);}
  //----------------------------------------------------------------------
#ifndef __CYGWIN__
  template<> inline void assign(long long int &i,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);
  }
  //------------------------------------------------------------------
  

  //--------------------------------------------------------------------
}
//========================================================================
__END_NAMESPACE_SYNAPS
#endif // synaps_arithm_let_H