ITensor/itensor/index.h at unordered_map · ITensor/ITensor

548 lines (409 loc) · 10.3 KB
// Copyright 2018 The Simons Foundation, Inc. - All Rights Reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//    http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef __ITENSOR_INDEX_H
#define __ITENSOR_INDEX_H
#include "itensor/global.h"
#include "itensor/tagset.h"
#include "itensor/arrow.h"
#include "itensor/qn.h"
#include <thread>
namespace itensor {
//Forward declarations
class IndexVal;
using QNInt = std::pair<QN,long>;
namespace detail {
    struct RandomID
        using rng_type = std::mt19937_64;
        using result_type = typename rng_type::result_type;
        std::hash<std::thread::id> hasher;
        RandomID()
            : rng(std::clock() + hasher(std::this_thread::get_id()))
        result_type
        operator()() { return rng(); }
        private:
        rng_type rng;
    struct SequentialID
        using result_type = std::uint_fast32_t;
        SequentialID() : id(1) { }
        result_type
        operator()()
            auto res = id;
            id += 1;
            return res; 
        private:
        result_type id = 0;
    } //namespace detail
// Represents a tensor index of fixed bond dimension m.
// Can be compared with == operator (returns true if both
// are copies of the same Index instance).
class IQIndexDat;
class Index
    public:
    using IDGenerator = detail::RandomID;
    using id_type = IDGenerator::result_type;
    using extent_type = int;
    using qnstorage = std::vector<QNInt>;
    using qn_ptr = std::shared_ptr<IQIndexDat>;
    private:
    id_type id_;
    extent_type dim_;
    Arrow dir_ = Out;
    qn_ptr pd;
    TagSet tags_;
    public:
    Index();
    explicit
    Index(long dim, 
          TagSet const& ts = TagSet("0"));
    // Deprecated
    explicit
    Index(std::string s,
          long m)
        Error("Index(string,int) constructor deprecated, use Index(int,...) instead");
    template<typename... QN_Sizes>
    Index(QN const& q1, long size1,
          QN_Sizes const&... qnsizes);
    Index(qnstorage && qns, 
          TagSet const& ts = TagSet("0"));
    Index(qnstorage && qns, 
          Arrow dir,
          TagSet const& ts = TagSet("0"));
    // Returns the dimension of this Index
    dim() const { return dim_; }
    // Returns the prime level
    primeLevel() const { return tags_.primeLevel(); }
    // Returns the TagSet
    tags() const { return tags_; }
    id_type
    id() const { return id_; }
    // Evaluates to false if Index is default constructed.
    explicit operator bool() const;
    // (Explicitly) convertible to integer types
    explicit operator int() const { return dim(); }
    explicit operator long() const { return dim(); }
    explicit operator size_t() const { return dim(); }
    // Add tags
    addTags(const TagSet& t) { tags_.addTags(t); return *this; }
    // Remove tags
    removeTags(const TagSet& t) { tags_.removeTags(t); return *this; }
    // Set tags
    setTags(const TagSet& t) { tags_.setTags(t); return *this; }
    // Remove all tags
    noTags() { tags_.noTags(); return *this; }
    // Set tags
    replaceTags(const TagSet& tsold, const TagSet& tsnew) { tags_.replaceTags(tsold,tsnew); return *this; }
    // Sets the prime level to a specified value.
    Index& 
    setPrime(int p);
    // Sets the prime level to 0.
    Index& 
    noPrime();
    // Increase primelevel by 1 (or by optional amount inc)
    Index& 
    prime(int inc = 1);
    //Return an IndexVal with specified value
    IndexVal
    operator()(long val) const;
    IndexVal
    operator=(long val) const;
    //define size()==dim() in order to do 
    //for(auto n : range(I)) { ... } for some Index I
    size() const { return dim(); }
    // Write Index to binary output stream.
    write(std::ostream& s) const;
    // Read Index from binary input stream.
    Index& 
    read(std::istream& s);
    // QN related functions
    //number of quantum number blocks
    nblock() const;
    //1-indexed
    blocksize(long i) const;
    //1-indexed
    QN const& 
    qn(long i) const;
    dir() const { return dir_; }
    setDir(Arrow ndir) { dir_ = ndir; }
    Index& 
    dag() { dir_ = -dir_; return *this; }
    qn_ptr const&
    store() const { return pd; }
    sim(Index const& I)
      *this = I;
      id_ = generateID();
      return *this;
    private:
    makeStorage(qnstorage && qi);
    Index::id_type 
    generateID();
    public:
    // Advanced / developer methods.
    // Not intended for normal usage.
    // Constructor taking a QN pointer
    Index(qn_ptr const& p,
          TagSet const& tags = TagSet());
    Index(qn_ptr const& p,
          Arrow dir, 
          TagSet const& tags);
    Index(id_type id,
          long dim, 
          Arrow dir, 
          TagSet const& ts);
    //0-indexed
    blocksize0(long i) const;
    removeQNs() { pd.reset(); }
    public:
    //Deprecated: prefer to use I.dim() or dim(I)
    //long 
    //m() const
    //    {
    //    Global::warnDeprecated(".m() is deprecated in favor of dim(Index)");
    //    return this->dim();
    //    }
    }; //class Index
// i1 compares equal to i2 if i2 is a copy of i1 with same primelevel
operator==(Index const& i1, Index const& i2);
operator!=(Index const& i1, Index const& i2);
// Useful for sorting Index objects
operator<(Index const& i1, Index const& i2);
operator>(Index const& i1, Index const& i2);
// IndexVal
// Class pairing an Index of dimension m
// with a specific value i where 1 <= i <= m
class IndexVal
    public:
    Index index;
    long val;
    IndexVal();
    IndexVal(const Index& index, long val_);
    dim() const { return index.dim(); }
    explicit operator bool() const { return bool(index); }
    // Add tags
    IndexVal&
    addTags(const TagSet& t) { index.addTags(t); return *this; }
    // Remove tags
    IndexVal&
    removeTags(const TagSet& t) { index.removeTags(t); return *this; }
    // Set tags
    IndexVal&
    setTags(const TagSet& t) { index.setTags(t); return *this; }
    // Remove all tags
    IndexVal&
    noTags() { index.noTags(); return *this; }
    // Set tags
    IndexVal&
    replaceTags(const TagSet& tsold, const TagSet& tsnew) { index.replaceTags(tsold,tsnew); return *this; }
    // Sets the prime level to a specified value.
    IndexVal&
    setPrime(int p) { index.setPrime(p); return *this; }
    // Sets the prime level to 0.
    IndexVal&
    noPrime() { index.noPrime(); return *this; }
    // Increase primelevel by 1 (or by optional amount inc)
    IndexVal&
    prime(int inc = 1) { index.prime(inc); return *this; }
    IndexVal& 
    QN const&
    qn() const;
    //Deprecated: prefer to use .dim()
    m() const 
      Global::warnDeprecated(".m() is deprecated in favor of dim(IndexVal)");
      return this->dim();
operator==(IndexVal const& iv1, IndexVal const& iv2);
operator!=(IndexVal const& iv1, IndexVal const& iv2);
operator==(IndexVal const& iv, Index const& I);
operator==(Index const& I, IndexVal const& iv);
Index::id_type
id(Index const& I);
dim(Index const& I);
dim(IndexVal const& I);
primeLevel(Index const& I);
tags(Index const& I);
// Check if Index I contains the tags tsmatch.
hasTags(Index I, TagSet const& tsmatch);
hasQNs(Index const& I);
removeQNs(Index I);
hasQNs(IndexVal const& iv);
dag(Index res);
dag(IndexVal res);
qn(Index const& i, long b);
qn(IndexVal const& iv);
dir(Index const& res);
dir(IndexVal const& res);
Index const&
index(IndexVal const& res);
val(IndexVal const& res);
nblock(Index const& i);
blocksize(Index const& i, long b);
// Tag functions
addTags(Index I, TagSet const& t);
removeTags(Index I, TagSet const& t);
setTags(Index I, TagSet const& t);
noTags(Index I);
replaceTags(Index I, TagSet const& tsold, TagSet const& tsnew);
prime(Index I, int plinc = 1);
setPrime(Index I, int plev);
noPrime(Index I);
addTags(IndexVal I, TagSet const& t);
removeTags(IndexVal I, TagSet const& t);
setTags(IndexVal I, TagSet const& t);
noTags(IndexVal I);
replaceTags(IndexVal I, TagSet const& tsold, TagSet const& tsnew);
prime(IndexVal I, int plinc = 1); 
setPrime(IndexVal I, int plev); 
noPrime(IndexVal I); 
// Get the direct sum of two indices
directSum(Index const& i,
          Index const& j,
          Args const& args = Args::global());
//Make a new index with same properties as I,
//but a different id number (will not compare equal)
sim(Index const& I);
//Returns a string version of this Index's bond dimension.
std::string
showDim(Index const& I);
std::ostream& 
operator<<(std::ostream & s, Index const& t);
std::ostream& 
operator<<(std::ostream& s, IndexVal const& iv);
add(Args& args, 
    Args::Name const& name, 
    TagSet const& ts);
getTagSet(Args const& args, 
          Args::Name const& name);
getTagSet(Args const& args, 
          Args::Name const& name, 
          TagSet const& default_val);
QNblock(Index const& I, 
        QN const& Q);
QNblockSize(Index const& I, 
            QN const& Q);
write(std::ostream & s, QNInt const& q);
read(std::istream & s, QNInt & q);
isFermionic(Index const& I);
#ifdef ITENSOR_USE_HDF5
h5_write(h5::group parent, std::string const& name, Index const& I);
h5_read(h5::group parent, std::string const& name, Index & I);
} //namespace itensor
#include "itensor/index_impl.h"
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

index.h

Latest commit

History

index.h

File metadata and controls
