#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2015 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library 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
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_GEOMETRY_MATH_H
#error This file must be included through Math.h
#endif

namespace Nuclex { namespace Geometry {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Math routines for geometry classes based on floating point values</summary>
  template <>
  class Math<float> {

    /// <summary>The PI constant</summary>
    public: NUCLEX_GEOMETRY_API static constexpr float Pi = (
      3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825f
    );

    /// <summary>Two times PI, useful for some operations</summary>
    public: NUCLEX_GEOMETRY_API static constexpr float Perigon = (
      6.283185307179586476925286766559005768394338798750211641949889184615632812572417997256069651f
    );

    /// <summary>Calculates the square root of the specified value</summary>
    /// <param name="value">Value of which the square root is calculated</param>
    /// <returns>The square root of the specified number</returns>
    public: NUCLEX_GEOMETRY_API static float SquareRoot(float value) {
      return std::sqrt(value);
    }

    /// <summary>Returns a random number from 0.0 to the specified maximum</summary>
    /// <param name="random">The random number generator that will be used</param>
    /// <param name="max">Upper limit for the random number (exclusive)</param>
    /// <returns>A random number from 0.0 to the specified maximum</returns>
    public: template <typename TRandomNumberEngine> static float Random(
      TRandomNumberEngine &random, float max
    ) {
      std::uniform_real_distribution<float> distribution(0.0f, max);
      return distribution(random);
    }

    /// <summary>Returns a random number in the specified range</summary>
    /// <param name="random">The random number generator that will be used</param>
    /// <param name="min">Minimum possible value of the random number</param>
    /// <param name="max">Upper limit for the random number (exclusive)</param>
    /// <returns>A random number within the specified range</returns>
    public: template <typename TRandomNumberEngine> static float Random(
      TRandomNumberEngine &random, float min, float max
    ) {
      std::uniform_real_distribution<float> distribution(min, max);
      return distribution(random);
    }

    /// <summary>Calculates the sine of the specified angle</summary>
    /// <param name="angleInRadians">Angle for which the sine will be calculated</param>
    /// <returns>The sine of the specified angle</returns>
    public: NUCLEX_GEOMETRY_API static float Sine(float angleInRadians) {
      return std::sin(angleInRadians);
    }

    /// <summary>Calculates the cosine of the specified angle</summary>
    /// <param name="angleInRadians">Angle for which the cosine will be calculated</param>
    /// <returns>The cosine of the specified angle</returns>
    public: NUCLEX_GEOMETRY_API static float Cosine(float angleInRadians) {
      return std::cos(angleInRadians);
    }

    /// <summary>Calculates the angle of the specified sine value</summary>
    /// <param name="sineValue">Sine value of which the angle will be calculated</param>
    /// <returns>The angle of the specified sine value in radians</returns>
    public: NUCLEX_GEOMETRY_API static float ArcSine(float sineValue) {
      return std::asin(sineValue);
    }

    /// <summary>Calculates the angle of the specified cosine value</summary>
    /// <param name="cosineValue">Cosine value for which the angle will be calculated</param>
    /// <returns>The angle of the specified cosine value in radians</returns>
    public: NUCLEX_GEOMETRY_API static float ArcCosine(float cosineValue) {
      return std::acos(cosineValue);
    }

    /// <summary>Calculates the angle of the tangent specified by a direction</summary>
    /// <param name="x">X coordinate of the direction</param>
    /// <param name="y">Y coordinate of the direction</param>
    /// <returns>The angle of the tangent specified through the direction</returns>
    public: NUCLEX_GEOMETRY_API static float ArcTangent(float x, float y) {
      return std::atan2(y, x);
    }

    /// <summary>Returns the absolute value of the specified value</summary>
    /// <param name="value">Value of which the absolute value will be returned</param>
    /// <returns>The absolute value of the provided value</returns>
    public: NUCLEX_GEOMETRY_API static float Abs(float value) {
      return std::fabs(value);
    }

    /// <summary>Calculates <see cref="value" /> to the power of <see cref="power" /></summary>
    /// <param name="value">Value that will be multiplied</param>
    /// <param name="power">To which power the value will be multiplied</param>
    /// <returns><see cref="value" /> to the power of <see cref="power" /></returns>
    public: NUCLEX_GEOMETRY_API static float Power(float value, float power) {
      return std::pow(value, power);
    }

    /// <summary>Returns the smaller of two values</summary>
    /// <param name="first">First of the two values</param>
    /// <param name="second">Second of the two values</param>
    /// <returns>The smaller of the two provided values</returns>
    public: NUCLEX_GEOMETRY_API static float Min(float first, float second) {
      return std::min(first, second);
    }

    /// <summary>Returns the smallest of three values</summary>
    /// <param name="first">First of the three values</param>
    /// <param name="second">Second of the three values</param>
    /// <param name="third">Third of the three values</param>
    /// <returns>The smallest of the three provided values</returns>
    public: NUCLEX_GEOMETRY_API static float Min(float first, float second, float third) {
      return std::min(std::min(first, second), third);
    }

    /// <summary>Returns the larger of two values</summary>
    /// <param name="first">First of the two values</param>
    /// <param name="second">Second of the two values</param>
    /// <returns>The larger of the two provided values</returns>
    public: NUCLEX_GEOMETRY_API static float Max(float first, float second) {
      return std::max(first, second);
    }

    /// <summary>Returns the largest of three values</summary>
    /// <param name="first">First of the three values</param>
    /// <param name="second">Second of the three values</param>
    /// <param name="third">Third of the three values</param>
    /// <returns>The largest of the three provided values</returns>
    public: NUCLEX_GEOMETRY_API static float Max(float first, float second, float third) {
      return std::max(std::max(first, second), third);
    }

    /// <summary>Determines the extremes of two values</summary>
    /// <param name="first">First of the values whose extremes will be found</param>
    /// <param name="second">Second of the values whose extremes will be found</param>
    /// <returns>
    ///   A pair containing the smaller and the larger value in that order
    /// </returns>
    public: NUCLEX_GEOMETRY_API static std::pair<float, float> Extremes(
      float first, float second
    ) {
      if(first < second) {
        return std::pair<float, float>(first, second);
      } else {
        return std::pair<float, float>(second, first);
      }
    }

    /// <summary>Determines the extremes of three values</summary>
    /// <param name="first">First of the values whose extremes will be found</param>
    /// <param name="second">Second of the values whose extremes will be found</param>
    /// <param name="third">Third of the values whose extremes will be found</param>
    /// <returns>
    ///   A pair containing the smallest and the largest value of the three inputs
    /// </returns>
    public: NUCLEX_GEOMETRY_API static std::pair<float, float> Extremes(
      float first, float second, float third
    ) {
      if(first < second) {
        if(second < third) { // first < second < third
          return std::make_pair(first, third);
        } else if(first < third) { // first < third < second
          return std::make_pair(first, second);
        } else { // third < first < second
          return std::make_pair(third, second);
        }
      } else {
        if(first < third) { // second < first < third
          return std::make_pair(second, third);
        } else if(second < third) { // second < third < first
          return std::make_pair(second, first);
        } else { // third < second < first
          return std::make_pair(third, first);
        }
      }
    }

    /// <summary>Unwinds a value in a circular (repeating) value range</summary>
    /// <param name="value">Value that will be unwound</param>
    /// <param name="min">Lower limit of the circular value range</param>
    /// <param name="max">Upper limit of the circular value range</param>
    /// <returns>The unwound value</returns>
    public: NUCLEX_GEOMETRY_API static float Unwind(float value, float min, float max) {
      float range = (max - min);
      float floor = std::floor((value - min) / range);
      return value - (floor * range);
    }

    /// <summary>Limits the value to the specified range</summary>
    /// <param name="value">Value that will be limited</param>
    /// <param name="min">Minimum the value cannot go under</param>
    /// <param name="max">Maximum the value cannot go above</param>
    /// <returns>The value limited to the specified range</returns>
    public: NUCLEX_GEOMETRY_API static float Clamp(float value, float min, float max) {
      if(value < min) {
        return min;
      }
      if(value > max) {
        return max;
      }

      return value;
    }

    /// <summary>Linearly interpolates between two values</summary>
    /// <param name="left">Value at the left interpolation point</param>
    /// <param name="right">Value at the right interpolation point</param>
    /// <param name="t">Time (0.0 .. 1.0) for which to interpolate the value</param>
    /// <returns>The interpolated value at the specified time</returns>
    public: NUCLEX_GEOMETRY_API static float Lerp(float left, float right, float t) {
      return (right - left) * t + left;
    }

    /// <summary>Calculates the time of a linearly interpolated value</summary>
    /// <param name="left">Value at the left interpolation point</param>
    /// <param name="right">Value at the right interpolation point</param>
    /// <param name="value">Value that resulted from the interpolation</param>
    /// <returns>Time at which the value is placed in the interpolation range</returns>
    public: NUCLEX_GEOMETRY_API static float Unlerp(float left, float right, float value) {
      return (value - left) / (right - left);
    }

    /// <summary>Checks whether the specified value is invalid (not a number)</summary>
    /// <param name="value">Value that will be checked</param>
    /// <returns>True if the specified value is not a number</returns>
    public: NUCLEX_GEOMETRY_API static bool IsNan(float value) {
      return std::isnan(value);
    }

  };

  // ------------------------------------------------------------------------------------------- //

}} // namespace Nuclex::Geometry