Mercurial > repos > public > sbplib_julia

annotate LazyTensors/src/lazy_operations.jl @ 194:d30d42a11566 boundary_conditions

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Move all Lazy operation into the same module
author Jonatan Werpers <jonatan@werpers.com>
date Thu, 20 Jun 2019 23:11:30 +0200
parents 8964b3165097
children 5413067d2c4a
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 """
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
2 LazyTensorMappingTranspose{T,R,D} <: TensorMapping{T,D,R}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
3
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
4 Struct for lazy transpose of a TensorMapping.
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
5
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
6 If a mapping implements the the `apply_transpose` method this allows working with
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
7 the transpose of mapping `m` by using `m'`. `m'` will work as a regular TensorMapping lazily calling
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
8 the appropriate methods of `m`.
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
9 """
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
10 struct LazyTensorMappingTranspose{T,R,D} <: TensorMapping{T,D,R}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
11 tm::TensorMapping{T,R,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
12 end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
13 export LazyTensorMappingTranspose
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
14
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
15 # # TBD: Should this be implemented on a type by type basis or through a trait to provide earlier errors?
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
16 Base.adjoint(t::TensorMapping) = LazyTensorMappingTranspose(t)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
17 Base.adjoint(t::LazyTensorMappingTranspose) = t.tm
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
18
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
19 apply(tm::LazyTensorMappingTranspose{T,R,D}, v::AbstractArray{T,R}, I::Vararg) where {T,R,D} = apply_transpose(tm.tm, v, I...)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
20 apply_transpose(tm::LazyTensorMappingTranspose{T,R,D}, v::AbstractArray{T,D}, I::Vararg) where {T,R,D} = apply(tm.tm, v, I...)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
21
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
22 range_size(tmt::LazyTensorMappingTranspose{T,R,D}, d_size::NTuple{R,Integer}) where {T,R,D} = domain_size(tmt.tm, domain_size)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
23 domain_size(tmt::LazyTensorMappingTranspose{T,R,D}, r_size::NTuple{D,Integer}) where {T,R,D} = range_size(tmt.tm, range_size)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
24
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
25
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
26
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 LazyTensorMappingApplication{T,R,D} <: AbstractArray{T,R}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
29
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
30 Struct for lazy application of a TensorMapping. Created using `*`.
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
31
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
32 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
33 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
34 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
35 """
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
36 struct LazyTensorMappingApplication{T,R,D} <: AbstractArray{T,R}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
37 t::TensorMapping{T,R,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
38 o::AbstractArray{T,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
39 end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
40 export LazyTensorMappingApplication
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 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
43
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
44 Base.getindex(ta::LazyTensorMappingApplication{T,R,D}, I::Vararg) where {T,R,D} = apply(ta.t, ta.o, I...)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
45 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
46 # 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
47
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
48
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
49 # # We need the associativity to be a→b→c = a→(b→c), which is the case for '→'
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
50 Base.:*(args::Union{TensorMapping{T}, AbstractArray{T}}...) where T = foldr(*,args)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
51 # # Should we overload some other infix binary operator?
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
52 # →(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
53 # 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
54 # 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
55
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
56
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
57
194
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
58 """
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
59 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
60
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
61 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
62
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
63 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
64 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
65 LazyElementwiseOperation is indexed.
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 struct 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
68 a::T1
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
69 b::T2
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
70
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
71 function LazyElementwiseOperation{T,D,Op}(a::T1,b::T2) where {T,D,Op, T1<:AbstractArray{T,D}, T2<:AbstractArray{T,D}}
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
72 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
73 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
74 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
75
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
76 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
77
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
78 # 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
79 # 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
80 # 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
81 # 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
82 # boundschecking differently.
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
83 Base.@propagate_inbounds @inline function Base.getindex(leo::LazyElementwiseOperation{T,D,:+}, I...) where {T,D}
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
84 @boundscheck if !checkbounds(Bool,leo.a,I...)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
85 throw(BoundsError([leo],[I...]))
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
86 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
87 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
88 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
89 Base.@propagate_inbounds @inline function Base.getindex(leo::LazyElementwiseOperation{T,D,:-}, I...) where {T,D}
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
90 @boundscheck if !checkbounds(Bool,leo.a,I...)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
91 throw(BoundsError([leo],[I...]))
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
92 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
93 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
94 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
95 Base.@propagate_inbounds @inline function Base.getindex(leo::LazyElementwiseOperation{T,D,:*}, I...) where {T,D}
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
96 @boundscheck if !checkbounds(Bool,leo.a,I...)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
97 throw(BoundsError([leo],[I...]))
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
98 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
99 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
100 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
101 Base.@propagate_inbounds @inline function Base.getindex(leo::LazyElementwiseOperation{T,D,:/}, I...) where {T,D}
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
102 @boundscheck if !checkbounds(Bool,leo.a,I...)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
103 throw(BoundsError([leo],[I...]))
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
104 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
105 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
106 end
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
107
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
108 # 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
109 # can later be indexed into. Lazy operations are denoted by the usual operator followed by a tilde
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
110 @inline +̃(a::AbstractArray{T,D},b::AbstractArray{T,D}) where {T,D} = LazyElementwiseOperation{T,D,:+}(a,b)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
111 @inline -̃(a::AbstractArray{T,D},b::AbstractArray{T,D}) where {T,D} = LazyElementwiseOperation{T,D,:-}(a,b)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
112 @inline *̃(a::AbstractArray{T,D},b::AbstractArray{T,D}) where {T,D} = LazyElementwiseOperation{T,D,:*}(a,b)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
113 @inline /̃(a::AbstractArray{T,D},b::AbstractArray{T,D}) where {T,D} = LazyElementwiseOperation{T,D,:/}(a,b)
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
114
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
115 # Abstract type for which the normal operations are defined by their
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
116 # lazy counterparts
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
117 abstract type LazyArray{T,D} <: AbstractArray{T,D} end;
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 Base.:+(a::LazyArray{T,D},b::AbstractArray{T,D}) where {T,D} = a +̃ b
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
120 Base.:+(a::AbstractArray{T,D}, b::LazyArray{T,D}) where {T,D} = b + a
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
121 Base.:-(a::LazyArray{T,D},b::AbstractArray{T,D}) where {T,D} = a -̃ b
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
122 Base.:-(a::AbstractArray{T,D}, b::LazyArray{T,D}) where {T,D} = a -̃ b
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
123 Base.:*(a::LazyArray{T,D},b::AbstractArray{T,D}) where {T,D} = a *̃ b
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
124 Base.:*(a::AbstractArray{T,D},b::LazyArray{T,D}) where {T,D} = b * a
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
125 # TODO: / seems to be ambiguous
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
126 # Base.:/(a::LazyArray{T,D},b::AbstractArray{T,D}) where {T,D} = a /̃ b
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
127 # Base.:/(a::AbstractArray{T,D},b::LazyArray{T,D}) where {T,D} = a /̃ b
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
128
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
129 export +̃, -̃, *̃, /̃, +, -, * #, /
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
130
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
131
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
132
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
133
d30d42a11566 Move all Lazy operation into the same module
Jonatan Werpers <jonatan@werpers.com>
parents: 190
diff changeset
134
190
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
135 # TODO: Write tests and documentation for LazyTensorMappingComposition
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
136 # 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
137 # t1::TensorMapping{T,R,K}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
138 # t2::TensorMapping{T,K,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
139 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
140
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
141 # 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
142
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
143 # 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
144 # 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
145 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
146
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
147 # 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
148 # 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
149 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
150
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
151 # function apply(c::LazyTensorMappingComposition{T,R,K,D}, v::AbstractArray{T,D}, I::Vararg) where {T,R,K,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
152 # apply(c.t1, LazyTensorMappingApplication(c.t2,v), I...)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
153 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
154
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
155 # function apply_transpose(c::LazyTensorMappingComposition{T,R,K,D}, v::AbstractArray{T,D}, I::Vararg) where {T,R,K,D}
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
156 # apply_transpose(c.t2, LazyTensorMappingApplication(c.t1',v), I...)
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
157 # end
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
158
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
159 # # 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
160
8964b3165097 Break LazyTensors.jl into several files
Jonatan Werpers <jonatan@werpers.com>
parents:
diff changeset
161 # export →