--- a/src/interpolate.cc	Mon May 12 21:38:35 2014 +0200
+++ b/src/interpolate.cc	Sat May 17 17:16:58 2014 +0200
@@ -15,13 +15,23 @@
  this program; if not, see <http://www.gnu.org/licenses/>.
 */
 
+#include "coefficient.h"
 #include "function.h"
+#include "functionspace.h"
 
 DEFUN_DLD (interpolate, args, nargout, "-*- texinfo -*-\n\
-@deftypefn {Function File} @var{interpolated} =\
-interpolate (@var{f}, @var{g})\n\
-Interpolate Function @var{g} on @var{f}'s space. \n\
-@seealso{Function}\n\
+@deftypefn {Function File} @var{interp} = \
+interpolate (@var{Function}, @var{v})\n\
+interpolate (@var{v}, @var{FunctionSpace})\n\
+Interpolate a function on a FunctionSpace.\n\
+This function can be used in two ways:\n\
+@itemize @bullet\n\
+@item To interpolate a Function, Expression or Constant, \
+@var{v}, on the same FunctionSpace of a @var{Function}\n\
+@item To interpolate a Function, Expression or Constant, \
+@var{v}, on a given @var{FunctionSpace}\n\
+@end itemize\n\
+@seealso{Function, Expression, Constant, FunctionSpace}\n\
 @end deftypefn")
 {
 
@@ -39,27 +49,98 @@
           mlock ();
         }
 
-      if (args(0).type_id () == function::static_type_id () &&
-          args(1).type_id () == function::static_type_id ())
+      if (! coefficient_type_loaded)
+        {
+          coefficient::register_type ();
+          coefficient_type_loaded = true;
+          mlock ();
+        }
+
+      if (! functionspace_type_loaded)
+        {
+          functionspace::register_type ();
+          functionspace_type_loaded = true;
+          mlock ();
+        }
+
+      if (args(1).type_id () == functionspace::static_type_id ())
+        {
+          const functionspace & u1 =
+            static_cast<const functionspace&> (args(1).get_rep ());
+
+          if (! error_state)
+            {
+              boost::shared_ptr<dolfin::Function>
+                output (new dolfin::Function (u1.get_pfsp ()));
+
+              if (args(0).type_id () == function::static_type_id ())
+                {
+                  const function & u0 =
+                    static_cast<const function&> (args(0).get_rep ());
+
+                  if (! error_state)
+                    {
+                      output->interpolate (u0.get_fun ());
+                      std::string name = u0.get_str ();
+                      retval = new function (name, output);
+                    }
+                }
+              else if (args(0).type_id () == coefficient::static_type_id ())
+                {
+                  const coefficient & u0 =
+                    static_cast<const coefficient&> (args(0).get_rep ());
+
+                  if (! error_state)
+                    {
+                      output->interpolate (* u0.get_expr ());
+                      std::string name = u0.get_str ();
+                      retval = new function (name, output);
+                    }
+                }
+              else
+                error ("interpolate: invalid arguments");
+            }
+        }
+      else if (args(0).type_id () == function::static_type_id ())
         {
           const function & u0 =
             static_cast<const function&> (args(0).get_rep ());
-          const function & u1 =
-            static_cast<const function&> (args(1).get_rep ());
 
-          if (!error_state)
+          if (! error_state)
             {
               boost::shared_ptr<dolfin::Function>
                 output (new dolfin::Function (u0.get_fun ()));
-              const dolfin::Function &
-                input = u1.get_fun ();
+
+              if (args(1).type_id () == function::static_type_id ())
+                {
+                  const function & u1 =
+                    static_cast<const function&> (args(1).get_rep ());
 
-              output->interpolate (input);
-              std::string name = u1.get_str ();
+                  if (! error_state)
+                    {
+                      output->interpolate (u1.get_fun ());
+                      std::string name = u1.get_str ();
+                      retval = new function (name, output);
+                    }
+                }
+              else if (args(1).type_id () == coefficient::static_type_id ())
+                {
+                  const coefficient & u1 =
+                    static_cast<const coefficient&> (args(1).get_rep ());
 
-              retval = new function (name, output);
+                  if (! error_state)
+                    {
+                      output->interpolate (* u1.get_expr ());
+                      std::string name = u1.get_str ();
+                      retval = new function (name, output);
+                    }
+                }
+              else
+                error ("interpolate: invalid arguments");
             }
         }
+      else
+        error ("interpolate: invalid arguments");
     }
   return retval;
 }