Upgrade to Julia v0.7

Author: dlfivefifty

REQUIRE

@@ -4,3 +4,6 @@ BlockArrays 0.3.1
 FillArrays 0.1
 BandedMatrices 0.5
 FastGaussQuadrature 0.3
+RecipesBase 0.5.0
+FastTransforms 0.4.1
+StaticArrays 0.3

src/DirichletTriangle.jl

@@ -1,6 +1,6 @@
 # this is TriangleWeight(a,b,c,KoornwinderTriangle(a,b,c)) with some extra columns to span
 # all the polynomials
-immutable DirichletTriangle{a,b,c} <: Space{Triangle,Float64}
+struct DirichletTriangle{a,b,c} <: Space{Triangle,Float64}
     domain::Triangle
 end
 
@@ -112,7 +112,7 @@ end
 
 
 
-function getindex{T}(R::ConcreteConversion{DirichletTriangle{0,1,0},KoornwinderTriangle,T},k::Integer,j::Integer)::T
+function getindex(R::ConcreteConversion{DirichletTriangle{0,1,0},KoornwinderTriangle,T},k::Integer,j::Integer) where T
     K = Int(block(rangespace(R),k))
     J = Int(block(domainspace(R),j))
     κ=k-blockstart(rangespace(R),K)+1
@@ -138,8 +138,7 @@ function getindex{T}(R::ConcreteConversion{DirichletTriangle{0,1,0},KoornwinderT
 end
 
 
-function getindex(R::ConcreteConversion{DirichletTriangle{0,0,1},KoornwinderTriangle},k::Integer,j::Integer)
-    T=eltype(R)
+function getindex(R::ConcreteConversion{DirichletTriangle{0,0,1},KoornwinderTriangle,T},k::Integer,j::Integer) where T
     K = Int(block(rangespace(R),k))
     J = Int(block(domainspace(R),j))
     κ=k-blockstart(rangespace(R),K)+1

src/DiskSpace.jl

@@ -4,7 +4,7 @@ export DiskSpace
 
 
 
-immutable DiskSpace{m,a,b,JS,S} <: AbstractProductSpace{Tuple{JS,S},Complex128,2}
+struct DiskSpace{m,a,b,JS,S} <: AbstractProductSpace{Tuple{JS,S},Complex128,2}
     domain::Disk
     spacet::S
     DiskSpace(d,sp)=new(d,sp)
@@ -65,7 +65,7 @@ function Base.real{JS,DD}(f::ProductFun{JS,Laurent{DD},DiskSpace{0,0,0,JS,Lauren
 
     ProductFun(ret,DiskSpace{0,0,0,JS,Fourier}(space(f).domain,Fourier()))
 end
-#Base.imag{S,T}(u::ProductFun{S,Larent,T})=real(TensorFun(imag(u.coefficients),space(u,2)).').'+imag(TensorFun(real(u.coefficients),space(u,2)).').'
+
 
 
 

src/JacobiSquare.jl

@@ -5,7 +5,7 @@ export WeightedSquare, JacobiSquare
 # as r^m P_k^{a,b}(1-2r^2)
 # when domain is Segment(1,0)
 
-immutable WeightedSquare{S} <: RealUnivariateSpace{Segment{Float64}}
+struct WeightedSquare{S} <: RealUnivariateSpace{Segment{Float64}}
     m::Float64
     space::S
 end

src/MultivariateOrthogonalPolynomials.jl

@@ -2,7 +2,8 @@ __precompile__()
 
 module MultivariateOrthogonalPolynomials
 using Base, RecipesBase, ApproxFun, BandedMatrices, BlockArrays,
-    FastTransforms, FastGaussQuadrature, StaticArrays, FillArrays
+    FastTransforms, FastGaussQuadrature, StaticArrays, FillArrays,
+    Libdl
 
 # package code goes here
 import Base: values,getindex,setindex!,*,.*,+,.+,-,.-,==,<,<=,>,
@@ -11,8 +12,6 @@ import Base: values,getindex,setindex!,*,.*,+,.+,-,.-,==,<,<=,>,
 
 import BandedMatrices: mul!, inbands_getindex, inbands_setindex!
 
-importall ApproxFun
-
 # ApproxFun general import
 import ApproxFun: BandedMatrix, order, blocksize,
                   linesum,complexlength, BandedBlockBandedMatrix,

src/Triangle.jl

@@ -70,7 +70,7 @@ Base.isnan(::Triangle) = false
 # P_{n-k}^{2k+β+γ+1,α}(2x-1)*(1-x)^k*P_k^{γ,β}(2y/(1-x)-1)
 
 
-immutable ProductTriangle <: AbstractProductSpace{Tuple{WeightedJacobi{Segment{Float64},Float64},
+struct ProductTriangle <: AbstractProductSpace{Tuple{WeightedJacobi{Segment{Float64},Float64},
                                                         Jacobi{Segment{Float64},Float64}},
                                                   Triangle,Float64}
     α::Float64
@@ -80,7 +80,7 @@ immutable ProductTriangle <: AbstractProductSpace{Tuple{WeightedJacobi{Segment{F
 end
 
 
-immutable KoornwinderTriangle <: Space{Triangle,Float64}
+struct KoornwinderTriangle <: Space{Triangle,Float64}
     α::Float64
     β::Float64
     γ::Float64
@@ -338,7 +338,7 @@ end
 columnspace(T::ProductTriangle,k::Integer) =
     JacobiWeight(0.,k-1.,Jacobi(T.α,2k-1+T.β+T.γ,Segment(0.,1.)))
 
-Base.sum{KT<:KoornwinderTriangle}(f::Fun{KT}) =
+Base.sum(f::Fun{<:KoornwinderTriangle}) =
     Fun(f,KoornwinderTriangle(0,0,0)).coefficients[1]/2
 
 # convert coefficients
@@ -350,17 +350,17 @@ Base.sum{KT<:KoornwinderTriangle}(f::Fun{KT}) =
 function coefficients(f::AbstractVector,K::KoornwinderTriangle,P::ProductTriangle)
     C=totensor(K,f)
     D=Float64[2.0^(-k) for k=0:size(C,1)-1]
-    fromtensor(K,(C.')*diagm(D))
+    fromtensor(K,transpose(C)*diagm(D))
 end
 
 function coefficients(f::AbstractVector,K::ProductTriangle,P::KoornwinderTriangle)
     C=totensor(K,f)
     D=Float64[2.0^(k) for k=0:size(C,1)-1]
-    fromtensor(P,(C*diagm(D)).')
+    fromtensor(P,transpose(C*diagm(D)))
 end
 
 
-function clenshaw2D{T}(Jx,Jy,cfs::Vector{Vector{T}},x,y)
+function clenshaw2D(Jx,Jy,cfs::Vector{Vector{T}},x,y) where T
     N=length(cfs)
     bk1=zeros(T,N+1)
     bk2=zeros(T,N+2)
@@ -545,9 +545,9 @@ function getindex(D::ConcreteDerivative{KoornwinderTriangle},k::Integer,j::Integ
     end
 end
 
-function Base.convert{T}(::Type{BandedBlockBandedMatrix},
+function Base.convert(::Type{BandedBlockBandedMatrix},
         S::SubOperator{T,ConcreteDerivative{KoornwinderTriangle,Vector{Int},T},
-                                                                        Tuple{BlockRange1,BlockRange1}})
+                                                                        Tuple{BlockRange1,BlockRange1}}) where T
     ret = BandedBlockBandedMatrix(Zeros,S)
     D = parent(S)
     sp=domainspace(D)
@@ -851,12 +851,12 @@ end
 ## Jacobi Operators
 
 # k is 1, 2, ... for x, y, z,...
-immutable Lowering{k,S,T} <: Operator{T}
+struct Lowering{k,S,T} <: Operator{T}
     space::S
 end
 
-Base.convert{k}(::Type{Lowering{k}},sp) = Lowering{k,typeof(sp),prectype(sp)}(sp)
-Base.convert{x,T,S}(::Type{Operator{T}},J::Lowering{x,S}) = Lowering{x,S,T}(J.space)
+Base.convert(::Type{Lowering{k}},sp) where k = Lowering{k,typeof(sp),prectype(sp)}(sp)
+Base.convert(::Type{Operator{T}},J::Lowering{x,S}) where {x,T,S} = Lowering{x,S,T}(J.space)
 
 
 domainspace(R::Lowering) = R.space
@@ -882,7 +882,7 @@ rangespace(R::Lowering{3,KoornwinderTriangle}) =
     KoornwinderTriangle(R.space.α,R.space.β,R.space.γ-1,domain(domainspace(R)))
 
 
-function getindex{T}(R::Lowering{1,KoornwinderTriangle,T},k::Integer,j::Integer)
+function getindex(R::Lowering{1,KoornwinderTriangle,T},k::Integer,j::Integer) where T
     α,β,γ=R.space.α,R.space.β,R.space.γ
     K = Int(block(rangespace(R),k))
     J = Int(block(domainspace(R),j))
@@ -979,8 +979,8 @@ function Base.convert(::Type{BandedBlockBandedMatrix},S::SubOperator{T,Lowering{
 end
 
 
-function Base.convert{T}(::Type{BandedBlockBandedMatrix},S::SubOperator{T,Lowering{2,KoornwinderTriangle,T},
-                                                                        Tuple{BlockRange1,BlockRange1}})
+function Base.convert(::Type{BandedBlockBandedMatrix},S::SubOperator{T,Lowering{2,KoornwinderTriangle,T},
+                                                                        Tuple{BlockRange1,BlockRange1}}) where T
     ret = BandedBlockBandedMatrix(Zeros,S)
     R = parent(S)
     α,β,γ=R.space.α,R.space.β,R.space.γ
@@ -1017,8 +1017,8 @@ function Base.convert{T}(::Type{BandedBlockBandedMatrix},S::SubOperator{T,Loweri
     ret
 end
 
-function Base.convert{T}(::Type{BandedBlockBandedMatrix},S::SubOperator{T,Lowering{3,KoornwinderTriangle,T},
-                                                                        Tuple{BlockRange1,BlockRange1}})
+function Base.convert(::Type{BandedBlockBandedMatrix},S::SubOperator{T,Lowering{3,KoornwinderTriangle,T},
+                                                                        Tuple{BlockRange1,BlockRange1}}) where T
     ret = BandedBlockBandedMatrix(Zeros,S)
     R = parent(S)
     α,β,γ=R.space.α,R.space.β,R.space.γ
@@ -1057,7 +1057,7 @@ end
 
 ### Weighted
 
-immutable TriangleWeight{S} <: WeightSpace{S,Triangle,Float64}
+struct TriangleWeight{S} <: WeightSpace{S,Triangle,Float64}
     α::Float64
     β::Float64
     γ::Float64
@@ -1082,12 +1082,12 @@ weight(S::TriangleWeight,xy::Vec) = weight(S,xy...)
 
 setdomain(K::TriangleWeight, d::Triangle) = TriangleWeight(K.α,K.β,K.γ,setdomain(K.space,d))
 
-immutable TriangleWeightEvaluatePlan{S,PP}
+struct TriangleWeightEvaluatePlan{S,PP}
     space::S
     plan::PP
 end
 
-plan_evaluate{SS}(f::Fun{TriangleWeight{SS}},xy...) =
+plan_evaluate(f::Fun{<:TriangleWeight},xy...) =
     TriangleWeightEvaluatePlan(space(f),
         plan_evaluate(Fun(space(f).space,coefficients(f)),xy...))
 
@@ -1325,7 +1325,7 @@ subblockbandinds(D::ConcreteDerivative{TriangleWeight{KoornwinderTriangle}},k::I
     k==1 ? -1 : 0  #TODO: subblockbandinds (-1,-1) for Dy
 
 
-function getindex{OT,T}(D::ConcreteDerivative{TriangleWeight{KoornwinderTriangle},OT,T},k::Integer,j::Integer)::T
+function getindex(D::ConcreteDerivative{TriangleWeight{KoornwinderTriangle},OT,T},k::Integer,j::Integer) where {OT,T}
     α,β,γ=D.space.α,D.space.β,D.space.γ
     K = Int(block(rangespace(D),k))
     J = Int(block(domainspace(D),j))
@@ -1349,7 +1349,7 @@ end
 
 
 ## Multiplication Operators
-function operator_clenshaw2D{T}(Jx,Jy,cfs::Vector{Vector{T}},x,y)
+function operator_clenshaw2D(Jx,Jy,cfs::Vector{Vector{T}},x,y) where T
     N=length(cfs)
     S = domainspace(x)
     Z=ZeroOperator(S,S)

src/c_tri2cheb.jl

@@ -4,7 +4,7 @@ struct ft_plan_struct end
 const PlanPtr = Ptr{ft_plan_struct}
 
 
-if Base.Libdl.find_library(libfasttransforms) ≡ libfasttransforms
+if Libdl.find_library(libfasttransforms) ≡ libfasttransforms
     c_plan_sph2fourier(n::Int) = ccall((:plan_sph2fourier, libfasttransforms), PlanPtr, (Int64, ), n)
     fc_sph2fourier(P::PlanPtr, A::Matrix{Float64}) = ccall((:execute_sph2fourier, libfasttransforms), Void, (PlanPtr, Ptr{Float64}, Int64, Int64), P, A, size(A, 1), size(A, 2))