code: def _lincomb(self, a, f1, b, f2, out):
          
          # Avoid infinite recursions by making a copy of the functions
          f1_copy = f1.copy()
          f2_copy = f2.copy()
  
          def lincomb_oop(x, **kwargs):
              """Linear combination, out-of-place version."""
              # Not optimized since that raises issues with alignment
              # of input and partial results
              out = a * np.asarray(f1_copy(x, **kwargs),
                                   dtype=self.scalar_out_dtype)
              tmp = b * np.asarray(f2_copy(x, **kwargs),
                                   dtype=self.scalar_out_dtype)
              out += tmp
              return out
  
          out._call_out_of_place = lincomb_oop
          decorator = preload_first_arg(out, 'in-place')
          out._call_in_place = decorator(_default_in_place)
          out._call_has_out = out._call_out_optional = False
          return out
docs: Linear combination of ``f1`` and ``f2``.
  
          Notes
          -----
          The additions and multiplications are implemented via simple
          Python functions, so non-vectorized versions are slow.