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 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 - basemath - gen2.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 19043-64ae2d8) Lines: 1322 1500 88.1 %
Date: 2016-06-25 Functions: 133 144 92.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 1118 1421 78.7 %

           Branch data     Line data    Source code
       1                 :            : /* Copyright (C) 2000  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                 :            : /********************************************************************/
      15                 :            : /**                                                                **/
      16                 :            : /**                      GENERIC OPERATIONS                        **/
      17                 :            : /**                        (second part)                           **/
      18                 :            : /**                                                                **/
      19                 :            : /********************************************************************/
      20                 :            : #include "pari.h"
      21                 :            : #include "paripriv.h"
      22                 :            : 
      23                 :            : /*********************************************************************/
      24                 :            : /**                                                                 **/
      25                 :            : /**                MAP FUNCTIONS WITH GIVEN PROTOTYPES              **/
      26                 :            : /**                                                                 **/
      27                 :            : /*********************************************************************/
      28                 :            : GEN
      29                 :        182 : map_proto_G(GEN (*f)(GEN), GEN x)
      30                 :            : {
      31         [ +  + ]:        182 :   if (is_matvec_t(typ(x)))
      32                 :            :   {
      33                 :            :     long lx, i;
      34                 :          7 :     GEN y = cgetg_copy(x, &lx);
      35         [ +  + ]:         28 :     for (i=1; i<lx; i++) gel(y,i) = map_proto_G(f, gel(x,i));
      36                 :          7 :     return y;
      37                 :            :   }
      38                 :        182 :   return f(x);
      39                 :            : }
      40                 :            : 
      41                 :            : GEN
      42                 :    3447403 : map_proto_lG(long (*f)(GEN), GEN x)
      43                 :            : {
      44         [ +  + ]:    3447403 :   if (is_matvec_t(typ(x)))
      45                 :            :   {
      46                 :            :     long lx, i;
      47                 :         14 :     GEN y = cgetg_copy(x, &lx);
      48         [ +  + ]:         56 :     for (i=1; i<lx; i++) gel(y,i) = map_proto_lG(f, gel(x,i));
      49                 :         14 :     return y;
      50                 :            :   }
      51                 :    3552830 :   return stoi(f(x));
      52                 :            : }
      53                 :            : 
      54                 :            : GEN
      55                 :        126 : map_proto_lGL(long (*f)(GEN,long), GEN x, long y)
      56                 :            : {
      57         [ +  + ]:        126 :   if (is_matvec_t(typ(x)))
      58                 :            :   {
      59                 :            :     long l, i;
      60                 :          7 :     GEN t = cgetg_copy(x, &l);
      61         [ +  + ]:         35 :     for (i=1; i<l; i++) gel(t,i) = map_proto_lGL(f,gel(x,i),y);
      62                 :          7 :     return t;
      63                 :            :   }
      64                 :        126 :   return stoi(f(x,y));
      65                 :            : }
      66                 :            : 
      67                 :            : static GEN
      68                 :      74779 : _domul(void *data, GEN x, GEN y)
      69                 :            : {
      70                 :      74779 :   GEN (*mul)(GEN,GEN)=(GEN (*)(GEN,GEN)) data;
      71                 :      74779 :   return mul(x,y);
      72                 :            : }
      73                 :            : 
      74                 :            : GEN
      75                 :     104473 : gassoc_proto(GEN (*f)(GEN,GEN), GEN x, GEN y)
      76                 :            : {
      77         [ +  + ]:     104473 :   if (!y)
      78                 :            :   {
      79                 :     101666 :     pari_sp av = avma;
      80      [ +  +  + ]:     101666 :     switch(typ(x))
      81                 :            :     {
      82                 :            :       case t_LIST:
      83         [ +  + ]:         21 :         x = list_data(x); if (!x) return gen_1;
      84                 :            :       case t_VEC:
      85                 :     101652 :       case t_COL: break;
      86                 :          7 :       default: pari_err_TYPE("association",x);
      87                 :            :     }
      88                 :     101652 :     return gerepileupto(av, gen_product(x, (void *)f, _domul));
      89                 :            : 
      90                 :            :   }
      91                 :     104466 :   return f(x,y);
      92                 :            : }
      93                 :            : /*******************************************************************/
      94                 :            : /*                                                                 */
      95                 :            : /*                    CREATION OF A P-ADIC GEN                     */
      96                 :            : /*                                                                 */
      97                 :            : /*******************************************************************/
      98                 :            : GEN
      99                 :    1015392 : cgetp(GEN x)
     100                 :            : {
     101                 :    1015392 :   GEN y = cgetg(5,t_PADIC);
     102                 :    1015392 :   y[1] = (x[1]&PRECPBITS) | _evalvalp(0);
     103                 :    1015392 :   gel(y,2) = icopy(gel(x,2));
     104                 :    1015394 :   gel(y,3) = icopy(gel(x,3));
     105                 :    1015395 :   gel(y,4) = cgeti(lgefint(gel(x,3))); return y;
     106                 :            : }
     107                 :            : 
     108                 :            : /*******************************************************************/
     109                 :            : /*                                                                 */
     110                 :            : /*                            SIZES                                */
     111                 :            : /*                                                                 */
     112                 :            : /*******************************************************************/
     113                 :            : 
     114                 :            : long
     115                 :    4080694 : glength(GEN x)
     116                 :            : {
     117                 :    4080694 :   long tx = typ(x);
     118   [ +  +  +  +  :    4080694 :   switch(tx)
                   +  + ]
     119                 :            :   {
     120                 :         84 :     case t_INT:  return lgefint(x)-2;
     121                 :            :     case t_LIST: {
     122                 :         21 :       GEN L = list_data(x);
     123         [ +  + ]:         21 :       return L? lg(L)-1: 0;
     124                 :            :     }
     125         [ +  + ]:         14 :     case t_REAL: return signe(x)? lg(x)-2: 0;
     126                 :          7 :     case t_STR:  return strlen( GSTR(x) );
     127                 :        982 :     case t_VECSMALL: return lg(x)-1;
     128                 :            :   }
     129                 :    4080694 :   return lg(x) - lontyp[tx];
     130                 :            : }
     131                 :            : 
     132                 :            : GEN
     133                 :        112 : matsize(GEN x)
     134                 :            : {
     135                 :        112 :   long L = lg(x) - 1;
     136   [ +  +  +  + ]:        112 :   switch(typ(x))
     137                 :            :   {
     138                 :          7 :     case t_VEC: return mkvec2s(1, L);
     139                 :          7 :     case t_COL: return mkvec2s(L, 1);
     140         [ +  + ]:         91 :     case t_MAT: return mkvec2s(L? nbrows(x): 0, L);
     141                 :            :   }
     142                 :          7 :   pari_err_TYPE("matsize",x);
     143                 :        105 :   return NULL; /* not reached */
     144                 :            : }
     145                 :            : 
     146                 :            : /*******************************************************************/
     147                 :            : /*                                                                 */
     148                 :            : /*                  Conversion t_POL --> t_SER                     */
     149                 :            : /*                                                                 */
     150                 :            : /*******************************************************************/
     151                 :            : static GEN
     152                 :    1182851 : greffe_aux(GEN x, long l, long lx, long v)
     153                 :            : {
     154                 :    1182851 :   GEN y = cgetg(l,t_SER);
     155                 :            :   long i;
     156         [ -  + ]:    1182851 :   if (l <= 2) pari_err_BUG("RgX_to_ser (l <= 2)");
     157                 :    1182851 :   y[1] = x[1]; setvalp(y, v);
     158                 :    1182851 :   x += v; lx -= v;
     159         [ +  + ]:    1182851 :   if (lx > l) {
     160         [ +  + ]:     537695 :     for (i = 2; i < l; i++) gel(y,i) = gel(x,i);
     161                 :            :   } else {
     162         [ +  + ]:    3815999 :     for (i = 2; i <lx; i++) gel(y,i) = gel(x,i);
     163         [ +  + ]:    3831784 :     for (     ; i < l; i++) gel(y,i) = gen_0;
     164                 :            :   }
     165                 :    1182851 :   return normalize(y);
     166                 :            : }
     167                 :            : /* enlarge/truncate t_POL x to a t_SER with lg l */
     168                 :            : GEN
     169                 :     842846 : RgX_to_ser(GEN x, long l)
     170                 :            : {
     171         [ +  + ]:     842846 :   if (lg(x) == 2) return zeroser(varn(x), l-2);
     172                 :     842846 :   return greffe_aux(x, l, lg(x), RgX_val(x));
     173                 :            : }
     174                 :            : GEN
     175                 :     340089 : RgX_to_ser_inexact(GEN x, long l)
     176                 :            : {
     177                 :     340089 :   long i, lx = lg(x);
     178                 :     340089 :   int first = 1;
     179                 :            :   /* analogous to RgX_valrem + normalize */
     180         [ -  + ]:     340089 :   if (lx == 2) return zeroser(varn(x), l-2);
     181                 :     340089 :   i = 2;
     182 [ +  - ][ +  + ]:     345465 :   while (i<lx && gequal0(gel(x,i))) {
     183 [ +  - ][ +  + ]:       5376 :     if (first && !isexactzero(gel(x,i)))
     184                 :            :     {
     185                 :          7 :       pari_warn(warner,"normalizing a series with 0 leading term");
     186                 :          7 :       first = 0;
     187                 :            :     }
     188                 :       5376 :     i++;
     189                 :            :   }
     190                 :     340089 :   return greffe_aux(x, l, lx, i - 2);
     191                 :            : }
     192                 :            : GEN
     193                 :        133 : rfrac_to_ser(GEN x, long l)
     194                 :            : {
     195                 :        133 :   return gdiv(gel(x,1), RgX_to_ser(gel(x,2), l));
     196                 :            : }
     197                 :            : /*******************************************************************/
     198                 :            : /*                                                                 */
     199                 :            : /*                 CONVERSION GEN --> long                         */
     200                 :            : /*                                                                 */
     201                 :            : /*******************************************************************/
     202                 :            : 
     203                 :            : long
     204                 :         77 : gtolong(GEN x)
     205                 :            : {
     206   [ +  +  +  +  :         77 :   switch(typ(x))
                   +  + ]
     207                 :            :   {
     208                 :            :     case t_INT:
     209                 :         42 :       return itos(x);
     210                 :            :     case t_REAL:
     211                 :          7 :       return (long)(rtodbl(x) + 0.5);
     212                 :            :     case t_FRAC: {
     213                 :          7 :       pari_sp av = avma;
     214                 :          7 :       long y = itos(ground(x));
     215                 :          7 :       avma = av; return y;
     216                 :            :     }
     217                 :            :     case t_COMPLEX:
     218         [ +  - ]:          7 :       if (gequal0(gel(x,2))) return gtolong(gel(x,1)); break;
     219                 :            :     case t_QUAD:
     220         [ +  - ]:          7 :       if (gequal0(gel(x,3))) return gtolong(gel(x,2)); break;
     221                 :            :   }
     222                 :          7 :   pari_err_TYPE("gtolong",x);
     223                 :         70 :   return 0; /* not reached */
     224                 :            : }
     225                 :            : 
     226                 :            : /*******************************************************************/
     227                 :            : /*                                                                 */
     228                 :            : /*                         COMPARISONS                             */
     229                 :            : /*                                                                 */
     230                 :            : /*******************************************************************/
     231                 :            : int
     232                 :  198089640 : isexactzero(GEN g)
     233                 :            : {
     234                 :            :   long i, lx;
     235   [ +  +  +  +  :  198089640 :   switch (typ(g))
          +  +  +  +  +  
                      + ]
     236                 :            :   {
     237                 :            :     case t_INT:
     238                 :  149660647 :       return !signe(g);
     239                 :            :     case t_INTMOD:
     240                 :     778343 :       return !signe(gel(g,2));
     241                 :            :     case t_COMPLEX:
     242 [ +  + ][ +  + ]:    1341143 :       return isexactzero(gel(g,1)) && isexactzero(gel(g,2));
     243                 :            :     case t_FFELT:
     244                 :    8045379 :       return FF_equal0(g);
     245                 :            :     case t_QUAD:
     246 [ +  + ][ +  + ]:        497 :       return isexactzero(gel(g,2)) && isexactzero(gel(g,3));
     247                 :            :     case t_POLMOD:
     248                 :      60867 :       return isexactzero(gel(g,2));
     249                 :            :     case t_POL:
     250                 :   28382816 :       lx = lg(g); /* cater for Mod(0,2)*x^0 */
     251 [ +  + ][ +  + ]:   28382816 :       return lx == 2 || (lx == 3 && isexactzero(gel(g,2)));
                 [ +  + ]
     252                 :            :     case t_RFRAC:
     253                 :     458193 :       return isexactzero(gel(g,1)); /* may occur: Mod(0,2)/x */
     254                 :            :     case t_VEC: case t_COL: case t_MAT:
     255         [ +  + ]:         98 :       for (i=lg(g)-1; i; i--)
     256         [ +  + ]:         84 :         if (!isexactzero(gel(g,i))) return 0;
     257                 :         14 :       return 1;
     258                 :            :   }
     259                 :  198089640 :   return 0;
     260                 :            : }
     261                 :            : 
     262                 :            : int
     263                 :  319740119 : isrationalzero(GEN g)
     264                 :            : {
     265                 :            :   long i;
     266   [ +  +  +  +  :  319740119 :   switch (typ(g))
                +  -  + ]
     267                 :            :   {
     268                 :            :     case t_INT:
     269                 :  211817971 :       return !signe(g);
     270                 :            :     case t_COMPLEX:
     271 [ +  + ][ +  + ]:    2620670 :       return isintzero(gel(g,1)) && isintzero(gel(g,2));
     272                 :            :     case t_QUAD:
     273 [ +  + ][ +  + ]:       1659 :       return isintzero(gel(g,2)) && isintzero(gel(g,3));
     274                 :            :     case t_POLMOD:
     275                 :     565894 :       return isrationalzero(gel(g,2));
     276                 :   62549951 :     case t_POL: return lg(g) == 2;
     277                 :            :     case t_VEC: case t_COL: case t_MAT:
     278         [ #  # ]:          0 :       for (i=lg(g)-1; i; i--)
     279         [ #  # ]:          0 :         if (!isrationalzero(gel(g,i))) return 0;
     280                 :          0 :       return 1;
     281                 :            :   }
     282                 :  319740119 :   return 0;
     283                 :            : }
     284                 :            : 
     285                 :            : int
     286                 :  398180404 : gequal0(GEN x)
     287                 :            : {
     288   [ +  +  +  +  :  398180404 :   switch(typ(x))
          +  +  +  +  +  
                      + ]
     289                 :            :   {
     290                 :            :     case t_INT: case t_REAL: case t_POL: case t_SER:
     291                 :  374917412 :       return !signe(x);
     292                 :            : 
     293                 :            :     case t_INTMOD:
     294                 :    1312446 :       return !signe(gel(x,2));
     295                 :            : 
     296                 :            :     case t_FFELT:
     297                 :     692188 :       return FF_equal0(x);
     298                 :            : 
     299                 :            :     case t_COMPLEX:
     300                 :            :      /* is 0 iff norm(x) would be 0 (can happen with Re(x) and Im(x) != 0
     301                 :            :       * only if Re(x) and Im(x) are of type t_REAL). See mp.c:addrr().
     302                 :            :       */
     303         [ +  + ]:    4786889 :       if (gequal0(gel(x,1)))
     304                 :            :       {
     305         [ +  + ]:     252807 :         if (gequal0(gel(x,2))) return 1;
     306 [ +  + ][ -  + ]:     149850 :         if (typ(gel(x,1))!=t_REAL || typ(gel(x,2))!=t_REAL) return 0;
     307                 :      15741 :         return (expo(gel(x,1))>=expo(gel(x,2)));
     308                 :            :       }
     309         [ +  + ]:    4534082 :       if (gequal0(gel(x,2)))
     310                 :            :       {
     311 [ +  + ][ -  + ]:     147690 :         if (typ(gel(x,1))!=t_REAL || typ(gel(x,2))!=t_REAL) return 0;
     312                 :      94682 :         return (expo(gel(x,2))>=expo(gel(x,1)));
     313                 :            :       }
     314                 :    4386392 :       return 0;
     315                 :            : 
     316                 :            :     case t_PADIC:
     317                 :      45688 :       return !signe(gel(x,4));
     318                 :            : 
     319                 :            :     case t_QUAD:
     320 [ +  + ][ +  + ]:       1281 :       return gequal0(gel(x,2)) && gequal0(gel(x,3));
     321                 :            : 
     322                 :            :     case t_POLMOD:
     323                 :     533694 :       return gequal0(gel(x,2));
     324                 :            : 
     325                 :            :     case t_RFRAC:
     326                 :    5999403 :       return gequal0(gel(x,1));
     327                 :            : 
     328                 :            :     case t_VEC: case t_COL: case t_MAT:
     329                 :            :     {
     330                 :            :       long i;
     331         [ +  + ]:    7222270 :       for (i=lg(x)-1; i; i--)
     332         [ +  + ]:    6449261 :         if (!gequal0(gel(x,i))) return 0;
     333                 :     773009 :       return 1;
     334                 :            :     }
     335                 :            :   }
     336                 :  398180404 :   return 0;
     337                 :            : }
     338                 :            : 
     339                 :            : /* x a t_POL or t_SER, considered as having valuation v; let X(t) = t^(-v) x(t)
     340                 :            :  * return 1 (true) if coeff(X,i) = 0 for all i != 0 and test(coeff(X, 0))
     341                 :            :  * is true. Return 0 (false) otherwise, or if x == 0 */
     342                 :            : static int
     343                 :   13073477 : is_monomial_test(GEN x, long v, int(*test)(GEN))
     344                 :            : {
     345                 :            :   long d, i, l;
     346 [ +  + ][ +  + ]:   13073477 :   if (!signe(x)) return (typ(x) == t_SER && v <= 0);
                 [ +  + ]
     347         [ +  + ]:   13007265 :   if (v > 0) return 0;
     348                 :   13007251 :   l = lg(x); d = 2-v;
     349         [ -  + ]:   13007251 :   if (l <= d) return 0;
     350                 :            :   /* 2 <= d < l */
     351         [ +  + ]:   13007251 :   if (!test(gel(x,d))) return 0;
     352         [ +  + ]:    4006936 :   for (i = 2; i < d; i++)
     353         [ -  + ]:         14 :     if (!gequal0(gel(x,i))) return 0;
     354         [ +  + ]:    4631450 :   for (i = d+1; i < l; i++)
     355         [ +  + ]:    2185246 :     if (!gequal0(gel(x,i))) return 0;
     356                 :   13073477 :   return 1;
     357                 :            : }
     358                 :            : static int
     359                 :         84 : col_test(GEN x, int(*test)(GEN))
     360                 :            : {
     361                 :         84 :   long i, l = lg(x);
     362 [ +  + ][ +  + ]:         84 :   if (l == 1 || !test(gel(x,1))) return 0;
     363         [ +  + ]:         42 :   for (i = 2; i < l; i++)
     364         [ +  + ]:         21 :     if (!gequal0(gel(x,i))) return 0;
     365                 :         84 :   return 1;
     366                 :            : }
     367                 :            : static int
     368                 :         98 : mat_test(GEN x, int(*test)(GEN))
     369                 :            : {
     370                 :         98 :   long i, j, l = lg(x);
     371         [ +  + ]:         98 :   if (l == 1) return 1;
     372         [ -  + ]:         84 :   if (l != lgcols(x)) return 0;
     373         [ +  + ]:        126 :   for (i = 1; i < l; i++)
     374         [ +  + ]:        196 :     for (j = 1; j < l; j++)
     375         [ +  + ]:        154 :       if (i == j) {
     376         [ +  + ]:        105 :         if (!test(gcoeff(x,i,i))) return 0;
     377                 :            :       } else {
     378         [ +  + ]:         49 :         if (!gequal0(gcoeff(x,i,j))) return 0;
     379                 :            :       }
     380                 :         98 :   return 1;
     381                 :            : }
     382                 :            : 
     383                 :            : /* returns 1 whenever x = 1, and 0 otherwise */
     384                 :            : int
     385                 :  143538358 : gequal1(GEN x)
     386                 :            : {
     387   [ +  +  +  +  :  143538358 :   switch(typ(x))
          +  +  +  +  +  
          +  +  +  +  +  
                      + ]
     388                 :            :   {
     389                 :            :     case t_INT:
     390                 :  128190594 :       return equali1(x);
     391                 :            : 
     392                 :            :     case t_REAL:
     393                 :            :     {
     394                 :     784276 :       long s = signe(x);
     395         [ +  + ]:     784276 :       if (!s) return expo(x) >= 0;
     396         [ +  + ]:     784227 :       return s > 0 ? absrnz_equal1(x): 0;
     397                 :            :     }
     398                 :            :     case t_INTMOD:
     399 [ +  + ][ +  + ]:        714 :       return is_pm1(gel(x,2)) || is_pm1(gel(x,1));
     400                 :            :     case t_POLMOD:
     401 [ +  + ][ +  + ]:     297824 :       return gequal1(gel(x,2)) || gequal1(gel(x,1));
     402                 :            : 
     403                 :            :     case t_FFELT:
     404                 :       4690 :       return FF_equal1(x);
     405                 :            : 
     406                 :            :     case t_FRAC:
     407                 :      93096 :       return 0;
     408                 :            : 
     409                 :            :     case t_COMPLEX:
     410 [ +  + ][ -  + ]:      63616 :       return gequal1(gel(x,1)) && gequal0(gel(x,2));
     411                 :            : 
     412                 :            :     case t_PADIC:
     413 [ +  + ][ +  + ]:        133 :       return !valp(x) && gequal1(gel(x,4));
     414                 :            : 
     415                 :            :     case t_QUAD:
     416 [ -  + ][ #  # ]:         35 :       return gequal1(gel(x,2)) && gequal0(gel(x,3));
     417                 :            : 
     418                 :   13071440 :     case t_POL: return is_monomial_test(x, 0, &gequal1);
     419                 :         84 :     case t_SER: return is_monomial_test(x, valp(x), &gequal1);
     420                 :            : 
     421                 :    1031751 :     case t_RFRAC: return gequal(gel(x,1), gel(x,2));
     422                 :         42 :     case t_COL: return col_test(x, &gequal1);
     423                 :         49 :     case t_MAT: return mat_test(x, &gequal1);
     424                 :            :   }
     425                 :  143538355 :   return 0;
     426                 :            : }
     427                 :            : 
     428                 :            : /* returns 1 whenever the x = -1, 0 otherwise */
     429                 :            : int
     430                 :    1175273 : gequalm1(GEN x)
     431                 :            : {
     432                 :            :   pari_sp av;
     433                 :            :   long y;
     434                 :            :   GEN p1;
     435                 :            : 
     436   [ +  +  +  +  :    1175273 :   switch(typ(x))
          +  +  +  +  +  
          +  +  +  +  +  
                      + ]
     437                 :            :   {
     438                 :            :     case t_INT:
     439                 :     336915 :       return equalim1(x);
     440                 :            : 
     441                 :            :     case t_REAL:
     442                 :            :     {
     443                 :     779145 :       long s = signe(x);
     444         [ -  + ]:     779145 :       if (!s) return expo(x) >= 0;
     445         [ +  + ]:     779145 :       return s < 0 ? absrnz_equal1(x): 0;
     446                 :            :     }
     447                 :            :     case t_INTMOD:
     448                 :         21 :       av=avma; y=equalii(addsi(1,gel(x,2)), gel(x,1)); avma=av; return y;
     449                 :            : 
     450                 :            :     case t_FRAC:
     451                 :         14 :       return 0;
     452                 :            : 
     453                 :            :     case t_FFELT:
     454                 :         42 :       return FF_equalm1(x);
     455                 :            : 
     456                 :            :     case t_COMPLEX:
     457 [ -  + ][ #  # ]:      57008 :       return gequalm1(gel(x,1)) && gequal0(gel(x,2));
     458                 :            : 
     459                 :            :     case t_QUAD:
     460 [ -  + ][ #  # ]:          7 :       return gequalm1(gel(x,2)) && gequal0(gel(x,3));
     461                 :            : 
     462                 :            :     case t_PADIC:
     463                 :          7 :       av=avma; y=equalii(addsi(1,gel(x,4)), gel(x,3)); avma=av; return y;
     464                 :            : 
     465                 :            :     case t_POLMOD:
     466                 :         35 :       av=avma; p1 = gaddgs(gel(x,2), 1);
     467 [ +  - ][ +  + ]:         35 :       y = gequal0(p1) || gequal(p1,gel(x,1)); avma=av; return y;
     468                 :            : 
     469                 :       1876 :     case t_POL: return is_monomial_test(x, 0, &gequalm1);
     470                 :         77 :     case t_SER: return is_monomial_test(x, valp(x), &gequalm1);
     471                 :            : 
     472                 :            :     case t_RFRAC:
     473                 :         21 :       av=avma; y=gequal(gel(x,1), gneg_i(gel(x,2))); avma=av; return y;
     474                 :         42 :     case t_COL: return col_test(x, &gequalm1);
     475                 :         49 :     case t_MAT: return mat_test(x, &gequalm1);
     476                 :            :   }
     477                 :    1175273 :   return 0;
     478                 :            : }
     479                 :            : 
     480                 :            : int
     481         [ +  + ]:     334014 : gequalX(GEN x) { return typ(x) == t_POL && lg(x) == 4
     482 [ +  + ][ +  + ]:     334014 :                       && isintzero(gel(x,2)) && isint1(gel(x,3)); }
                 [ +  + ]
     483                 :            : 
     484                 :            : static int
     485                 :        476 : cmp_str(const char *x, const char *y)
     486                 :            : {
     487                 :        476 :   int f = strcmp(x, y);
     488                 :        476 :   return f > 0? 1
     489 [ +  + ][ +  + ]:        476 :               : f? -1: 0;
     490                 :            : }
     491                 :            : 
     492                 :            : static int
     493                 :   25921700 : cmp_universal_rec(GEN x, GEN y, long i0)
     494                 :            : {
     495                 :   25921700 :   long i, lx = lg(x), ly = lg(y);
     496         [ -  + ]:   25921700 :   if (lx < ly) return -1;
     497         [ -  + ]:   25921700 :   if (lx > ly) return 1;
     498         [ +  + ]:   38809386 :   for (i = i0; i < lx; i++)
     499                 :            :   {
     500                 :   33182534 :     int f = cmp_universal(gel(x,i), gel(y,i));
     501         [ +  + ]:   33182534 :     if (f) return f;
     502                 :            :   }
     503                 :   25921700 :   return 0;
     504                 :            : }
     505                 :            : /* Universal "meaningless" comparison function. Transitive, returns 0 iff
     506                 :            :  * gidentical(x,y) */
     507                 :            : int
     508                 :   46114474 : cmp_universal(GEN x, GEN y)
     509                 :            : {
     510                 :   46114474 :   long lx, ly, i, tx = typ(x), ty = typ(y);
     511                 :            : 
     512         [ +  + ]:   46114474 :   if (tx < ty) return -1;
     513         [ +  + ]:   46110673 :   if (ty < tx) return 1;
     514   [ +  +  +  +  :   46109574 :   switch(tx)
                   +  + ]
     515                 :            :   {
     516                 :   18680865 :     case t_INT: return cmpii(x,y);
     517                 :        455 :     case t_STR: return cmp_str(GSTR(x),GSTR(y));
     518                 :            :     case t_REAL:
     519                 :            :     case t_VECSMALL:
     520                 :    1506526 :       lx = lg(x);
     521                 :    1506526 :       ly = lg(y);
     522         [ +  + ]:    1506526 :       if (lx < ly) return -1;
     523         [ +  + ]:    1455097 :       if (lx > ly) return 1;
     524         [ +  + ]:    6383196 :       for (i = 1; i < lx; i++)
     525                 :            :       {
     526         [ +  + ]:    6147989 :         if (x[i] < y[i]) return -1;
     527         [ +  + ]:    5564357 :         if (x[i] > y[i]) return 1;
     528                 :            :       }
     529                 :     235207 :       return 0;
     530                 :            : 
     531                 :            :     case t_POL:
     532                 :            :     case t_SER:
     533                 :            :     case t_FFELT:
     534                 :            :     case t_CLOSURE:
     535         [ +  + ]:     886074 :       if (x[1] < y[1]) return -1;
     536         [ +  + ]:     886060 :       if (x[1] > y[1]) return 1;
     537                 :     886046 :       return cmp_universal_rec(x, y, 2);
     538                 :            : 
     539                 :            :     case t_LIST:
     540                 :            :       {
     541                 :         21 :         long tx = list_typ(x), ty = list_typ(y);
     542                 :            :         GEN vx, vy;
     543         [ -  + ]:         21 :         if (tx < ty) return -1;
     544         [ -  + ]:         21 :         if (tx > ty) return 1;
     545                 :         21 :         vx = list_data(x);
     546                 :         21 :         vy = list_data(y);
     547 [ -  + ][ #  # ]:         21 :         if (!vx) return vy? -1: 0;
     548         [ -  + ]:         21 :         if (!vy) return 1;
     549         [ -  + ]:         21 :         switch (tx)
     550                 :            :         {
     551                 :            :         case t_LIST_MAP:
     552                 :            :           {
     553                 :          0 :             pari_sp av = avma;
     554                 :          0 :             int ret = cmp_universal_rec(maptomat_shallow(x), maptomat_shallow(y),1);
     555                 :          0 :             avma = av; return ret;
     556                 :            :           }
     557                 :            :         default:
     558                 :         21 :           return cmp_universal_rec(vx, vy, 1);
     559                 :            :         }
     560                 :            :       }
     561                 :            :     default:
     562                 :   46114474 :       return cmp_universal_rec(x, y, lontyp[tx]);
     563                 :            :   }
     564                 :            : }
     565                 :            : 
     566                 :            : static int
     567                 :      53631 : cmpfrac(GEN x, GEN y)
     568                 :            : {
     569                 :      53631 :   pari_sp av = avma;
     570                 :      53631 :   GEN a = gel(x,1), b = gel(x,2);
     571                 :      53631 :   GEN c = gel(y,1), d = gel(y,2);
     572                 :      53631 :   int r = cmpii(mulii(a, d), mulii(b, c));
     573                 :      53631 :   avma = av; return r;
     574                 :            : }
     575                 :            : static int
     576                 :      15547 : cmpifrac(GEN a, GEN y)
     577                 :            : {
     578                 :      15547 :   pari_sp av = avma;
     579                 :      15547 :   GEN c = gel(y,1), d = gel(y,2);
     580                 :      15547 :   int r = cmpii(mulii(a, d), c);
     581                 :      15547 :   avma = av; return r;
     582                 :            : }
     583                 :            : static int
     584                 :      35777 : cmprfrac(GEN a, GEN y)
     585                 :            : {
     586                 :      35777 :   pari_sp av = avma;
     587                 :      35777 :   GEN c = gel(y,1), d = gel(y,2);
     588                 :      35777 :   int r = cmpri(mulri(a, d), c);
     589                 :      35777 :   avma = av; return r;
     590                 :            : }
     591                 :            : static int
     592                 :         42 : cmpgen(GEN x, GEN y)
     593                 :            : {
     594                 :         42 :   pari_sp av = avma;
     595                 :         42 :   int s = gsigne(gsub(x,y));
     596                 :         35 :   avma = av; return s;
     597                 :            : }
     598                 :            : 
     599                 :            : /* returns the sign of x - y when it makes sense. 0 otherwise */
     600                 :            : int
     601                 :  143755050 : gcmp(GEN x, GEN y)
     602                 :            : {
     603                 :  143755050 :   long tx = typ(x), ty = typ(y);
     604                 :            : 
     605         [ +  + ]:  143755050 :   if (tx == ty) /* generic case */
     606   [ +  +  +  +  :  143043310 :     switch(tx)
                +  +  - ]
     607                 :            :     {
     608                 :   73006692 :       case t_INT:  return cmpii(x, y);
     609                 :   70219394 :       case t_REAL: return cmprr(x, y);
     610                 :      53631 :       case t_FRAC: return cmpfrac(x, y);
     611                 :         14 :       case t_QUAD: return cmpgen(x, y);
     612                 :         21 :       case t_STR:  return cmp_str(GSTR(x), GSTR(y));
     613                 :            :       case t_INFINITY:
     614                 :            :       {
     615                 :       5985 :         long sx = inf_get_sign(x), sy = inf_get_sign(y);
     616         [ +  + ]:       5985 :         if (sx < sy) return -1;
     617         [ +  + ]:         21 :         if (sx > sy) return 1;
     618                 :         14 :         return 0;
     619                 :            :       }
     620                 :            :     }
     621         [ +  + ]:     469313 :   if (ty == t_INFINITY) return -inf_get_sign(y);
     622   [ +  +  +  +  :     463485 :   switch(tx)
                   +  + ]
     623                 :            :   {
     624                 :            :     case t_INT:
     625   [ +  +  -  + ]:      21651 :       switch(ty)
     626                 :            :       {
     627                 :      15838 :         case t_REAL: return cmpir(x, y);
     628                 :       5806 :         case t_FRAC: return cmpifrac(x, y);
     629                 :          0 :         case t_QUAD: return cmpgen(x, y);
     630                 :            :       }
     631                 :          7 :       break;
     632                 :            :     case t_REAL:
     633   [ +  +  -  + ]:     407668 :       switch(ty)
     634                 :            :       {
     635                 :     395642 :         case t_INT:  return cmpri(x, y);
     636                 :      12019 :         case t_FRAC: return cmprfrac(x, y);
     637                 :          0 :         case t_QUAD: return cmpgen(x, y);
     638                 :            :       }
     639                 :          7 :       break;
     640                 :            :     case t_FRAC:
     641   [ +  +  -  + ]:      33506 :       switch(ty)
     642                 :            :       {
     643                 :       9741 :         case t_INT:  return -cmpifrac(y, x);
     644                 :      23758 :         case t_REAL: return -cmprfrac(y, x);
     645                 :          0 :         case t_QUAD: return cmpgen(x, y);
     646                 :            :       }
     647                 :          7 :       break;
     648                 :            :     case t_QUAD:
     649                 :         28 :       return cmpgen(x, y);
     650                 :        625 :     case t_INFINITY: return inf_get_sign(x);
     651                 :            :   }
     652                 :         28 :   pari_err_TYPE2("comparison",x,y);
     653                 :  143691287 :   return 0;/*not reached*/
     654                 :            : }
     655                 :            : 
     656                 :            : int
     657                 :      24408 : gcmpsg(long s, GEN y)
     658                 :            : {
     659                 :      24408 :   long ty = typ(y);
     660   [ +  +  +  -  :      24408 :   switch(ty) {
                      - ]
     661                 :        756 :     case t_INT:  return cmpsi(s,y);
     662                 :      23050 :     case t_REAL: return cmpsr(s,y);
     663                 :            :     case t_FRAC: {
     664                 :        602 :       pari_sp av = avma;
     665                 :        602 :       GEN n = gel(y,1), d = gel(y,2);
     666                 :        602 :       int f = cmpii(mulsi(s,d), n); avma = av; return f;
     667                 :            :     }
     668                 :          0 :     case t_STR: return -1;
     669                 :            :   }
     670                 :          0 :   pari_err_TYPE2("comparison",stoi(s),y);
     671                 :      24408 :   return 0; /* not reached */
     672                 :            : }
     673                 :            : 
     674                 :            : static long
     675                 :     148323 : roughtype(GEN x)
     676                 :            : {
     677   [ +  +  +  + ]:     148323 :   switch(typ(x))
     678                 :            :   {
     679                 :        406 :     case t_MAT: return t_MAT;
     680                 :      55909 :     case t_VEC: case t_COL: return t_VEC;
     681                 :        210 :     case t_VECSMALL: return t_VECSMALL;
     682                 :     148323 :     default: return t_INT;
     683                 :            :   }
     684                 :            : }
     685                 :            : 
     686                 :            : static int lexcmpsg(long x, GEN y);
     687                 :         28 : static int lexcmpgs(GEN x, long y) { return -lexcmpsg(y,x); }
     688                 :            : /* lexcmp(stoi(x),y), y t_VEC/t_COL/t_MAT */
     689                 :            : static int
     690                 :         21 : lexcmp_s_matvec(long x, GEN y)
     691                 :            : {
     692                 :            :   int fl;
     693         [ +  + ]:         21 :   if (lg(y)==1) return 1;
     694                 :         14 :   fl = lexcmpsg(x,gel(y,1));
     695         [ +  + ]:         14 :   if (fl) return fl;
     696                 :         21 :   return -1;
     697                 :            : }
     698                 :            : /* x a scalar, y a t_VEC/t_COL/t_MAT */
     699                 :            : static int
     700                 :        224 : lexcmp_scal_matvec(GEN x, GEN y)
     701                 :            : {
     702                 :            :   int fl;
     703         [ -  + ]:        224 :   if (lg(y)==1) return 1;
     704                 :        224 :   fl = lexcmp(x,gel(y,1));
     705         [ +  - ]:        224 :   if (fl) return fl;
     706                 :        224 :   return -1;
     707                 :            : }
     708                 :            : /* x a scalar, y a t_VECSMALL */
     709                 :            : static int
     710                 :         28 : lexcmp_scal_vecsmall(GEN x, GEN y)
     711                 :            : {
     712                 :            :   int fl;
     713         [ -  + ]:         28 :   if (lg(y)==1) return 1;
     714                 :         28 :   fl = lexcmpgs(x, y[1]);
     715         [ +  - ]:         28 :   if (fl) return fl;
     716                 :         28 :   return -1;
     717                 :            : }
     718                 :            : 
     719                 :            : /* tx = ty = t_MAT, or x and y are both vect_t */
     720                 :            : static int
     721                 :      27958 : lexcmp_similar(GEN x, GEN y)
     722                 :            : {
     723                 :      27958 :   long i, lx = lg(x), ly = lg(y), l = minss(lx,ly);
     724         [ +  + ]:      47824 :   for (i=1; i<l; i++)
     725                 :            :   {
     726                 :      43351 :     int fl = lexcmp(gel(x,i),gel(y,i));
     727         [ +  + ]:      43351 :     if (fl) return fl;
     728                 :            :   }
     729         [ +  + ]:       4473 :   if (lx == ly) return 0;
     730         [ +  + ]:      27958 :   return (lx < ly)? -1 : 1;
     731                 :            : }
     732                 :            : /* x a t_VECSMALL, y a t_VEC/t_COL ~ lexcmp_similar */
     733                 :            : static int
     734                 :        154 : lexcmp_vecsmall_vec(GEN x, GEN y)
     735                 :            : {
     736                 :        154 :   long i, lx = lg(x), ly = lg(y), l = minss(lx,ly);
     737         [ +  + ]:        343 :   for (i=1; i<l; i++)
     738                 :            :   {
     739                 :        287 :     int fl = lexcmpsg(x[i], gel(y,i));
     740         [ +  + ]:        287 :     if (fl) return fl;
     741                 :            :   }
     742         [ +  + ]:         56 :   if (lx == ly) return 0;
     743         [ +  + ]:        154 :   return (lx < ly)? -1 : 1;
     744                 :            : }
     745                 :            : 
     746                 :            : /* x t_VEC/t_COL, y t_MAT */
     747                 :            : static int
     748                 :         84 : lexcmp_vec_mat(GEN x, GEN y)
     749                 :            : {
     750                 :            :   int fl;
     751         [ -  + ]:         84 :   if (lg(x)==1) return -1;
     752         [ -  + ]:         84 :   if (lg(y)==1) return 1;
     753                 :         84 :   fl = lexcmp_similar(x,gel(y,1));
     754         [ +  - ]:         84 :   if (fl) return fl;
     755                 :         84 :   return -1;
     756                 :            : }
     757                 :            : /* x t_VECSMALl, y t_MAT ~ lexcmp_vec_mat */
     758                 :            : static int
     759                 :         42 : lexcmp_vecsmall_mat(GEN x, GEN y)
     760                 :            : {
     761                 :            :   int fl;
     762         [ -  + ]:         42 :   if (lg(x)==1) return -1;
     763         [ -  + ]:         42 :   if (lg(y)==1) return 1;
     764                 :         42 :   fl = lexcmp_vecsmall_vec(x, gel(y,1));
     765         [ +  - ]:         42 :   if (fl) return fl;
     766                 :         42 :   return -1;
     767                 :            : }
     768                 :            : 
     769                 :            : /* x a t_VECSMALL, not y */
     770                 :            : static int
     771                 :        182 : lexcmp_vecsmall_other(GEN x, GEN y, long ty)
     772                 :            : {
     773      [ +  +  + ]:        182 :   switch(ty)
     774                 :            :   {
     775                 :         42 :     case t_MAT: return lexcmp_vecsmall_mat(x, y);
     776                 :        112 :     case t_VEC: return lexcmp_vecsmall_vec(x, y);
     777                 :        182 :     default: return -lexcmp_scal_vecsmall(y, x); /*y scalar*/
     778                 :            :   }
     779                 :            : }
     780                 :            : 
     781                 :            : /* lexcmp(stoi(s), y) */
     782                 :            : static int
     783                 :        329 : lexcmpsg(long x, GEN y)
     784                 :            : {
     785      [ +  +  + ]:        329 :   switch(roughtype(y))
     786                 :            :   {
     787                 :            :     case t_MAT:
     788                 :            :     case t_VEC:
     789                 :         21 :       return lexcmp_s_matvec(x,y);
     790                 :            :     case t_VECSMALL: /* ~ lexcmp_scal_matvec */
     791         [ +  + ]:         14 :       if (lg(y)==1) return 1;
     792         [ -  + ]:          7 :       return (x > y[1])? 1: -1;
     793                 :        329 :     default: return gcmpsg(x,y);
     794                 :            :   }
     795                 :            : }
     796                 :            : 
     797                 :            : /* as gcmp for vector/matrices, using lexicographic ordering on components */
     798                 :            : int
     799                 :      73997 : lexcmp(GEN x, GEN y)
     800                 :            : {
     801                 :      73997 :   const long tx = roughtype(x), ty = roughtype(y);
     802         [ +  + ]:      73997 :   if (tx == ty)
     803      [ +  +  + ]:      73507 :     switch(tx)
     804                 :            :     {
     805                 :            :       case t_MAT:
     806                 :            :       case t_VEC:
     807                 :      27874 :         return lexcmp_similar(x,y);
     808                 :            :       case t_VECSMALL:
     809                 :          7 :         return vecsmall_lexcmp(x,y);
     810                 :            :       default:
     811                 :      45626 :         return gcmp(x,y);
     812                 :            :     }
     813         [ +  + ]:        490 :   if (tx == t_VECSMALL) return  lexcmp_vecsmall_other(x,y,ty);
     814         [ +  + ]:        371 :   if (ty == t_VECSMALL) return -lexcmp_vecsmall_other(y,x,tx);
     815                 :            : 
     816         [ +  + ]:        308 :   if (tx == t_INT) return  lexcmp_scal_matvec(x,y); /*scalar*/
     817         [ +  + ]:        154 :   if (ty == t_INT) return -lexcmp_scal_matvec(y,x);
     818                 :            : 
     819         [ +  + ]:         84 :   if (ty==t_MAT) return  lexcmp_vec_mat(x,y);
     820                 :      73997 :   /*tx==t_MAT*/  return -lexcmp_vec_mat(y,x);
     821                 :            : }
     822                 :            : 
     823                 :            : /*****************************************************************/
     824                 :            : /*                                                               */
     825                 :            : /*                          EQUALITY                             */
     826                 :            : /*                returns 1 if x == y, 0 otherwise               */
     827                 :            : /*                                                               */
     828                 :            : /*****************************************************************/
     829                 :            : /* x,y t_POL */
     830                 :            : static int
     831                 :     763356 : polidentical(GEN x, GEN y)
     832                 :            : {
     833                 :            :   long lx;
     834         [ +  + ]:     763356 :   if (x[1] != y[1]) return 0;
     835         [ +  + ]:     763335 :   lx = lg(x); if (lg(y) != lg(x)) return 0;
     836 [ +  + ][ +  + ]:    3083794 :   for (lx--; lx >= 2; lx--) if (!gidentical(gel(x,lx), gel(y,lx))) return 0;
     837                 :     763356 :   return 1;
     838                 :            : }
     839                 :            : /* x,y t_SER */
     840                 :            : static int
     841                 :         14 : seridentical(GEN x, GEN y) { return polidentical(x,y); }
     842                 :            : /* typ(x) = typ(y) = t_VEC/COL/MAT */
     843                 :            : static int
     844                 :    3649380 : vecidentical(GEN x, GEN y)
     845                 :            : {
     846                 :            :   long i;
     847         [ +  + ]:    3649380 :   if ((x[0] ^ y[0]) & (TYPBITS|LGBITS)) return 0;
     848         [ +  + ]:    9744889 :   for (i = lg(x)-1; i; i--)
     849         [ +  + ]:    6701100 :     if (! gidentical(gel(x,i),gel(y,i)) ) return 0;
     850                 :    3649380 :   return 1;
     851                 :            : }
     852                 :            : static int
     853                 :         21 : identicalrr(GEN x, GEN y)
     854                 :            : {
     855                 :         21 :   long i, lx = lg(x);
     856         [ +  + ]:         21 :   if (lg(y) != lx) return 0;
     857         [ +  + ]:         14 :   if (x[1] != y[1]) return 0;
     858 [ +  + ][ +  - ]:         22 :   i=2; while (i<lx && x[i]==y[i]) i++;
     859                 :         21 :   return (i == lx);
     860                 :            : }
     861                 :            : 
     862                 :            : static int
     863                 :         28 : closure_identical(GEN x, GEN y)
     864                 :            : {
     865 [ +  - ][ +  + ]:         28 :   if (lg(x)!=lg(y) || x[1]!=y[1]) return 0;
     866 [ +  - ][ +  + ]:         21 :   if (!gidentical(gel(x,2),gel(y,2)) || !gidentical(gel(x,3),gel(y,3))
     867         [ -  + ]:         21 :    || !gidentical(gel(x,4),gel(y,4))) return 0;
     868         [ +  - ]:          7 :   if (lg(x)<8) return 1;
     869                 :         28 :   return gidentical(gel(x,7),gel(y,7));
     870                 :            : }
     871                 :            : 
     872                 :            : static int
     873                 :        336 : list_cmp(GEN x, GEN y, int cmp(GEN x, GEN y))
     874                 :            : {
     875                 :        336 :   int t = list_typ(x);
     876                 :            :   GEN vx, vy;
     877         [ -  + ]:        336 :   if (list_typ(y)!=t) return 0;
     878                 :        336 :   vx = list_data(x);
     879                 :        336 :   vy = list_data(y);
     880         [ +  + ]:        336 :   if (!vx) return vy? 0: 1;
     881         [ +  + ]:        322 :   if (!vy) return 0;
     882         [ +  + ]:        308 :   if (lg(vx) != lg(vy)) return 0;
     883         [ +  + ]:        301 :   switch (t)
     884                 :            :   {
     885                 :            :   case t_LIST_MAP:
     886                 :            :     {
     887                 :        280 :       pari_sp av = avma;
     888                 :        280 :       GEN mx  = maptomat_shallow(x), my = maptomat_shallow(y);
     889 [ +  + ][ +  + ]:        280 :       int ret = gidentical(gel(mx, 1), gel(my, 1)) && cmp(gel(mx, 2), gel(my, 2));
     890                 :        280 :       avma = av; return ret;
     891                 :            :     }
     892                 :            :   default:
     893                 :        336 :     return cmp(vx, vy);
     894                 :            :   }
     895                 :            : }
     896                 :            : 
     897                 :            : int
     898                 :   33441058 : gidentical(GEN x, GEN y)
     899                 :            : {
     900                 :            :   long tx;
     901                 :            : 
     902         [ +  + ]:   33441058 :   if (x == y) return 1;
     903         [ +  + ]:   32705323 :   tx = typ(x); if (typ(y) != tx) return 0;
     904   [ +  +  +  +  :   32705127 :   switch(tx)
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
                      - ]
     905                 :            :   {
     906                 :            :     case t_INT:
     907                 :    6562732 :       return equalii(x,y);
     908                 :            : 
     909                 :            :     case t_REAL:
     910                 :         14 :       return identicalrr(x,y);
     911                 :            : 
     912                 :            :     case t_FRAC: case t_INTMOD:
     913 [ +  + ][ +  + ]:      16436 :       return equalii(gel(x,2), gel(y,2)) && equalii(gel(x,1), gel(y,1));
     914                 :            : 
     915                 :            :     case t_COMPLEX:
     916 [ +  - ][ +  + ]:         14 :       return gidentical(gel(x,2),gel(y,2)) && gidentical(gel(x,1),gel(y,1));
     917                 :            :     case t_PADIC:
     918                 :         14 :       return valp(x) == valp(y)
     919         [ +  - ]:         14 :         && equalii(gel(x,2),gel(y,2))
     920         [ +  - ]:         14 :         && equalii(gel(x,3),gel(y,3))
     921 [ +  - ][ +  + ]:         28 :         && equalii(gel(x,4),gel(y,4));
     922                 :            :     case t_POLMOD:
     923 [ +  + ][ +  + ]:         49 :       return gidentical(gel(x,2),gel(y,2)) && polidentical(gel(x,1),gel(y,1));
     924                 :            :     case t_POL:
     925                 :     763321 :       return polidentical(x,y);
     926                 :            :     case t_SER:
     927                 :         14 :       return seridentical(x,y);
     928                 :            :     case t_FFELT:
     929                 :         14 :       return FF_equal(x,y);
     930                 :            : 
     931                 :            :     case t_QFR:
     932         [ +  - ]:          7 :           if (!identicalrr(gel(x,4),gel(y,4))) return 0; /* fall through */
     933                 :            :     case t_QFI:
     934                 :     927962 :       return equalii(gel(x,1),gel(y,1))
     935         [ +  + ]:     463974 :           && equalii(gel(x,2),gel(y,2))
     936 [ +  + ][ +  + ]:     927955 :           && equalii(gel(x,3),gel(y,3));
     937                 :            : 
     938                 :            :     case t_QUAD:
     939                 :         28 :       return ZX_equal(gel(x,1),gel(y,1))
     940         [ -  + ]:          7 :           && gidentical(gel(x,2),gel(y,2))
     941 [ +  + ][ #  # ]:         21 :           && gidentical(gel(x,3),gel(y,3));
     942                 :            : 
     943                 :            :     case t_RFRAC:
     944 [ +  - ][ -  + ]:          7 :       return gidentical(gel(x,1),gel(y,1)) && gidentical(gel(x,2),gel(y,2));
     945                 :            : 
     946                 :            :     case t_STR:
     947                 :         35 :       return !strcmp(GSTR(x),GSTR(y));
     948                 :            :     case t_VEC: case t_COL: case t_MAT:
     949                 :    3649380 :       return vecidentical(x,y);
     950                 :            :     case t_VECSMALL:
     951                 :   21248892 :       return zv_equal(x,y);
     952                 :            :     case t_CLOSURE:
     953                 :         21 :       return closure_identical(x,y);
     954                 :            :     case t_LIST:
     955                 :        161 :       return list_cmp(x, y, gidentical);
     956                 :         21 :     case t_INFINITY: return gidentical(gel(x,1),gel(y,1));
     957                 :            :   }
     958                 :   33441058 :   return 0;
     959                 :            : }
     960                 :            : /* x,y t_POL */
     961                 :            : static int
     962                 :     339568 : polequal(GEN x, GEN y)
     963                 :            : {
     964                 :            :   long lx, ly;
     965         [ +  + ]:     339568 :   if ((x[1] ^ y[1]) & (VARNBITS | SIGNBITS)) return 0;
     966                 :     331007 :   lx = lg(x); ly = lg(y);
     967 [ +  - ][ +  + ]:     331007 :   while (lx > ly) if (!gequal0(gel(x,--lx))) return 0;
     968 [ +  - ][ +  + ]:     329747 :   while (ly > lx) if (!gequal0(gel(y,--ly))) return 0;
     969 [ +  + ][ +  + ]:    1021986 :   for (lx--; lx >= 2; lx--) if (!gequal(gel(x,lx), gel(y,lx))) return 0;
     970                 :     339568 :   return 1;
     971                 :            : }
     972                 :            : 
     973                 :            : /* x,y t_POL */
     974                 :            : static int
     975                 :        294 : serequal(GEN x, GEN y)
     976                 :            : {
     977                 :            :   long lx;
     978         [ -  + ]:        294 :   if (varn(x) != varn(y)) return 0;
     979         [ +  + ]:        294 :   if (!signe(x))
     980                 :            :   {
     981         [ +  - ]:        273 :     if (!signe(y)) return 1;
     982                 :          0 :     return valp(y) >= valp(x);
     983                 :            :   }
     984         [ -  + ]:         21 :   if (!signe(y))
     985                 :          0 :     return valp(x) >= valp(y);
     986         [ -  + ]:         21 :   if ((x[1] ^ y[1]) & VALPBITS) return 0;
     987                 :         21 :   lx = minss(lg(x), lg(y));
     988 [ -  + ][ +  + ]:     282821 :   for (lx--; lx >= 2; lx--) if (!gequal(gel(x,lx), gel(y,lx))) return 0;
     989                 :        294 :   return 1;
     990                 :            : }
     991                 :            : 
     992                 :            : /* typ(x) = typ(y) = t_VEC/COL/MAT */
     993                 :            : static int
     994                 :     609438 : vecequal(GEN x, GEN y)
     995                 :            : {
     996                 :            :   long i;
     997         [ +  + ]:     609438 :   if ((x[0] ^ y[0]) & (TYPBITS|LGBITS)) return 0;
     998         [ +  + ]:    5574544 :   for (i = lg(x)-1; i; i--)
     999         [ +  + ]:    5030685 :     if (! gequal(gel(x,i),gel(y,i)) ) return 0;
    1000                 :     609438 :   return 1;
    1001                 :            : }
    1002                 :            : 
    1003                 :            : static int
    1004                 :    1719401 : gequal_try(GEN x, GEN y)
    1005                 :            : {
    1006                 :            :   int i;
    1007         [ +  + ]:    1719401 :   pari_CATCH(CATCH_ALL) {
    1008                 :        175 :     GEN E = pari_err_last();
    1009         [ -  + ]:        175 :     switch(err_get_num(E))
    1010                 :            :     {
    1011                 :            :       case e_STACK: case e_MEM: case e_ALARM:
    1012                 :          0 :         pari_err(0, E); /* rethrow */
    1013                 :            :     }
    1014                 :        175 :     return 0;
    1015                 :            :   } pari_TRY {
    1016                 :    1719401 :     i = gequal0(gadd(x, gneg_i(y)));
    1017                 :    1719226 :   } pari_ENDCATCH;
    1018                 :    1719401 :   return i;
    1019                 :            : }
    1020                 :            : 
    1021                 :            : int
    1022                 :   50196319 : gequal(GEN x, GEN y)
    1023                 :            : {
    1024                 :            :   pari_sp av;
    1025                 :            :   long tx, ty;
    1026                 :            :   long i;
    1027                 :            : 
    1028         [ +  + ]:   50196319 :   if (x == y) return 1;
    1029                 :   43020077 :   tx = typ(x);
    1030                 :   43020077 :   ty = typ(y);
    1031         [ +  + ]:   43020077 :   if (tx == ty)
    1032   [ +  +  +  +  :   41300683 :     switch(tx)
          +  +  +  +  +  
          +  +  +  +  +  
             +  +  +  +  
                      - ]
    1033                 :            :     {
    1034                 :            :       case t_INT:
    1035                 :   38343515 :         return equalii(x,y);
    1036                 :            : 
    1037                 :            :       case t_REAL:
    1038                 :       1650 :         return equalrr(x,y);
    1039                 :            : 
    1040                 :            :       case t_FRAC: case t_INTMOD:
    1041 [ +  + ][ +  + ]:     294323 :         return equalii(gel(x,2), gel(y,2)) && equalii(gel(x,1), gel(y,1));
    1042                 :            : 
    1043                 :            :       case t_COMPLEX:
    1044 [ +  + ][ +  - ]:        182 :         return gequal(gel(x,2),gel(y,2)) && gequal(gel(x,1),gel(y,1));
    1045                 :            :       case t_PADIC:
    1046         [ -  + ]:        511 :         if (!equalii(gel(x,2),gel(y,2))) return 0;
    1047                 :        511 :         av = avma; i = gequal0(gsub(x,y)); avma = av;
    1048                 :        511 :         return i;
    1049                 :            :       case t_POLMOD:
    1050         [ +  + ]:      24638 :         if (varn(gel(x,1)) != varn(gel(y,1))) break;
    1051 [ +  + ][ +  - ]:      24631 :         return gequal(gel(x,2),gel(y,2)) && RgX_equal_var(gel(x,1),gel(y,1));
    1052                 :            :       case t_POL:
    1053                 :     339568 :         return polequal(x,y);
    1054                 :            :       case t_SER:
    1055                 :        294 :         return serequal(x,y);
    1056                 :            : 
    1057                 :            :       case t_FFELT:
    1058                 :      16566 :         return FF_equal(x,y);
    1059                 :            : 
    1060                 :            :       case t_QFR:
    1061                 :            :       case t_QFI:
    1062                 :    2077014 :         return equalii(gel(x,1),gel(y,1))
    1063         [ +  + ]:     223255 :             && equalii(gel(x,2),gel(y,2))
    1064 [ +  + ][ +  - ]:    1261762 :             && equalii(gel(x,3),gel(y,3));
    1065                 :            : 
    1066                 :            :       case t_QUAD:
    1067                 :         14 :         return ZX_equal(gel(x,1),gel(y,1))
    1068         [ #  # ]:          0 :             && gequal(gel(x,2),gel(y,2))
    1069 [ -  + ][ #  # ]:          7 :             && gequal(gel(x,3),gel(y,3));
    1070                 :            : 
    1071                 :            :       case t_RFRAC:
    1072                 :            :       {
    1073                 :      73717 :         GEN a = gel(x,1), b = gel(x,2), c = gel(y,1), d = gel(y,2);
    1074         [ +  - ]:      73717 :         if (gequal(b,d)) return gequal(a,c); /* simple case */
    1075                 :          0 :         av = avma;
    1076                 :          0 :         i = gequal(simplify_shallow(gmul(a,d)), simplify_shallow(gmul(b,c)));
    1077                 :          0 :         avma = av; return i;
    1078                 :            :       }
    1079                 :            : 
    1080                 :            :       case t_STR:
    1081                 :      35593 :         return !strcmp(GSTR(x),GSTR(y));
    1082                 :            :       case t_VEC: case t_COL: case t_MAT:
    1083                 :     609438 :         return vecequal(x,y);
    1084                 :            :       case t_VECSMALL:
    1085                 :     521978 :         return zv_equal(x,y);
    1086                 :            :       case t_LIST:
    1087                 :        175 :         return list_cmp(x, y, gequal);
    1088                 :            :       case t_CLOSURE:
    1089                 :          7 :         return closure_identical(x,y);
    1090                 :            :       case t_INFINITY:
    1091                 :         14 :         return gequal(gel(x,1),gel(y,1));
    1092                 :            :     }
    1093                 :            :   (void)&av; /* emulate volatile */
    1094                 :    1719401 :   av = avma; i = gequal_try(x, y);
    1095                 :   50196319 :   avma = av; return i;
    1096                 :            : }
    1097                 :            : 
    1098                 :            : int
    1099                 :      23079 : gequalsg(long s, GEN x)
    1100                 :            : {
    1101                 :      23079 :   pari_sp av = avma;
    1102                 :      23079 :   int f = gequal(stoi(s), x);
    1103                 :      23079 :   avma = av; return f;
    1104                 :            : }
    1105                 :            : /*******************************************************************/
    1106                 :            : /*                                                                 */
    1107                 :            : /*                          VALUATION                              */
    1108                 :            : /*             p is either a t_INT or a t_POL.                     */
    1109                 :            : /*  returns the largest exponent of p dividing x when this makes   */
    1110                 :            : /*  sense : error for types real, integermod and polymod if p does */
    1111                 :            : /*  not divide the modulus, q-adic if q!=p.                        */
    1112                 :            : /*                                                                 */
    1113                 :            : /*******************************************************************/
    1114                 :            : 
    1115                 :            : static long
    1116                 :        224 : minval(GEN x, GEN p)
    1117                 :            : {
    1118                 :        224 :   long i,k, val = LONG_MAX, lx = lg(x);
    1119         [ +  + ]:       5775 :   for (i=lontyp[typ(x)]; i<lx; i++)
    1120                 :            :   {
    1121                 :       5551 :     k = gvaluation(gel(x,i),p);
    1122         [ +  + ]:       5551 :     if (k < val) val = k;
    1123                 :            :   }
    1124                 :        224 :   return val;
    1125                 :            : }
    1126                 :            : 
    1127                 :            : static int
    1128                 :         91 : intdvd(GEN x, GEN y, GEN *z) { GEN r; *z = dvmdii(x,y,&r); return (r==gen_0); }
    1129                 :            : 
    1130                 :            : /* x t_FRAC, p t_INT, return v_p(x) */
    1131                 :            : static long
    1132                 :      56161 : ratval(GEN x, GEN p) {
    1133                 :      56161 :   long v = Z_pval(gel(x,2),p);
    1134         [ +  + ]:      56161 :   if (v) return -v;
    1135                 :      56161 :   return Z_pval(gel(x,1),p);
    1136                 :            : }
    1137                 :            : 
    1138                 :            : long
    1139         [ +  + ]:     265870 : Q_pval(GEN x, GEN p) { return (typ(x) == t_INT)? Z_pval(x, p): ratval(x, p); }
    1140                 :            : 
    1141                 :            : long
    1142                 :     159078 : Q_pvalrem(GEN x, GEN p, GEN *y)
    1143                 :            : {
    1144                 :            :   GEN a, b;
    1145                 :            :   long v;
    1146         [ +  + ]:     159078 :   if (typ(x) == t_INT) return Z_pvalrem(x, p, y);
    1147                 :       2842 :   a = gel(x,1);
    1148                 :       2842 :   b = gel(x,2);
    1149                 :       2842 :   v = Z_pvalrem(b, p, &b);
    1150 [ +  + ][ +  + ]:       2842 :   if (v) { *y = isint1(b)? a: mkfrac(a, b); return -v; }
    1151                 :       2072 :   v = Z_pvalrem(a, p, &a);
    1152                 :     159070 :   *y = mkfrac(a, b); return v;
    1153                 :            : }
    1154                 :            : 
    1155                 :            : long
    1156                 :      12229 : gvaluation(GEN x, GEN p)
    1157                 :            : {
    1158                 :      12229 :   long tx = typ(x), tp = typ(p);
    1159                 :            :   pari_sp av;
    1160                 :            : 
    1161      [ +  +  + ]:      12229 :   switch(tp)
    1162                 :            :   {
    1163                 :            :     case t_INT:
    1164 [ +  + ][ +  + ]:       9569 :       if (signe(p) && !is_pm1(p)) break;
    1165                 :         28 :       pari_err_DOMAIN("gvaluation", "p", "=", p, p);
    1166                 :            :     case t_POL:
    1167         [ +  - ]:       2653 :       if (degpol(p) > 0) break;
    1168                 :            :     default:
    1169                 :          7 :       pari_err_DOMAIN("gvaluation", "p", "=", p, p);
    1170                 :            :   }
    1171                 :            : 
    1172   [ +  +  +  +  :      12194 :   switch(tx)
          +  +  +  +  +  
                +  +  - ]
    1173                 :            :   {
    1174                 :            :     case t_INT:
    1175         [ +  + ]:       9016 :       if (!signe(x)) return LONG_MAX;
    1176         [ +  + ]:       8939 :       if (tp == t_POL) return 0;
    1177                 :       8526 :       return Z_pval(x,p);
    1178                 :            : 
    1179                 :            :     case t_REAL:
    1180         [ +  + ]:         49 :       if (tp == t_POL) return 0;
    1181                 :         21 :       break;
    1182                 :            : 
    1183                 :            :     case t_FFELT:
    1184 [ +  + ][ -  + ]:         28 :       if (tp == t_POL) return FF_equal0(x)? LONG_MAX: 0;
    1185                 :         14 :       break;
    1186                 :            : 
    1187                 :            :     case t_INTMOD: {
    1188                 :         77 :       GEN a = gel(x,1), b = gel(x,2);
    1189                 :            :       long val;
    1190 [ +  + ][ +  - ]:         77 :       if (tp == t_POL) return signe(b)? 0: LONG_MAX;
    1191                 :         42 :       av = avma;
    1192         [ +  + ]:         42 :       if (!intdvd(a, p, &a)) break;
    1193         [ +  + ]:         28 :       if (!intdvd(b, p, &b)) { avma = av; return 0; }
    1194 [ +  + ][ -  + ]:         14 :       val = 1; while (intdvd(a,p,&a) && intdvd(b,p,&b)) val++;
    1195                 :         77 :       avma = av; return val;
    1196                 :            :     }
    1197                 :            : 
    1198                 :            :     case t_FRAC:
    1199         [ +  + ]:         42 :       if (tp == t_POL) return 0;
    1200                 :         28 :       return ratval(x, p);
    1201                 :            : 
    1202                 :            :     case t_PADIC:
    1203         [ +  + ]:        693 :       if (tp == t_POL) return 0;
    1204         [ +  + ]:        679 :       if (!equalii(p,gel(x,2))) break;
    1205                 :        672 :       return valp(x);
    1206                 :            : 
    1207                 :            :     case t_POLMOD: {
    1208                 :         35 :       GEN a = gel(x,1), b = gel(x,2);
    1209                 :            :       long v, val;
    1210         [ +  + ]:         35 :       if (tp == t_INT) return gvaluation(b,p);
    1211                 :         21 :       v = varn(p);
    1212         [ -  + ]:         21 :       if (varn(a) != v) return 0;
    1213                 :         21 :       av = avma;
    1214                 :         21 :       a = RgX_divrem(a, p, ONLY_DIVIDES);
    1215         [ +  + ]:         21 :       if (!a) break;
    1216 [ +  - ][ +  - ]:         14 :       if (typ(b) != t_POL || varn(b) != v ||
                 [ +  + ]
    1217                 :          7 :           !(b = RgX_divrem(b, p, ONLY_DIVIDES)) ) { avma = av; return 0; }
    1218                 :          7 :       val = 1;
    1219 [ +  - ][ +  + ]:         14 :       while ((a = RgX_divrem(a, p, ONLY_DIVIDES)) &&
    1220                 :          7 :              (b = RgX_divrem(b, p, ONLY_DIVIDES)) ) val++;
    1221                 :          7 :       avma = av; return val;
    1222                 :            :     }
    1223                 :            :     case t_POL: {
    1224         [ +  + ]:       1981 :       if (tp == t_POL) {
    1225                 :       1855 :         long vp = varn(p), vx = varn(x);
    1226         [ +  + ]:       1855 :         if (vp == vx)
    1227                 :            :         {
    1228                 :            :           long val;
    1229         [ +  + ]:       1848 :           if (RgX_is_monomial(p)) return RgX_val(x) / degpol(p);
    1230                 :          7 :           av = avma;
    1231                 :          7 :           for (val=0; ; val++)
    1232                 :            :           {
    1233                 :          7 :             x = RgX_divrem(x,p,ONLY_DIVIDES);
    1234         [ +  - ]:          7 :             if (!x) { avma = av; return val; }
    1235         [ #  # ]:          0 :             if (gc_needed(av,1))
    1236                 :            :             {
    1237         [ #  # ]:          0 :               if(DEBUGMEM>1) pari_warn(warnmem,"gvaluation");
    1238                 :          0 :               x = gerepilecopy(av, x);
    1239                 :            :             }
    1240                 :          0 :           }
    1241                 :            :         }
    1242         [ +  - ]:          7 :         if (varncmp(vx, vp) > 0) return 0;
    1243                 :            :       }
    1244                 :        126 :       return minval(x,p);
    1245                 :            :     }
    1246                 :            : 
    1247                 :            :     case t_SER: {
    1248         [ +  + ]:        175 :       if (tp == t_POL) {
    1249                 :        161 :         long vp = varn(p), vx = varn(x);
    1250         [ +  + ]:        161 :         if (vp == vx)
    1251                 :            :         {
    1252                 :        154 :           long val = RgX_val(p);
    1253         [ +  + ]:        154 :           if (!val) pari_err_DOMAIN("gvaluation", "p", "=", p, p);
    1254                 :        147 :           return (long)(valp(x) / val);
    1255                 :            :         }
    1256         [ +  - ]:          7 :         if (varncmp(vx, vp) > 0) return 0;
    1257                 :            :       }
    1258                 :         14 :       return minval(x,p);
    1259                 :            :     }
    1260                 :            : 
    1261                 :            :     case t_RFRAC:
    1262                 :         14 :       return gvaluation(gel(x,1),p) - gvaluation(gel(x,2),p);
    1263                 :            : 
    1264                 :            :     case t_COMPLEX: case t_QUAD: case t_VEC: case t_COL: case t_MAT:
    1265                 :         84 :       return minval(x,p);
    1266                 :            :   }
    1267                 :         63 :   pari_err_OP("valuation", x,p);
    1268                 :      12124 :   return 0; /* not reached */
    1269                 :            : }
    1270                 :            : GEN
    1271                 :       3605 : gpvaluation(GEN x, GEN p)
    1272                 :            : {
    1273                 :       3605 :   long v = gvaluation(x,p);
    1274         [ +  + ]:       3507 :   return v == LONG_MAX? mkoo(): stoi(v);
    1275                 :            : }
    1276                 :            : 
    1277                 :            : /* x is non-zero */
    1278                 :            : long
    1279                 :    9783640 : u_lvalrem(ulong x, ulong p, ulong *py)
    1280                 :            : {
    1281                 :            :   ulong vx;
    1282         [ +  + ]:    9783640 :   if (p == 2) { vx = vals(x); *py = x >> vx; return vx; }
    1283                 :    7720670 :   for(vx = 0;;)
    1284                 :            :   {
    1285         [ +  + ]:   17413399 :     if (x % p) { *py = x; return vx; }
    1286                 :    9692729 :     x /= p; /* gcc is smart enough to make a single div */
    1287                 :    9692729 :     vx++;
    1288                 :   19476369 :   }
    1289                 :            : }
    1290                 :            : long
    1291                 :    4457088 : u_lval(ulong x, ulong p)
    1292                 :            : {
    1293                 :            :   ulong vx;
    1294         [ +  + ]:    4457088 :   if (p == 2) return vals(x);
    1295                 :    4092872 :   for(vx = 0;;)
    1296                 :            :   {
    1297         [ +  + ]:   14204305 :     if (x % p) return vx;
    1298                 :   10111433 :     x /= p; /* gcc is smart enough to make a single div */
    1299                 :   10111433 :     vx++;
    1300                 :   14568520 :   }
    1301                 :            : }
    1302                 :            : 
    1303                 :            : long
    1304                 :      71890 : z_lval(long s, ulong p) { return u_lval(labs(s), p); }
    1305                 :            : long
    1306                 :          0 : z_lvalrem(long s, ulong p, long *py)
    1307                 :            : {
    1308                 :            :   long v;
    1309         [ #  # ]:          0 :   if (s < 0)
    1310                 :            :   {
    1311                 :          0 :     ulong u = (ulong)-s;
    1312                 :          0 :     v = u_lvalrem(u, p, &u);
    1313                 :          0 :     *py = -(long)u;
    1314                 :            :   }
    1315                 :            :   else
    1316                 :            :   {
    1317                 :          0 :     ulong u = (ulong)s;
    1318                 :          0 :     v = u_lvalrem(u, p, &u);
    1319                 :          0 :     *py = (long)u;
    1320                 :            :   }
    1321                 :          0 :   return v;
    1322                 :            : }
    1323                 :            : /* assume |p| > 1 */
    1324                 :            : long
    1325                 :       2079 : z_pval(long s, GEN p)
    1326                 :            : {
    1327         [ -  + ]:       2079 :   if (lgefint(p) > 3) return 0;
    1328                 :       2079 :   return z_lval(s, uel(p,2));
    1329                 :            : }
    1330                 :            : /* assume |p| > 1 */
    1331                 :            : long
    1332                 :          0 : z_pvalrem(long s, GEN p, long *py)
    1333                 :            : {
    1334         [ #  # ]:          0 :   if (lgefint(p) > 3) { *py = s; return 0; }
    1335                 :          0 :   return z_lvalrem(s, uel(p,2), py);
    1336                 :            : }
    1337                 :            : 
    1338                 :            : /* return v_q(x) and set *py = x / q^v_q(x), using divide & conquer */
    1339                 :            : static long
    1340                 :    1171760 : Z_pvalrem_DC(GEN x, GEN q, GEN *py)
    1341                 :            : {
    1342                 :    1171760 :   GEN r, z = dvmdii(x, q, &r);
    1343                 :            :   long v;
    1344         [ +  + ]:    1171760 :   if (r != gen_0) { *py = x; return 0; }
    1345         [ +  + ]:     855347 :   if (2 * lgefint(q) <= lgefint(z)+3) /* avoid squaring if pointless */
    1346                 :     841971 :     v = Z_pvalrem_DC(z, sqri(q), py) << 1;
    1347                 :            :   else
    1348                 :      13376 :   { v = 0; *py = z; }
    1349                 :     855347 :   z = dvmdii(*py, q, &r);
    1350         [ +  + ]:     855347 :   if (r != gen_0) return v + 1;
    1351                 :    1171760 :   *py = z; return v + 2;
    1352                 :            : }
    1353                 :            : 
    1354                 :            : static const long VAL_DC_THRESHOLD = 16;
    1355                 :            : 
    1356                 :            : long
    1357                 :    5279750 : Z_lval(GEN x, ulong p)
    1358                 :            : {
    1359                 :            :   long vx;
    1360                 :            :   pari_sp av;
    1361         [ +  + ]:    5279750 :   if (p == 2) return vali(x);
    1362         [ +  + ]:    3933022 :   if (lgefint(x) == 3) return u_lval(uel(x,2), p);
    1363                 :     307858 :   av = avma;
    1364                 :     307858 :   for(vx = 0;;)
    1365                 :            :   {
    1366                 :            :     ulong r;
    1367                 :    1941338 :     GEN q = diviu_rem(x, p, &r);
    1368         [ +  + ]:    1941338 :     if (r) break;
    1369                 :    1663096 :     vx++; x = q;
    1370         [ +  + ]:    1663096 :     if (vx == VAL_DC_THRESHOLD) {
    1371         [ -  + ]:      29616 :       if (p == 1) pari_err_DOMAIN("Z_lval", "p", "=", gen_1, gen_1);
    1372                 :      29616 :       vx += Z_pvalrem_DC(x, sqru(p), &x) << 1;
    1373         [ +  + ]:      29616 :       q = diviu_rem(x, p, &r); if (!r) vx++;
    1374                 :            :       break;
    1375                 :            :     }
    1376                 :    1633480 :   }
    1377                 :    5279750 :   avma = av; return vx;
    1378                 :            : }
    1379                 :            : long
    1380                 :    6804121 : Z_lvalrem(GEN x, ulong p, GEN *py)
    1381                 :            : {
    1382                 :            :   long vx, sx;
    1383                 :            :   pari_sp av;
    1384         [ +  + ]:    6804121 :   if (p == 2) { vx = vali(x); *py = shifti(x, -vx); return vx; }
    1385         [ +  + ]:    5012275 :   if (lgefint(x) == 3) {
    1386                 :            :     ulong u;
    1387                 :    3014193 :     vx = u_lvalrem(uel(x,2), p, &u);
    1388         [ +  + ]:    3014193 :     *py = signe(x) < 0? utoineg(u): utoipos(u);
    1389                 :    3014193 :     return vx;
    1390                 :            :   }
    1391                 :    1998082 :   av = avma; (void)new_chunk(lgefint(x));
    1392                 :    1998082 :   sx = signe(x);
    1393                 :    1998082 :   for(vx = 0;;)
    1394                 :            :   {
    1395                 :            :     ulong r;
    1396                 :    9471404 :     GEN q = diviu_rem(x, p, &r);
    1397         [ +  + ]:    9471404 :     if (r) break;
    1398                 :    7765571 :     vx++; x = q;
    1399         [ +  + ]:    7765571 :     if (vx == VAL_DC_THRESHOLD) {
    1400         [ -  + ]:     292249 :       if (p == 1) pari_err_DOMAIN("Z_lvalrem", "p", "=", gen_1, gen_1);
    1401                 :     292249 :       vx += Z_pvalrem_DC(x, sqru(p), &x) << 1;
    1402         [ +  + ]:     292249 :       q = diviu_rem(x, p, &r); if (!r) { vx++; x = q; }
    1403                 :            :       break;
    1404                 :            :     }
    1405                 :    7473322 :   }
    1406                 :    6804080 :   avma = av; *py = icopy(x); setsigne(*py, sx); return vx;
    1407                 :            : }
    1408                 :            : 
    1409                 :            : /* Is |q| <= p ? */
    1410                 :            : static int
    1411                 :  170320989 : isless_iu(GEN q, ulong p) {
    1412                 :  170320989 :   long l = lgefint(q);
    1413 [ +  + ][ +  + ]:  170320989 :   return l==2 || (l == 3 && uel(q,2) <= p);
                 [ +  + ]
    1414                 :            : }
    1415                 :            : 
    1416                 :            : long
    1417                 :  354777847 : u_lvalrem_stop(ulong *n, ulong p, int *stop)
    1418                 :            : {
    1419                 :  354777847 :   ulong N = *n, q = N / p, r = N % p; /* gcc makes a single div */
    1420                 :  354777847 :   long v = 0;
    1421         [ +  + ]:  354777847 :   if (!r)
    1422                 :            :   {
    1423         [ +  + ]:   23683640 :     do { v++; N = q; q = N / p; r = N % p; } while (!r);
    1424                 :   14756379 :     *n = N;
    1425                 :            :   }
    1426                 :  354777847 :   *stop = q <= p; return v;
    1427                 :            : }
    1428                 :            : /* Assume n > 0. Return v_p(n), set *n := n/p^v_p(n). Set 'stop' if now
    1429                 :            :  * n < p^2 [implies n prime if no prime < p divides n] */
    1430                 :            : long
    1431                 :  476882277 : Z_lvalrem_stop(GEN *n, ulong p, int *stop)
    1432                 :            : {
    1433                 :            :   pari_sp av;
    1434                 :            :   long v;
    1435                 :            :   ulong r;
    1436                 :            :   GEN N, q;
    1437                 :            : 
    1438         [ +  + ]:  476882277 :   if (lgefint(*n) == 3)
    1439                 :            :   {
    1440                 :  306565721 :     r = (*n)[2];
    1441                 :  306565721 :     v = u_lvalrem_stop(&r, p, stop);
    1442         [ +  + ]:  306565827 :     if (v) *n = utoipos(r);
    1443                 :  306565827 :     return v;
    1444                 :            :   }
    1445                 :  170316556 :   av = avma; v = 0; q = diviu_rem(*n, p, &r);
    1446         [ +  + ]:  170316907 :   if (r) avma = av;
    1447                 :            :   else
    1448                 :            :   {
    1449                 :            :     do {
    1450                 :     696761 :       v++; N = q;
    1451         [ +  + ]:     696761 :       if (v == VAL_DC_THRESHOLD)
    1452                 :            :       {
    1453                 :       7924 :         v += Z_pvalrem_DC(N,sqru(p),&N) << 1;
    1454         [ +  + ]:       7924 :         q = diviu_rem(N, p, &r); if (!r) { v++; N = q; }
    1455                 :       7924 :         break;
    1456                 :            :       }
    1457                 :     688837 :       q = diviu_rem(N, p, &r);
    1458         [ +  + ]:     688837 :     } while (!r);
    1459                 :     321328 :     *n = N;
    1460                 :            :   }
    1461                 :  476882734 :   *stop = isless_iu(q,p); return v;
    1462                 :            : }
    1463                 :            : 
    1464                 :            : /* x is a non-zero integer, |p| > 1 */
    1465                 :            : long
    1466                 :    4569087 : Z_pvalrem(GEN x, GEN p, GEN *py)
    1467                 :            : {
    1468                 :            :   long vx;
    1469                 :            :   pari_sp av;
    1470                 :            : 
    1471         [ +  + ]:    4569087 :   if (lgefint(p) == 3) return Z_lvalrem(x, uel(p,2), py);
    1472         [ +  + ]:     122304 :   if (lgefint(x) == 3) { *py = icopy(x); return 0; }
    1473                 :       1884 :   av = avma; vx = 0; (void)new_chunk(lgefint(x));
    1474                 :            :   for(;;)
    1475                 :            :   {
    1476                 :       4038 :     GEN r, q = dvmdii(x,p,&r);
    1477         [ +  + ]:       4038 :     if (r != gen_0) { avma = av; *py = icopy(x); return vx; }
    1478                 :       2154 :     vx++; x = q;
    1479                 :    4571211 :   }
    1480                 :            : }
    1481                 :            : long
    1482                 :     376418 : u_pvalrem(ulong x, GEN p, ulong *py)
    1483                 :            : {
    1484         [ +  + ]:     376418 :   if (lgefint(p) == 3) return u_lvalrem(x, uel(p,2), py);
    1485                 :     376418 :   *py = x; return 0;
    1486                 :            : }
    1487                 :            : long
    1488                 :     101374 : u_pval(ulong x, GEN p)
    1489                 :            : {
    1490         [ +  - ]:     101374 :   if (lgefint(p) == 3) return u_lval(x, uel(p,2));
    1491                 :     101374 :   return 0;
    1492                 :            : }
    1493                 :            : long
    1494                 :    4586007 : Z_pval(GEN x, GEN p) {
    1495                 :            :   long vx;
    1496                 :            :   pari_sp av;
    1497                 :            : 
    1498         [ +  + ]:    4586007 :   if (lgefint(p) == 3) return Z_lval(x, uel(p,2));
    1499         [ +  + ]:      70202 :   if (lgefint(x) == 3) return 0;
    1500                 :      64596 :   av = avma; vx = 0;
    1501                 :            :   for(;;)
    1502                 :            :   {
    1503                 :      81162 :     GEN r, q = dvmdii(x,p,&r);
    1504         [ +  + ]:      81162 :     if (r != gen_0) { avma = av; return vx; }
    1505                 :      16566 :     vx++; x = q;
    1506                 :    4602573 :   }
    1507                 :            : }
    1508                 :            : 
    1509                 :            : /* return v_p(n!) = [n/p] + [n/p^2] + ... */
    1510                 :            : long
    1511                 :      64698 : factorial_lval(ulong n, ulong p)
    1512                 :            : {
    1513                 :      64698 :   ulong q = p, v = 0;
    1514         [ +  + ]:     106768 :   do { v += n/q; q *= p; } while (n >= q);
    1515                 :      64698 :   return (long)v;
    1516                 :            : }
    1517                 :            : 
    1518                 :            : /********** Same for "containers" ZX / ZV / ZC **********/
    1519                 :            : 
    1520                 :            : /* If the t_INT q divides the ZX/ZV x, return the quotient. Otherwise NULL.
    1521                 :            :  * Stack clean; assumes lg(x) > 1 */
    1522                 :            : static GEN
    1523                 :       3878 : gen_Z_divides(GEN x, GEN q, long imin)
    1524                 :            : {
    1525                 :            :   long i, l;
    1526                 :       3878 :   GEN y = cgetg_copy(x, &l);
    1527                 :            : 
    1528                 :       3878 :   y[1] = x[1]; /* Needed for ZX; no-op if ZV, overwritten in first iteration */
    1529         [ +  + ]:      81214 :   for (i = imin; i < l; i++)
    1530                 :            :   {
    1531                 :      79695 :     GEN r, xi = gel(x,i);
    1532         [ +  + ]:      79695 :     if (!signe(xi)) { gel(y,i) = xi; continue; }
    1533                 :      48692 :     gel(y,i) = dvmdii(xi, q, &r);
    1534         [ +  + ]:      48692 :     if (r != gen_0) { avma = (pari_sp)(y+l); return NULL; }
    1535                 :            :   }
    1536                 :       3878 :   return y;
    1537                 :            : }
    1538                 :            : /* If q divides the ZX/ZV x, return the quotient. Otherwise NULL.
    1539                 :            :  * Stack clean; assumes lg(x) > 1 */
    1540                 :            : static GEN
    1541                 :       2534 : gen_z_divides(GEN x, ulong q, long imin)
    1542                 :            : {
    1543                 :            :   long i, l;
    1544                 :       2534 :   GEN y = cgetg_copy(x, &l);
    1545                 :            : 
    1546                 :       2534 :   y[1] = x[1]; /* Needed for ZX; no-op if ZV, overwritten in first iteration */
    1547         [ +  + ]:      35518 :   for (i = imin; i < l; i++)
    1548                 :            :   {
    1549                 :            :     ulong r;
    1550                 :      35182 :     GEN xi = gel(x,i);
    1551         [ +  + ]:      35182 :     if (!signe(xi)) { gel(y,i) = xi; continue; }
    1552                 :      21707 :     gel(y,i) = diviu_rem(xi, q, &r);
    1553         [ +  + ]:      21707 :     if (r) { avma = (pari_sp)(y+l); return NULL; }
    1554                 :      19509 :     affectsign_safe(xi, &gel(y,i));
    1555                 :            :   }
    1556                 :       2534 :   return y;
    1557                 :            : }
    1558                 :            : 
    1559                 :            : /* return v_q(x) and set *py = x / q^v_q(x), using divide & conquer */
    1560                 :            : static long
    1561                 :       6389 : gen_pvalrem_DC(GEN x, GEN q, GEN *py, long imin)
    1562                 :            : {
    1563                 :            : 
    1564                 :       6389 :   pari_sp av = avma;
    1565                 :       6389 :   long v, i, l, lz = LONG_MAX;
    1566                 :       6389 :   GEN y = cgetg_copy(x, &l);
    1567                 :            : 
    1568                 :       6389 :   y[1] = x[1];
    1569         [ +  + ]:     117400 :   for (i = imin; i < l; i++)
    1570                 :            :   {
    1571                 :     113522 :     GEN r, xi = gel(x,i);
    1572         [ +  + ]:     113522 :     if (!signe(xi)) { gel(y,i) = xi; continue; }
    1573                 :      71153 :     gel(y,i) = dvmdii(xi, q, &r);
    1574         [ +  + ]:      71153 :     if (r != gen_0) { avma = av; *py = x; return 0; }
    1575                 :      68642 :     lz = minss(lz, lgefint(gel(y,i)));
    1576                 :            :   }
    1577         [ +  + ]:       3878 :   if (2 * lgefint(q) <= lz+3) /* avoid squaring if pointless */
    1578                 :       3848 :     v = gen_pvalrem_DC(y, sqri(q), py, imin) << 1;
    1579                 :            :   else
    1580                 :         30 :   { v = 0; *py = y; }
    1581                 :            : 
    1582                 :       3878 :   y = gen_Z_divides(*py, q, imin);
    1583         [ +  + ]:       3878 :   if (!y) return v+1;
    1584                 :       6389 :   *py = y; return v+2;
    1585                 :            : }
    1586                 :            : 
    1587                 :            : static long
    1588                 :        336 : gen_2val(GEN x, long imin)
    1589                 :            : {
    1590                 :        336 :   long i, lx = lg(x), v = LONG_MAX;
    1591         [ +  + ]:        595 :   for (i = imin; i < lx; i++)
    1592                 :            :   {
    1593                 :        567 :     GEN c = gel(x,i);
    1594                 :            :     long w;
    1595         [ +  + ]:        567 :     if (!signe(c)) continue;
    1596                 :        434 :     w = vali(c);
    1597 [ +  + ][ +  + ]:        434 :     if (w < v) { v = w; if (!v) break; }
    1598                 :            :   }
    1599                 :        336 :   return v;
    1600                 :            : }
    1601                 :            : static long
    1602                 :       5127 : gen_lval(GEN x, ulong p, long imin)
    1603                 :            : {
    1604                 :            :   long i, lx, v;
    1605                 :            :   pari_sp av;
    1606                 :            :   GEN y;
    1607         [ +  + ]:       5127 :   if (p == 2) return gen_2val(x, imin);
    1608                 :       4791 :   av = avma;
    1609                 :       4791 :   lx = lg(x); y = leafcopy(x);
    1610                 :       4791 :   for(v = 0;; v++)
    1611         [ +  + ]:       6065 :     for (i = imin; i < lx; i++)
    1612                 :            :     {
    1613                 :       6009 :       ulong r; gel(y,i) = diviu_rem(gel(y,i), p, &r);
    1614         [ +  + ]:       6009 :       if (r) { avma = av; return v; }
    1615                 :       5183 :     }
    1616                 :            : }
    1617                 :            : long
    1618                 :         28 : ZX_lval(GEN x, ulong p) { return gen_lval(x, p, 2); }
    1619                 :            : long
    1620                 :          0 : ZV_lval(GEN x, ulong p) { return gen_lval(x, p, 1); }
    1621                 :            : 
    1622                 :            : static long
    1623                 :       7273 : gen_pval(GEN x, GEN p, long imin)
    1624                 :            : {
    1625                 :            :   long i, lx, v;
    1626                 :            :   pari_sp av;
    1627                 :            :   GEN y;
    1628         [ +  + ]:       7273 :   if (lgefint(p) == 3) return gen_lval(x, p[2], imin);
    1629                 :       2174 :   av = avma;
    1630                 :       2174 :   lx = lg(x); y = leafcopy(x);
    1631                 :       2174 :   for(v = 0;; v++)
    1632                 :            :   {
    1633         [ -  + ]:       2174 :     if (v == VAL_DC_THRESHOLD)
    1634                 :            :     {
    1635         [ #  # ]:          0 :       if (is_pm1(p)) pari_err_DOMAIN("gen_pval", "p", "=", p, p);
    1636                 :          0 :       v += gen_pvalrem_DC(y, p, &y, imin);
    1637                 :          0 :       avma = av; return v;
    1638                 :            :     }
    1639                 :            : 
    1640         [ +  - ]:       2174 :     for (i = imin; i < lx; i++)
    1641                 :            :     {
    1642                 :       2174 :       GEN r; gel(y,i) = dvmdii(gel(y,i), p, &r);
    1643         [ +  - ]:       2174 :       if (r != gen_0) { avma = av; return v; }
    1644                 :            :     }
    1645                 :       7273 :   }
    1646                 :            : }
    1647                 :            : long
    1648                 :       6307 : ZX_pval(GEN x, GEN p) { return gen_pval(x, p, 2); }
    1649                 :            : long
    1650                 :        966 : ZV_pval(GEN x, GEN p) { return gen_pval(x, p, 1); }
    1651                 :            : /* v = 0 (mod p) */
    1652                 :            : int
    1653                 :         49 : ZV_Z_dvd(GEN v, GEN p)
    1654                 :            : {
    1655                 :         49 :   pari_sp av = avma;
    1656                 :         49 :   long i, l = lg(v);
    1657         [ +  + ]:        168 :   for (i=1; i<l; i++)
    1658         [ -  + ]:        119 :     if (remii(gel(v,i), p) != gen_0) { avma = av; return 0; }
    1659                 :         49 :   avma = av; return 1;
    1660                 :            : }
    1661                 :            : 
    1662                 :            : static long
    1663                 :     266497 : gen_2valrem(GEN x, GEN *px, long imin)
    1664                 :            : {
    1665                 :     266497 :   long i, lx = lg(x), v = LONG_MAX;
    1666                 :            :   GEN z;
    1667         [ +  + ]:    3170545 :   for (i = imin; i < lx; i++)
    1668                 :            :   {
    1669                 :    3000382 :     GEN c = gel(x,i);
    1670                 :            :     long w;
    1671         [ +  + ]:    3000382 :     if (!signe(c)) continue;
    1672                 :    2866388 :     w = vali(c);
    1673         [ +  + ]:    2866388 :     if (w < v) {
    1674                 :     554848 :       v = w;
    1675         [ +  + ]:     554848 :       if (!v) { *px = x; return 0; } /* early abort */
    1676                 :            :     }
    1677                 :            :   }
    1678                 :     170163 :   z = cgetg_copy(x, &lx); z[1] = x[1];
    1679         [ +  + ]:    2852563 :   for (i=imin; i<lx; i++) gel(z,i) = shifti(gel(x,i), -v);
    1680                 :     266497 :   *px = z; return v;
    1681                 :            : }
    1682                 :            : static long
    1683                 :     527638 : gen_lvalrem(GEN x, ulong p, GEN *px, long imin)
    1684                 :            : {
    1685                 :            :   long i, lx, v;
    1686                 :            :   GEN y;
    1687         [ +  + ]:     527638 :   if (p == 2) return gen_2valrem(x, px, imin);
    1688                 :     261141 :   y = cgetg_copy(x, &lx);
    1689                 :     261141 :   y[1] = x[1];
    1690                 :     261141 :   x = leafcopy(x);
    1691                 :     261141 :   for(v = 0;; v++)
    1692                 :            :   {
    1693         [ +  + ]:     659163 :     if (v == VAL_DC_THRESHOLD)
    1694                 :            :     {
    1695         [ -  + ]:       2534 :       if (p == 1) pari_err_DOMAIN("gen_lvalrem", "p", "=", gen_1, gen_1);
    1696                 :       2534 :       v += gen_pvalrem_DC(x, sqru(p), px, imin) << 1;
    1697                 :       2534 :       x = gen_z_divides(*px, p, imin);
    1698         [ +  + ]:       2534 :       if (x) { *px = x; v++; }
    1699                 :       2534 :       return v;
    1700                 :            :     }
    1701                 :            : 
    1702         [ +  + ]:    5819089 :     for (i = imin; i < lx; i++)
    1703                 :            :     {
    1704                 :    5421067 :       ulong r; gel(y,i) = diviu_rem(gel(x,i), p, &r);
    1705         [ +  + ]:    5421067 :       if (r) { *px = x; return v; }
    1706                 :    5162460 :       affectsign_safe(gel(x,i), &gel(y,i));
    1707                 :            :     }
    1708                 :     398022 :     swap(x, y);
    1709                 :     925660 :   }
    1710                 :            : }
    1711                 :            : long
    1712                 :          0 : ZX_lvalrem(GEN x, ulong p, GEN *px) { return gen_lvalrem(x,p,px, 2); }
    1713                 :            : long
    1714                 :          0 : ZV_lvalrem(GEN x, ulong p, GEN *px) { return gen_lvalrem(x,p,px, 1); }
    1715                 :            : 
    1716                 :            : static long
    1717                 :     527674 : gen_pvalrem(GEN x, GEN p, GEN *px, long imin)
    1718                 :            : {
    1719                 :            :   long i, lx, v;
    1720                 :            :   GEN y;
    1721         [ +  + ]:     527674 :   if (lgefint(p) == 3) return gen_lvalrem(x, p[2], px, imin);
    1722                 :         36 :   y = cgetg_copy(x, &lx);
    1723                 :         36 :   y[1] = x[1];
    1724                 :         36 :   x = leafcopy(x);
    1725                 :         36 :   for(v = 0;; v++)
    1726                 :            :   {
    1727         [ +  + ]:        160 :     if (v == VAL_DC_THRESHOLD)
    1728                 :            :     {
    1729         [ -  + ]:          7 :       if (is_pm1(p)) pari_err_DOMAIN("gen_pvalrem", "p", "=", p, p);
    1730                 :          7 :       return v + gen_pvalrem_DC(x, p, px, imin);
    1731                 :            :     }
    1732                 :            : 
    1733         [ +  + ]:       3693 :     for (i = imin; i < lx; i++)
    1734                 :            :     {
    1735                 :       3569 :       GEN r; gel(y,i) = dvmdii(gel(x,i), p, &r);
    1736         [ +  + ]:       3569 :       if (r != gen_0) { *px = x; return v; }
    1737                 :            :     }
    1738                 :        124 :     swap(x, y);
    1739                 :     527798 :   }
    1740                 :            : }
    1741                 :            : long
    1742                 :     523257 : ZX_pvalrem(GEN x, GEN p, GEN *px) { return gen_pvalrem(x,p,px, 2); }
    1743                 :            : long
    1744                 :       4417 : ZV_pvalrem(GEN x, GEN p, GEN *px) { return gen_pvalrem(x,p,px, 1); }
    1745                 :            : 
    1746                 :            : /*******************************************************************/
    1747                 :            : /*                                                                 */
    1748                 :            : /*                       NEGATION: Create -x                       */
    1749                 :            : /*                                                                 */
    1750                 :            : /*******************************************************************/
    1751                 :            : 
    1752                 :            : GEN
    1753                 :  191449165 : gneg(GEN x)
    1754                 :            : {
    1755                 :            :   long lx, i;
    1756                 :            :   GEN y;
    1757                 :            : 
    1758   [ +  +  +  +  :  191449165 :   switch(typ(x))
          +  +  +  +  +  
          +  +  +  +  +  
                +  +  - ]
    1759                 :            :   {
    1760                 :            :     case t_INT:
    1761         [ +  + ]:   56019767 :       return signe(x)? negi(x): gen_0;
    1762                 :            :     case t_REAL:
    1763                 :   92127424 :       return mpneg(x);
    1764                 :            : 
    1765                 :     142915 :     case t_INTMOD: y=cgetg(3,t_INTMOD);
    1766                 :     142915 :       gel(y,1) = icopy(gel(x,1));
    1767         [ +  + ]:     142915 :       gel(y,2) = signe(gel(x,2))? subii(gel(y,1),gel(x,2)): gen_0;
    1768                 :     142915 :       break;
    1769                 :            : 
    1770                 :            :     case t_FRAC:
    1771                 :     951426 :       y = cgetg(3, t_FRAC);
    1772                 :     951426 :       gel(y,1) = negi(gel(x,1));
    1773                 :     951426 :       gel(y,2) = icopy(gel(x,2)); break;
    1774                 :            : 
    1775                 :            :     case t_COMPLEX:
    1776                 :   40811276 :       y=cgetg(3, t_COMPLEX);
    1777                 :   40811276 :       gel(y,1) = gneg(gel(x,1));
    1778                 :   40811276 :       gel(y,2) = gneg(gel(x,2));
    1779                 :   40811276 :       break;
    1780                 :            : 
    1781                 :      21242 :     case t_POLMOD: y=cgetg(3,t_POLMOD);
    1782                 :      21242 :       gel(y,1) = RgX_copy(gel(x,1));
    1783                 :      21242 :       gel(y,2) = gneg(gel(x,2)); break;
    1784                 :            : 
    1785                 :            :     case t_RFRAC:
    1786                 :     153041 :       y = cgetg(3, t_RFRAC);
    1787                 :     153041 :       gel(y,1) = gneg(gel(x,1));
    1788                 :     153041 :       gel(y,2) = RgX_copy(gel(x,2)); break;
    1789                 :            : 
    1790                 :            :     case t_PADIC:
    1791         [ +  + ]:       5411 :       if (!signe(gel(x,4))) return gcopy(x);
    1792                 :       4592 :       y = cgetg(5, t_PADIC);
    1793                 :       4592 :       y[1] = x[1];
    1794                 :       4592 :       gel(y,2) = icopy(gel(x,2));
    1795                 :       4592 :       gel(y,3) = icopy(gel(x,3));
    1796                 :       4592 :       gel(y,4) = subii(gel(x,3),gel(x,4));
    1797                 :       4592 :       break;
    1798                 :            : 
    1799                 :            :     case t_QUAD:
    1800                 :         42 :       y=cgetg(4,t_QUAD);
    1801                 :         42 :       gel(y,1) = ZX_copy(gel(x,1));
    1802                 :         42 :       gel(y,2) = gneg(gel(x,2));
    1803                 :         42 :       gel(y,3) = gneg(gel(x,3)); break;
    1804                 :            : 
    1805                 :      20241 :     case t_FFELT: return FF_neg(x);
    1806                 :    1166719 :     case t_POL: return RgX_neg(x);
    1807                 :            :     case t_SER:
    1808                 :       1316 :       y = cgetg_copy(x, &lx); y[1] = x[1];
    1809         [ +  + ]:       7910 :       for (i=2; i<lx; i++) gel(y,i) = gneg(gel(x,i));
    1810                 :       1316 :       break;
    1811                 :       6343 :     case t_VEC: return RgV_neg(x);
    1812                 :      19034 :     case t_COL: return RgC_neg(x);
    1813                 :       2317 :     case t_MAT: return RgM_neg(x);
    1814         [ +  - ]:        651 :     case t_INFINITY: return inf_get_sign(x) == 1? mkmoo(): mkoo();
    1815                 :            :     default:
    1816                 :          0 :       pari_err_TYPE("gneg",x);
    1817                 :          0 :       return NULL; /* not reached */
    1818                 :            :   }
    1819                 :  191449165 :   return y;
    1820                 :            : }
    1821                 :            : 
    1822                 :            : GEN
    1823                 :   39173566 : gneg_i(GEN x)
    1824                 :            : {
    1825                 :            :   long lx, i;
    1826                 :            :   GEN y;
    1827                 :            : 
    1828   [ +  +  +  +  :   39173566 :   switch(typ(x))
          +  +  +  +  +  
             +  +  +  - ]
    1829                 :            :   {
    1830                 :            :     case t_INT:
    1831         [ +  + ]:   22396737 :       return signe(x)? negi(x): gen_0;
    1832                 :            :     case t_REAL:
    1833                 :    3591869 :       return mpneg(x);
    1834                 :            : 
    1835                 :       8704 :     case t_INTMOD: y=cgetg(3,t_INTMOD);
    1836                 :       8704 :       gel(y,1) = gel(x,1);
    1837         [ +  + ]:       8704 :       gel(y,2) = signe(gel(x,2))? subii(gel(y,1),gel(x,2)): gen_0;
    1838                 :       8704 :       break;
    1839                 :            : 
    1840                 :            :     case t_FRAC:
    1841                 :    1086845 :       y = cgetg(3, t_FRAC);
    1842                 :    1086845 :       gel(y,1) = negi(gel(x,1));
    1843                 :    1086845 :       gel(y,2) = gel(x,2); break;
    1844                 :            : 
    1845                 :            :     case t_COMPLEX:
    1846                 :     871797 :       y = cgetg(3, t_COMPLEX);
    1847                 :     871797 :       gel(y,1) = gneg_i(gel(x,1));
    1848                 :     871797 :       gel(y,2) = gneg_i(gel(x,2)); break;
    1849                 :            : 
    1850                 :        903 :     case t_PADIC: y = cgetg(5,t_PADIC);
    1851                 :        903 :       y[1] = x[1];
    1852                 :        903 :       gel(y,2) = gel(x,2);
    1853                 :        903 :       gel(y,3) = gel(x,3);
    1854         [ +  + ]:        903 :       gel(y,4) = signe(gel(x,4))? subii(gel(x,3),gel(x,4)): gen_0; break;
    1855                 :            : 
    1856                 :      61532 :     case t_POLMOD: y=cgetg(3,t_POLMOD);
    1857                 :      61532 :       gel(y,1) = gel(x,1);
    1858                 :      61532 :       gel(y,2) = gneg_i(gel(x,2)); break;
    1859                 :            : 
    1860                 :      83107 :     case t_FFELT: return FF_neg_i(x);
    1861                 :            : 
    1862                 :        609 :     case t_QUAD: y=cgetg(4,t_QUAD);
    1863                 :        609 :       gel(y,1) = gel(x,1);
    1864                 :        609 :       gel(y,2) = gneg_i(gel(x,2));
    1865                 :        609 :       gel(y,3) = gneg_i(gel(x,3)); break;
    1866                 :            : 
    1867                 :            :     case t_VEC: case t_COL: case t_MAT:
    1868                 :      46634 :       y = cgetg_copy(x, &lx);
    1869         [ +  + ]:     135331 :       for (i=1; i<lx; i++) gel(y,i) = gneg_i(gel(x,i));
    1870                 :      46634 :       break;
    1871                 :            : 
    1872                 :            :     case t_POL: case t_SER:
    1873                 :    6067486 :       y = cgetg_copy(x, &lx); y[1]=x[1];
    1874         [ +  + ]:   19250402 :       for (i=2; i<lx; i++) gel(y,i) = gneg_i(gel(x,i));
    1875                 :    6067486 :       break;
    1876                 :            : 
    1877                 :            :     case t_RFRAC:
    1878                 :    4957343 :       y = cgetg(3, t_RFRAC);
    1879                 :    4957343 :       gel(y,1) = gneg_i(gel(x,1));
    1880                 :    4957343 :       gel(y,2) = gel(x,2); break;
    1881                 :            : 
    1882                 :            :     default:
    1883                 :          0 :       pari_err_TYPE("gneg_i",x);
    1884                 :          0 :       return NULL; /* not reached */
    1885                 :            :   }
    1886                 :   39173566 :   return y;
    1887                 :            : }
    1888                 :            : 
    1889                 :            : /******************************************************************/
    1890                 :            : /*                                                                */
    1891                 :            : /*                       ABSOLUTE VALUE                           */
    1892                 :            : /*    Create abs(x) if x is integer, real, fraction or complex.   */
    1893                 :            : /*                       Error otherwise.                         */
    1894                 :            : /*                                                                */
    1895                 :            : /******************************************************************/
    1896                 :            : static int
    1897                 :          0 : is_negative(GEN x) {
    1898      [ #  #  # ]:          0 :   switch(typ(x))
    1899                 :            :   {
    1900                 :            :     case t_INT: case t_REAL:
    1901                 :          0 :       return (signe(x) < 0);
    1902                 :            :     case t_FRAC:
    1903                 :          0 :       return (signe(gel(x,1)) < 0);
    1904                 :            :   }
    1905                 :          0 :   return 0;
    1906                 :            : }
    1907                 :            : 
    1908                 :            : GEN
    1909                 :    7638177 : gabs(GEN x, long prec)
    1910                 :            : {
    1911                 :            :   long lx, i;
    1912                 :            :   pari_sp av, tetpil;
    1913                 :            :   GEN y,p1;
    1914                 :            : 
    1915   [ +  +  +  +  :    7638177 :   switch(typ(x))
             -  +  +  - ]
    1916                 :            :   {
    1917                 :            :     case t_INT: case t_REAL:
    1918                 :    6026708 :       return mpabs(x);
    1919                 :            : 
    1920                 :            :     case t_FRAC:
    1921                 :        378 :       return absfrac(x);
    1922                 :            : 
    1923                 :            :     case t_COMPLEX:
    1924                 :    1601634 :       av=avma; p1=cxnorm(x);
    1925      [ +  +  + ]:    1601634 :       switch(typ(p1))
    1926                 :            :       {
    1927                 :            :         case t_INT:
    1928         [ +  + ]:        903 :           if (!Z_issquareall(p1, &y)) break;
    1929                 :        693 :           return gerepileupto(av, y);
    1930                 :            :         case t_FRAC: {
    1931                 :            :           GEN a,b;
    1932         [ +  + ]:         56 :           if (!Z_issquareall(gel(p1,1), &a)) break;
    1933         [ -  + ]:         42 :           if (!Z_issquareall(gel(p1,2), &b)) break;
    1934                 :         56 :           return gerepileupto(av, gdiv(a,b));
    1935                 :            :         }
    1936                 :            :       }
    1937                 :    1600941 :       tetpil=avma;
    1938                 :    1600941 :       return gerepile(av,tetpil,gsqrt(p1,prec));
    1939                 :            : 
    1940                 :            :     case t_QUAD:
    1941                 :         21 :       av = avma;
    1942                 :         21 :       return gerepileuptoleaf(av, gabs(quadtofp(x, prec), prec));
    1943                 :            : 
    1944                 :            :     case t_POL:
    1945         [ #  # ]:          0 :       lx = lg(x); if (lx<=2) return RgX_copy(x);
    1946         [ #  # ]:          0 :       return is_negative(gel(x,lx-1))? gneg(x): RgX_copy(x);
    1947                 :            : 
    1948                 :            :     case t_SER:
    1949         [ -  + ]:          7 :      if (!signe(x)) pari_err_DOMAIN("abs", "argument", "=", gen_0, x);
    1950         [ +  - ]:          7 :      if (valp(x)) pari_err_DOMAIN("abs", "series valuation", "!=", gen_0, x);
    1951         [ #  # ]:          0 :      return is_negative(gel(x,2))? gneg(x): gcopy(x);
    1952                 :            : 
    1953                 :            :     case t_VEC: case t_COL: case t_MAT:
    1954                 :       9429 :       y = cgetg_copy(x, &lx);
    1955         [ +  + ]:      73486 :       for (i=1; i<lx; i++) gel(y,i) = gabs(gel(x,i),prec);
    1956                 :       9429 :       return y;
    1957                 :            :   }
    1958                 :          0 :   pari_err_TYPE("gabs",x);
    1959                 :    7638170 :   return NULL; /* not reached */
    1960                 :            : }
    1961                 :            : 
    1962                 :            : GEN
    1963         [ +  + ]:    7830131 : gmax(GEN x, GEN y) { return gcopy(gcmp(x,y)<0? y: x); }
    1964                 :            : GEN
    1965         [ #  # ]:          0 : gmaxgs(GEN x, long s) { return (gcmpsg(s,x)>=0)? stoi(s): gcopy(x); }
    1966                 :            : 
    1967                 :            : GEN
    1968         [ +  + ]:      89712 : gmin(GEN x, GEN y) { return gcopy(gcmp(x,y)<0? x: y); }
    1969                 :            : GEN
    1970         [ #  # ]:          0 : gmings(GEN x, long s) { return (gcmpsg(s,x)>0)? gcopy(x): stoi(s); }
    1971                 :            : 
    1972                 :            : long
    1973                 :       5716 : vecindexmax(GEN x)
    1974                 :            : {
    1975                 :       5716 :   long lx = lg(x), i0, i;
    1976                 :            :   GEN s;
    1977                 :            : 
    1978         [ +  + ]:       5716 :   if (lx==1) pari_err_DOMAIN("vecindexmax", "empty argument", "=", x,x);
    1979      [ +  -  - ]:       5702 :   switch(typ(x))
    1980                 :            :   {
    1981                 :            :     case t_VEC: case t_COL:
    1982                 :       5702 :       s = gel(x,i0=1);
    1983         [ +  + ]:      19951 :       for (i=2; i<lx; i++)
    1984         [ +  + ]:      14249 :         if (gcmp(gel(x,i),s) > 0) s = gel(x,i0=i);
    1985                 :       5702 :       return i0;
    1986                 :            :     case t_VECSMALL:
    1987                 :          0 :       return vecsmall_indexmax(x);
    1988                 :          0 :     default: pari_err_TYPE("vecindexmax",x);
    1989                 :            :   }
    1990                 :            :   /* NOT REACHED */
    1991                 :       5702 :   return 0;
    1992                 :            : }
    1993                 :            : long
    1994                 :       5485 : vecindexmin(GEN x)
    1995                 :            : {
    1996                 :       5485 :   long lx = lg(x), i0, i;
    1997                 :            :   GEN s;
    1998                 :            : 
    1999         [ +  + ]:       5485 :   if (lx==1) pari_err_DOMAIN("vecindexmin", "empty argument", "=", x,x);
    2000      [ +  -  - ]:       5478 :   switch(typ(x))
    2001                 :            :   {
    2002                 :            :     case t_VEC: case t_COL:
    2003                 :       5478 :       s = gel(x,i0=1);
    2004         [ +  + ]:      10753 :       for (i=2; i<lx; i++)
    2005         [ -  + ]:       5275 :         if (gcmp(gel(x,i),s) < 0) s = gel(x,i0=i);
    2006                 :       5478 :       return i0;
    2007                 :            :     case t_VECSMALL:
    2008                 :          0 :       return vecsmall_indexmin(x);
    2009                 :          0 :     default: pari_err_TYPE("vecindexmin",x);
    2010                 :            :   }
    2011                 :            :   /* NOT REACHED */
    2012                 :       5478 :   return 0;
    2013                 :            : }
    2014                 :            : 
    2015                 :            : 
    2016                 :            : GEN
    2017                 :       1762 : vecmax0(GEN x, GEN *pi)
    2018                 :            : {
    2019                 :            :   long i0, j0, i, j;
    2020                 :            :   GEN s;
    2021   [ +  +  +  + ]:       1762 :   switch(typ(x))
    2022                 :            :   {
    2023                 :            :     case t_VEC: case t_COL:
    2024                 :       1309 :       i = vecindexmax(x);
    2025         [ +  + ]:       1295 :       if (pi) *pi = utoipos(i);
    2026                 :       1295 :       return gcopy(gel(x, i));
    2027                 :            :     case t_MAT: {
    2028                 :        425 :       long lx2, lx = lg(x);
    2029 [ +  - ][ +  + ]:        425 :       if (lx==1 || (lx2 = lgcols(x)) == 1)
    2030                 :            :       {
    2031                 :          7 :         pari_err_DOMAIN("vecmax", "empty argument", "=", x,x);
    2032                 :          0 :         return NULL;/*not reached*/
    2033                 :            :       }
    2034                 :        418 :       s = gcoeff(x,i0=1,j0=1); i = 2;
    2035         [ +  + ]:       1660 :       for (j=1; j<lx; j++,i=1)
    2036                 :            :       {
    2037                 :       1242 :         GEN c = gel(x,j);
    2038         [ +  + ]:      24574 :         for (; i<lx2; i++)
    2039         [ +  + ]:      23332 :           if (gcmp(gel(c,i),s) > 0) { s = gel(c,i); j0=j; i0=i; }
    2040                 :            :       }
    2041         [ +  + ]:        418 :       if (pi) *pi = mkvec2(utoipos(i0), utoipos(j0));
    2042                 :        418 :       return gcopy(s);
    2043                 :            :     }
    2044                 :            :     case t_VECSMALL:
    2045                 :         14 :       i = vecsmall_indexmax(x);
    2046         [ +  + ]:         14 :       if (pi) *pi = utoipos(i);
    2047                 :         14 :       return stoi(x[i]);
    2048                 :            :     default:
    2049                 :       1741 :       return gcopy(x);
    2050                 :            :   }
    2051                 :            : }
    2052                 :            : GEN
    2053                 :       5527 : vecmin0(GEN x, GEN *pi)
    2054                 :            : {
    2055                 :            :   long i0, j0, i, j;
    2056                 :            :   GEN s;
    2057   [ +  +  +  + ]:       5527 :   switch(typ(x))
    2058                 :            :   {
    2059                 :            :     case t_VEC: case t_COL:
    2060                 :       5485 :       i = vecindexmin(x);
    2061         [ +  + ]:       5478 :       if (pi) *pi = utoipos(i);
    2062                 :       5478 :       return gcopy(gel(x, i));
    2063                 :            :     case t_MAT: {
    2064                 :         14 :       long lx2, lx = lg(x);
    2065 [ +  - ][ -  + ]:         14 :       if (lx==1 || (lx2 = lgcols(x)) == 1)
    2066                 :            :       {
    2067                 :          0 :         pari_err_DOMAIN("vecmin", "empty argument", "=", x,x);
    2068                 :          0 :         return NULL;/*not reached*/
    2069                 :            :       }
    2070                 :         14 :       s = gcoeff(x,i0=1,j0=1); i = 2;
    2071         [ +  + ]:         42 :       for (j=1; j<lx; j++,i=1)
    2072                 :            :       {
    2073                 :         28 :         GEN c = gel(x,j);
    2074         [ +  + ]:         70 :         for (; i<lx2; i++)
    2075         [ -  + ]:         42 :           if (gcmp(gel(c,i),s) < 0) { s = gel(c,i); j0=j; i0=i; }
    2076                 :            :       }
    2077         [ +  + ]:         14 :       if (pi) *pi = mkvec2(utoipos(i0), utoipos(j0));
    2078                 :         14 :       return gcopy(s);
    2079                 :            :     }
    2080                 :            :     case t_VECSMALL:
    2081                 :         14 :       i = vecsmall_indexmin(x);
    2082         [ +  + ]:         14 :       if (pi) *pi = utoipos(i);
    2083                 :         14 :       return stoi(x[i]);
    2084                 :            :     default:
    2085                 :       5520 :       return gcopy(x);
    2086                 :            :   }
    2087                 :            : }
    2088                 :            : 
    2089                 :            : GEN
    2090                 :       1622 : vecmax(GEN x) { return vecmax0(x, NULL); }
    2091                 :            : GEN
    2092                 :       5457 : vecmin(GEN x) { return vecmin0(x, NULL); }
    2093                 :            : 
    2094                 :            : /*******************************************************************/
    2095                 :            : /*                                                                 */
    2096                 :            : /*                      AFFECT long --> GEN                        */
    2097                 :            : /*         affect long s to GEN x. Useful for initialization.      */
    2098                 :            : /*                                                                 */
    2099                 :            : /*******************************************************************/
    2100                 :            : 
    2101                 :            : static void
    2102                 :          0 : padicaff0(GEN x)
    2103                 :            : {
    2104         [ #  # ]:          0 :   if (signe(gel(x,4)))
    2105                 :            :   {
    2106                 :          0 :     x[1] = evalvalp(valp(x)+precp(x));
    2107                 :          0 :     affsi(0,gel(x,4));
    2108                 :            :   }
    2109                 :          0 : }
    2110                 :            : 
    2111                 :            : void
    2112                 :        980 : gaffsg(long s, GEN x)
    2113                 :            : {
    2114   [ -  +  -  -  :        980 :   switch(typ(x))
             -  -  -  - ]
    2115                 :            :   {
    2116                 :          0 :     case t_INT: affsi(s,x); break;
    2117                 :        980 :     case t_REAL: affsr(s,x); break;
    2118                 :          0 :     case t_INTMOD: modsiz(s,gel(x,1),gel(x,2)); break;
    2119                 :          0 :     case t_FRAC: affsi(s,gel(x,1)); affsi(1,gel(x,2)); break;
    2120                 :          0 :     case t_COMPLEX: gaffsg(s,gel(x,1)); gaffsg(0,gel(x,2)); break;
    2121                 :            :     case t_PADIC: {
    2122                 :            :       long vx;
    2123                 :            :       GEN y;
    2124         [ #  # ]:          0 :       if (!s) { padicaff0(x); break; }
    2125                 :          0 :       vx = Z_pvalrem(stoi(s), gel(x,2), &y);
    2126                 :          0 :       setvalp(x,vx); modiiz(y,gel(x,3),gel(x,4));
    2127                 :            :       break;
    2128                 :            :     }
    2129                 :          0 :     case t_QUAD: gaffsg(s,gel(x,2)); gaffsg(0,gel(x,3)); break;
    2130                 :          0 :     default: pari_err_TYPE2("=",stoi(s),x);
    2131                 :            :   }
    2132                 :        980 : }
    2133                 :            : 
    2134                 :            : /*******************************************************************/
    2135                 :            : /*                                                                 */
    2136                 :            : /*                     GENERIC AFFECTATION                         */
    2137                 :            : /*         Affect the content of x to y, whenever possible         */
    2138                 :            : /*                                                                 */
    2139                 :            : /*******************************************************************/
    2140                 :            : /* x PADIC, Y INT, return lift(x * Mod(1,Y)) */
    2141                 :            : GEN
    2142                 :         56 : padic_to_Fp(GEN x, GEN Y) {
    2143                 :         56 :   pari_sp av = avma;
    2144                 :         56 :   GEN p = gel(x,2), z;
    2145                 :         56 :   long vy, vx = valp(x);
    2146         [ -  + ]:         56 :   if (!signe(Y)) pari_err_INV("padic_to_Fp",Y);
    2147                 :         56 :   vy = Z_pvalrem(Y,p, &z);
    2148 [ +  - ][ +  + ]:         56 :   if (vx < 0 || !gequal1(z)) pari_err_OP("",x, mkintmod(gen_1,Y));
    2149         [ -  + ]:         42 :   if (vx >= vy) { avma = av; return gen_0; }
    2150                 :         42 :   z = gel(x,4);
    2151 [ +  - ][ -  + ]:         42 :   if (!signe(z) || vy > vx + precp(x)) pari_err_OP("",x, mkintmod(gen_1,Y));
    2152         [ -  + ]:         42 :   if (vx) z = mulii(z, powiu(p,vx));
    2153                 :         42 :   return gerepileuptoint(av, remii(z, Y));
    2154                 :            : }
    2155                 :            : ulong
    2156                 :         77 : padic_to_Fl(GEN x, ulong Y) {
    2157                 :         77 :   GEN p = gel(x,2);
    2158                 :            :   ulong u, z;
    2159                 :         77 :   long vy, vx = valp(x);
    2160                 :         77 :   vy = u_pvalrem(Y,p, &u);
    2161 [ +  - ][ -  + ]:         77 :   if (vx < 0 || u != 1) pari_err_OP("",x, mkintmodu(1,Y));
    2162                 :            :   /* Y = p^vy */
    2163         [ +  + ]:         77 :   if (vx >= vy) return 0;
    2164                 :         70 :   z = umodiu(gel(x,4), Y);
    2165 [ +  - ][ -  + ]:         70 :   if (!z || vy > vx + precp(x)) pari_err_OP("",x, mkintmodu(1,Y));
    2166         [ -  + ]:         70 :   if (vx) {
    2167                 :          0 :     ulong pp = p[2];
    2168                 :          0 :     z = Fl_mul(z, upowuu(pp,vx), Y); /* p^vx < p^vy = Y */
    2169                 :            :   }
    2170                 :         77 :   return z;
    2171                 :            : }
    2172                 :            : 
    2173                 :            : static void
    2174                 :          0 : croak(const char *s) {
    2175                 :            :   char *t;
    2176                 :          0 :   t = stack_sprintf("gaffect [overwriting universal object: %s]",s);
    2177                 :          0 :   pari_err_BUG(t);
    2178                 :          0 : }
    2179                 :            : 
    2180                 :            : void
    2181                 :     246200 : gaffect(GEN x, GEN y)
    2182                 :            : {
    2183                 :     246200 :   long vx, i, lx, ly, tx = typ(x), ty = typ(y);
    2184                 :            :   pari_sp av;
    2185                 :            :   GEN p1, num, den;
    2186                 :            : 
    2187 [ +  + ][ +  +  :     246200 :   if (tx == ty) switch(tx) {
          -  -  +  -  -  
                   +  - ]
    2188                 :            :     case t_INT:
    2189         [ +  - ]:     119829 :       if (!is_universal_constant(y)) { affii(x,y); return; }
    2190                 :            :       /* y = gen_0, gnil, gen_1 or gen_2 */
    2191         [ #  # ]:          0 :       if (y==gen_0)  croak("gen_0");
    2192         [ #  # ]:          0 :       if (y==gen_1)  croak("gen_1");
    2193         [ #  # ]:          0 :       if (y==gen_m1) croak("gen_m1");
    2194         [ #  # ]:          0 :       if (y==gen_m2) croak("gen_m2");
    2195         [ #  # ]:          0 :       if (y==gen_2)  croak("gen_2");
    2196                 :          0 :       croak("gnil)");
    2197                 :      51501 :     case t_REAL: affrr(x,y); return;
    2198                 :            :     case t_INTMOD:
    2199         [ #  # ]:          0 :       if (!dvdii(gel(x,1),gel(y,1))) pari_err_OP("",x,y);
    2200                 :          0 :       modiiz(gel(x,2),gel(y,1),gel(y,2)); return;
    2201                 :            :     case t_FRAC:
    2202                 :          0 :       affii(gel(x,1),gel(y,1));
    2203                 :          0 :       affii(gel(x,2),gel(y,2)); return;
    2204                 :            :     case t_COMPLEX:
    2205                 :       1799 :       gaffect(gel(x,1),gel(y,1));
    2206                 :       1799 :       gaffect(gel(x,2),gel(y,2)); return;
    2207                 :            :     case t_PADIC:
    2208         [ #  # ]:          0 :       if (!equalii(gel(x,2),gel(y,2))) pari_err_OP("",x,y);
    2209                 :          0 :       modiiz(gel(x,4),gel(y,3),gel(y,4));
    2210                 :          0 :       setvalp(y,valp(x)); return;
    2211                 :            :     case t_QUAD:
    2212         [ #  # ]:          0 :       if (! ZX_equal(gel(x,1),gel(y,1))) pari_err_OP("",x,y);
    2213                 :          0 :       affii(gel(x,2),gel(y,2));
    2214                 :          0 :       affii(gel(x,3),gel(y,3)); return;
    2215                 :            :     case t_VEC: case t_COL: case t_MAT:
    2216         [ -  + ]:      72077 :       lx = lg(x); if (lx != lg(y)) pari_err_DIM("gaffect");
    2217         [ +  + ]:     191906 :       for (i=1; i<lx; i++) gaffect(gel(x,i),gel(y,i));
    2218                 :            :       return;
    2219                 :            :   }
    2220                 :            : 
    2221                 :            :   /* Various conversions. Avoid them, use specialized routines ! */
    2222                 :            : 
    2223         [ -  + ]:        994 :   if (!is_const_t(ty)) pari_err_TYPE2("=",x,y);
    2224   [ -  +  +  -  :        994 :   switch(tx)
                -  -  - ]
    2225                 :            :   {
    2226                 :            :     case t_INT:
    2227   [ #  #  #  #  :          0 :       switch(ty)
                   #  # ]
    2228                 :            :       {
    2229                 :            :         case t_REAL:
    2230                 :          0 :           affir(x,y); break;
    2231                 :            : 
    2232                 :            :         case t_INTMOD:
    2233                 :          0 :           modiiz(x,gel(y,1),gel(y,2)); break;
    2234                 :            : 
    2235                 :            :         case t_COMPLEX:
    2236                 :          0 :           gaffect(x,gel(y,1)); gaffsg(0,gel(y,2)); break;
    2237                 :            : 
    2238                 :            :         case t_PADIC:
    2239         [ #  # ]:          0 :           if (!signe(x)) { padicaff0(y); break; }
    2240                 :          0 :           av = avma;
    2241                 :          0 :           setvalp(y, Z_pvalrem(x,gel(y,2),&p1));
    2242                 :          0 :           affii(modii(p1,gel(y,3)), gel(y,4));
    2243                 :          0 :           avma = av; break;
    2244                 :            : 
    2245                 :          0 :         case t_QUAD: gaffect(x,gel(y,2)); gaffsg(0,gel(y,3)); break;
    2246                 :          0 :         default: pari_err_TYPE2("=",x,y);
    2247                 :            :       }
    2248                 :          0 :       break;
    2249                 :            : 
    2250                 :            :     case t_REAL:
    2251         [ +  - ]:        980 :       switch(ty)
    2252                 :            :       {
    2253                 :        980 :         case t_COMPLEX: gaffect(x,gel(y,1)); gaffsg(0,gel(y,2)); break;
    2254                 :          0 :         default: pari_err_TYPE2("=",x,y);
    2255                 :            :       }
    2256                 :        980 :       break;
    2257                 :            : 
    2258                 :            :     case t_FRAC:
    2259   [ +  -  -  -  :         14 :       switch(ty)
                   -  - ]
    2260                 :            :       {
    2261                 :         14 :         case t_REAL: rdiviiz(gel(x,1),gel(x,2), y); break;
    2262                 :          0 :         case t_INTMOD: av = avma;
    2263                 :          0 :           p1 = Fp_inv(gel(x,2),gel(y,1));
    2264                 :          0 :           affii(modii(mulii(gel(x,1),p1),gel(y,1)), gel(y,2));
    2265                 :          0 :           avma = av; break;
    2266                 :          0 :         case t_COMPLEX: gaffect(x,gel(y,1)); gaffsg(0,gel(y,2)); break;
    2267                 :            :         case t_PADIC:
    2268         [ #  # ]:          0 :           if (!signe(gel(x,1))) { padicaff0(y); break; }
    2269                 :          0 :           num = gel(x,1);
    2270                 :          0 :           den = gel(x,2);
    2271                 :          0 :           av = avma; vx = Z_pvalrem(num, gel(y,2), &num);
    2272         [ #  # ]:          0 :           if (!vx) vx = -Z_pvalrem(den,gel(y,2),&den);
    2273                 :          0 :           setvalp(y,vx);
    2274                 :          0 :           p1 = mulii(num,Fp_inv(den,gel(y,3)));
    2275                 :          0 :           affii(modii(p1,gel(y,3)), gel(y,4)); avma = av; break;
    2276                 :          0 :         case t_QUAD: gaffect(x,gel(y,2)); gaffsg(0,gel(y,3)); break;
    2277                 :          0 :         default: pari_err_TYPE2("=",x,y);
    2278                 :            :       }
    2279                 :         14 :       break;
    2280                 :            : 
    2281                 :            :     case t_COMPLEX:
    2282         [ #  # ]:          0 :       if (!gequal0(gel(x,2))) pari_err_TYPE2("=",x,y);
    2283                 :          0 :       gaffect(gel(x,1), y);
    2284                 :          0 :       break;
    2285                 :            : 
    2286                 :            :     case t_PADIC:
    2287         [ #  # ]:          0 :       switch(ty)
    2288                 :            :       {
    2289                 :            :         case t_INTMOD:
    2290                 :          0 :           av = avma; affii(padic_to_Fp(x, gel(y,1)), gel(y,2));
    2291                 :          0 :           avma = av; break;
    2292                 :          0 :         default: pari_err_TYPE2("=",x,y);
    2293                 :            :       }
    2294                 :          0 :       break;
    2295                 :            : 
    2296                 :            :     case t_QUAD:
    2297   [ #  #  #  # ]:          0 :       switch(ty)
    2298                 :            :       {
    2299                 :            :         case t_INT: case t_INTMOD: case t_FRAC: case t_PADIC:
    2300                 :          0 :           pari_err_TYPE2("=",x,y);
    2301                 :            : 
    2302                 :            :         case t_REAL:
    2303                 :          0 :           av = avma; affgr(quadtofp(x,realprec(y)), y); avma = av; break;
    2304                 :            :         case t_COMPLEX:
    2305         [ #  # ]:          0 :           ly = precision(y); if (!ly) pari_err_TYPE2("=",x,y);
    2306                 :          0 :           av = avma; gaffect(quadtofp(x,ly), y); avma = av; break;
    2307                 :          0 :         default: pari_err_TYPE2("=",x,y);
    2308                 :            :       }
    2309                 :     246200 :     default: pari_err_TYPE2("=",x,y);
    2310                 :            :   }
    2311                 :            : }
    2312                 :            : 
    2313                 :            : /*******************************************************************/
    2314                 :            : /*                                                                 */
    2315                 :            : /*           CONVERSION QUAD --> REAL, COMPLEX OR P-ADIC           */
    2316                 :            : /*                                                                 */
    2317                 :            : /*******************************************************************/
    2318                 :            : GEN
    2319                 :        112 : quadtofp(GEN x, long prec)
    2320                 :            : {
    2321                 :        112 :   GEN z, Q, u = gel(x,2), v = gel(x,3);
    2322                 :            :   pari_sp av;
    2323         [ -  + ]:        112 :   if (prec < LOWDEFAULTPREC) prec = LOWDEFAULTPREC;
    2324         [ -  + ]:        112 :   if (isintzero(v)) return cxcompotor(u, prec);
    2325                 :        112 :   av = avma; Q = gel(x,1);
    2326                 :        112 :   z = itor(quad_disc(x), prec);
    2327         [ +  - ]:        112 :   if (signe(gel(Q,2)) < 0) /* Q[2] = -D/4 or (1-D)/4 */
    2328                 :            :   {
    2329                 :        112 :     z = subri(sqrtr(z), gel(Q,3));
    2330                 :        112 :     shiftr_inplace(z, -1);
    2331                 :            :   }
    2332                 :            :   else
    2333                 :            :   {
    2334                 :          0 :     z = sqrtr_abs(z); shiftr_inplace(z, -1);
    2335                 :          0 :     z = mkcomplex(gmul2n(negi(gel(Q,3)),-1), z);
    2336                 :            :   }/* z = (-b + sqrt(D)) / 2 */
    2337                 :        112 :   return gerepileupto(av, gadd(u, gmul(v,z)));
    2338                 :            : }
    2339                 :            : 
    2340                 :            : static GEN
    2341                 :         14 : qtop(GEN x, GEN p, long d)
    2342                 :            : {
    2343                 :         14 :   GEN z, D, P, b, u = gel(x,2), v = gel(x,3);
    2344                 :            :   pari_sp av;
    2345         [ -  + ]:         14 :   if (gequal0(v)) return cvtop(u, p, d);
    2346                 :         14 :   P = gel(x,1);
    2347                 :         14 :   b = gel(P,3);
    2348                 :         14 :   av = avma; D = quad_disc(x);
    2349         [ -  + ]:         14 :   if (equaliu(p,2)) d += 2;
    2350                 :         14 :   z = Qp_sqrt(cvtop(D,p,d));
    2351         [ +  - ]:         14 :   if (!z) pari_err_SQRTN("Qp_sqrt",D);
    2352                 :          0 :   z = gmul2n(gsub(z, b), -1);
    2353                 :            : 
    2354                 :          0 :   z = gadd(u, gmul(v, z));
    2355         [ #  # ]:          0 :   if (typ(z) != t_PADIC) /* t_INTMOD for t_QUAD of t_INTMODs... */
    2356                 :          0 :     z = cvtop(z, p, d);
    2357                 :          0 :   return gerepileupto(av, z);
    2358                 :            : }
    2359                 :            : static GEN
    2360                 :         14 : ctop(GEN x, GEN p, long d)
    2361                 :            : {
    2362                 :         14 :   pari_sp av = avma;
    2363                 :         14 :   GEN z, u = gel(x,1), v = gel(x,2);
    2364         [ -  + ]:         14 :   if (isrationalzero(v)) return cvtop(u, p, d);
    2365                 :         14 :   z = Qp_sqrt(cvtop(gen_m1, p, d - gvaluation(v, p))); /* = I */
    2366                 :            : 
    2367                 :         14 :   z = gadd(u, gmul(v, z));
    2368         [ -  + ]:         14 :   if (typ(z) != t_PADIC) /* t_INTMOD for t_COMPLEX of t_INTMODs... */
    2369                 :          0 :     z = cvtop(z, p, d);
    2370                 :         14 :   return gerepileupto(av, z);
    2371                 :            : }
    2372                 :            : 
    2373                 :            : /* cvtop2(stoi(s), y) */
    2374                 :            : GEN
    2375                 :          0 : cvstop2(long s, GEN y)
    2376                 :            : {
    2377                 :          0 :   GEN z, p = gel(y,2);
    2378         [ #  # ]:          0 :   long v, d = signe(gel(y,4))? precp(y): 0;
    2379         [ #  # ]:          0 :   if (!s) return zeropadic(p, d);
    2380                 :          0 :   v = z_pvalrem(s, p, &s);
    2381         [ #  # ]:          0 :   if (d <= 0) return zeropadic(p, v);
    2382                 :          0 :   z = cgetg(5, t_PADIC);
    2383                 :          0 :   z[1] = evalprecp(d) | evalvalp(v);
    2384                 :          0 :   gel(z,2) = p;
    2385                 :          0 :   gel(z,3) = gel(y,3);
    2386                 :          0 :   gel(z,4) = modsi(s, gel(y,3)); return z;
    2387                 :            : }
    2388                 :            : 
    2389                 :            : /* cvtop(x, gel(y,2), precp(y)), internal, not memory-clean */
    2390                 :            : GEN
    2391                 :     195365 : cvtop2(GEN x, GEN y)
    2392                 :            : {
    2393                 :     195365 :   GEN z, p = gel(y,2);
    2394         [ +  + ]:     195365 :   long v, d = signe(gel(y,4))? precp(y): 0;
    2395   [ +  -  +  +  :     195365 :   switch(typ(x))
                   +  - ]
    2396                 :            :   {
    2397                 :            :     case t_INT:
    2398         [ -  + ]:     182744 :       if (!signe(x)) return zeropadic(p, d);
    2399                 :     182744 :       v = Z_pvalrem(x, p, &x);
    2400         [ +  + ]:     182738 :       if (d <= 0) return zeropadic(p, v);
    2401                 :     178804 :       z = cgetg(5, t_PADIC);
    2402                 :     178805 :       z[1] = evalprecp(d) | evalvalp(v);
    2403                 :     178805 :       gel(z,2) = p;
    2404                 :     178805 :       gel(z,3) = gel(y,3);
    2405                 :     178805 :       gel(z,4) = modii(x, gel(y,3)); return z;
    2406                 :            : 
    2407                 :            :     case t_INTMOD:
    2408         [ #  # ]:          0 :       v = Z_pval(gel(x,1),p); if (v > d) v = d;
    2409                 :          0 :       return cvtop(gel(x,2), p, v);
    2410                 :            : 
    2411                 :      12600 :     case t_FRAC: { GEN num = gel(x,1), den = gel(x,2);
    2412         [ -  + ]:      12600 :       if (!signe(num)) return zeropadic(p, d);
    2413                 :      12600 :       v = Z_pvalrem(num, p, &num);
    2414         [ +  + ]:      12600 :       if (!v) v = -Z_pvalrem(den, p, &den); /* assume (num,den) = 1 */
    2415         [ +  + ]:      12600 :       if (d <= 0) return zeropadic(p, v);
    2416                 :      11319 :       z = cgetg(5, t_PADIC);
    2417                 :      11319 :       z[1] = evalprecp(d) | evalvalp(v);
    2418                 :      11319 :       gel(z,2) = p;
    2419                 :      11319 :       gel(z,3) = gel(y,3);
    2420         [ +  + ]:      11319 :       if (!is_pm1(den)) num = mulii(num, Fp_inv(den, gel(y,3)));
    2421                 :      12600 :       gel(z,4) = modii(num, gel(y,3)); return z;
    2422                 :            :     }
    2423                 :          7 :     case t_COMPLEX: return ctop(x, p, d);
    2424                 :         14 :     case t_QUAD:    return qtop(x, p, d);
    2425                 :            :   }
    2426                 :          0 :   pari_err_TYPE("cvtop2",x);
    2427                 :     195343 :   return NULL; /* not reached */
    2428                 :            : }
    2429                 :            : 
    2430                 :            : /* assume is_const_t(tx) */
    2431                 :            : GEN
    2432                 :      28734 : cvtop(GEN x, GEN p, long d)
    2433                 :            : {
    2434                 :            :   GEN z;
    2435                 :            :   long v;
    2436                 :            : 
    2437         [ -  + ]:      28734 :   if (typ(p) != t_INT) pari_err_TYPE("cvtop",p);
    2438   [ +  -  +  +  :      28734 :   switch(typ(x))
                -  -  - ]
    2439                 :            :   {
    2440                 :            :     case t_INT:
    2441         [ +  + ]:      28706 :       if (!signe(x)) return zeropadic(p, d);
    2442                 :      27530 :       v = Z_pvalrem(x, p, &x);
    2443         [ -  + ]:      27530 :       if (d <= 0) return zeropadic(p, v);
    2444                 :      27530 :       z = cgetg(5, t_PADIC);
    2445                 :      27530 :       z[1] = evalprecp(d) | evalvalp(v);
    2446                 :      27530 :       gel(z,2) = icopy(p);
    2447                 :      27530 :       gel(z,3) = powiu(p, d);
    2448                 :      27530 :       gel(z,4) = modii(x, gel(z,3)); return z; /* not memory-clean */
    2449                 :            : 
    2450                 :            :     case t_INTMOD:
    2451         [ #  # ]:          0 :       v = Z_pval(gel(x,1),p); if (v > d) v = d;
    2452                 :          0 :       return cvtop(gel(x,2), p, v);
    2453                 :            : 
    2454                 :         21 :     case t_FRAC: { GEN num = gel(x,1), den = gel(x,2);
    2455         [ -  + ]:         21 :       if (!signe(num)) return zeropadic(p, d);
    2456                 :         21 :       v = Z_pvalrem(num, p, &num);
    2457         [ +  + ]:         21 :       if (!v) v = -Z_pvalrem(den, p, &den); /* assume (num,den) = 1 */
    2458         [ -  + ]:         21 :       if (d <= 0) return zeropadic(p, v);
    2459                 :         21 :       z = cgetg(5, t_PADIC);
    2460                 :         21 :       z[1] = evalprecp(d) | evalvalp(v);
    2461                 :         21 :       gel(z,2) = icopy(p);
    2462                 :         21 :       gel(z,3) = powiu(p, d);
    2463         [ +  + ]:         21 :       if (!is_pm1(den)) num = mulii(num, Fp_inv(den, gel(z,3)));
    2464                 :         21 :       gel(z,4) = modii(num, gel(z,3)); return z; /* not memory-clean */
    2465                 :            :     }
    2466                 :          7 :     case t_COMPLEX: return ctop(x, p, d);
    2467                 :          0 :     case t_PADIC: return gprec(x,d);
    2468                 :          0 :     case t_QUAD: return qtop(x, p, d);
    2469                 :            :   }
    2470                 :          0 :   pari_err_TYPE("cvtop",x);
    2471                 :      28734 :   return NULL; /* not reached */
    2472                 :            : }
    2473                 :            : 
    2474                 :            : GEN
    2475                 :         21 : gcvtop(GEN x, GEN p, long r)
    2476                 :            : {
    2477                 :            :   long i, lx;
    2478                 :            :   GEN y;
    2479                 :            : 
    2480      [ +  -  + ]:         21 :   switch(typ(x))
    2481                 :            :   {
    2482                 :            :     case t_POL: case t_SER:
    2483                 :          7 :       y = cgetg_copy(x, &lx); y[1] = x[1];
    2484         [ +  + ]:         21 :       for (i=2; i<lx; i++) gel(y,i) = gcvtop(gel(x,i),p,r);
    2485                 :          7 :       return y;
    2486                 :            :     case t_POLMOD: case t_RFRAC:
    2487                 :            :     case t_VEC: case t_COL: case t_MAT:
    2488                 :          0 :       y = cgetg_copy(x, &lx);
    2489         [ #  # ]:          0 :       for (i=1; i<lx; i++) gel(y,i) = gcvtop(gel(x,i),p,r);
    2490                 :          0 :       return y;
    2491                 :            :   }
    2492                 :         21 :   return cvtop(x,p,r);
    2493                 :            : }
    2494                 :            : 
    2495                 :            : long
    2496                 :   65402934 : gexpo(GEN x)
    2497                 :            : {
    2498                 :   65402934 :   long tx = typ(x), lx, e, f, i;
    2499                 :            : 
    2500   [ +  +  +  +  :   65402934 :   switch(tx)
             +  +  +  - ]
    2501                 :            :   {
    2502                 :            :     case t_INT:
    2503                 :   17601171 :       return expi(x);
    2504                 :            : 
    2505                 :            :     case t_FRAC:
    2506                 :     279161 :       return expi(gel(x,1)) - expi(gel(x,2));
    2507                 :            : 
    2508                 :            :     case t_REAL:
    2509                 :   32742922 :       return expo(x);
    2510                 :            : 
    2511                 :            :     case t_COMPLEX:
    2512                 :    8051159 :       e = gexpo(gel(x,1));
    2513                 :    8051159 :       f = gexpo(gel(x,2)); return maxss(e, f);
    2514                 :            : 
    2515                 :            :     case t_QUAD: {
    2516                 :         21 :       GEN p = gel(x,1); /* mod = X^2 + {0,1}* X - {D/4, (1-D)/4})*/
    2517                 :         21 :       long d = 1 + expi(gel(p,2))/2; /* ~ expo(sqrt(D)) */
    2518                 :         21 :       e = gexpo(gel(x,2));
    2519                 :         21 :       f = gexpo(gel(x,3)) + d; return maxss(e, f);
    2520                 :            :     }
    2521                 :            :     case t_POL: case t_SER:
    2522                 :    6566162 :       lx = lg(x); f = -(long)HIGHEXPOBIT;
    2523 [ +  + ][ +  + ]:   35663560 :       for (i=2; i<lx; i++) { e=gexpo(gel(x,i)); if (e>f) f=e; }
    2524                 :    6566162 :       return f;
    2525                 :            :     case t_VEC: case t_COL: case t_MAT:
    2526                 :     162338 :       lx = lg(x); f = -(long)HIGHEXPOBIT;
    2527 [ +  + ][ +  + ]:    1376245 :       for (i=1; i<lx; i++) { e=gexpo(gel(x,i)); if (e>f) f=e; }
    2528                 :     162338 :       return f;
    2529                 :            :   }
    2530                 :          0 :   pari_err_TYPE("gexpo",x);
    2531                 :   65402934 :   return 0; /* not reached */
    2532                 :            : }
    2533                 :            : 
    2534                 :            : long
    2535                 :          7 : sizedigit(GEN x)
    2536                 :            : {
    2537         [ +  - ]:          7 :   return gequal0(x)? 0: (long) ((gexpo(x)+1) * LOG10_2) + 1;
    2538                 :            : }
    2539                 :            : 
    2540                 :            : /* normalize series. avma is not updated */
    2541                 :            : GEN
    2542                 :    5544672 : normalize(GEN x)
    2543                 :            : {
    2544                 :    5544672 :   long i, lx = lg(x), vx=varn(x), vp=valp(x);
    2545                 :            :   GEN y, z;
    2546                 :            : 
    2547         [ -  + ]:    5544672 :   if (typ(x) != t_SER) pari_err_TYPE("normalize",x);
    2548         [ +  + ]:    5544672 :   if (lx == 2) { setsigne(x,0); return x; }
    2549         [ +  + ]:    5544525 :   if (lx == 3) {
    2550                 :      89905 :     z = gel(x,2);
    2551         [ +  + ]:      89905 :     if (!gequal0(z)) { setsigne(x,1); return x; }
    2552         [ +  + ]:       3989 :     if (isrationalzero(z)) return zeroser(vx,vp+1);
    2553         [ +  + ]:       1350 :     if (isexactzero(z)) {
    2554                 :            :       /* dangerous case: already normalized ? */
    2555         [ -  + ]:         14 :       if (!signe(x)) return x;
    2556                 :         14 :       setvalp(x,vp+1); /* no: normalize */
    2557                 :            :     }
    2558                 :       1350 :     setsigne(x,0); return x;
    2559                 :            :   }
    2560         [ +  + ]:    5490096 :   for (i=2; i<lx; i++)
    2561         [ +  + ]:    5488430 :     if (! isrationalzero(gel(x,i))) break;
    2562         [ +  + ]:    5454620 :   if (i == lx) return zeroser(vx,lx-2+vp);
    2563                 :    5452954 :   z = gel(x,i);
    2564 [ +  + ][ +  + ]:    5453143 :   while (i<lx && isexactzero(gel(x,i))) i++;
    2565         [ +  + ]:    5452954 :   if (i == lx)
    2566                 :            :   {
    2567                 :         28 :     i -= 3; y = x + i;
    2568                 :         28 :     stackdummy((pari_sp)y, (pari_sp)x);
    2569                 :         28 :     gel(y,2) = z;
    2570                 :         28 :     y[1] = evalsigne(0) | evalvalp(lx-2+vp) | evalvarn(vx);
    2571                 :         28 :     y[0] = evaltyp(t_SER) | _evallg(3);
    2572                 :         28 :     return y;
    2573                 :            :   }
    2574                 :            : 
    2575                 :    5452926 :   i -= 2; y = x + i; lx -= i;
    2576                 :    5452926 :   y[1] = evalsigne(1) | evalvalp(vp+i) | evalvarn(vx);
    2577                 :    5452926 :   y[0] = evaltyp(t_SER) | evallg(lx);
    2578                 :            : 
    2579                 :    5452926 :   stackdummy((pari_sp)y, (pari_sp)x);
    2580         [ +  + ]:    5465009 :   for (i = 2; i < lx; i++)
    2581         [ +  + ]:    5464486 :     if (!gequal0(gel(y, i))) return y;
    2582                 :    5544672 :   setsigne(y, 0); return y;
    2583                 :            : }
    2584                 :            : 
    2585                 :            : GEN
    2586                 :       3501 : normalizepol_approx(GEN x, long lx)
    2587                 :            : {
    2588                 :            :   long i;
    2589         [ +  + ]:      17698 :   for (i = lx-1; i>1; i--)
    2590         [ +  + ]:      17697 :     if (! gequal0(gel(x,i))) break;
    2591                 :       3501 :   stackdummy((pari_sp)(x + lg(x)), (pari_sp)(x + i+1));
    2592         [ +  + ]:       3501 :   setlg(x, i+1); setsigne(x, i!=1); return x;
    2593                 :            : }
    2594                 :            : 
    2595                 :            : GEN
    2596                 :  169061120 : normalizepol_lg(GEN x, long lx)
    2597                 :            : {
    2598                 :  169061120 :   long i, LX = 0;
    2599                 :  169061120 :   GEN KEEP = NULL;
    2600                 :            : 
    2601         [ +  + ]:  215461156 :   for (i = lx-1; i>1; i--)
    2602                 :            :   {
    2603                 :  197076901 :     GEN z = gel(x,i);
    2604         [ +  + ]:  197076901 :     if (! gequal0(z) ) {
    2605         [ +  + ]:  150676494 :       if (!LX) LX = i+1;
    2606                 :  150676494 :       stackdummy((pari_sp)(x + lg(x)), (pari_sp)(x + LX));
    2607                 :  150675835 :       x[0] = evaltyp(t_POL) | evallg(LX);
    2608                 :  150675348 :       setsigne(x,1); return x;
    2609         [ +  + ]:   46400036 :     } else if (!isexactzero(z)) {
    2610         [ +  + ]:     141743 :       if (!LX) LX = i+1; /* to be kept as leading coeff */
    2611         [ +  + ]:   46258293 :     } else if (!isrationalzero(z))
    2612                 :     688291 :       KEEP = z; /* to be kept iff all other coeffs are exact 0s */
    2613                 :            :   }
    2614         [ +  + ]:   18384255 :   if (!LX) {
    2615         [ +  + ]:   18366289 :     if (KEEP) { /* e.g. Pol(Mod(0,2)) */
    2616                 :     329479 :       gel(x,2) = KEEP;
    2617                 :     329479 :       LX = 3;
    2618                 :            :     } else
    2619                 :   18036810 :       LX = 2; /* Pol(0) */
    2620                 :            :   }
    2621                 :   18384255 :   stackdummy((pari_sp)(x + lg(x)), (pari_sp)(x + LX));
    2622                 :   18384255 :   x[0] = evaltyp(t_POL) | evallg(LX);
    2623                 :  169059603 :   setsigne(x,0); return x;
    2624                 :            : }
    2625                 :            : 
    2626                 :            : /* normalize polynomial x in place */
    2627                 :            : GEN
    2628                 :      99009 : normalizepol(GEN x)
    2629                 :            : {
    2630                 :      99009 :   return normalizepol_lg(x, lg(x));
    2631                 :            : }
    2632                 :            : 
    2633                 :            : int
    2634                 :    2747267 : gsigne(GEN x)
    2635                 :            : {
    2636   [ +  +  +  +  :    2747267 :   switch(typ(x))
                      - ]
    2637                 :            :   {
    2638                 :    2713717 :     case t_INT: case t_REAL: return signe(x);
    2639                 :      31212 :     case t_FRAC: return signe(gel(x,1));
    2640                 :            :     case t_QUAD:
    2641                 :            :     {
    2642                 :        112 :       pari_sp av = avma;
    2643                 :        112 :       GEN T = gel(x,1), a = gel(x,2), b = gel(x,3);
    2644                 :            :       long sa, sb;
    2645         [ +  + ]:        112 :       if (signe(gel(T,2)) > 0) break;
    2646                 :         98 :       a = gmul2n(a,1);
    2647         [ +  + ]:         98 :       if (signe(gel(T,3))) a = gadd(a,b);
    2648                 :            :       /* a + b sqrt(D) > 0 ? */
    2649                 :         98 :       sa = gsigne(a);
    2650         [ +  + ]:         98 :       sb = gsigne(b); if (sa == sb) { avma = av; return sa; }
    2651         [ +  + ]:         77 :       if (sa == 0) { avma = av; return sb; }
    2652         [ -  + ]:         70 :       if (sb == 0) { avma = av; return sa; }
    2653                 :            :       /* different signs, take conjugate expression */
    2654                 :         70 :       sb = gsigne(gsub(gsqr(a), gmul(quad_disc(x), gsqr(b))));
    2655                 :         70 :       avma = av; return sb * sa;
    2656                 :            :     }
    2657                 :       2226 :     case t_INFINITY: return inf_get_sign(x);
    2658                 :            :   }
    2659                 :         14 :   pari_err_TYPE("gsigne",x);
    2660                 :    2747253 :   return 0; /* not reached */
    2661                 :            : }
    2662                 :            : 
    2663                 :            : /*******************************************************************/
    2664                 :            : /*                                                                 */
    2665                 :            : /*                              LISTS                              */
    2666                 :            : /*                                                                 */
    2667                 :            : /*******************************************************************/
    2668                 :            : /* make sure L can hold l elements, at least doubling the previous max number
    2669                 :            :  * of components. */
    2670                 :            : static void
    2671                 :     785799 : ensure_nb(GEN L, long l)
    2672                 :            : {
    2673                 :     785799 :   long nmax = list_nmax(L), i, lw;
    2674                 :            :   GEN v, w;
    2675         [ +  + ]:     786114 :   if (l <= nmax) return;
    2676         [ +  + ]:        315 :   if (nmax)
    2677                 :            :   {
    2678                 :        273 :     nmax <<= 1;
    2679         [ -  + ]:        273 :     if (l > nmax) nmax = l;
    2680                 :        273 :     w = list_data(L); lw = lg(w);
    2681                 :        273 :     v = newblock(nmax+1);
    2682                 :        273 :     v[0] = w[0];
    2683         [ +  + ]:    1045653 :     for (i=1; i < lw; i++) gel(v,i) = gel(w, i);
    2684                 :        273 :     killblock(w);
    2685                 :            :   }
    2686                 :            :   else /* unallocated */
    2687                 :            :   {
    2688                 :         42 :     nmax = 32;
    2689         [ -  + ]:         42 :     if (list_data(L))
    2690                 :          0 :       pari_err(e_MISC, "store list in variable before appending elements");
    2691                 :         42 :     v = newblock(nmax+1);
    2692                 :         42 :     v[0] = evaltyp(t_VEC) | _evallg(1);
    2693                 :            :   }
    2694                 :        315 :   list_data(L) = v;
    2695                 :        315 :   L[1] = evaltyp(list_typ(L))|evallg(nmax);
    2696                 :            : }
    2697                 :            : 
    2698                 :            : void
    2699                 :          7 : listkill(GEN L)
    2700                 :            : {
    2701                 :            : 
    2702         [ -  + ]:          7 :   if (typ(L) != t_LIST) pari_err_TYPE("listkill",L);
    2703         [ +  - ]:          7 :   if (list_nmax(L)) {
    2704                 :          7 :     GEN v = list_data(L);
    2705                 :          7 :     long i, l = lg(v);
    2706         [ +  + ]:         49 :     for (i=1; i<l; i++) gunclone_deep(gel(v,i));
    2707                 :          7 :     killblock(v);
    2708                 :          7 :     L[1] = evaltyp(list_typ(L));
    2709                 :          7 :     list_data(L) = NULL;
    2710                 :            :   }
    2711                 :          7 : }
    2712                 :            : 
    2713                 :            : GEN
    2714                 :        722 : listcreate_typ(long t)
    2715                 :            : {
    2716                 :        722 :   GEN L = cgetg(3,t_LIST);
    2717                 :        722 :   L[1] = evaltyp(t);
    2718                 :        722 :   list_data(L) = NULL; return L;
    2719                 :            : }
    2720                 :            : 
    2721                 :            : GEN
    2722                 :        687 : listcreate(void)
    2723                 :            : {
    2724                 :        687 :   return listcreate_typ(t_LIST_RAW);
    2725                 :            : }
    2726                 :            : 
    2727                 :            : GEN
    2728                 :     750827 : listput(GEN L, GEN x, long index)
    2729                 :            : {
    2730                 :            :   long l;
    2731                 :            :   GEN z;
    2732                 :            : 
    2733         [ +  + ]:     750827 :   if (index < 0) pari_err_COMPONENT("listput", "<", gen_0, stoi(index));
    2734                 :     750820 :   z = list_data(L);
    2735         [ +  + ]:     750820 :   l = z? lg(z): 1;
    2736                 :            : 
    2737                 :     750820 :   x = gclone(x);
    2738 [ +  + ][ -  + ]:     750820 :   if (!index || index >= l)
    2739                 :            :   {
    2740                 :     750799 :     ensure_nb(L, l);
    2741                 :     750799 :     z = list_data(L); /* it may change ! */
    2742                 :     750799 :     index = l;
    2743                 :     750799 :     l++;
    2744                 :            :   } else
    2745                 :         21 :     gunclone_deep( gel(z, index) );
    2746                 :     750820 :   gel(z,index) = x;
    2747                 :     750820 :   z[0] = evaltyp(t_VEC) | evallg(l); /*must be after gel(z,index) is set*/
    2748                 :     750820 :   return gel(z,index);
    2749                 :            : }
    2750                 :            : 
    2751                 :            : GEN
    2752                 :     700049 : listput0(GEN L, GEN x, long index)
    2753                 :            : {
    2754 [ +  - ][ -  + ]:     700049 :   if (typ(L) != t_LIST || list_typ(L) != t_LIST_RAW)
    2755                 :          0 :     pari_err_TYPE("listput",L);
    2756                 :     700049 :   return listput(L, x, index);
    2757                 :            : }
    2758                 :            : 
    2759                 :            : GEN
    2760                 :      35014 : listinsert(GEN L, GEN x, long index)
    2761                 :            : {
    2762                 :            :   long l, i;
    2763                 :            :   GEN z;
    2764                 :            : 
    2765 [ +  - ][ -  + ]:      35014 :   if (typ(L) != t_LIST || list_typ(L) != t_LIST_RAW)
    2766                 :          0 :     pari_err_TYPE("listinsert",L);
    2767         [ +  + ]:      35014 :   z = list_data(L); l = z? lg(z): 1;
    2768         [ +  + ]:      35014 :   if (index <= 0) pari_err_COMPONENT("listinsert", "<=", gen_0, stoi(index));
    2769         [ +  + ]:      35007 :   if (index > l) pari_err_COMPONENT("listinsert", ">", stoi(l), stoi(index));
    2770                 :      35000 :   ensure_nb(L, l);
    2771         [ +  - ]:      35000 :   BLOCK_SIGINT_START
    2772                 :      35000 :   z = list_data(L);
    2773 [ +  + ][ +  + ]:   87552500 :   for (i=l; i > index; i--) gel(z,i) = gel(z,i-1);
    2774                 :      35000 :   z[0] = evaltyp(t_VEC) | evallg(l+1);
    2775                 :      35000 :   gel(z,index) = gclone(x);
    2776 [ +  - ][ -  + ]:      35000 :   BLOCK_SIGINT_END
         [ +  - ][ -  + ]
    2777                 :      35000 :   return gel(z,index);
    2778                 :            : }
    2779                 :            : 
    2780                 :            : void
    2781                 :      21910 : listpop(GEN L, long index)
    2782                 :            : {
    2783                 :            :   long l, i;
    2784                 :            :   GEN z;
    2785                 :            : 
    2786         [ -  + ]:      21910 :   if (typ(L) != t_LIST) pari_err_TYPE("listinsert",L);
    2787         [ -  + ]:      21910 :   if (index < 0) pari_err_COMPONENT("listpop", "<", gen_0, stoi(index));
    2788                 :      21910 :   z = list_data(L);
    2789 [ +  + ][ +  + ]:      43806 :   if (!z || (l = lg(z)-1) == 0) return;
    2790                 :            : 
    2791 [ +  + ][ -  + ]:      21896 :   if (!index || index > l) index = l;
    2792         [ +  - ]:      21896 :   BLOCK_SIGINT_START
    2793                 :      21896 :   gunclone_deep( gel(z, index) );
    2794                 :      21896 :   z[0] = evaltyp(t_VEC) | evallg(l);
    2795         [ +  + ]:      21903 :   for (i=index; i < l; i++) z[i] = z[i+1];
    2796 [ +  - ][ -  + ]:      21896 :   BLOCK_SIGINT_END
         [ +  - ][ -  + ]
    2797                 :            : }
    2798                 :            : 
    2799                 :            : void
    2800                 :         35 : listpop0(GEN L, long index)
    2801                 :            : {
    2802 [ +  - ][ -  + ]:         35 :   if (typ(L) != t_LIST || list_typ(L) != t_LIST_RAW)
    2803                 :          0 :     pari_err_TYPE("listpop",L);
    2804                 :         35 :   listpop(L, index);
    2805                 :         35 : }
    2806                 :            : 
    2807                 :            : /* return a list with single element x, allocated on stack */
    2808                 :            : GEN
    2809                 :         49 : mklistcopy(GEN x)
    2810                 :            : {
    2811                 :         49 :   GEN y = listcreate();
    2812                 :         49 :   list_data(y) = mkveccopy(x);
    2813                 :         49 :   return y;
    2814                 :            : }
    2815                 :            : 
    2816                 :            : /* return a copy fully allocated on stack. gclone from changevalue is
    2817                 :            :  * supposed to malloc() it */
    2818                 :            : GEN
    2819                 :        410 : gtolist(GEN x)
    2820                 :            : {
    2821                 :            :   GEN y;
    2822                 :            : 
    2823         [ +  + ]:        410 :   if (!x) return listcreate();
    2824      [ +  -  + ]:        287 :   switch(typ(x))
    2825                 :            :   {
    2826                 :            :     case t_VEC: case t_COL:
    2827                 :        238 :       y = listcreate();
    2828         [ +  + ]:        238 :       if (lg(x) == 1) return y;
    2829                 :        224 :       list_data(y) = gcopy(x);
    2830                 :        224 :       settyp(list_data(y), t_VEC);
    2831                 :        224 :       return y;
    2832                 :            :     case t_LIST:
    2833                 :          0 :       y = listcreate();
    2834         [ #  # ]:          0 :       list_data(y) = list_data(x)? gcopy(list_data(x)): NULL;
    2835                 :          0 :       return y;
    2836                 :            :     default:
    2837                 :        410 :       return mklistcopy(x);
    2838                 :            :   }
    2839                 :            : }
    2840                 :            : 
    2841                 :            : void
    2842                 :         21 : listsort(GEN L, long flag)
    2843                 :            : {
    2844                 :            :   long i, l;
    2845                 :         21 :   pari_sp av = avma;
    2846                 :            :   GEN perm, v, vnew;
    2847                 :            : 
    2848         [ -  + ]:         21 :   if (typ(L) != t_LIST) pari_err_TYPE("listsort",L);
    2849         [ +  - ]:         21 :   v = list_data(L); l = v? lg(v): 1;
    2850         [ -  + ]:         42 :   if (l < 3) return;
    2851         [ +  + ]:         21 :   if (flag)
    2852                 :            :   {
    2853                 :            :     long lnew;
    2854                 :         14 :     perm = gen_indexsort_uniq(L, (void*)&cmp_universal, cmp_nodata);
    2855                 :         14 :     lnew = lg(perm); /* may have changed since 'uniq' */
    2856                 :         14 :     vnew = cgetg(lnew,t_VEC);
    2857         [ +  + ]:         56 :     for (i=1; i<lnew; i++) {
    2858                 :         42 :       long c = perm[i];
    2859                 :         42 :       gel(vnew,i) = gel(v,c);
    2860                 :         42 :       gel(v,c) = NULL;
    2861                 :            :     }
    2862         [ +  - ]:         14 :     if (l != lnew) { /* was shortened */
    2863         [ +  + ]:        105 :       for (i=1; i<l; i++)
    2864         [ +  + ]:         91 :         if (gel(v,i)) gunclone_deep(gel(v,i));
    2865                 :         14 :       l = lnew;
    2866                 :            :     }
    2867                 :            :   }
    2868                 :            :   else
    2869                 :            :   {
    2870                 :          7 :     perm = gen_indexsort(L, (void*)&cmp_universal, cmp_nodata);
    2871                 :          7 :     vnew = cgetg(l,t_VEC);
    2872         [ +  + ]:         63 :     for (i=1; i<l; i++) gel(vnew,i) = gel(v,perm[i]);
    2873                 :            :   }
    2874         [ +  + ]:        119 :   for (i=1; i<l; i++) gel(v,i) = gel(vnew,i);
    2875                 :         21 :   v[0] = vnew[0]; avma = av;
    2876                 :            : }

Generated by: LCOV version 1.9