macros.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2014> <EDF-R&D> <FRANCE>
 * 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 TY_MACROS
#define TY_MACROS
 
#include <assert.h>
#include <complex>
 
#include "Tympan/core/defines.h"
 
// Type pour les valeurs complexes.
typedef std::complex<double> TYComplex;
 
#define CPLX_UN TYComplex(1.0, 0.0)
#define CPLX_MUN TYComplex(-1.0, 0.0)
#define CPLX_J TYComplex(0.0, 1.0)
 
inline TYComplex cotanh(const TYComplex& valeur)
{
    double reel = 0.0;
    double imag = 0.0;
 
    if (valeur.real() >= 100.0)
    {
        reel = 100.0;
    }
    else if (valeur.real() <= -100.0)
    {
        reel = -100.0;
    }
    else // -100 <= valeur.real() <= 100
    {
        reel = valeur.real();
    }
 
    imag = valeur.imag();
 
    TYComplex valeurTravail = TYComplex(reel, imag);
 
    return (std::cosh(valeurTravail) / std::sinh(valeurTravail));
}
 
inline std::string indentNbToStr(int indentNb)
{
    std::string str = "";
 
    while (indentNb--)
    {
        str += "\t";
    }
 
    return str;
}
 
#if TY_ARCH_TYPE == TY_ARCHITECTURE_64
inline std::string uintToStr(unsigned int val)
{
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
 
inline std::string uintToStr(size_t val)
{
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
    #if TY_COMPILER == TY_COMPILER_MSVC
inline std::string uintToStr(unsigned long val)
{
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
    #endif
#else
inline std::string uintToStr(size_t val)
{
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
 
inline std::string uintToStr(unsigned long val)
{
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
#endif
 
inline std::string intToStr(int val)
{
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
 
inline std::string floatToStr(float val)
{
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
 
inline std::string doubleToStr(double val)
{
    std::ostringstream oss;
    oss << val;
    return oss.str();
}
 
inline std::string doubleToStrPre(double val, int precision = 2)
{
    std::ostringstream oss;
    oss.precision(precision);
    oss << std::fixed << val;
    return oss.str();
}
 
template <class T> inline T fromString(const std::string& str, std::ios_base& (*f)(std::ios_base&) = std::dec)
{
    T value;
    std::istringstream iss(str);
    iss >> f >> value;
    return value;
}
 
#ifndef SAFE_DELETE
    #define SAFE_DELETE(_p)                                                                                  \
        {                                                                                                    \
            if ((_p) != NULL)                                                                                \
            {                                                                                                \
                delete (_p);                                                                                 \
                (_p) = NULL;                                                                                 \
            }                                                                                                \
        }
#endif
 
#ifndef SAFE_DELETE_LIST
    #define SAFE_DELETE_LIST(_p)                                                                             \
        {                                                                                                    \
            if ((_p) != NULL)                                                                                \
            {                                                                                                \
                delete[] (_p);                                                                               \
                (_p) = NULL;                                                                                 \
            }                                                                                                \
        }
#endif
 
#endif // TY_MACROS