protected override ScalarValue GetValue(ScalarValue value)
{
return(value.Log(2.0));
}
static ScalarValue GetValue(ScalarValue value, Double newBase)
{
return value.Log(newBase);
}
public static ScalarValue Polylog(int n, ScalarValue z)
{
if (n == 2)
return SpenceFunction.DiLog(z);
if (n == -1)
return PolylogNeg1(z);
if (n == 0)
return PolylogZero(z);
if (n == 1)
return PolylogPos1(z);
if (n == -2)
return PolylogNeg2(z);
if (n == -3)
return PolylogNeg3(z);
if (n == -4)
return PolylogNeg4(z);
if (n < -4)
return PolylogNegative(n, z);
if (z == ScalarValue.One && n > 1)
return PolylogZetaPositive(n);
if (-z == ScalarValue.One && n > 1)
return PolylogZetaNegative(n);
/* This recurrence provides formulas for n < 2.
*
* d 1
* -- Li (x) = --- Li (x) .
* dx n x n-1
*
*/
var s = ScalarValue.Zero;
var ah = Math.Abs(z.Re) + Math.Abs(z.Im);
int i, j;
if (ah > 3.0)
return PolylogInversion(n, z);
else if (ah >= 0.75)
{
var ad = 0.0;
var x = z.Log();
var h = -((-x).Log());
for (i = 1; i < n; i++)
h += 1.0 / i;
var p = ScalarValue.One;
s = PolylogZetaPositive(n);
for (j = 1; j <= n + 1; j++)
{
p = p * x / j;
if (j == n - 1)
s += h * p;
else
s += PolylogZetaPositive(n - j) * p;
}
j = n + 3;
x = x * x;
for (; ; )
{
p = p * x / ((j - 1) * j);
h = PolylogZetaPositive(n - j);
h = h * p;
s += h;
ah = Math.Abs(h.Re) + Math.Abs(h.Im);
ad = Math.Abs(s.Re) + Math.Abs(s.Im);
if (ah < ad * double.Epsilon)
break;
j += 2;
}
return s;
}
else if(ah >= 1e-6)
{
var p = z * z * z;
var ad = 0.0;
var k = 3.0;
var h = ScalarValue.Zero;
do
{
p = p * z;
k += 1.0;
h = p / Math.Pow(k, n);
s += h;
ah = Math.Abs(h.Re) + Math.Abs(h.Im);
ad = Math.Abs(s.Re) + Math.Abs(s.Im);
}
while (ah > ad * 1.1e-16);
}
s += z * z * z / Math.Pow(3.0, n);
s += z * z / Math.Pow(2.0, n);
return s + z;
}
ScalarValue GetValue(ScalarValue value, double newBase)
{
return(value.Log(newBase));
}
