diff --git a/nifty5/library/amplitude_model.py b/nifty5/library/amplitude_model.py
index 1e0b10dbc7537538eddd13dcb79ad1866e568209..55f31372b5fb3e2a2c94f8f26e80347ff6b025c2 100644
--- a/nifty5/library/amplitude_model.py
+++ b/nifty5/library/amplitude_model.py
@@ -106,23 +106,21 @@ class AmplitudeModel(Operator):
from ..operators.symmetrizing_operator import SymmetrizingOperator
h_space = s_space.get_default_codomain()
- p_space = PowerSpace(h_space)
- self._exp_transform = ExpTransform(p_space, Npixdof)
+ self._exp_transform = ExpTransform(PowerSpace(h_space), Npixdof)
logk_space = self._exp_transform.domain[0]
qht = QHTOperator(target=logk_space)
dof_space = qht.domain[0]
- param_space = UnstructuredDomain(2)
sym = SymmetrizingOperator(logk_space)
phi_mean = np.array([sm, im])
phi_sig = np.array([sv, iv])
- self._slope = SlopeOperator(param_space, logk_space, phi_sig)
- self._norm_phi_mean = Field.from_global_data(param_space,
+ self._slope = SlopeOperator(logk_space, phi_sig)
+ self._norm_phi_mean = Field.from_global_data(self._slope.domain,
phi_mean/phi_sig)
self._domain = MultiDomain.make({keys[0]: dof_space,
- keys[1]: param_space})
+ keys[1]: self._slope.domain})
self._target = self._exp_transform.target
kern = lambda k: _ceps_kernel(dof_space, k, ceps_a, ceps_k)
diff --git a/nifty5/operators/chain_operator.py b/nifty5/operators/chain_operator.py
index b25d8bc07d80cf8e10f8b7134b7e2db8e8f5261a..9ad77ce658bd79d29d899c89267888e92c8580fa 100644
--- a/nifty5/operators/chain_operator.py
+++ b/nifty5/operators/chain_operator.py
@@ -133,6 +133,9 @@ class ChainOperator(LinearOperator):
x = op.apply(x, mode)
return x
+ def __repr__(self):
+ subs = "\n".join(sub.__repr__() for sub in self._ops)
+ return "ChainOperator:\n" + utilities.indent(subs)
# def draw_sample(self, from_inverse=False, dtype=np.float64):
# from ..sugar import from_random
@@ -144,7 +147,3 @@ class ChainOperator(LinearOperator):
# for op in self._ops:
# samp = op.process_sample(samp, from_inverse)
# return samp
-
- def __repr__(self):
- subs = "\n".join(sub.__repr__() for sub in self._ops)
- return "ChainOperator:\n" + utilities.indent(subs)
diff --git a/nifty5/operators/exp_transform.py b/nifty5/operators/exp_transform.py
index 423cc840b64513ad8f7452acbdf8eac458052922..37d217359e7fb3bcdd15a4b7bdee8ba563d3ea10 100644
--- a/nifty5/operators/exp_transform.py
+++ b/nifty5/operators/exp_transform.py
@@ -108,6 +108,7 @@ class ExpTransform(LinearOperator):
v = x.val
ndim = len(self.target.shape)
curshp = list(self._dom(mode).shape)
+ tgtshp = self._tgt(mode).shape
d0 = self._target.axes[self._space][0]
for d in self._target.axes[self._space]:
idx = (slice(None),) * d
@@ -117,7 +118,7 @@ class ExpTransform(LinearOperator):
if mode == self.ADJOINT_TIMES:
shp = list(x.shape)
- shp[d] = self._tgt(mode).shape[d]
+ shp[d] = tgtshp[d]
xnew = np.zeros(shp, dtype=x.dtype)
xnew = special_add_at(xnew, d, self._bindex[d-d0], x*(1.-wgt))
xnew = special_add_at(xnew, d, self._bindex[d-d0]+1, x*wgt)
@@ -125,6 +126,6 @@ class ExpTransform(LinearOperator):
xnew = x[idx + (self._bindex[d-d0],)] * (1.-wgt)
xnew += x[idx + (self._bindex[d-d0]+1,)] * wgt
- curshp[d] = self._tgt(mode).shape[d]
+ curshp[d] = xnew.shape[d]
v = dobj.from_local_data(curshp, xnew, distaxis=dobj.distaxis(v))
return Field(self._tgt(mode), dobj.ensure_default_distributed(v))
diff --git a/nifty5/operators/field_zero_padder.py b/nifty5/operators/field_zero_padder.py
index f39cb28ae981e59a07fbdae78ea80e0b537738a4..0a0617d4106964035a4fad1b3e35f02b818623ab 100644
--- a/nifty5/operators/field_zero_padder.py
+++ b/nifty5/operators/field_zero_padder.py
@@ -1,3 +1,21 @@
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+# Copyright(C) 2013-2018 Max-Planck-Society
+#
+# NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik
+# and financially supported by the Studienstiftung des deutschen Volkes.
+
from __future__ import absolute_import, division, print_function
import numpy as np
@@ -11,9 +29,10 @@ from .linear_operator import LinearOperator
class FieldZeroPadder(LinearOperator):
- def __init__(self, domain, new_shape, space=0):
+ def __init__(self, domain, new_shape, space=0, central=False):
self._domain = DomainTuple.make(domain)
self._space = utilities.infer_space(self._domain, space)
+ self._central = central
dom = self._domain[self._space]
if not isinstance(dom, RGSpace):
raise TypeError("RGSpace required")
@@ -22,7 +41,7 @@ class FieldZeroPadder(LinearOperator):
if len(new_shape) != len(dom.shape):
raise ValueError("Shape mismatch")
- if any([a < b for a, b in zip(new_shape, dom.shape)]):
+ if any([a <= b for a, b in zip(new_shape, dom.shape)]):
raise ValueError("New shape must be larger than old shape")
self._target = list(self._domain)
self._target[self._space] = RGSpace(new_shape, dom.distances)
@@ -31,25 +50,48 @@ class FieldZeroPadder(LinearOperator):
def apply(self, x, mode):
self._check_input(x, mode)
- x = x.val
- dax = dobj.distaxis(x)
- shp_in = x.shape
- shp_out = self._tgt(mode).shape
- axbefore = self._target.axes[self._space][0]
- axes = self._target.axes[self._space]
- if dax in axes:
- x = dobj.redistribute(x, nodist=axes)
- curax = dobj.distaxis(x)
-
- if mode == self.ADJOINT_TIMES:
- newarr = np.empty(dobj.local_shape(shp_out, curax), dtype=x.dtype)
- sl = tuple(slice(0, shp_out[axis]) for axis in axes)
- newarr[()] = dobj.local_data(x)[(slice(None),)*axbefore + sl]
- else:
- newarr = np.zeros(dobj.local_shape(shp_out, curax), dtype=x.dtype)
- sl = tuple(slice(0, shp_in[axis]) for axis in axes)
- newarr[(slice(None),)*axbefore + sl] = dobj.local_data(x)
- newarr = dobj.from_local_data(shp_out, newarr, distaxis=curax)
- if dax in axes:
- newarr = dobj.redistribute(newarr, dist=dax)
- return Field(self._tgt(mode), val=newarr)
+ v = x.val
+ curshp = list(self._dom(mode).shape)
+ tgtshp = self._tgt(mode).shape
+ for d in self._target.axes[self._space]:
+ idx = (slice(None),) * d
+
+ v, x = dobj.ensure_not_distributed(v, (d,))
+
+ if mode == self.TIMES:
+ shp = list(x.shape)
+ shp[d] = tgtshp[d]
+ xnew = np.zeros(shp, dtype=x.dtype)
+ if self._central:
+ Nyquist = x.shape[d]//2
+ i1 = idx + (slice(0, Nyquist+1),)
+ xnew[i1] = x[i1]
+ i1 = idx + (slice(None, -(Nyquist+1), -1),)
+ xnew[i1] = x[i1]
+# if (x.shape[d] & 1) == 0: # even number of pixels
+# print (Nyquist, x.shape[d]-Nyquist)
+# i1 = idx+(Nyquist,)
+# xnew[i1] *= 0.5
+# i1 = idx+(-Nyquist,)
+# xnew[i1] *= 0.5
+ else:
+ xnew[idx + (slice(0, x.shape[d]),)] = x
+ else: # ADJOINT_TIMES
+ if self._central:
+ shp = list(x.shape)
+ shp[d] = tgtshp[d]
+ xnew = np.zeros(shp, dtype=x.dtype)
+ Nyquist = xnew.shape[d]//2
+ i1 = idx + (slice(0, Nyquist+1),)
+ xnew[i1] = x[i1]
+ i1 = idx + (slice(None, -(Nyquist+1), -1),)
+ xnew[i1] += x[i1]
+# if (xnew.shape[d] & 1) == 0: # even number of pixels
+# i1 = idx+(Nyquist,)
+# xnew[i1] *= 0.5
+ else:
+ xnew = x[idx + (slice(0, tgtshp[d]),)]
+
+ curshp[d] = xnew.shape[d]
+ v = dobj.from_local_data(curshp, xnew, distaxis=dobj.distaxis(v))
+ return Field(self._tgt(mode), dobj.ensure_default_distributed(v))
diff --git a/nifty5/operators/qht_operator.py b/nifty5/operators/qht_operator.py
index d224291cfca66fbc0ed5c440c359b7a7c217d485..8ee0c1a88a5964edb78ac162a8eb05823ec519a2 100644
--- a/nifty5/operators/qht_operator.py
+++ b/nifty5/operators/qht_operator.py
@@ -52,8 +52,7 @@ class QHTOperator(LinearOperator):
raise ValueError("target[space] has to be a LogRGSpace!")
if self._target[self._space].harmonic:
- raise TypeError(
- "target[space] must be a nonharmonic space")
+ raise TypeError("target[space] must be a nonharmonic space")
self._domain = [dom for dom in self._target]
self._domain[self._space] = \
diff --git a/nifty5/operators/regridding_operator.py b/nifty5/operators/regridding_operator.py
index 5d29bb22497663b97f7c1caa28068f68da762653..8c5a877f65fbbb95105fc0bd6d36f8e78d92b132 100644
--- a/nifty5/operators/regridding_operator.py
+++ b/nifty5/operators/regridding_operator.py
@@ -65,6 +65,7 @@ class RegriddingOperator(LinearOperator):
v = x.val
ndim = len(self.target.shape)
curshp = list(self._dom(mode).shape)
+ tgtshp = self._tgt(mode).shape
d0 = self._target.axes[self._space][0]
for d in self._target.axes[self._space]:
idx = (slice(None),) * d
@@ -74,7 +75,7 @@ class RegriddingOperator(LinearOperator):
if mode == self.ADJOINT_TIMES:
shp = list(x.shape)
- shp[d] = self._tgt(mode).shape[d]
+ shp[d] = tgtshp[d]
xnew = np.zeros(shp, dtype=x.dtype)
xnew = special_add_at(xnew, d, self._bindex[d-d0], x*(1.-wgt))
xnew = special_add_at(xnew, d, self._bindex[d-d0]+1, x*wgt)
@@ -82,6 +83,6 @@ class RegriddingOperator(LinearOperator):
xnew = x[idx + (self._bindex[d-d0],)] * (1.-wgt)
xnew += x[idx + (self._bindex[d-d0]+1,)] * wgt
- curshp[d] = self._tgt(mode).shape[d]
+ curshp[d] = xnew.shape[d]
v = dobj.from_local_data(curshp, xnew, distaxis=dobj.distaxis(v))
return Field(self._tgt(mode), dobj.ensure_default_distributed(v))
diff --git a/nifty5/operators/slope_operator.py b/nifty5/operators/slope_operator.py
index 98925d902b9c29b332f4c54639b34dcd52366eac..3847805c622ab52255b212e4089be29009505a24 100644
--- a/nifty5/operators/slope_operator.py
+++ b/nifty5/operators/slope_operator.py
@@ -34,30 +34,24 @@ class SlopeOperator(LinearOperator):
This operator creates a field on a LogRGSpace, which is created
according to a slope of given entries, (mean, y-intercept).
- The slope mean is the powerlaw of the field in normal-space.
+ The slope mean is the power law of the field in normal-space.
Parameters
----------
domain : domain or DomainTuple, shape=(2,)
- It has to be and UnstructuredDomain.
+ It has to be an UnstructuredDomain.
The domain of the slope mean and the y-intercept mean.
target : domain or DomainTuple
The output domain has to a LogRGSpace
sigmas : np.array, shape=(2,)
The slope variance and the y-intercept variance.
"""
- def __init__(self, domain, target, sigmas):
+ def __init__(self, target, sigmas):
if not isinstance(target, LogRGSpace):
raise TypeError
- if not (isinstance(domain, UnstructuredDomain) and domain.shape == (2,)):
- raise TypeError
-
- self._domain = DomainTuple.make(domain)
+ self._domain = DomainTuple.make(UnstructuredDomain((2,)))
self._target = DomainTuple.make(target)
- self._capability = self.TIMES | self.ADJOINT_TIMES
-
- if self.domain[0].shape != (len(self.target[0].shape) + 1,):
- raise AssertionError("Shape mismatch!")
+ self._capability = self.TIMES | self.ADJOINT_TIMES
self._sigmas = sigmas
self.ndim = len(self.target[0].shape)
diff --git a/test/test_operators/test_adjoint.py b/test/test_operators/test_adjoint.py
index a923a46a4a0568429bfbbb9b54aeb7a7689c6e6d..b669777507251f87ec3d848ae28bac3f112907ad 100644
--- a/test/test_operators/test_adjoint.py
+++ b/test/test_operators/test_adjoint.py
@@ -74,8 +74,7 @@ class Consistency_Tests(unittest.TestCase):
tmp = ift.ExpTransform(ift.PowerSpace(args[0]), args[1], args[2])
tgt = tmp.domain[0]
sig = np.array([0.3, 0.13])
- dom = ift.UnstructuredDomain(2)
- op = ift.SlopeOperator(dom, tgt, sig)
+ op = ift.SlopeOperator(tgt, sig)
ift.extra.consistency_check(op, dtype, dtype)
@expand(product(_h_spaces + _p_spaces + _pow_spaces,
@@ -202,19 +201,20 @@ class Consistency_Tests(unittest.TestCase):
op = ift.SymmetrizingOperator(dom, space)
ift.extra.consistency_check(op, dtype, dtype)
- @expand(product([0, 2], [2, 2.7], [np.float64, np.complex128]))
- def testZeroPadder(self, space, factor, dtype):
+ @expand(product([0, 2], [2, 2.7], [np.float64, np.complex128],
+ [False, True]))
+ def testZeroPadder(self, space, factor, dtype, central):
dom = (ift.RGSpace(10), ift.UnstructuredDomain(13), ift.RGSpace(7, 12),
ift.HPSpace(4))
- newshape = [factor*l for l in dom[space].shape]
- op = ift.FieldZeroPadder(dom, newshape, space)
+ newshape = [int(factor*l) for l in dom[space].shape]
+ op = ift.FieldZeroPadder(dom, newshape, space, central)
ift.extra.consistency_check(op, dtype, dtype)
@expand(product([0, 2], [2, 2.7], [np.float64, np.complex128]))
def testZeroPadder2(self, space, factor, dtype):
dom = (ift.RGSpace(10), ift.UnstructuredDomain(13), ift.RGSpace(7, 12),
ift.HPSpace(4))
- newshape = [factor*l for l in dom[space].shape]
+ newshape = [int(factor*l) for l in dom[space].shape]
op = ift.CentralZeroPadder(dom, newshape, space)
ift.extra.consistency_check(op, dtype, dtype)
@@ -244,7 +244,7 @@ class Consistency_Tests(unittest.TestCase):
@expand([[ift.RGSpace((13, 52, 40)), (4, 6, 25), None],
[ift.RGSpace((128, 128)), (45, 48), 0],
[ift.RGSpace(13), (7,), None],
- [(ift.HPSpace(3), ift.RGSpace((12, 24),distances=0.3)),
+ [(ift.HPSpace(3), ift.RGSpace((12, 24), distances=0.3)),
(12, 12), 1]])
def testRegridding(self, domain, shape, space):
op = ift.RegriddingOperator(domain, shape, space)