Functions for applying many-qubit rotations around Pauli Z axis, and phase flips and shifts. More...

Functions
void	applyControlledPhaseGadget (Qureg qureg, int control, int *targets, int numTargets, qreal angle)

void	applyControlledPhaseGadget (Qureg qureg, int control, std::vector< int > targets, qreal angle)

void	applyMultiControlledPhaseGadget (Qureg qureg, int controls, int numControls, int targets, int numTargets, qreal angle)

void	applyMultiControlledPhaseGadget (Qureg qureg, std::vector< int > controls, std::vector< int > targets, qreal angle)

void	applyMultiQubitPhaseFlip (Qureg qureg, int *targets, int numTargets)

void	applyMultiQubitPhaseFlip (Qureg qureg, std::vector< int > targets)

void	applyMultiQubitPhaseShift (Qureg qureg, int *targets, int numTargets, qreal angle)

void	applyMultiQubitPhaseShift (Qureg qureg, std::vector< int > targets, qreal angle)

void	applyMultiStateControlledPhaseGadget (Qureg qureg, int controls, int states, int numControls, int *targets, int numTargets, qreal angle)

void	applyMultiStateControlledPhaseGadget (Qureg qureg, std::vector< int > controls, std::vector< int > states, std::vector< int > targets, qreal angle)

void	applyPhaseFlip (Qureg qureg, int target)

void	applyPhaseGadget (Qureg qureg, int *targets, int numTargets, qreal angle)

void	applyPhaseGadget (Qureg qureg, std::vector< int > targets, qreal angle)

void	applyPhaseShift (Qureg qureg, int target, qreal angle)

void	applyTwoQubitPhaseFlip (Qureg qureg, int target1, int target2)

void	applyTwoQubitPhaseShift (Qureg qureg, int target1, int target2, qreal angle)

void	multiplyPhaseGadget (Qureg qureg, int *targets, int numTargets, qreal angle)

void	multiplyPhaseGadget (Qureg qureg, std::vector< int > targets, qreal angle)

Detailed Description

Functions for applying many-qubit rotations around Pauli Z axis, and phase flips and shifts.

Function Documentation

◆ applyControlledPhaseGadget() [1/2]

void applyControlledPhaseGadget	(	Qureg	qureg,
		int	control,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note: Documentation for this function or struct is under construction!

Definition at line 1500 of file operations.cpp.

                                                                                                     {
    validate_quregFields(qureg, __func__);
    validate_controlAndTargets(qureg, control, targets, numTargets, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledPhaseGadget(qureg, &control, nullptr, 1, targets, numTargets, angle);
}

Referenced by applyControlledPhaseGadget().

◆ applyControlledPhaseGadget() [2/2]

void applyControlledPhaseGadget	(	Qureg	qureg,
		int	control,
		std::vector< int >	targets,
		qreal	angle )

Warning: This function has not yet been unit tested and may contain bugs. Please use with caution!

Attention: This function's input validation has not yet been unit tested, so erroneous usage may produce unexpected output. Please use with caution!

Note: Documentation for this function or struct is under construction!

Remarks: This function is only available in C++.

Definition at line 1548 of file operations.cpp.

                                                                                            {
 
    applyControlledPhaseGadget(qureg, control, targets.data(), targets.size(), angle);
}

◆ applyMultiControlledPhaseGadget() [1/2]

void applyMultiControlledPhaseGadget	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note: Documentation for this function or struct is under construction!

Definition at line 1508 of file operations.cpp.

                                                                                                                             {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTargets(qureg, controls, numControls, targets, numTargets, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledPhaseGadget(qureg, controls, nullptr, numControls, targets, numTargets, angle);
}

Referenced by applyMultiControlledPhaseGadget().

◆ applyMultiControlledPhaseGadget() [2/2]

void applyMultiControlledPhaseGadget	(	Qureg	qureg,
		std::vector< int >	controls,
		std::vector< int >	targets,
		qreal	angle )

Warning: This function has not yet been unit tested and may contain bugs. Please use with caution!

Attention: This function's input validation has not yet been unit tested, so erroneous usage may produce unexpected output. Please use with caution!

Note: Documentation for this function or struct is under construction!

Remarks: This function is only available in C++.

Definition at line 1553 of file operations.cpp.

                                                                                                          {
 
    applyMultiControlledPhaseGadget(qureg, controls.data(), controls.size(), targets.data(), targets.size(), angle);
}

◆ applyMultiQubitPhaseFlip() [1/2]

void applyMultiQubitPhaseFlip	(	Qureg	qureg,
		int *	targets,
		int	numTargets )

Note: Documentation for this function or struct is under construction!

Definition at line 1632 of file operations.cpp.

                                                                         {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    // treat as a (numTargets-1)-controlled 1-target Pauli Z
    DiagMatr1 matr = getDiagMatr1({1, -1});
 
    // harmlessly re-validates
    applyMultiStateControlledDiagMatr1(qureg, &targets[1], nullptr, numTargets-1, targets[0], matr);
}

Referenced by applyMultiQubitPhaseFlip(), applyPhaseFlip(), and applyTwoQubitPhaseFlip().

◆ applyMultiQubitPhaseFlip() [2/2]

void applyMultiQubitPhaseFlip	(	Qureg	qureg,
		std::vector< int >	targets )

Warning: This function has not yet been unit tested and may contain bugs. Please use with caution!

Attention: This function's input validation has not yet been unit tested, so erroneous usage may produce unexpected output. Please use with caution!

Note: Documentation for this function or struct is under construction!

Remarks: This function is only available in C++.

Definition at line 1645 of file operations.cpp.

                                                                {
 
    applyMultiQubitPhaseFlip(qureg, targets.data(), targets.size());
}

◆ applyMultiQubitPhaseShift() [1/2]

void applyMultiQubitPhaseShift	(	Qureg	qureg,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note: Documentation for this function or struct is under construction!

Definition at line 1589 of file operations.cpp.

                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    // treat as a (numTargets-1)-controlled 1-target diagonal matrix
    DiagMatr1 matr = getDiagMatr1({1, std::exp(1_i * angle)});
 
    // harmlessly re-validates
    applyMultiStateControlledDiagMatr1(qureg, &targets[1], nullptr, numTargets-1, targets[0], matr);
}

Referenced by applyMultiQubitPhaseShift(), applyPhaseShift(), and applyTwoQubitPhaseShift().

◆ applyMultiQubitPhaseShift() [2/2]

void applyMultiQubitPhaseShift	(	Qureg	qureg,
		std::vector< int >	targets,
		qreal	angle )

Warning: This function has not yet been unit tested and may contain bugs. Please use with caution!

Attention: This function's input validation has not yet been unit tested, so erroneous usage may produce unexpected output. Please use with caution!

Note: Documentation for this function or struct is under construction!

Remarks: This function is only available in C++.

Definition at line 1602 of file operations.cpp.

                                                                              {
 
    applyMultiQubitPhaseShift(qureg, targets.data(), targets.size(), angle);
}

◆ applyMultiStateControlledPhaseGadget() [1/2]

void applyMultiStateControlledPhaseGadget	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note: Documentation for this function or struct is under construction!

Definition at line 1516 of file operations.cpp.

                                                                                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTargets(qureg, controls, numControls, targets, numTargets, __func__);
    validate_controlStates(states, numControls, __func__);
 
    qreal phase = util_getPhaseFromGateAngle(angle);
    auto ctrlVec = util_getVector(controls, numControls);
    auto targVec = util_getVector(targets,  numTargets);
    auto stateVec = util_getVector(states,  numControls); // empty if states==nullptr
    localiser_statevec_anyCtrlPhaseGadget(qureg, ctrlVec, stateVec, targVec, phase);
 
    if (!qureg.isDensityMatrix)
        return;
 
    phase *= -1;
    ctrlVec = util_getBraQubits(ctrlVec, qureg);
    targVec = util_getBraQubits(targVec, qureg);
    localiser_statevec_anyCtrlPhaseGadget(qureg, ctrlVec, stateVec, targVec, phase);
}

Referenced by applyControlledPhaseGadget(), applyMultiControlledPhaseGadget(), applyMultiStateControlledPhaseGadget(), and applyPhaseGadget().

◆ applyMultiStateControlledPhaseGadget() [2/2]

void applyMultiStateControlledPhaseGadget	(	Qureg	qureg,
		std::vector< int >	controls,
		std::vector< int >	states,
		std::vector< int >	targets,
		qreal	angle )

Warning: This function has not yet been unit tested and may contain bugs. Please use with caution!

Attention: This function's input validation has not yet been unit tested, so erroneous usage may produce unexpected output. Please use with caution!

Note: Documentation for this function or struct is under construction!

Remarks: This function is only available in C++.

Definition at line 1558 of file operations.cpp.

                                                                                                                                   {
    validate_controlsMatchStates(controls.size(), states.size(), __func__);
 
    applyMultiStateControlledPhaseGadget(qureg, controls.data(), states.data(), controls.size(), targets.data(), targets.size(), angle);
}

◆ applyPhaseFlip()

void applyPhaseFlip	(	Qureg	qureg,
		int	target )

Note: Documentation for this function or struct is under construction!

Definition at line 1615 of file operations.cpp.

                                             {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiQubitPhaseFlip(qureg, &target, 1);
}

◆ applyPhaseGadget() [1/2]

void applyPhaseGadget	(	Qureg	qureg,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note: Documentation for this function or struct is under construction!

Definition at line 1492 of file operations.cpp.

                                                                              {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledPhaseGadget(qureg, nullptr, nullptr, 0, targets, numTargets, angle);
}

Referenced by applyPhaseGadget().

◆ applyPhaseGadget() [2/2]

void applyPhaseGadget	(	Qureg	qureg,
		std::vector< int >	targets,
		qreal	angle )

Warning: This function has not yet been unit tested and may contain bugs. Please use with caution!

Attention: This function's input validation has not yet been unit tested, so erroneous usage may produce unexpected output. Please use with caution!

Note: Documentation for this function or struct is under construction!

Remarks: This function is only available in C++.

Definition at line 1543 of file operations.cpp.

                                                                     {
 
    applyPhaseGadget(qureg, targets.data(), targets.size(), angle);
}

◆ applyPhaseShift()

void applyPhaseShift	(	Qureg	qureg,
		int	target,
		qreal	angle )

Note: Documentation for this function or struct is under construction!

Definition at line 1572 of file operations.cpp.

                                                           {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiQubitPhaseShift(qureg, &target, 1, angle);
}

◆ applyTwoQubitPhaseFlip()

void applyTwoQubitPhaseFlip	(	Qureg	qureg,
		int	target1,
		int	target2 )

Applies a two-qubit phase flip upon qubit1 and qubit2 of qureg.

Diagram: This browser is not able to show SVG: try Firefox, Chrome, Safari, or Opera instead.

Note: Documentation for this function or struct is under construction!

Definition at line 1623 of file operations.cpp.

                                                                   {
    validate_quregFields(qureg, __func__);
    validate_twoTargets(qureg, target1, target2, __func__);
 
    // harmlessly re-validates
    int targets[] = {target1, target2};
    applyMultiQubitPhaseFlip(qureg, targets, 2);
}

◆ applyTwoQubitPhaseShift()

void applyTwoQubitPhaseShift	(	Qureg	qureg,
		int	target1,
		int	target2,
		qreal	angle )

Applies a two-qubit phase flip upon qubit1 and qubit2 of qureg.

Diagram: This browser is not able to show SVG: try Firefox, Chrome, Safari, or Opera instead.

Note: Documentation for this function or struct is under construction!

Definition at line 1580 of file operations.cpp.

                                                                                 {
    validate_quregFields(qureg, __func__);
    validate_twoTargets(qureg, target1, target2, __func__);
 
    // harmlessly re-validates
    int targets[] = {target1, target2};
    applyMultiQubitPhaseShift(qureg, targets, 2, angle);
}

Referenced by applyQuantumFourierTransform().

◆ multiplyPhaseGadget() [1/2]

void multiplyPhaseGadget	(	Qureg	qureg,
		int *	targets,
		int	numTargets,
		qreal	angle )

Note: Documentation for this function or struct is under construction!

Definition at line 1484 of file operations.cpp.

                                                                                 {
    validate_quregFields(qureg, __func__);
    validate_targets(qureg, targets, numTargets, __func__);
 
    qreal phase = util_getPhaseFromGateAngle(angle);
    localiser_statevec_anyCtrlPhaseGadget(qureg, {}, {}, util_getVector(targets,numTargets), phase);
}

Referenced by multiplyPhaseGadget().

◆ multiplyPhaseGadget() [2/2]

void multiplyPhaseGadget	(	Qureg	qureg,
		std::vector< int >	targets,
		qreal	angle )

Warning: This function has not yet been unit tested and may contain bugs. Please use with caution!

Attention: This function's input validation has not yet been unit tested, so erroneous usage may produce unexpected output. Please use with caution!

Note: Documentation for this function or struct is under construction!

Remarks: This function is only available in C++.

Definition at line 1538 of file operations.cpp.

                                                                        {
 
    multiplyPhaseGadget(qureg, targets.data(), targets.size(), angle);
}