GGEMSMathAlgorithms.hh

Go to the documentation of this file.

#ifndef GUARD_GGEMS_MATHS_GGEMSMATHALGORITHMS_HH
#define GUARD_GGEMS_MATHS_GGEMSMATHALGORITHMS_HH
 
// ************************************************************************
// * This file is part of GGEMS.                                          *
// *                                                                      *
// * GGEMS 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 3 of the License, or    *
// * (at your option) any later version.                                  *
// *                                                                      *
// * GGEMS 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 GGEMS.  If not, see <https://www.gnu.org/licenses/>.      *
// *                                                                      *
// ************************************************************************
 
#include "GGEMS/tools/GGEMSSystemOfUnits.hh"
 
#ifdef __OPENCL_C_VERSION__
inline GGint BinarySearchLeft(GGfloat const key, global GGfloat const* array, GGint const size, GGint const offset, GGint min)
#else
inline GGint BinarySearchLeft(GGfloat const key, GGfloat const* array, GGint const size, GGint const offset, GGint min)
#endif
{
  GGint max = size - 1, mid = 0; // Max element, and median element
  GGint min_check = min; // Min element
 
  while (min < max) {
    // Computing median index
    mid = (min + max) >> 1;
    if (key == array[mid + offset]) {
      return mid;
    }
    else if (key > array[mid + offset]) {
      min = mid + 1;
    }
    else {
      max = mid;
    }
  }
 
  // Checking the min elements
  if (min > min_check) min--;
 
  // Return the min element
  return min;
}
 
inline GGfloat LinearInterpolation(GGfloat const xa, GGfloat const ya, GGfloat const xb, GGfloat const yb, GGfloat const x)
{
  // Taylor young 1st order
  // if ( xa > x ) return ya;
  // if ( xb < x ) return yb;
  if (xa > xb) return yb;
  if (xa >= x) return ya;
  if (xb <= x) return yb;
 
  return ya + (x - xa)*(yb - ya)/(xb - xa);
}
 
inline GGfloat LogLogInterpolation(GGfloat x, GGfloat x0, GGfloat y0, GGfloat x1, GGfloat y1)
{
  if (x < x0) return y0;
  if (x > x1) return y1;
 
  x0 = 1.0f / x0;
 
  #ifdef __OPENCL_C_VERSION__
  return pow(10.0f, log10(y0) + log10(y1/y0) * (log10(x*x0) / log10(x1*x0)));
  #else
  return std::pow(10.0f, std::log10(y0) + std::log10(y1/y0) * (std::log10(x*x0) / std::log10(x1*x0)));
  #endif
}
 
#endif // GUARD_GGEMS_MATHS_GGEMSMATHALGORITHMS_HH