implement Clausen functions with long double precision

src/Li1.cpp

@@ -32,6 +32,18 @@ double Cl1(double x)
    return std::real(Li1(std::exp(i*x)));
 }
 
+/**
+ * @brief Clausen function \f$\mathrm{Cl}_1(\theta) = \mathrm{Re}(\mathrm{Li}_1(e^{i\theta}))\f$ with long double precision
+ * @param x real angle
+ * @return \f$\mathrm{Cl}_1(\theta)\f$
+ */
+long double Cl1(long double x)
+{
+   const std::complex<long double> i(0.0L, 1.0L);
+
+   return std::real(Li1(std::exp(i*x)));
+}
+
 /**
  * @brief Real polylogarithm \f$\mathrm{Li}_1(x) = -\log(1-x)\f$
  * @param x real argument

src/Li1.hpp

@@ -13,6 +13,9 @@ namespace polylogarithm {
 /// Clausen function with n=1
 double Cl1(double);
 
+/// Clausen function with n=1 with long double precision
+long double Cl1(long double);
+
 /// real polylogarithm with n=1
 double Li1(double);
 

src/Li2.cpp

@@ -69,6 +69,33 @@ double Cl2(double x)
    return std::imag(Li2(std::exp(i*x)));
 }
 
+/**
+ * @brief Clausen function \f$\mathrm{Cl}_2(\theta) = \mathrm{Im}(\mathrm{Li}_2(e^{i\theta}))\f$ with long double precision
+ * @param x real angle
+ * @return \f$\mathrm{Cl}_2(\theta)\f$
+ */
+long double Cl2(long double x)
+{
+   const long double PI = 3.14159265358979323846264338327950288L;
+   const std::complex<long double> i(0.0L, 1.0L);
+
+   while (x >= 2*PI) {
+      x -= 2*PI;
+   }
+
+   while (x < 0.0L) {
+      x += 2*PI;
+   }
+
+   if (std::abs(x) < std::numeric_limits<long double>::epsilon() ||
+       std::abs(x - PI) < std::numeric_limits<long double>::epsilon() ||
+       std::abs(x - 2*PI) < std::numeric_limits<long double>::epsilon()) {
+      return 0.0L;
+   }
+
+   return std::imag(Li2(std::exp(i*x)));
+}
+
 /**
  * @brief Real dilogarithm \f$\mathrm{Li}_2(x)\f$
  * @param x real argument

src/Li2.hpp

@@ -13,16 +13,19 @@ namespace polylogarithm {
 /// Clausen function with n=2
 double Cl2(double);
 
+/// Clausen function with n=2 with long double precision
+long double Cl2(long double);
+
 /// real polylogarithm with n=2 (dilogarithm)
 double Li2(double);
 
-/// real polylogarithm with n=2 (dilogarithm)
+/// real polylogarithm with n=2 (dilogarithm) with long double precision
 long double Li2(long double);
 
 /// complex polylogarithm with n=2 (dilogarithm)
 std::complex<double> Li2(const std::complex<double>&);
 
-/// complex polylogarithm with n=2 (dilogarithm)
+/// complex polylogarithm with n=2 (dilogarithm) with long double precision
 std::complex<long double> Li2(const std::complex<long double>&);
 
 } // namespace polylogarithm

src/Li3.cpp

@@ -78,6 +78,27 @@ double Cl3(double x)
    return std::real(Li3(std::exp(i*x)));
 }
 
+/**
+ * @brief Clausen function \f$\mathrm{Cl}_3(\theta) = \mathrm{Re}(\mathrm{Li}_3(e^{i\theta}))\f$ with long double precision
+ * @param x real angle
+ * @return \f$\mathrm{Cl}_3(\theta)\f$
+ */
+long double Cl3(long double x)
+{
+   const long double PI = 3.14159265358979323846264338327950288L;
+   const std::complex<long double> i(0.0L, 1.0L);
+
+   while (x >= 2*PI) {
+      x -= 2*PI;
+   }
+
+   while (x < 0.0L) {
+      x += 2*PI;
+   }
+
+   return std::real(Li3(std::exp(i*x)));
+}
+
 /**
  * @brief Complex trilogarithm \f$\mathrm{Li}_3(z)\f$
  * @param z complex argument

src/Li3.hpp

@@ -13,10 +13,13 @@ namespace polylogarithm {
 /// Clausen function with n=3
 double Cl3(double);
 
+/// Clausen function with n=3 with long double precision
+long double Cl3(long double);
+
 /// complex polylogarithm with n=3 (trilogarithm)
 std::complex<double> Li3(const std::complex<double>&);
 
-/// complex polylogarithm with n=3 (trilogarithm)
+/// complex polylogarithm with n=3 (trilogarithm) with long double precision
 std::complex<long double> Li3(const std::complex<long double>&);
 
 } // namespace polylogarithm

src/Li4.cpp

@@ -83,6 +83,33 @@ double Cl4(double x)
    return std::imag(Li4(std::exp(i*x)));
 }
 
+/**
+ * @brief Clausen function \f$\mathrm{Cl}_4(\theta) = \mathrm{Im}(\mathrm{Li}_4(e^{i\theta}))\f$ with long double precision
+ * @param x real angle
+ * @return \f$\mathrm{Cl}_4(\theta)\f$
+ */
+long double Cl4(long double x)
+{
+   const long double PI = 3.14159265358979323846264338327950288L;
+   const std::complex<long double> i(0.0L, 1.0L);
+
+   while (x >= 2*PI) {
+      x -= 2*PI;
+   }
+
+   while (x < 0.0L) {
+      x += 2*PI;
+   }
+
+   if (std::abs(x) < std::numeric_limits<long double>::epsilon() ||
+       std::abs(x - PI) < std::numeric_limits<long double>::epsilon() ||
+       std::abs(x - 2*PI) < std::numeric_limits<long double>::epsilon()) {
+      return 0.0L;
+   }
+
+   return std::imag(Li4(std::exp(i*x)));
+}
+
 /**
  * @brief Complex polylogarithm \f$\mathrm{Li}_4(z)\f$
  * @param z complex argument

src/Li4.hpp

@@ -13,6 +13,9 @@ namespace polylogarithm {
 /// Clausen function with n=4
 double Cl4(double);
 
+/// Clausen function with n=4 with long double precision
+long double Cl4(long double);
+
 /// complex polylogarithm with n=4
 std::complex<double> Li4(const std::complex<double>&);
 

src/Li5.cpp

@@ -77,6 +77,27 @@ double Cl5(double x)
    return std::real(Li5(std::exp(i*x)));
 }
 
+/**
+ * @brief Clausen function \f$\mathrm{Cl}_5(\theta) = \mathrm{Re}(\mathrm{Li}_5(e^{i\theta}))\f$ with long double precision
+ * @param x real angle
+ * @return \f$\mathrm{Cl}_5(\theta)\f$
+ */
+long double Cl5(long double x)
+{
+   const long double PI = 3.14159265358979323846264338327950288L;
+   const std::complex<long double> i(0.0L, 1.0L);
+
+   while (x >= 2*PI) {
+      x -= 2*PI;
+   }
+
+   while (x < 0.0L) {
+      x += 2*PI;
+   }
+
+   return std::real(Li5(std::exp(i*x)));
+}
+
 /**
  * @brief Complex polylogarithm \f$\mathrm{Li}_5(z)\f$
  * @param z complex argument

src/Li5.hpp

@@ -13,6 +13,9 @@ namespace polylogarithm {
 /// Clausen function with n=5
 double Cl5(double);
 
+/// Clausen function with n=5 with long double precision
+long double Cl5(long double);
+
 /// complex polylogarithm with n=5
 std::complex<double> Li5(const std::complex<double>&);
 

src/Li6.cpp

@@ -83,6 +83,33 @@ double Cl6(double x)
    return std::imag(Li6(std::exp(i*x)));
 }
 
+/**
+ * @brief Clausen function \f$\mathrm{Cl}_6(\theta) = \mathrm{Im}(\mathrm{Li}_6(e^{i\theta}))\f$ with long double precision
+ * @param x real angle
+ * @return \f$\mathrm{Cl}_6(\theta)\f$
+ */
+long double Cl6(long double x)
+{
+   const long double PI = 3.14159265358979323846264338327950288L;
+   const std::complex<long double> i(0.0L, 1.0L);
+
+   while (x >= 2*PI) {
+      x -= 2*PI;
+   }
+
+   while (x < 0.0L) {
+      x += 2*PI;
+   }
+
+   if (std::abs(x) < std::numeric_limits<long double>::epsilon() ||
+       std::abs(x - PI) < std::numeric_limits<long double>::epsilon() ||
+       std::abs(x - 2*PI) < std::numeric_limits<long double>::epsilon()) {
+      return 0.0L;
+   }
+
+   return std::imag(Li6(std::exp(i*x)));
+}
+
 /**
  * @brief Complex polylogarithm \f$\mathrm{Li}_6(z)\f$
  * @param z complex argument

src/Li6.hpp

@@ -13,6 +13,9 @@ namespace polylogarithm {
 /// Clausen function with n=6
 double Cl6(double);
 
+/// Clausen function with n=6 with long double precision
+long double Cl6(long double);
+
 /// complex polylogarithm with n=5
 std::complex<double> Li6(const std::complex<double>&);