Code coverage tests

This page documents the degree to which the PARI/GP source code is tested by our public test suite, distributed with the source distribution in directory src/test/. This is measured by the gcov utility; we then process gcov output using the lcov frond-end.

We test a few variants depending on Configure flags on the pari.math.u-bordeaux.fr machine (x86_64 architecture), and agregate them in the final report:

The target is to exceed 90% coverage for all mathematical modules (given that branches depending on DEBUGLEVEL or DEBUGMEM are not covered). This script is run to produce the results below.

LCOV - code coverage report
Current view: top level - modules - groupid.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.14.0 lcov report (development 27102-e8476a37b5) Lines: 192 224 85.7 %
Date: 2021-12-02 07:05:14 Functions: 7 8 87.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Copyright (C) 2003  The PARI group.
       2             : 
       3             : This file is part of the PARI/GP package.
       4             : 
       5             : PARI/GP is free software; you can redistribute it and/or modify it under the
       6             : terms of the GNU General Public License as published by the Free Software
       7             : Foundation; either version 2 of the License, or (at your option) any later
       8             : version. It is distributed in the hope that it will be useful, but WITHOUT
       9             : ANY WARRANTY WHATSOEVER.
      10             : 
      11             : Check the License for details. You should have received a copy of it, along
      12             : with the package; see the file 'COPYING'. If not, write to the Free Software
      13             : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      14             : 
      15             : #include "pari.h"
      16             : #include "paripriv.h"
      17             : 
      18             : static long
      19        1953 : groupelts_sumorders(GEN S)
      20             : {
      21        1953 :   long i, s = 0;
      22       42812 :   for(i=1; i < lg(S); i++) s += perm_orderu(gel(S,i));
      23        1953 :   return s;
      24             : }
      25             : 
      26             : static long
      27         693 : vecgroup_sumorders(GEN L)
      28             : {
      29         693 :   long i, s = 0;
      30       31927 :   for(i=1; i<lg(L); i++) s += group_order(gel(L,i));
      31         693 :   return s;
      32             : }
      33             : 
      34             : static int
      35          14 : indexgroupsubgroup(GEN L, long order, const long *good, const long *bad)
      36             : {
      37             :   long i;
      38         826 :   for(i=1; i<lg(L); i++)
      39             :   {
      40         812 :     GEN G=gel(L,i);
      41             :     long idx;
      42             :     const long *p;
      43         812 :     if (group_order(G)!=order) continue;
      44         210 :     idx = group_ident(G,NULL);
      45         420 :     for(p=good; *p; p++)
      46         210 :       if (*p==idx) return 1;
      47         210 :     for(p=bad; *p; p++)
      48           0 :       if (*p==idx) return 0;
      49             :   }
      50          14 :   return 0;
      51             : }
      52             : 
      53             : static int
      54         133 : indexgroupcentre(GEN G, GEN Z, const long *good, const long *bad)
      55             : {
      56             :   long i;
      57         357 :   for(i=1;i<lg(Z);i++)
      58             :   {
      59         357 :     GEN z=gel(Z,i);
      60         357 :     if (perm_orderu(z)==2)
      61             :     {
      62         182 :       pari_sp btop=avma;
      63         182 :       GEN H = cyclicgroup(z,2);
      64         182 :       GEN C = group_quotient(G,H);
      65         182 :       GEN Q = quotient_group(C,G);
      66             :       const long *p;
      67         182 :       long idx=group_ident(Q,NULL);
      68         182 :       set_avma(btop);
      69         413 :       for(p=good;*p;p++)
      70         252 :         if (*p==idx) return 1;
      71         259 :       for(p=bad;*p;p++)
      72         210 :         if (*p==idx) return 0;
      73             :     }
      74             :   }
      75           0 :   return 0;
      76             : }
      77             : 
      78             : static GEN
      79          91 : vecgroup_idxlist(GEN L, long order)
      80             : {
      81          91 :   pari_sp ltop=avma;
      82             :   GEN V;
      83             :   long i,j,n;
      84        8001 :   for (n=0,i=1; i<lg(L); i++)
      85        7910 :     if (group_order(gel(L,i))==order)
      86         385 :       n++;
      87          91 :   V=cgetg(n+1,t_VECSMALL);
      88         777 :   for(i=1,j=1; j<=n; i++)
      89         686 :     if (group_order(gel(L,i))==order)
      90         385 :       V[j++]=group_ident(gel(L,i),NULL);
      91          91 :   return gerepileupto(ltop,vecsmall_uniq(V));
      92             : }
      93             : 
      94             : /* Group identification code.
      95             :  * The group data are taken from GAP 4 and the SMALL GROUPS LIBRARY by  Hans
      96             :  * Ulrich Besche, Bettina Eick and Eamonn O'Brien.
      97             :  */
      98             : 
      99             : static long
     100        1260 : group_ident_i(GEN G, GEN S)
     101             : {
     102        1260 :   long n = S? lg(S)-1: group_order(G);
     103             :   long s;
     104             :   GEN F,p,e;
     105        1260 :   if (n==1) return 1;
     106        1260 :   if (!S) S = group_elts(G,group_domain(G));
     107        1260 :   s = groupelts_sumorders(S);/*This is used as a hash value*/
     108        1260 :   F = factoru(n);
     109        1260 :   p = gel(F,1);
     110        1260 :   e = gel(F,2);
     111        1260 :   switch(lg(p)-1)
     112             :   {
     113         980 :   case 1:/*prime power*/
     114         980 :     switch (e[1])
     115             :     {
     116          98 :     case 1: /* p */
     117          98 :       return 1;
     118          35 :     case 2: /* p^2 */
     119          35 :       return (s == 1 - p[1] + n*p[1])? 2: 1; /* pxp || p^2 */
     120         231 :     case 3: /* p^3 */
     121             :       {
     122         231 :         GEN H = group_abelianSNF(G, S);
     123         231 :         if (H) /*G is abelian*/
     124             :         {
     125         161 :           long l = lg(H)-1;
     126         161 :           return (l==3)?5: l; /*pxpxp || p^3 or p^2xp*/
     127             :         } /*G is not abelian*/
     128          70 :         if (p[1] == 2)
     129          63 :           return (s == 19)? 3: 4; /*D8 || Q8*/
     130             :         else
     131             :         {
     132           7 :           long q = p[1]*p[1];
     133           7 :           q *= q;
     134           7 :           return (s == q - p[1] + 1)?3 :4; /* pxp:p || p^2:p */
     135             :         }
     136             :       }
     137             :     }
     138         616 :     break;
     139         266 :   case 2:
     140         266 :     switch(e[1]+e[2])
     141             :     {
     142          49 :     case 2: /*pq*/
     143          49 :       return (p[2]%p[1]!=1)?1:1+group_isabelian(G); /*pq || pq or p:q*/
     144          77 :     case 3:
     145          77 :       if (p[1]==2 && e[1]==2) /* 4p */
     146             :       {
     147          63 :         long q = p[2], q2 = q*q, pmq2 = (q%4 == 1 || q==3);
     148          63 :         if (s==3+5*q+3*q2) return 1; /* 2p.2 */
     149          63 :         if (s==11-11*q+11*q2) return 2; /* 4p */
     150          63 :         if (s==3+q+3*q2) return 3+pmq2; /* D4p */
     151          63 :         if (s==7-7*q+7*q2) return 4+pmq2; /* 2px2 */
     152          63 :         return 3; /*A4 or p:4 */
     153             :       }
     154          14 :       else if (p[1]==2 && e[1]==1) /*2p^2*/
     155             :       {
     156           7 :         long q = p[2], q2 = q*q, q3 = q*q2, q4 = q*q3;
     157           7 :         if (s==1-q+3*q2-q3+q4) return 1; /* p^2:2 */
     158           7 :         if (s==3-3*q+3*q2-3*q3+3*q4) return 2; /* 2p^2 */
     159           7 :         if (s==1+q-2*q2+3*q3) return 3; /* D2pxp */
     160           7 :         if (s==1-q+2*q2+q3) return 4; /* p:2+p:2 */
     161           7 :         return 5;   /* 2pxp */
     162             :       }
     163           7 :       else if (p[1]==3 && e[1]==2) /*9p, p>3*/
     164             :       {
     165           7 :         long q= p[2], q2 = q*q, p3 = (q%3 == 1), p9 = (q%9 == 1);
     166           7 :         if (s==7+47*q+7*q2) return 1; /* 3p.3 */
     167           7 :         if (s==61-61*q+61*q2) return 1+p3; /* 9p */
     168           7 :         if (s==1+59*q+q2) return 3; /* p:9 */
     169           7 :         if (s==7+11*q+7*q2) return 3+p9; /* p:3x3 */
     170           7 :         return 2+2*p3+p9; /* 3^2xp */
     171             :       }
     172           0 :       break;
     173             :     }
     174         154 :   case 3:
     175         154 :     switch(e[1]+e[2]+e[3])
     176             :     {
     177          14 :     case 3: /*pqr*/
     178          14 :       if (p[1]==2)  /*2qr*/
     179             :       {
     180          14 :         long q = p[2],q2 = q*q, qc = 1-q+q2, qd = 1+q+q2;
     181          14 :         long r = p[3],r2 = r*r, rc = 1-r+r2, rd = 1+r+r2;
     182          14 :         long pmq = (r%q==1)? 2: 0;
     183          14 :         if (pmq && s==3*r*(q2-q)+rd) return 1; /* r:2q */
     184          14 :         if (pmq && s==3*(r2+(q2-q-1)*r+1)) return 2; /* r:qx2 */
     185           7 :         if (s==qd*rc) return 1+pmq; /* D2qxr */
     186           7 :         if (s==rd*qc) return 2+pmq; /* D2rxq */
     187           7 :         if (s==3*qc*rc) return 4+pmq; /* 2qr */
     188           0 :         return 3+pmq; /* q:2+r:2 */
     189             :       }
     190           0 :       break;
     191             :     }
     192         756 :   }
     193             :   {
     194         756 :     const long tab[]={
     195             :     24, 173, 301, 99, 125, 113, 101, 97, 85, 161, 133, 189, 67, 87, 73, 105, -1,
     196             :     36, 255, 671, 265, 219, 427, 243, 147, 275, 115, 127, 121, 159, 111, 175,
     197             :        -1,
     198             :     40, 391, 903, 263, 311, 291, 271, 227, 207, 483, 399, 567, 163, 187, 315,
     199             :        -1,
     200             :     56, 697, 1849, 585, 557, 529, 413, 385, 989, 817, 1161, 351, 357, 645, -1,
     201             :     60, 945, 721, 561, 1617, 211, 497, 337, 373, 651, 581, 693, 501, 1029, -1,
     202             :     75, 3647, 271, 847, -1,
     203             :     84, 647, 935, 1935, 1295, 1071, 3311, 451, 699, 595, 1333, 469, 1099, 1419,
     204             :         987, 2107, -1,
     205             :     88, 1573, 4773, 1397, 1353, 1309, 953, 909, 2553, 2109, 2997, 865, 1665, -1,
     206             :     90, 1659, 1891, 1371, 3843, 775, 1407, 735, 903, 615, 1575, -1,
     207             :     104, 2143, 6751, 991, 1935, 1883, 1831, 1307, 1255, 3611, 2983, 4239, 731,
     208             :          1203, 2355, -1,
     209             :     105, 1785, 6321, -1,
     210             :     126, 1533, 2037, 3397, 3477, 2749, 7869, 777, 937, 721, 1281, 1425, 2881,
     211             :          1369, 1849, 1201, 3225, -1,
     212             :     132, 4995, 2947, 2595, 8547, 1663, 3441, 2639, 3663, 2463, 5439, -1,
     213             :     136, 3547, 11739, 1499, 3275, 3207, 3139, 2183, 2115, 6279, 5187, 7371,
     214             :          987, 1159, 2047, 4095, -1,
     215             :     140, 4429, 3885, 2989, 9933, 3053, 1613, 1697, 3297, 3569, 2849, 6321, -1,
     216             :       -1};
     217             :       long i;
     218             :       const long *t;
     219       11165 :       for(t=tab;*t!=-1;t++)
     220             :       {
     221       10472 :         if (t[0]==n)
     222             :         {
     223         686 :           for(i=1; t[i] != -1; i++)
     224         686 :             if (t[i]==s) return i;
     225           0 :           return -1;
     226             :         }
     227      143689 :         while (*t>=0) t++;
     228             :       }
     229             :   }
     230             :   {
     231         693 :     const long tab[]={
     232             :       16, 1710031, 550075, 70099, 70075, 870059, 110059, 30079, 30071, 30063,
     233             : 470131, 70155, 70107, 110115, 310307, -1,
     234             :       32, 6830063, 150323, 1830171, /*230171*/0, 230227, 30283, 30251, 30203,
     235             : /*70267*/0, 70219, 110227, /*230171*/0, /*70187*/0, /*70187*/0, 110155,
     236             : 3430123, 430123, 30191, 30175, 30159, 1110387, 150563, 150387, 230323, 230411,
     237             : 230299, 70619, 70467, 70355, /*70379*/0, /*70379*/0, /*70267*/0, 70291, 70555,
     238             : 70331, 1750291, 230291, 430275, 70411, 70363, 70315, 110331, 30371, 30323,
     239             : 950819, 150995, 150643, 230691, 30747, 30635, 632451, -1,
     240             :       48, 430156, 11970124, 10219, 430324, 110324, 30396, 30444, 30348, 230300,
     241             : 110300, 230396, /*70396*/0, /*70396*/0, 70540, 30412, 30364, 30380, 30332,
     242             : 70492, 3850300, 490396, 490300, 6090236, 770236, 210316, 210284, 210252, 30299,
     243             : 30371, 30363, 110299, 70311, 110271, 70588, 230732, 70876, 110636, 30868,
     244             : 30628, 30596, 30644, 150684, 70828, 3290524, 490620, 490428, 770460, 30627,
     245             : 70571, 10643, 151740, 2171228, -1,
     246             :       54, 10256, 16410120, 70292, 610232, 10373, 10292, 10616, 70517, 5610228,
     247             : 210309, 210228, 250448, 70616, 11696, 2370552, -1,
     248             :       /*64*/
     249             :       72, 110307, 26230195, 210272, 30523, 110631, 30739, 70575, 30683,
     250             : 14030351, 1830403, 1830299, 770346, 110586, 10750330, 10620, 210420, 71223,
     251             : 9150663, 30426, 30858, 30978, 30954, 31074, 30762, 210452, 210538, 770634,
     252             : 210730, 490626, 210722, 31018, 111234, 31450, 71106, 31322, 5750594, 750682,
     253             : 750506, 10346, 10826, 10490, 70620, 11124, 10716, 30786, 31746, 210636, 491202,
     254             : 72402, 3751122, -1,
     255             :       80, 430250, 35910186, 110282, 430530, 110530, 30650, 30730, 30570,
     256             : 230482, 110482, 230642, /*70642*/0, /*70642*/0, 70882, 30666, 30586, 30618,
     257             : 30538, 70786, 11550450, 1470594, 1470450, 18270354, 2310354, 630474, 630426,
     258             : 630378, 110562, 30562, 110722, 30722, 70546, 30546, 30946, 70962, 231202,
     259             : 71442, 111042, 31426, 31026, 30978, 31058, 151106, 71346, 9870786, 1470930,
     260             : 1470642, 2310690, 10467, 71266, 152866, 6511842, -1,
     261             :       81,49210121, 6730319, 250427, 250319, 16450238, 610238, 70454, 70346,
     262             : 70400, 70319, 5650670, 250994, 250670, 610589, 2412452, -1,
     263             :       /*96*/
     264             :       100, 30393, 57310217, 10481, 30693, 36470341, 630408, 30968, 13310392,
     265             : 210416, 10576, 11256, 10856, 11096, 630648, 31768, 8470616, -1,
     266             :       108, 30552, 60170280, 610359, 30984, 38290440, 210660, 1830540, 30849,
     267             : 30660, 31308, 211137, 20570532, 770721, 770532, 70769, 11636, 11813, 610647,
     268             : 70647, 250674, 70674, 70890, 211092, 1830852, 31389, 31092, 32388, 211965,
     269             : 13090836, 491133, 490836, 751080, 211416, 33576, 8691288, 70904, 11048, 71720,
     270             : 13688, 12344, 251538, 751608, 212280, 36600, 5532024,-1,
     271             :       112, 430344, 73530248, 430736, 110736, 30904, 31016, 30792, 230664,
     272             : 110664, 230888, 0/*70888*/, 0/*70888*/, 71224, 30920, 30808, 30856, 30744,
     273             : 71080, 23650600, 3010792, 3010600, 37410472, 4730472, 1290632, 1290568,
     274             : 1290504, 71336, 231672, 72008, 111448, 31984, 31424, 31360, 31472, 151528,
     275             : 71864, 20211048, 3011240, 3010856, 4730920, 30643, 153992, 13332456,-1,
     276             :       120, 2310456, 770488, 110648, 63210360, 30763, 210552, 30712, 31256,
     277             : 31240, 31336, 31400, 31496, 31480, 31096, 630498, 210808, 770968, 211128,
     278             : 490904, 211064, 630744, 2310888, 631032, 1470840, 630984, 31128, 111368, 31608,
     279             : 71224, 31464, 33810648, 4410744, 4410552, 11211, 31263, 11416, 210858, 11290,
     280             : 11090, 211032, 31352, 32600, 630738, 491864, 1471704, 72664, 22051224, -1,
     281             :       135, 114870240, 39270456, 1470618, 1470456, 16591104 , -1,
     282             :       -1};
     283             :     long i;
     284             :     const long *t;
     285         693 :     GEN Z = groupelts_center(S), L = group_subgroups(G);
     286         693 :     long scenter = groupelts_sumorders(Z), svecgroup = vecgroup_sumorders(L);
     287         693 :     long u = svecgroup+10000*scenter; /*This is used as a hash value*/
     288             : 
     289        2205 :     for(t=tab; *t!=-1; t++)
     290             :     {
     291        2128 :       if (t[0]==n)
     292             :       {
     293       12789 :         for(i=1; t[i] != -1; i++)
     294       12866 :           if (t[i]==u) return i;
     295         105 :         switch(n)
     296             :         {
     297          98 :         case 32:
     298             :           switch(u)
     299             :           {
     300          42 :           case 230171:
     301             :             {
     302          42 :               const long good[]={2,0}, bad[]={4,5,0};
     303          42 :               return indexgroupcentre(G,Z,good,bad)? 4: 12;
     304             :             }
     305           7 :           case 70267:
     306           7 :             if (s==135) return 9;
     307           7 :             return 32;
     308          35 :           case 70187:
     309             :             {
     310          35 :               const long good[]={8,0}, bad[]={7,9,0};
     311          35 :               return indexgroupcentre(G,Z,good,bad)? 13: 14;
     312             :             }
     313          14 :           case 70379:
     314             :             {
     315          14 :               const long good[]={4,0},bad[]={0};
     316          14 :               return indexgroupsubgroup(L,8,good,bad)? 31: 30;
     317             :             }
     318             :           }
     319           0 :           break;
     320           7 :         case 48: case 80:
     321             :           {
     322           7 :             const long good[]={5,8,0},bad[]={6,7,0};
     323           7 :             return indexgroupcentre(G,Z,good,bad)? 12: 13;
     324             :           }
     325           0 :         case 112:
     326             :           {
     327           0 :             const long good[]={7,4,0},bad[]={5,6,0};
     328           0 :             return indexgroupcentre(G,Z,good,bad)? 11: 12;
     329             :           }
     330             :         }
     331           0 :         return -1;
     332             :       }
     333       45563 :       while (*t!=-1) t++;
     334             :     }
     335             :     {
     336          77 :       const long tab[]={ 64, 1270001, /*4270003*/0, /*4270003*/0, 8190072,
     337             :  6430073, 6670445, 5550446, 8190278, 7070279, 6350071, 5230072, 8110154,
     338             :  /*5870155*/0, /*5870155*/0, /*4270042*/0, /*4270042*/0, 7710246, 7390277,
     339             :  6750037, 8032377, 8670266, 6750397, 11390022, 7710267, 7070277, /*3630046*/0,
     340             :  /*3630046*/0, 3630057, 4830196, 4830207, 4671808, 9070697, 6670700, 8750094,
     341             :  6990091, 6350111, 5870115, 6671599, 5711601, 5551702, 5871512, 6351709,
     342             :  5391711, /*3630046*/0, 3630047, 4111467, /*4430156*/0, /*4430156*/0, 3790166,
     343             :  /*2510026*/0, /*2510026*/0, 4470028, 4150300, 3830030, 13470021, 20350065,
     344             :  10910041, 16514365, /*12190433*/0, 34110271, /*16514475*/0, 15230465,
     345             :  /*10910433*/0, 9630041, 13470233, /*16514475*/0, 20834696, /*10910433*/0,
     346             :  13954343, /*12190433*/0, 19553542, 13474377, 25790466, 15870467, 18914476,
     347             :  14110477, /*14590443*/0, 13310443, 11550043, /*14590443*/0, 10270043, 8990002,
     348             :  8990546, 8990646, 8993647, 8356896, 13310905, 13310915, 12039018, 16990866,
     349             :  12670888, 15071116, 11551217, 12038218, 16031739, 12512740, 12353138, 12993048,
     350             :  15391849, 11872850, 12993551, 12353851, 8991446, 8991447, 8354830, 9951566,
     351             :  9951666, 8674709, 9317039, 8031897, 8030187, 7713641, 7714641, 7074743,
     352             :  9236585, 9236415, 9236586, 10990821, 9879066, 8751833, 9873399, 8751766,
     353             :  10990754, 8593054, 8593087, 6830446, 6833546, 17472434, 13953445, 14432313,
     354             :  16352544, 12833555, 13313423, 15635143, 13234877, 13874853, 12755287, 17870919,
     355             :  14190949, 13075209, 11955310, 10835253, 9715354, 11312124, 10193135, 11074927,
     356             :  12197529, 9957664, 11074970, 12196539, 9956674, 9958907, 10439497, 9479551,
     357             :  9554015, 8433958, 9553915, 8434058, 8918081, 7798421, 10110856, 10110756,
     358             :  9476648, 8991757, 8991857, 8356682, 10994275, 8750435, 8590474, 9230510,
     359             :  10355254, 8115355, 13556790, 15790679, 11310691, 12275539, 14035061, 11795172,
     360             :  8750465, 7474472, 8750475, 8114920, 6110196, 6111806, 5951808, 10191819,
     361             :  9238364, 8271841, 8590736, 9390959, 8432079, 25470255, 41792701, 25470275,
     362             :  20355344, 27233751, 18593673, 19717567, 23394762, 17312707, 19717633, 46115277,
     363             :  31557088, 22917189, 24677288, 24039835, 24676366, 16032362, 17793529, 17153269,
     364             :  38432486, 21153763, 23393635, 16037076, 27710971, 27074338, 20995174, 23396204,
     365             :  20193482, 17157790, 19550231, 14751475, 17153832, 19070249, 16038080, 33391110,
     366             :  25875097, 22197835, 22195018, 21070221, 24590112, 18999456, 15952565, 18356361,
     367             :  17237769, 18359003, 15951169, 14832955, 16110295, 18350268, 21392354, 22030301,
     368             :  18353365, 15955257, 13550032, 18430405, 18434015, 17150260, 17154128, 27234036,
     369             :  23710639, 20194057, 21157900, 24198470, 20679613, 21158141, 22435065, 21318520,
     370             :  20197076, 67390501, 83715011, 51070497, 54590283, 58915129, 50275230, 52035340,
     371             :  263870051, -1,
     372             :       -1};
     373             :       long i;
     374             :       const long *t;
     375          77 :       GEN V=vecgroup_idxlist(L,32);
     376          77 :       long idxlist=vecsmall_pack(V,10,9967);
     377          77 :       long w=10000*svecgroup+idxlist; /*This is used as a hash value*/
     378          84 :       for(t=tab; *t!=-1; t++)
     379             :       {
     380          77 :         if (t[0]==n)
     381             :         {
     382       18760 :           for(i=1; t[i] != -1; i++)
     383       18760 :             if (t[i]==w) return i;
     384          70 :           switch(n)
     385             :           {
     386          70 :           case 64:
     387             :             switch(w)
     388             :             {
     389           7 :             case 4270003:
     390           7 :               return (scenter==439)? 2: 3;
     391           7 :             case 5870155:
     392             :               {
     393           7 :                 const long good[]={8,9,0},bad[]={7,0};
     394           7 :                 return indexgroupcentre(G,Z,good,bad)? 13: 14;
     395             :               }
     396           7 :             case 4270042:
     397             :               {
     398           7 :                 const long good[]={13,0},bad[]={14,0};
     399           7 :                 return indexgroupcentre(G,Z,good,bad)? 15: 16;
     400             :               }
     401           7 :             case 4430156:
     402             :               {
     403           7 :                 const long good[]={18,20,0},bad[]={19,0};
     404           7 :                 return indexgroupcentre(G,Z,good,bad)? 47: 48;
     405             :               }
     406           7 :             case 2510026:
     407           7 :               return scenter==1367? 50: 51;
     408           7 :             case 12190433:
     409           7 :               return scenter==47? 59: 70;
     410           7 :             case 16514475:
     411             :               {
     412           7 :                 const long good[]={22,24,28,0},bad[]={23,25,27,30,0};
     413           7 :                 return indexgroupcentre(G,Z,good,bad)? 61: 66;
     414             :               }
     415           7 :             case 10910433:
     416             :               {
     417           7 :                 const long good[]={23,31,0},bad[]={25,26,29,30,33,0};
     418           7 :                 return indexgroupcentre(G,Z,good,bad)? 63: 68;
     419             :               }
     420           7 :             case 14590443:
     421             :               {
     422           7 :                 const long good[]={28,33,0},bad[]={30,34,0};
     423           7 :                 return indexgroupcentre(G,Z,good,bad)? 77: 80;
     424             :               }
     425           7 :             case 3630046:
     426             :               {
     427           7 :                 const long good[]={3,0},bad[]={12,16,0};
     428           7 :                 if (scenter==695) return 26;
     429           7 :                 return indexgroupcentre(G,Z,good,bad)? 27: 44;
     430             :               }
     431             :             }
     432           0 :             break;
     433             :           }
     434           0 :           return -1;
     435             :         }
     436        1883 :         while (*t!=-1) t++;
     437             :       }
     438             :     }
     439             :     {
     440           7 :       const long tab[]={ 96, 316010002, 252010002, 707020000, 676160124,
     441             :     676170124, 87180027, 988190278, 892200028, 876030110, 876040110, 876120110,
     442             :     215111237, 503062153, 972141052, 972131052, 455091156, 167101154, 620160033,
     443             :     620170033, 908031033, 908121033, 908041033, 199101564, 7130153, 7140153,
     444             :     812150123, 247051165, 487091566, 812151024, 391071276, 103081274, 247111377,
     445             :     988180195, 892190205, 924190197, 828200207, 103050134, 679020464, 295091075,
     446             :     199070145, 391060235, 103101076, 7080146, 135111157, 295020044, 684030223,
     447             :     684040223, 908050274, 135060255, 7070285, 812080286, 71092475, 876102476,
     448             :     908112287, 684120223, 748130243, 748140243, 620150254, 492160043, 492170043,
     449             :     764180045, 700190477, 636200047, 963110003, 779050031, 935100032, 799110033,
     450             :     819210003, 791260032, 246270050, 723330003, 987340003, 651360031, 623380033,
     451             :     647263930, 839351534, 455321350, 178211335, 791244031, 322256848, 189340236,
     452             :     130316409, 599331360, 743244548, 935295937, 551333907, 189222029, 274255883,
     453             :     525275609, 82306043, 610289391, 82315641, 82307025, 647262487, 839353950,
     454             :     0/*455322385*/, 0/*455322385*/, 178233588, 791245051, 322256982, 130307015,
     455             :     658286619, 983297004, 983297037, 599333858, 631365165, 631376165, 535386399,
     456             :     66408676, 354390966, 871428265, 775411064, 631376407, 535386309, 114430028,
     457             :     823441008, 314398920, 74437993, 831420054, 42405827, 90439425, 799440830,
     458             :     847426805, 767410275, 815440314, 863429143, 487360134, 487371044, 66211564,
     459             :     66231664, 871295713, 66231764, 679242567, 125228724, 210253894, 18306803,
     460             :     546288536, 162390938, 919437378, 871401018, 162255761, 967304398, 967313318,
     461             :     413274329, 498283470, 498288163, 29345108, 967401139, 727449579, 679411219,
     462             :     775352619, 583261276, 919295225, 66312839, 423381047, 2437470, 759424560,
     463             :     711448550, 770222372, 109272382, 551210244, 258222592, 551230264, 295242430,
     464             :     647254411, 199262266, 482272602, 871283751, 423293752, 519303751, 519312662,
     465             :     71320222, 167332232, 226340245, 327352266, 167360274, 167372584, 103382587,
     466             :     647392595, 455406162, 263412616, 327428742, 487438955, 295440098, 358290331,
     467             :     622253358, 886280358, 322410312, 754400322, 394443122, 282440313, 354423123,
     468             :     522430323, 726220349, 990273529, 470450359, 742460359, 522470032, 198470031,
     469             :     282480353, 290490033, 274500353, 414470000, 614490000, 605473864, 664459790,
     470             :     723464091, 893482714, 675465704, 845486215, 184493728, 653478045, 941489155,
     471             :     605501588, 925482982, 264492577, 589502601, 312450472, 371466994, 285450492,
     472             :     989464902, 578470486, 770489139, 994490497, 546500507, 604460529, 65270050,
     473             :     684510049, 468510050, 134510562, 831510052, -1
     474             :         -1};
     475             :       long i;
     476             :       const long *t;
     477           7 :       GEN V=vecgroup_idxlist(L,48);
     478           7 :       long idx48=vecsmall_pack(V,10,9967);
     479           7 :       long idx32=vecgroup_idxlist(L,32)[1];
     480           7 :       long w=1000000*(svecgroup%997)+10000*idx32+idx48;
     481             :       /*This is used as a hash value*/
     482           7 :       for(t=tab; *t!=-1; t++)
     483             :       {
     484           7 :         if (t[0]==n)
     485             :         {
     486        1127 :           for(i=1; t[i] != -1; i++)
     487        1127 :             if (t[i]==w) return i;
     488           0 :           switch(n)
     489             :           {
     490           0 :           case 96:
     491             :             switch(w)
     492             :             {
     493           0 :             case 455322385:
     494             :               {
     495           0 :                 const long good[]={37,40,0},bad[]={34,41,0};
     496           0 :                 return indexgroupcentre(G,Z,good,bad)? 96: 97;
     497             :               }
     498             :             }
     499           0 :             break;
     500             :           }
     501           0 :           return -1;
     502             :         }
     503           0 :         while (*t!=-1) t++;
     504             :       }
     505             :     }
     506             :   }
     507           0 :   return 0;
     508             : }
     509             : 
     510             : long
     511        1260 : group_ident(GEN G, GEN S)
     512             : {
     513        1260 :   pari_sp av = avma;
     514        1260 :   long idx = group_ident_i(G, S);
     515        1260 :   if (idx < 0) pari_err_TYPE("group_ident [not a group]", G);
     516        1260 :   if (!idx) pari_err_IMPL("galoisidentify for groups of order > 127");
     517        1260 :   return gc_long(av, idx);
     518             : }
     519             : 
     520             : long
     521           0 : group_ident_trans(GEN G, GEN S)
     522             : {
     523           0 :   const long tab[]={
     524             :         4, 1, 2, -1,
     525             :         6, 2, 1, -1,
     526             :         8, 1, 2, 4, 5, 3, -1,
     527             :         9, 1, 2, -1,
     528             :         10, 2, 1, -1,
     529             :         12, 5, 1, 4, 3, 2, -1,
     530             :         14, 2, 1, -1,
     531             :         15, 1, -1,
     532             :         16, 1, 4, 10, 8, 5, 6, 13, 12, 14, 2, 9, 7, 11, 3, -1,
     533             :         18, 5, 1, 3, 4, 2, -1,
     534             :         20, 2, 1, 5, 4, 3, -1,
     535             :         21, 2, 1, -1,
     536             :         22, 2, 1, -1,
     537             :         24, 8, 1, 7, 5, 12, 13, 6, 14, 2, 15, 4, 10, 9, 11, 3, -1,
     538             :         25, 1, 2, -1,
     539             :         26, 2, 1, -1,
     540             :         27, 1, 2, 3, 5, 4, -1,
     541             :         28, 3, 1, 4, 2, -1,
     542             :         30, 2, 4, 3, 1, -1,
     543             :         -1};
     544           0 :   long n = group_order(G), s;
     545             :   const long *t;
     546           0 :   if (n == 1) return 1;
     547             :   /* N.B. known up to 32 (Cannon-Holt) */
     548           0 :   if (n > 30) pari_err_IMPL("group_ident_trans [n > 30]");
     549           0 :   if (uisprime(n)) return 1;
     550           0 :   s = group_ident(G,S);
     551           0 :   for(t=tab;*t>=0;t++)
     552             :   {
     553           0 :     if (t[0]==n) return t[s];
     554           0 :     while (*t>=0) t++;
     555             :   }
     556             :   return 0; /*LCOV_EXCL_LINE*/
     557             : }

Generated by: LCOV version 1.13