Mercurial > repos > public > sbplib_julia
annotate src/LazyTensors/lazy_tensor_operations.jl @ 1016:5c8c148c56a3 refactor/lazy_tensors
Fix typo
| author | Jonatan Werpers <jonatan@werpers.com> |
|---|---|
| date | Mon, 21 Mar 2022 13:19:53 +0100 |
| parents | 4dd3c2312d9e |
| children | 6abbb2c6c3e4 |
| 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 """ |
| 995 | 2 LazyTensorApplication{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`. |
| 7 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
|
8 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
|
9 """ |
| 995 | 10 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
|
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 |
| 995 | 14 function LazyTensorApplication(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 |
|
1005
becd95ba0fce
Add bounds checking for lazy tensor application and clea up tests a bit
Jonatan Werpers <jonatan@werpers.com>
parents:
1002
diff
changeset
|
22 function Base.getindex(ta::LazyTensorApplication{T,R}, I::Vararg{Any,R}) where {T,R} |
|
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 |
| 1016 | 26 Base.@propagate_inbounds Base.getindex(ta::LazyTensorApplication{T,1} where T, I::CartesianIndex{1}) = ta[Tuple(I)...] # Would otherwise be caught in the previous method. |
| 995 | 27 Base.size(ta::LazyTensorApplication) = 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 """ |
| 995 | 31 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
|
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 """ |
| 995 | 39 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
|
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`? |
| 45 Base.adjoint(tm::LazyTensor) = LazyTensorTranspose(tm) | |
| 46 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
|
47 |
| 995 | 48 apply(tmt::LazyTensorTranspose{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::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
|
50 |
| 995 | 51 range_size(tmt::LazyTensorTranspose) = domain_size(tmt.tm) |
| 52 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
|
53 |
|
1002
271aa6ae1055
Split out a file for tensor types
Jonatan Werpers <jonatan@werpers.com>
parents:
1001
diff
changeset
|
54 |
|
1000
1091ac8c69ad
Rename another struct
Jonatan Werpers <jonatan@werpers.com>
parents:
999
diff
changeset
|
55 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
|
56 tm1::T1 |
|
11010bb74260
Dispatch getindex for TensorMappingApplication on region indices. Dispatch apply
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
267
diff
changeset
|
57 tm2::T2 |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
58 |
|
1001
a3df203861d3
Simplify some type parameter usage
Jonatan Werpers <jonatan@werpers.com>
parents:
1000
diff
changeset
|
59 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}} |
|
1007
f7a718bcb4da
Add checking of sizes to LazyTensorBinaryOperation
Jonatan Werpers <jonatan@werpers.com>
parents:
1006
diff
changeset
|
60 @boundscheck check_domain_size(tm2, domain_size(tm1)) |
|
f7a718bcb4da
Add checking of sizes to LazyTensorBinaryOperation
Jonatan Werpers <jonatan@werpers.com>
parents:
1006
diff
changeset
|
61 @boundscheck check_range_size(tm2, range_size(tm1)) |
|
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 |
|
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
65 |
|
1001
a3df203861d3
Simplify some type parameter usage
Jonatan Werpers <jonatan@werpers.com>
parents:
1000
diff
changeset
|
66 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
|
67 |
|
1000
1091ac8c69ad
Rename another struct
Jonatan Werpers <jonatan@werpers.com>
parents:
999
diff
changeset
|
68 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
|
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...) |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
70 |
|
1000
1091ac8c69ad
Rename another struct
Jonatan Werpers <jonatan@werpers.com>
parents:
999
diff
changeset
|
71 range_size(tmBinOp::LazyTensorBinaryOperation) = range_size(tmBinOp.tm1) |
|
1091ac8c69ad
Rename another struct
Jonatan Werpers <jonatan@werpers.com>
parents:
999
diff
changeset
|
72 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
|
73 |
|
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
74 |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
75 """ |
| 995 | 76 LazyTensorComposition{T,R,K,D} |
|
210
2aa33d0eef90
Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
209
diff
changeset
|
77 |
| 995 | 78 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
|
79 """ |
| 995 | 80 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
|
81 t1::TM1 |
|
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
82 t2::TM2 |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
83 |
|
1001
a3df203861d3
Simplify some type parameter usage
Jonatan Werpers <jonatan@werpers.com>
parents:
1000
diff
changeset
|
84 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
|
85 @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
|
86 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
|
87 end |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
88 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
89 |
| 995 | 90 range_size(tm::LazyTensorComposition) = range_size(tm.t1) |
| 91 domain_size(tm::LazyTensorComposition) = domain_size(tm.t2) | |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
92 |
| 995 | 93 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
|
94 apply(c.t1, c.t2*v, I...) |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
95 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
96 |
| 995 | 97 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
|
98 apply_transpose(c.t2, c.t1'*v, I...) |
|
412
d94891b8dfca
Start implementing TensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
402
diff
changeset
|
99 end |
|
190
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
100 |
|
8964b3165097
Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff
changeset
|
101 |
|
377
8414c2334393
Start implementing LazyLinearMap
Jonatan Werpers <jonatan@werpers.com>
parents:
359
diff
changeset
|
102 """ |
|
998
390dfc3db4b1
Move simplifying implementations from \circ to LazyTensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
997
diff
changeset
|
103 LazyTensorComposition(tm, tmi::IdentityTensor) |
|
390dfc3db4b1
Move simplifying implementations from \circ to LazyTensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
997
diff
changeset
|
104 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
|
105 |
| 995 | 106 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
|
107 """ |
|
998
390dfc3db4b1
Move simplifying implementations from \circ to LazyTensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
997
diff
changeset
|
108 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
|
109 @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
|
110 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
|
111 end |
|
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
112 |
|
998
390dfc3db4b1
Move simplifying implementations from \circ to LazyTensorComposition
Jonatan Werpers <jonatan@werpers.com>
parents:
997
diff
changeset
|
113 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
|
114 @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
|
115 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
|
116 end |
| 995 | 117 # 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
|
118 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
|
119 @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
|
120 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
|
121 end |
|
95f3b9036801
Specialize composition operator for composing a tensormapping with an identitymapping.
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents:
465
diff
changeset
|
122 |
|
992
bc384aaade30
Add a bunch of todos and add a ScalingTensor
Jonatan Werpers <jonatan@werpers.com>
parents:
977
diff
changeset
|
123 |
|
459
11e58c49fb46
Add some documentation
Jonatan Werpers <jonatan@werpers.com>
parents:
458
diff
changeset
|
124 """ |
| 995 | 125 InflatedLazyTensor{T,R,D} <: LazyTensor{T,R,D} |
|
459
11e58c49fb46
Add some documentation
Jonatan Werpers <jonatan@werpers.com>
parents:
458
diff
changeset
|
126 |
| 995 | 127 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
|
128 """ |
| 995 | 129 struct InflatedLazyTensor{T,R,D,D_before,R_middle,D_middle,D_after, TM<:LazyTensor{T,R_middle,D_middle}} <: LazyTensor{T,R,D} |
| 130 before::IdentityTensor{T,D_before} | |
|
449
14d60de71b72
Change to concrete fields in the type
Jonatan Werpers <jonatan@werpers.com>
parents:
448
diff
changeset
|
131 tm::TM |
| 995 | 132 after::IdentityTensor{T,D_after} |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
133 |
| 995 | 134 function InflatedLazyTensor(before, tm::LazyTensor{T}, after) where T |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
135 R_before = range_dim(before) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
136 R_middle = range_dim(tm) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
137 R_after = range_dim(after) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
138 R = R_before+R_middle+R_after |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
139 |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
140 D_before = domain_dim(before) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
141 D_middle = domain_dim(tm) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
142 D_after = domain_dim(after) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
143 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
|
144 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
|
145 end |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
146 end |
|
1002
271aa6ae1055
Split out a file for tensor types
Jonatan Werpers <jonatan@werpers.com>
parents:
1001
diff
changeset
|
147 |
| 461 | 148 """ |
| 995 | 149 InflatedLazyTensor(before, tm, after) |
| 150 InflatedLazyTensor(before,tm) | |
| 151 InflatedLazyTensor(tm,after) | |
| 461 | 152 |
| 995 | 153 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
|
154 |
| 995 | 155 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
|
156 |
| 995 | 157 If `tm` already is an `InflatedLazyTensor`, `before` and `after` will be extended instead of |
| 158 creating a nested `InflatedLazyTensor`. | |
| 461 | 159 """ |
| 995 | 160 InflatedLazyTensor(::IdentityTensor, ::LazyTensor, ::IdentityTensor) |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
161 |
| 995 | 162 function InflatedLazyTensor(before, itm::InflatedLazyTensor, after) |
| 163 return InflatedLazyTensor( | |
| 164 IdentityTensor(before.size..., itm.before.size...), | |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
165 itm.tm, |
| 995 | 166 IdentityTensor(itm.after.size..., after.size...), |
|
493
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
167 ) |
|
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
168 end |
|
df566372bb4f
Implement constructors to avoid creating nested InflatedTensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents:
487
diff
changeset
|
169 |
| 995 | 170 InflatedLazyTensor(before::IdentityTensor, tm::LazyTensor{T}) where T = InflatedLazyTensor(before,tm,IdentityTensor{T}()) |
| 171 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
|
172 # Resolve ambiguity between the two previous methods |
| 995 | 173 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
|
174 |
| 995 | 175 # 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
|
176 |
| 995 | 177 function range_size(itm::InflatedLazyTensor) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
178 return flatten_tuple( |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
179 range_size(itm.before), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
180 range_size(itm.tm), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
181 range_size(itm.after), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
182 ) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
183 end |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
184 |
| 995 | 185 function domain_size(itm::InflatedLazyTensor) |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
186 return flatten_tuple( |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
187 domain_size(itm.before), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
188 domain_size(itm.tm), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
189 domain_size(itm.after), |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
190 ) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
191 end |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
192 |
| 995 | 193 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
|
194 dim_before = range_dim(itm.before) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
195 dim_domain = domain_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
196 dim_range = range_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
197 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
|
198 |
|
538
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
199 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
|
200 |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
201 v_inner = view(v, view_index...) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
202 return apply(itm.tm, v_inner, inner_index...) |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
203 end |
|
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
204 |
| 995 | 205 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
|
206 dim_before = range_dim(itm.before) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
207 dim_domain = domain_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
208 dim_range = range_dim(itm.tm) |
|
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
209 dim_after = range_dim(itm.after) |
|
526
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
210 |
|
538
848dec405332
Change variable names in apply and apply_transpose
Jonatan Werpers <jonatan@werpers.com>
parents:
537
diff
changeset
|
211 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
|
212 |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
213 v_inner = view(v, view_index...) |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
214 return apply_transpose(itm.tm, v_inner, inner_index...) |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
215 end |
|
be152486d136
Implement apply_transpose with tests
Jonatan Werpers <jonatan@werpers.com>
parents:
525
diff
changeset
|
216 |
|
446
904aae1899df
Start implementing InflatedTensorMapping
Jonatan Werpers <jonatan@werpers.com>
parents:
429
diff
changeset
|
217 |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
218 @doc raw""" |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
219 LazyOuterProduct(tms...) |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
220 |
| 995 | 221 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
|
222 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
|
223 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
224 First let |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
225 ```math |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
226 \begin{aligned} |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
227 A &= A_{I,J} \\ |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
228 B &= B_{M,N} \\ |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
229 C &= C_{P,Q} \\ |
|
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
230 \end{aligned} |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
231 ``` |
|
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 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
|
234 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
235 We use ``⊗`` to denote the outer product |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
236 ```math |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
237 (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
|
238 ``` |
|
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 We note that |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
241 ```math |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
242 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
|
243 ``` |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
244 And that |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
245 ```math |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
246 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
|
247 ``` |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
248 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
|
249 To apply ``A⊗B⊗C`` we evaluate |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
250 |
|
838
76e5682d0e52
Fix a bunch of docstring mistakes
Jonatan Werpers <jonatan@werpers.com>
parents:
625
diff
changeset
|
251 ```math |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
252 (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
|
253 ``` |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
254 """ |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
255 function LazyOuterProduct end |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
256 |
| 995 | 257 function LazyOuterProduct(tm1::LazyTensor{T}, tm2::LazyTensor{T}) where T |
| 258 itm1 = InflatedLazyTensor(tm1, IdentityTensor{T}(range_size(tm2))) | |
| 259 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
|
260 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
261 return itm1∘itm2 |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
262 end |
|
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
263 |
| 995 | 264 LazyOuterProduct(t1::IdentityTensor{T}, t2::IdentityTensor{T}) where T = IdentityTensor{T}(t1.size...,t2.size...) |
| 265 LazyOuterProduct(t1::LazyTensor, t2::IdentityTensor) = InflatedLazyTensor(t1, t2) | |
| 266 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
|
267 |
| 995 | 268 LazyOuterProduct(tms::Vararg{LazyTensor}) = foldl(LazyOuterProduct, tms) |
|
468
a52f38e72258
Start implementing function for outer products
Jonatan Werpers <jonatan@werpers.com>
parents:
461
diff
changeset
|
269 |
| 498 | 270 |
| 995 | 271 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
|
272 if domain_size(tm) != sz |
|
1006
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
273 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
|
274 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
|
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 |
|
1006
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
277 function check_range_size(tm::LazyTensor, sz) |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
278 if range_size(tm) != sz |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
279 throw(RangeSizeMismatch(tm,sz)) |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
280 end |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
281 end |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
282 |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
283 struct DomainSizeMismatch <: Exception |
| 995 | 284 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
|
285 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
|
286 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
|
287 |
|
1006
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
288 function Base.showerror(io::IO, err::DomainSizeMismatch) |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
289 print(io, "DomainSizeMismatch: ") |
| 995 | 290 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
|
291 end |
|
1006
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
292 |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
293 |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
294 struct RangeSizeMismatch <: Exception |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
295 tm::LazyTensor |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
296 sz |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
297 end |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
298 |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
299 function Base.showerror(io::IO, err::RangeSizeMismatch) |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
300 print(io, "RangeSizeMismatch: ") |
|
d9476fede83d
Add check methods for range size
Jonatan Werpers <jonatan@werpers.com>
parents:
1005
diff
changeset
|
301 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
|
302 end |