real.cpp

Go to the documentation of this file.

/*
 * real.cpp - some real valued function implementations
 *
 * Copyright (C) 2008 Stefan Jahn <stefan@lkcc.org>
 * Copyright (C) 2014 Guilheme Brondani Torri <guitorri@gmail.com>
 *
 * This 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, or (at your option)
 * any later version.
 *
 * This software 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 package; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * $Id$
 *
 */

#if HAVE_CONFIG_H
# include <config.h>
#endif

//#include <cstdlib>
#include <cmath>
#include <cassert>

#include "consts.h"
#include "real.h"

namespace qucs {

//
// trigonometric
//

nr_double_t cos (const nr_double_t arg) {
  return std::cos (arg);
}

nr_double_t sin (const nr_double_t arg) {
  return std::sin (arg);
}

nr_double_t  tan (const nr_double_t arg) {
  return std::tan (arg);
}

nr_double_t  acos (const nr_double_t arg) {
  return std::acos (arg);
}

nr_double_t  asin (const nr_double_t arg) {
  return std::asin (arg);
}

nr_double_t  atan (const nr_double_t arg) {
  return std::atan (arg);
}

nr_double_t  atan2 (const nr_double_t x, const nr_double_t y) {
  return std::atan2 (x,y);
}

//
// hyperbolic
//

nr_double_t  cosh (const nr_double_t arg) {
  return std::cosh (arg);
}

nr_double_t  sinh (const nr_double_t arg) {
  return std::sinh (arg);
}

nr_double_t  tanh (const nr_double_t arg) {
  return std::tanh (arg);
}

nr_double_t  acosh (const nr_double_t arg) {
#ifdef HAVE_STD_ACOSH
  // c++11
  return std::acosh (arg);
#elif HAVE_ACOSH
  return ::acosh (arg);
#else
  return log (arg + sqrt (arg * arg - 1.0));
#endif
}

nr_double_t asinh (const nr_double_t arg)
{
#ifdef HAVE_STD_ASINH
  // c++11
  return std::asinh (arg);
#elif HAVE_ASINH
  return ::asinh (arg);
#else
  return log (arg + sqrt (arg * arg + 1.0));
#endif
}

nr_double_t atanh (const nr_double_t arg)
{
#ifdef HAVE_STD_ATANH
  // c++11
  return std::atanh (arg);
#elif HAVE_ATANH
  return ::atanh (arg);
#else
  return 0.5 * log ( 2.0 / (1.0 - arg) - 1.0);
#endif
}


//
// exponential and logarithmic functions
//
nr_double_t exp (const nr_double_t arg) {
  return std::exp (arg);
}
nr_double_t log (const nr_double_t arg) {
  return std::log (arg);
}
nr_double_t log10 (const nr_double_t arg) {
  return std::log10 (arg);
}

//
// power functions
//

nr_double_t pow (const nr_double_t a, const nr_double_t b)
{
  return std::pow (a,b);
}

nr_double_t sqrt (const nr_double_t d) {
  return std::sqrt (d);
}

nr_double_t xhypot (const nr_double_t a, const nr_double_t b) {
#ifdef HAVE_STD_HYPOT
  return std::hypot(a,b) // c++11
#else
  nr_double_t c = fabs (a);
  nr_double_t d = fabs (b);
  if (c > d) {
    nr_double_t e = d / c;
    return c * sqrt (1 + e * e);
  }
  else if (d == 0)
    return 0;
  else {
    nr_double_t e = c / d;
    return d * sqrt (1 + e * e);
  }
#endif
}

//
// error functions
//

nr_double_t erf( nr_double_t arg) {
#ifdef HAVE_STD_ERF
  return std::erf (arg); // c++11
#elif HAVE_ERF
  return ::erf (arg);
#endif
}


//
// rounding and remainder functions
//
nr_double_t ceil( nr_double_t arg) {
  return std::ceil(arg);
}

nr_double_t floor( nr_double_t arg) {
  return std::floor(arg);
}

nr_double_t fmod( nr_double_t arg) {
#ifdef HAVE_STD_TRUNC
  return std::fmod(arg);
#else
  return fmod(arg);
#endif
}

nr_double_t trunc( nr_double_t arg) {
#ifdef HAVE_STD_TRUNC
  return std::trunc(arg);
#elif HAVE_TRUNC
  return ::trunc (arg);
#else
  return arg > 0 ? floor (arg) : floor (arg + 1);
#endif
}
nr_double_t round( nr_double_t arg) {
#ifdef HAVE_STD_ROUND
  return std::round(arg);
#elif HAVE_ROUND
  return ::round (arg);
#else
  return (arg > 0) ? floor (arg + 0.5) : ceil (arg - 0.5);
#endif
}


//
// Qucs extra trigonometric helper
//
nr_double_t coth (const nr_double_t d) {
  return 1.0 / std::tanh (d);
}

nr_double_t sech (const nr_double_t d) {
  return  (1.0 / std::cosh (d));
}

nr_double_t cosech (const nr_double_t d) {
  return  (1.0 / std::sinh (d));
}


//
// Qucs extra math functions
//

nr_double_t  sqr (const nr_double_t r) {
  return r * r;
}

unsigned int sqr (unsigned int r) {
  return r * r;
}



nr_double_t  quadr (const nr_double_t r) {
  return r * r * r * r;
}


//
//  extra math functions
//

nr_double_t limexp (const nr_double_t r) {
  return r < limitexp ? exp (r) : exp (limitexp) * (1.0 + (r - limitexp));
}

nr_double_t signum (const nr_double_t d) {
  if (d == 0) return 0;
  return d < 0 ? -1 : 1;
}

nr_double_t sign (const nr_double_t d) {
  return d < 0 ? -1 : 1;
}

nr_double_t sinc (const nr_double_t d) {
  if (d == 0) return 1;
  return sin (d) / d;
}

nr_double_t fix (const nr_double_t d) {
  return (d > 0) ? floor (d) : ceil (d);
}

nr_double_t step (const nr_double_t d) {
  nr_double_t x = d;
  if (x < 0.0)
    x = 0.0;
  else if (x > 0.0)
    x = 1.0;
  else
    x = 0.5;
  return x;
}

unsigned int
factorial (unsigned int n) {
  unsigned int result = 1;

  /* 13! > 2^32 */
  assert (n < 13);

  if (n == 0)
    return 1;

  for (; n > 1; n--)
    result = result * n;

  return result;
}


//
// overload complex manipulations on reals
//


nr_double_t real (const nr_double_t r) {
  return r;
}

nr_double_t imag (const nr_double_t r) {
  return 0.0;
}

nr_double_t norm (const nr_double_t r) {
  return r * r;
}

nr_double_t abs (const nr_double_t r) {
  return std::abs (r);
}

nr_double_t conj (const nr_double_t r) {
  return r;
}

nr_double_t rad2deg (const nr_double_t x) {
  return (180.0 * (x) / pi); 
}

nr_double_t deg2rad (const nr_double_t x) {
  return (pi * (x) / 180.0); 
}



} // namespace qucs