From 41d3585e278e271d5f30a75a201ea4d337438011 Mon Sep 17 00:00:00 2001
From: Martin Reinecke <martin@mpa-garching.mpg.de>
Date: Tue, 30 Jan 2018 21:16:32 +0100
Subject: [PATCH] PEP8 work, revert some overly strict PEP8
---
nifty4/__init__.py | 16 ++++++++--------
nifty4/library/critical_power_curvature.py | 2 +-
nifty4/library/critical_power_energy.py | 10 +++++-----
.../log_normal_wiener_filter_curvature.py | 5 ++---
.../library/log_normal_wiener_filter_energy.py | 7 +++----
nifty4/library/noise_energy.py | 6 +++---
nifty4/library/nonlinear_power_curvature.py | 4 ++--
nifty4/library/response_operators.py | 8 ++++----
nifty4/library/wiener_filter_curvature.py | 9 ++++-----
nifty4/library/wiener_filter_energy.py | 3 +--
nifty4/operators/scaling_operator.py | 4 ++--
nifty4/plotting/plot.py | 6 +++---
nifty4/sugar.py | 16 ++++++++++++++++
test/test_energies/test_map.py | 6 ++++--
test/test_energies/test_power.py | 3 ++-
test/test_minimization/test_minimizers.py | 5 +++--
test/test_operators/test_adjoint.py | 1 +
test/test_operators/test_fft_operator.py | 4 +---
18 files changed, 65 insertions(+), 50 deletions(-)
diff --git a/nifty4/__init__.py b/nifty4/__init__.py
index b2d198f9f..2524edd7f 100644
--- a/nifty4/__init__.py
+++ b/nifty4/__init__.py
@@ -55,11 +55,11 @@ from .sugar import *
from .plotting.plot import plot
from . import library
-__all__= ["DomainObject", "FieldArray", "Space", "RGSpace", "LMSpace",
- "HPSpace", "GLSpace", "DOFSpace", "PowerSpace", "DomainTuple",
- "LinearOperator", "EndomorphicOperator", "ScalingOperator",
- "DiagonalOperator", "FFTOperator", "FFTSmoothingOperator",
- "DirectSmoothingOperator", "ResponseOperator", "LaplaceOperator",
- "PowerProjectionOperator", "InversionEnabler",
- "Field", "sqrt", "exp", "log",
- "Prober", "DiagonalProberMixin", "TraceProberMixin"]
+__all__ = ["DomainObject", "FieldArray", "Space", "RGSpace", "LMSpace",
+ "HPSpace", "GLSpace", "DOFSpace", "PowerSpace", "DomainTuple",
+ "LinearOperator", "EndomorphicOperator", "ScalingOperator",
+ "DiagonalOperator", "FFTOperator", "FFTSmoothingOperator",
+ "DirectSmoothingOperator", "ResponseOperator", "LaplaceOperator",
+ "PowerProjectionOperator", "InversionEnabler",
+ "Field", "sqrt", "exp", "log",
+ "Prober", "DiagonalProberMixin", "TraceProberMixin"]
diff --git a/nifty4/library/critical_power_curvature.py b/nifty4/library/critical_power_curvature.py
index f8cff9f2f..8e4d16e21 100644
--- a/nifty4/library/critical_power_curvature.py
+++ b/nifty4/library/critical_power_curvature.py
@@ -22,4 +22,4 @@ from ..operators.diagonal_operator import DiagonalOperator
def CriticalPowerCurvature(theta, T, inverter):
theta = DiagonalOperator(theta)
- return InversionEnabler(T + theta, inverter, theta.inverse_times)
+ return InversionEnabler(T+theta, inverter, theta.inverse_times)
diff --git a/nifty4/library/critical_power_energy.py b/nifty4/library/critical_power_energy.py
index d21ab497a..2f7f289ab 100644
--- a/nifty4/library/critical_power_energy.py
+++ b/nifty4/library/critical_power_energy.py
@@ -94,21 +94,21 @@ class CriticalPowerEnergy(Energy):
sample = self.D.generate_posterior_sample() + self.m
w += P(abs(sample)**2)
- w *= 1. / self.samples
+ w *= 1./self.samples
else:
w = P(abs(self.m)**2)
self._w = w
- self._theta = exp(-self.position) * (self.q + self._w * 0.5)
+ self._theta = exp(-self.position) * (self.q + self._w*0.5)
Tt = self.T(self.position)
energy = self._theta.sum()
- energy += self.position.sum() * (self.alpha - 0.5)
- energy += 0.5 * self.position.vdot(Tt)
+ energy += self.position.sum() * (self.alpha-0.5)
+ energy += 0.5*self.position.vdot(Tt)
self._value = energy.real
gradient = -self._theta
- gradient += self.alpha - 0.5
+ gradient += self.alpha-0.5
gradient += Tt
self._gradient = gradient
diff --git a/nifty4/library/log_normal_wiener_filter_curvature.py b/nifty4/library/log_normal_wiener_filter_curvature.py
index 395d3a5f9..a04badce2 100644
--- a/nifty4/library/log_normal_wiener_filter_curvature.py
+++ b/nifty4/library/log_normal_wiener_filter_curvature.py
@@ -20,7 +20,6 @@ from ..operators.inversion_enabler import InversionEnabler
def LogNormalWienerFilterCurvature(R, N, S, ht, expp_sspace, inverter):
- part1 = S.inverse
LinResp = R * ht.adjoint * expp_sspace * ht
- part3 = (LinResp.adjoint * N.inverse * LinResp)
- return InversionEnabler(part1 + part3, inverter)
+ t_op = LinResp.adjoint * N.inverse * LinResp
+ return InversionEnabler(S.inverse + t_op, inverter)
diff --git a/nifty4/library/log_normal_wiener_filter_energy.py b/nifty4/library/log_normal_wiener_filter_energy.py
index 539ae962c..0e5922b40 100644
--- a/nifty4/library/log_normal_wiener_filter_energy.py
+++ b/nifty4/library/log_normal_wiener_filter_energy.py
@@ -19,7 +19,7 @@
from ..minimization.energy import Energy
from ..utilities import memo
from .log_normal_wiener_filter_curvature import LogNormalWienerFilterCurvature
-from ..sugar import create_composed_fft_operator
+from ..sugar import create_composed_ht_operator
from ..field import exp
@@ -52,8 +52,7 @@ class LogNormalWienerFilterEnergy(Energy):
self._inverter = inverter
if ht is None:
- self._ht = create_composed_fft_operator(self.S.domain,
- all_to='position')
+ self._ht = create_composed_ht_operator(self.S.domain)
else:
self._ht = ht
@@ -63,7 +62,7 @@ class LogNormalWienerFilterEnergy(Energy):
expp = self._ht.adjoint_times(self._expp_sspace)
Rexppd = self.R(expp) - self.d
NRexppd = self.N.inverse_times(Rexppd)
- self._value = 0.5 * (self.position.vdot(Sp) + Rexppd.vdot(NRexppd))
+ self._value = 0.5*(self.position.vdot(Sp) + Rexppd.vdot(NRexppd))
exppRNRexppd = self._ht.adjoint_times(
self._expp_sspace * self._ht(self.R.adjoint_times(NRexppd)))
self._gradient = Sp + exppRNRexppd
diff --git a/nifty4/library/noise_energy.py b/nifty4/library/noise_energy.py
index f9a2ac014..2ea0bcb8d 100644
--- a/nifty4/library/noise_energy.py
+++ b/nifty4/library/noise_energy.py
@@ -51,7 +51,7 @@ class NoiseEnergy(Energy):
self.xi_sample_list = xi_sample_list
self.inverter = inverter
- A = Projection.adjoint_times(exp(.5 * self.t))
+ A = Projection.adjoint_times(exp(.5*self.t))
self._gradient = None
for sample in self.xi_sample_list:
@@ -60,7 +60,7 @@ class NoiseEnergy(Energy):
residual = self.d - \
self.Instrument(self.nonlinearity(map_s))
lh = .5 * residual.vdot(self.N.inverse_times(residual))
- grad = -.5 * self.N.inverse_times(residual.conjugate() * residual)
+ grad = -.5 * self.N.inverse_times(residual.conjugate()*residual)
if self._gradient is None:
self._value = lh
@@ -75,7 +75,7 @@ class NoiseEnergy(Energy):
self.q.vdot(exp(-self.position))
self._gradient *= 1. / len(self.xi_sample_list)
- self._gradient += (self.alpha - 0.5) - self.q * (exp(-self.position))
+ self._gradient += (self.alpha-0.5) - self.q*(exp(-self.position))
def at(self, position):
return self.__class__(
diff --git a/nifty4/library/nonlinear_power_curvature.py b/nifty4/library/nonlinear_power_curvature.py
index 80e109099..a5a885a4d 100644
--- a/nifty4/library/nonlinear_power_curvature.py
+++ b/nifty4/library/nonlinear_power_curvature.py
@@ -26,7 +26,7 @@ def NonlinearPowerCurvature(tau, ht, Instrument, nonlinearity, Projection, N,
for xi_sample in xi_sample_list:
LinearizedResponse = LinearizedPowerResponse(
Instrument, nonlinearity, ht, Projection, tau, xi_sample)
- op = LinearizedResponse.adjoint * N.inverse * LinearizedResponse
+ op = LinearizedResponse.adjoint*N.inverse*LinearizedResponse
result = op if result is None else result + op
- result = result * (1. / len(xi_sample_list)) + T
+ result = result * (1./len(xi_sample_list)) + T
return InversionEnabler(result, inverter)
diff --git a/nifty4/library/response_operators.py b/nifty4/library/response_operators.py
index 2027c5f01..ec7edfe78 100644
--- a/nifty4/library/response_operators.py
+++ b/nifty4/library/response_operators.py
@@ -20,11 +20,11 @@ from ..field import exp
def LinearizedSignalResponse(Instrument, nonlinearity, ht, power, m):
- return (Instrument * nonlinearity.derivative(m) * ht * power)
+ return Instrument * nonlinearity.derivative(m) * ht * power
def LinearizedPowerResponse(Instrument, nonlinearity, ht, Projection, tau, xi):
- power = exp(0.5 * tau)
- position = ht(Projection.adjoint_times(power) * xi)
+ power = exp(0.5*tau)
+ position = ht(Projection.adjoint_times(power)*xi)
linearization = nonlinearity.derivative(position)
- return (0.5 * Instrument * linearization * ht * xi * Projection.adjoint * power)
+ return 0.5*Instrument*linearization*ht*xi*Projection.adjoint*power
diff --git a/nifty4/library/wiener_filter_curvature.py b/nifty4/library/wiener_filter_curvature.py
index 4262b1359..32159966e 100644
--- a/nifty4/library/wiener_filter_curvature.py
+++ b/nifty4/library/wiener_filter_curvature.py
@@ -45,7 +45,7 @@ class WienerFilterCurvature(EndomorphicOperator):
self.R = R
self.N = N
self.S = S
- op = R.adjoint * N.inverse * R + S.inverse
+ op = R.adjoint*N.inverse*R + S.inverse
self._op = InversionEnabler(op, inverter, S.times)
@property
@@ -91,10 +91,9 @@ class WienerFilterCurvature(EndomorphicOperator):
def generate_posterior_sample2(self):
power = self.S.diagonal()
- mock_signal = Field.from_random(
- random_type="normal",
- domain=self.S.domain,
- dtype=power.dtype)
+ mock_signal = Field.from_random(random_type="normal",
+ domain=self.S.domain,
+ dtype=power.dtype)
mock_signal *= sqrt(power)
noise = self.N.diagonal()
diff --git a/nifty4/library/wiener_filter_energy.py b/nifty4/library/wiener_filter_energy.py
index 153fd4e1e..e8297a195 100644
--- a/nifty4/library/wiener_filter_energy.py
+++ b/nifty4/library/wiener_filter_energy.py
@@ -52,8 +52,7 @@ class WienerFilterEnergy(Energy):
_j = self.R.adjoint_times(self.N.inverse_times(d))
self._j = _j
Dx = self._curvature(self.position)
- self._value = 0.5 * \
- self.position.vdot(Dx) - self._j.vdot(self.position)
+ self._value = 0.5*self.position.vdot(Dx) - self._j.vdot(self.position)
self._gradient = Dx - self._j
def at(self, position):
diff --git a/nifty4/operators/scaling_operator.py b/nifty4/operators/scaling_operator.py
index 40d34530c..2e3b976a6 100644
--- a/nifty4/operators/scaling_operator.py
+++ b/nifty4/operators/scaling_operator.py
@@ -69,7 +69,7 @@ class ScalingOperator(EndomorphicOperator):
@property
def inverse(self):
- if self._factor!= 0.:
+ if self._factor != 0.:
return ScalingOperator(1./self._factor, self._domain)
from .inverse_operator import InverseOperator
return InverseOperator(self)
@@ -84,7 +84,7 @@ class ScalingOperator(EndomorphicOperator):
@property
def capability(self):
- if self._factor==0.:
+ if self._factor == 0.:
return self.TIMES | self.ADJOINT_TIMES
return (self.TIMES | self.ADJOINT_TIMES |
self.INVERSE_TIMES | self.ADJOINT_INVERSE_TIMES)
diff --git a/nifty4/plotting/plot.py b/nifty4/plotting/plot.py
index 75ed595cd..2d2ee9757 100644
--- a/nifty4/plotting/plot.py
+++ b/nifty4/plotting/plot.py
@@ -189,13 +189,13 @@ def plot(f, **kwargs):
if fld.domain != dom:
raise ValueError("domain mismatch")
if not (isinstance(dom[0], PowerSpace) or
- (isinstance(dom[0], RGSpace) and len(dom[0].shape)==1)):
+ (isinstance(dom[0], RGSpace) and len(dom[0].shape) == 1)):
raise ValueError("PowerSpace or 1D RGSpace required")
label = _get_kw("label", None, **kwargs)
if label is None:
label = [None] * len(f)
- if not isinstance (label, list):
+ if not isinstance(label, list):
label = [label]
dom = dom[0]
@@ -216,7 +216,7 @@ def plot(f, **kwargs):
xcoord = np.arange(npoints, dtype=np.float64)*dist
for i, fld in enumerate(f):
ycoord = dobj.to_global_data(fld.val)
- plt.plot(xcoord, ycoord,label=label[i])
+ plt.plot(xcoord, ycoord, label=label[i])
_limit_xy(**kwargs)
if label != ([None]*len(f)):
plt.legend()
diff --git a/nifty4/sugar.py b/nifty4/sugar.py
index c4550d0d2..05ae727f7 100644
--- a/nifty4/sugar.py
+++ b/nifty4/sugar.py
@@ -23,6 +23,7 @@ from .field import Field, sqrt
from .operators.diagonal_operator import DiagonalOperator
from .operators.power_projection_operator import PowerProjectionOperator
from .operators.fft_operator import FFTOperator
+from .operators.harmonic_transform_operator import HarmonicTransformOperator
from .domain_tuple import DomainTuple
from . import dobj, utilities
@@ -32,6 +33,7 @@ __all__ = ['PS_field',
'power_synthesize_nonrandom',
'create_power_field',
'create_power_operator',
+ 'create_composed_ht_operator',
'create_composed_fft_operator',
'create_harmonic_smoothing_operator']
@@ -241,6 +243,20 @@ def create_power_operator(domain, power_spectrum, space=None, dtype=None):
spaces=space)
+def create_composed_ht_operator(domain, codomain=None):
+ if codomain is None:
+ codomain = [None]*len(domain)
+ res = None
+ for i, space in enumerate(domain):
+ if isinstance(space, Space) and space.harmonic:
+ tdom = domain if res is None else res.target
+ op = HarmonicTransformOperator(tdom, codomain[i], i)
+ res = op if res is None else op*res
+ if res is None:
+ raise ValueError("empty operator")
+ return res
+
+
def create_composed_fft_operator(domain, codomain=None, all_to='other'):
if codomain is None:
codomain = [None]*len(domain)
diff --git a/test/test_energies/test_map.py b/test/test_energies/test_map.py
index 484a7a029..dfa0f81e7 100644
--- a/test/test_energies/test_map.py
+++ b/test/test_energies/test_map.py
@@ -147,7 +147,8 @@ class Energy_Tests(unittest.TestCase):
S = ift.create_power_operator(hspace, power_spectrum=_flat_PS)
energy0 = ift.library.NonlinearWienerFilterEnergy(
- position=xi0, d=d, Instrument=R, nonlinearity=f, ht=ht, power=A, N=N, S=S)
+ position=xi0, d=d, Instrument=R, nonlinearity=f, ht=ht, power=A,
+ N=N, S=S)
energy1 = energy0.at(xi1)
a = (energy1.value - energy0.value) / eps
@@ -204,7 +205,8 @@ class Curvature_Tests(unittest.TestCase):
@expand(product([ift.RGSpace(64, distances=.789),
ift.RGSpace([32, 32], distances=.789)],
- # Only linear case due to approximation of Hessian in the case of nontrivial nonlinearities.
+ # Only linear case due to approximation of Hessian in the
+ # case of nontrivial nonlinearities.
[ift.library.Linear],
[4, 78, 23]))
def testNonlinearMapCurvature(self, space, nonlinearity, seed):
diff --git a/test/test_energies/test_power.py b/test/test_energies/test_power.py
index 0a5a84e77..743b7281c 100644
--- a/test/test_energies/test_power.py
+++ b/test/test_energies/test_power.py
@@ -70,7 +70,8 @@ class Energy_Tests(unittest.TestCase):
inverter=inverter).curvature
energy0 = ift.library.CriticalPowerEnergy(
- position=tau0, m=s, inverter=inverter, D=D, samples=10, smoothness_prior=1.)
+ position=tau0, m=s, inverter=inverter, D=D, samples=10,
+ smoothness_prior=1.)
energy1 = energy0.at(tau1)
a = (energy1.value - energy0.value) / eps
diff --git a/test/test_minimization/test_minimizers.py b/test/test_minimization/test_minimizers.py
index 31460d292..aff783a63 100644
--- a/test/test_minimization/test_minimizers.py
+++ b/test/test_minimization/test_minimizers.py
@@ -41,7 +41,8 @@ class Test_Minimizers(unittest.TestCase):
covariance = ift.DiagonalOperator(covariance_diagonal)
required_result = ift.Field.ones(space, dtype=np.float64)
- IC = ift.GradientNormController(tol_abs_gradnorm=1e-5, iteration_limit=1000)
+ IC = ift.GradientNormController(tol_abs_gradnorm=1e-5,
+ iteration_limit=1000)
try:
minimizer = minimizer_class(controller=IC)
energy = ift.QuadraticEnergy(A=covariance, b=required_result,
@@ -57,4 +58,4 @@ class Test_Minimizers(unittest.TestCase):
rtol=1e-3, atol=1e-3)
-#MR FIXME: add Rosenbrock test
+# MR FIXME: add Rosenbrock test
diff --git a/test/test_operators/test_adjoint.py b/test/test_operators/test_adjoint.py
index af71fc24e..9472dbce3 100644
--- a/test/test_operators/test_adjoint.py
+++ b/test/test_operators/test_adjoint.py
@@ -39,6 +39,7 @@ def _check_adjointness(op, dtype=np.float64):
op.inverse_adjoint_times(f1).vdot(f2),
rtol=1e-8)
+
_h_RG_spaces = [ift.RGSpace(7, distances=0.2, harmonic=True),
ift.RGSpace((12, 46), distances=(.2, .3), harmonic=True)]
_h_spaces = _h_RG_spaces + [ift.LMSpace(17)]
diff --git a/test/test_operators/test_fft_operator.py b/test/test_operators/test_fft_operator.py
index 5f2f9f111..1eaa2cdf1 100644
--- a/test/test_operators/test_fft_operator.py
+++ b/test/test_operators/test_fft_operator.py
@@ -83,7 +83,6 @@ class FFTOperatorTests(unittest.TestCase):
assert_allclose(ift.dobj.to_global_data(inp.val),
ift.dobj.to_global_data(out.val), rtol=tol, atol=tol)
-
@expand(product([0, 1, 2],
[np.float64, np.float32, np.complex64, np.complex128]))
def test_composed_fft(self, index, dtype):
@@ -98,9 +97,8 @@ class FFTOperatorTests(unittest.TestCase):
assert_allclose(ift.dobj.to_global_data(inp.val),
ift.dobj.to_global_data(out.val), rtol=tol, atol=tol)
-
@expand(product([ift.RGSpace(128, distances=3.76, harmonic=True),
- ift.RGSpace((15,27), distances=(1.7,3.33), harmonic=True),
+ ift.RGSpace((15, 27), distances=(.7, .33), harmonic=True),
ift.RGSpace(73, distances=0.5643)],
[np.float64, np.float32, np.complex64, np.complex128]))
def test_normalisation(self, space, tp):
--
GitLab