Merge branch 'master' of github.com:ITensor/NDTensors.jl

Author: mtfishman

Project.toml

@@ -1,16 +1,19 @@
 name = "NDTensors"
 uuid = "23ae76d9-e61a-49c4-8f12-3f1a16adf9cf"
 authors = ["Matthew Fishman <mfishman@flatironinstitute.org>"]
-version = "0.1.18"
+version = "0.1.19"
 
 [deps]
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
+Dictionaries = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
 HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Strided = "5e0ebb24-38b0-5f93-81fe-25c709ecae67"
+TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
+TupleTools = "9d95972d-f1c8-5527-a6e0-b4b365fa01f6"
 
 [compat]
 Compat = "2.1, 3"
@@ -19,4 +22,6 @@ HDF5 = "0.12, 0.13, 0.14"
 Requires = "1.1"
 StaticArrays = "0.12, 1.0"
 Strided = "0.3, 1"
+TimerOutputs = "0.5.5"
+TupleTools = "1.2.0"
 julia = "1.3"

src/NDTensors.jl

@@ -1,17 +1,25 @@
 module NDTensors
 
 using Compat
+using Dictionaries
 using Random
 using LinearAlgebra
 using StaticArrays
 using HDF5
 using Requires
 using Strided
+using TimerOutputs
+using TupleTools
+
+using Base:
+  @propagate_inbounds,
+  ReshapedArray
 
 #####################################
-# Exports
+# Imports and exports
 #
 include("exports.jl")
+include("imports.jl")
 
 #####################################
 # DenseTensor and DiagTensor
@@ -33,6 +41,7 @@ include("svd.jl")
 # BlockSparseTensor
 #
 include("blocksparse/blockdims.jl")
+include("blocksparse/block.jl")
 include("blocksparse/blockoffsets.jl")
 include("blocksparse/blocksparse.jl")
 include("blocksparse/blocksparsetensor.jl")
@@ -45,6 +54,17 @@ include("blocksparse/linearalgebra.jl")
 #
 include("empty.jl")
 
+#####################################
+# Deprecations
+#
+include("deprecated.jl")
+
+#####################################
+# A global timer used with TimerOutputs.jl
+#
+
+const GLOBAL_TIMER = TimerOutput()
+
 #####################################
 # Optional TBLIS contraction backend
 #

src/blocksparse/block.jl

@@ -0,0 +1,153 @@
+
+#
+# Block
+#
+
+struct Block{N}
+  data::NTuple{N, UInt}
+  hash::UInt
+  function Block{N}(data::NTuple{N, UInt}) where {N}
+    h = _hash(data)
+    return new{N}(data, h)
+  end
+  function Block{0}(::Tuple{})
+    h = _hash(())
+    return new{0}((), h)
+  end
+end
+
+#
+# Constructors
+#
+
+Block{N}(t::Tuple{Vararg{<:Any, N}}) where {N} =
+  Block{N}(UInt.(t))
+
+Block{N}(I::CartesianIndex{N}) where {N} = Block{N}(I.I)
+
+Block{N}(v::MVector{N}) where {N} = Block{N}(Tuple(v))
+
+Block{N}(v::SVector{N}) where {N} = Block{N}(Tuple(v))
+
+Block(b::Block) = b
+
+Block(I::CartesianIndex{N}) where {N} = Block{N}(I)
+
+Block(v::MVector{N}) where {N} = Block{N}(v)
+
+Block(v::SVector{N}) where {N} = Block{N}(v)
+
+Block(t::NTuple{N, UInt}) where {N} = Block{N}(t)
+
+Block(t::Tuple{Vararg{<:Any, N}}) where {N} = Block{N}(t)
+
+Block(::Tuple{}) where {N} = Block{0}(())
+
+Block(I::Integer...) = Block(I)
+
+#
+# Conversions
+#
+
+CartesianIndex(b::Block) = CartesianIndex(Tuple(b))
+
+Tuple(b::Block{N}) where {N} = NTuple{N, UInt}(b.data)
+
+convert(::Type{Block}, I::CartesianIndex{N}) where {N} = Block{N}(I.I)
+
+convert(::Type{Block{N}}, I::CartesianIndex{N}) where {N} = Block{N}(I.I)
+
+convert(::Type{Block}, t::Tuple) where {N} = Block(t)
+
+convert(::Type{Block{N}}, t::Tuple) where {N} = Block{N}(t)
+
+#
+# Getting and setting fields
+#
+
+gethash(b::Block) = b.hash[]
+
+sethash!(b::Block, h::UInt) = (b.hash[] = h; return b)
+
+#
+# Basic functions
+#
+
+length(::Block{N}) where {N} = N
+
+iterate(b::Block, args...) = iterate(b.data, args...)
+
+using Base: @propagate_inbounds
+@propagate_inbounds function getindex(b::Block, i::Integer)
+  return b.data[i]
+end
+
+@propagate_inbounds setindex(b::Block{N}, val, i::Integer) where {N} =
+  Block{N}(setindex(b.data, UInt(val), i))
+
+ValLength(::Type{<:Block{N}}) where {N} = Val{N}
+
+deleteat(b::Block, pos) = Block(deleteat(Tuple(b), pos))
+
+insertafter(b::Block, val, pos) =
+  Block(insertafter(Tuple(b), UInt.(val), pos))
+
+getindices(b::Block, I) = getindices(Tuple(b), I)
+
+#
+# Hashing
+#
+
+# Borrowed from:
+# https://github.com/JuliaLang/julia/issues/37073
+# This is the same as Julia's Base tuple hash, but is
+# a bit faster.
+_hash(t::Tuple) = _hash(t, zero(UInt))
+_hash(::Tuple{}, h::UInt) = h + Base.tuplehash_seed
+using Base.Cartesian: @nexprs
+@generated function _hash(b::NTuple{N}, h::UInt) where {N}
+  quote
+    out = h + Base.tuplehash_seed
+    @nexprs $N i -> out = hash(b[$N-i+1], out)
+  end
+end
+# Stop inlining after some number of arguments to avoid code blowup
+function _hash(t::Base.Any16, h::UInt)
+  out = h + Base.tuplehash_seed
+  for i = length(t):-1:1
+      out = hash(t[i], out)
+  end
+  return out
+end
+
+hash(b::Block) = UInt(b.hash)
+hash(b::Block, h::UInt) = h + hash(b)
+
+#
+# Custom NTuple{N, Int} hashes
+# These are faster, but have a lot of collisions
+#
+
+# Borrowed from:
+# https://stackoverflow.com/questions/20511347/a-good-hash-function-for-a-vector
+# This seems to have a lot of clashes
+#function Base.hash(b::Block, seed::UInt)
+#  h = UInt(0x9e3779b9)
+#  for n in b
+#    seed ⊻= n + h + (seed << 6) + (seed >> 2)
+#  end
+#  return seed
+#end
+
+# Borrowed from:
+# http://www.docjar.com/html/api/java/util/Arrays.java.html
+# Could also consider uring the CPython tuple hash:
+# https://github.com/python/cpython/blob/0430dfac629b4eb0e899a09b899a494aa92145f6/Objects/tupleobject.c#L406
+#function Base.hash(b::Block, h::UInt)
+#  h += Base.tuplehash_seed
+#  for n in b
+#    h = 31 * h + n ⊻ (n >> 32)
+#  end
+#  return h
+#end
+

src/blocksparse/blockdims.jl

@@ -1,9 +1,3 @@
-export BlockDims,
-       blockdim,
-       blockdims,
-       nblocks,
-       blockindex
-
 """
 BlockDim
 
@@ -107,34 +101,30 @@ function blockdim(ind::BlockDim,
 end
 
 """
-blockdim(::BlockDims,block,::Integer)
+    blockdim(::BlockDims,block,::Integer)
 
 The size of the specified block in the specified
 dimension.
 """
-function blockdim(inds,
-                  block,
-                  i::Integer)
+function blockdim(inds, block, i::Integer)
   return blockdim(inds[i],block[i])
 end
 
 """
-blockdims(::BlockDims,block)
+    blockdims(::BlockDims,block)
 
 The size of the specified block.
 """
-function blockdims(inds,
-                   block)
+function blockdims(inds, block)
   return ntuple(i->blockdim(inds,block,i),ValLength(inds))
 end
 
 """
-blockdim(::BlockDims,block)
+    blockdim(::BlockDims,block)
 
 The total size of the specified block.
 """
-function blockdim(inds,
-                  block)
+function blockdim(inds, block)
   return prod(blockdims(inds,block))
 end
 
@@ -164,8 +154,7 @@ end
 
 # Given a CartesianIndex in the range dims(T), get the block it is in
 # and the index within that block
-function blockindex(T,
-                    i::Vararg{Int,N}) where {ElT,N}
+function blockindex(T, i::Vararg{Int,N}) where {ElT,N}
   # Start in the (1,1,...,1) block
   current_block_loc = @MVector ones(Int,N)
   current_block_dims = blockdims(T,Tuple(current_block_loc))
@@ -177,7 +166,7 @@ function blockindex(T,
       current_block_dims = blockdims(T,Tuple(current_block_loc))
     end
   end
-  return Tuple(block_index),Block{N}(current_block_loc)
+  return Tuple(block_index), Block{N}(current_block_loc)
 end
 
 blockindex(T) = (),Block{0}()