Rotations

Functions for applying one-qubit rotations around Pauli and arbitrary axis. More...

Functions
void	applyControlledRotateAroundAxis (Qureg qureg, int ctrl, int targ, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyControlledRotateX (Qureg qureg, int control, int target, qreal angle)
void	applyControlledRotateY (Qureg qureg, int control, int target, qreal angle)
void	applyControlledRotateZ (Qureg qureg, int control, int target, qreal angle)
void	applyMultiControlledRotateAroundAxis (Qureg qureg, int *ctrls, int numCtrls, int targ, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyMultiControlledRotateAroundAxis (Qureg qureg, std::vector< int > ctrls, int targ, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyMultiControlledRotateX (Qureg qureg, int *controls, int numControls, int target, qreal angle)
void	applyMultiControlledRotateX (Qureg qureg, std::vector< int > controls, int target, qreal angle)
void	applyMultiControlledRotateY (Qureg qureg, int *controls, int numControls, int target, qreal angle)
void	applyMultiControlledRotateY (Qureg qureg, std::vector< int > controls, int target, qreal angle)
void	applyMultiControlledRotateZ (Qureg qureg, int *controls, int numControls, int target, qreal angle)
void	applyMultiControlledRotateZ (Qureg qureg, std::vector< int > controls, int target, qreal angle)
void	applyMultiStateControlledRotateAroundAxis (Qureg qureg, int *ctrls, int *states, int numCtrls, int targ, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyMultiStateControlledRotateAroundAxis (Qureg qureg, std::vector< int > ctrls, std::vector< int > states, int targ, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyMultiStateControlledRotateX (Qureg qureg, int *controls, int *states, int numControls, int target, qreal angle)
void	applyMultiStateControlledRotateX (Qureg qureg, std::vector< int > controls, std::vector< int > states, int target, qreal angle)
void	applyMultiStateControlledRotateY (Qureg qureg, int *controls, int *states, int numControls, int target, qreal angle)
void	applyMultiStateControlledRotateY (Qureg qureg, std::vector< int > controls, std::vector< int > states, int target, qreal angle)
void	applyMultiStateControlledRotateZ (Qureg qureg, int *controls, int *states, int numControls, int target, qreal angle)
void	applyMultiStateControlledRotateZ (Qureg qureg, std::vector< int > controls, std::vector< int > states, int target, qreal angle)
void	applyRotateAroundAxis (Qureg qureg, int targ, qreal angle, qreal axisX, qreal axisY, qreal axisZ)
void	applyRotateX (Qureg qureg, int target, qreal angle)
void	applyRotateY (Qureg qureg, int target, qreal angle)
void	applyRotateZ (Qureg qureg, int target, qreal angle)

Detailed Description

Functions for applying one-qubit rotations around Pauli and arbitrary axis.

Function Documentation

applyControlledRotateAroundAxis()

void applyControlledRotateAroundAxis	(	Qureg	qureg,
		int	ctrl,
		int	targ,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

Note

Documentation for this function or struct is under construction!

Definition at line 1349 of file operations.cpp.

                                                                                                                          {
    validate_quregFields(qureg, __func__);
    validate_controlAndTarget(qureg, ctrl, targ, __func__);
    validate_rotationAxisNotZeroVector(axisX, axisY, axisZ, __func__);
 
    applyMultiStateControlledRotateAroundAxis(qureg, &ctrl, nullptr, 1, targ, angle, axisX, axisY, axisZ);
}

applyControlledRotateX()

void applyControlledRotateX	(	Qureg	qureg,
		int	control,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1223 of file operations.cpp.

                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlAndTarget(qureg, control, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateX(qureg, &control, nullptr, 1, target, angle);
}

applyControlledRotateY()

void applyControlledRotateY	(	Qureg	qureg,
		int	control,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1231 of file operations.cpp.

                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlAndTarget(qureg, control, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateY(qureg, &control, nullptr, 1, target, angle);
}

applyControlledRotateZ()

void applyControlledRotateZ	(	Qureg	qureg,
		int	control,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1239 of file operations.cpp.

                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlAndTarget(qureg, control, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateZ(qureg, &control, nullptr, 1, target, angle);
}

applyMultiControlledRotateAroundAxis() [1/2]

void applyMultiControlledRotateAroundAxis	(	Qureg	qureg,
		int *	ctrls,
		int	numCtrls,
		int	targ,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

Note

Documentation for this function or struct is under construction!

Definition at line 1357 of file operations.cpp.

                                                                                                                                               {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, ctrls, numCtrls, targ, __func__);
    validate_rotationAxisNotZeroVector(axisX, axisY, axisZ, __func__);
 
    applyMultiStateControlledRotateAroundAxis(qureg, ctrls, nullptr, numCtrls, targ, angle, axisX, axisY, axisZ);
}

Referenced by applyMultiControlledRotateAroundAxis().

applyMultiControlledRotateAroundAxis() [2/2]

void applyMultiControlledRotateAroundAxis	(	Qureg	qureg,
		std::vector< int >	ctrls,
		int	targ,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

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 1389 of file operations.cpp.

                                                                                                                                        {
 
    applyMultiControlledRotateAroundAxis(qureg, ctrls.data(), ctrls.size(), targ, angle, axisX, axisY, axisZ);
}

applyMultiControlledRotateX() [1/2]

void applyMultiControlledRotateX	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1247 of file operations.cpp.

                                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateX(qureg, controls, nullptr, numControls, target, angle);
}

Referenced by applyMultiControlledRotateX().

applyMultiControlledRotateX() [2/2]

void applyMultiControlledRotateX	(	Qureg	qureg,
		std::vector< int >	controls,
		int	target,
		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 1300 of file operations.cpp.

                                                                                             {
 
    applyMultiControlledRotateX(qureg, controls.data(), controls.size(), target, angle);
}

applyMultiControlledRotateY() [1/2]

void applyMultiControlledRotateY	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1255 of file operations.cpp.

                                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateY(qureg, controls, nullptr, numControls, target, angle);
}

Referenced by applyMultiControlledRotateY().

applyMultiControlledRotateY() [2/2]

void applyMultiControlledRotateY	(	Qureg	qureg,
		std::vector< int >	controls,
		int	target,
		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 1305 of file operations.cpp.

                                                                                             {
 
    applyMultiControlledRotateY(qureg, controls.data(), controls.size(), target, angle);
}

applyMultiControlledRotateZ() [1/2]

void applyMultiControlledRotateZ	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1263 of file operations.cpp.

                                                                                                       {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateZ(qureg, controls, nullptr, numControls, target, angle);
}

Referenced by applyMultiControlledRotateZ().

applyMultiControlledRotateZ() [2/2]

void applyMultiControlledRotateZ	(	Qureg	qureg,
		std::vector< int >	controls,
		int	target,
		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 1310 of file operations.cpp.

                                                                                             {
 
    applyMultiControlledRotateZ(qureg, controls.data(), controls.size(), target, angle);
}

applyMultiStateControlledRotateAroundAxis() [1/2]

void applyMultiStateControlledRotateAroundAxis	(	Qureg	qureg,
		int *	ctrls,
		int *	states,
		int	numCtrls,
		int	targ,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

Note

Documentation for this function or struct is under construction!

Definition at line 1365 of file operations.cpp.

                                                                                                                                                                 {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, ctrls, numCtrls, targ, __func__);
    validate_controlStates(states, numCtrls, __func__); // permits states==nullptr
    validate_rotationAxisNotZeroVector(axisX, axisY, axisZ, __func__);
 
    // defer division of vector norm to improve numerical accuracy
    qreal norm = std::sqrt(std::pow(axisX,2) + std::pow(axisY,2) + std::pow(axisZ,2)); // != 0
 
    // treat as generic 1-qubit matrix
    qreal c = std::cos(angle/2);
    qreal s = std::sin(angle/2);
    qcomp u11 = c - (s * axisZ * 1_i) / norm;
    qcomp u12 =   - (s * (axisY + axisX * 1_i)) / norm;
    qcomp u21 =     (s * (axisY - axisX * 1_i)) / norm;
    qcomp u22 = c + (s * axisZ * 1_i) / norm;
    auto matr = getCompMatr1({{u11,u12},{u21,u22}});
 
    // harmlessly re-validates, and checks unitarity of matr
    applyMultiStateControlledCompMatr1(qureg, ctrls, states, numCtrls, targ, matr);
}

Referenced by applyControlledRotateAroundAxis(), applyMultiControlledRotateAroundAxis(), applyMultiStateControlledRotateAroundAxis(), and applyRotateAroundAxis().

applyMultiStateControlledRotateAroundAxis() [2/2]

void applyMultiStateControlledRotateAroundAxis	(	Qureg	qureg,
		std::vector< int >	ctrls,
		std::vector< int >	states,
		int	targ,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

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 1394 of file operations.cpp.

                                                                                                                                                                 {
    validate_controlsMatchStates(ctrls.size(), states.size(), __func__);
 
    applyMultiStateControlledRotateAroundAxis(qureg, ctrls.data(), states.data(), ctrls.size(), targ, angle, axisX, axisY, axisZ);
}

applyMultiStateControlledRotateX() [1/2]

void applyMultiStateControlledRotateX	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1271 of file operations.cpp.

                                                                                                                         {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // harmlessly re-validates
    applyMultiStateControlledPauliGadget(qureg, controls, states, numControls, getPauliStr("X", {target}), angle);
}

Referenced by applyControlledRotateX(), applyMultiControlledRotateX(), applyMultiStateControlledRotateX(), and applyRotateX().

applyMultiStateControlledRotateX() [2/2]

void applyMultiStateControlledRotateX	(	Qureg	qureg,
		std::vector< int >	controls,
		std::vector< int >	states,
		int	target,
		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 1315 of file operations.cpp.

                                                                                                                      {
    validate_controlsMatchStates(controls.size(), states.size(), __func__);
 
    applyMultiStateControlledRotateX(qureg, controls.data(), states.data(), controls.size(), target, angle);
}

applyMultiStateControlledRotateY() [1/2]

void applyMultiStateControlledRotateY	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1280 of file operations.cpp.

                                                                                                                         {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // harmlessly re-validates
    applyMultiStateControlledPauliGadget(qureg, controls, states, numControls, getPauliStr("Y", {target}), angle);
}

Referenced by applyControlledRotateY(), applyMultiControlledRotateY(), applyMultiStateControlledRotateY(), and applyRotateY().

applyMultiStateControlledRotateY() [2/2]

void applyMultiStateControlledRotateY	(	Qureg	qureg,
		std::vector< int >	controls,
		std::vector< int >	states,
		int	target,
		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 1321 of file operations.cpp.

                                                                                                                      {
    validate_controlsMatchStates(controls.size(), states.size(), __func__);
 
    applyMultiStateControlledRotateY(qureg, controls.data(), states.data(), controls.size(), target, angle);
}

applyMultiStateControlledRotateZ() [1/2]

void applyMultiStateControlledRotateZ	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		int	target,
		qreal	angle )

Note

Documentation for this function or struct is under construction!

Definition at line 1289 of file operations.cpp.

                                                                                                                         {
    validate_quregFields(qureg, __func__);
    validate_controlsAndTarget(qureg, controls, numControls, target, __func__);
    validate_controlStates(states, numControls, __func__); // permits states==nullptr
 
    // harmlessly re-validates
    applyMultiStateControlledPauliGadget(qureg, controls, states, numControls, getPauliStr("Z", {target}), angle);
}

Referenced by applyControlledRotateZ(), applyMultiControlledRotateZ(), applyMultiStateControlledRotateZ(), and applyRotateZ().

applyMultiStateControlledRotateZ() [2/2]

void applyMultiStateControlledRotateZ	(	Qureg	qureg,
		std::vector< int >	controls,
		std::vector< int >	states,
		int	target,
		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 1327 of file operations.cpp.

                                                                                                                      {
    validate_controlsMatchStates(controls.size(), states.size(), __func__);
 
    applyMultiStateControlledRotateZ(qureg, controls.data(), states.data(), controls.size(), target, angle);
}

applyRotateAroundAxis()

void applyRotateAroundAxis	(	Qureg	qureg,
		int	targ,
		qreal	angle,
		qreal	axisX,
		qreal	axisY,
		qreal	axisZ )

Note

Documentation for this function or struct is under construction!

Definition at line 1341 of file operations.cpp.

                                                                                                      {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, targ, __func__);
    validate_rotationAxisNotZeroVector(axisX, axisY, axisZ, __func__);
 
    applyMultiStateControlledRotateAroundAxis(qureg, nullptr, nullptr, 0, targ, angle, axisX, axisY, axisZ);
}

applyRotateX()

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

Note

Documentation for this function or struct is under construction!

Definition at line 1199 of file operations.cpp.

                                                        {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateX(qureg, nullptr, nullptr, 0, target, angle);
}

applyRotateY()

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

Note

Documentation for this function or struct is under construction!

Definition at line 1207 of file operations.cpp.

                                                        {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateY(qureg, nullptr, nullptr, 0, target, angle);
}

applyRotateZ()

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

Note

Documentation for this function or struct is under construction!

Definition at line 1215 of file operations.cpp.

                                                        {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
 
    // harmlessly re-validates
    applyMultiStateControlledRotateZ(qureg, nullptr, nullptr, 0, target, angle);
}