reorder file

Author: ogauthe

src/blockedtuple.jl

@@ -3,26 +3,19 @@
 
 using BlockArrays: Block, BlockArrays, BlockIndexRange, BlockRange, blockedrange
 
+#
+# ==================================  AbstractBlockTuple  ==================================
+#
 abstract type AbstractBlockTuple end
 
-struct BlockedTuple{BlockLengths,Flat} <: AbstractBlockTuple
-  flat::Flat
-
-  function BlockedTuple{BlockLengths}(flat::Tuple) where {BlockLengths}
-    length(flat) != sum(BlockLengths) && throw(DimensionMismatch("Invalid total length"))
-    return new{BlockLengths,typeof(flat)}(flat)
-  end
-end
-
-# TensorAlgebra Interface
-BlockedTuple(tt::Vararg{Tuple}) = BlockedTuple{length.(tt)}(flatten_tuples(tt))
-BlockedTuple(bt::BlockedTuple) = bt
-
 # Base interface
-Base.Tuple(bt::BlockedTuple) = bt.flat
-
 Base.axes(bt::AbstractBlockTuple) = (blockedrange([blocklengths(bt)...]),)
 
+Base.firstindex(::AbstractBlockTuple) = 1
+
+Base.lastindex(bt::AbstractBlockTuple) = length(bt)
+
+# Broadcast interface
 Base.broadcastable(bt::AbstractBlockTuple) = bt
 struct BlockedTupleBroadcastStyle{BlockLengths} <: Broadcast.BroadcastStyle end
 function Base.BroadcastStyle(type::Type{<:AbstractBlockTuple})
@@ -39,12 +32,48 @@ function Base.copy(
   return BlockedTuple{BlockLengths}(bc.f.((Tuple.(bc.args))...))
 end
 
+# BlockArrays interface
+function BlockArrays.blockfirsts(bt::AbstractBlockTuple)
+  return (0, cumsum(blocklengths(bt)[begin:(end - 1)])...) .+ 1
+end
+
+function BlockArrays.blocklasts(bt::AbstractBlockTuple)
+  return cumsum(blocklengths(bt)[begin:end])
+end
+
+BlockArrays.blocklength(bt::AbstractBlockTuple) = length(blocklengths(bt))
+
+BlockArrays.blocklengths(bt::AbstractBlockTuple) = blocklengths(typeof(bt))
+
+function BlockArrays.blocks(bt::AbstractBlockTuple)
+  bf = blockfirsts(bt)
+  bl = blocklasts(bt)
+  return ntuple(i -> Tuple(bt)[bf[i]:bl[i]], blocklength(bt))
+end
+
+#
+# =====================================  BlockedTuple  =====================================
+#
+struct BlockedTuple{BlockLengths,Flat} <: AbstractBlockTuple
+  flat::Flat
+
+  function BlockedTuple{BlockLengths}(flat::Tuple) where {BlockLengths}
+    length(flat) != sum(BlockLengths) && throw(DimensionMismatch("Invalid total length"))
+    return new{BlockLengths,typeof(flat)}(flat)
+  end
+end
+
+# TensorAlgebra Interface
+BlockedTuple(tt::Vararg{Tuple}) = BlockedTuple{length.(tt)}(flatten_tuples(tt))
+BlockedTuple(bt::BlockedTuple) = bt
+
+# Base interface
+Base.Tuple(bt::BlockedTuple) = bt.flat
+
 Base.copy(bt::BlockedTuple) = BlockedTuple{blocklengths(bt)}(copy.(Tuple(bt)))
 
 Base.deepcopy(bt::BlockedTuple) = BlockedTuple{blocklengths(bt)}(deepcopy.(Tuple(bt)))
 
-Base.firstindex(::AbstractBlockTuple) = 1
-
 Base.getindex(bt::BlockedTuple, i::Integer) = Tuple(bt)[i]
 Base.getindex(bt::BlockedTuple, r::AbstractUnitRange) = Tuple(bt)[r]
 Base.getindex(bt::BlockedTuple, b::Block{1}) = blocks(bt)[Int(b)]
@@ -54,30 +83,11 @@ Base.getindex(bt::BlockedTuple, bi::BlockIndexRange{1}) = bt[Block(bi)][only(bi.
 Base.iterate(bt::BlockedTuple) = iterate(Tuple(bt))
 Base.iterate(bt::BlockedTuple, i::Int) = iterate(Tuple(bt), i)
 
-Base.lastindex(bt::AbstractBlockTuple) = length(bt)
-
 Base.length(bt::BlockedTuple) = length(Tuple(bt))
 
 Base.map(f, bt::BlockedTuple) = BlockedTuple{blocklengths(bt)}(map(f, Tuple(bt)))
 
 # BlockArrays interface
-function BlockArrays.blockfirsts(bt::AbstractBlockTuple)
-  return (0, cumsum(blocklengths(bt)[begin:(end - 1)])...) .+ 1
-end
-
-function BlockArrays.blocklasts(bt::AbstractBlockTuple)
-  return cumsum(blocklengths(bt)[begin:end])
-end
-
-BlockArrays.blocklength(bt::AbstractBlockTuple) = length(blocklengths(bt))
-
-BlockArrays.blocklengths(bt::AbstractBlockTuple) = blocklengths(typeof(bt))
 function BlockArrays.blocklengths(::Type{<:BlockedTuple{BlockLengths}}) where {BlockLengths}
   return BlockLengths
 end
-
-function BlockArrays.blocks(bt::AbstractBlockTuple)
-  bf = blockfirsts(bt)
-  bl = blocklasts(bt)
-  return ntuple(i -> Tuple(bt)[bf[i]:bl[i]], blocklength(bt))
-end

test/test_blockedtuple.jl

@@ -5,25 +5,25 @@ using BlockArrays: Block, blocklength, blocklengths, blockedrange, blockisequal,
 using TensorAlgebra: BlockedTuple
 
 @testset "BlockedTuple" begin
-  flat = (1, 'a', 2, 'b', 3)
+  flat = (true, 'a', 2, "b", 3.0)
   divs = (1, 2, 2)
 
   bt = BlockedTuple{divs}(flat)
 
   @test Tuple(bt) == flat
-  @test bt == BlockedTuple((1,), ('a', 2), ('b', 3))
+  @test bt == BlockedTuple((true,), ('a', 2), ("b", 3.0))
   @test BlockedTuple(bt) == bt
   @test blocklength(bt) == 3
   @test blocklengths(bt) == (1, 2, 2)
-  @test blocks(bt) == ((1,), ('a', 2), ('b', 3))
+  @test blocks(bt) == ((true,), ('a', 2), ("b", 3.0))
 
-  @test bt[1] == 1
+  @test bt[1] == true
   @test bt[2] == 'a'
   @test bt[Block(1)] == blocks(bt)[1]
   @test bt[Block(2)] == blocks(bt)[2]
   @test bt[Block(1):Block(2)] == blocks(bt)[1:2]
   @test bt[Block(2)[1:2]] == ('a', 2)
-  @test bt[2:4] == ('a', 2, 'b')
+  @test bt[2:4] == ('a', 2, "b")
 
   @test firstindex(bt) == 1
   @test lastindex(bt) == 5