Added invertible_operator_mixin.

nifty/operators/__init__.py

@@ -31,6 +31,8 @@ from smoothing_operator import SmoothingOperator
 
 from fft_operator import *
 
+from invertible_operator_mixin import InvertibleOperatorMixin
+
 from propagator_operator import PropagatorOperator
 
 from composed_operator import ComposedOperator

nifty/operators/invertible_operator_mixin/__init__.py

+# -*- coding: utf-8 -*-
+
+from invertible_operator_mixin import InvertibleOperatorMixin
\ No newline at end of file

nifty/operators/invertible_operator_mixin/invertible_operator_mixin.py

+# -*- coding: utf-8 -*-
+
+from nifty.minimization import ConjugateGradient
+
+from nifty.field import Field
+
+
+class InvertibleOperatorMixin(object):
+    def __init__(self, inverter=None, preconditioner=None):
+        self.__preconditioner = preconditioner
+        if inverter is not None:
+            self.__inverter = inverter
+        else:
+            self.__inverter = ConjugateGradient(
+                                            preconditioner=self.preconditioner)
+
+    def _times(self, x, spaces, types, x0=None):
+        if x0 is None:
+            x0 = Field(self.target, val=0., dtype=x.dtype)
+
+        (result, convergence) = self.inverter(A=self.inverse_times,
+                                              b=x,
+                                              x0=x0)
+        return result
+
+    def _adjoint_times(self, x, spaces, types, x0=None):
+        if x0 is None:
+            x0 = Field(self.domain, val=0., dtype=x.dtype)
+
+        (result, convergence) = self.inverter(A=self.adjoint_inverse_times,
+                                              b=x,
+                                              x0=x0)
+        return result
+
+    def _inverse_times(self, x, spaces, types, x0=None):
+        if x0 is None:
+            x0 = Field(self.domain, val=0., dtype=x.dtype)
+
+        (result, convergence) = self.inverter(A=self.times,
+                                              b=x,
+                                              x0=x0)
+        return result
+
+    def _adjoint_inverse_times(self, x, spaces, types, x0=None):
+        if x0 is None:
+            x0 = Field(self.target, val=0., dtype=x.dtype)
+
+        (result, convergence) = self.inverter(A=self.adjoint_times,
+                                              b=x,
+                                              x0=x0)
+        return result
+
+    def _inverse_adjoint_times(self, x, spaces, types):
+        raise NotImplementedError(
+            "no generic instance method 'inverse_adjoint_times'.")

nifty/operators/propagator_operator/propagator_operator.py

@@ -109,7 +109,7 @@ class PropagatorOperator(EndomorphicOperator):
 
     def _times(self, x, spaces, types, x0=None):
         if x0 is None:
-            x0 = Field(self.domain, val=0., dtype=x.dtype)
+            x0 = Field(self.target, val=0., dtype=x.dtype)
 
         (result, convergence) = self.inverter(A=self.inverse_times,
                                               b=x,