@@ -10,6 +10,12 @@ struct BasisLayout <: AbstractBasisLayout end
10
10
struct SubBasisLayout <: AbstractBasisLayout end
11
11
struct MappedBasisLayout <: AbstractBasisLayout end
12
12
struct WeightedBasisLayout <: AbstractBasisLayout end
13
+ struct SubWeightedBasisLayout <: AbstractBasisLayout end
14
+ struct MappedWeightedBasisLayout <: AbstractBasisLayout end
15
+
16
+ SubBasisLayouts = Union{SubBasisLayout,SubWeightedBasisLayout}
17
+ WeightedBasisLayouts = Union{WeightedBasisLayout,SubWeightedBasisLayout,MappedWeightedBasisLayout}
18
+ MappedBasisLayouts = Union{MappedBasisLayout,MappedWeightedBasisLayout}
13
19
14
20
abstract type AbstractAdjointBasisLayout <: AbstractQuasiLazyLayout end
15
21
struct AdjointBasisLayout <: AbstractAdjointBasisLayout end
@@ -19,11 +25,21 @@ struct AdjointMappedBasisLayout <: AbstractAdjointBasisLayout end
19
25
MemoryLayout (:: Type{<:Basis} ) = BasisLayout ()
20
26
MemoryLayout (:: Type{<:Weight} ) = WeightLayout ()
21
27
22
- adjointlayout (:: Type , :: BasisLayout ) = AdjointBasisLayout ()
28
+ adjointlayout (:: Type , :: AbstractBasisLayout ) = AdjointBasisLayout ()
23
29
adjointlayout (:: Type , :: SubBasisLayout ) = AdjointSubBasisLayout ()
24
- adjointlayout (:: Type , :: MappedBasisLayout ) = AdjointMappedBasisLayout ()
30
+ adjointlayout (:: Type , :: MappedBasisLayouts ) = AdjointMappedBasisLayout ()
25
31
broadcastlayout (:: Type{typeof(*)} , :: WeightLayout , :: BasisLayout ) = WeightedBasisLayout ()
26
32
broadcastlayout (:: Type{typeof(*)} , :: WeightLayout , :: SubBasisLayout ) = WeightedBasisLayout ()
33
+ broadcastlayout (:: Type{typeof(*)} , :: WeightLayout , :: MappedBasisLayouts ) = MappedWeightedBasisLayout ()
34
+
35
+ # A sub of a weight is still a weight
36
+ sublayout (:: WeightLayout , _) = WeightLayout ()
37
+
38
+ # # Weighted basis interface
39
+ unweightedbasis (P:: BroadcastQuasiMatrix{<:Any,typeof(*),<:Tuple{AbstractQuasiVector,AbstractQuasiMatrix}} ) = last (P. args)
40
+ unweightedbasis (V:: SubQuasiArray ) = view (unweightedbasis (parent (V)), parentindices (V)... )
41
+
42
+
27
43
28
44
# Default is lazy
29
45
ApplyStyle (:: typeof (pinv), :: Type{<:Basis} ) = LazyQuasiArrayApplyStyle ()
48
64
@inline copy (L:: Ldiv{<:AbstractBasisLayout,BroadcastLayout{typeof(-)},<:Any,<:AbstractQuasiVector} ) =
49
65
transform_ldiv (L. A, L. B)
50
66
51
- function copy (P:: Ldiv{BasisLayout,BasisLayout } )
67
+ function copy (P:: Ldiv{<:AbstractBasisLayout,<:AbstractBasisLayout } )
52
68
A, B = P. A, P. B
53
69
A == B || throw (ArgumentError (" Override copy for $(typeof (A)) \\ $(typeof (B)) " ))
54
70
SquareEye {eltype(P)} ((axes (A,2 ),))
55
71
end
56
- function copy (P:: Ldiv{SubBasisLayout,SubBasisLayout } )
72
+ function copy (P:: Ldiv{<:SubBasisLayouts,<:SubBasisLayouts } )
57
73
A, B = P. A, P. B
58
74
parent (A) == parent (B) ||
59
75
throw (ArgumentError (" Override copy for $(typeof (A)) \\ $(typeof (B)) " ))
60
76
Eye {eltype(P)} ((axes (A,2 ),axes (B,2 )))
61
77
end
62
78
63
- @inline function copy (P:: Ldiv{MappedBasisLayout,MappedBasisLayout } )
79
+ @inline function copy (P:: Ldiv{<:MappedBasisLayouts,<:MappedBasisLayouts } )
64
80
A, B = P. A, P. B
65
81
demap (A)\ demap (B)
66
82
end
67
83
68
- @inline copy (L:: Ldiv{BasisLayout,SubBasisLayout } ) = apply (\ , L. A, ApplyQuasiArray (L. B))
69
- @inline function copy (L:: Ldiv{SubBasisLayout,BasisLayout } )
84
+ @inline copy (L:: Ldiv{<:AbstractBasisLayout,<:SubBasisLayouts } ) = apply (\ , L. A, ApplyQuasiArray (L. B))
85
+ @inline function copy (L:: Ldiv{<:SubBasisLayouts,<:AbstractBasisLayout } )
70
86
P = parent (L. A)
71
87
kr, jr = parentindices (L. A)
72
88
layout_getindex (apply (\ , P, L. B), jr, :) # avoid sparse arrays
83
99
_grid (_, P) = error (" Overload Grid" )
84
100
_grid (:: MappedBasisLayout , P) = igetindex .(Ref (parentindices (P)[1 ]), grid (demap (P)))
85
101
_grid (:: SubBasisLayout , P) = grid (parent (P))
86
- _grid (:: WeightedBasisLayout , P) = grid (last (P . args ))
102
+ _grid (:: WeightedBasisLayouts , P) = grid (unweightedbasis (P ))
87
103
grid (P) = _grid (MemoryLayout (typeof (P)), P)
88
104
89
105
struct TransformFactorization{T,Grid,Plan,IPlan} <: Factorization{T}
121
137
\ (a:: ProjectionFactorization , b:: AbstractVector ) = (a. F \ b)[a. inds]
122
138
123
139
_factorize (:: SubBasisLayout , L) = ProjectionFactorization (factorize (parent (L)), parentindices (L)[2 ])
140
+ # function _factorize(::MappedBasisLayout, L)
141
+ # kr, jr = parentindices(L)
142
+ # P = parent(L)
143
+ # ProjectionFactorization(factorize(view(P,:,jr)), parentindices(L)[2])
144
+ # end
124
145
125
146
transform_ldiv (A, B, _) = factorize (A) \ B
126
147
transform_ldiv (A, B) = transform_ldiv (A, B, axes (A))
@@ -131,18 +152,6 @@ copy(L::Ldiv{<:AbstractBasisLayout,<:Any,<:Any,<:AbstractQuasiVector}) =
131
152
copy (L:: Ldiv{<:AbstractBasisLayout,ApplyLayout{typeof(*)},<:Any,<:AbstractQuasiVector} ) =
132
153
transform_ldiv (L. A, L. B)
133
154
134
- function copy (L:: Ldiv{ApplyLayout{typeof(*)},<:AbstractBasisLayout} )
135
- args = arguments (ApplyLayout {typeof(*)} (), L. A)
136
- @assert length (args) == 2 # temporary
137
- apply (\ , last (args), apply (\ , first (args), L. B))
138
- end
139
-
140
-
141
- function copy (L:: Ldiv{<:AbstractBasisLayout,BroadcastLayout{typeof(*)},<:AbstractQuasiMatrix,<:AbstractQuasiVector} )
142
- p,T = factorize (L. A)
143
- T \ L. B[p]
144
- end
145
-
146
155
147
156
# #
148
157
# Algebra
151
160
# struct ExpansionLayout <: MemoryLayout end
152
161
# applylayout(::Type{typeof(*)}, ::BasisLayout, _) = ExpansionLayout()
153
162
154
- const Expansion{T,Space<: Basis ,Coeffs<: AbstractVector } = ApplyQuasiVector{T,typeof (* ),<: Tuple{Space,Coeffs} }
163
+ const Expansion{T,Space<: AbstractQuasiMatrix ,Coeffs<: AbstractVector } = ApplyQuasiVector{T,typeof (* ),<: Tuple{Space,Coeffs} }
155
164
156
- basis (v:: AbstractQuasiVector ) = v. args[1 ]
165
+
166
+ basis (v:: Expansion ) = v. args[1 ]
157
167
158
168
for op in (:* , :\ )
159
169
@eval function broadcasted (:: LazyQuasiArrayStyle{1} , :: typeof ($ op), x:: Number , f:: Expansion )
@@ -169,11 +179,19 @@ for op in (:*, :/)
169
179
end
170
180
171
181
172
- function broadcastbasis (:: typeof (+ ), a, b)
173
- a ≠ b && error (" Overload broadcastbasis(::typeof(+), ::$(typeof (a)) , ::$(typeof (b)) )" )
182
+ function _broadcastbasis (:: typeof (+ ), _, _, a, b)
183
+ try
184
+ a ≠ b && error (" Overload broadcastbasis(::typeof(+), ::$(typeof (a)) , ::$(typeof (b)) )" )
185
+ catch
186
+ error (" Overload broadcastbasis(::typeof(+), ::$(typeof (a)) , ::$(typeof (b)) )" )
187
+ end
174
188
a
175
189
end
176
190
191
+ _broadcastbasis (:: typeof (+ ), :: MappedBasisLayouts , :: MappedBasisLayouts , a, b) = broadcastbasis (+ , demap (a), demap (b))[basismap (a), :]
192
+
193
+ broadcastbasis (:: typeof (+ ), a, b) = _broadcastbasis (+ , MemoryLayout (a), MemoryLayout (b), a, b)
194
+
177
195
broadcastbasis (:: typeof (- ), a, b) = broadcastbasis (+ , a, b)
178
196
179
197
for op in (:+ , :- )
@@ -228,48 +246,43 @@ end
228
246
(Derivative (axes (P,1 ))* P* kr. A)[kr,jr]
229
247
end
230
248
231
- function copy (L:: Ldiv{<:AbstractBasisLayout,BroadcastLayout{typeof(*)},<:AbstractQuasiMatrix} )
232
- args = arguments (L. B)
233
- # this is a temporary hack
234
- if args isa Tuple{AbstractQuasiMatrix,Number}
235
- (L. A \ first (args))* last (args)
236
- elseif args isa Tuple{Number,AbstractQuasiMatrix}
237
- first (args)* (L. A \ last (args))
238
- else
239
- error (" Not implemented" )
240
- end
241
- end
242
-
243
-
244
249
# we represent as a Mul with a banded matrix
245
250
sublayout (:: AbstractBasisLayout , :: Type{<:Tuple{<:Inclusion,<:AbstractUnitRange}} ) = SubBasisLayout ()
246
251
sublayout (:: AbstractBasisLayout , :: Type{<:Tuple{<:AbstractAffineQuasiVector,<:AbstractUnitRange}} ) = MappedBasisLayout ()
252
+ sublayout (:: WeightedBasisLayout , :: Type{<:Tuple{<:AbstractAffineQuasiVector,<:AbstractUnitRange}} ) = MappedWeightedBasisLayout ()
253
+ sublayout (:: WeightedBasisLayout , :: Type{<:Tuple{<:Inclusion,<:AbstractUnitRange}} ) = SubWeightedBasisLayout ()
247
254
248
255
@inline sub_materialize (:: AbstractBasisLayout , V:: AbstractQuasiArray ) = V
249
256
@inline sub_materialize (:: AbstractBasisLayout , V:: AbstractArray ) = V
250
257
251
258
demap (x) = x
252
- demap (V:: SubQuasiArray{<:Any,2,<:Any,<:Tuple{<:Any,<:Slice}} ) = parent (V)
259
+ demap (x:: BroadcastQuasiArray ) = BroadcastQuasiArray (x. f, map (demap, arguments (x))... )
260
+ demap (V:: SubQuasiArray{<:Any,2,<:Any,<:Tuple{<:AbstractAffineQuasiVector,<:Slice}} ) = parent (V)
261
+ demap (V:: SubQuasiArray{<:Any,1,<:Any,<:Tuple{<:AbstractAffineQuasiVector}} ) = parent (V)
253
262
function demap (V:: SubQuasiArray{<:Any,2} )
254
263
kr, jr = parentindices (V)
255
264
demap (parent (V)[kr,:])[:,jr]
256
265
end
257
266
267
+ basismap (x:: SubQuasiArray{<:Any,2,<:Any,<:Tuple{<:AbstractAffineQuasiVector,<:Any}} ) = parentindices (x)[1 ]
268
+ basismap (x:: SubQuasiArray{<:Any,1,<:Any,<:Tuple{<:AbstractAffineQuasiVector}} ) = parentindices (x)[1 ]
269
+ basismap (x:: BroadcastQuasiArray ) = basismap (x. args[1 ])
270
+
258
271
259
272
# #
260
273
# SubLayout behaves like ApplyLayout{typeof(*)}
261
274
262
- combine_mul_styles (:: SubBasisLayout ) = combine_mul_styles (ApplyLayout {typeof(*)} ())
263
- _mul_arguments (:: SubBasisLayout , A) = _mul_arguments (ApplyLayout {typeof(*)} (), A)
264
- arguments (:: SubBasisLayout , A) = arguments (ApplyLayout {typeof(*)} (), A)
265
- call (:: SubBasisLayout , :: SubQuasiArray ) = *
275
+ combine_mul_styles (:: SubBasisLayouts ) = combine_mul_styles (ApplyLayout {typeof(*)} ())
276
+ _mul_arguments (:: SubBasisLayouts , A) = _mul_arguments (ApplyLayout {typeof(*)} (), A)
277
+ arguments (:: SubBasisLayouts , A) = arguments (ApplyLayout {typeof(*)} (), A)
278
+ call (:: SubBasisLayouts , :: SubQuasiArray ) = *
266
279
267
280
combine_mul_styles (:: AdjointSubBasisLayout ) = combine_mul_styles (ApplyLayout {typeof(*)} ())
268
281
_mul_arguments (:: AdjointSubBasisLayout , A) = _mul_arguments (ApplyLayout {typeof(*)} (), A)
269
282
arguments (:: AdjointSubBasisLayout , A) = arguments (ApplyLayout {typeof(*)} (), A)
270
283
call (:: AdjointSubBasisLayout , :: SubQuasiArray ) = *
271
284
272
- copy (M:: Mul{AdjointSubBasisLayout,SubBasisLayout } ) = apply (* , arguments (M. A)... , arguments (M. B)... )
285
+ copy (M:: Mul{AdjointSubBasisLayout,<:SubBasisLayouts } ) = apply (* , arguments (M. A)... , arguments (M. B)... )
273
286
274
287
function arguments (:: ApplyLayout{typeof(*)} , V:: SubQuasiArray{<:Any,2,<:Any,<:Tuple{<:Inclusion,<:AbstractUnitRange}} )
275
288
A = parent (V)
@@ -297,8 +310,8 @@ function __sum(LAY::ApplyLayout{typeof(*)}, V::AbstractQuasiVector, ::Colon)
297
310
first (apply (* , sum (a[1 ]; dims= 1 ), tail (a)... ))
298
311
end
299
312
300
- function __sum (:: MappedBasisLayout , V:: AbstractQuasiArray , dims)
301
- kr, jr = parentindices (V)
313
+ function __sum (:: MappedBasisLayouts , V:: AbstractQuasiArray , dims)
314
+ kr = basismap (V)
302
315
@assert kr isa AbstractAffineQuasiVector
303
316
sum (demap (V); dims= dims)/ kr. A
304
317
end
0 commit comments