/src/muparser/include/muParserTemplateMagic.h

Source
/*

   _____  __ _____________ _______  ______ ___________
  /     \|  |  \____ \__  \\_  __ \/  ___// __ \_  __ \
   |  Y Y  \  |  /  |_> > __ \|  | \/\___ \\  ___/|  | \/
   |__|_|  /____/|   __(____  /__|  /____  >\___  >__|
     \/      |__|       \/           \/     \/
   Copyright (C) 2004 - 2026 Ingo Berg

  Redistribution and use in source and binary forms, with or without modification, are permitted
  provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this list of
    conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of
    conditions and the following disclaimer in the documentation and/or other materials provided
    with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef MU_PARSER_TEMPLATE_MAGIC_H
#define MU_PARSER_TEMPLATE_MAGIC_H

#include <algorithm>
#include <random>
#include <cmath>
#include "muParserError.h"


namespace mu
{
  //-----------------------------------------------------------------------------------------------
  //
  // Compile time type detection
  //
  //-----------------------------------------------------------------------------------------------

  /** \brief A class singling out integer types at compile time using
         template meta programming.
  */
  template<typename T>
  struct TypeInfo
  {
    static bool IsInteger() { return false; }
  };

  template<>
  struct TypeInfo<char>
  {
    static bool IsInteger() { return true; }
  };

  template<>
  struct TypeInfo<short>
  {
    static bool IsInteger() { return true; }
  };

  template<>
  struct TypeInfo<int>
  {
    static bool IsInteger() { return true; }
  };

  template<>
  struct TypeInfo<long>
  {
    static bool IsInteger() { return true; }
  };

  template<>
  struct TypeInfo<unsigned char>
  {
    static bool IsInteger() { return true; }
  };

  template<>
  struct TypeInfo<unsigned short>
  {
    static bool IsInteger() { return true; }
  };

  template<>
  struct TypeInfo<unsigned int>
  {
    static bool IsInteger() { return true; }
  };

  template<>
  struct TypeInfo<unsigned long>
  {
    static bool IsInteger() { return true; }
  };


  //-----------------------------------------------------------------------------------------------
  //
  // Standard math functions with dummy overload for integer types
  //
  //-----------------------------------------------------------------------------------------------

  /** \brief A template class for providing wrappers for essential math functions.

    This template is spezialized for several types in order to provide a unified interface
    for parser internal math function calls regardless of the data type.
  */
  template<typename T>
  struct MathImpl
  {
    static T Sin(T v) { return sin(v); }
    static T Cos(T v) { return cos(v); }
    static T Tan(T v) { return tan(v); }
    static T Cot(T v) { return 1.0 / tan(v); }
    static T ASin(T v) { return asin(v); }
    static T ACos(T v) { return acos(v); }
    static T ATan(T v) { return atan(v); }
    static T ATan2(T v1, T v2) { return atan2(v1, v2); }
    static T Sinh(T v) { return sinh(v); }
    static T Cosh(T v) { return cosh(v); }
    static T Tanh(T v) { return tanh(v); }
    static T Coth(T v) { return 1.0 / tanh(v); }
    static T ASinh(T v) { return log(v + sqrt(v * v + 1)); }
    static T ACosh(T v) { return log(v + sqrt(v * v - 1)); }
    static T ATanh(T v) { return ((T)0.5 * log((1 + v) / (1 - v))); }
    static T Log(T v) { return log(v); }
    static T Log2(T v) { return log(v) / log((T)2); } // Logarithm base 2
    static T Log10(T v) { return log10(v); }         // Logarithm base 10
    static T Exp(T v) { return exp(v); }
    static T Abs(T v) { return (v >= 0) ? v : -v; }
    static T Sqrt(T v) { return sqrt(v); }
    static T Rint(T v) { return floor(v + (T)0.5); }
    static T Sign(T v) { return (T)((v < 0) ? -1 : (v > 0) ? 1 : 0); }
    static T Pow(T v1, T v2) { return std::pow(v1, v2); }
    static T Rnd()
    {
      static std::random_device rd;  
      static std::mt19937 gen(rd()); 
      static std::uniform_real_distribution<T> dis(0.0, 1.0); // Range [0, 1)

      return dis(gen);
    }

    static T UnaryMinus(T v) { return -v; }
    static T UnaryPlus(T v) { return v; }

    static T Sum(const T *a_afArg, int a_iArgc)
    {
      if (!a_iArgc)
        throw ParserError(_T("too few arguments for function sum."));

      T fRes = 0;
      for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i];
      return fRes;
    }

    static T Avg(const T *a_afArg, int a_iArgc)
    {
      if (!a_iArgc)
        throw ParserError(_T("too few arguments for function avg."));

      T fRes = 0;
      for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i];
      return fRes / (T)a_iArgc;
    }

    static T Min(const T *a_afArg, int a_iArgc)
    {
      if (!a_iArgc)
        throw ParserError(_T("too few arguments for function min."));

      T fRes = a_afArg[0];
      for (int i = 0; i < a_iArgc; ++i)
        fRes = std::min(fRes, a_afArg[i]);

      return fRes;
    }

    static T Max(const T *a_afArg, int a_iArgc)
    {
      if (!a_iArgc)
        throw ParserError(_T("too few arguments for function max."));

      T fRes = a_afArg[0];
      for (int i = 0; i < a_iArgc; ++i) fRes = std::max(fRes, a_afArg[i]);

      return fRes;
    }


#if defined (__GNUG__)
    // Bei zu genauer definition von pi kann die Berechnung von
    // sin(pi*a) mit a=1 10 x langsamer sein! 
    static constexpr T CONST_PI = (T)3.141592653589;
#else
    static constexpr T CONST_PI = (T)3.141592653589793238462643;
#endif

    static constexpr T CONST_E = (T)2.718281828459045235360287;
  };
}

#endif

Coverage Report

Created: 2026-09-01 07:04

Line	Count	Source
1		/*
2
3		_____ __ _____________ _______ ______ ___________
4		/ \\| \| \____ \__ \\_ __ \/ ___// __ \_ __ \
5		\| Y Y \ \| / \|_> > __ \\| \| \/\___ \\ ___/\| \| \/
6		\|__\|_\| /____/\| __(____ /__\| /____ >\___ >__\|
7		\/ \|__\| \/ \/ \/
8		Copyright (C) 2004 - 2026 Ingo Berg
9
10		Redistribution and use in source and binary forms, with or without modification, are permitted
11		provided that the following conditions are met:
12
13		* Redistributions of source code must retain the above copyright notice, this list of
14		conditions and the following disclaimer.
15		* Redistributions in binary form must reproduce the above copyright notice, this list of
16		conditions and the following disclaimer in the documentation and/or other materials provided
17		with the distribution.
18
19		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
20		IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
21		FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
22		CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24		DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25		IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
26		OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27		*/
28
29		#ifndef MU_PARSER_TEMPLATE_MAGIC_H
30		#define MU_PARSER_TEMPLATE_MAGIC_H
31
32		#include <algorithm>
33		#include <random>
34		#include <cmath>
35		#include "muParserError.h"
36
37
38		namespace mu
39		{
40		//-----------------------------------------------------------------------------------------------
41		//
42		// Compile time type detection
43		//
44		//-----------------------------------------------------------------------------------------------
45
46		/** \brief A class singling out integer types at compile time using
47		template meta programming.
48		*/
49		template<typename T>
50		struct TypeInfo
51		{
52	3.84k	static bool IsInteger() { return false; }
53		};
54
55		template<>
56		struct TypeInfo<char>
57		{
58	0	static bool IsInteger() { return true; }
59		};
60
61		template<>
62		struct TypeInfo<short>
63		{
64	0	static bool IsInteger() { return true; }
65		};
66
67		template<>
68		struct TypeInfo<int>
69		{
70	0	static bool IsInteger() { return true; }
71		};
72
73		template<>
74		struct TypeInfo<long>
75		{
76	0	static bool IsInteger() { return true; }
77		};
78
79		template<>
80		struct TypeInfo<unsigned char>
81		{
82	0	static bool IsInteger() { return true; }
83		};
84
85		template<>
86		struct TypeInfo<unsigned short>
87		{
88	0	static bool IsInteger() { return true; }
89		};
90
91		template<>
92		struct TypeInfo<unsigned int>
93		{
94	0	static bool IsInteger() { return true; }
95		};
96
97		template<>
98		struct TypeInfo<unsigned long>
99		{
100	0	static bool IsInteger() { return true; }
101		};
102
103
104		//-----------------------------------------------------------------------------------------------
105		//
106		// Standard math functions with dummy overload for integer types
107		//
108		//-----------------------------------------------------------------------------------------------
109
110		/** \brief A template class for providing wrappers for essential math functions.
111
112		This template is spezialized for several types in order to provide a unified interface
113		for parser internal math function calls regardless of the data type.
114		*/
115		template<typename T>
116		struct MathImpl
117		{
118	203	static T Sin(T v) { return sin(v); }
119	200	static T Cos(T v) { return cos(v); }
120	241	static T Tan(T v) { return tan(v); }
121	197	static T Cot(T v) { return 1.0 / tan(v); }
122	196	static T ASin(T v) { return asin(v); }
123	195	static T ACos(T v) { return acos(v); }
124	196	static T ATan(T v) { return atan(v); }
125	437	static T ATan2(T v1, T v2) { return atan2(v1, v2); }
126	229	static T Sinh(T v) { return sinh(v); }
127	195	static T Cosh(T v) { return cosh(v); }
128	201	static T Tanh(T v) { return tanh(v); }
129	195	static T Coth(T v) { return 1.0 / tanh(v); }
130	195	static T ASinh(T v) { return log(v + sqrt(v * v + 1)); }
131	195	static T ACosh(T v) { return log(v + sqrt(v * v - 1)); }
132	213	static T ATanh(T v) { return ((T)0.5 * log((1 + v) / (1 - v))); }
133	538	static T Log(T v) { return log(v); }
134	198	static T Log2(T v) { return log(v) / log((T)2); } // Logarithm base 2
135	329	static T Log10(T v) { return log10(v); } // Logarithm base 10
136	195	static T Exp(T v) { return exp(v); }
137	462	static T Abs(T v) { return (v >= 0) ? v : -v; }
138	196	static T Sqrt(T v) { return sqrt(v); }
139	359	static T Rint(T v) { return floor(v + (T)0.5); }
140	392	static T Sign(T v) { return (T)((v < 0) ? -1 : (v > 0) ? 1 : 0); }
141	98.5k	static T Pow(T v1, T v2) { return std::pow(v1, v2); }
142		static T Rnd()
143	888	{
144	888	static std::random_device rd;
145	888	static std::mt19937 gen(rd());
146	888	static std::uniform_real_distribution<T> dis(0.0, 1.0); // Range [0, 1)
147
148	888	return dis(gen);
149	888	}
150
151	4.99k	static T UnaryMinus(T v) { return -v; }
152	0	static T UnaryPlus(T v) { return v; }
153
154		static T Sum(const T *a_afArg, int a_iArgc)
155	702	{
156	702	if (!a_iArgc)
157	0	throw ParserError(_T("too few arguments for function sum."));
158
159	702	T fRes = 0;
160	115k	for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i];
161	702	return fRes;
162	702	}
163
164		static T Avg(const T *a_afArg, int a_iArgc)
165	714	{
166	714	if (!a_iArgc)
167	0	throw ParserError(_T("too few arguments for function avg."));
168
169	714	T fRes = 0;
170	77.2k	for (int i = 0; i < a_iArgc; ++i) fRes += a_afArg[i];
171	714	return fRes / (T)a_iArgc;
172	714	}
173
174		static T Min(const T *a_afArg, int a_iArgc)
175	1.09k	{
176	1.09k	if (!a_iArgc)
177	0	throw ParserError(_T("too few arguments for function min."));
178
179	1.09k	T fRes = a_afArg[0];
180	56.1k	for (int i = 0; i < a_iArgc; ++i)
181	55.0k	fRes = std::min(fRes, a_afArg[i]);
182
183	1.09k	return fRes;
184	1.09k	}
185
186		static T Max(const T *a_afArg, int a_iArgc)
187	1.24k	{
188	1.24k	if (!a_iArgc)
189	0	throw ParserError(_T("too few arguments for function max."));
190
191	1.24k	T fRes = a_afArg[0];
192	80.8k	for (int i = 0; i < a_iArgc; ++i) fRes = std::max(fRes, a_afArg[i]);
193
194	1.24k	return fRes;
195	1.24k	}
196
197
198		#if defined (__GNUG__)
199		// Bei zu genauer definition von pi kann die Berechnung von
200		// sin(pi*a) mit a=1 10 x langsamer sein!
201		static constexpr T CONST_PI = (T)3.141592653589;
202		#else
203		static constexpr T CONST_PI = (T)3.141592653589793238462643;
204		#endif
205
206		static constexpr T CONST_E = (T)2.718281828459045235360287;
207		};
208		}
209
210		#endif