Fix grad for bivariate Fun (#247)

* fix grad

* version bump to v0.7.25

* return a Fun in grad

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.7.24"
+version = "0.7.25"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/Operators/general/algebra.jl

@@ -623,7 +623,8 @@ mul_coefficients(A::PlusOperator,b::Fun) =
     mapreduce(x->mul_coefficients(x,b),+,A.ops)
 
 *(A::Operator, b::AbstractMatrix{<:Fun}) = A*Fun(b)
-*(A::Vector{<:Operator}, b::Fun) = map(a->a*b,strictconvert(Array{Any,1},A))
+*(A::AbstractVector{<:Operator}, b::Fun) = map(a->a*b, A)
+*(A::AbstractVector{<:Operator}, b::ScalarFun) = map(a->a*b, A)
 
 
 

src/PDE/KroneckerOperator.jl

@@ -450,7 +450,7 @@ end
 function (*)(ko::KroneckerOperator{<:Operator, <:ConstantOperator}, pf::ProductFun)
     O1, O2 = ko.ops
     O12 = O2.λ * O1
-    ProductFun(map(x -> O12*x, pf.coefficients), factors(pf.space)[2])
+    ProductFun(map(x -> O12*x, pf.coefficients), factor(pf.space, 2))
 end
 
 function (*)(ko::KroneckerOperator, lrf::LowRankFun)

src/PDE/PDE.jl

@@ -22,8 +22,13 @@ function Laplacian(d::BivariateSpace,k::Integer)
 end
 
 Laplacian(d::EuclideanDomain{2}, k::Integer) = Laplacian(Space(d),k)
-grad(d::ProductDomain) = [Derivative(d,[1,0]),Derivative(d,[0,1])]
-
+grad(d::ProductDomain) = grad(Space(d))
+function grad(d::BivariateSpace)
+    n = length(factors(d))
+    @assert n == 2 "grad for n>2 is not implemented"
+    Vec{2}(Derivative(d, Vec{2}(1,0)), Derivative(d, Vec{2}(0,1)))
+end
+grad(f::Fun{<:BivariateSpace}) = Fun(grad(space(f)) * f)
 
 function tensor_Dirichlet(d::Union{ProductDomain,TensorSpace},k)
     @assert nfactors(d)==2
@@ -49,15 +54,17 @@ function timedirichlet(d::Union{ProductDomain,TensorSpace})
 end
 
 
-# Operators on an univariate space may act on the second space of the ProductFun,
-# consistent with treating it as an expansion in the second space
+# Operators on a univariate space act on the coefficient Funs when multiplied from the left,
+# and on the basis of the second space when multiplied from the right.
+# Note that the latter produces a function, and not an operator. To obtain an operator,
+# right multiply by a kronecker product of operators
 # We re-route through _mulop to distinguish between operators on UnivariateSpace and
 # those on BivariateSpace
 function _mulop(B::Operator, ::UnivariateSpace, f::ProductFun)
     if isafunctional(B)
         Fun(factor(space(f),2),map(c->Number(B*c),f.coefficients))
     else
-        ProductFun(space(f),map(c->B*c,f.coefficients))
+        ProductFun(map(c->B*c,f.coefficients), space(f))
     end
 end
 *(B::Operator,f::ProductFun) = _mulop(B, domainspace(B), f)