Mercurial > repos > public > sbplib_julia
annotate src/LazyTensors/lazy_tensor_operations.jl @ 1003:7ef605b8f132 refactor/lazy_tensors
Remove a bunch of todos
| author | Jonatan Werpers <jonatan@werpers.com> |
|---|---|
| date | Sun, 20 Mar 2022 21:19:00 +0100 |
| parents | 271aa6ae1055 |
| children | becd95ba0fce |
| rev | line source |
|---|---|
|
999
20cb83efb3f1
More operator definitions to top file
Jonatan Werpers <jonatan@werpers.com>
parents:
998
diff
changeset
|
1 # TODO: We need to be really careful about good error messages. |
|
1001
a3df203861d3
Simplify some type parameter usage
Jonatan Werpers <jonatan@werpers.com>
parents:
1000
diff
changeset
|
2 # TODO: Go over type parameters |
|
992
bc384aaade30
Add a bunch of todos and add a ScalingTensor
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
3 |
|
1002
271aa6ae1055
Split out a file for tensor types
Jonatan Werpers <jonatan@werpers.com>
parents:
1001
diff
changeset
|
4 |
|
196
b3c252280a19
Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents:
195
diff
changeset
|
5 """ |
| 995 | 6 LazyTensorApplication{T,R,D} <: LazyArray{T,R} |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
7 |
| 995 | 8 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
|
9 |
| 995 | 10 Allows the result of a `LazyTensor` applied to a vector to be treated as an `AbstractArray`. |
| 11 With a mapping `m` and a vector `v` the LazyTensorApplication object can be created by `m*v`. | |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
12 The actual result will be calcualted when indexing into `m*v`. |
|
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
13 """ |
| 995 | 14 struct LazyTensorApplication{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
|
15 t::TM |
|
946516954c85
Use concrete types in LazyTensorApplication
Jonatan Werpers <jonatan@werpers.com>
parents:
359
diff
changeset
|
16 o::AA |
|
942
7829c09f8137
Add promotion calculation of element type for LazyTensorMappingApplication
Jonatan Werpers <jonatan@werpers.com>
parents:
838
diff
changeset
|
17 |
| 995 | 18 function LazyTensorApplication(t::LazyTensor{<:Any,R,D}, o::AbstractArray{<:Any,D}) where {R,D} |
|
977
043d13ef8898
Fix type calculation of LazyTensorMappingApplication element type
Jonatan Werpers <jonatan@werpers.com>
parents:
976
diff
changeset
|
19 I = ntuple(i->1, range_dim(t)) |
|
043d13ef8898
Fix type calculation of LazyTensorMappingApplication element type
Jonatan Werpers <jonatan@werpers.com>
parents:
976
diff
changeset
|
20 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
|
21 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
|
22 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
23 end |
|
348
7fe43d902a27
Start trying to change LazyTensors
Jonatan Werpers <jonatan@werpers.com>
parents:
333
diff
changeset
|
24 # TODO: Do boundschecking on creation! |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
25 |
| 995 | 26 Base.getindex(ta::LazyTensorApplication{T,R}, I::Vararg{Any,R}) where {T,R} = apply(ta.t, ta.o, I...) |
| 27 Base.getindex(ta::LazyTensorApplication{T,1}, I::CartesianIndex{1}) where {T} = apply(ta.t, ta.o, I.I...) # Would otherwise be caught in the previous method. | |
| 28 Base.size(ta::LazyTensorApplication) = range_size(ta.t) | |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
29 # TODO: What else is needed to implement the AbstractArray interface? |
|
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
30 |
|
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
31 |
|
194
d30d42a11566
Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents:
190
diff
changeset
|
32 """ |
| 995 | 33 LazyTensorTranspose{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
|
34 |
| 995 | 35 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
|
36 |
|
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
37 If a mapping implements the the `apply_transpose` method this allows working with |
| 995 | 38 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
|
39 the appropriate methods of `m`. |
|
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
40 """ |
| 995 | 41 struct LazyTensorTranspose{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
|
42 tm::TM |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
43 end |
|
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
44 |
|
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
45 # # TBD: Should this be implemented on a type by type basis or through a trait to provide earlier errors? |
| 995 | 46 # Jonatan 2020-09-25: Is the problem that you can take the transpose of any LazyTensor even if it doesn't implement `apply_transpose`? |
| 47 Base.adjoint(tm::LazyTensor) = LazyTensorTranspose(tm) | |
| 48 Base.adjoint(tmt::LazyTensorTranspose) = tmt.tm | |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
49 |
| 995 | 50 apply(tmt::LazyTensorTranspose{T,R,D}, v::AbstractArray{<:Any,R}, I::Vararg{Any,D}) where {T,R,D} = apply_transpose(tmt.tm, v, I...) |
| 51 apply_transpose(tmt::LazyTensorTranspose{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
|
52 |
| 995 | 53 range_size(tmt::LazyTensorTranspose) = domain_size(tmt.tm) |
| 54 domain_size(tmt::LazyTensorTranspose) = range_size(tmt.tm) | |
|
197
a340fa91b1fc
Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents:
196
diff
changeset
|
55 |
|
1002
271aa6ae1055
Split out a file for tensor types
Jonatan Werpers <jonatan@werpers.com>
parents:
1001
diff
changeset
|
56 |
|
1000
1091ac8c69ad
Rename another struct
Jonatan Werpers <jonatan@werpers.com>
parents:
999
diff
changeset
|
57 struct LazyTensorBinaryOperation{Op,T,R,D,T1<:LazyTensor{T,R,D},T2<:LazyTensor{T,R,D}} <: LazyTensor{T,D,R} |
|
274
11010bb74260
Dispatch getindex for TensorMappingApplication on region indices. Dispatch apply
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
267
diff
changeset
|
58 tm1::T1 |
|
11010bb74260
Dispatch getindex for TensorMappingApplication on region indices. Dispatch apply
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
267
diff
changeset
|
59 tm2::T2 |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
60 |
|
1001
a3df203861d3
Simplify some type parameter usage
Jonatan Werpers <jonatan@werpers.com>
parents:
1000
diff
changeset
|
61 function LazyTensorBinaryOperation{Op,T,R,D}(tm1::T1,tm2::T2) where {Op,T,R,D, T1<:LazyTensor{T,R,D},T2<:LazyTensor{T,R,D}} |
|
274
11010bb74260
Dispatch getindex for TensorMappingApplication on region indices. Dispatch apply
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
267
diff
changeset
|
62 return new{Op,T,R,D,T1,T2}(tm1,tm2) |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
63 end |
|
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
64 end |
|
348
7fe43d902a27
Start trying to change LazyTensors
Jonatan Werpers <jonatan@werpers.com>
parents:
333
diff
changeset
|
65 # TODO: Boundschecking in constructor. |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
66 |
|
1001
a3df203861d3
Simplify some type parameter usage
Jonatan Werpers <jonatan@werpers.com>
parents:
1000
diff
changeset
|
67 LazyTensorBinaryOperation{Op}(s,t) where Op = LazyTensorBinaryOperation{Op,eltype(s), range_dim(s), domain_dim(s)}(s,t) |
|
a3df203861d3
Simplify some type parameter usage
Jonatan Werpers <jonatan@werpers.com>
parents:
1000
diff
changeset
|
68 |
|
1000
1091ac8c69ad
Rename another struct
Jonatan Werpers <jonatan@werpers.com>
parents:
999
diff
changeset
|
69 apply(tmBinOp::LazyTensorBinaryOperation{:+,T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg{Any,R}) where {T,R,D} = apply(tmBinOp.tm1, v, I...) + apply(tmBinOp.tm2, v, I...) |
|
1091ac8c69ad
Rename another struct
Jonatan Werpers <jonatan@werpers.com>
parents:
999
diff
changeset
|
70 apply(tmBinOp::LazyTensorBinaryOperation{:-,T,R,D}, v::AbstractArray{<:Any,D}, I::Vararg{Any,R}) where {T,R,D} = apply(tmBinOp.tm1, v, I...) - apply(tmBinOp.tm2, v, I...) |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
71 |
|
1000
1091ac8c69ad
Rename another struct
Jonatan Werpers <jonatan@werpers.com>
parents:
999
diff
changeset
|
72 range_size(tmBinOp::LazyTensorBinaryOperation) = range_size(tmBinOp.tm1) |
|
1091ac8c69ad
Rename another struct
Jonatan Werpers <jonatan@werpers.com>
parents:
999
diff
changeset
|
73 domain_size(tmBinOp::LazyTensorBinaryOperation) = domain_size(tmBinOp.tm1) |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
74 |
|
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
75 |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
76 """ |
| 995 | 77 LazyTensorComposition{T,R,K,D} |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
78 |
| 995 | 79 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
|
80 """ |
| 995 | 81 struct LazyTensorComposition{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
|
82 t1::TM1 |
|
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
83 t2::TM2 |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
84 |
|
1001
a3df203861d3
Simplify some type parameter usage
Jonatan Werpers <jonatan@werpers.com>
parents:
1000
diff
changeset
|
85 function LazyTensorComposition(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
|
86 @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
|
87 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
|
88 end |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
89 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
90 |
| 995 | 91 range_size(tm::LazyTensorComposition) = range_size(tm.t1) |
| 92 domain_size(tm::LazyTensorComposition) = domain_size(tm.t2) | |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
93 |
| 995 | 94 function apply(c::LazyTensorComposition{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
|
95 apply(c.t1, c.t2*v, I...) |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
96 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
97 |
| 995 | 98 function apply_transpose(c::LazyTensorComposition{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
|
99 apply_transpose(c.t2, c.t1'*v, I...) |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
100 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
101 |
|
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
102 |
|
377
8414c2334393
Start implementing LazyLinearMap
Jonatan Werpers <jonatan@werpers.com>
parents:
359
diff
changeset
|
103 """ |
|
998
390dfc3db4b1
Move simplifying implementations from \circ to LazyTensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
997
diff
changeset
|
104 LazyTensorComposition(tm, tmi::IdentityTensor) |
|
390dfc3db4b1
Move simplifying implementations from \circ to LazyTensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
997
diff
changeset
|
105 LazyTensorComposition(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
|
106 |
| 995 | 107 Composes a `Tensormapping` `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
|
108 """ |
|
998
390dfc3db4b1
Move simplifying implementations from \circ to LazyTensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
997
diff
changeset
|
109 function LazyTensorComposition(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
|
110 @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
|
111 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
|
112 end |
|
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
113 |
|
998
390dfc3db4b1
Move simplifying implementations from \circ to LazyTensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
997
diff
changeset
|
114 function LazyTensorComposition(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
|
115 @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
|
116 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
|
117 end |
| 995 | 118 # Specialization for the case where tm is an IdentityTensor. Required to resolve ambiguity. |
|
998
390dfc3db4b1
Move simplifying implementations from \circ to LazyTensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
997
diff
changeset
|
119 function LazyTensorComposition(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
|
120 @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
|
121 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
|
122 end |
|
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
123 |
|
992
bc384aaade30
Add a bunch of todos and add a ScalingTensor
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
124 |
|
459
11e58c49fb46
Add some documentation
Jonatan Werpers <jonatan@werpers.com>
parents:
458
diff
changeset
|
125 """ |
| 995 | 126 InflatedLazyTensor{T,R,D} <: LazyTensor{T,R,D} |
|
459
11e58c49fb46
Add some documentation
Jonatan Werpers <jonatan@werpers.com>
parents:
458
diff
changeset
|
127 |
| 995 | 128 An inflated `LazyTensor` with dimensions added before and afer its actual dimensions. |
|
459
11e58c49fb46
Add some documentation
Jonatan Werpers <jonatan@werpers.com>
parents:
458
diff
changeset
|
129 """ |
| 995 | 130 struct InflatedLazyTensor{T,R,D,D_before,R_middle,D_middle,D_after, TM<:LazyTensor{T,R_middle,D_middle}} <: LazyTensor{T,R,D} |
| 131 before::IdentityTensor{T,D_before} | |
|
449
14d60de71b72
Change to concrete fields in the type
Jonatan Werpers <jonatan@werpers.com>
parents:
448
diff
changeset
|
132 tm::TM |
| 995 | 133 after::IdentityTensor{T,D_after} |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
134 |
| 995 | 135 function InflatedLazyTensor(before, tm::LazyTensor{T}, after) where T |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
136 R_before = range_dim(before) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
137 R_middle = range_dim(tm) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
138 R_after = range_dim(after) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
139 R = R_before+R_middle+R_after |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
140 |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
141 D_before = domain_dim(before) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
142 D_middle = domain_dim(tm) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
143 D_after = domain_dim(after) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
144 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
|
145 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
|
146 end |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
147 end |
|
1002
271aa6ae1055
Split out a file for tensor types
Jonatan Werpers <jonatan@werpers.com>
parents:
1001
diff
changeset
|
148 |
| 461 | 149 """ |
| 995 | 150 InflatedLazyTensor(before, tm, after) |
| 151 InflatedLazyTensor(before,tm) | |
| 152 InflatedLazyTensor(tm,after) | |
| 461 | 153 |
| 995 | 154 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
|
155 |
| 995 | 156 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
|
157 |
| 995 | 158 If `tm` already is an `InflatedLazyTensor`, `before` and `after` will be extended instead of |
| 159 creating a nested `InflatedLazyTensor`. | |
| 461 | 160 """ |
| 995 | 161 InflatedLazyTensor(::IdentityTensor, ::LazyTensor, ::IdentityTensor) |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
162 |
| 995 | 163 function InflatedLazyTensor(before, itm::InflatedLazyTensor, after) |
| 164 return InflatedLazyTensor( | |
| 165 IdentityTensor(before.size..., itm.before.size...), | |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
166 itm.tm, |
| 995 | 167 IdentityTensor(itm.after.size..., after.size...), |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
168 ) |
|
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
169 end |
|
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
170 |
| 995 | 171 InflatedLazyTensor(before::IdentityTensor, tm::LazyTensor{T}) where T = InflatedLazyTensor(before,tm,IdentityTensor{T}()) |
| 172 InflatedLazyTensor(tm::LazyTensor{T}, after::IdentityTensor) where T = InflatedLazyTensor(IdentityTensor{T}(),tm,after) | |
|
465
f270d82fc9ad
Change documention in an attempt to follow the guidelines
Jonatan Werpers <jonatan@werpers.com>
parents:
464
diff
changeset
|
173 # Resolve ambiguity between the two previous methods |
| 995 | 174 InflatedLazyTensor(I1::IdentityTensor{T}, I2::IdentityTensor{T}) where T = InflatedLazyTensor(I1,I2,IdentityTensor{T}()) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
175 |
| 995 | 176 # TODO: Implement some pretty printing in terms of ⊗. E.g InflatedLazyTensor(I(3),B,I(2)) -> I(3)⊗B⊗I(2) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
177 |
| 995 | 178 function range_size(itm::InflatedLazyTensor) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
179 return flatten_tuple( |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
180 range_size(itm.before), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
181 range_size(itm.tm), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
182 range_size(itm.after), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
183 ) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
184 end |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
185 |
| 995 | 186 function domain_size(itm::InflatedLazyTensor) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
187 return flatten_tuple( |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
188 domain_size(itm.before), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
189 domain_size(itm.tm), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
190 domain_size(itm.after), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
191 ) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
192 end |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
193 |
| 995 | 194 function apply(itm::InflatedLazyTensor{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
|
195 dim_before = range_dim(itm.before) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
196 dim_domain = domain_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
197 dim_range = range_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
198 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
|
199 |
|
538
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
200 view_index, inner_index = split_index(Val(dim_before), Val(dim_domain), Val(dim_range), Val(dim_after), I...) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
201 |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
202 v_inner = view(v, view_index...) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
203 return apply(itm.tm, v_inner, inner_index...) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
204 end |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
205 |
| 995 | 206 function apply_transpose(itm::InflatedLazyTensor{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
|
207 dim_before = range_dim(itm.before) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
208 dim_domain = domain_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
209 dim_range = range_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
210 dim_after = range_dim(itm.after) |
|
526
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
211 |
|
538
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
212 view_index, inner_index = split_index(Val(dim_before), Val(dim_range), Val(dim_domain), Val(dim_after), I...) |
|
526
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
213 |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
214 v_inner = view(v, view_index...) |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
215 return apply_transpose(itm.tm, v_inner, inner_index...) |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
216 end |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
217 |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
218 |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
219 @doc raw""" |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
220 LazyOuterProduct(tms...) |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
221 |
| 995 | 222 Creates a `LazyTensorComposition` for the outerproduct of `tms...`. |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
223 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
|
224 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
225 First let |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
226 ```math |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
227 \begin{aligned} |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
228 A &= A_{I,J} \\ |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
229 B &= B_{M,N} \\ |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
230 C &= C_{P,Q} \\ |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
231 \end{aligned} |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
232 ``` |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
233 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
234 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
|
235 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
236 We use ``⊗`` to denote the outer product |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
237 ```math |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
238 (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
|
239 ``` |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
240 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
241 We note that |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
242 ```math |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
243 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
|
244 ``` |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
245 And that |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
246 ```math |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
247 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
|
248 ``` |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
249 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
|
250 To apply ``A⊗B⊗C`` we evaluate |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
251 |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
252 ```math |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
253 (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
|
254 ``` |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
255 """ |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
256 function LazyOuterProduct end |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
257 |
| 995 | 258 function LazyOuterProduct(tm1::LazyTensor{T}, tm2::LazyTensor{T}) where T |
| 259 itm1 = InflatedLazyTensor(tm1, IdentityTensor{T}(range_size(tm2))) | |
| 260 itm2 = InflatedLazyTensor(IdentityTensor{T}(domain_size(tm1)),tm2) | |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
261 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
262 return itm1∘itm2 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
263 end |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
264 |
| 995 | 265 LazyOuterProduct(t1::IdentityTensor{T}, t2::IdentityTensor{T}) where T = IdentityTensor{T}(t1.size...,t2.size...) |
| 266 LazyOuterProduct(t1::LazyTensor, t2::IdentityTensor) = InflatedLazyTensor(t1, t2) | |
| 267 LazyOuterProduct(t1::IdentityTensor, t2::LazyTensor) = InflatedLazyTensor(t1, t2) | |
|
491
2dc2eac27f75
Add special methods for Identity mappings
Jonatan Werpers <jonatan@werpers.com>
parents:
475
diff
changeset
|
268 |
| 995 | 269 LazyOuterProduct(tms::Vararg{LazyTensor}) = foldl(LazyOuterProduct, tms) |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
270 |
| 498 | 271 |
| 995 | 272 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
|
273 if domain_size(tm) != 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
|
274 throw(SizeMismatch(tm,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
|
275 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
|
276 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
|
277 |
|
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
278 struct SizeMismatch <: Exception |
| 995 | 279 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
|
280 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
|
281 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
|
282 |
|
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
283 function Base.showerror(io::IO, err::SizeMismatch) |
|
6a6b7eaf9edf
Move exception handling to end of file and update error message.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
485
diff
changeset
|
284 print(io, "SizeMismatch: ") |
| 995 | 285 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
|
286 end |