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 <stdio.h>
#include <iostream>

#include <sstream>
//====================================================================
//namespace std {template<class C> struct complex;}
//--------------------------------------------------------------------
namespace mmx {

inline std::string to_string(int x)      {
    int sz=1,m=1;
    while(m<x) {m*=10; sz++;} sz++;
    char str[sz];
    sprintf(str,"%i",x);
    return std::string(str);
    //return std::to_string(x);
}
//inline std::string to_string(unsigned x) { return std::to_string(x);}


inline std::string to_string(double x)   {
    char str[20];
    sprintf(str,"%f",x);
    return std::string(str);
    //    return std::to_string(x);
}

#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

template<> struct as_helper<double,char*> {
    static inline double cv (char* x) {
        double r;
        //std::istringstream in(x); in>>r;
        r=atof(x);
        return r;
    }
};

template<> struct as_helper<double,const char*> {
    static inline double cv (const char* x) {
        double r;
        //std::istringstream in(x); in>>r;
        r = atof(x);
        return r;
    }
};

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

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 ) { if( ceil(d)==floor(d) ){int numb = (int)ceil(d);if(numb%2==0){a = (int)ceil(d);}else{a = (int)floor(d);}}else{a = (int)floor(d+0.5);} };
//--------------------------------------------------------------------
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) { std::istringstream in(s); in >>a; }
//----------------------------------------------------------------------
//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){std::istringstream in(s); in >>i;}
#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(double & d,  const char* s) {d = atof(s);}

//  template<>
//inline void assign(long double & d, char *s) {d = atof(s);}
//--------------------------------------------------------------------
template<> inline void
assign(std::complex<double> & z, const char* s) {
    z = std::complex<double>(atof(s),0);
}
//--------------------------------------------------------------------
}
//========================================================================
} //namespace mmx
//========================================================================
#endif // realroot_assign_hpp