diff --git a/demos/polynomial_fit.py b/demos/polynomial_fit.py index 108d9a06da9b21f1455995ec6014422da274ce42..969e6822ad9d30de7d59037d6ae6166e8bcef83e 100644 --- a/demos/polynomial_fit.py +++ b/demos/polynomial_fit.py @@ -62,14 +62,6 @@ class PolynomialResponse(ift.LinearOperator): out = self._mat.conj().T.dot(val) return ift.from_global_data(self._tgt(mode), out) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES diff --git a/nifty5/library/amplitude_model.py b/nifty5/library/amplitude_model.py index f9ff03b79eba6f1ddc6f2d53e37936e017d52bec..77842d2ef383c309c8baa4548c3c5311ef0d9eee 100644 --- a/nifty5/library/amplitude_model.py +++ b/nifty5/library/amplitude_model.py @@ -133,14 +133,6 @@ class AmplitudeModel(Operator): self._smooth_op = sym(qht(ceps)) self._keys = tuple(keys) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - def apply(self, x): smooth_spec = self._smooth_op(x[self._keys[0]]) phi = x[self._keys[1]] + self._norm_phi_mean diff --git a/nifty5/library/correlated_fields.py b/nifty5/library/correlated_fields.py index b2edc026c6a0ba69dc7aa816709e9dd488bdd4cc..07f4a90b378f51b52f3e753f4f06a9335b734dbc 100644 --- a/nifty5/library/correlated_fields.py +++ b/nifty5/library/correlated_fields.py @@ -50,14 +50,6 @@ class CorrelatedField(Operator): (self._amplitude_model.domain, MultiDomain.make({"xi": self._h_space}))) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._ht.target - def apply(self, x): A = self._power_distributor(self._amplitude_model(x)) correlated_field_h = A * x["xi"] diff --git a/nifty5/library/inverse_gamma_model.py b/nifty5/library/inverse_gamma_model.py index 3cce6ae1686e82c6f97dfe7ddb530943f7b0b143..e40ac09608d506522462b67a1cbaa2ac1c7b2cb1 100644 --- a/nifty5/library/inverse_gamma_model.py +++ b/nifty5/library/inverse_gamma_model.py @@ -30,18 +30,10 @@ from ..sugar import makeOp class InverseGammaModel(Operator): def __init__(self, domain, alpha, q): - self._domain = domain + self._domain = self._target = domain self._alpha = alpha self._q = q - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._domain - def apply(self, x): lin = isinstance(x, Linearization) val = x.val.local_data if lin else x.local_data diff --git a/nifty5/library/los_response.py b/nifty5/library/los_response.py index ec946bdb7298c057bf2b2c38af6cbb090a3f79b3..f8c112f230520032c2990c83ff0df16e7d115f5d 100644 --- a/nifty5/library/los_response.py +++ b/nifty5/library/los_response.py @@ -221,14 +221,6 @@ class LOSResponse(LinearOperator): self._target = DomainTuple.make(UnstructuredDomain(nlos)) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES diff --git a/nifty5/multi_domain.py b/nifty5/multi_domain.py index a4fb03aec7b183a61049696f34b97d6ca1fa863a..f2257ba967d4e584adab0e6c5b05391eaaaaa7c6 100644 --- a/nifty5/multi_domain.py +++ b/nifty5/multi_domain.py @@ -109,6 +109,7 @@ class MultiDomain(object): @staticmethod def union(inp): res = {} + # FIXME speed up! for dom in inp: for key, subdom in zip(dom._keys, dom._domains): if key in res: diff --git a/nifty5/operators/block_diagonal_operator.py b/nifty5/operators/block_diagonal_operator.py index 956be8dcb374d365d7eb544b97fac578efa5a950..9a601e15c6bdd965b50a4fcdf2127996ffbdba39 100644 --- a/nifty5/operators/block_diagonal_operator.py +++ b/nifty5/operators/block_diagonal_operator.py @@ -45,10 +45,6 @@ class BlockDiagonalOperator(EndomorphicOperator): if op is not None: self._cap &= op.capability - @property - def domain(self): - return self._domain - @property def capability(self): return self._cap diff --git a/nifty5/operators/central_zero_padder.py b/nifty5/operators/central_zero_padder.py index 2a7f0649caaec908fe7ddc306f2f2f25519ad975..1f48c8d83a6d2f7a4646146f0e2b4449e0fdb723 100644 --- a/nifty5/operators/central_zero_padder.py +++ b/nifty5/operators/central_zero_padder.py @@ -53,14 +53,6 @@ class CentralZeroPadder(LinearOperator): self.slicer[i] = tuple(tmp) self.slicer = tuple(self.slicer) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES diff --git a/nifty5/operators/chain_operator.py b/nifty5/operators/chain_operator.py index 9f78bae755fe778a19d8b846cafd1ca3c87fad78..548ba0474e26f88e1e1dda3cbf3086e18c722454 100644 --- a/nifty5/operators/chain_operator.py +++ b/nifty5/operators/chain_operator.py @@ -36,6 +36,8 @@ class ChainOperator(LinearOperator): self._capability = self._all_ops for op in ops: self._capability &= op.capability + self._domain = self._ops[-1].domain + self._target = self._ops[0].target @staticmethod def simplify(ops): @@ -117,14 +119,6 @@ class ChainOperator(LinearOperator): return ops[0] return ChainOperator(ops, _callingfrommake=True) - @property - def domain(self): - return self._ops[-1].domain - - @property - def target(self): - return self._ops[0].target - def _flip_modes(self, trafo): ADJ = self.ADJOINT_BIT INV = self.INVERSE_BIT diff --git a/nifty5/operators/diagonal_operator.py b/nifty5/operators/diagonal_operator.py index 48b06cff57749109c96c4158dfcf15a4ed78c98f..506964163c3d44da2f0005c4f4eae9e9af3338cc 100644 --- a/nifty5/operators/diagonal_operator.py +++ b/nifty5/operators/diagonal_operator.py @@ -150,10 +150,6 @@ class DiagonalOperator(EndomorphicOperator): return Field.from_local_data(x.domain, x.local_data*xdiag) return Field.from_local_data(x.domain, x.local_data/xdiag) - @property - def domain(self): - return self._domain - @property def capability(self): return self._all_ops diff --git a/nifty5/operators/dof_distributor.py b/nifty5/operators/dof_distributor.py index 31ce2eca45fe11e7caafb57e0c98926b971bff56..ef864760cbb34b9bbcde2d3ec2851f1902e30546 100644 --- a/nifty5/operators/dof_distributor.py +++ b/nifty5/operators/dof_distributor.py @@ -143,14 +143,6 @@ class DOFDistributor(LinearOperator): self._check_input(x, mode) return self._times(x) if mode == self.TIMES else self._adjoint_times(x) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES diff --git a/nifty5/operators/domain_distributor.py b/nifty5/operators/domain_distributor.py index eb1899c76f7fb9f34b8388738c93e3d1ff36e043..08939a45fc079396dc47ddea569bb63a4662557f 100644 --- a/nifty5/operators/domain_distributor.py +++ b/nifty5/operators/domain_distributor.py @@ -36,14 +36,6 @@ class DomainDistributor(LinearOperator): if i in self._spaces] self._domain = DomainTuple.make(self._domain) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - def apply(self, x, mode): self._check_input(x, mode) if mode == self.TIMES: diff --git a/nifty5/operators/endomorphic_operator.py b/nifty5/operators/endomorphic_operator.py index 081742441469adba67e2150a2e51fc5cd30662e1..56e65b03981685b0b50a7ce992a607bc9e2d2114 100644 --- a/nifty5/operators/endomorphic_operator.py +++ b/nifty5/operators/endomorphic_operator.py @@ -38,7 +38,7 @@ class EndomorphicOperator(LinearOperator): Returns `self.domain`, because this is also the target domain for endomorphic operators.""" - return self.domain + return self._domain def draw_sample(self, from_inverse=False, dtype=np.float64): """Generate a zero-mean sample diff --git a/nifty5/operators/energy_operators.py b/nifty5/operators/energy_operators.py index bf779728d16b1ba7602c8b4d4d5b6baaa821d068..dc5c75e94bd04bd7b334f0edb91a073d5f99f673 100644 --- a/nifty5/operators/energy_operators.py +++ b/nifty5/operators/energy_operators.py @@ -33,20 +33,12 @@ from .simple_linear_operators import VdotOperator class EnergyOperator(Operator): _target = DomainTuple.scalar_domain() - @property - def target(self): - return EnergyOperator._target - class SquaredNormOperator(EnergyOperator): def __init__(self, domain): super(SquaredNormOperator, self).__init__() self._domain = domain - @property - def domain(self): - return self._domain - def apply(self, x): if isinstance(x, Linearization): val = Field(self._target, x.val.vdot(x.val)) @@ -62,10 +54,7 @@ class QuadraticFormOperator(EnergyOperator): if not isinstance(op, EndomorphicOperator): raise TypeError("op must be an EndomorphicOperator") self._op = op - - @property - def domain(self): - return self._op.domain + self._domain = op.domain def apply(self, x): if isinstance(x, Linearization): @@ -102,10 +91,6 @@ class GaussianEnergy(EnergyOperator): if self._domain is not newdom: raise ValueError("domain mismatch") - @property - def domain(self): - return self._domain - def apply(self, x): residual = x if self._mean is None else x-self._mean res = self._op(residual) @@ -118,10 +103,7 @@ class GaussianEnergy(EnergyOperator): class PoissonianEnergy(EnergyOperator): def __init__(self, op, d): self._op, self._d = op, d - - @property - def domain(self): - return self._op.domain + self._domain = d.domain def apply(self, x): x = self._op(x) @@ -136,10 +118,7 @@ class BernoulliEnergy(EnergyOperator): def __init__(self, p, d): self._p = p self._d = d - - @property - def domain(self): - return self._p.domain + self._domain = d.domain def apply(self, x): x = self._p(x) @@ -157,10 +136,7 @@ class Hamiltonian(EnergyOperator): self._lh = lh self._prior = GaussianEnergy(domain=lh.domain) self._ic_samp = ic_samp - - @property - def domain(self): - return self._lh.domain + self._domain = lh.domain def apply(self, x): if self._ic_samp is None or not isinstance(x, Linearization): @@ -182,12 +158,9 @@ class SampledKullbachLeiblerDivergence(EnergyOperator): """ super(SampledKullbachLeiblerDivergence, self).__init__() self._h = h + self._domain = h.domain self._res_samples = tuple(res_samples) - @property - def domain(self): - return self._h.domain - def apply(self, x): res = (utilities.my_sum(map(lambda v: self._h(x+v), self._res_samples)) * (1./len(self._res_samples))) diff --git a/nifty5/operators/exp_transform.py b/nifty5/operators/exp_transform.py index c4fbcad8952b45d61a89e88c06e2cc77f575108d..db12ba311ba508687bbf3fb5cb125b9753ae9289 100644 --- a/nifty5/operators/exp_transform.py +++ b/nifty5/operators/exp_transform.py @@ -84,14 +84,6 @@ class ExpTransform(LinearOperator): self._domain[self._space] = log_space self._domain = DomainTuple.make(self._domain) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - def apply(self, x, mode): self._check_input(x, mode) x = x.val diff --git a/nifty5/operators/field_zero_padder.py b/nifty5/operators/field_zero_padder.py index d3afb12bbe88753a168d649cbb0978ce1b07b321..b0f67daa4f1888ccf4be7a9ec9a3a210986dba53 100644 --- a/nifty5/operators/field_zero_padder.py +++ b/nifty5/operators/field_zero_padder.py @@ -31,14 +31,6 @@ class FieldZeroPadder(LinearOperator): self._target[self._space] = tgt self._target = DomainTuple.make(self._target) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES diff --git a/nifty5/operators/harmonic_operators.py b/nifty5/operators/harmonic_operators.py index 6eeb5b4344cb32dc5031f918a2ecb7c7aa4cd0f3..e07d3da107e7d8bf4a06bf241dd326fb4be9dc6c 100644 --- a/nifty5/operators/harmonic_operators.py +++ b/nifty5/operators/harmonic_operators.py @@ -127,14 +127,6 @@ class FFTOperator(LinearOperator): fct *= self._target[self._space].scalar_dvol return Tval if fct == 1 else Tval*fct - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self._all_ops @@ -247,14 +239,6 @@ class HartleyOperator(LinearOperator): fct = self._target[self._space].scalar_dvol return Tval if fct == 1 else Tval*fct - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self._all_ops @@ -367,14 +351,6 @@ class SHTOperator(LinearOperator): odat = dobj.redistribute(odat, dist=dobj.distaxis(x.val)) return Field(tdom, odat) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES @@ -421,19 +397,13 @@ class HarmonicTransformOperator(LinearOperator): self._op = HartleyOperator(domain, target, space) else: self._op = SHTOperator(domain, target, space) + self._domain = self._op.domain + self._target = self._op.target def apply(self, x, mode): self._check_input(x, mode) return self._op.apply(x, mode) - @property - def domain(self): - return self._op.domain - - @property - def target(self): - return self._op.target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES diff --git a/nifty5/operators/inversion_enabler.py b/nifty5/operators/inversion_enabler.py index ba9fff48a83dc2b61ff11d704080311542afba32..9b7cc7654a871e12f40dfa5eed61dcf72b914a73 100644 --- a/nifty5/operators/inversion_enabler.py +++ b/nifty5/operators/inversion_enabler.py @@ -55,10 +55,7 @@ class InversionEnabler(EndomorphicOperator): self._op = op self._ic = iteration_controller self._approximation = approximation - - @property - def domain(self): - return self._op.domain + self._domain = op.domain @property def capability(self): diff --git a/nifty5/operators/laplace_operator.py b/nifty5/operators/laplace_operator.py index 0725d8ea3f39368ef68c83d9e625f3dea64822e9..a779b9279f3ee8ad44e4c72c35eabdba56324cd3 100644 --- a/nifty5/operators/laplace_operator.py +++ b/nifty5/operators/laplace_operator.py @@ -68,10 +68,6 @@ class LaplaceOperator(EndomorphicOperator): self._dposc[1:] += self._dpos self._dposc *= 0.5 - @property - def domain(self): - return self._domain - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES diff --git a/nifty5/operators/mask_operator.py b/nifty5/operators/mask_operator.py index 84b15e3cb35f0856c2e03c1e14fd7a0613303309..6cc700f2f56eede76da405c927b5b7dbbc77b8af 100644 --- a/nifty5/operators/mask_operator.py +++ b/nifty5/operators/mask_operator.py @@ -59,11 +59,3 @@ class MaskOperator(LinearOperator): @property def capability(self): return self.TIMES | self.ADJOINT_TIMES - - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target diff --git a/nifty5/operators/operator.py b/nifty5/operators/operator.py index 88efbbf798d4b32e4e9ba27ebbeffb17538294f7..24b5e435758c1c8d391a7668237729687d9a468a 100644 --- a/nifty5/operators/operator.py +++ b/nifty5/operators/operator.py @@ -15,14 +15,14 @@ class Operator(NiftyMetaBase()): """DomainTuple or MultiDomain : the operator's input domain The domain on which the Operator's input Field lives.""" - raise NotImplementedError + return self._domain @property def target(self): """DomainTuple or MultiDomain : the operator's output domain The domain on which the Operator's output Field lives.""" - raise NotImplementedError + return self._target def scale(self, factor): if factor == 1: @@ -73,17 +73,9 @@ for f in ["sqrt", "exp", "log", "tanh", "positive_tanh"]: class _FunctionApplier(Operator): def __init__(self, domain, funcname): from ..sugar import makeDomain - self._domain = makeDomain(domain) + self._domain = self._target = makeDomain(domain) self._funcname = funcname - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._domain - def apply(self, x): return getattr(x, self._funcname)() @@ -114,14 +106,8 @@ class _CombinedOperator(Operator): class _OpChain(_CombinedOperator): def __init__(self, ops, _callingfrommake=False): super(_OpChain, self).__init__(ops, _callingfrommake) - - @property - def domain(self): - return self._ops[-1].domain - - @property - def target(self): - return self._ops[0].target + self._domain = self._ops[-1].domain + self._target = self._ops[0].target def apply(self, x): for op in reversed(self._ops): @@ -132,14 +118,8 @@ class _OpChain(_CombinedOperator): class _OpProd(_CombinedOperator): def __init__(self, ops, _callingfrommake=False): super(_OpProd, self).__init__(ops, _callingfrommake) - - @property - def domain(self): - return self._ops[0].domain - - @property - def target(self): - return self._ops[0].target + self._domain = self._ops[0].domain + self._target = self._ops[0].target def apply(self, x): return my_product(map(lambda op: op(x), self._ops)) @@ -151,13 +131,5 @@ class _OpSum(_CombinedOperator): self._domain = domain_union([op.domain for op in self._ops]) self._target = domain_union([op.target for op in self._ops]) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - def apply(self, x): raise NotImplementedError diff --git a/nifty5/operators/operator_adapter.py b/nifty5/operators/operator_adapter.py index 310a56b66d7114da2071209156da92f11f64f7bd..6d4d79c38a519b04cd8571575a4fe927e77cdc5e 100644 --- a/nifty5/operators/operator_adapter.py +++ b/nifty5/operators/operator_adapter.py @@ -50,14 +50,8 @@ class OperatorAdapter(LinearOperator): self._trafo = int(op_transform) if self._trafo < 1 or self._trafo > 3: raise ValueError("invalid operator transformation") - - @property - def domain(self): - return self._op._dom(1 << self._trafo) - - @property - def target(self): - return self._op._tgt(1 << self._trafo) + self._domain = self._op._dom(1 << self._trafo) + self._target = self._op._tgt(1 << self._trafo) @property def capability(self): diff --git a/nifty5/operators/qht_operator.py b/nifty5/operators/qht_operator.py index d60bb12489274de3dc214ae21dcf119821abc024..b2d0f07b374e4e81988b9b65f1baaba548fff011 100644 --- a/nifty5/operators/qht_operator.py +++ b/nifty5/operators/qht_operator.py @@ -60,14 +60,6 @@ class QHTOperator(LinearOperator): self._target[self._space].get_default_codomain() self._domain = DomainTuple.make(self._domain) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - def apply(self, x, mode): self._check_input(x, mode) dom = self._domain[self._space] diff --git a/nifty5/operators/relaxed_sum_operator.py b/nifty5/operators/relaxed_sum_operator.py index 4b52cea437c4110c5a1be100291678af3ee61518..fb4d6117d6d59f0f3083bf0ba0917bd2f3530591 100644 --- a/nifty5/operators/relaxed_sum_operator.py +++ b/nifty5/operators/relaxed_sum_operator.py @@ -46,14 +46,6 @@ class RelaxedSumOperator(LinearOperator): # else: # self._ops += [op] - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def adjoint(self): return RelaxedSumOperator([op.adjoint for op in self._ops]) diff --git a/nifty5/operators/sampling_enabler.py b/nifty5/operators/sampling_enabler.py index f2666db2095ea6642a7c1ac6f7165cef77d03a78..728f4ad864044a97bb8a2d4a7fb1805d68d21ca3 100644 --- a/nifty5/operators/sampling_enabler.py +++ b/nifty5/operators/sampling_enabler.py @@ -56,6 +56,7 @@ class SamplingEnabler(EndomorphicOperator): self._prior = prior self._ic = iteration_controller self._approximation = approximation + self._domain = self._op.domain def draw_sample(self, from_inverse=False, dtype=np.float64): try: @@ -76,10 +77,6 @@ class SamplingEnabler(EndomorphicOperator): energy, convergence = inverter(energy) return energy.position - @property - def domain(self): - return self._op.domain - @property def capability(self): return self._op.capability diff --git a/nifty5/operators/sandwich_operator.py b/nifty5/operators/sandwich_operator.py index 480e098dbb00d451e6e00a7a76ba5ec69efa8193..76ea55a504b87a67c9390564736277ced014dfbb 100644 --- a/nifty5/operators/sandwich_operator.py +++ b/nifty5/operators/sandwich_operator.py @@ -38,6 +38,7 @@ class SandwichOperator(EndomorphicOperator): self._bun = bun self._cheese = cheese self._op = op + self._domain = op.domain @staticmethod def make(bun, cheese=None): @@ -65,10 +66,6 @@ class SandwichOperator(EndomorphicOperator): return op return SandwichOperator(bun, cheese, op, _callingfrommake=True) - @property - def domain(self): - return self._op.domain - @property def capability(self): return self._op.capability diff --git a/nifty5/operators/scaling_operator.py b/nifty5/operators/scaling_operator.py index 371b5b440163d28ac7769d0f16c6570c14faaf76..b3d5e5d426b491d9a6ef76ded38b2c471f5e7bbd 100644 --- a/nifty5/operators/scaling_operator.py +++ b/nifty5/operators/scaling_operator.py @@ -82,10 +82,6 @@ class ScalingOperator(EndomorphicOperator): fct = 1./fct return ScalingOperator(fct, self._domain) - @property - def domain(self): - return self._domain - @property def capability(self): return self._all_ops diff --git a/nifty5/operators/simple_linear_operators.py b/nifty5/operators/simple_linear_operators.py index bef589f75a92f123770f9523f9b67f4dd00ac33e..cb047d3247b7c204b705ef36088dfb3903be2337 100644 --- a/nifty5/operators/simple_linear_operators.py +++ b/nifty5/operators/simple_linear_operators.py @@ -35,16 +35,9 @@ class VdotOperator(LinearOperator): def __init__(self, field): super(VdotOperator, self).__init__() self._field = field + self._domain = field.domain self._target = DomainTuple.scalar_domain() - @property - def domain(self): - return self._field.domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES @@ -62,14 +55,6 @@ class SumReductionOperator(LinearOperator): self._domain = domain self._target = DomainTuple.scalar_domain() - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES @@ -86,10 +71,6 @@ class ConjugationOperator(EndomorphicOperator): super(ConjugationOperator, self).__init__() self._domain = domain - @property - def domain(self): - return self._domain - @property def capability(self): return self._all_ops @@ -104,10 +85,6 @@ class Realizer(EndomorphicOperator): super(Realizer, self).__init__() self._domain = domain - @property - def domain(self): - return self._domain - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES @@ -123,14 +100,6 @@ class FieldAdapter(LinearOperator): self._name = name_dom self._target = dom[name_dom] - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES @@ -167,14 +136,6 @@ class GeometryRemover(LinearOperator): target_list = [UnstructuredDomain(dom.shape) for dom in self._domain] self._target = DomainTuple.make(target_list) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES @@ -216,14 +177,6 @@ class NullOperator(LinearOperator): return self._nullfield(self._target) return self._nullfield(self._domain) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def capability(self): return self.TIMES | self.ADJOINT_TIMES diff --git a/nifty5/operators/slope_operator.py b/nifty5/operators/slope_operator.py index dadee40c0ae80acb22495afa8b57609d9f1a41d9..618b022c875d128df7dd1b0787cc6f20afadb576 100644 --- a/nifty5/operators/slope_operator.py +++ b/nifty5/operators/slope_operator.py @@ -56,14 +56,6 @@ class SlopeOperator(LinearOperator): self.pos[i] += tmp.reshape( (1,)*i + (shape[i],) + (1,)*(self.ndim-i-1)) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - def apply(self, x, mode): self._check_input(x, mode) diff --git a/nifty5/operators/sum_operator.py b/nifty5/operators/sum_operator.py index a2b9ffe6c405e0f6369463aa82782788ade17ce5..de43f1650b9cef0ce002346d17ac6a8f0576f92f 100644 --- a/nifty5/operators/sum_operator.py +++ b/nifty5/operators/sum_operator.py @@ -159,14 +159,6 @@ class SumOperator(LinearOperator): return ops[0] return SumOperator(ops, neg, dom, tgt, _callingfrommake=True) - @property - def domain(self): - return self._domain - - @property - def target(self): - return self._target - @property def adjoint(self): return self.make([op.adjoint for op in self._ops], self._neg) diff --git a/nifty5/operators/symmetrizing_operator.py b/nifty5/operators/symmetrizing_operator.py index a8c9e49eda5fac886e2013480c4f67ff77143e89..5c4d6276a64454a958978a48b6adc30837cc490b 100644 --- a/nifty5/operators/symmetrizing_operator.py +++ b/nifty5/operators/symmetrizing_operator.py @@ -35,10 +35,6 @@ class SymmetrizingOperator(EndomorphicOperator): if not (isinstance(dom, LogRGSpace) and not dom.harmonic): raise TypeError("nonharmonic LogRGSpace needed") - @property - def domain(self): - return self._domain - def apply(self, x, mode): self._check_input(x, mode) tmp = x.val.copy()