Mercurial > repos > public > sbplib_julia
annotate src/LazyTensors/lazy_tensor_operations.jl @ 2061:e70417f95713 feature/lazy_tensors/zero_tensor
Add ZeroTensor
| author | Jonatan Werpers <jonatan@werpers.com> |
|---|---|
| date | Mon, 16 Feb 2026 21:46:35 +0100 |
| parents | ed50eec18365 |
| children |
| rev | line source |
|---|---|
|
196
b3c252280a19
Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents:
195
diff
changeset
|
1 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
2 TensorApplication{T,R,D} <: LazyArray{T,R} |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
3 |
| 995 | 4 Struct for lazy application of a LazyTensor. Created using `*`. |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
5 |
| 995 | 6 Allows the result of a `LazyTensor` applied to a vector to be treated as an `AbstractArray`. |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
7 With a mapping `m` and a vector `v` the TensorApplication object can be created by `m*v`. |
|
1513
d7bc11053951
Fix spelling mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
1365
diff
changeset
|
8 The actual result will be calculated when indexing into `m*v`. |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
9 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
10 struct TensorApplication{T,R,D, TM<:LazyTensor{<:Any,R,D}, AA<:AbstractArray{<:Any,D}} <: LazyArray{T,R} |
|
378
946516954c85
Use concrete types in LazyTensorApplication
Jonatan Werpers <jonatan@werpers.com>
parents:
359
diff
changeset
|
11 t::TM |
|
946516954c85
Use concrete types in LazyTensorApplication
Jonatan Werpers <jonatan@werpers.com>
parents:
359
diff
changeset
|
12 o::AA |
|
942
7829c09f8137
Add promotion calculation of element type for LazyTensorMappingApplication
Jonatan Werpers <jonatan@werpers.com>
parents:
838
diff
changeset
|
13 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
14 function TensorApplication(t::LazyTensor{<:Any,R,D}, o::AbstractArray{<:Any,D}) where {R,D} |
|
1005
becd95ba0fce
Add bounds checking for lazy tensor application and clea up tests a bit
Jonatan Werpers <jonatan@werpers.com>
parents:
1002
diff
changeset
|
15 @boundscheck check_domain_size(t, size(o)) |
|
977
043d13ef8898
Fix type calculation of LazyTensorMappingApplication element type
Jonatan Werpers <jonatan@werpers.com>
parents:
976
diff
changeset
|
16 I = ntuple(i->1, range_dim(t)) |
|
043d13ef8898
Fix type calculation of LazyTensorMappingApplication element type
Jonatan Werpers <jonatan@werpers.com>
parents:
976
diff
changeset
|
17 T = typeof(apply(t,o,I...)) |
|
942
7829c09f8137
Add promotion calculation of element type for LazyTensorMappingApplication
Jonatan Werpers <jonatan@werpers.com>
parents:
838
diff
changeset
|
18 return new{T,R,D,typeof(t), typeof(o)}(t,o) |
|
7829c09f8137
Add promotion calculation of element type for LazyTensorMappingApplication
Jonatan Werpers <jonatan@werpers.com>
parents:
838
diff
changeset
|
19 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
20 end |
|
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
21 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
22 function Base.getindex(ta::TensorApplication{T,R}, I::Vararg{Any,R}) where {T,R} |
|
1005
becd95ba0fce
Add bounds checking for lazy tensor application and clea up tests a bit
Jonatan Werpers <jonatan@werpers.com>
parents:
1002
diff
changeset
|
23 @boundscheck checkbounds(ta, Int.(I)...) |
|
1015
4dd3c2312d9e
Fix some @boundscheck @inboudns combos
Jonatan Werpers <jonatan@werpers.com>
parents:
1007
diff
changeset
|
24 return @inbounds apply(ta.t, ta.o, I...) |
|
1005
becd95ba0fce
Add bounds checking for lazy tensor application and clea up tests a bit
Jonatan Werpers <jonatan@werpers.com>
parents:
1002
diff
changeset
|
25 end |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
26 Base.@propagate_inbounds Base.getindex(ta::TensorApplication{T,1} where T, I::CartesianIndex{1}) = ta[Tuple(I)...] # Would otherwise be caught in the previous method. |
|
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
27 Base.size(ta::TensorApplication) = range_size(ta.t) |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
28 |
|
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
29 |
|
194
d30d42a11566
Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents:
190
diff
changeset
|
30 """ |
| 1037 | 31 TensorTranspose{T,R,D} <: LazyTensor{T,D,R} |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
32 |
| 995 | 33 Struct for lazy transpose of a LazyTensor. |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
34 |
|
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
35 If a mapping implements the the `apply_transpose` method this allows working with |
| 995 | 36 the transpose of mapping `m` by using `m'`. `m'` will work as a regular LazyTensor lazily calling |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
37 the appropriate methods of `m`. |
|
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
38 """ |
| 1037 | 39 struct TensorTranspose{T,R,D, TM<:LazyTensor{T,R,D}} <: LazyTensor{T,D,R} |
|
438
907b0510699f
Change LazyTensorTranspose to have concrete fields
Jonatan Werpers <jonatan@werpers.com>
parents:
436
diff
changeset
|
40 tm::TM |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
41 end |
|
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
42 |
|
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
43 # # TBD: Should this be implemented on a type by type basis or through a trait to provide earlier errors? |
| 995 | 44 # Jonatan 2020-09-25: Is the problem that you can take the transpose of any LazyTensor even if it doesn't implement `apply_transpose`? |
| 1037 | 45 Base.adjoint(tm::LazyTensor) = TensorTranspose(tm) |
| 46 Base.adjoint(tmt::TensorTranspose) = tmt.tm | |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
47 |
| 1037 | 48 apply(tmt::TensorTranspose{T,R,D}, v::AbstractArray{<:Any,R}, I::Vararg{Any,D}) where {T,R,D} = apply_transpose(tmt.tm, v, I...) |
| 49 apply_transpose(tmt::TensorTranspose{T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg{Any,R}) where {T,R,D} = apply(tmt.tm, v, I...) | |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
50 |
| 1037 | 51 range_size(tmt::TensorTranspose) = domain_size(tmt.tm) |
| 52 domain_size(tmt::TensorTranspose) = range_size(tmt.tm) | |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
53 |
|
1002
271aa6ae1055
Split out a file for tensor types
Jonatan Werpers <jonatan@werpers.com>
parents:
1001
diff
changeset
|
54 |
| 1840 | 55 """ |
| 56 TensorNegation{T,R,D,...} <: LazyTensor{T,R,D} | |
| 57 | |
| 58 The negation of a LazyTensor. | |
| 59 """ | |
| 60 struct TensorNegation{T,R,D,TM<:LazyTensor{T,R,D}} <: LazyTensor{T,R,D} | |
| 1836 | 61 tm::TM |
| 62 end | |
| 63 | |
| 64 apply(tm::TensorNegation, v, I...) = -apply(tm.tm, v, I...) | |
| 65 apply_transpose(tm::TensorNegation, v, I...) = -apply_transpose(tm.tm, v, I...) | |
| 66 | |
| 67 range_size(tm::TensorNegation) = range_size(tm.tm) | |
| 68 domain_size(tm::TensorNegation) = domain_size(tm.tm) | |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
69 |
| 1878 | 70 |
| 1840 | 71 """ |
| 72 TensorSum{T,R,D,...} <: LazyTensor{T,R,D} | |
|
1002
271aa6ae1055
Split out a file for tensor types
Jonatan Werpers <jonatan@werpers.com>
parents:
1001
diff
changeset
|
73 |
| 1879 | 74 The lazy sum of 2 or more lazy tensors. |
| 1840 | 75 """ |
|
1837
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
76 struct TensorSum{T,R,D,TT<:NTuple{N, LazyTensor{T,R,D}} where N} <: LazyTensor{T,R,D} |
|
1788
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
77 tms::TT |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
78 |
|
1837
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
79 function TensorSum{T,R,D}(tms::TT) where {T,R,D, TT<:NTuple{N, LazyTensor{T,R,D}} where N} |
|
1788
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
80 @boundscheck map(tms) do tm |
|
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
81 check_domain_size(tm, domain_size(tms[1])) |
|
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
82 check_range_size(tm, range_size(tms[1])) |
|
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
83 end |
|
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
84 |
|
1837
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
85 return new{T,R,D,TT}(tms) |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
86 end |
|
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
87 end |
|
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
88 |
| 1879 | 89 """ |
| 90 TensorSum(ts::Vararg{LazyTensor}) | |
| 91 | |
| 92 The lazy sum of the tensors `ts`. | |
| 93 """ | |
|
1837
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
94 function TensorSum(ts::Vararg{LazyTensor}) |
|
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
95 T = eltype(ts[1]) |
|
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
96 R = range_dim(ts[1]) |
|
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
97 D = domain_dim(ts[1]) |
|
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
98 return TensorSum{T,R,D}(ts) |
|
1788
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
99 end |
|
1001
a3df203861d3
Simplify some type parameter usage
Jonatan Werpers <jonatan@werpers.com>
parents:
1000
diff
changeset
|
100 |
|
1837
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
101 function apply(tmBinOp::TensorSum{T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg{Any,R}) where {T,R,D} |
|
1897
ed50eec18365
Change implementation of apply to use sum()
Jonatan Werpers <jonatan@werpers.com>
parents:
1880
diff
changeset
|
102 return sum(tmBinOp.tms) do tm |
|
1788
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
103 apply(tm,v,I...) |
|
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
104 end |
|
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
105 end |
|
8b64df6cadba
Refactor ElementWiseOperation to give a flatter structure of tensor compositions improving type inference
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
106 |
|
1880
378002c78e86
Add implementation of apply_transpose to TensorSum
Jonatan Werpers <jonatan@werpers.com>
parents:
1879
diff
changeset
|
107 function apply_transpose(tmBinOp::TensorSum{T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg{Any,R}) where {T,R,D} |
|
1897
ed50eec18365
Change implementation of apply to use sum()
Jonatan Werpers <jonatan@werpers.com>
parents:
1880
diff
changeset
|
108 return sum(tmBinOp.tms) do tm |
|
1880
378002c78e86
Add implementation of apply_transpose to TensorSum
Jonatan Werpers <jonatan@werpers.com>
parents:
1879
diff
changeset
|
109 apply_transpose(tm,v,I...) |
|
378002c78e86
Add implementation of apply_transpose to TensorSum
Jonatan Werpers <jonatan@werpers.com>
parents:
1879
diff
changeset
|
110 end |
|
378002c78e86
Add implementation of apply_transpose to TensorSum
Jonatan Werpers <jonatan@werpers.com>
parents:
1879
diff
changeset
|
111 end |
|
378002c78e86
Add implementation of apply_transpose to TensorSum
Jonatan Werpers <jonatan@werpers.com>
parents:
1879
diff
changeset
|
112 |
|
1837
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
113 range_size(tmBinOp::TensorSum) = range_size(tmBinOp.tms[1]) |
|
200971c71657
Refactor ElementwiseTensorOperation into TensorSum and use TensorNegation for handling subtraction
Jonatan Werpers <jonatan@werpers.com>
parents:
1836
diff
changeset
|
114 domain_size(tmBinOp::TensorSum) = domain_size(tmBinOp.tms[1]) |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
115 |
| 2061 | 116 TensorSum(a::ZeroTensor{T,R,D}, b::ZeroTensor{T,R,D}) where {T,R,D} = ZeroTensor{T,R,D}() |
| 117 TensorSum(::ZeroTensor, t::LazyTensor) = t | |
| 118 TensorSum(t::LazyTensor, ::ZeroTensor) = t | |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
119 |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
120 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
121 TensorComposition{T,R,K,D} |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
122 |
| 995 | 123 Lazily compose two `LazyTensor`s, so that they can be handled as a single `LazyTensor`. |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
124 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
125 struct TensorComposition{T,R,K,D, TM1<:LazyTensor{T,R,K}, TM2<:LazyTensor{T,K,D}} <: LazyTensor{T,R,D} |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
126 t1::TM1 |
|
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
127 t2::TM2 |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
128 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
129 function TensorComposition(t1::LazyTensor{T,R,K}, t2::LazyTensor{T,K,D}) where {T,R,K,D} |
|
485
4b49f03bdb98
Switch from DimensionMismatch to SizeMismatch for boundschecks on compositions
Jonatan Werpers <jonatan@werpers.com>
parents:
484
diff
changeset
|
130 @boundscheck check_domain_size(t1, range_size(t2)) |
|
417
4c6604b7d990
Add dimension checking in the constructor
Jonatan Werpers <jonatan@werpers.com>
parents:
415
diff
changeset
|
131 return new{T,R,K,D, typeof(t1), typeof(t2)}(t1,t2) |
|
4c6604b7d990
Add dimension checking in the constructor
Jonatan Werpers <jonatan@werpers.com>
parents:
415
diff
changeset
|
132 end |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
133 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
134 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
135 range_size(tm::TensorComposition) = range_size(tm.t1) |
|
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
136 domain_size(tm::TensorComposition) = domain_size(tm.t2) |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
137 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
138 function apply(c::TensorComposition{T,R,K,D}, v::AbstractArray{<:Any,D}, I::Vararg{Any,R}) where {T,R,K,D} |
|
418
264af2bb646f
Switch to using * instead of calling the constructor
Jonatan Werpers <jonatan@werpers.com>
parents:
417
diff
changeset
|
139 apply(c.t1, c.t2*v, I...) |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
140 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
141 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
142 function apply_transpose(c::TensorComposition{T,R,K,D}, v::AbstractArray{<:Any,R}, I::Vararg{Any,D}) where {T,R,K,D} |
|
418
264af2bb646f
Switch to using * instead of calling the constructor
Jonatan Werpers <jonatan@werpers.com>
parents:
417
diff
changeset
|
143 apply_transpose(c.t2, c.t1'*v, I...) |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
144 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
145 |
|
377
8414c2334393
Start implementing LazyLinearMap
Jonatan Werpers <jonatan@werpers.com>
parents:
359
diff
changeset
|
146 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
147 TensorComposition(tm, tmi::IdentityTensor) |
|
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
148 TensorComposition(tmi::IdentityTensor, tm) |
|
479
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
149 |
|
1513
d7bc11053951
Fix spelling mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
1365
diff
changeset
|
150 Composes a `LazyTensor` `tm` with an `IdentityTensor` `tmi`, by returning `tm` |
|
479
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
151 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
152 function TensorComposition(tm::LazyTensor{T,R,D}, tmi::IdentityTensor{T,D}) where {T,R,D} |
|
485
4b49f03bdb98
Switch from DimensionMismatch to SizeMismatch for boundschecks on compositions
Jonatan Werpers <jonatan@werpers.com>
parents:
484
diff
changeset
|
153 @boundscheck check_domain_size(tm, range_size(tmi)) |
|
479
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
154 return tm |
|
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
155 end |
|
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
156 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
157 function TensorComposition(tmi::IdentityTensor{T,R}, tm::LazyTensor{T,R,D}) where {T,R,D} |
|
485
4b49f03bdb98
Switch from DimensionMismatch to SizeMismatch for boundschecks on compositions
Jonatan Werpers <jonatan@werpers.com>
parents:
484
diff
changeset
|
158 @boundscheck check_domain_size(tmi, range_size(tm)) |
|
479
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
159 return tm |
|
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
160 end |
| 995 | 161 # Specialization for the case where tm is an IdentityTensor. Required to resolve ambiguity. |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
162 function TensorComposition(tm::IdentityTensor{T,D}, tmi::IdentityTensor{T,D}) where {T,D} |
|
485
4b49f03bdb98
Switch from DimensionMismatch to SizeMismatch for boundschecks on compositions
Jonatan Werpers <jonatan@werpers.com>
parents:
484
diff
changeset
|
163 @boundscheck check_domain_size(tm, range_size(tmi)) |
|
479
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
164 return tmi |
|
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
165 end |
|
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
166 |
| 2061 | 167 |
| 168 function TensorComposition(a::ZeroTensor{T,R,D}, b::ZeroTensor{T,D,K}) where {T,R,D,K} | |
| 169 return ZeroTensor{T,R,K}() | |
| 170 end | |
| 171 | |
| 172 function TensorComposition(a::ZeroTensor{T,R,D}, b::LazyTensor{T,D,K}) where {T,R,D,K} | |
| 173 return ZeroTensor{T,R,K}() | |
| 174 end | |
| 175 | |
| 176 function TensorComposition(a::LazyTensor{T,R,D}, b::ZeroTensor{T,D,K}) where {T,R,D,K} | |
| 177 return ZeroTensor{T,R,K}() | |
| 178 end | |
| 179 | |
| 180 | |
|
1084
2e606d4c0ab1
Add support for multiplying a LazyTensor with a scalar
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
1037
diff
changeset
|
181 Base.:*(a::T, tm::LazyTensor{T}) where T = TensorComposition(ScalingTensor{T,range_dim(tm)}(a,range_size(tm)), tm) |
|
2e606d4c0ab1
Add support for multiplying a LazyTensor with a scalar
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
1037
diff
changeset
|
182 Base.:*(tm::LazyTensor{T}, a::T) where T = a*tm |
|
992
bc384aaade30
Add a bunch of todos and add a ScalingTensor
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
183 |
|
459
11e58c49fb46
Add some documentation
Jonatan Werpers <jonatan@werpers.com>
parents:
458
diff
changeset
|
184 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
185 InflatedTensor{T,R,D} <: LazyTensor{T,R,D} |
|
459
11e58c49fb46
Add some documentation
Jonatan Werpers <jonatan@werpers.com>
parents:
458
diff
changeset
|
186 |
|
1513
d7bc11053951
Fix spelling mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
1365
diff
changeset
|
187 An inflated `LazyTensor` with dimensions added before and after its actual dimensions. |
|
459
11e58c49fb46
Add some documentation
Jonatan Werpers <jonatan@werpers.com>
parents:
458
diff
changeset
|
188 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
189 struct InflatedTensor{T,R,D,D_before,R_middle,D_middle,D_after, TM<:LazyTensor{T,R_middle,D_middle}} <: LazyTensor{T,R,D} |
| 995 | 190 before::IdentityTensor{T,D_before} |
|
449
14d60de71b72
Change to concrete fields in the type
Jonatan Werpers <jonatan@werpers.com>
parents:
448
diff
changeset
|
191 tm::TM |
| 995 | 192 after::IdentityTensor{T,D_after} |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
193 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
194 function InflatedTensor(before, tm::LazyTensor{T}, after) where T |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
195 R_before = range_dim(before) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
196 R_middle = range_dim(tm) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
197 R_after = range_dim(after) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
198 R = R_before+R_middle+R_after |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
199 |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
200 D_before = domain_dim(before) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
201 D_middle = domain_dim(tm) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
202 D_after = domain_dim(after) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
203 D = D_before+D_middle+D_after |
|
449
14d60de71b72
Change to concrete fields in the type
Jonatan Werpers <jonatan@werpers.com>
parents:
448
diff
changeset
|
204 return new{T,R,D,D_before,R_middle,D_middle,D_after, typeof(tm)}(before, tm, after) |
|
448
912ae510dec9
Use new name of IdentityMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
447
diff
changeset
|
205 end |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
206 end |
|
1002
271aa6ae1055
Split out a file for tensor types
Jonatan Werpers <jonatan@werpers.com>
parents:
1001
diff
changeset
|
207 |
| 461 | 208 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
209 InflatedTensor(before, tm, after) |
|
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
210 InflatedTensor(before,tm) |
|
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
211 InflatedTensor(tm,after) |
| 461 | 212 |
| 995 | 213 The outer product of `before`, `tm` and `after`, where `before` and `after` are `IdentityTensor`s. |
|
465
f270d82fc9ad
Change documention in an attempt to follow the guidelines
Jonatan Werpers <jonatan@werpers.com>
parents:
464
diff
changeset
|
214 |
| 995 | 215 If one of `before` or `after` is left out, a 0-dimensional `IdentityTensor` is used as the default value. |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
216 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
217 If `tm` already is an `InflatedTensor`, `before` and `after` will be extended instead of |
|
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
218 creating a nested `InflatedTensor`. |
| 461 | 219 """ |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
220 InflatedTensor(::IdentityTensor, ::LazyTensor, ::IdentityTensor) |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
221 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
222 function InflatedTensor(before, itm::InflatedTensor, after) |
|
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
223 return InflatedTensor( |
| 995 | 224 IdentityTensor(before.size..., itm.before.size...), |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
225 itm.tm, |
| 995 | 226 IdentityTensor(itm.after.size..., after.size...), |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
227 ) |
|
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
228 end |
|
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
229 |
|
1762
164e26a6cf79
Remove ambiguities in LazyOuterProduct and InflatedTensor
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
230 InflatedTensor(before::IdentityTensor, tm::LazyTensor) = InflatedTensor(before,tm,IdentityTensor{eltype(tm)}()) |
|
164e26a6cf79
Remove ambiguities in LazyOuterProduct and InflatedTensor
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
231 InflatedTensor(tm::LazyTensor, after::IdentityTensor) = InflatedTensor(IdentityTensor{eltype(tm)}(),tm,after) |
|
465
f270d82fc9ad
Change documention in an attempt to follow the guidelines
Jonatan Werpers <jonatan@werpers.com>
parents:
464
diff
changeset
|
232 # Resolve ambiguity between the two previous methods |
|
1762
164e26a6cf79
Remove ambiguities in LazyOuterProduct and InflatedTensor
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
233 InflatedTensor(I1::IdentityTensor, I2::IdentityTensor) = InflatedTensor(I1,I2,IdentityTensor{promote_type(eltype(I1), eltype(I2))}()) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
234 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
235 # TODO: Implement some pretty printing in terms of ⊗. E.g InflatedTensor(I(3),B,I(2)) -> I(3)⊗B⊗I(2) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
236 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
237 function range_size(itm::InflatedTensor) |
|
1225
6567e38b05ca
Replace flatten_tuple with concatenate_tuple
Jonatan Werpers <jonatan@werpers.com>
parents:
1098
diff
changeset
|
238 return concatenate_tuples( |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
239 range_size(itm.before), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
240 range_size(itm.tm), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
241 range_size(itm.after), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
242 ) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
243 end |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
244 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
245 function domain_size(itm::InflatedTensor) |
|
1225
6567e38b05ca
Replace flatten_tuple with concatenate_tuple
Jonatan Werpers <jonatan@werpers.com>
parents:
1098
diff
changeset
|
246 return concatenate_tuples( |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
247 domain_size(itm.before), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
248 domain_size(itm.tm), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
249 domain_size(itm.after), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
250 ) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
251 end |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
252 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
253 function apply(itm::InflatedTensor{T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg{Any,R}) where {T,R,D} |
|
538
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
254 dim_before = range_dim(itm.before) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
255 dim_domain = domain_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
256 dim_range = range_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
257 dim_after = range_dim(itm.after) |
|
520
fe86ac896377
Start refactoring split index and apply to accomodate future addition of apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
501
diff
changeset
|
258 |
|
1229
8f4259fbd39c
Simplify split_index
Jonatan Werpers <jonatan@werpers.com>
parents:
1225
diff
changeset
|
259 view_index, inner_index = split_index(dim_before, dim_domain, dim_range, dim_after, I...) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
260 |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
261 v_inner = view(v, view_index...) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
262 return apply(itm.tm, v_inner, inner_index...) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
263 end |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
264 |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
265 function apply_transpose(itm::InflatedTensor{T,R,D}, v::AbstractArray{<:Any,R}, I::Vararg{Any,D}) where {T,R,D} |
|
538
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
266 dim_before = range_dim(itm.before) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
267 dim_domain = domain_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
268 dim_range = range_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
269 dim_after = range_dim(itm.after) |
|
526
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
270 |
|
1229
8f4259fbd39c
Simplify split_index
Jonatan Werpers <jonatan@werpers.com>
parents:
1225
diff
changeset
|
271 view_index, inner_index = split_index(dim_before, dim_range, dim_domain, dim_after, I...) |
|
526
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
272 |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
273 v_inner = view(v, view_index...) |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
274 return apply_transpose(itm.tm, v_inner, inner_index...) |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
275 end |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
276 |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
277 |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
278 @doc raw""" |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
279 LazyOuterProduct(tms...) |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
280 |
|
1513
d7bc11053951
Fix spelling mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
1365
diff
changeset
|
281 Creates a `TensorComposition` for the outer product of `tms...`. |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
282 This is done by separating the outer product into regular products of outer products involving only identity mappings and one non-identity mapping. |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
283 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
284 First let |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
285 ```math |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
286 \begin{aligned} |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
287 A &= A_{I,J} \\ |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
288 B &= B_{M,N} \\ |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
289 C &= C_{P,Q} \\ |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
290 \end{aligned} |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
291 ``` |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
292 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
293 where ``I``, ``M``, ``P`` are multi-indexes for the ranges of ``A``, ``B``, ``C``, and ``J``, ``N``, ``Q`` are multi-indexes of the domains. |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
294 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
295 We use ``⊗`` to denote the outer product |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
296 ```math |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
297 (A⊗B)_{IM,JN} = A_{I,J}B_{M,N} |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
298 ``` |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
299 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
300 We note that |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
301 ```math |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
302 A⊗B⊗C = (A⊗B⊗C)_{IMP,JNQ} = A_{I,J}B_{M,N}C_{P,Q} |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
303 ``` |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
304 And that |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
305 ```math |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
306 A⊗B⊗C = (A⊗I_{|M|}⊗I_{|P|})(I_{|J|}⊗B⊗I_{|P|})(I_{|J|}⊗I_{|N|}⊗C) |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
307 ``` |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
308 where ``|⋅|`` of a multi-index is a vector of sizes for each dimension. ``I_v`` denotes the identity tensor of size ``v[i]`` in each direction |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
309 To apply ``A⊗B⊗C`` we evaluate |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
310 |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
311 ```math |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
312 (A⊗B⊗C)v = [(A⊗I_{|M|}⊗I_{|P|}) [(I_{|J|}⊗B⊗I_{|P|}) [(I_{|J|}⊗I_{|N|}⊗C)v]]] |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
313 ``` |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
314 """ |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
315 function LazyOuterProduct end |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
316 |
| 995 | 317 function LazyOuterProduct(tm1::LazyTensor{T}, tm2::LazyTensor{T}) where T |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
318 itm1 = InflatedTensor(tm1, IdentityTensor{T}(range_size(tm2))) |
|
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
319 itm2 = InflatedTensor(IdentityTensor{T}(domain_size(tm1)),tm2) |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
320 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
321 return itm1∘itm2 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
322 end |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
323 |
|
1762
164e26a6cf79
Remove ambiguities in LazyOuterProduct and InflatedTensor
Jonatan Werpers <jonatan@werpers.com>
parents:
1609
diff
changeset
|
324 LazyOuterProduct(t1::IdentityTensor, t2::IdentityTensor) = IdentityTensor{promote_type(eltype(t1),eltype(t2))}(t1.size...,t2.size...) |
|
1017
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
325 LazyOuterProduct(t1::LazyTensor, t2::IdentityTensor) = InflatedTensor(t1, t2) |
|
6abbb2c6c3e4
Remove the Lazy prefix on some types
Jonatan Werpers <jonatan@werpers.com>
parents:
1016
diff
changeset
|
326 LazyOuterProduct(t1::IdentityTensor, t2::LazyTensor) = InflatedTensor(t1, t2) |
|
491
2dc2eac27f75
Add special methods for Identity mappings
Jonatan Werpers <jonatan@werpers.com>
parents:
475
diff
changeset
|
327 |
| 995 | 328 LazyOuterProduct(tms::Vararg{LazyTensor}) = foldl(LazyOuterProduct, tms) |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
329 |
| 498 | 330 |
| 331 | |
|
1022
bbbc31953367
Introduce an inflate function in lazy tensors and use it in volume_operator and boundary_operator
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
332 """ |
| 1088 | 333 inflate(tm::LazyTensor, sz, dir) |
| 334 | |
| 335 Inflate `tm` such that it gets the size `sz` in all directions except `dir`. | |
| 336 Here `sz[dir]` is ignored and replaced with the range and domains size of | |
| 337 `tm`. | |
|
1022
bbbc31953367
Introduce an inflate function in lazy tensors and use it in volume_operator and boundary_operator
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
338 |
| 1088 | 339 An example of when this operation is useful is when extending a one |
|
1513
d7bc11053951
Fix spelling mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
1365
diff
changeset
|
340 dimensional difference operator `D` to a 2D grid of a certain size. In that |
| 1088 | 341 case we could have |
|
1022
bbbc31953367
Introduce an inflate function in lazy tensors and use it in volume_operator and boundary_operator
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
342 |
| 1088 | 343 ```julia |
| 344 Dx = inflate(D, (10,10), 1) | |
| 345 Dy = inflate(D, (10,10), 2) | |
| 346 ``` | |
|
1022
bbbc31953367
Introduce an inflate function in lazy tensors and use it in volume_operator and boundary_operator
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
347 """ |
| 1023 | 348 function inflate(tm::LazyTensor, sz, dir) |
| 349 Is = IdentityTensor{eltype(tm)}.(sz) | |
|
1022
bbbc31953367
Introduce an inflate function in lazy tensors and use it in volume_operator and boundary_operator
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
350 parts = Base.setindex(Is, tm, dir) |
|
bbbc31953367
Introduce an inflate function in lazy tensors and use it in volume_operator and boundary_operator
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
351 return foldl(⊗, parts) |
|
bbbc31953367
Introduce an inflate function in lazy tensors and use it in volume_operator and boundary_operator
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
352 end |
|
bbbc31953367
Introduce an inflate function in lazy tensors and use it in volume_operator and boundary_operator
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
353 |
| 995 | 354 function check_domain_size(tm::LazyTensor, sz) |
|
487
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
355 if domain_size(tm) != sz |
|
1006
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
356 throw(DomainSizeMismatch(tm,sz)) |
|
487
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
357 end |
|
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
358 end |
|
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
359 |
|
1006
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
360 function check_range_size(tm::LazyTensor, sz) |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
361 if range_size(tm) != sz |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
362 throw(RangeSizeMismatch(tm,sz)) |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
363 end |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
364 end |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
365 |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
366 struct DomainSizeMismatch <: Exception |
| 995 | 367 tm::LazyTensor |
|
487
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
368 sz |
|
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
369 end |
|
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
370 |
|
1006
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
371 function Base.showerror(io::IO, err::DomainSizeMismatch) |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
372 print(io, "DomainSizeMismatch: ") |
| 995 | 373 print(io, "domain size $(domain_size(err.tm)) of LazyTensor not matching size $(err.sz)") |
|
487
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
374 end |
|
1006
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
375 |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
376 |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
377 struct RangeSizeMismatch <: Exception |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
378 tm::LazyTensor |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
379 sz |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
380 end |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
381 |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
382 function Base.showerror(io::IO, err::RangeSizeMismatch) |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
383 print(io, "RangeSizeMismatch: ") |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
384 print(io, "range size $(range_size(err.tm)) of LazyTensor not matching size $(err.sz)") |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
385 end |