Funciones de ordenación
qf_ferm_op_canonical_order
QfFermionOperator *qf_ferm_op_canonical_order(const QfFermionOperator *op)
Devuelve una copia de un operador fermiónico con sus términos en orden canónico.
Los términos se ordenan según un orden canónico que depende únicamente de la estructura de cada término (la cadena de operadores que representa) y no de su coeficiente. Por lo tanto, el orden es determinista para un conjunto dado de términos, independientemente de cómo se haya construido el operador. Los términos en sí no se modifican: esto solo cambia su orden, no simplifica ni pone en orden normal el operador.
1QfFermionOperator *op = qf_ferm_op_zero();
2bool actions[2] = {true, false};
3uint32_t modes_a[2] = {1, 0};
4QkComplex64 coeff_a = {1.0, 0.0};
5qf_ferm_op_add_term(op, 2, actions, modes_a, &coeff_a);
6uint32_t modes_b[2] = {0, 1};
7QkComplex64 coeff_b = {2.0, 0.0};
8qf_ferm_op_add_term(op, 2, actions, modes_b, &coeff_b);
9
10QfFermionOperator *ordered = qf_ferm_op_canonical_order(op);Se conservan los índices de grupo (véase qf_ferm_op_get_groups()): cada término lleva consigo su índice de grupo al desplazarse, ya que un índice de grupo es una etiqueta propia de cada término, independiente del orden de los términos. A partir de ese momento, los términos del mismo grupo ya no son contiguos. Si la entrada no tiene grupos, el resultado tampoco los tiene.
Parámetros
- op : un puntero al operador cuyos términos se van a reordenar.
Devuelve
Un puntero al operador creado.
qf_maj_op_canonical_order
QfMajoranaOperator *qf_maj_op_canonical_order(const QfMajoranaOperator *op)
Devuelve una copia de un operador de Majorana con sus términos en orden canónico.
Los términos se ordenan según un orden canónico que depende únicamente de la estructura de cada término (la cadena de operadores que representa) y no de su coeficiente. Por lo tanto, el orden es determinista para un conjunto dado de términos, independientemente de cómo se haya construido el operador. Los términos en sí no se modifican: esto solo cambia su orden, no simplifica ni pone en orden normal el operador.
1QfMajoranaOperator *op = qf_maj_op_zero();
2uint32_t modes_a[2] = {1, 0};
3QkComplex64 coeff_a = {1.0, 0.0};
4qf_maj_op_add_term(op, 2, modes_a, &coeff_a);
5uint32_t modes_b[2] = {0, 1};
6QkComplex64 coeff_b = {2.0, 0.0};
7qf_maj_op_add_term(op, 2, modes_b, &coeff_b);
8
9QfMajoranaOperator *ordered = qf_maj_op_canonical_order(op);Se conservan los índices de grupo (véase qf_maj_op_get_groups()): cada término lleva consigo su índice de grupo al desplazarse, ya que un índice de grupo es una etiqueta propia de cada término, independiente del orden de los términos. A partir de ese momento, los términos del mismo grupo ya no son contiguos. Si la entrada no tiene grupos, el resultado tampoco los tiene.
Parámetros
- op : un puntero al operador cuyos términos se van a reordenar.
Devuelve
Un puntero al operador creado.
qf_edge_op_canonical_order
QfEdgeVertexOperator *qf_edge_op_canonical_order(const QfEdgeVertexOperator *op)
Devuelve una copia de un operador de arista-vértice con sus términos en orden canónico.
Los términos se ordenan según un orden canónico que depende únicamente de la estructura de cada término (la cadena de operadores que representa) y no de su coeficiente. Por lo tanto, el orden es determinista para un conjunto dado de términos, independientemente de cómo se haya construido el operador. Los términos en sí no se modifican: esto solo cambia su orden, no simplifica ni pone en orden normal el operador.
1QfEdgeVertexOperator *op = qf_edge_op_zero();
2uint32_t left_a[1] = {1};
3uint32_t right_a[1] = {2};
4QkComplex64 coeff_a = {1.0, 0.0};
5qf_edge_op_add_term(op, 1, left_a, right_a, &coeff_a);
6uint32_t left_b[1] = {0};
7uint32_t right_b[1] = {1};
8QkComplex64 coeff_b = {2.0, 0.0};
9qf_edge_op_add_term(op, 1, left_b, right_b, &coeff_b);
10
11QfEdgeVertexOperator *ordered = qf_edge_op_canonical_order(op);Se conservan los índices de grupo (véase qf_edge_op_get_groups()): cada término lleva consigo su índice de grupo al desplazarse, ya que un índice de grupo es una etiqueta propia de cada término, independiente del orden de los mismos. A partir de ese momento, los términos del mismo grupo ya no son contiguos. Si la entrada no tiene grupos, el resultado tampoco los tiene.
Parámetros
- op : un puntero al operador cuyos términos se van a reordenar.
Devuelve
Un puntero al operador creado.
qf_transfer_op_canonical_order
QfTransferVertexOperator *qf_transfer_op_canonical_order(const QfTransferVertexOperator *op)
Devuelve una copia de un operador de transferencia de vértices con sus términos en orden canónico.
Los términos se ordenan según un orden canónico que depende únicamente de la estructura de cada término (la cadena de operadores que representa) y no de su coeficiente. Por lo tanto, el orden es determinista para un conjunto dado de términos, independientemente de cómo se haya construido el operador. Los términos en sí no se modifican: esto solo cambia su orden, no simplifica ni pone en orden normal el operador.
1QfTransferVertexOperator *op = qf_transfer_op_zero();
2uint32_t left_a[1] = {1};
3uint32_t right_a[1] = {2};
4QkComplex64 coeff_a = {1.0, 0.0};
5qf_transfer_op_add_term(op, 1, left_a, right_a, &coeff_a);
6uint32_t left_b[1] = {0};
7uint32_t right_b[1] = {1};
8QkComplex64 coeff_b = {2.0, 0.0};
9qf_transfer_op_add_term(op, 1, left_b, right_b, &coeff_b);
10
11QfTransferVertexOperator *ordered = qf_transfer_op_canonical_order(op);Se conservan los índices de grupo (véase qf_transfer_op_get_groups()): cada término lleva consigo su índice de grupo al desplazarse, ya que un índice de grupo es una etiqueta propia de cada término, independiente del orden de los mismos. A partir de ese momento, los términos del mismo grupo ya no son contiguos. Si la entrada no tiene grupos, el resultado tampoco los tiene.
Parámetros
- op : un puntero al operador cuyos términos se van a reordenar.
Devuelve
Un puntero al operador creado.
qf_ferm_op_group_order
QfFermionOperator *qf_ferm_op_group_order(const QfFermionOperator *op)
Devuelve una copia de un operador fermiónico con sus términos ordenados por índice de grupo.
Los términos se ordenan únicamente por su índice de grupo, lo que hace que cada grupo sea una secuencia contigua de términos y que los índices de grupo sean no decrecientes. La ordenación es estable, por lo que los términos de un mismo grupo mantienen su orden relativo. Los términos en sí no se modifican: esto solo cambia su orden, pero no simplifica ni pone el operador en orden normal.
Los índices de grupo solo indican qué términos van juntos, por lo que esto modifica la disposición del operador, pero no su valor. Lo que se gana con esta estructura es en el coste de la búsqueda: por lo general, qf_ferm_op_split_out_groups() hay que recorrer todos los términos para encontrar los grupos solicitados, pero en un operador ordenado por grupos, los términos de cada grupo forman un intervalo que se puede localizar mediante búsqueda binaria, por lo que una búsqueda cuesta lo que cuestan los grupos solicitados, en lugar de lo que cuestan los términos almacenados.
1QfFermionOperator *op = qf_ferm_op_zero();
2bool actions[2] = {true, false};
3uint32_t modes_a[2] = {0, 1};
4QkComplex64 coeff_a = {1.0, 0.0};
5qf_ferm_op_add_term(op, 2, actions, modes_a, &coeff_a);
6uint32_t modes_b[2] = {1, 0};
7QkComplex64 coeff_b = {2.0, 0.0};
8qf_ferm_op_add_term(op, 2, actions, modes_b, &coeff_b);
9uint32_t groups[2] = {1, 0};
10qf_ferm_op_set_groups(op, groups, 2);
11
12QfFermionOperator *ordered = qf_ferm_op_group_order(op);Un operador que no tenga índices de grupo (véase qf_ferm_op_get_groups()) no tiene ningún criterio de ordenación y se devuelve como una copia sin modificar. El resultado tampoco incluye a ningún grupo.
Parámetros
- op : un puntero al operador cuyos términos se van a reordenar.
Devuelve
Un puntero al operador creado.
qf_maj_op_group_order
QfMajoranaOperator *qf_maj_op_group_order(const QfMajoranaOperator *op)
Devuelve una copia de un operador de Majorana con sus términos ordenados por índice de grupo.
Los términos se ordenan únicamente por su índice de grupo, lo que hace que cada grupo sea una secuencia contigua de términos y que los índices de grupo sean no decrecientes. La ordenación es estable, por lo que los términos de un mismo grupo mantienen su orden relativo. Los términos en sí no se modifican: esto solo cambia su orden, pero no simplifica ni pone el operador en orden normal.
Los índices de grupo solo indican qué términos van juntos, por lo que esto modifica la disposición del operador, pero no su valor. Lo que se gana con esta estructura es en el coste de la búsqueda: por lo general, qf_maj_op_split_out_groups() hay que recorrer todos los términos para encontrar los grupos solicitados, pero en un operador ordenado por grupos, los términos de cada grupo forman un intervalo que se puede localizar mediante búsqueda binaria, por lo que una búsqueda cuesta lo que cuestan los grupos solicitados, en lugar de lo que cuestan los términos almacenados.
1QfMajoranaOperator *op = qf_maj_op_zero();
2uint32_t modes_a[2] = {0, 1};
3QkComplex64 coeff_a = {1.0, 0.0};
4qf_maj_op_add_term(op, 2, modes_a, &coeff_a);
5uint32_t modes_b[2] = {2, 3};
6QkComplex64 coeff_b = {2.0, 0.0};
7qf_maj_op_add_term(op, 2, modes_b, &coeff_b);
8uint32_t groups[2] = {1, 0};
9qf_maj_op_set_groups(op, groups, 2);
10
11QfMajoranaOperator *ordered = qf_maj_op_group_order(op);Un operador que no tenga índices de grupo (véase qf_maj_op_get_groups()) no tiene ningún criterio de ordenación y se devuelve como una copia sin modificar. El resultado tampoco incluye a ningún grupo.
Parámetros
- op : un puntero al operador cuyos términos se van a reordenar.
Devuelve
Un puntero al operador creado.
qf_edge_op_group_order
QfEdgeVertexOperator *qf_edge_op_group_order(const QfEdgeVertexOperator *op)
Devuelve una copia de un operador de arista-vértice con sus términos ordenados por índice de grupo.
Los términos se ordenan únicamente por su índice de grupo, lo que hace que cada grupo sea una secuencia contigua de términos y que los índices de grupo sean no decrecientes. La ordenación es estable, por lo que los términos de un mismo grupo mantienen su orden relativo. Los términos en sí no se modifican: esto solo cambia su orden, pero no simplifica ni pone el operador en orden normal.
Los índices de grupo solo indican qué términos van juntos, por lo que esto modifica la disposición del operador, pero no su valor. Lo que se gana con esta estructura es en el coste de la búsqueda: por lo general, qf_edge_op_split_out_groups() hay que recorrer todos los términos para encontrar los grupos solicitados, pero en un operador ordenado por grupos, los términos de cada grupo forman un intervalo que se puede localizar mediante búsqueda binaria, por lo que una búsqueda cuesta lo que cuestan los grupos solicitados, en lugar de lo que cuestan los términos almacenados.
1QfEdgeVertexOperator *op = qf_edge_op_zero();
2uint32_t left_a[1] = {0};
3uint32_t right_a[1] = {1};
4QkComplex64 coeff_a = {1.0, 0.0};
5qf_edge_op_add_term(op, 1, left_a, right_a, &coeff_a);
6uint32_t left_b[1] = {1};
7uint32_t right_b[1] = {2};
8QkComplex64 coeff_b = {2.0, 0.0};
9qf_edge_op_add_term(op, 1, left_b, right_b, &coeff_b);
10uint32_t groups[2] = {1, 0};
11qf_edge_op_set_groups(op, groups, 2);
12
13QfEdgeVertexOperator *ordered = qf_edge_op_group_order(op);Un operador que no tenga índices de grupo (véase qf_edge_op_get_groups()) no tiene ningún criterio de ordenación y se devuelve como una copia sin modificar. El resultado tampoco incluye a ningún grupo.
Parámetros
- op : un puntero al operador cuyos términos se van a reordenar.
Devuelve
Un puntero al operador creado.
qf_transfer_op_group_order
QfTransferVertexOperator *qf_transfer_op_group_order(const QfTransferVertexOperator *op)
Devuelve una copia de un operador de transferencia de vértices cuyos términos están ordenados por índice de grupo.
Los términos se ordenan únicamente por su índice de grupo, lo que hace que cada grupo sea una secuencia contigua de términos y que los índices de grupo sean no decrecientes. La ordenación es estable, por lo que los términos de un mismo grupo mantienen su orden relativo. Los términos en sí no se modifican: esto solo cambia su orden, pero no simplifica ni pone el operador en orden normal.
Los índices de grupo solo indican qué términos van juntos, por lo que esto modifica la disposición del operador, pero no su valor. Lo que se gana con esta estructura es en el coste de la búsqueda: por lo general, qf_transfer_op_split_out_groups() hay que recorrer todos los términos para encontrar los grupos solicitados, pero en un operador ordenado por grupos, los términos de cada grupo forman un intervalo que se puede localizar mediante búsqueda binaria, por lo que una búsqueda cuesta lo que cuestan los grupos solicitados, en lugar de lo que cuestan los términos almacenados.
1QfTransferVertexOperator *op = qf_transfer_op_zero();
2uint32_t left_a[1] = {0};
3uint32_t right_a[1] = {1};
4QkComplex64 coeff_a = {1.0, 0.0};
5qf_transfer_op_add_term(op, 1, left_a, right_a, &coeff_a);
6uint32_t left_b[1] = {1};
7uint32_t right_b[1] = {2};
8QkComplex64 coeff_b = {2.0, 0.0};
9qf_transfer_op_add_term(op, 1, left_b, right_b, &coeff_b);
10uint32_t groups[2] = {1, 0};
11qf_transfer_op_set_groups(op, groups, 2);
12
13QfTransferVertexOperator *ordered = qf_transfer_op_group_order(op);Un operador que no tenga índices de grupo (véase qf_transfer_op_get_groups()) no tiene ningún criterio de ordenación y se devuelve como una copia sin modificar. El resultado tampoco incluye a ningún grupo.
Parámetros
- op : un puntero al operador cuyos términos se van a reordenar.
Devuelve
Un puntero al operador creado.