def translate_from(self, src_expansion, src_coeff_exprs, src_rscale,
dvec, tgt_rscale):
if not isinstance(src_expansion, type(self)):
raise RuntimeError("do not know how to translate %s to %s"
% (type(src_expansion).__name__,
type(self).__name__))
if not self.use_rscale:
src_rscale = 1
tgt_rscale = 1
from sumpy.symbolic import sym_real_norm_2
dvec_len = sym_real_norm_2(dvec)
bessel_j = sym.Function("bessel_j")
new_center_angle_rel_old_center = sym.atan2(dvec[1], dvec[0])
arg_scale = self.get_bessel_arg_scaling()
translated_coeffs = []
for l in self.get_coefficient_identifiers():
translated_coeffs.append(
sum(src_coeff_exprs[src_expansion.get_storage_index(m)]
* bessel_j(m - l, arg_scale * dvec_len)
* src_rscale ** abs(m)
/ tgt_rscale ** abs(l)
* sym.exp(sym.I * (m - l) * new_center_angle_rel_old_center)
for m in src_expansion.get_coefficient_identifiers()))
return translated_coeffs
def translate_from(self, src_expansion, src_coeff_exprs, src_rscale,
dvec, tgt_rscale, sac=None):
if not isinstance(src_expansion, type(self)):
raise RuntimeError("do not know how to translate %s to %s"
% (type(src_expansion).__name__,
type(self).__name__))
if not self.use_rscale:
src_rscale = 1
tgt_rscale = 1
from sumpy.symbolic import sym_real_norm_2
dvec_len = sym_real_norm_2(dvec)
bessel_j = sym.Function("bessel_j")
new_center_angle_rel_old_center = sym.atan2(dvec[1], dvec[0])
arg_scale = self.get_bessel_arg_scaling()
translated_coeffs = []
for j in self.get_coefficient_identifiers():
translated_coeffs.append(
sum(src_coeff_exprs[src_expansion.get_storage_index(m)]
* bessel_j(m - j, arg_scale * dvec_len)
* src_rscale ** abs(m)
/ tgt_rscale ** abs(j)
* sym.exp(sym.I * (m - j) * new_center_angle_rel_old_center)
for m in src_expansion.get_coefficient_identifiers()))
return translated_coeffs
def test_subtraction_opt():
# Make sure subtraction is optimized.
e = (x - y)*(z - y) + exp((x - y)*(z - y))
substs, reduced = cse(
[e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
assert substs == [(x0, (x - y)*(y - z))]
assert reduced == [-x0 + exp(-x0)]
e = -(x - y)*(z - y) + exp(-(x - y)*(z - y))
substs, reduced = cse(
[e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
assert substs == [(x0, (x - y)*(y - z))]
assert reduced == [x0 + exp(x0)]
# issue 4077
n = -1 + 1/x
e = n/x/(-n)**2 - 1/n/x
assert cse(e, optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)]) == \
([], [0])
def test_subtraction_opt():
# Make sure subtraction is optimized.
e = (x - y)*(z - y) + exp((x - y)*(z - y))
substs, reduced = cse(
[e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
assert substs == [(x0, (x - y)*(y - z))]
assert reduced == [-x0 + exp(-x0)]
e = -(x - y)*(z - y) + exp(-(x - y)*(z - y))
substs, reduced = cse(
[e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
assert substs == [(x0, (x - y)*(y - z))]
assert reduced == [x0 + exp(x0)]
# issue 4077
n = -1 + 1/x
e = n/x/(-n)**2 - 1/n/x
assert cse(e, optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)]) == \
([], [0])
def test_pow_invpow():
assert cse(1/x**2 + x**2) == \
([(x0, x**2)], [x0 + 1/x0])
assert cse(x**2 + (1 + 1/x**2)/x**2) == \
([(x0, x**2), (x1, 1/x0)], [x0 + x1*(x1 + 1)])
assert cse(1/x**2 + (1 + 1/x**2)*x**2) == \
([(x0, x**2), (x1, 1/x0)], [x0*(x1 + 1) + x1])
assert cse(cos(1/x**2) + sin(1/x**2)) == \
([(x0, x**(-2))], [sin(x0) + cos(x0)])
assert cse(cos(x**2) + sin(x**2)) == \
([(x0, x**2)], [sin(x0) + cos(x0)])
assert cse(y/(2 + x**2) + z/x**2/y) == \
([(x0, x**2)], [y/(x0 + 2) + z/(x0*y)])
assert cse(exp(x**2) + x**2*cos(1/x**2)) == \
([(x0, x**2)], [x0*cos(1/x0) + exp(x0)])
assert cse((1 + 1/x**2)/x**2) == \
([(x0, x**(-2))], [x0*(x0 + 1)])
assert cse(x**(2*y) + x**(-2*y)) == \
([(x0, x**(2*y))], [x0 + 1/x0])
def test_pow_invpow():
assert cse(1/x**2 + x**2) == \
([(x0, x**2)], [x0 + 1/x0])
assert cse(x**2 + (1 + 1/x**2)/x**2) == \
([(x0, x**2), (x1, 1/x0)], [x0 + x1*(x1 + 1)])
assert cse(1/x**2 + (1 + 1/x**2)*x**2) == \
([(x0, x**2), (x1, 1/x0)], [x0*(x1 + 1) + x1])
assert cse(cos(1/x**2) + sin(1/x**2)) == \
([(x0, x**(-2))], [sin(x0) + cos(x0)])
assert cse(cos(x**2) + sin(x**2)) == \
([(x0, x**2)], [sin(x0) + cos(x0)])
assert cse(y/(2 + x**2) + z/x**2/y) == \
([(x0, x**2)], [y/(x0 + 2) + z/(x0*y)])
assert cse(exp(x**2) + x**2*cos(1/x**2)) == \
([(x0, x**2)], [x0*cos(1/x0) + exp(x0)])
assert cse((1 + 1/x**2)/x**2) == \
([(x0, x**(-2))], [x0*(x0 + 1)])
assert cse(x**(2*y) + x**(-2*y)) == \
([(x0, x**(2*y))], [x0 + 1/x0])
def translate_from(self, src_expansion, src_coeff_exprs, src_rscale, dvec,
tgt_rscale):
from sumpy.symbolic import sym_real_norm_2
if not self.use_rscale:
src_rscale = 1
tgt_rscale = 1
arg_scale = self.get_bessel_arg_scaling()
if isinstance(src_expansion, type(self)):
dvec_len = sym_real_norm_2(dvec)
bessel_j = sym.Function("bessel_j")
new_center_angle_rel_old_center = sym.atan2(dvec[1], dvec[0])
translated_coeffs = []
for l in self.get_coefficient_identifiers():
translated_coeffs.append(
sum(src_coeff_exprs[src_expansion.get_storage_index(m)] *
bessel_j(m - l, arg_scale * dvec_len) /
src_rscale**abs(m) * tgt_rscale**abs(l) *
sym.exp(sym.I *
(m - l) * -new_center_angle_rel_old_center)
for m in src_expansion.get_coefficient_identifiers()))
return translated_coeffs
if isinstance(src_expansion, self.mpole_expn_class):
dvec_len = sym_real_norm_2(dvec)
hankel_1 = sym.Function("hankel_1")
new_center_angle_rel_old_center = sym.atan2(dvec[1], dvec[0])
translated_coeffs = []
for l in self.get_coefficient_identifiers():
translated_coeffs.append(
sum((-1)**l * hankel_1(m + l, arg_scale * dvec_len) *
src_rscale**abs(m) * tgt_rscale**abs(l) *
sym.exp(sym.I *
(m + l) * new_center_angle_rel_old_center) *
src_coeff_exprs[src_expansion.get_storage_index(m)]
for m in src_expansion.get_coefficient_identifiers()))
return translated_coeffs
raise RuntimeError("do not know how to translate %s to %s" %
(type(src_expansion).__name__, type(self).__name__))
def evaluate(self, coeffs, bvec, rscale):
if not self.use_rscale:
rscale = 1
from sumpy.symbolic import sym_real_norm_2
bessel_j = sym.Function("bessel_j")
bvec_len = sym_real_norm_2(bvec)
target_angle_rel_center = sym.atan2(bvec[1], bvec[0])
arg_scale = self.get_bessel_arg_scaling()
return sum(coeffs[self.get_storage_index(l)] *
self.kernel.postprocess_at_target(
bessel_j(l, arg_scale * bvec_len) / rscale**abs(l) *
sym.exp(sym.I * l * -target_angle_rel_center), bvec)
for l in self.get_coefficient_identifiers())
def evaluate(self, coeffs, bvec, rscale, sac=None):
if not self.use_rscale:
rscale = 1
from sumpy.symbolic import sym_real_norm_2
hankel_1 = sym.Function("hankel_1")
bvec_len = sym_real_norm_2(bvec)
target_angle_rel_center = sym.atan2(bvec[1], bvec[0])
arg_scale = self.get_bessel_arg_scaling()
return sum(coeffs[self.get_storage_index(c)] *
self.kernel.postprocess_at_target(
hankel_1(c, arg_scale * bvec_len) * rscale**abs(c) *
sym.exp(sym.I * c * target_angle_rel_center), bvec)
for c in self.get_coefficient_identifiers())
def evaluate(self, coeffs, bvec, rscale):
if not self.use_rscale:
rscale = 1
from sumpy.symbolic import sym_real_norm_2
hankel_1 = sym.Function("hankel_1")
bvec_len = sym_real_norm_2(bvec)
target_angle_rel_center = sym.atan2(bvec[1], bvec[0])
arg_scale = self.get_bessel_arg_scaling()
return sum(coeffs[self.get_storage_index(l)]
* self.kernel.postprocess_at_target(
hankel_1(l, arg_scale * bvec_len)
* rscale ** abs(l)
* sym.exp(sym.I * l * target_angle_rel_center), bvec)
for l in self.get_coefficient_identifiers())
def coefficients_from_source(self, avec, bvec, rscale):
if not self.use_rscale:
rscale = 1
from sumpy.symbolic import sym_real_norm_2
hankel_1 = sym.Function("hankel_1")
arg_scale = self.get_bessel_arg_scaling()
# The coordinates are negated since avec points from source to center.
source_angle_rel_center = sym.atan2(-avec[1], -avec[0])
avec_len = sym_real_norm_2(avec)
return [self.kernel.postprocess_at_source(
hankel_1(l, arg_scale * avec_len)
* rscale ** abs(l)
* sym.exp(sym.I * l * source_angle_rel_center), avec)
for l in self.get_coefficient_identifiers()]
def coefficients_from_source(self, avec, bvec, rscale):
if not self.use_rscale:
rscale = 1
from sumpy.symbolic import sym_real_norm_2
hankel_1 = sym.Function("hankel_1")
arg_scale = self.get_bessel_arg_scaling()
# The coordinates are negated since avec points from source to center.
source_angle_rel_center = sym.atan2(-avec[1], -avec[0])
avec_len = sym_real_norm_2(avec)
return [
self.kernel.postprocess_at_source(
hankel_1(l, arg_scale * avec_len) * rscale**abs(l) *
sym.exp(sym.I * l * source_angle_rel_center), avec)
for l in self.get_coefficient_identifiers()
]
def coefficients_from_source(self, kernel, avec, bvec, rscale, sac=None):
if not self.use_rscale:
rscale = 1
if kernel is None:
kernel = self.kernel
from sumpy.symbolic import sym_real_norm_2
bessel_j = sym.Function("bessel_j")
avec_len = sym_real_norm_2(avec)
arg_scale = self.get_bessel_arg_scaling()
# The coordinates are negated since avec points from source to center.
source_angle_rel_center = sym.atan2(-avec[1], -avec[0])
return [
kernel.postprocess_at_source(
bessel_j(c, arg_scale * avec_len)
/ rscale ** abs(c)
* sym.exp(sym.I * c * -source_angle_rel_center),
avec)
for c in self.get_coefficient_identifiers()]
