math.hpp

Go to the documentation of this file.

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
   Public License. The full license is in the file LICENSE, distributed with
   this software. */
 
#pragma once
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
#ifndef M_PI_2
#define M_PI_2 1.57079632679489661923
#endif
 
#ifndef M_SQRT2
#define M_SQRT2 1.41421356237309504880
#endif
 
#ifndef M_SQRT1_2
#define M_SQRT1_2 0.707106781186547524401
#endif
 
#include "highmap/array.hpp"
 
namespace hmap
{
 
enum DistanceFunction : int
{
  CHEBYSHEV, 
  EUCLIDIAN, 
  EUCLISHEV, 
  MANHATTAN, 
};
 
enum PhasorProfile : int
{
  PP_COSINE_BULKY,
  PP_COSINE_PEAKY,
  PP_COSINE_SQUARE,
  PP_COSINE_STD,
  PP_TRIANGLE,
};
 
enum RadialProfile : int
{
  RP_GAIN,
  RP_LINEAR,
  RP_POW,
  RP_SMOOTHSTEP,
  RP_SMOOTHSTEP_UPPER,
  RP_FLAT_BOTTOM,
  RP_SQRT
};
 
Array abs(const Array &array);
 
Array abs_smooth(const Array &array, float mu, const Array &vshift);
Array abs_smooth(const Array &array, float mu, float vshift); 
Array abs_smooth(const Array &array, float mu);               
float abs_smooth(float a, float mu);                          
 
Array almost_unit_identity(const Array &array);
float almost_unit_identity(float x); 
 
float almost_unit_identity_c2(float x);
float almost_unit_identity_c2(const Array &array);
 
inline float approx_hypot(float a, float b)
{
  a = std::abs(a);
  b = std::abs(b);
  if (a > b) std::swap(a, b);
  return 0.414f * a + b;
}
 
inline float approx_rsqrt(float a)
{
  union
  {
    float    f;
    uint32_t i;
  } conv = {.f = a};
  conv.i = 0x5f3759df - (conv.i >> 1);
  conv.f *= 1.5F - (a * 0.5F * conv.f * conv.f);
  return conv.f;
}
 
Array atan(const Array &array);
 
Array atan2(const Array &y, const Array &x);
 
int ceil_div(int a, int b);
 
Array cos(const Array &array);
 
Array exp(const Array &array);
 
float gain(float x, float factor);
 
Array gaussian_decay(const Array &array, float sigma);
 
std::function<float(float, float)> get_distance_function(
    DistanceFunction dist_fct);
 
std::function<float(float)> get_phasor_profile_function(
    PhasorProfile phasor_profile,
    float         delta,
    float        *p_profile_avg = nullptr);
 
std::function<float(float)> get_radial_profile_function(
    RadialProfile radial_profile,
    float         delta);
 
int highest_power_of_2(int n);
 
Array hypot(const Array &array1, const Array &array2);
 
Array is_equal(const Array &array, float value);
 
Array is_non_zero(const Array &array);
 
Array is_zero(const Array &array);
 
Array lerp(const Array &array1, const Array &array2, const Array &t);
Array lerp(const Array &array1, const Array &array2, float t); 
float lerp(float a, float b, float t);                         
 
Array log10(const Array &array);
 
Array pow(const Array &array, float exp);
 
void radial_displacement_to_xy(const Array &dr,
                               Array       &dx,
                               Array       &dy,
                               float        smoothing = 1.f,
                               glm::vec2    center = {0.5f, 0.5f},
                               glm::vec4    bbox = {0.f, 1.f, 0.f, 1.f});
 
void rotate_displacement(const Array &delta, float angle, Array &dx, Array &dy);
 
float sigmoid(float x,
              float width = 1.f,
              float vmin = 0.f,
              float vmax = 1.f,
              float x0 = 0.f);
 
Array sigmoid(const Array &array,
              float        width = 1.f,
              float        vmin = 0.f,
              float        vmax = 1.f,
              float        x0 = 0.f);
 
Array sin(const Array &array);
 
Array smoothstep3(const Array &array, float vmin = 0.f, float vmax = 1.f);
 
float smoothstep3(float x);
 
float smoothstep3_lower(float x);
Array smoothstep3_lower(const Array &x); 
 
float smoothstep3_upper(float x);
Array smoothstep3_upper(const Array &x); 
 
Array smoothstep5(const Array &array, float vmin = 0.f, float vmax = 1.f);
Array smoothstep5(const Array &array,
                  const Array &vmin,
                  const Array &vmax); 
 
float smoothstep5(float x);
 
float smoothstep5_lower(float x);
Array smoothstep5_lower(const Array &x); 
 
float smoothstep5_upper(float x);
Array smoothstep5_upper(const Array &x); 
 
float smoothstep7(float x);
Array smoothstep7(const Array &x); 
 
Array sqrt(const Array &array);
 
Array sqrt_safe(const Array &array);
 
float threshold(float x, float x0, float x1);
 
Array threshold(const Array &x, float x0, float x1);
 
float threshold_smooth(float x, float x0, float x1);
 
Array threshold_smooth(const Array &x, float x0, float x1);
 
float triangle(float x, float vmin, float vmax);
 
} // namespace hmap