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-bordeaux1.fr machine (x86_64 architecture), and agregate them in the final report:

The target is 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.8.0 lcov report (development 16741-1378b1c) Lines: 168 196 85.7 %
Date: 2014-08-17 Functions: 7 8 87.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 161 241 66.8 %

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

Generated by: LCOV version 1.9