Mercurial > repos > public > sbplib_julia

annotate LazyTensors/src/lazy_operations.jl @ 257:d4cd4882ee9f boundary_conditions

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Improve error messages when multiblying with TensorMappings and add some tests for TensorOperators
author Jonatan Werpers <jonatan@werpers.com>
date Fri, 28 Jun 2019 14:10:35 +0200
parents 1c6afdcfd657
children b577b5f64530
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
1 """
196
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
2 LazyArray{T,D} <: AbstractArray{T,D}
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
3
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
4 Array which is calcualted lazily when indexing.
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
5
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
6 A subtype of `LazyArray` will use lazy version of `+`, `-`, `*`, `/`.
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
7 """
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
8 abstract type LazyArray{T,D} <: AbstractArray{T,D} end
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
9 export LazyArray
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
10
198
b5c9be7f391c Fix up some formatting
Jonatan Werpers <jonatan@werpers.com>
parents: 197
diff changeset
11
b5c9be7f391c Fix up some formatting
Jonatan Werpers <jonatan@werpers.com>
parents: 197
diff changeset
12
196
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
13 """
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
14 LazyTensorMappingApplication{T,R,D} <: LazyArray{T,R}
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
15
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
16 Struct for lazy application of a TensorMapping. Created using `*`.
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
17
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
18 Allows the result of a `TensorMapping` applied to a vector to be treated as an `AbstractArray`.
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
19 With a mapping `m` and a vector `v` the LazyTensorMappingApplication object can be created by `m*v`.
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
20 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
21 """
196
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
22 struct LazyTensorMappingApplication{T,R,D} <: LazyArray{T,R}
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
23 t::TensorMapping{T,R,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
24 o::AbstractArray{T,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
25 end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
26 export LazyTensorMappingApplication
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
27
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
28 Base.:*(tm::TensorMapping{T,R,D}, o::AbstractArray{T,D}) where {T,R,D} = LazyTensorMappingApplication(tm,o)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
29
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
30 Base.getindex(ta::LazyTensorMappingApplication{T,R,D}, I::Vararg{Int,R}) where {T,R,D} = apply(ta.t, ta.o, I)
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
31 Base.size(ta::LazyTensorMappingApplication{T,R,D}) where {T,R,D} = range_size(ta.t,size(ta.o))
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
32 # 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
33
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
34 # # We need the associativity to be a→b→c = a→(b→c), which is the case for '→'
257
d4cd4882ee9f Improve error messages when multiblying with TensorMappings and add some tests for TensorOperators
Jonatan Werpers <jonatan@werpers.com>
parents: 237
diff changeset
35 Base.:*(a::TensorMapping{T,R,D}, b::TensorMapping{T,D,K}, args::Union{TensorMapping{T}, AbstractArray{T}}...) where {T,R,D,K} = foldr(*,(a,b,args...))
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
36 # # Should we overload some other infix binary operator?
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
37 # →(tm::TensorMapping{T,R,D}, o::AbstractArray{T,D}) where {T,R,D} = LazyTensorMappingApplication(tm,o)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
38 # TODO: We need to be really careful about good error messages.
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
39 # For example what happens if you try to multiply LazyTensorMappingApplication with a TensorMapping(wrong order)?
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
40
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
41
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
42
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
43 """
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
44 LazyElementwiseOperation{T,D,Op, T1<:AbstractArray{T,D}, T2 <: AbstractArray{T,D}} <: AbstractArray{T,D}
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
45
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
46 Struct allowing for lazy evaluation of elementwise operations on AbstractArrays.
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
47
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
48 A LazyElementwiseOperation contains two AbstractArrays of equal size,
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
49 together with an operation. The operations are carried out when the
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
50 LazyElementwiseOperation is indexed.
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
51 """
196
b3c252280a19 Move LazyArray and make LazyTensorMappingApplication and LazyElementwiseOperation subtypes of it
Jonatan Werpers <jonatan@werpers.com>
parents: 195
diff changeset
52 struct LazyElementwiseOperation{T,D,Op, T1<:AbstractArray{T,D}, T2 <: AbstractArray{T,D}} <: LazyArray{T,D}
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
53 a::T1
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
54 b::T2
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
55
199
a22b419bbdf0 Attempt fix for assertion inside constructor of LazyElementWiseOperation
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 198
diff changeset
56 @inline function LazyElementwiseOperation{T,D,Op}(a::T1,b::T2) where {T,D,Op, T1<:AbstractArray{T,D}, T2<:AbstractArray{T,D}}
207
f85a0b38f3ff Change error type when doing element wise operations on lazy arrays of missmatching dimension
Jonatan Werpers <jonatan@werpers.com>
parents: 206
diff changeset
57 @boundscheck if size(a) != size(b)
f85a0b38f3ff Change error type when doing element wise operations on lazy arrays of missmatching dimension
Jonatan Werpers <jonatan@werpers.com>
parents: 206
diff changeset
58 throw(DimensionMismatch("dimensions must match"))
f85a0b38f3ff Change error type when doing element wise operations on lazy arrays of missmatching dimension
Jonatan Werpers <jonatan@werpers.com>
parents: 206
diff changeset
59 end
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
60 return new{T,D,Op,T1,T2}(a,b)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
61 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
62 end
210
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
63 # TODO: Move Op to be the first parameter? Compare to Binary operations
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
64
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
65 Base.size(v::LazyElementwiseOperation) = size(v.a)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
66
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
67 # TODO: Make sure boundschecking is done properly and that the lenght of the vectors are equal
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
68 # NOTE: Boundschecking in getindex functions now assumes that the size of the
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
69 # vectors in the LazyElementwiseOperation are the same size. If we remove the
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
70 # size assertion in the constructor we might have to handle
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
71 # boundschecking differently.
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
72 Base.@propagate_inbounds @inline function Base.getindex(leo::LazyElementwiseOperation{T,D,:+}, I::Vararg{Int,D}) where {T,D}
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
73 @boundscheck if !checkbounds(Bool,leo.a,I...)
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
74 throw(BoundsError([leo],I...))
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
75 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
76 return leo.a[I...] + leo.b[I...]
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
77 end
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
78 Base.@propagate_inbounds @inline function Base.getindex(leo::LazyElementwiseOperation{T,D,:-}, I::Vararg{Int,D}) where {T,D}
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
79 @boundscheck if !checkbounds(Bool,leo.a,I...)
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
80 throw(BoundsError([leo],I...))
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
81 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
82 return leo.a[I...] - leo.b[I...]
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
83 end
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
84 Base.@propagate_inbounds @inline function Base.getindex(leo::LazyElementwiseOperation{T,D,:*}, I::Vararg{Int,D}) where {T,D}
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
85 @boundscheck if !checkbounds(Bool,leo.a,I...)
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
86 throw(BoundsError([leo],I...))
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
87 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
88 return leo.a[I...] * leo.b[I...]
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
89 end
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
90 Base.@propagate_inbounds @inline function Base.getindex(leo::LazyElementwiseOperation{T,D,:/}, I::Vararg{Int,D}) where {T,D}
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
91 @boundscheck if !checkbounds(Bool,leo.a,I...)
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
92 throw(BoundsError([leo],I...))
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
93 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
94 return leo.a[I...] / leo.b[I...]
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
95 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
96
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
97 # Define lazy operations for AbstractArrays. Operations constructs a LazyElementwiseOperation which
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
98 # can later be indexed into. Lazy operations are denoted by the usual operator followed by a tilde
202
9e737d19fcfe Fix formatting
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 199
diff changeset
99 Base.@propagate_inbounds +̃(a::AbstractArray{T,D}, b::AbstractArray{T,D}) where {T,D} = LazyElementwiseOperation{T,D,:+}(a,b)
9e737d19fcfe Fix formatting
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 199
diff changeset
100 Base.@propagate_inbounds -̃(a::AbstractArray{T,D}, b::AbstractArray{T,D}) where {T,D} = LazyElementwiseOperation{T,D,:-}(a,b)
9e737d19fcfe Fix formatting
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 199
diff changeset
101 Base.@propagate_inbounds *̃(a::AbstractArray{T,D}, b::AbstractArray{T,D}) where {T,D} = LazyElementwiseOperation{T,D,:*}(a,b)
9e737d19fcfe Fix formatting
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 199
diff changeset
102 Base.@propagate_inbounds /̃(a::AbstractArray{T,D}, b::AbstractArray{T,D}) where {T,D} = LazyElementwiseOperation{T,D,:/}(a,b)
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
103
204
9d9f7b0e514b Modify the implementation of elementwise operations to be more direct and add a few tests
Jonatan Werpers <jonatan@werpers.com>
parents: 198
diff changeset
104 # NOTE: Är det knas att vi har till exempel * istället för .* ??
9d9f7b0e514b Modify the implementation of elementwise operations to be more direct and add a few tests
Jonatan Werpers <jonatan@werpers.com>
parents: 198
diff changeset
105 # Oklart om det ens går att lösa..
205
70e1f3401d82 Merge. Throw away tests written by Jonatan
Jonatan Werpers <jonatan@werpers.com>
parents: 204 203
diff changeset
106 Base.@propagate_inbounds Base.:+(a::LazyArray{T,D}, b::LazyArray{T,D}) where {T,D} = a +̃ b
202
9e737d19fcfe Fix formatting
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 199
diff changeset
107 Base.@propagate_inbounds Base.:+(a::LazyArray{T,D}, b::AbstractArray{T,D}) where {T,D} = a +̃ b
205
70e1f3401d82 Merge. Throw away tests written by Jonatan
Jonatan Werpers <jonatan@werpers.com>
parents: 204 203
diff changeset
108 Base.@propagate_inbounds Base.:+(a::AbstractArray{T,D}, b::LazyArray{T,D}) where {T,D} = a +̃ b
204
9d9f7b0e514b Modify the implementation of elementwise operations to be more direct and add a few tests
Jonatan Werpers <jonatan@werpers.com>
parents: 198
diff changeset
109
205
70e1f3401d82 Merge. Throw away tests written by Jonatan
Jonatan Werpers <jonatan@werpers.com>
parents: 204 203
diff changeset
110 Base.@propagate_inbounds Base.:-(a::LazyArray{T,D}, b::LazyArray{T,D}) where {T,D} = a -̃ b
202
9e737d19fcfe Fix formatting
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 199
diff changeset
111 Base.@propagate_inbounds Base.:-(a::LazyArray{T,D}, b::AbstractArray{T,D}) where {T,D} = a -̃ b
199
a22b419bbdf0 Attempt fix for assertion inside constructor of LazyElementWiseOperation
Vidar Stiernström <vidar.stiernstrom@it.uu.se>
parents: 198
diff changeset
112 Base.@propagate_inbounds Base.:-(a::AbstractArray{T,D}, b::LazyArray{T,D}) where {T,D} = a -̃ b
204
9d9f7b0e514b Modify the implementation of elementwise operations to be more direct and add a few tests
Jonatan Werpers <jonatan@werpers.com>
parents: 198
diff changeset
113
206
7b0650021b36 Remove implementations of elementwise operation for * and /
Jonatan Werpers <jonatan@werpers.com>
parents: 205
diff changeset
114 # Element wise operation for `*` and `\` are not overloaded due to conflicts with the behavior
7b0650021b36 Remove implementations of elementwise operation for * and /
Jonatan Werpers <jonatan@werpers.com>
parents: 205
diff changeset
115 # of regular `*` and `/` for AbstractArrays. Use tilde versions instead.
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
116
195
5413067d2c4a Remove semicolon and some unneeded exports
Jonatan Werpers <jonatan@werpers.com>
parents: 194
diff changeset
117 export +̃, -̃, *̃, /̃
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
118
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
119
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
120
197
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
121 """
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
122 LazyTensorMappingTranspose{T,R,D} <: TensorMapping{T,D,R}
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
123
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
124 Struct for lazy transpose of a TensorMapping.
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
125
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
126 If a mapping implements the the `apply_transpose` method this allows working with
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
127 the transpose of mapping `m` by using `m'`. `m'` will work as a regular TensorMapping lazily calling
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
128 the appropriate methods of `m`.
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
129 """
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
130 struct LazyTensorMappingTranspose{T,R,D} <: TensorMapping{T,D,R}
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
131 tm::TensorMapping{T,R,D}
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
132 end
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
133 export LazyTensorMappingTranspose
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
134
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
135 # # TBD: Should this be implemented on a type by type basis or through a trait to provide earlier errors?
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
136 Base.adjoint(t::TensorMapping) = LazyTensorMappingTranspose(t)
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
137 Base.adjoint(t::LazyTensorMappingTranspose) = t.tm
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
138
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
139 apply(tm::LazyTensorMappingTranspose{T,R,D}, v::AbstractArray{T,R}, I::NTuple{D,Int}) where {T,R,D} = apply_transpose(tm.tm, v, I)
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
140 apply_transpose(tm::LazyTensorMappingTranspose{T,R,D}, v::AbstractArray{T,D}, I::NTuple{R,Int}) where {T,R,D} = apply(tm.tm, v, I)
197
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
141
232
a20bb4fac23d Improve tests for LazyTensors
Jonatan Werpers <jonatan@werpers.com>
parents: 210
diff changeset
142 range_size(tmt::LazyTensorMappingTranspose{T,R,D}, d_size::NTuple{R,Integer}) where {T,R,D} = domain_size(tmt.tm, d_size)
a20bb4fac23d Improve tests for LazyTensors
Jonatan Werpers <jonatan@werpers.com>
parents: 210
diff changeset
143 domain_size(tmt::LazyTensorMappingTranspose{T,R,D}, r_size::NTuple{D,Integer}) where {T,R,D} = range_size(tmt.tm, r_size)
197
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
144
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
145
a340fa91b1fc Move transpose def to the bottom of the file
Jonatan Werpers <jonatan@werpers.com>
parents: 196
diff changeset
146
210
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
147
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
148 struct LazyTensorMappingBinaryOperation{Op,T,R,D,T1<:TensorMapping{T,R,D},T2<:TensorMapping{T,R,D}} <: TensorMapping{T,D,R}
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
149 A::T1
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
150 B::T2
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
151
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
152 @inline function LazyTensorMappingBinaryOperation{Op,T,R,D}(A::T1,B::T2) where {Op,T,R,D, T1<:TensorMapping{T,R,D},T2<:TensorMapping{T,R,D}}
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
153 return new{Op,T,R,D,T1,T2}(A,B)
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
154 end
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
155 end
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
156
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
157 apply(mb::LazyTensorMappingBinaryOperation{:+,T,R,D}, v::AbstractArray{T,D}, I::NTuple{R,Int}) where {T,R,D} = apply(mb.A, v, I...) + apply(mb.B,v,I...)
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
158 apply(mb::LazyTensorMappingBinaryOperation{:-,T,R,D}, v::AbstractArray{T,D}, I::NTuple{R,Int}) where {T,R,D} = apply(mb.A, v, I...) - apply(mb.B,v,I...)
210
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
159
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
160 range_size(mp::LazyTensorMappingBinaryOperation{Op,T,R,D}, domain_size::NTuple{D,Integer}) where {Op,T,R,D} = range_size(mp.A, domain_size)
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
161 domain_size(mp::LazyTensorMappingBinaryOperation{Op,T,R,D}, range_size::NTuple{R,Integer}) where {Op,T,R,D} = domain_size(mp.A, range_size)
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
162
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
163 Base.:+(A::TensorMapping{T,R,D}, B::TensorMapping{T,R,D}) where {T,R,D} = LazyTensorMappingBinaryOperation{:+,T,R,D}(A,B)
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
164 Base.:-(A::TensorMapping{T,R,D}, B::TensorMapping{T,R,D}) where {T,R,D} = LazyTensorMappingBinaryOperation{:-,T,R,D}(A,B)
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
165
2aa33d0eef90 Add ability to add and subtract TensorMappings
Jonatan Werpers <jonatan@werpers.com>
parents: 209
diff changeset
166
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
167 # TODO: Write tests and documentation for LazyTensorMappingComposition
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
168 # struct LazyTensorMappingComposition{T,R,K,D} <: TensorMapping{T,R,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
169 # t1::TensorMapping{T,R,K}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
170 # t2::TensorMapping{T,K,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
171 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
172
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
173 # Base.:∘(s::TensorMapping{T,R,K}, t::TensorMapping{T,K,D}) where {T,R,K,D} = LazyTensorMappingComposition(s,t)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
174
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
175 # function range_size(tm::LazyTensorMappingComposition{T,R,K,D}, domain_size::NTuple{D,Integer}) where {T,R,K,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
176 # range_size(tm.t1, domain_size(tm.t2, domain_size))
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
177 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
178
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
179 # function domain_size(tm::LazyTensorMappingComposition{T,R,K,D}, range_size::NTuple{R,Integer}) where {T,R,K,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
180 # domain_size(tm.t1, domain_size(tm.t2, range_size))
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
181 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
182
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
183 # function apply(c::LazyTensorMappingComposition{T,R,K,D}, v::AbstractArray{T,D}, I::NTuple{R,Int}) where {T,R,K,D}
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
184 # apply(c.t1, LazyTensorMappingApplication(c.t2,v), I...)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
185 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
186
237
1c6afdcfd657 Regretsies on the CartesianIndex stuff. Use Vararg instead
Jonatan Werpers <jonatan@werpers.com>
parents: 236
diff changeset
187 # function apply_transpose(c::LazyTensorMappingComposition{T,R,K,D}, v::AbstractArray{T,D}, I::NTuple{D,Int}) where {T,R,K,D}
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
188 # apply_transpose(c.t2, LazyTensorMappingApplication(c.t1',v), I...)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
189 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
191 # # Have i gone too crazy with the type parameters? Maybe they aren't all needed?
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
192
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
193 # export →