Ticket #4260: trac_4260-matrix-modn-docs.patch

File trac_4260-matrix-modn-docs.patch, 9.4 KB (added by malb, 9 years ago)
  • sage/matrix/matrix_modn_dense_double.pyx

    # HG changeset patch
    # User Rob Beezer <beezer@ups.edu>
    # Date 1314252443 25200
    # Node ID 64c6dc325c7a1ca3a460e74f19a4390fc48efa9b
    # Parent  4f73ff550a412acda953baa9bf497ed3592e47a7
    #4260: mod n dense matrix documentation
    
    diff -r 4f73ff550a41 -r 64c6dc325c7a sage/matrix/matrix_modn_dense_double.pyx
    a b  
    4343
    4444
    4545cdef class Matrix_modn_dense_double(Matrix_modn_dense_template):
    46     """
     46    r"""
    4747    Dense matrices over `\ZZ/n\ZZ` for `n < 2^{23}` using LinBox's ``Modular<float>``
     48
     49    These are matrices with integer entries mod ``n`` represented as
     50    floating-point numbers in a 64-bit word for use with LinBox routines.
     51    This allows for ``n`` up to `2^{23}`.  The
     52    ``Matrix_modn_dense_float`` class specializes to smaller moduli.
     53   
     54    Routines here are for the most basic access, see the
     55    `matrix_modn_dense_template.pxi` file for higher-level routines.
    4856    """
    4957    cdef set_unsafe_int(self, Py_ssize_t i, Py_ssize_t j, int value):
    50         """
     58        r"""
    5159        Set the (i,j) entry of self to the int value.
    5260
    5361        EXAMPLE::
     
    5765            [1795330  767112 2967421 1373921]
    5866            [2757699 1142917 2720973 2877160]
    5967            [1674049 1341486 2641133 2173280]
    60 
    6168            sage: A[0,0] = 220082r; A
    6269            [ 220082 2824836  765701 2282256]
    6370            [1795330  767112 2967421 1373921]
    6471            [2757699 1142917 2720973 2877160]
    6572            [1674049 1341486 2641133 2173280]
    66            
    6773            sage: a = A[0,0]; a
    6874            220082
    69 
    7075            sage: ~a
    7176            2859358
    7277
     
    7580            [4649912 1157595 4928315 4382585]
    7681            [4252686  978867 2601478 1759921]
    7782            [1303120 1860486 3405811 2203284]
    78 
    7983            sage: A[0,0] = 220082r; A
    8084            [ 220082 1237101 2033003 3788106]
    8185            [4649912 1157595 4928315 4382585]
    8286            [4252686  978867 2601478 1759921]
    8387            [1303120 1860486 3405811 2203284]
    84            
    8588            sage: a = A[0,0]; a
    8689            220082
    87 
    8890            sage: a*a
    8991            4777936
    9092        """
    9193        self._matrix[i][j] = <double>value
    9294
    9395    cdef set_unsafe(self, Py_ssize_t i, Py_ssize_t j, x):
    94         """
     96        r"""
     97        Set the (i,j) entry with no bounds-checking, or any other checks.
     98       
     99        Assumes that `x` is in the base ring.
     100
    95101        EXAMPLE::
    96102
    97103            sage: A = random_matrix(GF(3016963), 4, 4); A
     
    99105            [1795330  767112 2967421 1373921]
    100106            [2757699 1142917 2720973 2877160]
    101107            [1674049 1341486 2641133 2173280]
    102 
    103108            sage: K = A.base_ring()
    104109            sage: A[0,0] = K(220082); A
    105110            [ 220082 2824836  765701 2282256]
    106111            [1795330  767112 2967421 1373921]
    107112            [2757699 1142917 2720973 2877160]
    108113            [1674049 1341486 2641133 2173280]
    109            
    110114            sage: a = A[0,0]; a
    111115            220082
    112 
    113116            sage: ~a
    114117            2859358
    115118
     
    118121            [4649912 1157595 4928315 4382585]
    119122            [4252686  978867 2601478 1759921]
    120123            [1303120 1860486 3405811 2203284]
    121 
    122124            sage: K = A.base_ring()
    123125            sage: A[0,0] = K(220081)
    124            
    125126            sage: a = A[0,0]; a
    126127            220081
    127 
    128128            sage: a*a
    129129            4337773
    130130        """
    131         # doesn't do bounds or any other checks; assumes x is in self._base_ring
    132131        self._matrix[i][j] = <double>(<IntegerMod_int>x).ivalue
    133132
    134133    cdef IntegerMod_abstract get_unsafe(self, Py_ssize_t i, Py_ssize_t j):
    135         """
     134        r"""
     135        Return the (i,j) entry with no bounds-checking.
     136       
    136137        EXAMPLE::
    137138
    138139            sage: A = random_matrix(GF(3016963), 4, 4); A
     
    140141            [1795330  767112 2967421 1373921]
    141142            [2757699 1142917 2720973 2877160]
    142143            [1674049 1341486 2641133 2173280]
    143 
    144144            sage: a = A[0,0]; a
    145145            220081
    146 
    147146            sage: ~a
    148147            697224
    149 
    150148            sage: K = A.base_ring()
    151149            sage: ~K(220081)
    152150            697224
     
    156154            [4649912 1157595 4928315 4382585]
    157155            [4252686  978867 2601478 1759921]
    158156            [1303120 1860486 3405811 2203284]
    159 
    160157            sage: a = A[0,1]; a
    161158            1237101
    162 
    163159            sage: a*a
    164160            3803997
    165 
    166161            sage: K = A.base_ring()
    167162            sage: K(1237101)^2
    168163            3803997
    169164        """
    170         # doesn't do checks
    171165        if (<Matrix_modn_dense_template>self).p <= INTEGER_MOD_INT32_LIMIT:
    172166            return IntegerMod_int(self._base_ring, <mod_int>(<Matrix_modn_dense_template>self)._matrix[i][j])
    173167        else:
  • sage/matrix/matrix_modn_dense_float.pyx

    diff -r 4f73ff550a41 -r 64c6dc325c7a sage/matrix/matrix_modn_dense_float.pyx
    a b  
    3636include "matrix_modn_dense_template.pxi"
    3737
    3838cdef class Matrix_modn_dense_float(Matrix_modn_dense_template):
    39     """
     39    r"""
    4040    Dense matrices over `\ZZ/n\ZZ` for `n < 2^{11}` using LinBox's ``Modular<float>``
     41   
     42    These are matrices with integer entries mod ``n`` represented as
     43    floating-point numbers in a 32-bit word for use with LinBox routines.
     44    This allows for ``n`` up to `2^{11}`.  The
     45    ``Matrix_modn_dense_double`` class is used for larger moduli.
     46   
     47    Routines here are for the most basic access, see the
     48    `matrix_modn_dense_template.pxi` file for higher-level routines.
    4149    """
    4250    cdef set_unsafe_int(self, Py_ssize_t i, Py_ssize_t j, int value):
    43         """
     51        r"""
    4452        Set the (i,j) entry of self to the int value.
     53       
     54        EXAMPLES::
     55       
     56            sage: A = random_matrix(GF(7), 4, 4); A
     57            [3 1 6 6]
     58            [4 4 2 2]
     59            [3 5 4 5]
     60            [6 2 2 1]
     61            sage: A[0,0] = 12; A
     62            [5 1 6 6]
     63            [4 4 2 2]
     64            [3 5 4 5]
     65            [6 2 2 1]
     66           
     67            sage: B = random_matrix(Integers(100), 4, 4); B
     68            [13 95  1 16]
     69            [18 33  7 31]
     70            [92 19 18 93]
     71            [82 42 15 38]
     72            sage: B[0,0] = 422; B
     73            [22 95  1 16]
     74            [18 33  7 31]
     75            [92 19 18 93]
     76            [82 42 15 38]
    4577        """
    4678        self._matrix[i][j] = <float>value
    4779
    4880    cdef set_unsafe(self, Py_ssize_t i, Py_ssize_t j, x):
    49         # doesn't do bounds or any other checks; assumes x is in self._base_ring
     81        r"""
     82        Set the (i,j) entry with no bounds-checking, or any other checks.
     83       
     84        Assumes that `x` is in the base ring.
     85       
     86        EXAMPLES::
     87       
     88            sage: A = random_matrix(GF(13), 4, 4); A
     89            [ 0  0  2  9]
     90            [10  6 11  8]
     91            [10 12  8  8]
     92            [ 3  6  8  0]
     93            sage: K = A.base_ring()
     94            sage: x = K(27)
     95            sage: A[0,0] = x; A
     96            [ 1  0  2  9]
     97            [10  6 11  8]
     98            [10 12  8  8]
     99            [ 3  6  8  0]
     100           
     101            sage: B = random_matrix(Integers(200), 4, 4); B
     102            [ 13  95 101 116]
     103            [118 133   7 131]
     104            [192  19 118 193]
     105            [ 82 142 115  38]
     106            sage: R = B.base_ring()
     107            sage: x = R(311)
     108            sage: B[0,0] = x; B
     109            [111  95 101 116]
     110            [118 133   7 131]
     111            [192  19 118 193]
     112            [ 82 142 115  38]
     113        """
    50114        self._matrix[i][j] = <float>(<IntegerMod_int>x).ivalue
    51115
    52116    cdef IntegerMod_int get_unsafe(self, Py_ssize_t i, Py_ssize_t j):
    53         # doesn't do checks
     117        r"""
     118        Return the (i,j) entry with no bounds-checking.
     119       
     120        EXAMPLES::
     121       
     122            sage: A = random_matrix(Integers(100), 4, 4); A
     123            [ 4 95 83 47]
     124            [44 57 91 53]
     125            [75 53 15 39]
     126            [26 25 10 74]
     127            sage: a = A[0,0]; a
     128            4
     129            sage: a in A.base_ring()
     130            True
     131       
     132            sage: B = random_matrix(Integers(100), 4, 4); B
     133            [13 95  1 16]
     134            [18 33  7 31]
     135            [92 19 18 93]
     136            [82 42 15 38]
     137            sage: b = B[0,0]; b
     138            13
     139            sage: b in B.base_ring()
     140            True
     141        """
    54142        return IntegerMod_int(self._base_ring, <mod_int>(<Matrix_modn_dense_template>self)._matrix[i][j])
  • sage/matrix/matrix_space.py

    diff -r 4f73ff550a41 -r 64c6dc325c7a sage/matrix/matrix_space.py
    a b  
    816816
    817817         
    818818    def _get_matrix_class(self):
    819         """
     819        r"""
    820820        Returns the class of self
    821821       
    822822        EXAMPLES::
     
    829829            <type 'sage.matrix.matrix_integer_sparse.Matrix_integer_sparse'>
    830830            sage: type(matrix(SR, 2, 2, 0))
    831831            <type 'sage.matrix.matrix_symbolic_dense.Matrix_symbolic_dense'>
     832            sage: type(matrix(GF(7), 2, range(4)))
     833            <type 'sage.matrix.matrix_modn_dense_float.Matrix_modn_dense_float'>
     834            sage: type(matrix(GF(16007), 2, range(4)))
     835            <type 'sage.matrix.matrix_modn_dense_double.Matrix_modn_dense_double'>
    832836        """
    833837        R = self.base_ring()
    834838        if self.is_dense():