EngineMath.h

Ir a la documentación de este archivo.

 
/*
 * MIT License
 *
 * Copyright (c) 2024 Roberto Charreton
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * In addition, any project or software that uses this library or class must include
 * the following acknowledgment in the credits:
 *
 * "This project uses software developed by Roberto Charreton and Attribute Overload."
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
*/
#pragma once
namespace EU {
 
  // Constantes matemáticas
  constexpr float PI = 3.14159265358979323846f;
  constexpr float E = 2.71828182845904523536f;
 
  inline float sqrt(float value) {
    if (value < 0) {
      return 0; // Handle negative input gracefully.
    }
    float x = value;
    float y = 1.0f;
    float epsilon = 0.00001f; // Desired precision.
    while (x - y > epsilon) {
      x = (x + y) / 2.0f;
      y = value / x;
    }
    return x;
  }
 
  inline float square(float value) {
    return value * value;
  }
 
  inline float cube(float value) {
    return value * value * value;
  }
 
  inline float power(float base, int exponent) {
    if (exponent == 0) return 1;
    if (exponent < 0) return 1.0f / power(base, -exponent);
    float result = 1;
    while (exponent) {
      if (exponent % 2 == 1) result *= base;
      base *= base;
      exponent /= 2;
    }
    return result;
  }
 
  inline float abs(float value) {
    return (value < 0) ? -value : value;
  }
 
  inline float EMax(float a, float b) {
    return (a > b) ? a : b;
  }
 
  inline float EMin(float a, float b) {
    return (a < b) ? a : b;
  }
 
  inline float round(float value) {
    return (value > 0) ? static_cast<int>(value + 0.5f) : static_cast<int>(value - 0.5f);
  }
 
  inline float floor(float value) {
    int intValue = static_cast<int>(value);
    return (value < intValue) ? intValue - 1 : intValue;
  }
 
  inline float ceil(float value) {
    int intValue = static_cast<int>(value);
    return (value > intValue) ? intValue + 1 : intValue;
  }
 
  inline float fabs(float value) {
    return value < 0.0f ? -value : value;
  }
 
  // Funciones Trigonométricas
  inline float sin(float angle) {
    float result = 0.0f;
    float term = angle;
    float angle_squared = angle * angle;
    int n = 1;
    while (term > 1e-6f || term < -1e-6f) {
      result += term;
      term *= -angle_squared / ((2 * n) * (2 * n + 1));
      ++n;
    }
    return result;
  }
 
  inline float cos(float angle) {
    return sin(angle + PI / 2);
  }
 
  inline float tan(float angle) {
    float s = sin(angle);
    float c = cos(angle);
    return c != 0.0f ? s / c : 0.0f; // Evita la división por cero
  }
 
  inline float asin(float value) {
    // Aproximación con la serie de Taylor
    float x = value;
    float result = x;
    float term = x;
    for (int n = 1; n < 10; ++n) {
      term *= x * x * (2 * n - 1) / ((2 * n + 1) * (2 * n));
      result += term;
    }
    return result;
  }
 
  inline float acos(float value) {
    return PI / 2 - asin(value);
  }
 
  inline float atan(float value) {
    // Aproximación de la función arcotangente
    float result = 0.0f;
    float term = value;
    for (int n = 0; n < 10; ++n) {
      result += term / (2 * n + 1);
      term *= -value * value;
    }
    return result;
  }
 
  inline float sinh(float value) {
    return (exp(value) - exp(-value)) / 2;
  }
 
  inline float cosh(float value) {
    return (exp(value) + exp(-value)) / 2;
  }
 
  inline float tanh(float value) {
    return sinh(value) / cosh(value);
  }
 
  // Conversión entre Radianes y Grados
  inline float radians(float degrees) {
    return degrees * PI / 180.0f;
  }
 
  inline float degrees(float radians) {
    return radians * 180.0f / PI;
  }
 
  // Funciones Exponenciales y Logarítmicas
  inline float exp(float value) {
    float result = 1.0f;
    float term = 1.0f;
    for (int n = 1; n < 20; ++n) {
      term *= value / n;
      result += term;
    }
    return result;
  }
 
  inline float log(float value) {
    // Aproximación usando la serie de Taylor
    if (value <= 0) return 0;
    float x = (value - 1) / (value + 1);
    float x2 = x * x;
    float result = 0.0f;
    float term = x;
    for (int n = 1; n < 20; ++n) {
      result += term / (2 * n - 1);
      term *= x2;
    }
    return 2 * result;
  }
 
  inline float log10(float value) {
    return log(value) / log(10);
  }
 
  // Operaciones de Redondeo Avanzadas
  inline float mod(float a, float b) {
    return a - b * static_cast<int>(a / b);
  }
 
  // Funciones de Geometría
  inline float circleArea(float radius) {
    return PI * radius * radius;
  }
 
  inline float circleCircumference(float radius) {
    return 2 * PI * radius;
  }
 
  inline float rectangleArea(float width, float height) {
    return width * height;
  }
 
  inline float rectanglePerimeter(float width, float height) {
    return 2 * (width + height);
  }
 
  inline float triangleArea(float base, float height) {
    return 0.5f * base * height;
  }
 
  inline float distance(float x1, float y1, float x2, float y2) {
    float dx = x2 - x1;
    float dy = y2 - y1;
    return sqrt(dx * dx + dy * dy);
  }
 
  // Funciones de Cálculo Numérico
  inline float lerp(float a, float b, float t) {
    return a + t * (b - a);
  }
 
  inline int factorial(int n) {
    int result = 1;
    for (int i = 2; i <= n; ++i) {
      result *= i;
    }
    return result;
  }
 
  inline bool approxEqual(float a, float b, float epsilon) {
    return fabs(a - b) < epsilon;
  }
 
}