passagemath-meataxe 10.6.1rc10__cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl

passagemath_meataxe-10.6.1rc10.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: passagemath-meataxe
+Version: 10.6.1rc10
+Summary: passagemath: Matrices over small finite fields with meataxe
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://doc.sagemath.org
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/x-rst
+Requires-Dist: passagemath-modules==10.6.1rc10
+
+========================================================================================
+ passagemath: Matrices over small finite fields with meataxe
+========================================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork was created in October 2024 with the following
+goals:
+
+-  providing modularized installation with pip, thus completing a `major
+   project started in 2020 in the Sage
+   codebase <https://github.com/sagemath/sage/issues/29705>`__,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  providing `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://doc.sagemath.org/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support all major Linux distributions and recent versions of
+macOS. Use on Windows currently requires the use of Windows Subsystem for Linux or
+virtualization.
+
+Complete sets of binary wheels are provided on PyPI for Python versions 3.10.x-3.13.x.
+Python 3.13.x is also supported, but some third-party packages are still missing wheels,
+so compilation from source is triggered for those.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-meataxe`` is a small
+optional distribution for use with ``passagemath-standard``.
+
+This distribution provides the SageMath modules ``sage.libs.meataxe``
+and ``sage.matrix.matrix_gfpn_dense``.
+
+It provides a specialized implementation of matrices over the finite field F_q, where
+q <= 255, using the `SharedMeatAxe <http://users.minet.uni-jena.de/~king/SharedMeatAxe/>`
+library.

passagemath_meataxe-10.6.1rc10.dist-info/RECORD

@@ -0,0 +1,14 @@
+passagemath_meataxe.libs/libmtx-842173ac.so.0.0.0,sha256=B_bzfuHCq4D-n7jIthJRUcq85eEnfU-CivxFXUXEgVA,1053169
+sage/all__sagemath_meataxe.py,sha256=bJKIZgWmLYLh-2IhrpKDQMoVtc2ryVmIVkPfzZk7-og,66
+sage/libs/all__sagemath_meataxe.py,sha256=isUgdlh6SqmFirYA2LvA-IFIJXW-fyhZrXsbt3PifDY,46
+sage/libs/meataxe.cpython-311-aarch64-linux-gnu.so,sha256=vBgkWLh2YHoZh7M88xJ4BOqJlWF1y8VQNrJ-HyB3lqw,526961
+sage/libs/meataxe.pxd,sha256=FqAwBUCWeeJpp4UjeWxWWhRgStywZP8jmCK0tTvxhTs,6643
+sage/libs/meataxe.pyx,sha256=fRhRX3270t1cC1dRab1H2UHeCRTeMi0WjT9521gblmE,3585
+sage/matrix/all__sagemath_meataxe.py,sha256=isUgdlh6SqmFirYA2LvA-IFIJXW-fyhZrXsbt3PifDY,46
+sage/matrix/matrix_gfpn_dense.cpython-311-aarch64-linux-gnu.so,sha256=6jEH7T2Tqk6TymHkwls3wLl-XIx6IiHRagxTnkZaDUU,2233449
+sage/matrix/matrix_gfpn_dense.pxd,sha256=IMkNNnShKEOvkr-5khmC17O0f4c6PiXvmtYc4Ka62rQ,1708
+sage/matrix/matrix_gfpn_dense.pyx,sha256=tLDSzmtPeBc0ZKv5Jw6FmLk3WicuSNd7CVA82EehEyc,71640
+passagemath_meataxe-10.6.1rc10.dist-info/METADATA,sha256=Anebh0lG5ANm4wWR9cO5UGdj_jVGmHDle3MsA4ur2MI,4243
+passagemath_meataxe-10.6.1rc10.dist-info/WHEEL,sha256=nENvFvUt2sTxh7qTwFTbrHft1Jd6WkcTog-2x3-pWGY,193
+passagemath_meataxe-10.6.1rc10.dist-info/top_level.txt,sha256=Kmzulf9WsphADFQuqgvdy5mvTLDj_V2zkFHU2s3UXos,6
+passagemath_meataxe-10.6.1rc10.dist-info/RECORD,,

passagemath_meataxe-10.6.1rc10.dist-info/WHEEL

@@ -0,0 +1,7 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_17_aarch64
+Tag: cp311-cp311-manylinux2014_aarch64
+Tag: cp311-cp311-manylinux_2_28_aarch64
+

passagemath_meataxe-10.6.1rc10.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+
+sage

sage/all__sagemath_meataxe.py

@@ -0,0 +1,2 @@
+# sage_setup: distribution = sagemath-meataxe
+# delvewheel: patch

sage/libs/all__sagemath_meataxe.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-meataxe

sage/libs/meataxe.pxd

@@ -0,0 +1,156 @@
+# sage_setup: distribution = sagemath-meataxe
+
+#*****************************************************************************
+#       Copyright (C) 2015 Simon King <simon.king@uni-jena.de>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+#
+# Import SOME features from meataxe.h
+# (most types are not needed, but listed here
+# in the comments, for completeness)
+#
+cdef extern from "meataxe.h":
+    # general ctype emulations
+    # ctypedef int size_t   # size_t should be a standard type!
+    # ctypedef unsigned long Ulong
+    # ctypedef unsigned short Ushort
+    # ctypedef unsigned char Uchar
+    ctypedef unsigned char FEL
+    ctypedef FEL *PTR
+
+    # global constants
+    cdef extern int FfOrder             # Current field order
+    cdef extern int FfChar              # Current characteristic
+    cdef extern FEL FfGen               # Generator
+    cdef extern int FfNoc               # Number of columns for row ops
+    cdef extern int MPB                 # Number of marks stored in a single byte
+    cdef extern size_t FfCurrentRowSize # The byte size of a single row in memory,
+                                        # always a multiple of sizeof(long)
+    cdef extern size_t FfCurrentRowSizeIo # The number of bytes actually used in a row
+    cdef extern char MtxLibDir[1024]    # Where to search/create multiplication tables
+
+    # we only wrap MeatAxe for small fields (size < 255)
+    cdef extern FEL mtx_tmult[256][256]
+    cdef extern FEL mtx_tadd[256][256]
+    cdef extern FEL mtx_taddinv[256]
+    cdef extern FEL mtx_tmultinv[256]
+    cdef extern FEL mtx_tinsert[8][256]
+    cdef extern FEL mtx_textract[8][256]
+    cdef extern FEL FF_ONE, FF_ZERO
+
+#########################################
+# function prototypes
+    ## global parameters
+    size_t FfRowSize(int noc)
+    size_t FfTrueRowSize(int noc) # Difference to FfRowSize: Doesn't count padding bytes
+    int FfSetField(int field) except -1
+    int FfSetNoc(int ncols) except -1
+
+    ## Finite Fields
+    FEL FfAdd(FEL a, FEL b)
+    FEL FfSub(FEL a, FEL b)
+    FEL FfNeg(FEL a)
+    FEL FfMul(FEL a, FEL b)
+    FEL FfDiv(FEL a, FEL b)
+    FEL FfInv(FEL a)
+    # FEL FfEmbed(FEL a, int subfield) except 255
+    # FEL FfRestrict(FEL a, int subfield) except 255
+    FEL FfFromInt(int l)
+    int FfToInt(FEL f)
+
+    ## Rows
+    void FfMulRow(PTR row, FEL mark)
+    void FfAddMulRow(PTR dest, PTR src, FEL f)
+    void FfAddMulRowPartial(PTR dest, PTR src, FEL f, int first, int len)
+    PTR FfAddRow(PTR dest, PTR src)
+    PTR FfAddRowPartial(PTR dest, PTR src, int first, int len)
+    PTR FfSubRow(PTR dest, PTR src)
+    PTR FfSubRowPartial(PTR dest, PTR src, int first, int len)
+    FEL FfExtract(PTR row, int col)
+    void FfInsert(PTR row, int col, FEL mark)
+    int FfFindPivot(PTR row, FEL *mark)
+    FEL FfScalarProduct(PTR a, PTR b)
+    void FfSwapRows(PTR dest, PTR src)
+    void FfPermRow(PTR row, long *perm, PTR result)
+    int FfCmpRows(PTR p1, PTR p2)
+
+    ## multiple rows
+    PTR FfAlloc(int nor) except NULL
+    void FfExtractColumn(PTR mat,int nor,int col,PTR result)
+    int FfStepPtr(PTR *x)  # Advance to next row
+    PTR FfGetPtr(PTR base, int row)  # Advance to "row" rows after base
+    void FfInsert(PTR row, int col, FEL mark)
+    void FfMapRow(PTR row, PTR matrix, int nor, PTR result)
+
+    ############
+    ## Skip: Application, error handling, i/o
+
+    ############
+    ## Matrices
+    ############
+    ctypedef struct Matrix_t:
+        int Field, Nor, Noc        # Field, #rows, #columns
+        PTR Data                   # Pointer to data area
+        int RowSize                # Size (in bytes) of one row
+        int *PivotTable            # Pivot table (if matrix is in echelon form)
+
+    ## Basic memory operations
+    Matrix_t *MatAlloc(int field, int nor, int noc) except NULL
+    int MatFree(Matrix_t *mat)
+    PTR MatGetPtr(Matrix_t *mat, int row) except NULL
+    int MatCompare(Matrix_t *a, Matrix_t *b) except -2
+    int MatCopyRegion(Matrix_t *dest, int destrow, int destcol, Matrix_t *src, int row1, int col1, int nrows, int ncols) except -1
+    Matrix_t *MatCut(Matrix_t *src, int row1, int col1, int nrows, int ncols) except NULL
+    Matrix_t *MatCutRows(Matrix_t *src, int row1, int nrows) except NULL
+    Matrix_t *MatDup(Matrix_t *src) except NULL
+    Matrix_t *MatId(int fl, int nor) except NULL
+    Matrix_t *MatLoad(char *fn) except? NULL
+    int MatSave(Matrix_t *mat, char *fn) except -1
+
+    ## Basic Arithmetic  ## general rule: dest is changed, src/mat are unchanged!
+    Matrix_t *MatTransposed(Matrix_t *src) except NULL
+    Matrix_t *MatAdd(Matrix_t *dest, Matrix_t *src) except NULL
+    Matrix_t *MatAddMul(Matrix_t *dest, Matrix_t *src, FEL coeff) except NULL
+    Matrix_t *MatMul(Matrix_t *dest, Matrix_t *src) except NULL
+    Matrix_t *MatMulScalar(Matrix_t *dest, FEL coeff) except NULL
+    Matrix_t *MatPower(Matrix_t *mat, long n) except NULL
+    int StablePower(Matrix_t *mat, int *pwr, Matrix_t **ker) except -1
+    FEL MatTrace(Matrix_t *mat) except 255
+    Matrix_t *MatMulStrassen(Matrix_t *dest, Matrix_t *A, Matrix_t *B) except NULL
+    void StrassenSetCutoff(size_t size)
+
+    ## "Higher" Arithmetic
+    Matrix_t *MatTensor(Matrix_t *m1, Matrix_t *m2) except NULL
+    Matrix_t *TensorMap(Matrix_t *vec, Matrix_t *a, Matrix_t *b) except NULL
+
+    int MatClean(Matrix_t *mat, Matrix_t *sub) except -1
+    int MatEchelonize(Matrix_t *mat) except -1
+    int MatOrder(Matrix_t *mat) except? -1
+    long MatNullity(Matrix_t *mat)
+    Matrix_t *MatInverse(Matrix_t *src) except NULL
+    Matrix_t *MatNullSpace(Matrix_t *mat) except NULL
+    Matrix_t *MatNullSpace__(Matrix_t *mat) except NULL
+
+    ## Error handling
+    cdef extern int MTX_ERR_NOMEM, MTX_ERR_GAME_OVER, MTX_ERR_DIV0, MTX_ERR_FILEFMT, MTX_ERR_BADARG
+    cdef extern int MTX_ERR_RANGE, MTX_ERR_NOTECH, MTX_ERR_NOTSQUARE, MTX_ERR_INCOMPAT
+    cdef extern int MTX_ERR_BADUSAGE, MTX_ERR_OPTION, MTX_ERR_NARGS, MTX_ERR_NOTMATRIX, MTX_ERR_NOTPERM
+    ctypedef struct MtxFileInfo_t:
+        char *Name
+        char *BaseName
+
+    ctypedef struct MtxErrorRecord_t:
+        MtxFileInfo_t *FileInfo
+        int LineNo
+        char *Text
+
+    ctypedef void MtxErrorHandler_t(MtxErrorRecord_t*)
+    MtxErrorHandler_t *MtxSetErrorHandler(MtxErrorHandler_t *h)
+
+cdef Matrix_t *rawMatrix(int Field, list entries) except NULL

sage/libs/meataxe.pyx

@@ -0,0 +1,95 @@
+# distutils: libraries = mtx
+# sage_setup: distribution = sagemath-meataxe
+
+# ****************************************************************************
+#       Copyright (C) 2017 Simon King <simon.king@uni-jena.de>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from cpython.exc cimport PyErr_SetObject
+from cysignals.signals cimport sig_block, sig_unblock
+cdef dict ErrMsg = {
+    "Not enough memory": MemoryError,
+    "Time limit exceeded": RuntimeError,
+    "Division by zero": ZeroDivisionError,
+    "Bad file format": OSError,
+    "No such file or directory": OSError,
+    "Bad argument": ValueError,
+    "Argument out of range": IndexError,
+
+    "Matrix not in echelon form": ValueError,
+    "Matrix not square": ArithmeticError,
+    "Incompatible objects": TypeError,
+
+    "Bad syntax, try `-help'": SyntaxError,
+    "Bad usage of option, try `-help'": ValueError,
+    "Bad number of arguments, try `-help'": ValueError,
+
+    "Not a matrix": TypeError,
+    "Not a permutation": TypeError
+}
+
+
+cdef Matrix_t *rawMatrix(int Field, list entries) except NULL:
+    """
+    Return a meataxe matrix.
+
+    INPUT:
+
+    - ``Field`` -- integer; the field size
+    - ``entries`` -- list of lists, the entries of the matrix, also
+      defining the matrix dimensions. It is *not* tested that all rows
+      in ``entries`` have the same length, and it is assumed that both
+      the number of rows and the number of columns is positive. All
+      elements are given by ints, they are automatically interpreted as
+      field elements.
+    """
+    cdef Matrix_t *M = MatAlloc(Field, len(entries), len(entries[0]))
+    cdef PTR x = M.Data
+    cdef int idx, i, j
+    cdef list dt_i
+    for i in range(M.Nor):
+        idx = 0
+        dt_i = entries[i]
+        for j in range(M.Noc):
+            FfInsert(x, j, FfFromInt(dt_i[j]))
+        FfStepPtr(&(x))
+    return M
+
+###############################################################
+## It is needed to do some initialisation. Since the meataxe
+## version used in Sage (SharedMeatAxe) is a dynamic (shared)
+## library, it sufficed to do this initialisation only once.
+## For convenience, the meataxe_init() function is called in
+## this module. Hence, `import sage.libs.meataxe` is enough
+## to make sure that MeatAxe is initialised.
+
+from sage.cpython.string cimport str_to_bytes, char_to_str
+
+cdef void sage_meataxe_error_handler(const MtxErrorRecord_t *err) noexcept:
+    sig_block()
+    ErrText  = char_to_str(err.Text)
+    BaseName = char_to_str(err.FileInfo.BaseName)
+    LineNo   = err.LineNo
+    PyErr_SetObject(ErrMsg.get(ErrText.split(': ')[-1], RuntimeError), f"{ErrText} in file {BaseName} (line {LineNo})")
+    sig_unblock()
+
+cdef inline meataxe_init() noexcept:
+    ## Assign to a variable that enables MeatAxe to find
+    ## its multiplication tables.
+    global MtxLibDir
+    from sage import env
+    mtxdir = str_to_bytes(env.MTXLIB)
+    if len(mtxdir) >= 1024:
+        raise RuntimeError(f"the path for the meataxe library {mtxdir!r} is too long, it needs to be of length < 1024")
+    MtxLibDir[:len(mtxdir)] = mtxdir
+    MtxLibDir[len(mtxdir)] = c'\0'
+    ## Error handling for MeatAxe, to prevent immediate exit of the program
+    MtxSetErrorHandler(sage_meataxe_error_handler)
+
+meataxe_init()

sage/matrix/all__sagemath_meataxe.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-meataxe

sage/matrix/matrix_gfpn_dense.pxd

@@ -0,0 +1,37 @@
+# sage_setup: distribution = sagemath-meataxe
+
+# ***************************************************************************
+#       Copyright (C) 2015 Simon King <simon.king@uni-jena.de>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+from sage.matrix.matrix_dense cimport Matrix_dense
+from sage.structure.element cimport Matrix
+from sage.libs.meataxe cimport *
+
+
+cdef class FieldConverter_class:
+    cdef field  # A function converting an int to a field element
+    cdef FEL zero_FEL  # the FEL representation of zero
+    cpdef fel_to_field(self, FEL x) noexcept
+    cpdef FEL field_to_fel(self, x) except 255
+
+cdef FieldConverter_class FieldConverter(field) noexcept
+
+cdef class Matrix_gfpn_dense(Matrix_dense):
+    cdef Matrix_t *Data
+    cdef readonly FieldConverter_class _converter
+
+    cdef set_slice_unsafe(self, Py_ssize_t i, Matrix_gfpn_dense S) noexcept
+    cdef inline int get_unsafe_int(self, Py_ssize_t i, Py_ssize_t j) noexcept
+    cpdef Matrix_gfpn_dense get_slice(self, Py_ssize_t i, Py_ssize_t j) noexcept
+    cpdef list _rowlist_(self, i, j=*) noexcept
+    cpdef Matrix_gfpn_dense _multiply_classical(Matrix_gfpn_dense self, Matrix_gfpn_dense right) noexcept
+    cpdef Matrix_gfpn_dense _multiply_strassen(Matrix_gfpn_dense self, Matrix_gfpn_dense right, cutoff=*) noexcept
+
+cdef Matrix_gfpn_dense new_mtx(Matrix_t* mat, Matrix_gfpn_dense template) noexcept