# HG changeset patch
# User David Roe <roed@math.harvard.edu>
# Date 1325752532 28800
# Node ID 043f1d83401880139532d635c3191b0ad4ada0f1
# Parent 43486464653c150ac9c7c4e1eb18adb72c287d48
#12262: add doctests to various files in sage/rings/finite_rings
diff --git a/sage/rings/finite_rings/constructor.py b/sage/rings/finite_rings/constructor.py
a
|
b
|
|
394 | 394 | """ |
395 | 395 | EXAMPLES:: |
396 | 396 | |
397 | | sage: K = GF(19) |
| 397 | sage: K = GF(19) # indirect doctest |
398 | 398 | sage: TestSuite(K).run() |
399 | 399 | """ |
400 | 400 | # IMPORTANT! If you add a new class to the list of classes |
diff --git a/sage/rings/finite_rings/element_base.pyx b/sage/rings/finite_rings/element_base.pyx
a
|
b
|
|
97 | 97 | raise ValueError, "unknown algorithm" |
98 | 98 | |
99 | 99 | cdef class FinitePolyExtElement(FiniteRingElement): |
100 | | |
| 100 | """ |
| 101 | Elements represented as polynomials modulo a given ideal. |
| 102 | |
| 103 | TESTS:: |
| 104 | |
| 105 | sage: k.<a> = GF(64) |
| 106 | sage: TestSuite(a).run() |
| 107 | """ |
101 | 108 | def _im_gens_(self, codomain, im_gens): |
102 | 109 | """ |
103 | 110 | Used for applying homomorphisms of finite fields. |
… |
… |
|
106 | 113 | |
107 | 114 | sage: k.<a> = FiniteField(73^2, 'a') |
108 | 115 | sage: K.<b> = FiniteField(73^4, 'b') |
109 | | sage: phi = k.hom([ b^(73*73+1) ]) |
| 116 | sage: phi = k.hom([ b^(73*73+1) ]) # indirect doctest |
110 | 117 | sage: phi(0) |
111 | 118 | 0 |
112 | 119 | sage: phi(a) |
diff --git a/sage/rings/finite_rings/element_givaro.pyx b/sage/rings/finite_rings/element_givaro.pyx
a
|
b
|
|
756 | 756 | def __reduce__(self): |
757 | 757 | """ |
758 | 758 | For pickling. |
| 759 | |
| 760 | TESTS:: |
| 761 | |
| 762 | sage: k.<a> = GF(3^8) |
| 763 | sage: TestSuite(a).run() |
759 | 764 | """ |
760 | 765 | p, k = self.order().factor()[0] |
761 | 766 | if self.repr == 0: |
… |
… |
|
888 | 893 | def _repr_(FiniteField_givaroElement self): |
889 | 894 | """ |
890 | 895 | EXAMPLE: |
891 | | sage: k.<FOOBAR> = GF(2^4) |
| 896 | sage: k.<FOOBAR> = GF(3^4) |
892 | 897 | sage: FOOBAR #indirect doctest |
893 | 898 | FOOBAR |
894 | 899 | |
895 | | sage: k.<FOOBAR> = GF(2^4,repr='log') |
| 900 | sage: k.<FOOBAR> = GF(3^4,repr='log') |
896 | 901 | sage: FOOBAR |
897 | | 1 |
| 902 | 41 |
898 | 903 | |
899 | | sage: k.<FOOBAR> = GF(2^4,repr='int') |
| 904 | sage: k.<FOOBAR> = GF(3^4,repr='int') |
900 | 905 | sage: FOOBAR |
901 | | 2 |
| 906 | 3 |
902 | 907 | """ |
903 | 908 | return self._cache._element_repr(self) |
904 | 909 | |
905 | 910 | def _element(self): |
906 | 911 | """ |
907 | 912 | Returns the int interally representing this element. |
| 913 | |
| 914 | EXAMPLES:: |
| 915 | |
| 916 | sage: k.<a> = GF(3^4) |
| 917 | sage: (a^2 + 1)._element() |
| 918 | 58 |
908 | 919 | """ |
909 | 920 | return self.element |
910 | 921 | |
… |
… |
|
1062 | 1073 | |
1063 | 1074 | EXAMPLE: |
1064 | 1075 | sage: k.<b> = GF(9**2) |
1065 | | sage: b^10 + 2*b |
| 1076 | sage: b^10 + 2*b # indirect doctest |
1066 | 1077 | 2*b^3 + 2*b^2 + 2*b + 1 |
1067 | 1078 | """ |
1068 | 1079 | cdef int r |
… |
… |
|
1076 | 1087 | |
1077 | 1088 | EXAMPLE: |
1078 | 1089 | sage: k.<b> = GF(9**2) |
1079 | | sage: b^10 + 2*b |
| 1090 | sage: b^10 + 2*b # indirect doctest |
1080 | 1091 | 2*b^3 + 2*b^2 + 2*b + 1 |
1081 | 1092 | """ |
1082 | 1093 | cdef int r |
… |
… |
|
1091 | 1102 | |
1092 | 1103 | EXAMPLE: |
1093 | 1104 | sage: k.<c> = GF(7**4) |
1094 | | sage: 3*c |
| 1105 | sage: 3*c # indirect doctest |
1095 | 1106 | 3*c |
1096 | 1107 | sage: c*c |
1097 | 1108 | c^2 |
… |
… |
|
1108 | 1119 | |
1109 | 1120 | EXAMPLE: |
1110 | 1121 | sage: k.<c> = GF(7**4) |
1111 | | sage: 3*c |
| 1122 | sage: 3*c # indirect doctest |
1112 | 1123 | 3*c |
1113 | 1124 | sage: c*c |
1114 | 1125 | c^2 |
… |
… |
|
1124 | 1135 | |
1125 | 1136 | EXAMPLE: |
1126 | 1137 | sage: k.<g> = GF(2**8) |
1127 | | sage: g/g |
| 1138 | sage: g/g # indirect doctest |
1128 | 1139 | 1 |
1129 | 1140 | |
1130 | 1141 | sage: k(1) / k(0) |
… |
… |
|
1145 | 1156 | |
1146 | 1157 | EXAMPLE: |
1147 | 1158 | sage: k.<g> = GF(2**8) |
1148 | | sage: g/g |
| 1159 | sage: g/g # indirect doctest |
1149 | 1160 | 1 |
1150 | 1161 | |
1151 | 1162 | sage: k(1) / k(0) |
… |
… |
|
1167 | 1178 | |
1168 | 1179 | EXAMPLE: |
1169 | 1180 | sage: k.<a> = GF(3**4) |
1170 | | sage: k(3) - k(1) |
| 1181 | sage: k(3) - k(1) # indirect doctest |
1171 | 1182 | 2 |
1172 | 1183 | sage: 2*a - a^2 |
1173 | 1184 | 2*a^2 + 2*a |
… |
… |
|
1183 | 1194 | |
1184 | 1195 | EXAMPLE: |
1185 | 1196 | sage: k.<a> = GF(3**4) |
1186 | | sage: k(3) - k(1) |
| 1197 | sage: k(3) - k(1) # indirect doctest |
1187 | 1198 | 2 |
1188 | 1199 | sage: 2*a - a^2 |
1189 | 1200 | 2*a^2 + 2*a |
… |
… |
|
1384 | 1395 | """ |
1385 | 1396 | return self._cache.log_to_int(self.element) |
1386 | 1397 | |
1387 | | def _integer_(FiniteField_givaroElement self, Integer): |
| 1398 | def _integer_(FiniteField_givaroElement self, ZZ=None): |
1388 | 1399 | """ |
1389 | 1400 | Convert self to an integer if it is in the prime subfield. |
1390 | 1401 | |
… |
… |
|
1392 | 1403 | |
1393 | 1404 | sage: k.<b> = GF(5^2); k |
1394 | 1405 | Finite Field in b of size 5^2 |
1395 | | sage: ZZ(k(4)) |
| 1406 | sage: k(4)._integer_() |
1396 | 1407 | 4 |
1397 | 1408 | sage: ZZ(b) |
1398 | 1409 | Traceback (most recent call last): |
diff --git a/sage/rings/finite_rings/element_ntl_gf2e.pyx b/sage/rings/finite_rings/element_ntl_gf2e.pyx
a
|
b
|
|
150 | 150 | the parent (see #12062). |
151 | 151 | """ |
152 | 152 | def __init__(self, parent, k, modulus): |
| 153 | """ |
| 154 | Initialization. |
| 155 | |
| 156 | TESTS:: |
| 157 | |
| 158 | sage: k.<a> = GF(2^8) |
| 159 | """ |
153 | 160 | cdef GF2X_c ntl_m, ntl_tmp |
154 | 161 | cdef GF2_c c |
155 | 162 | cdef Py_ssize_t i |
… |
… |
|
473 | 480 | raise ValueError, "You must provide a parent to construct a finite field element" |
474 | 481 | |
475 | 482 | def __cinit__(FiniteField_ntl_gf2eElement self, parent=None ): |
| 483 | """ |
| 484 | Restores the cache and constructs the underlying NTL element. |
| 485 | |
| 486 | EXAMPLES:: |
| 487 | |
| 488 | sage: k.<a> = GF(2^8) # indirect doctest |
| 489 | """ |
476 | 490 | if parent is None: |
477 | 491 | return |
478 | 492 | if PY_TYPE_CHECK(parent, FiniteField_ntl_gf2e): |
… |
… |
|
637 | 651 | EXAMPLES:: |
638 | 652 | |
639 | 653 | sage: k.<a> = GF(2^16) |
640 | | sage: e = a^2 + a + 1 |
| 654 | sage: e = a^2 + a + 1 # indirect doctest |
641 | 655 | sage: f = a^15 + a^2 + 1 |
642 | 656 | sage: e + f |
643 | 657 | a^15 + a |
… |
… |
|
653 | 667 | EXAMPLES:: |
654 | 668 | |
655 | 669 | sage: k.<a> = GF(2^16) |
656 | | sage: e = a^2 + a + 1 |
| 670 | sage: e = a^2 + a + 1 # indirect doctest |
657 | 671 | sage: f = a^15 + a^2 + 1 |
658 | 672 | sage: e + f |
659 | 673 | a^15 + a |
… |
… |
|
668 | 682 | EXAMPLES:: |
669 | 683 | |
670 | 684 | sage: k.<a> = GF(2^16) |
671 | | sage: e = a^2 + a + 1 |
| 685 | sage: e = a^2 + a + 1 # indirect doctest |
672 | 686 | sage: f = a^15 + a^2 + 1 |
673 | 687 | sage: e * f |
674 | 688 | a^15 + a^6 + a^5 + a^3 + a^2 |
… |
… |
|
684 | 698 | EXAMPLES:: |
685 | 699 | |
686 | 700 | sage: k.<a> = GF(2^16) |
687 | | sage: e = a^2 * a + 1 |
| 701 | sage: e = a^2 * a + 1 # indirect doctest |
688 | 702 | sage: f = a^15 * a^2 + 1 |
689 | 703 | sage: e * f |
690 | 704 | a^9 + a^7 + a + 1 |
… |
… |
|
699 | 713 | EXAMPLES:: |
700 | 714 | |
701 | 715 | sage: k.<a> = GF(2^16) |
702 | | sage: e = a^2 + a + 1 |
| 716 | sage: e = a^2 + a + 1 # indirect doctest |
703 | 717 | sage: f = a^15 + a^2 + 1 |
704 | 718 | sage: e / f |
705 | 719 | a^11 + a^8 + a^7 + a^6 + a^5 + a^3 + a^2 + 1 |
… |
… |
|
721 | 735 | EXAMPLES:: |
722 | 736 | |
723 | 737 | sage: k.<a> = GF(2^16) |
724 | | sage: e = a^2 / a + 1 |
| 738 | sage: e = a^2 / a + 1 # indirect doctest |
725 | 739 | sage: f = a^15 / a^2 + 1 |
726 | 740 | sage: e / f |
727 | 741 | a^15 + a^12 + a^10 + a^9 + a^6 + a^5 + a^3 |
… |
… |
|
736 | 750 | EXAMPLES:: |
737 | 751 | |
738 | 752 | sage: k.<a> = GF(2^16) |
739 | | sage: e = a^2 - a + 1 |
| 753 | sage: e = a^2 - a + 1 # indirect doctest |
740 | 754 | sage: f = a^15 - a^2 + 1 |
741 | 755 | sage: e - f |
742 | 756 | a^15 + a |
… |
… |
|
752 | 766 | EXAMPLES:: |
753 | 767 | |
754 | 768 | sage: k.<a> = GF(2^16) |
755 | | sage: e = a^2 - a + 1 |
| 769 | sage: e = a^2 - a + 1 # indirect doctest |
756 | 770 | sage: f = a^15 - a^2 + 1 |
757 | 771 | sage: e - f |
758 | 772 | a^15 + a |
diff --git a/sage/rings/finite_rings/finite_field_base.pyx b/sage/rings/finite_rings/finite_field_base.pyx
a
|
b
|
|
242 | 242 | |
243 | 243 | EXAMPLES:: |
244 | 244 | |
245 | | sage: FiniteField(3**2, 'c') == FiniteField(3**3, 'c') |
| 245 | sage: FiniteField(3**2, 'c') == FiniteField(3**3, 'c') # indirect doctest |
246 | 246 | False |
247 | 247 | sage: FiniteField(3**2, 'c') == FiniteField(3**2, 'c') |
248 | 248 | True |
diff --git a/sage/rings/finite_rings/finite_field_ext_pari.py b/sage/rings/finite_rings/finite_field_ext_pari.py
a
|
b
|
|
443 | 443 | |
444 | 444 | sage: from sage.rings.finite_rings.finite_field_ext_pari import FiniteField_ext_pari |
445 | 445 | sage: k = FiniteField_ext_pari(3^4, 'a') |
446 | | sage: b = k(5) |
| 446 | sage: b = k(5) # indirect doctest |
447 | 447 | sage: b.parent() |
448 | 448 | Finite Field in a of size 3^4 |
449 | 449 | sage: a = k.gen() |
diff --git a/sage/rings/finite_rings/finite_field_givaro.py b/sage/rings/finite_rings/finite_field_givaro.py
a
|
b
|
|
79 | 79 | |
80 | 80 | sage: GF(2^3,'a') == copy(GF(2^3,'a')) |
81 | 81 | True |
| 82 | sage: TestSuite(j).run() |
82 | 83 | """ |
83 | 84 | self._kwargs = {} |
84 | 85 | |
… |
… |
|
216 | 217 | |
217 | 218 | Floats, ints, longs, Integer are interpreted modulo characteristic:: |
218 | 219 | |
219 | | sage: k(2) |
| 220 | sage: k(2) # indirect doctest |
220 | 221 | 0 |
221 | 222 | |
222 | 223 | Floats coerce in: |
… |
… |
|
334 | 335 | def _coerce_map_from_(self, R): |
335 | 336 | """ |
336 | 337 | Returns True if this finite field has a coercion map from R. |
| 338 | |
| 339 | EXAMPLES:: |
| 340 | |
| 341 | sage: k.<a> = GF(3^8) |
| 342 | sage: a + 1 # indirect doctest |
| 343 | a + 1 |
| 344 | sage: a + int(1) |
| 345 | a + 1 |
| 346 | sage: a + GF(3)(1) |
| 347 | a + 1 |
337 | 348 | """ |
338 | 349 | from sage.rings.integer_ring import ZZ |
339 | 350 | from sage.rings.finite_rings.finite_field_base import is_FiniteField |
diff --git a/sage/rings/finite_rings/finite_field_ntl_gf2e.py b/sage/rings/finite_rings/finite_field_ntl_gf2e.py
a
|
b
|
|
9 | 9 | from sage.rings.finite_rings.integer_mod_ring import IntegerModRing_generic |
10 | 10 | |
11 | 11 | def late_import(): |
| 12 | """ |
| 13 | Imports various modules after startup. |
| 14 | |
| 15 | EXAMPLES:: |
| 16 | |
| 17 | sage: sage.rings.finite_rings.finite_field_ntl_gf2e.late_import() |
| 18 | sage: sage.rings.finite_rings.finite_field_ntl_gf2e.GF2 is None # indirect doctest |
| 19 | False |
| 20 | """ |
12 | 21 | if globals().has_key("GF2"): |
13 | 22 | return |
14 | 23 | global ResidueField_generic, is_FiniteField, exists_conway_polynomial, conway_polynomial, Cache_ntl_gf2e, GF, GF2, is_Polynomial |
… |
… |
|
190 | 199 | EXAMPLES:: |
191 | 200 | |
192 | 201 | sage: k.<a> = GF(2^20) |
193 | | sage: k(1) |
| 202 | sage: k(1) # indirect doctest |
194 | 203 | 1 |
195 | 204 | sage: k(int(2)) |
196 | 205 | 0 |
… |
… |
|
222 | 231 | def _coerce_map_from_(self, R): |
223 | 232 | """ |
224 | 233 | Coercion accepts elements of self.parent(), ints, and prime subfield elements. |
| 234 | |
| 235 | EXAMPLES:: |
| 236 | |
| 237 | sage: k.<a> = GF(2^8) |
| 238 | sage: a + int(1) # indirect doctest |
| 239 | a + 1 |
| 240 | sage: a + 1 |
| 241 | a + 1 |
| 242 | sage: a + GF(2)(1) |
| 243 | a + 1 |
225 | 244 | """ |
226 | 245 | if R is int or R is long or R is ZZ: |
227 | 246 | return True |
diff --git a/sage/rings/finite_rings/homset.py b/sage/rings/finite_rings/homset.py
a
|
b
|
|
52 | 52 | raise TypeError, "images do not define a valid homomorphism" |
53 | 53 | |
54 | 54 | def _coerce_impl(self, x): |
| 55 | """ |
| 56 | Coercion of other morphisms. |
| 57 | |
| 58 | EXAMPLES:: |
| 59 | |
| 60 | sage: k.<a> = GF(25) |
| 61 | sage: l.<b> = GF(625) |
| 62 | sage: H = Hom(k, l) |
| 63 | sage: G = loads(dumps(H)) |
| 64 | sage: H == G |
| 65 | True |
| 66 | sage: H is G # this should change eventually |
| 67 | False |
| 68 | sage: G.coerce(list(H)[0]) # indirect doctest |
| 69 | Ring morphism: |
| 70 | From: Finite Field in a of size 5^2 |
| 71 | To: Finite Field in b of size 5^4 |
| 72 | Defn: a |--> 4*b^3 + 4*b^2 + 4*b + 3 |
| 73 | """ |
55 | 74 | if not isinstance(x, FiniteFieldHomomorphism_im_gens): |
56 | 75 | raise TypeError |
57 | 76 | if x.parent() is self: |
… |
… |
|
64 | 83 | """ |
65 | 84 | EXAMPLES:: |
66 | 85 | |
67 | | sage: Hom(GF(4, 'a'), GF(16, 'b')) |
| 86 | sage: Hom(GF(4, 'a'), GF(16, 'b')) # indirect doctest |
68 | 87 | Set of field embeddings from Finite Field in a of size 2^2 to Finite Field in b of size 2^4 |
69 | 88 | sage: Hom(GF(4, 'a'), GF(4, 'c')) |
70 | 89 | Set of field embeddings from Finite Field in a of size 2^2 to Finite Field in c of size 2^2 |
diff --git a/sage/rings/finite_rings/integer_mod_ring.py b/sage/rings/finite_rings/integer_mod_ring.py
a
|
b
|
|
116 | 116 | True |
117 | 117 | """ |
118 | 118 | def create_key(self, order=0, category=None): |
| 119 | """ |
| 120 | An integer mod ring is specified uniquely by its order. |
| 121 | |
| 122 | EXAMPLES:: |
| 123 | |
| 124 | sage: Zmod.create_key(7) |
| 125 | 7 |
| 126 | """ |
119 | 127 | if category is None: |
120 | 128 | return order |
121 | 129 | return (order, category) |
… |
… |
|
331 | 339 | """ |
332 | 340 | EXAMPLES:: |
333 | 341 | |
334 | | sage: macaulay2(Integers(7)) # optional - macaulay2 |
| 342 | sage: macaulay2(Integers(7)) # indirect doctest, optional - macaulay2 |
335 | 343 | ZZ |
336 | 344 | -- |
337 | 345 | 7 |
… |
… |
|
401 | 409 | |
402 | 410 | |
403 | 411 | def _precompute_table(self): |
| 412 | """ |
| 413 | Computes a table of elements so that elements are unique. |
| 414 | |
| 415 | EXAMPLES:: |
| 416 | |
| 417 | sage: R = Zmod(500); R._precompute_table() |
| 418 | sage: R(7) + R(13) is R(3) + R(17) |
| 419 | True |
| 420 | """ |
404 | 421 | self._pyx_order.precompute_table(self) |
405 | 422 | |
406 | 423 | def list_of_elements_of_multiplicative_group(self): |
| 424 | """ |
| 425 | Returns a list of all invertible elements, as python ints. |
| 426 | |
| 427 | EXAMPLES:: |
| 428 | |
| 429 | sage: R = Zmod(12) |
| 430 | sage: L = R.list_of_elements_of_multiplicative_group(); L |
| 431 | [1, 5, 7, 11] |
| 432 | sage: type(L[0]) |
| 433 | <type 'int'> |
| 434 | """ |
407 | 435 | import sage.rings.fast_arith as a |
408 | 436 | if self.__order <= 46340: # todo: don't hard code |
409 | 437 | gcd = a.arith_int().gcd_int |
… |
… |
|
773 | 801 | return self.__order |
774 | 802 | |
775 | 803 | def _repr_(self): |
| 804 | """ |
| 805 | String representation. |
| 806 | |
| 807 | EXAMPLES:: |
| 808 | |
| 809 | sage: Zmod(87) # indirect doctest |
| 810 | Ring of integers modulo 87 |
| 811 | """ |
776 | 812 | return "Ring of integers modulo %s"%self.__order |
777 | 813 | |
778 | 814 | def _latex_(self): |
| 815 | """ |
| 816 | Latex representation. |
| 817 | |
| 818 | EXAMPLES:: |
| 819 | |
| 820 | sage: latex(Zmod(87)) # indirect doctest |
| 821 | \ZZ/87\ZZ |
| 822 | """ |
779 | 823 | return "\ZZ/%s\ZZ" % self.__order |
780 | 824 | |
781 | 825 | def modulus(self): |
… |
… |
|
804 | 848 | return self.__modulus |
805 | 849 | |
806 | 850 | def order(self): |
| 851 | """ |
| 852 | Returns the order of this ring. |
| 853 | |
| 854 | EXAMPLES:: |
| 855 | |
| 856 | sage: Zmod(87).order() |
| 857 | 87 |
| 858 | """ |
807 | 859 | return self.__order |
808 | 860 | |
809 | 861 | def cardinality(self): |
| 862 | """ |
| 863 | Returns the cardinality of this ring. |
| 864 | |
| 865 | EXAMPLES:: |
| 866 | |
| 867 | sage: Zmod(87).cardinality() |
| 868 | 87 |
| 869 | """ |
810 | 870 | return self.order() |
811 | 871 | |
812 | 872 | def _pari_order(self): |
| 873 | """ |
| 874 | Returns the pari integer representing the order of this ring. |
| 875 | |
| 876 | EXAMPLES:: |
| 877 | |
| 878 | sage: Zmod(87)._pari_order() |
| 879 | 87 |
| 880 | """ |
813 | 881 | try: |
814 | 882 | return self.__pari_order |
815 | 883 | except AttributeError: |
… |
… |
|
823 | 891 | sage: K2 = GF(2) |
824 | 892 | sage: K3 = GF(3) |
825 | 893 | sage: K8 = GF(8,'a') |
826 | | sage: K8(5) |
| 894 | sage: K8(5) # indirect doctest |
827 | 895 | 1 |
828 | 896 | sage: K8('a+1') |
829 | 897 | a + 1 |
… |
… |
|
892 | 960 | EXAMPLES:: |
893 | 961 | |
894 | 962 | sage: R = Integers(15) |
895 | | sage: f = R.coerce_map_from(Integers(450)); f |
| 963 | sage: f = R.coerce_map_from(Integers(450)); f # indirect doctest |
896 | 964 | Natural morphism: |
897 | 965 | From: Ring of integers modulo 450 |
898 | 966 | To: Ring of integers modulo 15 |
… |
… |
|
980 | 1048 | # them out from the unit_gens function. They are only called by |
981 | 1049 | # the unit_gens function. |
982 | 1050 | def __unit_gens_primecase(self, p): |
| 1051 | """ |
| 1052 | Assuming the modulus is prime, returns the smallest generator |
| 1053 | of the group of units. |
| 1054 | |
| 1055 | EXAMPLES:: |
| 1056 | |
| 1057 | sage: Zmod(17)._IntegerModRing_generic__unit_gens_primecase(17) |
| 1058 | 3 |
| 1059 | """ |
983 | 1060 | if p==2: |
984 | 1061 | return integer_mod.Mod(1,p) |
985 | 1062 | P = prime_divisors(p-1) |
… |
… |
|
1003 | 1080 | r""" |
1004 | 1081 | Find smallest generator for |
1005 | 1082 | `(\ZZ/p^r\ZZ)^*`. |
| 1083 | |
| 1084 | EXAMPLES:: |
| 1085 | |
| 1086 | sage: Zmod(27)._IntegerModRing_generic__unit_gens_primepowercase(3,3) |
| 1087 | [2] |
1006 | 1088 | """ |
1007 | 1089 | if r==1: |
1008 | 1090 | return [self.__unit_gens_primecase(p)] |
… |
… |
|
1141 | 1223 | sage: R = Integers(12345678900) |
1142 | 1224 | sage: R |
1143 | 1225 | Ring of integers modulo 12345678900 |
1144 | | sage: gap(R) |
| 1226 | sage: gap(R) # indirect doctest |
1145 | 1227 | (Integers mod 12345678900) |
1146 | 1228 | """ |
1147 | 1229 | return 'ZmodnZ(%s)'%self.order() |
… |
… |
|
1153 | 1235 | sage: R = Integers(12345678900) |
1154 | 1236 | sage: R |
1155 | 1237 | Ring of integers modulo 12345678900 |
1156 | | sage: magma(R) # optional - magma |
| 1238 | sage: magma(R) # indirect doctest, optional - magma |
1157 | 1239 | Residue class ring of integers modulo 12345678900 |
1158 | 1240 | """ |
1159 | 1241 | return 'Integers(%s)'%self.order() |
… |
… |
|
1194 | 1276 | """ |
1195 | 1277 | INPUT: v - (list) a lift of elements of rings.IntegerMod(n), for |
1196 | 1278 | various coprime moduli n. |
| 1279 | |
| 1280 | EXAMPLES:: |
| 1281 | |
| 1282 | sage: from sage.rings.finite_rings.integer_mod_ring import crt |
| 1283 | sage: crt([mod(3, 8),mod(1,19),mod(7, 15)]) |
| 1284 | 1027 |
1197 | 1285 | """ |
1198 | 1286 | if len(v) == 0: |
1199 | 1287 | return IntegerModRing(1)(1) |