Merge pull request #298 from gridap/use_promotion_in_tensor_values

Use promotion in tensor values

NEWS.md

@@ -18,6 +18,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - One of the `GradConformingFESpace` methods now more general `ConformingFESpace`. Since PR [#293](https://github.com/gridap/Gridap.jl/pull/293).
   - `DivConformingFESpace` and `CurlConformingFESpace` constructors eliminated. Since PR [#293](https://github.com/gridap/Gridap.jl/pull/293).
 
+### Fixed
+
+  - Construction of `VectorValue`, `TensorValue`, et al. objects from non-homogeneous arguments.  This solves some problems associated with automatic differentiation. Since PR [#298](https://github.com/gridap/Gridap.jl/pull/298).
+
 ## [0.11.2] - 2020-06-22
 
 ### Added

src/TensorValues/SymFourthOrderTensorValueTypes.jl

@@ -40,11 +40,17 @@ SymFourthOrderTensorValue{D}(data::NTuple{L,T}) where {D,L,T}           = SymFou
 SymFourthOrderTensorValue{D,T1}(data::NTuple{L,T2}) where {D,L,T1,T2}   = SymFourthOrderTensorValue{D,T1}(NTuple{L,T1}(data))
 SymFourthOrderTensorValue{D,T1,L}(data::NTuple{L,T2}) where {D,L,T1,T2} = SymFourthOrderTensorValue{D,T1}(NTuple{L,T1}(data))
 
+# SymTensorValue single Tuple argument constructor
+
+SymFourthOrderTensorValue(data::Tuple) = SymFourthOrderTensorValue(promote(data...))
+SymFourthOrderTensorValue{D}(data::Tuple) where {D} = SymFourthOrderTensorValue{D}(promote(data...))
+SymFourthOrderTensorValue{D,T1}(data::Tuple) where {D,T1} = SymFourthOrderTensorValue{D,T1}(NTuple{length(data),T1}(data))
+
 # SymTensorValue Vararg constructor
 
-SymFourthOrderTensorValue(data::T...) where {T}              = SymFourthOrderTensorValue(data)
-SymFourthOrderTensorValue{D}(data::T...) where {D,T}         = SymFourthOrderTensorValue{D}(data)
-SymFourthOrderTensorValue{D,T1}(data::T2...) where {D,T1,T2} = SymFourthOrderTensorValue{D,T1}(data)
+SymFourthOrderTensorValue(data...) = SymFourthOrderTensorValue(data)
+SymFourthOrderTensorValue{D}(data...) where {D} = SymFourthOrderTensorValue{D}(data)
+SymFourthOrderTensorValue{D,T1}(data...) where {D,T1} = SymFourthOrderTensorValue{D,T1}(data)
 
 ###############################################################
 # Conversions (SymTensorValue)

src/TensorValues/SymTensorValueTypes.jl

@@ -40,11 +40,19 @@ SymTensorValue{D}(data::NTuple{L,T}) where {D,L,T}           = SymTensorValue{D,
 SymTensorValue{D,T1}(data::NTuple{L,T2}) where {D,L,T1,T2}   = SymTensorValue{D,T1}(NTuple{L,T1}(data))
 SymTensorValue{D,T1,L}(data::NTuple{L,T2}) where {D,L,T1,T2} = SymTensorValue{D,T1}(NTuple{L,T1}(data))
 
+# SymTensorValue single Tuple argument constructor
+
+SymTensorValue(data::Tuple)                      = SymTensorValue(promote(data...))
+SymTensorValue{D}(data::Tuple) where {D}         = SymTensorValue{D}(promote(data...))
+SymTensorValue{D,T1}(data::Tuple) where {D,T1}   = SymTensorValue{D,T1}(NTuple{length(data),T1}(data))
+SymTensorValue{D,T1,L}(data::Tuple) where {D,T1,L}   = SymTensorValue{D,T1}(NTuple{L,T1}(data))
+
 # SymTensorValue Vararg constructor
 
-SymTensorValue(data::T...) where {T}              = SymTensorValue(data)
-SymTensorValue{D}(data::T...) where {D,T}         = SymTensorValue{D}(data)
-SymTensorValue{D,T1}(data::T2...) where {D,T1,T2} = SymTensorValue{D,T1}(data)
+SymTensorValue(data...)                    = SymTensorValue(data)
+SymTensorValue{D}(data...)    where {D}    = SymTensorValue{D}(data)
+SymTensorValue{D,T1}(data...) where {D,T1} = SymTensorValue{D,T1}(data)
+SymTensorValue{D,T1,L}(data...) where {D,T1,L} = SymTensorValue{D,T1}(data)
 
 # SymTensorValue single AbstractMatrix argument constructor
 

src/TensorValues/TensorValueTypes.jl

@@ -41,13 +41,21 @@ TensorValue{D1,D2}(data::NTuple{L,T}) where {D1,D2,L,T}           = TensorValue{
 TensorValue{D1,D2,T1}(data::NTuple{L,T2}) where {D1,D2,L,T1,T2}   = TensorValue{D1,D2,T1}(NTuple{L,T1}(data))
 TensorValue{D1,D2,T1,L}(data::NTuple{L,T2}) where {D1,D2,L,T1,T2} = TensorValue{D1,D2,T1}(NTuple{L,T1}(data))
 
+# TensorValue single Tuple argument constructor
+
+TensorValue(data::Tuple)                             = TensorValue(promote(data...))
+TensorValue{D}(data::Tuple)        where {D}         = TensorValue{D}(promote(data...))
+TensorValue{D1,D2}(data::Tuple)    where {D1,D2}     = TensorValue{D1,D2}(promote(data...))
+TensorValue{D1,D2,T1}(data::Tuple) where {D1,D2,T1}  = TensorValue{D1,D2,T1}(NTuple{length(data),T1}(data))
+TensorValue{D1,D2,T1,L}(data::Tuple) where {D1,D2,T1,L}  = TensorValue{D1,D2,T1}(NTuple{length(data),T1}(data))
+
 # TensorValue Vararg constructor
 
-TensorValue(data::T...) where {T}                      = TensorValue(data)
-TensorValue{D}(data::T...) where {D,T}                 = TensorValue{D}(data)
-TensorValue{D1,D2}(data::T...) where {D1,D2,T}         = TensorValue{D1,D2,T}(data)
-TensorValue{D1,D2,T1}(data::T2...) where {D1,D2,T1,T2} = TensorValue{D1,D2,T1}(data)
-TensorValue{D1,D2,T1,L}(data::T2...) where {D1,D2,L,T1,T2} = TensorValue{D1,D2,T1}(data)
+TensorValue(data...)                            = TensorValue(data)
+TensorValue{D}(data...)        where {D}        = TensorValue{D}(data)
+TensorValue{D1,D2}(data...)    where {D1,D2}    = TensorValue{D1,D2}(data)
+TensorValue{D1,D2,T1}(data...) where {D1,D2,T1} = TensorValue{D1,D2,T1}(data)
+TensorValue{D1,D2,T1,L}(data...) where {D1,D2,T1,L} = TensorValue{D1,D2,T1}(data)
 
 # TensorValue single AbstractMatrix argument constructor
 

src/TensorValues/ThirdOrderTensorValueTypes.jl

@@ -31,13 +31,27 @@ ThirdOrderTensorValue{D1,D2,D3}(data::NTuple{L,T}) where {D1,D2,D3,L,T}
 ThirdOrderTensorValue{D1,D2,D3,T1}(data::NTuple{L,T2}) where {D1,D2,D3,L,T1,T2}   = ThirdOrderTensorValue{D1,D2,D3,T1}(NTuple{L,T1}(data))
 ThirdOrderTensorValue{D1,D2,D3,T1,L}(data::NTuple{L,T2}) where {D1,D2,D3,L,T1,T2} = ThirdOrderTensorValue{D1,D2,D3,T1}(NTuple{L,T1}(data))
 
+# ThirdOrderTensorValue single Tuple argument constructor
+
+ThirdOrderTensorValue(data::Tuple) = ThirdOrderTensorValue(promote(data...))
+ThirdOrderTensorValue{D}(data::Tuple) where {D} = ThirdOrderTensorValue{D,D,D}(promote(data...))
+ThirdOrderTensorValue{D1,D2,D3}(data::Tuple) where {D1,D2,D3} = ThirdOrderTensorValue{D1,D2,D3}(promote(data...))
+ThirdOrderTensorValue{D1,D2,D3,T1}(data::Tuple) where {D1,D2,D3,T1}  = ThirdOrderTensorValue{D1,D2,D3,T1}(NTuple{length(data),T1}(data))
+ThirdOrderTensorValue{D1,D2,D3,T1,L}(data::Tuple) where {D1,D2,D3,T1,L}  = ThirdOrderTensorValue{D1,D2,D3,T1}(NTuple{L,T1}(data))
+
 # ThirdOrderTensorValue Vararg constructor
 
-ThirdOrderTensorValue(data::T...) where {T}                      = ThirdOrderTensorValue(data)
-ThirdOrderTensorValue{D}(data::T...) where {D,T}                 = ThirdOrderTensorValue{D}(data)
-ThirdOrderTensorValue{D1,D2,D3}(data::T...) where {D1,D2,D3,T}   = ThirdOrderTensorValue{D1,D2,D3}(data)
-ThirdOrderTensorValue{D1,D2,D3,T1}(data::T2...) where {D1,D2,D3,T1,T2} =  ThirdOrderTensorValue{D1,D2,D3,T1}(data)
-ThirdOrderTensorValue{D1,D2,D3,T1,L}(data::T2...) where {D1,D2,D3,L,T1,T2} = ThirdOrderTensorValue{D1,D2,D3,T1,L}(data)
+ThirdOrderTensorValue(data...) = ThirdOrderTensorValue(data)
+ThirdOrderTensorValue{D}(data...) where {D} = ThirdOrderTensorValue{D}(data)
+ThirdOrderTensorValue{D1,D2,D3}(data...) where {D1,D2,D3} = ThirdOrderTensorValue{D1,D2,D3}(data)
+ThirdOrderTensorValue{D1,D2,D3,T1}(data...) where {D1,D2,D3,T1} =  ThirdOrderTensorValue{D1,D2,D3,T1}(data)
+ThirdOrderTensorValue{D1,D2,D3,T1,L}(data...) where {D1,D2,D3,T1,L} =  ThirdOrderTensorValue{D1,D2,D3,T1}(data)
+
+# From an array
+
+ThirdOrderTensorValue(data::AbstractArray{T,3}) where {T} = ThirdOrderTensorValue(NTuple{length(data),T}(data))
+ThirdOrderTensorValue{D}(data::AbstractArray{T,3}) where {D,T} = ThirdOrderTensorValue{D}(NTuple{length(data),T}(data))
+ThirdOrderTensorValue{D,T1}(data::AbstractArray{T2,3}) where {D,T1,T2} = ThirdOrderTensorValue{D,T1}(NTuple{length(data),T}(data))
 
 change_eltype(::Type{ThirdOrderTensorValue{D1,D2,D3,T1,L}},::Type{T2}) where {D1,D2,D3,T1,T2,L} = ThirdOrderTensorValue{D1,D2,D3,T2,L}
 change_eltype(::T,::Type{T2}) where {T<:ThirdOrderTensorValue,T2} = change_eltype(T,T2)

src/TensorValues/VectorValueTypes.jl

@@ -30,11 +30,23 @@ VectorValue(data::NTuple{D,T})        where {D,T}     = VectorValue{D,T}(data)
 VectorValue{D}(data::NTuple{D,T})     where {D,T}     = VectorValue{D,T}(data)
 VectorValue{D,T1}(data::NTuple{D,T2}) where {D,T1,T2} = VectorValue{D,T1}(NTuple{D,T1}(data))
 
+VectorValue{D}(data::NTuple{D2,T2}) where {D,D2,T2} = @unreachable
+VectorValue{D1,T1}(data::NTuple{D2,T2}) where {D1,T1,D2,T2} = @unreachable
+
+# VectorValue single Tuple argument constructor
+
+VectorValue(data::Tuple)                    = VectorValue(promote(data...))
+VectorValue{D}(data::Tuple)    where {D}    = VectorValue{D}(promote(data...))
+VectorValue{D,T1}(data::Tuple) where {D,T1} = VectorValue{D,T1}(NTuple{D,T1}(data))
+
 # VectorValue Vararg constructor
 
-VectorValue(data::T...) where {T}              = VectorValue(data)
-VectorValue{D}(data::T...) where {D,T}         = VectorValue{D}(data)
-VectorValue{D,T1}(data::T2...) where {D,T1,T2} = VectorValue{D,T1}(data)
+VectorValue(data...)                    = VectorValue(data)
+VectorValue{D}(data...)    where {D}    = VectorValue{D}(data)
+VectorValue{D,T1}(data...) where {D,T1} = VectorValue{D,T1}(data)
+
+# Fix for julia 1.0.4
+VectorValue{D}(data::T...)    where {D,T}    = VectorValue{D,T}(data)
 
 # VectorValue single AbstractVector argument constructor
 

test/FieldsTests/DiffOperatorsTests.jl

@@ -74,4 +74,14 @@ for x in xs
   @test Δ(u)(x) == Δu(x)
 end
 
+u(x) = VectorValue( x[1]^2 + 2*x[2]^2, 0 )
+∇u(x) = TensorValue( 2*x[1], 4*x[2], 0, 0 )
+Δu(x) = VectorValue( 6, 0 )
+
+for x in xs
+  @test (∇⋅u)(x) == tr(∇u(x)) 
+  @test (∇×u)(x) == grad2curl(∇u(x))
+  @test Δ(u)(x) == Δu(x)
+end
+
 end # module

test/TensorValuesTests/TypesTests.jl

@@ -40,6 +40,22 @@ t = TensorValue{1}((10,))
 @test isa(t,TensorValue{1,1,Int})
 @test convert(SMatrix{1,1,Int},t) == 10*ones(1,1)
 
+t = TensorValue(1,2.0,3,4)
+@test isa(t,TensorValue{2,2,Float64})
+@test convert(SMatrix{2,2,Float64},t) == [1 3;2 4]
+
+t = TensorValue{2}(1,2.0,3,4)
+@test isa(t,TensorValue{2,2,Float64})
+@test convert(SMatrix{2,2,Float64},t) == [1 3;2 4]
+
+t = TensorValue{2,2}(1,2.0,3,4)
+@test isa(t,TensorValue{2,2,Float64})
+@test convert(SMatrix{2,2,Float64},t) == [1 3;2 4]
+
+t = TensorValue{2,2,Int}(1,2.0,3,4)
+@test isa(t,TensorValue{2,2,Int})
+@test convert(SMatrix{2,2,Int},t) == [1 3;2 4]
+
 # Constructors (SymTensorValue)
 
 s = SymTensorValue( (11,21,22) )
@@ -74,6 +90,18 @@ s = SymTensorValue{0,Int}()
 @test isa(s,SymTensorValue{0,Int})
 @test convert(SMatrix{0,0,Int},s) == Array{Any,2}(undef,0,0)
 
+s = SymTensorValue(11,21.0,22)
+@test isa(s,SymTensorValue{2,Float64})
+@test convert(SMatrix{2,2,Float64},s) == [11.0 21.0;21.0 22.0]
+
+s = SymTensorValue{2}(11,21.0,22)
+@test isa(s,SymTensorValue{2,Float64})
+@test convert(SMatrix{2,2,Float64},s) == [11.0 21.0;21.0 22.0]
+
+s = SymTensorValue{2,Int}(11,21.0,22)
+@test isa(s,SymTensorValue{2,Int})
+@test convert(SMatrix{2,2,Int},s) == [11.0 21.0;21.0 22.0]
+
 # Constructors (SymFourthOrderTensorValue)
 
 s = SymFourthOrderTensorValue( (1111,1121,1122, 2111,2121,2122, 2211,2221,2222) )
@@ -108,8 +136,19 @@ s = SymFourthOrderTensorValue{0,Int}()
 @test isa(s,SymFourthOrderTensorValue{0,Int})
 @test Tuple(s) == ()
 
-# Constructors (VectorValue)
+s = SymFourthOrderTensorValue(1111,2111,2211.0, 1121,2121.0,2221, 1122,2122,2222)
+@test isa(s,SymFourthOrderTensorValue{2,Float64})
+@test Tuple(s) == (1111,2111,2211, 1121,2121,2221, 1122,2122,2222  )
 
+s = SymFourthOrderTensorValue{2}(1111,2111,2211.0, 1121,2121.0,2221, 1122,2122,2222)
+@test isa(s,SymFourthOrderTensorValue{2,Float64})
+@test Tuple(s) == (1111,2111,2211, 1121,2121,2221, 1122,2122,2222  )
+
+s = SymFourthOrderTensorValue{2,Int}(1111,2111,2211.0, 1121,2121.0,2221, 1122,2122,2222)
+@test isa(s,SymFourthOrderTensorValue{2,Int})
+@test Tuple(s) == (1111,2111,2211, 1121,2121,2221, 1122,2122,2222  )
+
+# Constructors (VectorValue)
 
 a = SVector(1)
 g = VectorValue(a)
@@ -158,10 +197,6 @@ g = VectorValue{4,Float64}((1,2,3,4))
 @test isa(g,VectorValue{4,Float64})
 @test convert(SVector{4,Float64},g) == [1,2,3,4]
 
-g = VectorValue{4}(1,2,3,4)
-@test isa(g,VectorValue{4,Int})
-@test convert(SVector{4,Int},g) == [1,2,3,4]
-
 g = VectorValue{4,Float64}(1,2,3,4)
 @test isa(g,VectorValue{4,Float64})
 @test convert(SVector{4,Float64},g) == [1,2,3,4]
@@ -178,6 +213,23 @@ g = VectorValue(1)
 @test isa(g,VectorValue{1,Int})
 @test convert(SVector{1,Int},g) == [1,]
 
+g = VectorValue(1.0,2,3.0,4)
+@test isa(g,VectorValue{4,Float64})
+@test convert(SVector{4,Float64},g) == [1,2,3,4]
+
+g = VectorValue{4}(1.0,2,3.0,4)
+@test isa(g,VectorValue{4,Float64})
+@test convert(SVector{4,Float64},g) == [1,2,3,4]
+
+g = VectorValue{4,Int}(1.0,2,3.0,4)
+@test isa(g,VectorValue{4,Int})
+@test convert(SVector{4,Int},g) == [1,2,3,4]
+
+g = VectorValue((1.0,2,3.0,4))
+@test isa(g,VectorValue{4,Float64})
+@test convert(SVector{4,Float64},g) == [1,2,3,4]
+
+
 # Initializers
 
 z = zero(TensorValue{3,3,Int,9})
@@ -269,6 +321,36 @@ v = SymFourthOrderTensorValue{2,Int64}(1111,1121,1122, 2111,2121,2122, 2211,2221
 s = "(1111, 1121, 1122, 2111, 2121, 2122, 2211, 2221, 2222)"
 @test string(v) == s
 
+# Third order tensors
+
+a = SArray{Tuple{2,2,2}}(1,2,3,4,5,6,7,8)
+t = ThirdOrderTensorValue(a)
+@test isa(t,ThirdOrderTensorValue{2,2,2,Int})
+
+t = ThirdOrderTensorValue(1,2,3,4,5,6,7,8)
+@test isa(t,ThirdOrderTensorValue{2,2,2,Int})
+
+t = ThirdOrderTensorValue{2}(1,2,3,4,5,6,7,8)
+@test isa(t,ThirdOrderTensorValue{2,2,2,Int})
+
+t = ThirdOrderTensorValue{2,2,2}(1,2,3,4,5,6,7,8)
+@test isa(t,ThirdOrderTensorValue{2,2,2,Int})
+
+t = ThirdOrderTensorValue{2,2,2,Float64}(1,2,3,4,5,6,7,8)
+@test isa(t,ThirdOrderTensorValue{2,2,2,Float64})
+
+t = ThirdOrderTensorValue(1,2.0,3,4,5,6,7,8)
+@test isa(t,ThirdOrderTensorValue{2,2,2,Float64})
+
+t = ThirdOrderTensorValue{2}(1,2.0,3,4,5,6,7,8)
+@test isa(t,ThirdOrderTensorValue{2,2,2,Float64})
+
+t = ThirdOrderTensorValue{2,2,2}(1,2.0,3,4,5,6,7,8)
+@test isa(t,ThirdOrderTensorValue{2,2,2,Float64})
+
+t = ThirdOrderTensorValue{2,2,2,Int}(1,2.0,3,4,5,6,7,8)
+@test isa(t,ThirdOrderTensorValue{2,2,2,Int})
+
 # Misc
 
 M = mutable(VectorValue{3,Int})