hamiltonian.hpp

Go to the documentation of this file.

//
// (C) Daniel Strano and the Qrack contributors 2017-2023. All rights reserved.
//
// This is a multithreaded, universal quantum register simulation, allowing
// (nonphysical) register cloning and direct measurement of probability and
// phase, to leverage what advantages classical emulation of qubits can have.
//
// Licensed under the GNU Lesser General Public License V3.
// See LICENSE.md in the project root or https://www.gnu.org/licenses/lgpl-3.0.en.html
// for details.
#pragma once
 
#include "common/qrack_types.hpp"
 
struct _QrackTimeEvolveOpHeader {
    unsigned target;
    unsigned controlLen;
    unsigned controls[32U];
};
 
namespace Qrack {
 
typedef std::shared_ptr<complex> BitOp;
 
struct HamiltonianOp {
    bitLenInt targetBit;
    bool anti;
    bool uniform;
    BitOp matrix;
    std::vector<bitLenInt> controls;
    std::vector<bool> toggles;
 
    HamiltonianOp()
        : targetBit(0U)
        , anti(false)
        , uniform(false)
        , matrix{ nullptr }
        , controls()
        , toggles()
    {
    }
 
    HamiltonianOp(bitLenInt target, BitOp mtrx)
        : targetBit(target)
        , anti(false)
        , uniform(false)
        , matrix(mtrx)
        , controls()
        , toggles()
    {
    }
 
    HamiltonianOp(const std::vector<bitLenInt>& ctrls, bitLenInt target, BitOp mtrx, bool antiCtrled = false,
        const std::vector<bool>& ctrlToggles = std::vector<bool>())
        : targetBit(target)
        , anti(antiCtrled)
        , uniform(false)
        , matrix(mtrx)
        , controls(ctrls)
        , toggles(ctrlToggles)
    {
    }
};
 
struct UniformHamiltonianOp : HamiltonianOp {
    UniformHamiltonianOp(const std::vector<bitLenInt>& ctrls, bitLenInt target, BitOp mtrx)
        : HamiltonianOp(ctrls, target, mtrx)
    {
        uniform = true;
    }
 
    UniformHamiltonianOp(const _QrackTimeEvolveOpHeader& teoh, double* mtrx)
        : HamiltonianOp()
    {
        targetBit = (bitLenInt)(teoh.target);
 
        const bitLenInt controlLen = (bitLenInt)teoh.controlLen;
        controls = std::vector<bitLenInt>(teoh.controls, teoh.controls + controlLen);
 
        uniform = true;
 
        bitCapIntOcl mtrxTermCount = ((bitCapIntOcl)1U << controlLen) * 4U;
        BitOp m(new complex[mtrxTermCount], std::default_delete<complex[]>());
        matrix = std::move(m);
        for (bitCapIntOcl i = 0U; i < mtrxTermCount; ++i) {
            matrix.get()[i] = complex((real1)mtrx[i * 2U], (real1)mtrx[(i * 2U) + 1U]);
        }
    }
};
 
typedef std::shared_ptr<HamiltonianOp> HamiltonianOpPtr;
typedef std::vector<HamiltonianOpPtr> Hamiltonian;
} // namespace Qrack