/usr/include/m4ri/mzp.h is in libm4ri-dev 20140914-2+b1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 | /**
* \file mzp.h
*
* \brief Permutation matrices.
*
* \author Martin Albrecht <M.R.Albrecht@rhul.ac.uk>
*
*/
/******************************************************************************
*
* M4RI: Linear Algebra over GF(2)
*
* Copyright (C) 2008 Martin Albrecht <malb@informatik.uni-bremen.de>
*
* Distributed under the terms of the GNU General Public License (GPL)
* version 2 or higher.
*
* This code is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* The full text of the GPL is available at:
*
* http://www.gnu.org/licenses/
******************************************************************************/
#ifndef M4RI_MZP
#define M4RI_MZP
#include <m4ri/mzd.h>
/**
* \brief Permutations.
*/
typedef struct mzp_t {
/**
* The swap operations in LAPACK format.
*/
rci_t *values;
/**
* The length of the swap array.
*/
rci_t length;
} mzp_t; // note that this is NOT mpz_t
/**
* Construct an identity permutation.
*
* \param length Length of the permutation.
*/
mzp_t *mzp_init(rci_t length);
/**
* Free a mzp_t.
*
* \param P Permutation to free.
*/
void mzp_free(mzp_t *P);
/**
* \brief Create a window/view into the permutation P.
*
* Use mzp_free_mzp_t_window() to free the window.
*
* \param P Permutation matrix
* \param begin Starting index (inclusive)
* \param end Ending index (exclusive)
*
*/
mzp_t *mzp_init_window(mzp_t *P, rci_t begin, rci_t end);
/**
* \brief Free a permutation window created with
* mzp_init_mzp_t_window().
*
* \param condemned Permutation Matrix
*/
void mzp_free_window(mzp_t *condemned);
/**
* \brief copy permutation Q to P
*
* \param P Target permutation matrix (may be NULL)
* \param Q Source permutation matrix (must not be NULL)
*/
mzp_t *mzp_copy(mzp_t *P, const mzp_t *Q);
/**
* \brief Set the permutation P to the identity permutation. The only
* allowed value is 1.
*
*
* \param P Permutation
* \param value 1
*
* \note This interface was chosen to be similar to mzd_set_ui().
*/
void mzp_set_ui(mzp_t *P, unsigned int value);
/**
* Apply the permutation P to A from the left.
*
* This is equivalent to row swaps walking from 0 to length-1.
*
* \param A Matrix.
* \param P Permutation.
*/
void mzd_apply_p_left(mzd_t *A, mzp_t const *P);
/**
* Apply the permutation P to A from the left but transpose P before.
*
* This is equivalent to row swaps walking from length-1 to 0.
*
* \param A Matrix.
* \param P Permutation.
*/
void mzd_apply_p_left_trans(mzd_t *A, mzp_t const *P);
/**
* Apply the permutation P to A from the right.
*
* This is equivalent to column swaps walking from length-1 to 0.
*
* \param A Matrix.
* \param P Permutation.
*/
void mzd_apply_p_right(mzd_t *A, mzp_t const *P);
/**
* Apply the permutation P to A from the right but transpose P before.
*
* This is equivalent to column swaps walking from 0 to length-1.
*
* \param A Matrix.
* \param P Permutation.
*/
void mzd_apply_p_right_trans(mzd_t *A, mzp_t const *P);
/**
* Apply the permutation P to A from the right starting at start_row.
*
* This is equivalent to column swaps walking from length-1 to 0.
*
* \param A Matrix.
* \param P Permutation.
* \param start_row Start swapping at this row.
* \param start_col Start swapping at this column.
*/
void mzd_apply_p_right_even_capped(mzd_t *A, mzp_t const *P, rci_t start_row, rci_t start_col);
/**
* Apply the permutation P^T to A from the right starting at start_row.
*
* This is equivalent to column swaps walking from 0 to length-1.
*
* \param A Matrix.
* \param P Permutation.
* \param start_row Start swapping at this row.
* \param start_col Start swapping at this column.
*/
void mzd_apply_p_right_trans_even_capped(mzd_t *A, mzp_t const *P, rci_t start_row, rci_t start_col);
/**
* Apply the mzp_t P to A from the right but transpose P before.
*
* This is equivalent to column swaps walking from 0 to length-1.
*
* \param A Matrix.
* \param P Permutation.
*/
void mzd_apply_p_right_trans(mzd_t *A, mzp_t const *P);
/**
* Apply the permutation P to A from the right, but only on the upper
* the matrix A above the main diagonal.
*
* This is equivalent to column swaps walking from length-1 to 0.
*
* \param A Matrix.
* \param Q Permutation.
*/
void mzd_apply_p_right_trans_tri(mzd_t *A, mzp_t const *Q);
/**
* Print the mzp_t P
*
* \param P Permutation.
*/
void mzp_print(mzp_t const *P);
/**
* Compresses the matrix L in a step in blockwise-recursive PLE
* decomposition.
*
* \param A Matrix.
* \param r1 Rank of left matrix.
* \param n1 Column cut which separates left and right matrix.
* \param r2 Rank of right matrix.
*/
void _mzd_compress_l(mzd_t *A, rci_t r1, rci_t n1, rci_t r2);
#endif // M4RI_MZP
|