def test24_log(m):
x = ek.linspace(m.Float, 0.01, 1, 10)
ek.enable_grad(x)
y = ek.log(x * x)
ek.backward(y)
log_x = ek.log(ek.sqr(ek.detach(x)))
assert ek.allclose(y, log_x)
assert ek.allclose(ek.grad(x), 2 / ek.detach(x))
def log_(a0):
if not a0.IsFloat:
raise Exception("log(): requires floating point operands!")
ar, sr = _check1(a0)
if not a0.IsSpecial:
for i in range(sr):
ar[i] = _ek.log(a0[i])
elif a0.IsComplex:
ar.real = .5 * _ek.log(_ek.squared_norm(a0))
ar.imag = _ek.arg(a0)
elif a0.IsQuaternion:
qi_n = _ek.normalize(a0.imag)
rq = _ek.norm(a0)
acos_rq = _ek.acos(a0.real / rq)
log_rq = _ek.log(rq)
ar.imag = qi_n * acos_rq
ar.real = log_rq
else:
raise Exception("log(): unsupported array type!")
return ar
def atanh_(a0):
if not a0.IsFloat:
raise Exception("atanh(): requires floating point operands!")
ar, sr = _check1(a0)
if not a0.IsSpecial:
for i in range(sr):
ar[i] = _ek.atanh(a0[i])
elif a0.IsComplex:
return _ek.log((1 + a0) / (1 - a0)) * .5
else:
raise Exception("atanh(): unsupported array type!")
return ar
def acosh_(a0):
if not a0.IsFloat:
raise Exception("acosh(): requires floating point operands!")
ar, sr = _check1(a0)
if not a0.IsSpecial:
for i in range(sr):
ar[i] = _ek.acosh(a0[i])
elif a0.IsComplex:
return 2 * _ek.log(_ek.sqrt(.5 * (a0 + 1)) + _ek.sqrt(.5 * (a0 - 1)))
else:
raise Exception("acosh(): unsupported array type!")
return ar
def atan_(a0):
if not a0.IsFloat:
raise Exception("atan(): requires floating point operands!")
ar, sr = _check1(a0)
if not a0.IsSpecial:
for i in range(sr):
ar[i] = _ek.atan(a0[i])
elif a0.IsSpecial:
im = type(a0)(0, 1)
tmp = _ek.log((im - a0) / (im + a0))
return type(a0)(tmp.imag * .5, -tmp.real * 0.5)
else:
raise Exception("atan(): unsupported array type!")
return ar
def asin_(a0):
if not a0.IsFloat:
raise Exception("asin(): requires floating point operands!")
ar, sr = _check1(a0)
if not a0.IsSpecial:
for i in range(sr):
ar[i] = _ek.asin(a0[i])
elif a0.IsSpecial:
tmp = _ek.log(type(a0)(-a0.imag, a0.real) + _ek.sqrt(1 - _ek.sqr(a0)))
ar.real = tmp.imag
ar.imag = -tmp.real
else:
raise Exception("asin(): unsupported array type!")
return ar
def pow_(a0, a1):
if not a0.IsFloat:
raise Exception("pow(): requires floating point operands!")
if not a0.IsSpecial:
if isinstance(a1, int) or isinstance(a1, float):
ar, sr = _check1(a0)
for i in range(sr):
ar[i] = _ek.pow(a0[i], a1)
else:
ar, sr = _check2(a0, a1)
for i in range(sr):
ar[i] = _ek.pow(a0[i], a1[i])
else:
return _ek.exp(_ek.log(a0) * a1)
return ar
def test10_math_explog():
for i in range(-5, 5):
for j in range(-5, 5):
if i != 0 or j != 0:
a = ek.log(C(i, j))
b = C(cmath.log(complex(i, j)))
assert ek.allclose(a, b)
a = ek.log2(C(i, j))
b = C(cmath.log(complex(i, j)) / cmath.log(2))
assert ek.allclose(a, b)
a = ek.exp(C(i, j))
b = C(cmath.exp(complex(i, j)))
assert ek.allclose(a, b)
a = ek.exp2(C(i, j))
b = C(cmath.exp(complex(i, j) * cmath.log(2)))
assert ek.allclose(a, b)
a = ek.pow(C(2, 3), C(i, j))
b = C(complex(2, 3)**complex(i, j))
assert ek.allclose(a, b)
def rlgamma(a, x):
'Regularized lower incomplete gamma function based on CEPHES'
eps = 1e-15
big = 4.503599627370496e15
biginv = 2.22044604925031308085e-16
if a < 0 or x < 0:
raise "out of range"
if x == 0:
return 0
ax = (a * ek.log(x)) - x - ek.lgamma(a)
if ax < -709.78271289338399:
return 1.0 if a < x else 0.0
if x <= 1 or x <= a:
r2 = a
c2 = 1
ans2 = 1
while True:
r2 = r2 + 1
c2 = c2 * x / r2
ans2 += c2
if c2 / ans2 <= eps:
break
return ek.exp(ax) * ans2 / a
c = 0
y = 1 - a
z = x + y + 1
p3 = 1
q3 = x
p2 = x + 1
q2 = z * x
ans = p2 / q2
while True:
c += 1
y += 1
z += 2
yc = y * c
p = (p2 * z) - (p3 * yc)
q = (q2 * z) - (q3 * yc)
if q != 0:
nextans = p / q
error = ek.abs((ans - nextans) / nextans)
ans = nextans
else:
error = 1
p3 = p2
p2 = p
q3 = q2
q2 = q
# normalize fraction when the numerator becomes large
if ek.abs(p) > big:
p3 *= biginv
p2 *= biginv
q3 *= biginv
q2 *= biginv
if error <= eps:
break;
return 1 - ek.exp(ax) * ans
def reduced_albedo_to_effective_albedo(reduced_albedo):
return -ek.log(1.0 - reduced_albedo * (1.0 - ek.exp(-8.0))) / 8.0
def test06_log():
assert ek.allclose(ek.log(Q(1, 2, 3, 4)),
Q(0.200991, 0.401982, 0.602974, 1.7006))