开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 并行计算 > 查看源码
Math.h
资源名称：fastgrid-4.2.1-141-src.tar.gz　[点击查看]
上传用户：chinafayin
上传日期：2022-04-05
资源大小：153k
文件大小：5k
源码类别：

并行计算

开发平台：

Visual C++

Math.h：源码内容
  1. /*
  2.     Linear Algebra / Math library
  4.     Copyright (C) 2003-2009, Marek Olsak (maraeo@gmail.com), All Rights Reserved.
  5.     Copyright (C) 2003-2005, Tomas Pastorek (tomas@tomaspastorek.cz), All Rights Reserved.
  7.     This program is free software; you can redistribute it and/or
  8.     modify it under the terms of the GNU General Public License
  9.     as published by the Free Software Foundation; either version 2
  10.     of the License, or (at your option) any later version.
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20. */
  22. #pragma once
  24. namespace Rune
  25. {
  26.     /**
  27.         Definuje matematicke konstanty a funkce, vhodne pro pouziti v sablonach. Vetsina z nich je
  28.         designovana pro typy realnych cisel.
  29.     **************************************************************************************************/
  30.     template<typename T>
  31.     class Math
  32.     {
  33.     public:
  34.         // Konstanty
  35.         static T Pi()                   { return T(3.1415926535897932384626433832795); }
  36.         static T Pi2()                  { return T(6.283185307179586476925286766559); }
  37.         static T PiHalf()               { return T(1.5707963267948966192313216916398); }
  38.         static T Deg()                  { return T(57.295779513082320876798154814105); }
  39.         static T Rad()                  { return T(0.017453292519943295769236907684886); }
  40.         static T Epsilon()              { return T(0.0001); }
  41.         static T Epsilon2()             { return T(0.000001); }
  42.         static T Sqrt2()                { return T(1.4142135623730950488016887242097); }
  43.         static T Sqrt2Inv()             { return T(0.70710678118654752440084436210485); }
  45.         // Funkce
  46.         static T Sin(T f)               { return T(sin(f)); }
  47.         static T SinDeg(T f)            { return Sin(f*Rad()); }
  48.         static T Asin(T f)              { return T(asin(f)); }
  49.         static T Cos(T f)               { return T(cos(f)); }
  50.         static T CosDeg(T f)            { return Cos(f*Rad()); }
  51.         static T Acos(T f)              { return (f > 1)? 0 : (f < -1)? Pi() : T(acos(f)); }
  52.         static T Tan(T f)               { return T(tan(f)); }
  53.         static T TanDeg(T f)            { return Tan(f*Rad()); }
  54.         static T Atan(T f)              { return T(atan(f)); }
  55.         static T Cotan(T f)             { return 1 / Tan(f); }
  56.         static T CotanDeg(T f)          { return Cotan(f*Rad()); }
  57.         static T Atan2(T f, T g)        { return T(atan2(f, g)); }
  59.         static T Sqr(T f)               { return f*f; }
  60.         static T Sqrt(T f)              { return T(sqrt(f)); }
  61.         static T Cube(T f)              { return f*f*f; }
  63.         static T Abs(T f)               { return fabs(f); }
  64.         static T Min(T f, T g)          { return (f < g)? f : g; }
  65.         static T Max(T f, T g)          { return (f > g)? f : g; }
  66.         static T Clamp(T f, T min, T max) { return Min(Max(f, min), max); }
  67.         static T Saturate(T f)          { return Clamp(f, 0, 1); }
  68.         static T Sign(T f)              { return f < 0 ? -1 : (f > 0 ?  1 : 0); }
  70.         static T Floor(T f)             { return T(floor(f)); }
  71.         static T Ceil(T f)              { return T(ceil(f)); }
  72.         static T Round(T f)             { return Floor(f + T(0.5)); }
  73.         static T Frac(T f)              { return T(fmod(f, 1)); }
  75.         static bool SafeIsZero(T f)     { return f < Epsilon() && f > -Epsilon(); }
  76.         static bool SafeIsEqual(T f, T g) { return f < g+Epsilon() && f > g-Epsilon(); }
  78.         static T Discriminant(T a, T b, T c) { return b*b - 4*a*c; }
  79.         static T QuadraticEquationRoot(T a, T b, T d, T sign) { return (-b + sign * Sqrt(d)) / (2*a); }
  81.         static float RsqrtApprox(float a)
  82.         {
  83.             return union_cast<float>(0x5f3759df - (union_cast<int32>(a) >> 1));
  84.         }
  86.         // Commented out because it's too slow and doesn't give us any advantage over standard 1/sqrt
  87.         // Isn't the 64bit integer arithmetic little sluggish on 32bit architecture?
  88.         /*inline double RsqrtApprox(double a)
  89.         {
  90.             return union_cast<double>(0x5fe6ec85e7de30daLL - (union_cast<int64>(a) >> 1));
  91.         }*/
  93. #if 1
  94.         // 1 / Sqrt(f).
  95.         static T Rsqrt(T a)
  96.         {
  97.             return 1 / Sqrt(a);
  98.         }
  99. #else
  100.         // Fast approximation of 1 / Sqrt(f).
  101.         static T Rsqrt(T a, int iterations = 4)
  102.         {
  103.             T g = T(RsqrtApprox(float(a)));
  105.             // Improve the accuracy using Newton's method
  106.             T halfa = T(0.5) * a;
  107.             for (int i = 0; i < iterations; i++)
  108.                 g *= T(1.5) - halfa*g*g;
  110.             return g;
  111.         }
  112. #endif
  113.     };
  115.     typedef Math<float> Mathf;
  116.     typedef Math<double> Mathd;
  117.     typedef Math<int32> Mathi;
  118. }